Merge branch 'refs/heads/version/7.0.x'

# Conflicts: # buildSrc/src/main/kotlin/GradleExtras.kt # buildSrc/src/main/kotlin/LibsConfig.kt # buildSrc/src/main/kotlin/PlatformConfig.kt # gradle.properties # worldguard-libs/bukkit/build.gradle.kts
Ignore arrow combustion.
2024-09-16 20:08:34 +02:00 · 2024-09-13 14:29:18 -04:00 · 2024-09-13 14:15:32 -04:00 · 2024-09-13 11:58:55 -04:00 · 2024-09-13 11:58:22 -04:00 · 2024-09-13 11:46:06 -04:00
451 changed files with 32073 additions and 20013 deletions
@@ -1,2 +1,34 @@
-*.java   diff=java
-
+* text=auto eol=lf
+# Force Batch files to CRLF
+*.bat eol=crlf -text
+
+# Java sources
+*.java          text diff=java
+*.kt            text diff=java
+*.gradle        text diff=java
+*.gradle.kts    text diff=java
+
+# These files are text and should be normalized (Convert crlf => lf)
+*.css           text diff=css
+*.df            text
+*.htm           text diff=html
+*.html          text diff=html
+*.js            text
+*.jsp           text
+*.jspf          text
+*.jspx          text
+*.properties    text
+*.tld           text
+*.tag           text
+*.tagx          text
+*.xml           text
+
+# These files are binary and should be left untouched
+# (binary is a macro for -text -diff)
+*.class         binary
+*.dll           binary
+*.ear           binary
+*.jar           binary
+*.so            binary
+*.war           binary
+*.jks           binary
@@ -0,0 +1 @@
+github: enginehub
@@ -0,0 +1,93 @@
+name: Bug report
+description: Report a way in which WorldGuard is not working as intended
+labels: ['type:bug', 'status:pending']
+
+body:
+- type: markdown
+  attributes:
+    value: |
+      Please note that this is only for bugs, help with installation or other types of support should
+      be taken to the Discord Guild instead.
+  
+- type: input
+  attributes:
+    label: WorldEdit Version
+    description: The full version of WorldEdit, can be found by using `/we version`.
+    placeholder: e.g. 7.2.3 or 7.3.0-SNAPSHOT
+  validations:
+    required: true
+
+- type: input
+  attributes:
+    label: WorldGuard Version
+    description: The full version of WorldGuard, can be found by using `/wg version`.
+    placeholder: e.g. 7.0.5 or 7.0.6-SNAPSHOT
+  validations:
+    required: true
+
+- type: input
+  attributes:
+    label: Platform Version
+    description: |
+      The version of the platform you are on, i.e. Spigot or Paper.
+      Please ensure you are running up-to-date software before making a bug report.
+      Old versions, paper forks or hybrids will receive little to no support.
+    placeholder: e.g. git-Spigot-21fe707-e1ebe52, git-Paper-463
+  validations:
+    required: true
+
+- type: checkboxes
+  id: confirmations
+  attributes:
+    label: Confirmations
+    description: Please confirm the following before submitting the bug. Your report will be closed if you are running hybrids or old software.
+    options:
+      - label: I am using the most recent Minecraft release.
+        required: true
+      - label: I am using a version of WorldEdit compatible with my Minecraft version.
+        required: true
+      - label: I am using a version of WorldGuard compatible with my Minecraft version.
+        required: true
+      - label: I am using the latest or recommended version of my platform software.
+        required: true
+      - label: I am NOT using a hybrid server, e.g. a server that combines Bukkit and Forge. Examples include Arclight, Mohist, and Cardboard.
+        required: true
+      - label: I am NOT using a fork of WorldEdit, such as FastAsyncWorldEdit (FAWE) or AsyncWorldEdit (AWE)
+        required: true
+
+- type: textarea
+  attributes:
+    label: Bug Description
+    description: A clear and concise description of what the bug is.
+  validations:
+    required: true
+
+- type: textarea
+  attributes:
+    label: Expected Behavior
+    description: The behavior that you expected, instead of the bugged behavior that occurs.
+  validations:
+    required: true
+
+- type: textarea
+  attributes:
+    label: Reproduction Steps
+    description: Steps to reproduce the behavior.
+    value: |
+      1. ...
+      2. ...
+  validations:
+    required: true
+
+
+- type: input
+  attributes:
+    label: Optional WorldGuard-Report
+    description: Link to WorldGuard Region report for bugs with regions, received with `/wg report -p`
+  validations:
+    required: false
+
+- type: textarea
+  attributes:
+    label: Anything Else?
+    description: Add any additional context you can provide below.
@@ -0,0 +1,5 @@
+blank_issues_enabled: false
+contact_links:
+  - name: EngineHub Discord
+    url: https://discord.gg/EngineHub
+    about: Please ask and answer questions here.
@@ -0,0 +1,35 @@
+name: Feature request
+description: Suggest an idea for WorldGuard
+labels: ['type:feature-request', 'status:pending']
+
+body:
+- type: textarea
+  attributes:
+    label: The Problem
+    description: >
+      What is making your WorldGuard experience sub-optimal? This should be something that
+      cannot be easily solved by existing WorldGuard features.
+    placeholder: It's hard to ... ; I'm unable to ...
+  validations:
+    required: true
+
+- type: textarea
+  attributes:
+    label: A Solution
+    description: What is your proposed solution to the above problem?
+  validations:
+    required: true
+
+- type: textarea
+  attributes:
+    label: Alternatives
+    description: |
+      Alternative solutions or workarounds to the problem.
+      You should also describe why these are not preferable to the given solution.
+  validations:
+    required: false
+
+- type: textarea
+  attributes:
+    label: Anything Else?
+    description: Add any additional context you can provide below.
@@ -1,13 +1,19 @@
-/.classpath
-/.project
-/.settings
-/target
+.classpath
+.project
+.settings/
+target/

 .DS_Store
-/*.iml
-/.idea

-/bin
-/dependency-reduced-pom.xml
+**/*.iml
+**/.idea
+
+bin/
+dependency-reduced-pom.xml
 *-private.sh

+.gradle/
+**/build/
+out/
+
+scripts/
@@ -1,7 +0,0 @@
-language: java
-jdk:
-  - oraclejdk7
-  - openjdk7
-  - openjdk6
-notifications:
-  email: false
@@ -1,11 +1,384 @@
 # Changelog

+## 7.0.12
+
+* Fix a change in the default behavior of explosion flag handling.
+
+## 7.0.11
+
+* Add support for MC 1.21.
+* Add wind-charge-burst flag which is checked along with `use` (for the interaction) or `pvp` (for the knockback).
+* Add breeze-charge-explosion flag for breeze charges (i.e. from the mob, not player wind charges).
+* Add moisture-change flag and config options.
+* Fix an error if a player logged in to an unloaded world.
+* Fix chest boat usage always being counted as ride.
+* Consider potions thrown by mobs as mob-damage.
+* Workaround spigot no longer sending block change events when a book is placed on a lectern.
+* Improve accuracy of target blocks in blacklist/build-perms events.
+
+## 7.0.10
+
+* Add support for MC 1.20.5 and 1.20.6, drop support for other 1.20 versions
+
+## 7.0.9
+* Add support for MC 1.20, drop support for MC 1.19
+* Made entities spawned via the `/summon` command get treated as plugin-spawned entities
+* Add sniffer egg trample protection options
+
+## 7.0.8
+* Add support for MC 1.19
+* Add skulk-growth flag and config option
+* Add copper-fade flag
+* Add data packs to report output
+* Add protection for allay inventory slot
+* Categorize allay item pickups under item-pickup flag
+* Categorize dragon egg interaction (teleporting) as building
+* Ignore most NPC-based actions for Player events
+* Optimize handling of tamed animals where the owner was offline (Paper only)
+* Optimize additional InventoryHolder accesses (Paper only)
+* Fix an exception that occurred when plugins created portals with non-player entities
+* Fix possible error when using Paper's entity origin API
+* Update bstats and squirrelid libs
+
+## 7.0.7
+* Add rock-growth flag for budding amethyst and pointed dripstone.
+* Add /rg migrateheights command. See https://worldguard.enginehub.org/en/latest/regions/commands/#migrate-region-heights
+* Add regions.set-parent-on-claim config (set to a region id for /rg claim to automatically assign the parent region).
+* Add `-i search` and `-s` flags to /rg list, -c to /rg teleport.
+* Fix an error in blacklist logging caused by non-player actions (eg on-dispense)
+* Treat unknown causes as known if using paper-entity-origin config option.
+* Improve lightning strike handling from channeling tridents (PaperMC only).
+* Ignore an error caused by lingering player references of offline players.
+* Add red sand to no-physics-sand.
+* Fix potion splash events being cancelled if no entities were affected.
+
+## 7.0.6
+
+* Add support for 1.17 blocks/items, drop support for 1.16.
+* Add use-dripleaf flag for "toggling" big dripleaf blocks.
+* Fix support for fully negative-height regions.
+* Fix crop-growth config option.
+* Be more rigorous with protecting blocks against dispenser behaviors.
+* Fix handling of lingering splash potion effects.
+* Handle other-explosion flag consistently for block-like entities (armor frames etc.)
+* Allow inheriting values for all flags (previously wasn't used for things like teleport.)
+* Region commands that defaulted to the region the player was standing in no longer check parents.
+* Fix child regions being unlinked when redefining a parent region.
+
+## 7.0.5
+
+* Add a use-anvil flag and exclude it from the use flag (since they can break on use.)
+* Add nonplayer-protection-domains flag which allows merging region borders from the perspective of pistons, saplings, etc.
+* Expand crop-related options (crop-growth, etc) to sweet berry bushes, nether wart, and bamboo.
+* Add a config option (`mobs.block-vehicle-entry`) to prevent non-players from entering vehicles.
+* Add a UUID flag (for developers/API usage).
+* Add map query methods with fallback flag (for developers/API usage).
+* Add `on` and `off` optional arguments for `/rg toggle-bypass` command.
+* Add additional timings info for session handlers.
+* Fix sponge-simulation clearing NBT from blocks. Note that if you are using sponge simulation you should switch to something like CraftBook as the feature will be removed from WorldGuard in a future (major) version.
+* Fix the `/rg` command showing up as unknown client-side to players without bypass perms.
+* Fix error propagation from third-party flag loading causing WG to error.
+* Fix a (harmless) exception that occurred when swapping armor slots to the offhand slot.
+* Fix empty lines being sent on enderpearl/chorus-fruit teleport if the deny messages were empty.
+* Fix an issue with falling blocks when using max-priority-association.
+* Fix performance issues with third-party plugins querying protection for offline players.
+* Fix dispensing shulkers over region boundaries.
+* Fix iron door interaction being denied as if it were a regular door.
+* Fix being able to enter/exit regions with the flag denied by using entity mounting functions in other plugins.
+
+## 7.0.4 (including beta1)
+
+* Add support for MC 1.16. Dropped support for previous versions.
+* Add respawn-anchors flag mirroring the sleep flag (e.g. to prevent using respawn anchors to cause explosions in the overworld)
+* Add nether vines to vine-growth flag.
+* Add config option to disable the bypass permission cache.
+* Fix water-flow flags not checking waterlogged blocks.
+* Add config option to consider non-player causes (e.g. pistons, flowing water) to only be members of the highest priority region. This should be enabled for plots-within-city-like setups to prevent things in plots from modifying the city.
+* Fix items dropping from falling blocks that were suppressed by other plugins.
+* Add config option to block turtle egg trampling.
+* Fix ride flag being checked on striders that didn't have saddles.
+* Add config option to have /rg bypass toggled off on login.
+* Developer changes: Methods taking names in Domains are now explicitly deprecated (was previously just a javadoc comment.); These will eventually be removed: there is no reason to use names over UUIDs. Offline players and NPCs alike have stable UUIDs.
+* Also for developers; The new `com.sk89q.worldguard.protection.util.WorldEditRegionConverter` class has some useful static methods to convert to and from WorldEdit's Region and WorldGuard's ProtectedRegion classes.
+
+
+## 7.0.3
+
+* This is the last release supporting MC 1.14 and 1.15.
+* Decouple chest-access flag from interact flag. IMPORTANT: If you relied on allowing players to access chests via setting
+    the interact flag to allow, you will now need to set the chest-access flag to allow instead (or as well). This does not
+    affect any setups where users were *not* supposed to be able to access chests and other inventories.
+* Add natural-health-regen and natural-hunger-drain flags. Unlike the heal/feed flags, these can not restore or deplete health/hunger.
+* Fix the interact flag allowing breaking of turtle eggs (now tied directly to block-trampling flag).
+* Fix a memory leak that could occur with many many explosives.
+* Add regions.titles-always-use-default-times config option. Set this to true if you use greeting/farewell titles and another plugin
+    makes the titles disappear too quickly.
+* Add protection for cauldrons water level changing.
+* Improve diagnostic hints and information, such as spawn protection warnings, flag colors in region info, etc.
+* Fix waterlogged blocks bypassing water-flow flag.
+* Workaround for a CraftBukkit change that made no-physics-sand/gravel non-functional.
+* Workaround for CraftBukkit throttling move events.
+* Track projectiles shot by dispensers.
+* Allowed setting passthrough allow on global to unprotect it if members/owners are added.
+* Add support for newer forge clients (FML2) in host keys.
+* Allow using WorldEdit's `//world <worldname>` command to select a world for region commands. This removes the need to
+    use `-w <worldname>` in every command when running commands from console.
+* Add a teleport-message flag, shown when using `/rg tp`.
+* Add coral-fade flag, which prevents corals from drying when out of water.
+* Fix spammy deny-message when walking over redstone ore with certain flag setups.
+* Improve handling of interacting with various tools in hand that didn't modify blocks. (eg opening a chest with an axe in hand)
+* Fix allow-all-interact option not being read from per-world configs.
+* Fix misattribution of pets (eg wolves) in PvP.
+* Improve performance of hopper checks when on recent builds of Paper.
+* Add event-handling.break-hoppers-on-denied-move config option to prevent hoppers from being broken (but items still won't be moved).
+* Note to developers using the WorldGuard API: If you specifically relied on flags such as greeting/farewell, deny-message, etc being
+    StringFlags, be warned that this will change in a future version to support JSON text components. Please plan accordingly.
+
+
+## 7.0.2
+* Update to MC 1.15. Still compatible with 1.14, and incompatible with 1.13, as before.
+* Add an informational message when defining a region that overlaps vanilla spawn protection.
+* Protect against pushing a piston with another piston on a region border.
+* Protect against buckets in dispensers on region borders.
+
+## 7.0.1
+* Add `/rg toggle-bypass` command which temporarily turns off region bypassing until used again.
+* More improvements to `/rg flag` and `/rg flags` commands.
+* Fix some checks for adding owners to unclaimed regions.
+* Fix an issue with time-/weather-lock flags when logging in to a region with the flag set.
+* Fix cause tracking in vehicles (incl. breaking lilypads in a boat)
+* Use async teleports on Paper.
+* Include hopper minecarts in the ignore hoppers config setting.
+* Add sugar cane and cacti to the crop-growth flag. Bamboo is also included pending Spigot throwing an event for it.
+* Specifically track when players ignite creepers with flint and steel.
+* Fix fuzziness when using bonemeal near a protected region.
+* Fix color codes not applying in greeting, etc flags when placed after a newline (\n).
+* Add applicable region information to `/wg report`.
+* Fix pistons flag not applying to sticky pistons pulling blocks.
+* Add some custom metrics for bStats.
+* Everything in the RC/beta changelog below.
+
+## 7.0.1 RC 2 (inc. beta 1)
+* Due to breaking changes in important Bukkit API, this is not compatible with MC 1.13!
+* Update to MC 1.14. Adds protection for new blocks, etc.
+* To allow players to read from lecterns, but not take the book, flag interact allow, and then flag chest-access -g nonmembers deny.
+* Add ravager-grief flag.
+* Fix overprotection of unsaddled pigs with the ride flag.
+* Fix lava fire defaulting to off (won't change existing configs).
+* Fix damaged/chipped anvils not respecting use flag like regular anvils.
+* Add on-equip blacklist event. Note that it is overprotective due to deficiencies in Bukkit API.
+* Update WorldEdit CUI when using /rg select.
+* Add config option to disable villagers getting zapped into witches. ("weather.disable-villager-witchification")
+* Add entity support to interact-whitelist config option (use the Material of the corresponding item).
+* Fix vehicle-place protecting the rails at the very top of region boundaries incorrectly.
+* Fix for emptying buckets on waterloggable blocks.
+* Whitelist all player -> player interactions (previously was spammy in pvp).
+* Fix sleep flag not protecting against explosions in nether/end.
+* Add config for the teleport-on-void to reset fall distance.
+* Fix config options taking material lists requiring "minecraft:" namespace.
+* Fix disallowed-lightning-blocks situationally not working.
+* Fix errors that occurred when plugins used falling block entities with non-item materials.
+* Add special support for Paper servers (papermc.io): Paper's API allows us to track who launched fireworks.
+* Fireworks are now protected by default. On Paper servers, members can use them by default (to deal damage), 
+on non-Paper servers, flag firework-damage allow to revert to old behavior (everyone can deal damage with fireworks by default).
+* Misc performance enhancements for Paper servers.
+* Add 'regions.use-paper-entity-origin' as an experimental setting (default off) for Paper servers. Enabling it will make non-player entities be treated as members of the place they spawned, instead of their current location when flags are checked.
+
+## 7.0.0
+* Added support for MC 1.13, dropped support for previous versions.
+* Added lots of interactive text in e.g. `/rg info` command.
+* Added `/rg flags` command which allows viewing and interactively setting all flags on a region.
+* Large behind-the-scenes changes to WorldGuard's API (developers, see https://worldguard.enginehub.org/en/latest/developer/)
+* Places that used numeric block ids (e.g. blacklist) should now use Minecraft's new string IDs.
+* Fix various interactions with NPCs and region protection.
+* Sponge-simulation now destroys kelp and seagrass, and de-waterlogs blocks.
+* Added an option to block conduit effects.
+* Fix using newlines in string flags such as greeting and farewell.
+* Add item-frame-rotation flag.
+* Ender chests no longer require chest-access (since they don't have inventories).
+* Add kelp to vine-growth flag/config.
+* Add block-trampling flag (for turtle eggs and farmland).
+* Add snowman-trails flag.
+* Track potion area-of-effect cloud causes for pvp etc. protection.
+* Add confirmation to /stoplag command.
+* Forcefully eject players from vehicles trying to force their way into entry deny regions (and out of exit deny).
+* Fix removing child regions when removing a region with children.
+* Fix some over-protectiveness of pistons.
+* Chat and command flags (send-/receive- and allowed-/blocked-) now respect deny-message flag.
+* Misc fixes.
+
+## 6.2.2
+* Added support for MC 1.12.
+* Changed flower pots to fall under the build flag.
+* Fix heal flag not functioning.
+* Add option to allow Forge clients with host-keys setting.
+* Add mobs.block-armor-stand-destroy config.
+* Add firework-damage flag.
+* Add config option to ignore hopper checks.
+* Misc fixes.
+
+## 6.2
+* Added support for MC 1.11.
+* Add a custom flag and session API (for developers, see https://worldguard.enginehub.org/en/latest/developer/)
+* Add a config option to ensure location flags (teleport, spawn) are inside their region.
+* Misc fixes.
+
+## 6.1.2
+* Added support for new blocks in 1.8, 1.9, and 1.10.
+* Added protection from nether portals being created in protected region (enable via config `nether-portal-protection`).
+* Added protection from slime block piston contraptions pushing into or pulling from regions.
+* Added `chorus-fruit-teleport` flag, works similar to `enderpearl` to prevent teleportation.
+* Added protection from pulling armor stands, items, and entities from protected regions.
+* Changed order of greeting and farewell flags on adjacent regions. When leaving a region with a farewell flag and entering one with a greeting flag, the farewell message will be shown first now.
+* Changed /heal command to also fill food/saturation meters.
+* Changed fall damage prevention to also prevent flying into walls with elytra being fatal.
+* Fixed fire-spread flag only preventing destruction, now prevents spreading too as per its name.
+* Fixed creepers targeting players being able to blow things up in certain cases.
+* Fixed armor stands being removed by /stoplag.
+* Fixed some issues with fireballs being able to explode when ghast-fireball was set to deny.
+* Fixed a lot of other minor issues.
+
+## 6.1
+
+* Added `exit-via-teleport` flag (default allow) to control exiting an exit=deny region via teleportation.
+* Added a `fall-damage` flag to control player damage caused by falling.
+* Added a `time-lock` flag to lock players' time of day. Valid values are from 0 to 24000 for absolute time, or +- any number for relative time.
+* Added a `weather-lock` flag to lock players' weather. Valid values are "clear" or "downfall". Unset to restore to normal world weather.
+* Added `-s` to the event debugging commands to show a stack trace rather than attempt to detect the causing plugin.
+* Added support for using the `-e` argument (sets an empty value for the flag) in the flag set command when the type of flag is of the 'set' type.
+* Added NPCs from the Citizens plugin to a whitelist so they are not protected.
+* Added support for Spigot's BlockExplodeEvent.
+* Changed tripwire to fall under the `use` flag.
+* Changed enderchests to fall under the `use` flag.
+* Changed vehicles and animals so they are not included in the `interact` flag.
+* Changed the display of custom blacklist messages to no longer include a period at the end.
+* Changed protection logic to consider connected chests.
+* Changed the heal and feed flags to increase values for players who are invincible (or in creative mode) but not decrease them.
+* Changed PvP protection to consider both attacker and defender locations.
+* Fixed missing protection data for some 1.8-added blocks.
+* Fixed compatibility issues with MC 1.7.
+* Fixed inverted daylight detectors not being protected.
+* Fixed spawn eggs not being included in protection.
+* Fixed piston blocking not working due to a bug in Spigot.
+* Fixed the blocking of certain invalid entity damage events.
+* Fixed creeper explosions not being blocked in certain situations with explosion related flags set.
+* Fixed "stickiness" with some position-related flags, sometimes resulting in rubber banding in the exit flags.
+* Fixed armor stands so that they are treated more like item frames than mobs.
+* Fixed blocks (e.g. sugar canes) adjacent to physics blocks (e.g. sand) not updating.
+* Fixed a NullPointerException that occurred sometimes when generating the scheduler section of the report function (`/wg report`).
+* Fixed the "no XP drops" configuration not functioning following a previous release.
+* Fixed changes to region ownership sometimes not triggering a region database save.
+* Fixed bucket protection displaying the "deny effect" even if bucket use was not prevented.
+* Fixed CommandFilter matching emoticons and other unwanted characters.
+* Fixed an exception occurring sometimes during game mode changes.
+* Fixed primed TNT being checked twice for TNT flags.
+
+## 6.0 beta 5
+
+MC 1.7.9, 1.7.10 and 1.8 (Spigot only) are supported.
+
+* Added a feature to detect when another plugin (incorrectly) includes WorldGuard's files, causing errors.
+* Added a new `exit-override` flag that can be used on an entry=allow region that players can walk into from an entry=deny region.
+* Added a new `entry-deny-message` to change the "entry denied" message.
+* Added a new `exit-deny-message` to change the "exit denied" message.
+* Changed entry/exit blocking to disembark players from their vehicles.
+* Changed the PvP flag to no longer apply to self-attack.
+* Fixed [#3220](http://youtrack.sk89q.com/issue/WORLDGUARD-3220): Polygon regions sharing points
+* Fixed [#3216](http://youtrack.sk89q.com/issue/WORLDGUARD-3216): Polygon regions 'disappearing' or not working correctly
+* Fixed [#3315](http://youtrack.sk89q.com/issue/WORLDGUARD-3315): Invincibility flag and mode not blocking knockback from snowballs, etc.
+* Fixed [#3314](http://youtrack.sk89q.com/issue/WORLDGUARD-3314): Protection bypassable by getting a skeleton or creeper to target a player
+* Fixed [#3326](http://youtrack.sk89q.com/issue/WORLDGUARD-3326): Enderchests cannot be protected with the use flag
+* Fixed [#3327](http://youtrack.sk89q.com/issue/WORLDGUARD-3327): Fake players from some Forge mods are not being detected properly
+* Fixed [#3328](http://youtrack.sk89q.com/issue/WORLDGUARD-3328): TypeToken error with CraftBukkit 1.7 in `/wg report`
+* Fixed [#3086](http://youtrack.sk89q.com/issue/WORLDGUARD-3086): Region entry / exit messages overlap between seprate worlds
+* Fixed [#2542](http://youtrack.sk89q.com/issue/WORLDGUARD-2542): Exit deny regions don't handle respawn / logout consistently
+* Fixed [#2731](http://youtrack.sk89q.com/issue/WORLDGUARD-2731): Greeting / farewell messages don't understand region inheritance
+* Fixed [#3308](http://youtrack.sk89q.com/issue/WORLDGUARD-3308): Enderchest interaction block not functioning with blacklist.txt
+* Fixed [#3312](http://youtrack.sk89q.com/issue/WORLDGUARD-3312): PVP flag blocking enderpearl teleport fall damage
+* Fixed [#3309](http://youtrack.sk89q.com/issue/WORLDGUARD-3309): Inventory view commands being blocked in protected regions
+* Fixed [#3310](http://youtrack.sk89q.com/issue/WORLDGUARD-3310): USE flag is not allowing workbench usage
+* Fixed [#3330](http://youtrack.sk89q.com/issue/WORLDGUARD-3330): Build permissions preventing block placement
+* API: Added `BukkitUtil.toRegion(Chunk)`
+
+## 6.0 beta 4
+
+MC 1.7.9, 1.7.10 and 1.8 (Spigot only) are supported.
+
+* Added better support for MC 1.8 blocks (regarding the use flag, etc.).
+* Added an an experimental "lite" version of WarmRoast to CPU profile your server (try it: `/wg profile -p`)
+* Added permissions for individual flag values (i.e. `worldguard.region.flag.flags.use.allow`).
+* Added support for slightly older versions of Bukkit 1.7.9.
+* Improved `/wg report`'s output (try it: `/wg report -p`)
+* Fixed armor stands not being protected properly.
+* Fixed lack of wood plate support with the `USE` flag.
+* Fixed left click also being blocked when only right click needed to be blocked.
+* Fixed items and paintings/item frames not decaying under some versions of Spigot.
+* Fixed parent-child inheritance so the child will always inherit the parent.
+* Fixed inheritance issues with a flag is set with a region group on a parent region.
+* Fixed high CPU usage when Citizens is also installed.
+* Fixed `on-acquire` in the blacklist so it also handles item transfers between inventories.
+* Fixed the blacklist not supporting color codes.
+* Changed the PvP flag so it applies to self-attack like in WG 5 (this change *may* be reverted).
+
+## 6.0 beta 3
+
+MC 1.7.10 and 1.8 (Spigot only) are supported.
+
+* Support both MC 1.7.10 and 1.8.
+* Don't apply the region override permission to PvP.
+* Fix incorrect detection of hostile and ambient creatures when protecting against PvE.
+* Fix the splash potion flag not working with the other flags.
+* Fix potion blocking.
+* Fix inability to blacklist the enchantment table and the workbench.
+* Make PASSTHROUGH=DENY useful on ``__global__``.
+* Fix issues (pistons broken, etc.) caused by adding members to ``__global__``.
+* Make the EXP_DROPS flag a build-compat flag and set its deny message.
+* Give the player back his/her XP bottle if it was blocked.
+* Expand the interaction whitelist configuration to "physical" events.
+* Catch command prefixes in the command flags.
+* Add a RIDE flag for vehicles.
+* Check for names in addition to UUIDs with /rg list.
+* Whitelist hoppers and let them cross regions regardless of region protection.
+* Revert USE flag's functionality to 5.x, add new INTERACT flag.
+* Fix spawn egg blocking.
+* Fix failed detection of incorrect blacklist block and item names.
+* Fix command prefix bypass with the op command blocking configuration.
+* Rewrite and update report generation (wg report).
+* Add event cancellation debug commands.
+* Fix location flags causing NullPointerExceptions.
+* Show more details in error log which world the error belongs to.
+* Add missing color codes when parsing input.
+* Let players use NPCs always.
+* Fix [WorldGuard] in log messages stacking on reloads.
+* Better handle empty group / player names due to bad region data.
+* Fix players being invincible with BUILD=deny.
+* Fix certain entities not being damaged in protected regions.
+* Improve entity detection in Entities utility class, add Entities.isNonPlayerCreature().
+* Add missing SQL table prefix in statement selecting world names.
+
+## 6.0 beta 2
+
+* Added an `-e` parameter to `/rg flag` that sets the flag to an empty value. You can use this to, for example, make it so the `deny-message` flag is empty, meaning that players won't get a message at all.
+* Added a visual smoke effect when an action on a block has been denied.
+* Added `event-handling.interaction-whitelist`, a list of items or blocks that should never be protected. For example, adding `wooden_door` to the list would make it so that doors could be used by anyone regardless if they have permission or not. You may still protect the blocks via other means.
+* Added `event-handling.emit-block-use-at-feet`, a list of items that, when used, will also be considered as the player using that item on the block at the player's feet. The purpose of this setting is, for example, to allow you to (sort of) prevent the use of a mod-added item that does not emit events.
+* Added `-s` to silently turn toggle `/stoplag` and `-i` to show the current state of the setting. (Thanks, [stuntguy3000](https://github.com/stuntguy3000)).
+* Added support for Bukkit [Material](http://jd.bukkit.org/rb/apidocs/org/bukkit/Material.html) names in the blacklist.
+* Fixed [#3167](http://youtrack.sk89q.com/issue/WORLDGUARD-3167): Saplings can be used without permission although it won't place blocks inside the region
+* Fixed [#3168](http://youtrack.sk89q.com/issue/WORLDGUARD-3168): Grown saplings that are partially prevented from placing all of its leaves may not remove the sapling
+* Fixed [#3169](http://youtrack.sk89q.com/issue/WORLDGUARD-3169): Bonemeal usage falls under the USE flag when it should really fall under building
+* Fixed [#3174](http://youtrack.sk89q.com/issue/WORLDGUARD-3174): Boat placement is not properly prevented in a protected region
+* Fixed [#3130](http://youtrack.sk89q.com/issue/WORLDGUARD-3130): Polygonal selections allow unlimited claim volumes with /rg claim
+* Fixed [#3137](http://youtrack.sk89q.com/issue/WORLDGUARD-3137): Claiming infinite regions is possible due to integer overflow
+* Fixed [#3171](http://youtrack.sk89q.com/issue/WORLDGUARD-3171): Can't pickup XP in protected regions without permission
+* Fixed [#3170](http://youtrack.sk89q.com/issue/WORLDGUARD-3170): Boats without a driver can be used to break lily pads
+* Fixed [#3172](http://youtrack.sk89q.com/issue/WORLDGUARD-3172): Players cannot be damaged by mobs in protected regions unless they have permission
+* Fixed [#3152](http://youtrack.sk89q.com/issue/WORLDGUARD-3152): BUILD overrides all other flags, unlike in WG 5
+* Fixed [#3154](http://youtrack.sk89q.com/issue/WORLDGUARD-3154): notify-enterflag doesn't work with horses and other vehicles
+* Fixed [#3166](http://youtrack.sk89q.com/issue/WORLDGUARD-3166): Trees do not grow naturally within protected regions
+
 ## 6.0 beta 1

-This is a __MAJOR UPGRADE__ to WorldGuard so we recommend making backups of your worlds and WorldGuard configuration (although periodical backups are recommended regardless).
-
-Please see the upgrade document for a list of breaking changes.
-
 ### UUID support

 Regions now fully support the use of UUIDs rather than names for storing the owners and members of a region. Commands still accept names, but they are translated into UUIDs in the background. For users who already have existing region data, names will be automatically converted to UUIDs on the first run of WorldGuard.
@@ -0,0 +1,39 @@
+Compiling
+=========
+
+You can compile WorldGuard as long as you have some version of Java greater than or equal to 21 installed. 
+Gradle will download JDK 21 specifically if needed, but it needs some version of Java to bootstrap from.
+
+The build process uses Gradle, which you do *not* need to download. WorldGuard is a multi-module project with three modules:
+
+* `worldguard-core` contains the WorldGuard API
+* `worldguard-bukkit` is the Bukkit plugin
+* `worldguard-libs` contains library relocations
+
+## To compile...
+
+### On Windows
+
+1. **Shift** + **right click** the folder with WorldGuard's files and click "Open PowerShell window here".
+2. `gradlew build`
+
+### On Linux, BSD, or Mac OS X
+
+1. In your terminal, navigate to the folder with WorldGuard's files (`cd /folder/of/worldguard/files`)
+2. `./gradlew build`
+
+## Then you will find...
+
+You will find:
+
+* The core WorldGuard API in **worldguard-core/build/libs**
+* WorldGuard for Bukkit in **worldguard-bukkit/build/libs**
+
+If you want to use WorldGuard, use the `-dist` version.
+
+(The -dist version includes WorldGuard + necessary libraries.)
+
+## Other commands
+
+* `gradlew idea` will generate an [IntelliJ IDEA](http://www.jetbrains.com/idea/) module for each folder.
+* `gradlew eclipse` will generate an [Eclipse](https://www.eclipse.org/downloads/) project for each folder.
@@ -4,12 +4,10 @@ Thank you for your interest in contributing to WorldGuard! We appreciate your
 effort, but to make sure that the inclusion of your patch is a smooth process, we
 ask that you make note of the following guidelines.

-* **Follow the [Oracle coding conventions](http://www.oracle.com/technetwork/java/codeconv-138413.html).**
+* **Follow the [Oracle coding conventions](https://www.oracle.com/technetwork/java/javase/documentation/codeconvtoc-136057.html).**
  We can't stress this enough; if your code has notable issues, it may delay
  the process significantly.
-* **Target Java 6 for source and compilation.** Make sure to mark methods with
-  ` @Override` that override methods of parent classes, or that implement
-  methods of interfaces (Java 6+).
+* **Target Java 16 for source and compilation.**
 * **Use only spaces for indentation.** Our indents are 4-spaces long, and tabs
  are unacceptable.
 * **Wrap code to a 89 column limit.** We do this to make side by side diffs
@@ -0,0 +1,16 @@
+WorldGuard, a suite of tools for Minecraft
+Copyright (C) sk89q <http://www.sk89q.com>
+Copyright (C) WorldGuard team and contributors
+
+This program is free software: you can redistribute it and/or modify it
+under the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License
+for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this program. If not, see <http://www.gnu.org/licenses/>.
@@ -1,52 +0,0 @@
-# New User Guide
-
-Thank you for installing WorldGuard! By default, when you first install WorldGuard, most features will be disabled until you enable the ones that you want to use.
-
-## Requirements
-
-You will need to be using [Bukkit](http://dl.bukkit.org/) for your server or one of its derivatives (such as Spigot or Cauldron). If you are using Minecraft Forge, you will have to use Cauldron in order to use WorldGuard.
-
-It is not possible to use WorldGuard with the plain vanilla server from Mojang.
-
-## Installation
-
-Installation is simple!
-
-1. Extract the `WorldGuard.jar` file and put it into your server's `plugins` folder. If the folder does not exist yet, you can create it yourself.
-2. Run the Bukkit server.
-3. Look inside `plugins/WorldGuard` and configure the plugin as necessary. There are also in-game commands.
-
-By default, only "ops" can use WorldGuard commands. If you install a permissions plugin, then you can assign fine grained permissions to your server's trusted users.
-
-## Documentation
-
-To learn how to use WorldGuard, check out [the wiki](http://wiki.sk89q.com/wiki/WorldGuard).
-
-## Frequently Asked Questions
-
-### How do I protect my spawn?
-
-Check out the [region protection tutorial](http://wiki.sk89q.com/wiki/$%7Bproject.name%7D/Regions/Tutorial) on the wiki.
-
-### Players can't do anything!
-
-WorldGuard will typically not block something without also telling the user that he or she does not have permission. Please make sure that it's not another plugin that is preventing players from interacting with the world.
-
-Also, be aware that spawn protection is a feature of vanilla Minecraft and you must disable that in `bukkit.yml`. It only allows ops to do anything in a specified radius around the world's spawn point.
-
-### I made a region but anyone can build in it!
-
-1. If players get a "you can't do that here" message but they are still able to build, it's because another plugin is likely undoing the protection offered by WorldGuard.
-2. If no message is being sent, make sure that there is a region where you think one is. 
-
-### Where can I ask questions?
-
-You can [ask questions on our forum](http://forum.sk89q.com) or visit us on IRC (irc.esper.net #sk89q).
-
-### Where can I file a bug report or request a feature?
-
-Visit our [issue tracker](http://youtrack.sk89q.com/dashboard). It's also used for WorldEdit and our other projects.
-
-### Is WorldGuard open source?
-
-Yes! [View the source code on GitHub](https://github.com/sk89q/worldguard).
@@ -1,201 +1,201 @@
-
-                   GNU LESSER GENERAL PUBLIC LICENSE
-                       Version 3, 29 June 2007
-
- Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
- Everyone is permitted to copy and distribute verbatim copies
- of this license document, but changing it is not allowed.
-
-
-  This version of the GNU Lesser General Public License incorporates
-the terms and conditions of version 3 of the GNU General Public
-License, supplemented by the additional permissions listed below.
-
-  0. Additional Definitions.
-
-  As used herein, "this License" refers to version 3 of the GNU Lesser
-General Public License, and the "GNU GPL" refers to version 3 of the GNU
-General Public License.
-
-  "The Library" refers to a covered work governed by this License,
-other than an Application or a Combined Work as defined below.
-
-  An "Application" is any work that makes use of an interface provided
-by the Library, but which is not otherwise based on the Library.
-Defining a subclass of a class defined by the Library is deemed a mode
-of using an interface provided by the Library.
-
-  A "Combined Work" is a work produced by combining or linking an
-Application with the Library.  The particular version of the Library
-with which the Combined Work was made is also called the "Linked
-Version".
-
-  The "Minimal Corresponding Source" for a Combined Work means the
-Corresponding Source for the Combined Work, excluding any source code
-for portions of the Combined Work that, considered in isolation, are
-based on the Application, and not on the Linked Version.
-
-  The "Corresponding Application Code" for a Combined Work means the
-object code and/or source code for the Application, including any data
-and utility programs needed for reproducing the Combined Work from the
-Application, but excluding the System Libraries of the Combined Work.
-
-  1. Exception to Section 3 of the GNU GPL.
-
-  You may convey a covered work under sections 3 and 4 of this License
-without being bound by section 3 of the GNU GPL.
-
-  2. Conveying Modified Versions.
-
-  If you modify a copy of the Library, and, in your modifications, a
-facility refers to a function or data to be supplied by an Application
-that uses the facility (other than as an argument passed when the
-facility is invoked), then you may convey a copy of the modified
-version:
-
-   a) under this License, provided that you make a good faith effort to
-   ensure that, in the event an Application does not supply the
-   function or data, the facility still operates, and performs
-   whatever part of its purpose remains meaningful, or
-
-   b) under the GNU GPL, with none of the additional permissions of
-   this License applicable to that copy.
-
-  3. Object Code Incorporating Material from Library Header Files.
-
-  The object code form of an Application may incorporate material from
-a header file that is part of the Library.  You may convey such object
-code under terms of your choice, provided that, if the incorporated
-material is not limited to numerical parameters, data structure
-layouts and accessors, or small macros, inline functions and templates
-(ten or fewer lines in length), you do both of the following:
-
-   a) Give prominent notice with each copy of the object code that the
-   Library is used in it and that the Library and its use are
-   covered by this License.
-
-   b) Accompany the object code with a copy of the GNU GPL and this license
-   document.
-
-  4. Combined Works.
-
-  You may convey a Combined Work under terms of your choice that,
-taken together, effectively do not restrict modification of the
-portions of the Library contained in the Combined Work and reverse
-engineering for debugging such modifications, if you also do each of
-the following:
-
-   a) Give prominent notice with each copy of the Combined Work that
-   the Library is used in it and that the Library and its use are
-   covered by this License.
-
-   b) Accompany the Combined Work with a copy of the GNU GPL and this license
-   document.
-
-   c) For a Combined Work that displays copyright notices during
-   execution, include the copyright notice for the Library among
-   these notices, as well as a reference directing the user to the
-   copies of the GNU GPL and this license document.
-
-   d) Do one of the following:
-
-       0) Convey the Minimal Corresponding Source under the terms of this
-       License, and the Corresponding Application Code in a form
-       suitable for, and under terms that permit, the user to
-       recombine or relink the Application with a modified version of
-       the Linked Version to produce a modified Combined Work, in the
-       manner specified by section 6 of the GNU GPL for conveying
-       Corresponding Source.
-
-       1) Use a suitable shared library mechanism for linking with the
-       Library.  A suitable mechanism is one that (a) uses at run time
-       a copy of the Library already present on the user's computer
-       system, and (b) will operate properly with a modified version
-       of the Library that is interface-compatible with the Linked
-       Version.
-
-   e) Provide Installation Information, but only if you would otherwise
-   be required to provide such information under section 6 of the
-   GNU GPL, and only to the extent that such information is
-   necessary to install and execute a modified version of the
-   Combined Work produced by recombining or relinking the
-   Application with a modified version of the Linked Version. (If
-   you use option 4d0, the Installation Information must accompany
-   the Minimal Corresponding Source and Corresponding Application
-   Code. If you use option 4d1, you must provide the Installation
-   Information in the manner specified by section 6 of the GNU GPL
-   for conveying Corresponding Source.)
-
-  5. Combined Libraries.
-
-  You may place library facilities that are a work based on the
-Library side by side in a single library together with other library
-facilities that are not Applications and are not covered by this
-License, and convey such a combined library under terms of your
-choice, if you do both of the following:
-
-   a) Accompany the combined library with a copy of the same work based
-   on the Library, uncombined with any other library facilities,
-   conveyed under the terms of this License.
-
-   b) Give prominent notice with the combined library that part of it
-   is a work based on the Library, and explaining where to find the
-   accompanying uncombined form of the same work.
-
-  6. Revised Versions of the GNU Lesser General Public License.
-
-  The Free Software Foundation may publish revised and/or new versions
-of the GNU Lesser General Public License from time to time. Such new
-versions will be similar in spirit to the present version, but may
-differ in detail to address new problems or concerns.
-
-  Each version is given a distinguishing version number. If the
-Library as you received it specifies that a certain numbered version
-of the GNU Lesser General Public License "or any later version"
-applies to it, you have the option of following the terms and
-conditions either of that published version or of any later version
-published by the Free Software Foundation. If the Library as you
-received it does not specify a version number of the GNU Lesser
-General Public License, you may choose any version of the GNU Lesser
-General Public License ever published by the Free Software Foundation.
-
-  If the Library as you received it specifies that a proxy can decide
-whether future versions of the GNU Lesser General Public License shall
-apply, that proxy's public statement of acceptance of any version is
-permanent authorization for you to choose that version for the
-Library.
-
----------------------------------------------------------------------------
-
-This work includes Robert Olofsson's Priority R-Tree implementation, for which
-its license is reproduced below.
-
-Copyright (c) 2008-2010 Robert Olofsson.
-All rights reserved. 
-
-Redistribution and use in source and binary forms, with or without 
-modification, are permitted provided that the following conditions 
-are met: 
-
-1. Redistributions of source code must retain the above copyright 
-   notice, this list of conditions and the following disclaimer. 
-
-2. Redistributions in binary form must reproduce the above copyright 
-   notice, this list of conditions and the following disclaimer in the 
-   documentation and/or other materials provided with the distribution. 
-
-3. Neither the name of the authors nor the names of its contributors 
-   may be used to endorse or promote products derived from this software 
-   without specific prior written permission. 
-
-THIS SOFTWARE IS PROVIDED BY THE AUTHORS AND CONTRIBUTORS ``AS IS'' AND 
-ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 
-IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 
-ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE 
-FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 
-DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 
-OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 
-HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 
-LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 
-OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 
+
+                   GNU LESSER GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+
+  This version of the GNU Lesser General Public License incorporates
+the terms and conditions of version 3 of the GNU General Public
+License, supplemented by the additional permissions listed below.
+
+  0. Additional Definitions.
+
+  As used herein, "this License" refers to version 3 of the GNU Lesser
+General Public License, and the "GNU GPL" refers to version 3 of the GNU
+General Public License.
+
+  "The Library" refers to a covered work governed by this License,
+other than an Application or a Combined Work as defined below.
+
+  An "Application" is any work that makes use of an interface provided
+by the Library, but which is not otherwise based on the Library.
+Defining a subclass of a class defined by the Library is deemed a mode
+of using an interface provided by the Library.
+
+  A "Combined Work" is a work produced by combining or linking an
+Application with the Library.  The particular version of the Library
+with which the Combined Work was made is also called the "Linked
+Version".
+
+  The "Minimal Corresponding Source" for a Combined Work means the
+Corresponding Source for the Combined Work, excluding any source code
+for portions of the Combined Work that, considered in isolation, are
+based on the Application, and not on the Linked Version.
+
+  The "Corresponding Application Code" for a Combined Work means the
+object code and/or source code for the Application, including any data
+and utility programs needed for reproducing the Combined Work from the
+Application, but excluding the System Libraries of the Combined Work.
+
+  1. Exception to Section 3 of the GNU GPL.
+
+  You may convey a covered work under sections 3 and 4 of this License
+without being bound by section 3 of the GNU GPL.
+
+  2. Conveying Modified Versions.
+
+  If you modify a copy of the Library, and, in your modifications, a
+facility refers to a function or data to be supplied by an Application
+that uses the facility (other than as an argument passed when the
+facility is invoked), then you may convey a copy of the modified
+version:
+
+   a) under this License, provided that you make a good faith effort to
+   ensure that, in the event an Application does not supply the
+   function or data, the facility still operates, and performs
+   whatever part of its purpose remains meaningful, or
+
+   b) under the GNU GPL, with none of the additional permissions of
+   this License applicable to that copy.
+
+  3. Object Code Incorporating Material from Library Header Files.
+
+  The object code form of an Application may incorporate material from
+a header file that is part of the Library.  You may convey such object
+code under terms of your choice, provided that, if the incorporated
+material is not limited to numerical parameters, data structure
+layouts and accessors, or small macros, inline functions and templates
+(ten or fewer lines in length), you do both of the following:
+
+   a) Give prominent notice with each copy of the object code that the
+   Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the object code with a copy of the GNU GPL and this license
+   document.
+
+  4. Combined Works.
+
+  You may convey a Combined Work under terms of your choice that,
+taken together, effectively do not restrict modification of the
+portions of the Library contained in the Combined Work and reverse
+engineering for debugging such modifications, if you also do each of
+the following:
+
+   a) Give prominent notice with each copy of the Combined Work that
+   the Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the Combined Work with a copy of the GNU GPL and this license
+   document.
+
+   c) For a Combined Work that displays copyright notices during
+   execution, include the copyright notice for the Library among
+   these notices, as well as a reference directing the user to the
+   copies of the GNU GPL and this license document.
+
+   d) Do one of the following:
+
+       0) Convey the Minimal Corresponding Source under the terms of this
+       License, and the Corresponding Application Code in a form
+       suitable for, and under terms that permit, the user to
+       recombine or relink the Application with a modified version of
+       the Linked Version to produce a modified Combined Work, in the
+       manner specified by section 6 of the GNU GPL for conveying
+       Corresponding Source.
+
+       1) Use a suitable shared library mechanism for linking with the
+       Library.  A suitable mechanism is one that (a) uses at run time
+       a copy of the Library already present on the user's computer
+       system, and (b) will operate properly with a modified version
+       of the Library that is interface-compatible with the Linked
+       Version.
+
+   e) Provide Installation Information, but only if you would otherwise
+   be required to provide such information under section 6 of the
+   GNU GPL, and only to the extent that such information is
+   necessary to install and execute a modified version of the
+   Combined Work produced by recombining or relinking the
+   Application with a modified version of the Linked Version. (If
+   you use option 4d0, the Installation Information must accompany
+   the Minimal Corresponding Source and Corresponding Application
+   Code. If you use option 4d1, you must provide the Installation
+   Information in the manner specified by section 6 of the GNU GPL
+   for conveying Corresponding Source.)
+
+  5. Combined Libraries.
+
+  You may place library facilities that are a work based on the
+Library side by side in a single library together with other library
+facilities that are not Applications and are not covered by this
+License, and convey such a combined library under terms of your
+choice, if you do both of the following:
+
+   a) Accompany the combined library with a copy of the same work based
+   on the Library, uncombined with any other library facilities,
+   conveyed under the terms of this License.
+
+   b) Give prominent notice with the combined library that part of it
+   is a work based on the Library, and explaining where to find the
+   accompanying uncombined form of the same work.
+
+  6. Revised Versions of the GNU Lesser General Public License.
+
+  The Free Software Foundation may publish revised and/or new versions
+of the GNU Lesser General Public License from time to time. Such new
+versions will be similar in spirit to the present version, but may
+differ in detail to address new problems or concerns.
+
+  Each version is given a distinguishing version number. If the
+Library as you received it specifies that a certain numbered version
+of the GNU Lesser General Public License "or any later version"
+applies to it, you have the option of following the terms and
+conditions either of that published version or of any later version
+published by the Free Software Foundation. If the Library as you
+received it does not specify a version number of the GNU Lesser
+General Public License, you may choose any version of the GNU Lesser
+General Public License ever published by the Free Software Foundation.
+
+  If the Library as you received it specifies that a proxy can decide
+whether future versions of the GNU Lesser General Public License shall
+apply, that proxy's public statement of acceptance of any version is
+permanent authorization for you to choose that version for the
+Library.
+
+----------------------------------------------------------------------------
+
+This work includes Robert Olofsson's Priority R-Tree implementation, for which
+its license is reproduced below.
+
+Copyright (c) 2008-2010 Robert Olofsson.
+All rights reserved. 
+
+Redistribution and use in source and binary forms, with or without 
+modification, are permitted provided that the following conditions 
+are met: 
+
+1. Redistributions of source code must retain the above copyright 
+   notice, this list of conditions and the following disclaimer. 
+
+2. Redistributions in binary form must reproduce the above copyright 
+   notice, this list of conditions and the following disclaimer in the 
+   documentation and/or other materials provided with the distribution. 
+
+3. Neither the name of the authors nor the names of its contributors 
+   may be used to endorse or promote products derived from this software 
+   without specific prior written permission. 
+
+THIS SOFTWARE IS PROVIDED BY THE AUTHORS AND CONTRIBUTORS ``AS IS'' AND 
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 
+ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE 
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 
+OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 
+HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 
+LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 
+OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 
 SUCH DAMAGE.
@@ -1,46 +1,47 @@
-# ![WorldGuard](http://static.sk89q.com/readme/worldguard-new.png)
-
-WorldGuard lets you and players guard areas of land against griefers and undesirables, as well as tweak and disable various gameplay features of Minecraft.
-
-* Block creeper and wither block damage, falling damage, etc.;
-* Disable fire spread, lava fire spread, ice formation, Endermen picking up blocks, etc.;
-* Blacklist certain items and blocks so they can't be used;
-* Warn moderators when certain items and blocks are used;
-* Protect areas of your world so only certain people can build in them;
-* Set areas where PVP, TNT, mob damage, and other features are disabled;
-* Protect your server from various 'exploits' like magical obsidian creation machines;
-* Disable, or enable, various Minecraft features, like sponges from classic;
-* Add useful commands like an immediate "STOP ALL FIRE SPREAD" command.
-* Enable only features you want! Everything is off by default.
-
-WorldGuard is open source and is available under the GNU Lesser
-General Public License v3.
-
-Currently, Bukkit is required to use WorldGuard. You can get a release copy of WorldGuard from the [BukkitDev site](http://dev.bukkit.org/bukkit-plugins/worldguard/).
-
-Compiling
---------
-
-The project is written for Java 6 and our build process makes use of
-[Maven](http://maven.apache.org). Detailed compilation information
-[can be found on the wiki](http://wiki.sk89q.com/wiki/WorldGuard/Development#Compiling).
-
-Dependencies are automatically handled by Maven.
-
-Contributing
------------
-
-We happily accept contributions, especially through pull requests on GitHub.
-
-Please read CONTRIBUTING.md for important guidelines to follow.
-
-Submissions must be licensed under the GNU Lesser General Public License v3.
-
-Links
-----
-
-* [Homepage](http://enginehub.org/worldguard)
-* [IRC channel](http://skq.me/irc/irc.esper.net/sk89q/) (#sk89q on irc.esper.net)
-* [Issue tracker](http://youtrack.sk89q.com/issues/WORLDGUARD)
-* [Continuous integration](http://builds.enginehub.org)
-* [End-user documentation](http://wiki.sk89q.com/wiki/WorldGuard)
+<h1>
+    <img src="worldguard-logo.svg" alt="WorldGuard" width="400" /> 
+</h1>
+
+WorldGuard lets you and players guard areas of land against griefers and undesirables, as well as tweak and disable various gameplay features of Minecraft.
+
+* Block creeper and wither block damage, falling damage, etc.
+* Disable fire spread, lava fire spread, ice formation, Endermen picking up blocks, etc.
+* Blacklist certain items and blocks so they can't be used
+* Warn moderators when certain items and blocks are used
+* Protect areas of your world so only certain people can build in them
+* Set areas where PVP, TNT, mob damage, and other features are disabled
+* Protect your server from various 'exploits' like magical obsidian creation machines
+* Disable, or enable, various Minecraft features, like sponges from classic
+* Add useful commands like an immediate "STOP ALL FIRE SPREAD" command
+* Enable only features you want! Everything is off by default
+
+WorldGuard is open source and is available under the GNU Lesser
+General Public License v3.
+
+A Bukkit server implementation (such as [Paper](https://papermc.io)) and the [WorldEdit plugin](https://dev.bukkit.org/projects/worldedit) are required to use WorldGuard. You can get a release copy of WorldGuard from the [BukkitDev site](https://dev.bukkit.org/projects/worldguard).
+
+Compiling
+---------
+
+The project is written for Java 17 and our build process makes use of
+[Gradle](http://gradle.org).
+
+Dependencies are automatically handled by Gradle.
+
+Contributing
+------------
+
+We happily accept contributions, especially through pull requests on GitHub.
+
+Please read CONTRIBUTING.md for important guidelines to follow.
+
+Submissions must be licensed under the GNU Lesser General Public License v3.
+
+Links
+-----
+
+* [Homepage](https://enginehub.org/worldguard)
+* [Discord](https://discord.gg/enginehub)
+* [Issue tracker](https://github.com/EngineHub/WorldGuard/issues)
+* [Continuous integration](https://builds.enginehub.org) [![Build Status](https://ci.enginehub.org/app/rest/builds/buildType:bt11,branch:master/statusIcon.svg)](http://ci.enginehub.org/viewType.html?buildTypeId=bt11&guest=1)
+* [End-user documentation](https://worldguard.enginehub.org/en/latest/)
@@ -1,145 +0,0 @@
-# Upgrading to WorldGuard 6
-
-Version 6 is a __MAJOR UPGRADE__ to WorldGuard so we recommend:
-
-* Making backups of your worlds
-* Making backups of your WorldGuard configuration
-
-(Periodical backups are recommended anyway.)
-
-You can upgrade from any version of WorldGuard 5.
-
-It is __NOT POSSIBLE TO DOWNGRADE__ after upgrading to WorldGuard 6 without loss of data due to the conversion to UUIDs. Do NOT downgrade WorldGuard once you have installed version 6.
-
-If downgrading becomes necessary, please file a ticket on our issue tracker.
-
-If this is a __BETA BUILD__ or __SNAPSHOT BUILD__, then you should re-read this document every new release until after you have upgraded to a final release. Breaking changes may be added until the final release.
-
-You have downloaded version ${project.version}.
-
-## Reporting problems
-
-You can report bugs that you encounter on our [issue tracker](http://youtrack.sk89q.com) and [ask questions on our forum](http://forum.sk89q.com).
-
-## Breaking changes
-
-Be aware of these breaking changes:
-
-* Children regions now inherit from their parent even if there is no overlap.
-* Flags are now evaluated together so a `DENY` on `SLEEP` will override a `BUILD` set to `ALLOW`. (The sleep flag only applies to beds.) Possibly the real gotcha is that if you set `BUILD` to deny, then it will also override `PVP` (remember that `DENY` > `ALLOW` > `NONE`).
-* MySQL support now features the ability to migrate tables. If you are using tables without a prefix, then the new migration code should be able to handle your table. However, if you are using a table prefix, you may encounter trouble with migration.
-* Protection is now a lot more exhaustive so it is no longer, for example, possible to fling sand into a region, grow trees into a region, and so on.
-* The `USE` flag is now much more encompassing so you may find that it blocks things like CraftBook gates (for users of CraftBook). To fix that, you can do `/rg flag REGION_NAME use allow`, but be aware that that will also allow the opening of inventories. To block inventories specifically, use `/rg flag REGION_NAME chest-access deny -g nonmembers`. The `-g nonmembers` makes it so only non-members of the region are unable to use chests, but this is optional.
-* If you want to blacklist only water and lava blocks and not buckets, you can no longer apply `on-place` to water or lava blocks because it will also deny the use of buckets. If you wish to deny the use of just the liquid blocks, use `on-use`. This is because WorldGuard now considers the use of a bucket also the placement of a liquid block.
-* In the rare situation that you are user of the "auto-invincibility" and "auto-no-drowning" groups (`wg-invincible` and `wg-amphibious`), you now have to enable these features in the config (`auto-invincible-group: true` and `auto-no-drowning-group: true`). This is because some permission plugins have been causing severe hang ups whenever it is queried for a player's groups, which, in this case, happens to include when the player joins.
-* Plugins that utilize WorldGuard's API may not work anymore. They may crash with errors.
-
-## Incompatible plugins
-
-These plugins are known to be incompatible or have issues unless you update them.
-
-* EchoPet
-    * Can't spawn pets ([issue #393](https://github.com/DSH105/EchoPet/issues/393))
-* CraftBook
-    * Unable to use mechanics unless the `USE` flag is explicitly set to `ALLOW` ([CRAFTBOOK-3057](http://youtrack.sk89q.com/issue/CRAFTBOOK-3057))
-
-## Major features
-
-### UUID support
-
-Regions now fully support the use of UUIDs rather than names for storing the owners and members of a region. Commands still accept names, but they are translated into UUIDs in the background. For users who already have existing region data, names will be automatically converted to UUIDs on the first run of WorldGuard.
-
-It is still possible to specify names rather than a UUID by using the `-n` flag with the region membership commands.
-
-### 'Deny by default'
-
-Previously, a pre-determined list of blocks and entities was used to determine whether an action by the player should be blocked. However, this has been reversed so that every action on a block or entity is denied (in a protected region) unless it has been deemed safe (such as, for example, right clicking with steak). Mods are now supported as a result.
-
-The `USE` flag has been repurposed as a general "interaction" flag and covers every left click or right click of a block or entity. It also covers interaction that falls outside clicking.
-
-### Exhaustive protection
-
-More events are now handled in the protection code. For example,
-
-* It is no longer possible to drop sand or gravel into a protected region from outside.
-* It is no longer possible to grief a region by growing a tree into it.
-* The entry and exit flags now handle players sitting on vehicles properly.
-* Piston-moved blocks cannot be pushed into a different protected region.
-* Owners of tamable animals are now considered in protection code.
-
-Even water and lava flow can also be checked, although this requires that it be explicitly enabled in the configuration (flow events are very frequent, so they incur extra CPU cost).
-
-The goal is to provide extremely exhaustive protection.
-
-### Large performance boost for spatial queries
-
-The performance of spatial queries for regions has been substantially increased at least an order of magnitude. Spatial queries are a necessity for the region code to query the list of regions that apply to a location in the world. There should be a negligible difference between 4, 40, and 4000 regions as long as too many regions are not overlapping.
-
-### Background region operations
-
-Region commands are now executed in the background. Notably, saves and loads will not lock up your server while they complete. Additionally, changes to regions are now saved periodically rather than immediately after every change.
-
-### Updated MySQL region support
-
-MySQL support has been completely overhauled. It should now be faster, no longer crash on foreign key index errors, use transactions, and support automatic creation and migration of tables (including support for table prefixes).
-
-### Partial region data saving
-
-For users of MySQL, WorldGuard now only saves changed and deleted regions when saving region data. No longer does WorldGuard have to rewrite the entire region database on each save.
-
-### Improved handling of related flags
-
-Multiple flags that apply to an event are now evaluated together if they are similar. For example, if a player right clicks a bed to sleep in it, both the `USE` and `SLEEP` flag are checked since they are both interaction-related. If one of them is `DENY`, then sleeping is denied (remember, `DENY` overrides `ALLOW`). If one of them is `ALLOW` and the other is not `DENY`, then sleeping is permitted.
-
-Only one "category" of flags needs to evaluate to true to permit an action. `DENY` will not cross categories. For example, if `BUILD` is deny, it will not override `SLEEP`, so if `SLEEP` is set to `ALLOW`, sleeping will be permitted. This is fairly similar to how it worked on WorldGuard 5.
-
-### Flag groups now work properly
-
-While you could always set a group to a flag's value, the functionality was incomplete and did not work most of the time.
-
-Now that groups are supported, you can change a flag so it only applies to a certain group of players. For example, `/rg flag example sleep deny -g members` would deny sleeping for only members of the `example` region.
-
-### Inheritance now works as expected
-
-Previously, a region only inherited flags and other details from its parents if the parent and the child overlapped at the location queried. This is no longer the case and inheritance is now always applied. 
-
-In addition, a new `-g` flag for `/rg define` lets you create a region with no physical area so that you can assign flags and use this region as a "template region."
-
-### Settable deny message
-
-It is now possible to change the message that users get when they are prevented from interacting with blocks or entities. This message is defined as a region flag, so you can set it on the `__global__` region or override it in a specific region. In addition, the tone and color of the default message has been softened, but you are free to change it entirely.
-
-### Blacklist support for data values (and later, variants)
-
-The blacklist was rewritten to support more than just block and item IDs. The immediate result is that you can now use data values, but as those are in the process of being deprecated by Mojang, it also allows support for Minecraft's new block variants in the future.
-
-### Debounced events
-
-Events that tend to reoccur very frequently (such as the ones that occur when you stand on a pressure plate continuously) have been "debounced" to reduce the number of checks that WorldGuard has to perform, reducing the amount of wasted CPU. In addition, the "you don't have permission" message is rate limited so players are not flooded with the message.
-
-### New block place and break flags
-
-A long requested feature was the availability of block place and break flags. These newly added flags work in tandem with the `BUILD` flag but can override `BUILD`. At the moment, it is not possible to allow explicit types of blocks to be placed or broken yet.
-
-### Build permission nodes
-
-A new optional (disabled by default in the configuration) feature is the checking of build permission nodes. For every block, entity, and item, the following permission nodes are checked:
-
-* Block place: `worldguard.build.block.place.<material>`
-* Block break: `worldguard.build.block.remove.<material>`
-* Block interact: `worldguard.build.block.interact.<material>`
-* Entity spawn: `worldguard.build.entity.place.<type>`
-* Entity destroy: `worldguard.build.entity.remove.<type>`
-* Entity interact: `worldguard.build.entity.interact.<type>`
-* Entity damage: `worldguard.build.entity.damage.<type>`
-* Item use: `worldguard.build.item.use.<material>`
-
-In addition, the permissions are also checked in the style of `worldguard.build.block.<material>.<action>`, so `worldguard.build.block.<material>.place` would work too.
-
-The list of usable material names comes from the [Material enumeration in Bukkit](http://jd.bukkit.org/rb/apidocs/org/bukkit/Material.html). For example, the permission for placing the bed block would be `worldguard.build.build.place.bed_block`. Be aware that _Material_ contains both item and block names.
-
-For entity names, see [EntityType](http://jd.bukkit.org/rb/apidocs/org/bukkit/entity/EntityType.html).
-
-# Other changes
-
-The rest of the changes can be found in the CHANGELOG file.
@@ -0,0 +1,29 @@
+plugins {
+    `kotlin-dsl`
+}
+
+repositories {
+    gradlePluginPortal()
+}
+
+dependencies {
+    implementation(gradleApi())
+    implementation(libs.licenser)
+    implementation(libs.grgit)
+    implementation(libs.shadow)
+    implementation(libs.jfrog.buildinfo)
+    implementation(libs.gson)
+
+    constraints {
+        val asmVersion = "[${libs.versions.minimumAsm.get()},)"
+        implementation("org.ow2.asm:asm:$asmVersion") {
+            because("Need Java 21 support in shadow")
+        }
+        implementation("org.ow2.asm:asm-commons:$asmVersion") {
+            because("Need Java 21 support in shadow")
+        }
+        implementation("org.vafer:jdependency:[${libs.versions.minimumJdependency.get()},)") {
+            because("Need Java 21 support in shadow")
+        }
+    }
+}
@@ -0,0 +1,9 @@
+dependencyResolutionManagement {
+    versionCatalogs {
+        create("libs") {
+            from(files("../gradle/libs.versions.toml"))
+        }
+    }
+}
+
+rootProject.name = "build-logic"
@@ -0,0 +1,32 @@
+import org.jfrog.gradle.plugin.artifactory.dsl.ArtifactoryPluginConvention
+import org.jfrog.gradle.plugin.artifactory.task.ArtifactoryTask
+
+plugins {
+    id("com.jfrog.artifactory")
+}
+
+val ARTIFACTORY_CONTEXT_URL = "artifactory_contextUrl"
+val ARTIFACTORY_USER = "artifactory_user"
+val ARTIFACTORY_PASSWORD = "artifactory_password"
+
+if (!project.hasProperty(ARTIFACTORY_CONTEXT_URL)) ext[ARTIFACTORY_CONTEXT_URL] = "http://localhost"
+if (!project.hasProperty(ARTIFACTORY_USER)) ext[ARTIFACTORY_USER] = "guest"
+if (!project.hasProperty(ARTIFACTORY_PASSWORD)) ext[ARTIFACTORY_PASSWORD] = ""
+
+configure<ArtifactoryPluginConvention> {
+    setContextUrl("${project.property(ARTIFACTORY_CONTEXT_URL)}")
+    clientConfig.publisher.run {
+        repoKey = when {
+            "${project.version}".contains("SNAPSHOT") -> "libs-snapshot-local"
+            else -> "libs-release-local"
+        }
+        username = "${project.property(ARTIFACTORY_USER)}"
+        password = "${project.property(ARTIFACTORY_PASSWORD)}"
+        isMaven = true
+        isIvy = false
+    }
+}
+
+tasks.named<ArtifactoryTask>("artifactoryPublish") {
+    isSkip = true
+}
@@ -0,0 +1,10 @@
+plugins {
+    id("com.jfrog.artifactory")
+}
+
+// Artifactory eagerly evaluates publications, so this must run after all changes to artifacts are done
+afterEvaluate {
+    tasks.named<org.jfrog.gradle.plugin.artifactory.task.ArtifactoryTask>("artifactoryPublish") {
+        publications("maven")
+    }
+}
@@ -0,0 +1,65 @@
+import buildlogic.getLibrary
+import buildlogic.stringyLibs
+
+plugins {
+    id("eclipse")
+    id("idea")
+    id("checkstyle")
+    id("buildlogic.common")
+}
+
+tasks
+    .withType<JavaCompile>()
+    .matching { it.name == "compileJava" || it.name == "compileTestJava" }
+    .configureEach {
+        val disabledLint = listOf(
+            "processing", "path", "fallthrough", "serial", "overloads",
+        )
+        options.release.set(21)
+        options.compilerArgs.addAll(listOf("-Xlint:all") + disabledLint.map { "-Xlint:-$it" })
+        options.isDeprecation = true
+        options.encoding = "UTF-8"
+        options.compilerArgs.add("-parameters")
+        //options.compilerArgs.add("-Werror")
+    }
+
+configure<CheckstyleExtension> {
+    configFile = rootProject.file("config/checkstyle/checkstyle.xml")
+    toolVersion = "10.16.0"
+}
+
+tasks.withType<Test>().configureEach {
+    useJUnitPlatform()
+}
+
+dependencies {
+    "compileOnly"(stringyLibs.getLibrary("jsr305"))
+    "testImplementation"(platform(stringyLibs.getLibrary("junit-bom")))
+    "testImplementation"(stringyLibs.getLibrary("junit-jupiter-api"))
+    "testImplementation"(stringyLibs.getLibrary("junit-jupiter-params"))
+    "testRuntimeOnly"(stringyLibs.getLibrary("junit-jupiter-engine"))
+}
+
+// Java 8 turns on doclint which we fail
+tasks.withType<Javadoc>().configureEach {
+    options.encoding = "UTF-8"
+    (options as StandardJavadocDocletOptions).apply {
+        //addBooleanOption("Werror", true)
+        addBooleanOption("Xdoclint:all", true)
+        addBooleanOption("Xdoclint:-missing", true)
+        tags(
+            "apiNote:a:API Note:",
+            "implSpec:a:Implementation Requirements:",
+            "implNote:a:Implementation Note:"
+        )
+    }
+}
+
+configure<JavaPluginExtension> {
+    withJavadocJar()
+    withSourcesJar()
+}
+
+tasks.named("check").configure {
+    dependsOn("checkstyleMain", "checkstyleTest")
+}
@@ -0,0 +1,69 @@
+import buildlogic.getLibrary
+import buildlogic.stringyLibs
+import org.gradle.plugins.ide.idea.model.IdeaModel
+
+plugins {
+    id("org.cadixdev.licenser")
+}
+
+group = rootProject.group
+version = rootProject.version
+
+repositories {
+    mavenCentral()
+    maven {
+        name = "EngineHub"
+        url = uri("https://maven.enginehub.org/repo/")
+    }
+}
+
+configurations.all {
+    resolutionStrategy {
+        cacheChangingModulesFor(1, TimeUnit.DAYS)
+    }
+}
+
+plugins.withId("java") {
+    the<JavaPluginExtension>().toolchain {
+        languageVersion.set(JavaLanguageVersion.of(21))
+    }
+}
+
+dependencies {
+    for (conf in listOf("implementation", "api")) {
+        if (!configurations.names.contains(conf)) {
+            continue
+        }
+        add(conf, platform(stringyLibs.getLibrary("log4j-bom")).map {
+            val dep = create(it)
+            dep.because("Mojang provides Log4j")
+            dep
+        })
+        constraints {
+            add(conf, stringyLibs.getLibrary("guava")) {
+                because("Mojang provides Guava")
+            }
+            add(conf, stringyLibs.getLibrary("gson")) {
+                because("Mojang provides Gson")
+            }
+            add(conf, stringyLibs.getLibrary("fastutil")) {
+                because("Mojang provides FastUtil")
+            }
+        }
+    }
+}
+
+license {
+    header(rootProject.file("HEADER.txt"))
+    include("**/*.java")
+    include("**/*.kt")
+}
+
+plugins.withId("idea") {
+    configure<IdeaModel> {
+        module {
+            isDownloadSources = true
+            isDownloadJavadoc = true
+        }
+    }
+}
@@ -0,0 +1,23 @@
+plugins {
+    id("java")
+    id("maven-publish")
+    id("buildlogic.common-java")
+    id("buildlogic.artifactory-sub")
+}
+
+ext["internalVersion"] = "$version+${rootProject.ext["gitCommitHash"]}"
+
+publishing {
+    publications {
+        register<MavenPublication>("maven") {
+            versionMapping {
+                usage("java-api") {
+                    fromResolutionOf("runtimeClasspath")
+                }
+                usage("java-runtime") {
+                    fromResolutionResult()
+                }
+            }
+        }
+    }
+}
@@ -0,0 +1,179 @@
+plugins {
+    id("java-base")
+    id("maven-publish")
+    id("com.github.johnrengelman.shadow")
+    id("com.jfrog.artifactory")
+    id("buildlogic.common")
+    id("buildlogic.artifactory-sub")
+}
+
+// A horrible hack because `softwareComponentFactory` has to be gotten via plugin
+// gradle why
+internal open class LibsConfigPluginHack @Inject constructor(
+    private val softwareComponentFactory: SoftwareComponentFactory
+) : Plugin<Project> {
+    override fun apply(project: Project) {
+        val libsComponents = softwareComponentFactory.adhoc("libs")
+        project.components.add(libsComponents)
+    }
+}
+
+configurations {
+    create("shade")
+}
+
+group = "${rootProject.group}.worldguard-libs"
+
+val relocations = mapOf(
+    "org.enginehub.squirrelid" to "com.sk89q.worldguard.util.profile",
+)
+
+tasks.register<com.github.jengelman.gradle.plugins.shadow.tasks.ShadowJar>("jar") {
+    configurations = listOf(project.configurations["shade"])
+    archiveClassifier.set("")
+
+    // Yeet module-info's
+    exclude("module-info.class")
+
+    dependencies {
+        exclude(dependency("com.google.guava:guava"))
+        exclude(dependency("com.google.code.gson:gson"))
+        exclude(dependency("com.google.errorprone:error_prone_annotations"))
+        exclude(dependency("com.google.guava:failureaccess"))
+        exclude(dependency("org.checkerframework:checker-qual"))
+        exclude(dependency("org.jetbrains:annotations"))
+        exclude(dependency("org.apache.logging.log4j:log4j-api"))
+        exclude(dependency("com.google.code.findbugs:jsr305"))
+        exclude {
+            it.moduleGroup == "org.jetbrains.kotlin"
+        }
+    }
+
+    relocations.forEach { (from, to) ->
+        relocate(from, to)
+    }
+}
+val altConfigFiles = { artifactType: String ->
+    val deps = configurations["shade"].incoming.dependencies
+        .filterIsInstance<ModuleDependency>()
+        .map { it.copy() }
+        .map { dependency ->
+            val category = dependency.attributes.getAttribute(Category.CATEGORY_ATTRIBUTE)?.name
+            if (category == Category.REGULAR_PLATFORM || category == Category.ENFORCED_PLATFORM) {
+                return@map dependency
+            }
+            try {
+                dependency.artifact {
+                    name = dependency.name
+                    type = artifactType
+                    extension = "jar"
+                    classifier = artifactType
+                }
+            } catch (e: Exception) {
+                throw RuntimeException("Failed to add artifact to dependency: $dependency", e)
+            }
+            dependency
+        }
+
+    files(configurations.detachedConfiguration(*deps.toTypedArray())
+        .resolvedConfiguration.lenientConfiguration.artifacts
+        .filter { it.classifier == artifactType }
+        .map { zipTree(it.file) })
+}
+tasks.register<Jar>("sourcesJar") {
+    from({
+        altConfigFiles("sources")
+    })
+
+    // Yeet module-info's
+    exclude("module-info.java")
+
+    relocations.forEach { (from, to) ->
+        val filePattern = Regex("(.*)${from.replace('.', '/')}((?:/|$).*)")
+        val textPattern = Regex.fromLiteral(from)
+        eachFile {
+            filter {
+                it.replaceFirst(textPattern, to)
+            }
+            path = path.replaceFirst(filePattern, "$1${to.replace('.', '/')}$2")
+        }
+    }
+    archiveClassifier.set("sources")
+}
+
+tasks.named("assemble").configure {
+    dependsOn("jar", "sourcesJar")
+}
+
+project.apply<LibsConfigPluginHack>()
+
+val libsComponent = project.components["libs"] as AdhocComponentWithVariants
+
+val apiElements = project.configurations.register("apiElements") {
+    isVisible = false
+    description = "API elements for libs"
+    isCanBeResolved = false
+    isCanBeConsumed = true
+    attributes {
+        attribute(Usage.USAGE_ATTRIBUTE, project.objects.named(Usage.JAVA_API))
+        attribute(Category.CATEGORY_ATTRIBUTE, project.objects.named(Category.LIBRARY))
+        attribute(Bundling.BUNDLING_ATTRIBUTE, project.objects.named(Bundling.SHADOWED))
+        attribute(LibraryElements.LIBRARY_ELEMENTS_ATTRIBUTE, project.objects.named(LibraryElements.JAR))
+        attribute(TargetJvmVersion.TARGET_JVM_VERSION_ATTRIBUTE, 21)
+    }
+    outgoing.artifact(tasks.named("jar"))
+}
+
+val runtimeElements = project.configurations.register("runtimeElements") {
+    isVisible = false
+    description = "Runtime elements for libs"
+    isCanBeResolved = false
+    isCanBeConsumed = true
+    attributes {
+        attribute(Usage.USAGE_ATTRIBUTE, project.objects.named(Usage.JAVA_RUNTIME))
+        attribute(Category.CATEGORY_ATTRIBUTE, project.objects.named(Category.LIBRARY))
+        attribute(Bundling.BUNDLING_ATTRIBUTE, project.objects.named(Bundling.SHADOWED))
+        attribute(LibraryElements.LIBRARY_ELEMENTS_ATTRIBUTE, project.objects.named(LibraryElements.JAR))
+        attribute(TargetJvmVersion.TARGET_JVM_VERSION_ATTRIBUTE, 21)
+    }
+    outgoing.artifact(tasks.named("jar"))
+}
+
+val sourcesElements = project.configurations.register("sourcesElements") {
+    isVisible = false
+    description = "Source elements for libs"
+    isCanBeResolved = false
+    isCanBeConsumed = true
+    attributes {
+        attribute(Usage.USAGE_ATTRIBUTE, project.objects.named(Usage.JAVA_RUNTIME))
+        attribute(Category.CATEGORY_ATTRIBUTE, project.objects.named(Category.DOCUMENTATION))
+        attribute(Bundling.BUNDLING_ATTRIBUTE, project.objects.named(Bundling.SHADOWED))
+        attribute(DocsType.DOCS_TYPE_ATTRIBUTE, project.objects.named(DocsType.SOURCES))
+    }
+    outgoing.artifact(tasks.named("sourcesJar"))
+}
+
+libsComponent.addVariantsFromConfiguration(apiElements.get()) {
+    mapToMavenScope("compile")
+}
+
+libsComponent.addVariantsFromConfiguration(runtimeElements.get()) {
+    mapToMavenScope("runtime")
+}
+
+libsComponent.addVariantsFromConfiguration(sourcesElements.get()) {
+    mapToMavenScope("runtime")
+}
+
+configure<PublishingExtension> {
+    publications {
+        register<MavenPublication>("maven") {
+            from(libsComponent)
+        }
+    }
+}
+
+if (project != project(":worldguard-libs:core")) {
+    evaluationDependsOn(":worldguard-libs:core")
+    configurations["shade"].shouldResolveConsistentlyWith(project(":worldguard-libs:core").configurations["shade"])
+}
@@ -0,0 +1,39 @@
+plugins {
+    id("com.github.johnrengelman.shadow")
+    id("buildlogic.core-and-platform")
+}
+
+tasks.named<com.github.jengelman.gradle.plugins.shadow.tasks.ShadowJar>("shadowJar") {
+    archiveClassifier.set("dist")
+    dependencies {
+        include(project(":worldguard-libs:core"))
+        include(project(":worldguard-core"))
+
+        relocate("org.flywaydb", "com.sk89q.worldguard.internal.flywaydb") {
+            include(dependency("org.flywaydb:flyway-core"))
+        }
+        exclude("com.google.code.findbugs:jsr305")
+    }
+    exclude("GradleStart**")
+    exclude(".cache")
+    exclude("LICENSE*")
+    exclude("META-INF/maven/**")
+    minimize()
+}
+val javaComponent = components["java"] as AdhocComponentWithVariants
+// I don't think we want this published (it's the shadow jar)
+javaComponent.withVariantsFromConfiguration(configurations["shadowRuntimeElements"]) {
+    skip()
+}
+
+afterEvaluate {
+    tasks.named<Jar>("jar") {
+        val version = project(":worldguard-core").version
+        inputs.property("version", version)
+        val attributes = mutableMapOf(
+            "Implementation-Version" to version,
+            "WorldGuard-Version" to version,
+        )
+        manifest.attributes(attributes)
+    }
+}
@@ -0,0 +1,24 @@
+package buildlogic
+
+import org.gradle.api.Project
+import org.gradle.api.artifacts.MinimalExternalModuleDependency
+import org.gradle.api.artifacts.VersionCatalog
+import org.gradle.api.artifacts.VersionCatalogsExtension
+import org.gradle.api.artifacts.VersionConstraint
+import org.gradle.api.plugins.ExtraPropertiesExtension
+import org.gradle.api.provider.Provider
+import org.gradle.kotlin.dsl.getByType
+
+val Project.ext: ExtraPropertiesExtension
+    get() = extensions.getByType()
+
+val Project.stringyLibs: VersionCatalog
+    get() = extensions.getByType<VersionCatalogsExtension>().named("libs")
+
+fun VersionCatalog.getLibrary(name: String): Provider<MinimalExternalModuleDependency> = findLibrary(name).orElseThrow {
+    error("Library $name not found in version catalog")
+}
+
+fun VersionCatalog.getVersion(name: String): VersionConstraint = findVersion(name).orElseThrow {
+    error("Version $name not found in version catalog")
+}
@@ -0,0 +1,17 @@
+import org.ajoberstar.grgit.Grgit
+
+plugins {
+    id("buildlogic.common")
+    id("buildlogic.artifactory-root")
+}
+
+if (!project.hasProperty("gitCommitHash")) {
+    apply(plugin = "org.ajoberstar.grgit")
+    ext["gitCommitHash"] = try {
+        extensions.getByName<Grgit>("grgit").head()?.abbreviatedId
+    } catch (e: Exception) {
+        logger.warn("Error getting commit hash", e)
+
+        "no.git.id"
+    }
+}
@@ -0,0 +1,86 @@
+import org.gradle.api.Project
+import org.gradle.api.plugins.JavaPluginExtension
+import org.gradle.api.plugins.quality.CheckstyleExtension
+import org.gradle.api.tasks.compile.JavaCompile
+import org.gradle.api.tasks.javadoc.Javadoc
+import org.gradle.api.tasks.testing.Test
+import org.gradle.external.javadoc.StandardJavadocDocletOptions
+import org.gradle.kotlin.dsl.apply
+import org.gradle.kotlin.dsl.configure
+import org.gradle.kotlin.dsl.dependencies
+import org.gradle.kotlin.dsl.get
+import org.gradle.kotlin.dsl.withType
+
+fun Project.applyCommonJavaConfiguration(sourcesJar: Boolean, javaRelease: Int = 8, banSlf4j: Boolean = true) {
+    applyCommonConfiguration()
+    apply(plugin = "eclipse")
+    apply(plugin = "idea")
+    apply(plugin = "checkstyle")
+
+    tasks
+        .withType<JavaCompile>()
+        .matching { it.name == "compileJava" || it.name == "compileTestJava" }
+        .configureEach {
+            val disabledLint = listOf(
+                "processing", "path", "fallthrough", "serial"
+            )
+            options.release.set(javaRelease)
+            options.compilerArgs.addAll(listOf("-Xlint:all") + disabledLint.map { "-Xlint:-$it" })
+            options.isDeprecation = true
+            options.encoding = "UTF-8"
+            options.compilerArgs.add("-parameters")
+        }
+
+    configure<CheckstyleExtension> {
+        configFile = rootProject.file("config/checkstyle/checkstyle.xml")
+        toolVersion = "9.1"
+    }
+
+    tasks.withType<Test>().configureEach {
+        useJUnitPlatform()
+    }
+
+    dependencies {
+        "compileOnly"("com.google.code.findbugs:jsr305:${Versions.FINDBUGS}")
+        "testImplementation"("org.junit.jupiter:junit-jupiter-api:${Versions.JUNIT}")
+        "testImplementation"("org.junit.jupiter:junit-jupiter-params:${Versions.JUNIT}")
+        "testImplementation"("org.mockito:mockito-core:${Versions.MOCKITO}")
+        "testImplementation"("org.mockito:mockito-junit-jupiter:${Versions.MOCKITO}")
+        "testRuntimeOnly"("org.junit.jupiter:junit-jupiter-engine:${Versions.JUNIT}")
+    }
+
+    // Java 8 turns on doclint which we fail
+    tasks.withType<Javadoc>().configureEach {
+        options.encoding = "UTF-8"
+        (options as StandardJavadocDocletOptions).apply {
+            addStringOption("Xdoclint:none", "-quiet")
+            tags(
+                "apiNote:a:API Note:",
+                "implSpec:a:Implementation Requirements:",
+                "implNote:a:Implementation Note:"
+            )
+        }
+    }
+
+    configure<JavaPluginExtension> {
+        disableAutoTargetJvm()
+        withJavadocJar()
+        if (sourcesJar) {
+            withSourcesJar()
+        }
+    }
+
+    if (banSlf4j) {
+        configurations["compileClasspath"].apply {
+            resolutionStrategy.componentSelection {
+                withModule("org.slf4j:slf4j-api") {
+                    reject("No SLF4J allowed on compile classpath")
+                }
+            }
+        }
+    }
+
+    tasks.named("check").configure {
+        dependsOn("checkstyleMain", "checkstyleTest")
+    }
+}
@@ -1,63 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!--
-  ~ WorldGuard, a suite of tools for Minecraft
-  ~ Copyright (C) sk89q <http://www.sk89q.com>
-  ~ Copyright (C) WorldGuard team and contributors
-  ~
-  ~ This program is free software: you can redistribute it and/or modify it
-  ~ under the terms of the GNU Lesser General Public License as published by the
-  ~ Free Software Foundation, either version 3 of the License, or
-  ~ (at your option) any later version.
-  ~
-  ~ This program is distributed in the hope that it will be useful, but WITHOUT
-  ~ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-  ~ FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License
-  ~ for more details.
-  ~
-  ~ You should have received a copy of the GNU Lesser General Public License
-  ~ along with this program. If not, see <http://www.gnu.org/licenses/>.
-  -->
-
-<assembly
-  xmlns="http://maven.apache.org/plugins/maven-assembly-plugin/assembly/1.1.2"
-  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-  xsi:schemaLocation="http://maven.apache.org/plugins/maven-assembly-plugin/assembly/1.1.2 http://maven.apache.org/xsd/assembly-1.1.2.xsd">
-  <includeBaseDirectory>false</includeBaseDirectory>
-  <formats>
-    <format>tar.gz</format>
-    <format>tar.bz2</format>
-    <format>zip</format>
-  </formats>
-  <files>
-    <file>
-      <source>${project.build.directory}/${artifactId}-${project.version}.jar</source>
-      <outputDirectory>/</outputDirectory>
-      <filtered>false</filtered>
-    </file>
-    <file>
-      <source>${project.build.directory}/CHANGELOG.html</source>
-      <outputDirectory>/</outputDirectory>
-      <filtered>true</filtered>
-    </file>
-    <file>
-      <source>${project.build.directory}/INSTALL.html</source>
-      <destName>README.html</destName>
-      <outputDirectory>/</outputDirectory>
-      <filtered>true</filtered>
-    </file>
-    <file>
-      <source>${project.build.directory}/UPGRADE.html</source>
-      <destName>READ_BEFORE_UPGRADING_FROM_V5.html</destName>
-      <outputDirectory>/</outputDirectory>
-      <filtered>true</filtered>
-    </file>
-  </files>
-  <fileSets>
-    <fileSet>
-      <includes>
-        <include>contrib/blacklist_table.sql</include>
-        <include>contrib/region_manual_update_20110325.sql</include>
-      </includes>
-    </fileSet>
-  </fileSets>
-</assembly>
@@ -0,0 +1,63 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE module PUBLIC
+        "-//Puppy Crawl//DTD Check Configuration 1.3//EN"
+        "http://www.puppycrawl.com/dtds/configuration_1_3.dtd">
+<module name="Checker">
+  <!-- Tabs are strictly banned -->
+  <module name="FileTabCharacter"/>
+
+  <module name="SuppressionFilter">
+    <property name="file" value="${config_loc}/suppressions.xml"/>
+  </module>
+
+
+
+  <module name="TreeWalker">
+    <!-- Important basics -->
+    <!-- <module name="PackageDeclaration"/> Unlikely that we would miss this in a PR -->
+    <module name="OuterTypeFilename"/> <!-- TypeName -> TypeName.java -->
+
+    <!--
+    Control package usage, so people don't insert Bukkit into WG where it shouldn't belong, etc.
+    It is a bit draconian, so update as necessary!
+    -->
+    <module name="ImportControl">
+      <property name="file" value="${config_loc}/import-control.xml"/>
+    </module>
+
+    <!-- Code -->
+    <module name="HideUtilityClassConstructor"/> <!-- Utility classes should not have a constructor -->
+    <module name="CovariantEquals"/>
+    <module name="EqualsHashCode"/> <!-- equals() and hashCode() go together -->
+    <module name="NestedTryDepth"> <!-- SHOULD not need to adjust this -->
+      <property name="max" value="2"/>
+    </module>
+    <module name="SuperFinalize"/> <!-- We don't actually use this -->
+
+    <!-- Style -->
+    <module name="LeftCurly"> <!-- Left brace never goes on another line -->
+      <property name="option" value="eol"/>
+    </module> <!-- We don't check right brace -->
+    <module name="DefaultComesLast"/> <!-- default case in switch should be last -->
+    <module name="GenericWhitespace"/>
+
+    <!-- Naming -->
+    <module name="ClassTypeParameterName">
+      <property name="format" value="^[A-Z][a-zA-Z0-9]*$"/>
+    </module>
+    <module name="LocalFinalVariableName"/>
+    <module name="LocalVariableName">
+      <property name="format" value="^[a-z_][a-zA-Z0-9]*$"/>
+    </module>
+    <module name="MemberName">
+      <property name="format" value="^[a-z_][a-zA-Z0-9]*$"/>
+    </module>
+    <module name="MethodName">
+      <property name="format" value="^[a-z][a-zA-Z0-9]*$"/>
+    </module>
+    <!-- <module name="PackageName"/> Unlikely that we would miss this in a PR -->
+    <module name="ParameterName"/>
+    <!-- <module name="TypeName"/> Unlikely that we would miss this in a PR -->
+  </module>
+
+</module>
@@ -1,22 +1,3 @@
-<!--
-  ~ WorldGuard, a suite of tools for Minecraft
-  ~ Copyright (C) sk89q <http://www.sk89q.com>
-  ~ Copyright (C) WorldGuard team and contributors
-  ~
-  ~ This program is free software: you can redistribute it and/or modify it
-  ~ under the terms of the GNU Lesser General Public License as published by the
-  ~ Free Software Foundation, either version 3 of the License, or
-  ~ (at your option) any later version.
-  ~
-  ~ This program is distributed in the hope that it will be useful, but WITHOUT
-  ~ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-  ~ FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License
-  ~ for more details.
-  ~
-  ~ You should have received a copy of the GNU Lesser General Public License
-  ~ along with this program. If not, see <http://www.gnu.org/licenses/>.
-  -->
-
 <!DOCTYPE import-control PUBLIC
    "-//Puppy Crawl//DTD Import Control 1.1//EN"
    "http://www.puppycrawl.com/dtds/import_control_1_1.dtd">
@@ -25,16 +6,33 @@
  <allow pkg="java"/>
  <allow pkg="javax"/>
  <allow pkg="org.junit"/>
-  <allow pkg="junit"/>
-  <allow pkg="org.mockito"/>
  <allow pkg="org.hamcrest"/>
+  <allow pkg="junit.framework"/>
  <allow pkg="com.sk89q"/>
-  <allow pkg="org.enginehub"/>
-  <allow pkg="org.bukkit"/>
-  <allow pkg="org.yaml.snakeyaml"/>
-  <allow pkg="au.com.bytecode.opencsv"/>
-  <allow pkg="org.khelekore.prtree"/>
  <allow pkg="com.google.common"/>
-  <allow pkg="com.jolbox.bonecp"/>
-  <allow pkg="org.flywaydb.core"/>
-</import-control>
+
+  <subpackage name="worldguard">
+    <allow pkg="org.khelekore"/>
+    <allow pkg="org.flywaydb"/>
+    <allow pkg="org.yaml"/>
+    <allow pkg="org.enginehub.piston"/>
+
+    <subpackage name="util.profile.resolver">
+      <allow pkg="org.bukkit"/>
+      <allow pkg="io.papermc.lib"/>
+      <allow pkg="com.destroystokyo.paper"/>
+    </subpackage>
+
+    <subpackage name="bukkit">
+      <allow pkg="org.bukkit"/>
+      <allow pkg="org.bstats.bukkit"/>
+      <allow pkg="org.bstats.charts"/>
+      <allow pkg="io.papermc.lib"/>
+      <allow pkg="com.destroystokyo.paper"/>
+      <allow pkg="io.papermc.paper"/>
+      <allow pkg="org.spigotmc" />
+    </subpackage>
+
+  </subpackage>
+
+</import-control>
@@ -0,0 +1,7 @@
+<?xml version="1.0"?>
+<!DOCTYPE suppressions PUBLIC
+        "-//Checkstyle//DTD SuppressionFilter Configuration 1.2//EN"
+        "https://checkstyle.org/dtds/suppressions_1_2.dtd">
+<suppressions>
+    <suppress files="ProtectedRegion.java" checks="EqualsHashCode"/>
+</suppressions>
@@ -1,3 +0,0 @@
-</div>
-</body>
-</html>
@@ -1,368 +0,0 @@
-<!DOCTYPE html>
-<html>
-<head>
-<title>WorldGuard - titleToken</title>
-<style>
-body {
-  margin: 0;
-  padding: 2em 2em 3em 2em;
-  color: #333;
-  font-family: "Helvetica Neue", Helvetica, "Segoe UI", Arial, freesans, sans-serif;
-  font-size: 15px;
-  line-height: 1.5;
-  word-wrap: break-word;
-}
-
-.wrapper {
-  margin: auto;
-  max-width: 750px;
-}
-
-a {
-  background: transparent;
-}
-
-a:active,
-a:hover {
-  outline: 0;
-}
-
-strong {
-  font-weight: bold;
-}
-
-h1 {
-  font-size: 2em;
-  margin: 0 0 0.67em 0;
-}
-
-img {
-  border: 0;
-}
-
-hr {
-  -moz-box-sizing: content-box;
-  box-sizing: content-box;
-  height: 0;
-}
-
-pre {
-  overflow: auto;
-}
-
-code,
-pre {
-  font-family: monospace, monospace;
-  font-size: 1em;
-}
-
-table {
-  border-collapse: collapse;
-  border-spacing: 0;
-}
-
-td,
-th {
-  padding: 0;
-}
-
-* {
-  -moz-box-sizing: border-box;
-  box-sizing: border-box;
-}
-
-a {
-  color: #4183c4;
-  text-decoration: none;
-}
-
-a:hover,
-a:focus,
-a:active {
-  text-decoration: underline;
-}
-
-hr {
-  height: 0;
-  margin: 15px 0;
-  overflow: hidden;
-  background: transparent;
-  border: 0;
-  border-bottom: 1px solid #ddd;
-}
-
-hr:before,
-hr:after {
-  display: table;
-  content: " ";
-}
-
-hr:after {
-  clear: both;
-}
-
-blockquote {
-  margin: 0;
-}
-
-ul,
-ol {
-  padding: 0;
-  margin-top: 0;
-  margin-bottom: 0;
-}
-
-ol ol {
-  list-style-type: lower-roman;
-}
-
-dd {
-  margin-left: 0;
-}
-
-code,
-pre {
-  font-family: Consolas, "Liberation Mono", Menlo, Courier, monospace;
-  font-size: 12px;
-}
-
-pre {
-  margin-top: 0;
-  margin-bottom: 0;
-}
-
-*:first-child {
-  margin-top: 0 !important;
-}
-
-*:last-child {
-  margin-bottom: 0 !important;
-}
-
-.anchor {
-  position: absolute;
-  top: 0;
-  bottom: 0;
-  left: 0;
-  display: block;
-  padding-right: 6px;
-  padding-left: 30px;
-  margin-left: -30px;
-}
-
-.anchor:focus {
-  outline: none;
-}
-
-h1,
-h2,
-h3,
-h4,
-h5,
-h6 {
-  position: relative;
-  margin-top: 1.5em;
-  margin-bottom: 16px;
-  font-weight: bold;
-  line-height: 1.4;
-}
-
-h1 {
-  padding-bottom: 0.3em;
-  font-size: 2.1em;
-  line-height: 1.2;
-  border-bottom: 1px solid #eee;
-}
-
-h2 {
-  padding-bottom: 0.3em;
-  font-size: 1.65em;
-  line-height: 1.225;
-  border-bottom: 1px solid #eee;
-}
-
-h3 {
-  font-size: 1.2em;
-  line-height: 1.43;
-}
-
-h4 {
-  font-size: 1.1em;
-}
-
-h5 {
-  font-size: 1em;
-}
-
-h6 {
-  font-size: 1em;
-  color: #777;
-}
-
-p,
-blockquote,
-ul,
-ol,
-dl,
-table,
-pre {
-  margin-top: 0;
-  margin-bottom: 16px;
-}
-
-hr {
-  height: 4px;
-  padding: 0;
-  margin: 16px 0;
-  background-color: #e7e7e7;
-  border: 0 none;
-}
-
-ul,
-ol {
-  padding-left: 2em;
-}
-
-ol ol,
-ol ul {
-  margin-top: 0;
-  margin-bottom: 0;
-}
-
-li>p {
-  margin-top: 16px;
-}
-
-dl {
-  padding: 0;
-}
-
-dl dt {
-  padding: 0;
-  margin-top: 16px;
-  font-size: 1em;
-  font-style: italic;
-  font-weight: bold;
-}
-
-dl dd {
-  padding: 0 16px;
-  margin-bottom: 16px;
-}
-
-blockquote {
-  padding: 0 15px;
-  color: #777;
-  border-left: 4px solid #ddd;
-}
-
-blockquote>:first-child {
-  margin-top: 0;
-}
-
-blockquote>:last-child {
-  margin-bottom: 0;
-}
-
-table {
-  display: block;
-  width: 100%;
-  overflow: auto;
-  word-break: normal;
-  word-break: keep-all;
-}
-
-table th {
-  font-weight: bold;
-}
-
-table th,
-table td {
-  padding: 6px 13px;
-  border: 1px solid #ddd;
-}
-
-table tr {
-  background-color: #fff;
-  border-top: 1px solid #ccc;
-}
-
-table tr:nth-child(2n) {
-  background-color: #f8f8f8;
-}
-
-img {
-  max-width: 100%;
-  -moz-box-sizing: border-box;
-  box-sizing: border-box;
-}
-
-code {
-  padding: 0;
-  padding-top: 0.2em;
-  padding-bottom: 0.2em;
-  margin: 0;
-  font-size: 85%;
-  background-color: rgba(0,0,0,0.04);
-  border-radius: 3px;
-}
-
-code:before,
-code:after {
-  letter-spacing: -0.2em;
-  content: "\00a0";
-}
-
-pre>code {
-  padding: 0;
-  margin: 0;
-  font-size: 100%;
-  word-break: normal;
-  white-space: pre;
-  background: transparent;
-  border: 0;
-}
-
-.highlight {
-  margin-bottom: 16px;
-}
-
-.highlight pre,
-pre {
-  padding: 16px;
-  overflow: auto;
-  font-size: 85%;
-  line-height: 1.45;
-  background-color: #f7f7f7;
-  border-radius: 3px;
-}
-
-.highlight pre {
-  margin-bottom: 0;
-  word-break: normal;
-}
-
-pre {
-  word-wrap: normal;
-}
-
-pre code {
-  display: inline;
-  max-width: initial;
-  padding: 0;
-  margin: 0;
-  overflow: initial;
-  line-height: inherit;
-  word-wrap: normal;
-  background-color: transparent;
-  border: 0;
-}
-
-pre code:before,
-pre code:after {
-  content: normal;
-}
-</style>
-</head>
-<body>
-<div class="wrapper">
@@ -0,0 +1,4 @@
+group=com.sk89q.worldguard
+version=7.1.0-SNAPSHOT
+
+org.gradle.parallel=true
@@ -0,0 +1,2 @@
+#This file is generated by updateDaemonJvm
+toolchainVersion=21
@@ -0,0 +1,66 @@
+[versions]
+worldedit = "7.3.0"
+
+# Minimum versions we apply to make dependencies support newer Java
+minimumAsm = "9.7"
+minimumJdependency = "2.10"
+minimumTinyRemapper = "0.8.11"
+
+# lang-version = ""
+
+[libraries]
+
+licenser = "gradle.plugin.org.cadixdev.gradle:licenser:0.6.1"
+grgit = "org.ajoberstar.grgit:grgit-gradle:5.2.2"
+shadow = "com.github.johnrengelman:shadow:8.1.1"
+jfrog-buildinfo = "org.jfrog.buildinfo:build-info-extractor-gradle:5.2.0"
+
+squirrelid = "org.enginehub:squirrelid:0.3.2"
+
+autoService = "com.google.auto.service:auto-service:1.1.1"
+
+jsr305 = "com.google.code.findbugs:jsr305:3.0.2"
+jetbrains-annotations = "org.jetbrains:annotations:24.1.0"
+
+junit-bom = "org.junit:junit-bom:5.10.2"
+junit-jupiter-api.module = "org.junit.jupiter:junit-jupiter-api"
+junit-jupiter-params.module = "org.junit.jupiter:junit-jupiter-params"
+junit-jupiter-engine.module = "org.junit.jupiter:junit-jupiter-engine"
+
+spigot = "org.spigotmc:spigot-api:1.21-R0.1-SNAPSHOT"
+paperApi = "io.papermc.paper:paper-api:1.21-R0.1-SNAPSHOT"
+paperLib = "io.papermc:paperlib:1.0.8"
+
+dummypermscompat = "com.sk89q:dummypermscompat:1.10"
+bstats-bukkit = "org.bstats:bstats-bukkit:2.2.1"
+
+prtree = "org.khelekore:prtree:1.5.0"
+
+flyway-core = "org.flywaydb:flyway-core:3.0"
+
+commandbook = "com.sk89q:commandbook:2.3"
+
+hamcrest-library = "org.hamcrest:hamcrest-library:2.2"
+
+# Mojang-provided libraries, CHECK AGAINST MINECRAFT for versions
+guava = "com.google.guava:guava:32.1.3-jre!!"
+log4j-bom = "org.apache.logging.log4j:log4j-bom:2.22.1!!"
+gson = "com.google.code.gson:gson:2.10.1!!"
+fastutil = "it.unimi.dsi:fastutil:8.5.12!!"
+
+# Bukkit-provided libraries, CHECK AGAINST SPIGOT for versions
+# Note that we need to balance support for older MC versus working at all on newer ones, so the exact versions here
+# may not be the same as the ones in the latest Bukkit API.
+snakeyaml = "org.yaml:snakeyaml:2.0"
+
+[libraries.worldedit-core]
+module = "com.sk89q.worldedit:worldedit-core"
+version.ref = "worldedit"
+
+[libraries.worldedit-bukkit]
+module = "com.sk89q.worldedit:worldedit-bukkit"
+version.ref = "worldedit"
+
+[libraries.worldedit-libs-ap]
+module = "com.sk89q.worldedit.worldedit-libs:ap"
+version.ref = "worldedit"
@@ -0,0 +1,7 @@
+distributionBase=GRADLE_USER_HOME
+distributionPath=wrapper/dists
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.8-bin.zip
+networkTimeout=10000
+validateDistributionUrl=true
+zipStoreBase=GRADLE_USER_HOME
+zipStorePath=wrapper/dists
@@ -0,0 +1,249 @@
+#!/bin/sh
+
+#
+# Copyright © 2015-2021 the original authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+##############################################################################
+#
+#   Gradle start up script for POSIX generated by Gradle.
+#
+#   Important for running:
+#
+#   (1) You need a POSIX-compliant shell to run this script. If your /bin/sh is
+#       noncompliant, but you have some other compliant shell such as ksh or
+#       bash, then to run this script, type that shell name before the whole
+#       command line, like:
+#
+#           ksh Gradle
+#
+#       Busybox and similar reduced shells will NOT work, because this script
+#       requires all of these POSIX shell features:
+#         * functions;
+#         * expansions «$var», «${var}», «${var:-default}», «${var+SET}»,
+#           «${var#prefix}», «${var%suffix}», and «$( cmd )»;
+#         * compound commands having a testable exit status, especially «case»;
+#         * various built-in commands including «command», «set», and «ulimit».
+#
+#   Important for patching:
+#
+#   (2) This script targets any POSIX shell, so it avoids extensions provided
+#       by Bash, Ksh, etc; in particular arrays are avoided.
+#
+#       The "traditional" practice of packing multiple parameters into a
+#       space-separated string is a well documented source of bugs and security
+#       problems, so this is (mostly) avoided, by progressively accumulating
+#       options in "$@", and eventually passing that to Java.
+#
+#       Where the inherited environment variables (DEFAULT_JVM_OPTS, JAVA_OPTS,
+#       and GRADLE_OPTS) rely on word-splitting, this is performed explicitly;
+#       see the in-line comments for details.
+#
+#       There are tweaks for specific operating systems such as AIX, CygWin,
+#       Darwin, MinGW, and NonStop.
+#
+#   (3) This script is generated from the Groovy template
+#       https://github.com/gradle/gradle/blob/HEAD/subprojects/plugins/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt
+#       within the Gradle project.
+#
+#       You can find Gradle at https://github.com/gradle/gradle/.
+#
+##############################################################################
+
+# Attempt to set APP_HOME
+
+# Resolve links: $0 may be a link
+app_path=$0
+
+# Need this for daisy-chained symlinks.
+while
+    APP_HOME=${app_path%"${app_path##*/}"}  # leaves a trailing /; empty if no leading path
+    [ -h "$app_path" ]
+do
+    ls=$( ls -ld "$app_path" )
+    link=${ls#*' -> '}
+    case $link in             #(
+      /*)   app_path=$link ;; #(
+      *)    app_path=$APP_HOME$link ;;
+    esac
+done
+
+# This is normally unused
+# shellcheck disable=SC2034
+APP_BASE_NAME=${0##*/}
+# Discard cd standard output in case $CDPATH is set (https://github.com/gradle/gradle/issues/25036)
+APP_HOME=$( cd "${APP_HOME:-./}" > /dev/null && pwd -P ) || exit
+
+# Use the maximum available, or set MAX_FD != -1 to use that value.
+MAX_FD=maximum
+
+warn () {
+    echo "$*"
+} >&2
+
+die () {
+    echo
+    echo "$*"
+    echo
+    exit 1
+} >&2
+
+# OS specific support (must be 'true' or 'false').
+cygwin=false
+msys=false
+darwin=false
+nonstop=false
+case "$( uname )" in                #(
+  CYGWIN* )         cygwin=true  ;; #(
+  Darwin* )         darwin=true  ;; #(
+  MSYS* | MINGW* )  msys=true    ;; #(
+  NONSTOP* )        nonstop=true ;;
+esac
+
+CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
+
+
+# Determine the Java command to use to start the JVM.
+if [ -n "$JAVA_HOME" ] ; then
+    if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
+        # IBM's JDK on AIX uses strange locations for the executables
+        JAVACMD=$JAVA_HOME/jre/sh/java
+    else
+        JAVACMD=$JAVA_HOME/bin/java
+    fi
+    if [ ! -x "$JAVACMD" ] ; then
+        die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+    fi
+else
+    JAVACMD=java
+    if ! command -v java >/dev/null 2>&1
+    then
+        die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+    fi
+fi
+
+# Increase the maximum file descriptors if we can.
+if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then
+    case $MAX_FD in #(
+      max*)
+        # In POSIX sh, ulimit -H is undefined. That's why the result is checked to see if it worked.
+        # shellcheck disable=SC2039,SC3045
+        MAX_FD=$( ulimit -H -n ) ||
+            warn "Could not query maximum file descriptor limit"
+    esac
+    case $MAX_FD in  #(
+      '' | soft) :;; #(
+      *)
+        # In POSIX sh, ulimit -n is undefined. That's why the result is checked to see if it worked.
+        # shellcheck disable=SC2039,SC3045
+        ulimit -n "$MAX_FD" ||
+            warn "Could not set maximum file descriptor limit to $MAX_FD"
+    esac
+fi
+
+# Collect all arguments for the java command, stacking in reverse order:
+#   * args from the command line
+#   * the main class name
+#   * -classpath
+#   * -D...appname settings
+#   * --module-path (only if needed)
+#   * DEFAULT_JVM_OPTS, JAVA_OPTS, and GRADLE_OPTS environment variables.
+
+# For Cygwin or MSYS, switch paths to Windows format before running java
+if "$cygwin" || "$msys" ; then
+    APP_HOME=$( cygpath --path --mixed "$APP_HOME" )
+    CLASSPATH=$( cygpath --path --mixed "$CLASSPATH" )
+
+    JAVACMD=$( cygpath --unix "$JAVACMD" )
+
+    # Now convert the arguments - kludge to limit ourselves to /bin/sh
+    for arg do
+        if
+            case $arg in                                #(
+              -*)   false ;;                            # don't mess with options #(
+              /?*)  t=${arg#/} t=/${t%%/*}              # looks like a POSIX filepath
+                    [ -e "$t" ] ;;                      #(
+              *)    false ;;
+            esac
+        then
+            arg=$( cygpath --path --ignore --mixed "$arg" )
+        fi
+        # Roll the args list around exactly as many times as the number of
+        # args, so each arg winds up back in the position where it started, but
+        # possibly modified.
+        #
+        # NB: a `for` loop captures its iteration list before it begins, so
+        # changing the positional parameters here affects neither the number of
+        # iterations, nor the values presented in `arg`.
+        shift                   # remove old arg
+        set -- "$@" "$arg"      # push replacement arg
+    done
+fi
+
+
+# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
+
+# Collect all arguments for the java command:
+#   * DEFAULT_JVM_OPTS, JAVA_OPTS, JAVA_OPTS, and optsEnvironmentVar are not allowed to contain shell fragments,
+#     and any embedded shellness will be escaped.
+#   * For example: A user cannot expect ${Hostname} to be expanded, as it is an environment variable and will be
+#     treated as '${Hostname}' itself on the command line.
+
+set -- \
+        "-Dorg.gradle.appname=$APP_BASE_NAME" \
+        -classpath "$CLASSPATH" \
+        org.gradle.wrapper.GradleWrapperMain \
+        "$@"
+
+# Stop when "xargs" is not available.
+if ! command -v xargs >/dev/null 2>&1
+then
+    die "xargs is not available"
+fi
+
+# Use "xargs" to parse quoted args.
+#
+# With -n1 it outputs one arg per line, with the quotes and backslashes removed.
+#
+# In Bash we could simply go:
+#
+#   readarray ARGS < <( xargs -n1 <<<"$var" ) &&
+#   set -- "${ARGS[@]}" "$@"
+#
+# but POSIX shell has neither arrays nor command substitution, so instead we
+# post-process each arg (as a line of input to sed) to backslash-escape any
+# character that might be a shell metacharacter, then use eval to reverse
+# that process (while maintaining the separation between arguments), and wrap
+# the whole thing up as a single "set" statement.
+#
+# This will of course break if any of these variables contains a newline or
+# an unmatched quote.
+#
+
+eval "set -- $(
+        printf '%s\n' "$DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS" |
+        xargs -n1 |
+        sed ' s~[^-[:alnum:]+,./:=@_]~\\&~g; ' |
+        tr '\n' ' '
+    )" '"$@"'
+
+exec "$JAVACMD" "$@"
@@ -0,0 +1,92 @@
+@rem
+@rem Copyright 2015 the original author or authors.
+@rem
+@rem Licensed under the Apache License, Version 2.0 (the "License");
+@rem you may not use this file except in compliance with the License.
+@rem You may obtain a copy of the License at
+@rem
+@rem      https://www.apache.org/licenses/LICENSE-2.0
+@rem
+@rem Unless required by applicable law or agreed to in writing, software
+@rem distributed under the License is distributed on an "AS IS" BASIS,
+@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+@rem See the License for the specific language governing permissions and
+@rem limitations under the License.
+@rem
+
+@if "%DEBUG%"=="" @echo off
+@rem ##########################################################################
+@rem
+@rem  Gradle startup script for Windows
+@rem
+@rem ##########################################################################
+
+@rem Set local scope for the variables with windows NT shell
+if "%OS%"=="Windows_NT" setlocal
+
+set DIRNAME=%~dp0
+if "%DIRNAME%"=="" set DIRNAME=.
+@rem This is normally unused
+set APP_BASE_NAME=%~n0
+set APP_HOME=%DIRNAME%
+
+@rem Resolve any "." and ".." in APP_HOME to make it shorter.
+for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi
+
+@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m"
+
+@rem Find java.exe
+if defined JAVA_HOME goto findJavaFromJavaHome
+
+set JAVA_EXE=java.exe
+%JAVA_EXE% -version >NUL 2>&1
+if %ERRORLEVEL% equ 0 goto execute
+
+echo. 1>&2
+echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. 1>&2
+echo. 1>&2
+echo Please set the JAVA_HOME variable in your environment to match the 1>&2
+echo location of your Java installation. 1>&2
+
+goto fail
+
+:findJavaFromJavaHome
+set JAVA_HOME=%JAVA_HOME:"=%
+set JAVA_EXE=%JAVA_HOME%/bin/java.exe
+
+if exist "%JAVA_EXE%" goto execute
+
+echo. 1>&2
+echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME% 1>&2
+echo. 1>&2
+echo Please set the JAVA_HOME variable in your environment to match the 1>&2
+echo location of your Java installation. 1>&2
+
+goto fail
+
+:execute
+@rem Setup the command line
+
+set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
+
+
+@rem Execute Gradle
+"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %*
+
+:end
+@rem End local scope for the variables with windows NT shell
+if %ERRORLEVEL% equ 0 goto mainEnd
+
+:fail
+rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
+rem the _cmd.exe /c_ return code!
+set EXIT_CODE=%ERRORLEVEL%
+if %EXIT_CODE% equ 0 set EXIT_CODE=1
+if not ""=="%GRADLE_EXIT_CONSOLE%" exit %EXIT_CODE%
+exit /b %EXIT_CODE%
+
+:mainEnd
+if "%OS%"=="Windows_NT" endlocal
+
+:omega
@@ -1,528 +0,0 @@
-<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
-  <modelVersion>4.0.0</modelVersion>
-  <groupId>com.sk89q</groupId>
-  <artifactId>worldguard</artifactId>
-  <version>6.0.0-beta-01</version>
-  <packaging>jar</packaging>
-  
-  <!-- Project information -->
-  <name>WorldGuard</name>
-  <description>WorldGuard protects your Minecraft servers.</description>
-  <licenses>
-    <license>
-      <name>GNU General Public License 2.0</name>
-      <url>LICENSE.txt</url>
-      <distribution>repo</distribution>
-      <comments>License on all contributions</comments>
-    </license>
-  </licenses>
-  
-  <issueManagement>
-    <system>YouTrack</system>
-    <url>http://youtrack.sk89q.com</url>
-  </issueManagement>
-  
-  <ciManagement>
-    <system>Jenkins</system>
-    <url>http://build.sk89q.com</url>
-  </ciManagement>
-  
-  <scm>
-    <connection>scm:git:git://github.com/sk89q/worldguard.git</connection>
-    <developerConnection>scm:git:git@github.com:sk89q/worldguard.git</developerConnection>
-    <url>https://github.com/sk89q/worldguard</url>
-    <tag>master</tag>
-  </scm>
-  
-  <mailingLists>
-    <mailingList>
-      <name>Developer Discussion</name>
-      <archive>https://groups.google.com/d/forum/sk-dev-discuss</archive>
-    </mailingList>
-  </mailingLists>
-  
-  <distributionManagement>
-    <site>
-      <id>sk89q-docs-upload</id>
-      <url>ftp://sk89q-maven-deploy/worldguard/</url>
-    </site>
-    <repository>
-      <id>maven.sk89q.com</id>
-      <url>http://maven.sk89q.com/artifactory/libs-release-local</url>
-    </repository>
-    <snapshotRepository>
-      <id>maven.sk89q.com-snapshot</id>
-      <url>http://maven.sk89q.com/artifactory/libs-snapshot-local</url>
-    </snapshotRepository>
-  </distributionManagement>
-  
-  <properties> <!-- Fix encoding warnings -->
-    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
-  </properties>
-  
-  <repositories>
-    <repository>
-      <id>sk89q-repo</id>
-      <url>http://maven.sk89q.com/repo/</url>
-    </repository>
-    <repository>
-      <id>bukkit-repo</id>
-      <url>http://repo.bukkit.org/content/groups/public</url>
-    </repository>
-  </repositories>
-  
-  <dependencies>
-    <dependency>
-      <groupId>com.sk89q</groupId>
-      <artifactId>worldedit</artifactId>
-      <version>5.5.8</version>
-      <scope>compile</scope>
-      <type>jar</type>
-      <exclusions>
-        <exclusion>
-          <groupId>com.zachsthings.libcomponents</groupId>
-          <artifactId>libcomponents-bukkit</artifactId>
-        </exclusion>
-        <exclusion>
-          <groupId>org.bukkit</groupId>
-          <artifactId>bukkit</artifactId>
-        </exclusion>
-      </exclusions>
-    </dependency>
-
-    <!-- Used for running CraftBukkit from within your IDE
-         These are runtime-only dependencies -->
-    <dependency>
-      <groupId>org.sk89q.bukkit</groupId>
-      <artifactId>bukkit-classloader-check</artifactId>
-      <version>1.7.9-R0.2</version>
-      <scope>runtime</scope>
-      <type>jar</type>
-      <optional>true</optional>
-    </dependency>
-    <dependency>
-      <groupId>org.bukkit</groupId>
-      <artifactId>craftbukkit</artifactId>
-      <version>1.7.9-R0.2</version>
-      <scope>runtime</scope>
-      <type>jar</type>
-      <optional>true</optional>
-    </dependency>
-    <!-- End runtime only -->
-
-    <dependency>
-      <groupId>org.bukkit</groupId>
-      <artifactId>bukkit</artifactId>
-      <version>1.7.9-R0.2</version>
-      <scope>compile</scope>
-      <type>jar</type>
-    </dependency>
-    
-    <dependency>
-      <groupId>com.sk89q</groupId>
-      <artifactId>commandbook</artifactId>
-      <version>2.3</version>
-      <scope>compile</scope>
-      <type>jar</type>
-      <exclusions>
-        <exclusion>
-          <groupId>com.zachsthings.libcomponents</groupId>
-          <artifactId>libcomponents-bukkit</artifactId>
-        </exclusion>
-        <exclusion>
-          <groupId>org.spout</groupId>
-          <artifactId>spoutapi</artifactId>
-        </exclusion>
-        <exclusion>
-          <groupId>org.bukkit</groupId>
-          <artifactId>bukkit</artifactId>
-        </exclusion>
-      </exclusions>
-    </dependency>
-    
-    <dependency>
-      <groupId>com.nijikokun</groupId>
-      <artifactId>iconomy</artifactId>
-      <version>5.0</version>
-      <scope>compile</scope>
-      <type>jar</type>
-      <optional>true</optional>
-    </dependency>
-
-    <dependency>
-      <groupId>com.google.guava</groupId>
-      <artifactId>guava</artifactId>
-      <version>10.0.1</version> <!-- Bukkit only bundles 10.0.1 -->
-      <scope>compile</scope> <!-- required runtime dependency -->
-      <type>jar</type>
-    </dependency>
-
-    <dependency>
-      <groupId>com.google.code.findbugs</groupId>
-      <artifactId>jsr305</artifactId>
-      <version>1.3.9</version>
-      <scope>compile</scope>
-      <type>jar</type>
-    </dependency>
-    
-    <dependency>
-      <groupId>org.khelekore</groupId>
-      <artifactId>prtree</artifactId>
-      <version>1.5.0</version>
-      <scope>compile</scope>
-      <type>jar</type>
-    </dependency>
-    
-    <dependency>
-      <groupId>net.sf.opencsv</groupId>
-      <artifactId>opencsv</artifactId>
-      <version>2.0</version>
-      <scope>compile</scope>
-      <type>jar</type>
-      <optional>true</optional>
-    </dependency>
-
-    <dependency>
-      <groupId>org.flywaydb</groupId>
-      <artifactId>flyway-core</artifactId>
-      <version>3.0</version>
-      <scope>compile</scope>
-      <type>jar</type>
-      <optional>true</optional>
-    </dependency>
-
-    <dependency>
-      <groupId>com.sk89q</groupId>
-      <artifactId>squirrelid</artifactId>
-      <version>0.1.0</version>
-      <scope>compile</scope>
-      <type>jar</type>
-      <optional>true</optional>
-    </dependency>
-
-    <dependency>
-      <groupId>junit</groupId>
-      <artifactId>junit</artifactId>
-      <version>4.11</version>
-      <scope>test</scope>
-      <type>jar</type>
-      <exclusions>
-        <exclusion>
-          <groupId>org.hamcrest</groupId>
-          <artifactId>hamcrest-core</artifactId>
-        </exclusion>
-      </exclusions>
-    </dependency>
-
-    <dependency>
-      <groupId>org.hamcrest</groupId>
-      <artifactId>hamcrest-library</artifactId>
-      <version>1.2.1</version>
-      <scope>test</scope>
-      <optional>true</optional>
-    </dependency>
-  </dependencies>
-  
-  <build>
-    <defaultGoal>install</defaultGoal>
-    <sourceDirectory>${basedir}/src/main/java</sourceDirectory>
-    
-    <extensions> <!-- Used for uploading the docs -->
-      <extension>
-        <groupId>org.apache.maven.wagon</groupId>
-         <artifactId>wagon-ftp</artifactId>
-         <version>1.0-beta-6</version>
-      </extension>
-    </extensions>
-
-    <resources>
-      <resource>
-        <targetPath>.</targetPath>
-        <filtering>true</filtering>
-        <directory>${basedir}/src/main/resources/</directory>
-        <includes>
-          <include>plugin.yml</include>
-        </includes>
-      </resource>
-      <resource>
-        <targetPath>defaults/</targetPath>
-        <filtering>true</filtering>
-        <directory>${basedir}/src/main/resources/</directory>
-        <includes>
-          <include>config.yml</include>
-          <include>config_world.yml</include>
-          <include>blacklist.txt</include>
-        </includes>
-      </resource>
-      <resource>
-        <targetPath>migrations/</targetPath>
-        <filtering>false</filtering>
-        <directory>${basedir}/src/main/resources/migrations/</directory>
-      </resource>
-    </resources>
-
-    <plugins>
-      <!-- Check style -->
-      <plugin>
-        <groupId>org.apache.maven.plugins</groupId>
-        <artifactId>maven-checkstyle-plugin</artifactId>
-        <version>2.12</version>
-        <executions>
-          <execution>
-            <id>verify-style</id>
-            <phase>validate</phase>
-            <goals>
-              <goal>check</goal>
-            </goals>
-          </execution>
-        </executions>
-        <configuration>
-          <sourceDirectory>${basedir}/src</sourceDirectory>
-          <consoleOutput>true</consoleOutput>
-          <failsOnError>true</failsOnError>
-          <logViolationsToConsole>true</logViolationsToConsole>
-          <checkstyleRules>
-            <module name="Checker">
-              <!-- Tabs are strictly banned -->
-              <module name="FileTabCharacter"/>
-
-              <module name="TreeWalker">
-                <!-- Important basics -->
-                <!-- <module name="PackageDeclaration"/> Unlikely that we would miss this in a PR -->
-                <module name="OuterTypeFilename"/> <!-- TypeName -> TypeName.java -->
-
-                <!--
-                Control package usage, so people don't insert Bukkit into WE where it shouldn't belong, etc.
-                It is a bit draconian, so update as necessary!
-                -->
-                <module name="ImportControl">
-                  <property name="file" value="${basedir}/config/checkstyle/import-control.xml"/>
-                </module>
-
-                <!-- Code -->
-                <module name="HideUtilityClassConstructor"/> <!-- Utility classes should not have a constructor -->
-                <module name="CovariantEquals"/>
-                <module name="EqualsHashCode"/> <!-- equals() and hashCode() go together -->
-                <module name="NestedTryDepth"> <!-- SHOULD not need to adjust this -->
-                  <property name="max" value="2"/>
-                </module>
-                <module name="SuperFinalize"/> <!-- We don't actually use this -->
-                <module name="JUnitTestCase"/> <!-- Checks tearDown(), setUp() etc. -->
-
-                <!-- Style -->
-                <module name="LeftCurly"> <!-- Left brace never goes on another line -->
-                  <property name="option" value="eol"/>
-                </module> <!-- We don't check right brance -->
-                <module name="DefaultComesLast"/> <!-- default case in switch should be last -->
-                <module name="GenericWhitespace"/>
-
-                <!-- Naming -->
-                <module name="ClassTypeParameterName">
-                  <property name="format" value="^[A-Z][a-zA-Z0-9]*$"/>
-                </module>
-                <module name="LocalFinalVariableName"/>
-                <module name="LocalVariableName">
-                  <property name="format" value="^[a-z_][a-zA-Z0-9]*$"/>
-                </module>
-                <module name="MemberName">
-                  <property name="format" value="^[a-z_][a-zA-Z0-9]*$"/>
-                </module>
-                <module name="MethodName">
-                  <property name="format" value="^[a-z][a-zA-Z0-9]*$"/>
-                </module>
-                <!-- <module name="PackageName"/> Unlikely that we would miss this in a PR -->
-                <module name="ParameterName"/>
-                <!-- <module name="TypeName"/> Unlikely that we would miss this in a PR -->
-              </module>
-
-              <!-- Require the header, something that many people forget and we hate to fix -->
-              <!-- You should configure the header in your IDE -->
-              <module name="Header">
-                <property name="headerFile" value="${basedir}/config/checkstyle/header.txt"/>
-                <property name="fileExtensions" value="java"/>
-              </module>
-            </module>
-          </checkstyleRules>
-        </configuration>
-      </plugin>
-
-      <plugin>
-        <groupId>org.apache.maven.plugins</groupId>
-        <artifactId>maven-compiler-plugin</artifactId>
-        <version>2.3.2</version>
-        <configuration>
-          <source>1.6</source>
-          <target>1.6</target>
-        </configuration>
-      </plugin>
-      
-      <plugin>
-        <groupId>org.apache.maven.plugins</groupId>
-        <artifactId>maven-jar-plugin</artifactId>
-        <version>2.3.1</version>
-        <configuration>
-          <archive>
-            <addMavenDescriptor>true</addMavenDescriptor>
-            <manifest>
-              <addDefaultSpecificationEntries>true</addDefaultSpecificationEntries>
-              <addDefaultImplementationEntries>true</addDefaultImplementationEntries>
-            </manifest>
-            <manifestEntries>
-              <Class-Path>WorldGuard/WorldEdit.jar lib/WorldEdit.jar ../lib/WorldEdit.jar ../WorldEdit.jar</Class-Path>
-            </manifestEntries>
-          </archive>
-        </configuration>
-      </plugin>
-      
-      <plugin>
-        <groupId>org.apache.maven.plugins</groupId>
-        <artifactId>maven-shade-plugin</artifactId>
-        <version>1.4</version>
-        <executions>
-          <execution>
-            <phase>package</phase>
-            <goals>
-              <goal>shade</goal>
-            </goals>
-            <configuration>
-              <artifactSet>
-                <includes>
-                  <include>net.sf.opencsv:opencsv</include>
-                  <include>org.khelekore:prtree</include>
-                  <include>org.flywaydb:flyway-core</include>
-                  <include>com.sk89q:squirrelid</include>
-                </includes>
-              </artifactSet>
-              <relocations>
-                <relocation>
-                  <pattern>org.flywaydb</pattern>
-                  <shadedPattern>com.sk89q.worldguard.internal.flywaydb</shadedPattern>
-                </relocation>
-                <relocation>
-                  <pattern>com.sk89q.squirrelid</pattern>
-                  <shadedPattern>com.sk89q.worldguard.util.profile</shadedPattern>
-                </relocation>
-              </relocations>
-            </configuration>
-          </execution>
-        </executions>
-      </plugin>
-
-      <plugin>
-        <groupId>com.ruleoftech</groupId>
-        <artifactId>markdown-page-generator-plugin</artifactId>
-        <version>0.4</version>
-        <executions>
-          <execution>
-            <phase>package</phase>
-            <goals>
-              <goal>generate</goal>
-            </goals>
-          </execution>
-        </executions>
-        <configuration>
-          <inputDirectory>${basedir}</inputDirectory>
-          <outputDirectory>${project.build.directory}</outputDirectory>
-          <headerHtmlFile>${project.basedir}/config/markdown/header.html</headerHtmlFile>
-          <footerHtmlFile>${project.basedir}/config/markdown/footer.html</footerHtmlFile>
-        </configuration>
-      </plugin>
-      
-      <plugin>
-        <artifactId>maven-assembly-plugin</artifactId>
-        <version>2.2-beta-2</version>
-        <configuration>
-          <descriptor>${basedir}/config/assembly/default.xml</descriptor>
-        </configuration>
-        <executions>
-          <execution>
-            <id>release</id>
-            <phase>package</phase>
-            <goals>
-              <goal>single</goal>
-            </goals>
-          </execution>
-        </executions>
-      </plugin>
-      
-      <plugin>
-        <groupId>org.apache.maven.plugins</groupId>
-        <artifactId>maven-release-plugin</artifactId>
-        <version>2.4.1</version>
-        <configuration>
-          <preparationGoals>assembly:assembly</preparationGoals>
-          <goals>assembly:assembly</goals>
-          <tagNameFormat>@{project.version}</tagNameFormat>
-        </configuration>
-      </plugin>
-
-      <plugin>
-        <groupId>org.apache.maven.plugins</groupId>
-        <artifactId>maven-site-plugin</artifactId>
-        <version>3.1</version>
-        <configuration>
-          <reportPlugins>
-            <plugin>
-              <groupId>org.apache.maven.plugins</groupId>
-              <artifactId>maven-project-info-reports-plugin</artifactId>
-              <version>2.5</version>
-              <reportSets>
-                <reportSet>
-                  <reports>
-                    <report>license</report>
-                    <report>index</report>
-                  </reports>
-                </reportSet>
-              </reportSets>
-            </plugin>
-            
-            <plugin>
-              <groupId>org.apache.maven.plugins</groupId>
-              <artifactId>maven-javadoc-plugin</artifactId>
-              <version>2.8.1</version>
-            </plugin>
-          </reportPlugins>
-        </configuration>
-      </plugin>
-    </plugins>
-  </build>
-  
-  <profiles>
-    <!-- Attach javadocs and source .jars -->
-    <profile>
-      <id>attach-docs</id>
-      
-      <build>
-        <plugins>
-          <plugin>
-            <groupId>org.apache.maven.plugins</groupId>
-            <artifactId>maven-source-plugin</artifactId>
-            <version>2.2.1</version>
-            <executions>
-              <execution>
-                <id>attach-sources</id>
-                <goals>
-                  <goal>jar</goal>
-                </goals>
-              </execution>
-            </executions>
-          </plugin>
-          
-          <plugin>
-            <groupId>org.apache.maven.plugins</groupId>
-            <artifactId>maven-javadoc-plugin</artifactId>
-            <version>2.8.1</version>
-            <executions>
-              <execution>
-                <id>attach-javadocs</id>
-                <goals>
-                  <goal>jar</goal>
-                </goals>
-              </execution>
-            </executions>
-          </plugin>
-        </plugins>
-      </build>
-    </profile>
-  </profiles>
-</project>
@@ -0,0 +1,33 @@
+pluginManagement {
+    repositories {
+        gradlePluginPortal()
+    }
+}
+plugins {
+    id("org.gradle.toolchains.foojay-resolver-convention") version "0.8.0"
+}
+
+logger.lifecycle("""
+*******************************************
+ You are building WorldGuard!
+
+ If you encounter trouble:
+ 1) Read COMPILING.md if you haven't yet
+ 2) Try running 'build' in a separate Gradle run
+ 3) Use gradlew and not gradle
+ 4) If you still need help, ask on Discord! https://discord.gg/enginehub
+
+ Output files will be in [subproject]/build/libs
+*******************************************
+""")
+
+rootProject.name = "worldguard"
+
+includeBuild("build-logic")
+
+include("worldguard-libs")
+include("worldguard-libs:core")
+
+listOf("bukkit", "core").forEach {
+    include("worldguard-$it")
+}
@@ -1,117 +0,0 @@
-/*
- * WorldGuard, a suite of tools for Minecraft
- * Copyright (C) sk89q <http://www.sk89q.com>
- * Copyright (C) WorldGuard team and contributors
- *
- * This program is free software: you can redistribute it and/or modify it
- * under the terms of the GNU Lesser General Public License as published by the
- * Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License
- * for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-package com.sk89q.worldguard;
-
-import com.sk89q.worldedit.Vector;
-import com.sk89q.worldguard.domains.Association;
-import com.sk89q.worldguard.protection.association.RegionAssociable;
-import com.sk89q.worldguard.protection.regions.ProtectedRegion;
-
-import java.util.UUID;
-
-public abstract class LocalPlayer implements RegionAssociable {
-
-    /**
-     * Get this player's name.
-     * 
-     * @return The player's name
-     */
-    public abstract String getName();
-
-    /**
-     * Get this player's unique ID.
-     *
-     * @return a UUID
-     */
-    public abstract UUID getUniqueId();
-    
-    /**
-     * Returns true if this player is inside a group.
-     * 
-     * @param group The group to check
-     * @return Whether this player is in {@code group}
-     */
-    public abstract boolean hasGroup(String group);
-    
-    /**
-     * Get this player's position.
-     * 
-     * @return The player's position
-     */
-    public abstract Vector getPosition();
-    
-    /**
-     * Kick this player.
-     * 
-     * @param msg The message to kick the player with
-     */
-    public abstract void kick(String msg);
-    
-    /**
-     * Ban this player.
-     * 
-     * @param msg The message to ban the player with
-     */
-    public abstract void ban(String msg);
-    
-    /**
-     * Send this player a message.
-     * 
-     * @param msg The message to send to the player
-     */
-    public abstract void printRaw(String msg);
-    
-    /**
-     * Get this player's list of groups.
-     * 
-     * @return The groups this player is in
-     */
-    public abstract String[] getGroups();
-    
-    /**
-     * Returns whether this player has permission.
-     * 
-     * @param perm The permission to check
-     * @return Whether this player has {@code perm}
-     */
-    public abstract boolean hasPermission(String perm);
-
-    @Override
-    public Association getAssociation(ProtectedRegion region) {
-        if (region.isOwner(this)) {
-            return Association.OWNER;
-        } else if (region.isMember(this)) {
-            return Association.MEMBER;
-        } else {
-            return Association.NON_MEMBER;
-        }
-    }
-
-    @Override
-    public boolean equals(Object obj) {
-        return obj instanceof LocalPlayer && ((LocalPlayer) obj).getName().equals(getName());
-    }
-    
-    @Override
-    public int hashCode() {
-        return getName().hashCode();
-    }
-
-}
@@ -1,115 +0,0 @@
-/*
- * WorldGuard, a suite of tools for Minecraft
- * Copyright (C) sk89q <http://www.sk89q.com>
- * Copyright (C) WorldGuard team and contributors
- *
- * This program is free software: you can redistribute it and/or modify it
- * under the terms of the GNU Lesser General Public License as published by the
- * Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License
- * for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-package com.sk89q.worldguard.blacklist.target;
-
-import com.google.common.base.Predicate;
-import com.google.common.base.Predicates;
-import com.google.common.collect.Ranges;
-import com.sk89q.worldedit.blocks.ItemType;
-
-import java.util.ArrayList;
-import java.util.List;
-import java.util.regex.Matcher;
-import java.util.regex.Pattern;
-
-public class TargetMatcherParser {
-
-    private static final Pattern DATA_VALUE_PATTERN = Pattern.compile("^([^:]+):([^:]+)$");
-    private static final Pattern LESS_THAN_PATTERN = Pattern.compile("^<=\\s*([0-9]+)$");
-    private static final Pattern GREATER_THAN_PATTERN = Pattern.compile("^>=\\s*([0-9]+)$");
-    private static final Pattern RANGE_PATTERN = Pattern.compile("^([0-9]+)\\s*-\\s*([0-9]+)$");
-
-    public TargetMatcher fromInput(String input) throws TargetMatcherParseException {
-        Matcher matcher = DATA_VALUE_PATTERN.matcher(input.trim());
-        if (matcher.matches()) {
-            return new DataValueRangeMatcher(parseType(matcher.group(1)), parseDataValueRanges(matcher.group(2)));
-        } else {
-            return new WildcardDataMatcher(parseType(input));
-        }
-    }
-
-    private int parseType(String input) throws TargetMatcherParseException {
-        input = input.trim();
-
-        try {
-            return Integer.parseInt(input);
-        } catch (NumberFormatException e) {
-            int id = getItemID(input);
-            if (id == 0) {
-                throw new TargetMatcherParseException("Unknown block or item name: " + input);
-            }
-            return id;
-        }
-    }
-
-    private Predicate<Short> parseDataValueRanges(String input) throws TargetMatcherParseException {
-        List<Predicate<Short>> predicates = new ArrayList<Predicate<Short>>();
-
-        for (String part : input.split(";")) {
-            predicates.add(parseRange(part));
-        }
-
-        return Predicates.or(predicates);
-    }
-
-    private Predicate<Short> parseRange(String input) throws TargetMatcherParseException {
-        input = input.trim();
-
-        Matcher matcher;
-
-        matcher = LESS_THAN_PATTERN.matcher(input);
-        if (matcher.matches()) {
-            return Ranges.atMost(Short.parseShort(matcher.group(1)));
-        }
-
-        matcher = GREATER_THAN_PATTERN.matcher(input);
-        if (matcher.matches()) {
-            return Ranges.atLeast(Short.parseShort(matcher.group(1)));
-        }
-
-        matcher = RANGE_PATTERN.matcher(input);
-        if (matcher.matches()) {
-            return Ranges.closed(Short.parseShort(matcher.group(1)), Short.parseShort(matcher.group(2)));
-        }
-
-        try {
-            short s = Short.parseShort(input);
-            return Ranges.closed(s, s);
-        } catch (NumberFormatException e) {
-            throw new TargetMatcherParseException("Unknown data value range: " + input);
-        }
-    }
-
-    /**
-     * Get an item's ID from its name.
-     *
-     * @param name the name of the item to look up
-     * @return the id for name if contained in ItemId, else -1
-     */
-    private static int getItemID(String name) {
-        ItemType type = ItemType.lookup(name);
-        if (type != null) {
-            return type.getID();
-        } else {
-            return -1;
-        }
-    }
-
-}
@@ -1,111 +0,0 @@
-/*
- * WorldGuard, a suite of tools for Minecraft
- * Copyright (C) sk89q <http://www.sk89q.com>
- * Copyright (C) WorldGuard team and contributors
- *
- * This program is free software: you can redistribute it and/or modify it
- * under the terms of the GNU Lesser General Public License as published by the
- * Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License
- * for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-package com.sk89q.worldguard.bukkit;
-
-import org.bukkit.Location;
-import org.bukkit.entity.Player;
-
-import com.sk89q.worldedit.Vector;
-import com.sk89q.worldguard.LocalPlayer;
-
-import java.util.UUID;
-
-import static com.google.common.base.Preconditions.checkNotNull;
-
-public class BukkitPlayer extends LocalPlayer {
-
-    private final WorldGuardPlugin plugin;
-    private final Player player;
-    private final String name;
-    private final boolean silenced;
-
-    public BukkitPlayer(WorldGuardPlugin plugin, Player player) {
-        this(plugin, player, false);
-    }
-
-    BukkitPlayer(WorldGuardPlugin plugin, Player player, boolean silenced) {
-        checkNotNull(plugin);
-        checkNotNull(player);
-
-        this.plugin = plugin;
-        this.player = player;
-        // getName() takes longer than before in newer versions of Minecraft
-        this.name = player.getName();
-        this.silenced = silenced;
-    }
-
-    @Override
-    public String getName() {
-        return name;
-    }
-
-    @Override
-    public UUID getUniqueId() {
-        return player.getUniqueId();
-    }
-
-    @Override
-    public boolean hasGroup(String group) {
-        return plugin.inGroup(player, group);
-    }
-
-    @Override
-    public Vector getPosition() {
-        Location loc = player.getLocation();
-        return new Vector(loc.getX(), loc.getY(), loc.getZ());
-    }
-
-    @Override
-    public void kick(String msg) {
-        if (!silenced) {
-            player.kickPlayer(msg);
-        }
-    }
-
-    @Override
-    public void ban(String msg) {
-        if (!silenced) {
-            player.setBanned(true);
-            player.kickPlayer(msg);
-        }
-    }
-
-    @Override
-    public String[] getGroups() {
-        return plugin.getGroups(player);
-    }
-
-    @Override
-    public void printRaw(String msg) {
-        if (!silenced) {
-            player.sendMessage(msg);
-        }
-    }
-
-    @Override
-    public boolean hasPermission(String perm) {
-        return plugin.hasPermission(player, perm);
-    }
-
-    public Player getPlayer() {
-        return player;
-    }
-
-}
@@ -1,353 +0,0 @@
-/*
- * WorldGuard, a suite of tools for Minecraft
- * Copyright (C) sk89q <http://www.sk89q.com>
- * Copyright (C) WorldGuard team and contributors
- *
- * This program is free software: you can redistribute it and/or modify it
- * under the terms of the GNU Lesser General Public License as published by the
- * Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License
- * for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-package com.sk89q.worldguard.bukkit;
-
-import com.sk89q.worldedit.BlockVector;
-import com.sk89q.worldedit.Vector;
-import com.sk89q.worldedit.blocks.BlockID;
-import com.sk89q.worldedit.blocks.BlockType;
-import com.sk89q.worldedit.blocks.ItemID;
-import com.sk89q.worldguard.blacklist.target.MaterialTarget;
-import com.sk89q.worldguard.blacklist.target.Target;
-import org.bukkit.ChatColor;
-import org.bukkit.Location;
-import org.bukkit.Material;
-import org.bukkit.Server;
-import org.bukkit.World;
-import org.bukkit.block.Block;
-import org.bukkit.entity.Entity;
-import org.bukkit.entity.ExperienceOrb;
-import org.bukkit.entity.FallingBlock;
-import org.bukkit.entity.Item;
-import org.bukkit.entity.LivingEntity;
-import org.bukkit.entity.Player;
-import org.bukkit.entity.TNTPrimed;
-import org.bukkit.entity.Tameable;
-import org.bukkit.inventory.ItemStack;
-
-import java.util.List;
-
-import static com.google.common.base.Preconditions.checkNotNull;
-
-public class BukkitUtil {
-
-    private BukkitUtil()  {
-
-    }
-
-    /**
-     * Converts the location of a Bukkit block to a WorldEdit vector.
-     *
-     * @param block The block to convert
-     * @return The block's location as a BlockVector
-     */
-    public static BlockVector toVector(Block block) {
-        return new BlockVector(block.getX(), block.getY(), block.getZ());
-    }
-
-    /**
-     * Converts a Bukkit location to a WorldEdit vector.
-     *
-     * @param loc A Bukkit Location
-     * @return A Vector with the location's x, y, and z values
-     */
-    public static Vector toVector(Location loc) {
-        return new Vector(loc.getX(), loc.getY(), loc.getZ());
-    }
-
-    /**
-     * Converts a Bukkit vector to a WorldEdit vector.
-     *
-     * @param vector The Bukkit vector
-     * @return A WorldEdit vector with the same values as the Bukkit vector.
-     */
-    public static Vector toVector(org.bukkit.util.Vector vector) {
-        return new Vector(vector.getX(), vector.getY(), vector.getZ());
-    }
-
-    /**
-     * Converts a WorldEdit vector to a Bukkit location.
-     *
-     * @param world The World to create the new Location with
-     * @param vec The vector to use for coordinates
-     * @return The Vector as a location with a World of world
-     */
-    public static Location toLocation(World world, Vector vec) {
-        return new Location(world, vec.getX(), vec.getY(), vec.getZ());
-    }
-
-    /**
-     * Matches one player based on name.
-     *
-     * @param server The server to check
-     * @param name The name to attempt to match
-     * @deprecated see {@link WorldGuardPlugin#matchSinglePlayer(org.bukkit.command.CommandSender, String)}
-     * @return The matched player if any, otherwise null
-     */
-    @Deprecated
-    public static Player matchSinglePlayer(Server server, String name) {
-        List<Player> players = server.matchPlayer(name);
-        if (players.size() == 0) {
-            return null;
-        }
-        return players.get(0);
-    }
-
-    /**
-     * Drops a sign item and removes a sign.
-     *
-     * @param block The block
-     * @deprecated see {@link org.bukkit.block.Block#breakNaturally()}
-     */
-    @Deprecated
-    public static void dropSign(Block block) {
-        block.setTypeId(0);
-        block.getWorld().dropItemNaturally(block.getLocation(),
-                new ItemStack(ItemID.SIGN, 1));
-    }
-
-    /**
-     * Sets the given block to fluid water.
-     * Used by addSpongeWater()
-     *
-     * @param world
-     * @param ox
-     * @param oy
-     * @param oz
-     */
-    public static void setBlockToWater(World world, int ox, int oy, int oz) {
-        Block block = world.getBlockAt(ox, oy, oz);
-        int id = block.getTypeId();
-        if (id == 0) {
-            block.setTypeId(8);
-        }
-    }
-
-    /**
-     * Checks if the given block is water
-     *
-     * @param world the world
-     * @param ox x
-     * @param oy y
-     * @param oz z
-     * @return true if it's water
-     */
-    public static boolean isBlockWater(World world, int ox, int oy, int oz) {
-        Block block = world.getBlockAt(ox, oy, oz);
-        int id = block.getTypeId();
-        return id == 8 || id == 9;
-    }
-
-    /**
-     * Checks if the given potion is a vial of water.
-     *
-     * @param item the item to check
-     * @return true if it's a water vial
-     */
-    public static boolean isWaterPotion(ItemStack item) {
-        return (item.getDurability() & 0x3F) == 0;
-    }
-
-    /**
-     * Get just the potion effect bits. This is to work around bugs with potion
-     * parsing.
-     *
-     * @param item item
-     * @return new bits
-     */
-    public static int getPotionEffectBits(ItemStack item) {
-        return item.getDurability() & 0x3F;
-    }
-
-    /**
-     * Find a position for the player to stand that is not inside a block.
-     * Blocks above the player will be iteratively tested until there is
-     * a series of two free blocks. The player will be teleported to
-     * that free position.
-     *
-     * @param player
-     */
-    public static void findFreePosition(Player player) {
-        Location loc = player.getLocation();
-        int x = loc.getBlockX();
-        int y = Math.max(0, loc.getBlockY());
-        int origY = y;
-        int z = loc.getBlockZ();
-        World world = player.getWorld();
-
-        byte free = 0;
-
-        while (y <= world.getMaxHeight() + 1) {
-            if (BlockType.canPassThrough(world.getBlockTypeIdAt(x, y, z))) {
-                free++;
-            } else {
-                free = 0;
-            }
-
-            if (free == 2) {
-                if (y - 1 != origY || y == 1) {
-                    loc.setX(x + 0.5);
-                    loc.setY(y);
-                    loc.setZ(z + 0.5);
-                    if (y <= 2 && world.getBlockAt(x,0,z).getTypeId() == BlockID.AIR) {
-                        world.getBlockAt(x,0,z).setTypeId(20);
-                        loc.setY(2);
-                    }
-                    player.setFallDistance(0F);
-                    player.teleport(loc);
-                }
-                return;
-            }
-
-            y++;
-        }
-    }
-
-    /**
-     * Replace color macros in a string. The macros are in the form of `[char]
-     * where char represents the color. R is for red, Y is for yellow,
-     * G is for green, C is for cyan, B is for blue, and P is for purple.
-     * The uppercase versions of those are the darker shades, while the
-     * lowercase versions are the lighter shades. For white, it's 'w', and
-     * 0-2 are black, dark grey, and grey, respectively.
-     *
-     * @param str
-     * @return color-coded string
-     */
-    public static String replaceColorMacros(String str) {
-        str = str.replace("&r", ChatColor.RED.toString());
-        str = str.replace("&R", ChatColor.DARK_RED.toString());
-
-        str = str.replace("&y", ChatColor.YELLOW.toString());
-        str = str.replace("&Y", ChatColor.GOLD.toString());
-
-        str = str.replace("&g", ChatColor.GREEN.toString());
-        str = str.replace("&G", ChatColor.DARK_GREEN.toString());
-
-        str = str.replace("&c", ChatColor.AQUA.toString());
-        str = str.replace("&C", ChatColor.DARK_AQUA.toString());
-
-        str = str.replace("&b", ChatColor.BLUE.toString());
-        str = str.replace("&B", ChatColor.DARK_BLUE.toString());
-
-        str = str.replace("&p", ChatColor.LIGHT_PURPLE.toString());
-        str = str.replace("&P", ChatColor.DARK_PURPLE.toString());
-
-        str = str.replace("&0", ChatColor.BLACK.toString());
-        str = str.replace("&1", ChatColor.DARK_GRAY.toString());
-        str = str.replace("&2", ChatColor.GRAY.toString());
-        str = str.replace("&w", ChatColor.WHITE.toString());
-
-        str = str.replace("&k", ChatColor.MAGIC.toString());
-        str = str.replace("&l", ChatColor.BOLD.toString());
-        str = str.replace("&m", ChatColor.STRIKETHROUGH.toString());
-        str = str.replace("&n", ChatColor.UNDERLINE.toString());
-        str = str.replace("&o", ChatColor.ITALIC.toString());
-
-        str = str.replace("&x", ChatColor.RESET.toString());
-
-        return str;
-    }
-
-    /**
-     * Returns whether an entity should be removed for the halt activity mode.
-     *
-     * @param entity
-     * @return true if it's to be removed
-     */
-    public static boolean isIntensiveEntity(Entity entity) {
-        return entity instanceof Item
-                || entity instanceof TNTPrimed
-                || entity instanceof ExperienceOrb
-                || entity instanceof FallingBlock
-                || (entity instanceof LivingEntity
-                    && !(entity instanceof Tameable)
-                    && !(entity instanceof Player));
-    }
-
-    /**
-     * Search an enum for a value, and return the first one found. Return null if the
-     * enum entry is not found.
-     *
-     * @param enumType enum class
-     * @param values values to test
-     * @return a value in the enum or null
-     */
-    public static <T extends Enum<T>> T tryEnum(Class<T> enumType, String ... values) {
-        for (String val : values) {
-            try {
-                return Enum.valueOf(enumType, val);
-            } catch (IllegalArgumentException e) {
-            }
-        }
-
-        return null;
-    }
-
-    /**
-     * Get a blacklist target for the given block.
-     *
-     * @param block the block
-     * @return a target
-     */
-    public static Target createTarget(Block block) {
-        checkNotNull(block);
-        return new MaterialTarget(block.getTypeId(), block.getData());
-    }
-
-    /**
-     * Get a blacklist target for the given block.
-     *
-     * @param block the block
-     * @param material a fallback material
-     * @return a target
-     */
-    public static Target createTarget(Block block, Material material) {
-        checkNotNull(material);
-        if (block.getType() == material) {
-            return new MaterialTarget(block.getTypeId(), block.getData());
-        } else {
-            return new MaterialTarget(material.getId(), (short) 0);
-        }
-    }
-
-    /**
-     * Get a blacklist target for the given item.
-     *
-     * @param item the item
-     * @return a target
-     */
-    public static Target createTarget(ItemStack item) {
-        checkNotNull(item);
-        return new MaterialTarget(item.getTypeId(), item.getDurability());
-    }
-
-    /**
-     * Get a blacklist target for the given material.
-     *
-     * @param material the material
-     * @return a target
-     */
-    public static Target createTarget(Material material) {
-        checkNotNull(material);
-        return new MaterialTarget(material.getId(), (short) 0);
-    }
-
-}
@@ -1,333 +0,0 @@
-/*
- * WorldGuard, a suite of tools for Minecraft
- * Copyright (C) sk89q <http://www.sk89q.com>
- * Copyright (C) WorldGuard team and contributors
- *
- * This program is free software: you can redistribute it and/or modify it
- * under the terms of the GNU Lesser General Public License as published by the
- * Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License
- * for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-package com.sk89q.worldguard.bukkit;
-
-import com.google.common.collect.ImmutableMap;
-import com.sk89q.commandbook.CommandBook;
-import com.sk89q.commandbook.GodComponent;
-import com.sk89q.util.yaml.YAMLFormat;
-import com.sk89q.util.yaml.YAMLProcessor;
-import com.sk89q.worldguard.LocalPlayer;
-import com.sk89q.worldguard.protection.managers.storage.file.DirectoryYamlDriver;
-import com.sk89q.worldguard.protection.managers.storage.DriverType;
-import com.sk89q.worldguard.protection.managers.storage.RegionDriver;
-import com.sk89q.worldguard.protection.managers.storage.sql.SQLDriver;
-import com.sk89q.worldguard.util.sql.DataSourceConfig;
-import org.bukkit.World;
-import org.bukkit.entity.Player;
-
-import java.io.File;
-import java.io.IOException;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.Map;
-import java.util.Set;
-import java.util.concurrent.ConcurrentHashMap;
-import java.util.concurrent.ConcurrentMap;
-import java.util.logging.Logger;
-
-/**
- * Represents the global configuration and also delegates configuration
- * for individual worlds.
- *
- * @author sk89q
- * @author Michael
- */
-public class ConfigurationManager {
-
-    private static final Logger log = Logger.getLogger(ConfigurationManager.class.getCanonicalName());
-
-    private static final String CONFIG_HEADER = "#\r\n" +
-            "# WorldGuard's main configuration file\r\n" +
-            "#\r\n" +
-            "# This is the global configuration file. Anything placed into here will\r\n" +
-            "# be applied to all worlds. However, each world has its own configuration\r\n" +
-            "# file to allow you to replace most settings in here for that world only.\r\n" +
-            "#\r\n" +
-            "# About editing this file:\r\n" +
-            "# - DO NOT USE TABS. You MUST use spaces or Bukkit will complain. If\r\n" +
-            "#   you use an editor like Notepad++ (recommended for Windows users), you\r\n" +
-            "#   must configure it to \"replace tabs with spaces.\" In Notepad++, this can\r\n" +
-            "#   be changed in Settings > Preferences > Language Menu.\r\n" +
-            "# - Don't get rid of the indents. They are indented so some entries are\r\n" +
-            "#   in categories (like \"enforce-single-session\" is in the \"protection\"\r\n" +
-            "#   category.\r\n" +
-            "# - If you want to check the format of this file before putting it\r\n" +
-            "#   into WorldGuard, paste it into http://yaml-online-parser.appspot.com/\r\n" +
-            "#   and see if it gives \"ERROR:\".\r\n" +
-            "# - Lines starting with # are comments and so they are ignored.\r\n" +
-            "#\r\n";
-
-    private WorldGuardPlugin plugin;
-    private ConcurrentMap<String, WorldConfiguration> worlds;
-    private YAMLProcessor config;
-    @Deprecated
-    private Set<String> hasGodMode = new HashSet<String>();
-    private Set<String> hasAmphibious = new HashSet<String>();
-
-    private boolean hasCommandBookGodMode = false;
-
-    public boolean useRegionsScheduler;
-    public boolean useRegionsCreatureSpawnEvent;
-    public boolean activityHaltToggle = false;
-    public boolean useGodPermission;
-    public boolean useGodGroup;
-    public boolean useAmphibiousGroup;
-    public boolean usePlayerMove;
-    public boolean usePlayerTeleports;
-    public boolean deopOnJoin;
-    public boolean blockInGameOp;
-    public boolean migrateRegionsToUuid;
-    public boolean keepUnresolvedNames;
-    public Map<String, String> hostKeys = new HashMap<String, String>();
-
-    /**
-     * Region Storage Configuration method, and config values
-     */
-    public RegionDriver selectedRegionStoreDriver;
-    public Map<DriverType, RegionDriver> regionStoreDriverMap;
-
-    /**
-     * Construct the object.
-     *
-     * @param plugin The plugin instance
-     */
-    public ConfigurationManager(WorldGuardPlugin plugin) {
-        this.plugin = plugin;
-        this.worlds = new ConcurrentHashMap<String, WorldConfiguration>();
-    }
-
-    /**
-     * Get the folder for storing data files and configuration.
-     *
-     * @return the data folder
-     */
-    public File getDataFolder() {
-        return plugin.getDataFolder();
-    }
-
-    /**
-     * Get the folder for storing data files and configuration for each
-     * world.
-     *
-     * @return the data folder
-     */
-    public File getWorldsDataFolder() {
-        return new File(getDataFolder(), "worlds");
-    }
-
-    /**
-     * Load the configuration.
-     */
-    @SuppressWarnings("unchecked")
-    public void load() {
-        // Create the default configuration file
-        plugin.createDefaultConfiguration(
-                new File(plugin.getDataFolder(), "config.yml"), "config.yml");
-
-        config = new YAMLProcessor(new File(plugin.getDataFolder(), "config.yml"), true, YAMLFormat.EXTENDED);
-        try {
-            config.load();
-        } catch (IOException e) {
-            log.severe("Error reading configuration for global config: ");
-            e.printStackTrace();
-        }
-
-        config.removeProperty("suppress-tick-sync-warnings");
-        useRegionsScheduler = config.getBoolean("regions.use-scheduler", true);
-        migrateRegionsToUuid = config.getBoolean("regions.uuid-migration.perform-on-next-start", true);
-        keepUnresolvedNames = config.getBoolean("regions.uuid-migration.keep-names-that-lack-uuids", true);
-        useRegionsCreatureSpawnEvent = config.getBoolean("regions.use-creature-spawn-event", true);
-        useGodPermission = config.getBoolean("auto-invincible", config.getBoolean("auto-invincible-permission", false));
-        useGodGroup = config.getBoolean("auto-invincible-group", false);
-        useAmphibiousGroup = config.getBoolean("auto-no-drowning-group", false);
-        config.removeProperty("auto-invincible-permission");
-        usePlayerMove = config.getBoolean("use-player-move-event", true);
-        usePlayerTeleports = config.getBoolean("use-player-teleports", true);
-
-        deopOnJoin = config.getBoolean("security.deop-everyone-on-join", false);
-        blockInGameOp = config.getBoolean("security.block-in-game-op-command", false);
-
-        hostKeys = new HashMap<String, String>();
-        Object hostKeysRaw = config.getProperty("host-keys");
-        if (hostKeysRaw == null || !(hostKeysRaw instanceof Map)) {
-            config.setProperty("host-keys", new HashMap<String, String>());
-        } else {
-            for (Map.Entry<Object, Object> entry : ((Map<Object, Object>) hostKeysRaw).entrySet()) {
-                String key = String.valueOf(entry.getKey());
-                String value = String.valueOf(entry.getValue());
-                hostKeys.put(key.toLowerCase(), value);
-            }
-        }
-
-        // ====================================================================
-        // Region store drivers
-        // ====================================================================
-
-        boolean useSqlDatabase = config.getBoolean("regions.sql.use", false);
-        String sqlDsn = config.getString("regions.sql.dsn", "jdbc:mysql://localhost/worldguard");
-        String sqlUsername = config.getString("regions.sql.username", "worldguard");
-        String sqlPassword = config.getString("regions.sql.password", "worldguard");
-        String sqlTablePrefix = config.getString("regions.sql.table-prefix", "");
-
-        DataSourceConfig dataSourceConfig = new DataSourceConfig(sqlDsn, sqlUsername, sqlPassword, sqlTablePrefix);
-        SQLDriver sqlDriver = new SQLDriver(dataSourceConfig);
-        DirectoryYamlDriver yamlDriver = new DirectoryYamlDriver(getWorldsDataFolder(), "regions.yml");
-
-        this.regionStoreDriverMap = ImmutableMap.<DriverType, RegionDriver>builder()
-                .put(DriverType.MYSQL, sqlDriver)
-                .put(DriverType.YAML, yamlDriver)
-                .build();
-        this.selectedRegionStoreDriver = useSqlDatabase ? sqlDriver : yamlDriver;
-
-        // Load configurations for each world
-        for (World world : plugin.getServer().getWorlds()) {
-            get(world);
-        }
-
-        config.setHeader(CONFIG_HEADER);
-    }
-
-    /**
-     * Unload the configuration.
-     */
-    public void unload() {
-        worlds.clear();
-    }
-
-    public void disableUuidMigration() {
-        config.setProperty("regions.uuid-migration.perform-on-next-start", false);
-        if (!config.save()) {
-            log.severe("Error saving configuration!");
-        }
-    }
-
-    /**
-     * Get the configuration for a world.
-     *
-     * @param world The world to get the configuration for
-     * @return {@code world}'s configuration
-     */
-    public WorldConfiguration get(World world) {
-        String worldName = world.getName();
-        WorldConfiguration config = worlds.get(worldName);
-        WorldConfiguration newConfig = null;
-
-        while (config == null) {
-            if (newConfig == null) {
-                newConfig = new WorldConfiguration(plugin, worldName, this.config);
-            }
-            worlds.putIfAbsent(world.getName(), newConfig);
-            config = worlds.get(world.getName());
-        }
-
-        return config;
-    }
-
-    /**
-     * Forget a player.
-     *
-     * @param player The player to forget about
-     */
-    public void forgetPlayer(LocalPlayer player) {
-        hasGodMode.remove(player.getName());
-        hasAmphibious.remove(player.getName());
-    }
-
-    /**
-     * Enable god mode for a player.
-     *
-     * @param player The player to enable god mode for.
-     */
-    @Deprecated
-    public void enableGodMode(Player player) {
-
-        hasGodMode.add(player.getName());
-    }
-
-    /**
-     * Disable god mode for a player.
-     *
-     * @param player The player to disable godmode for
-     */
-    @Deprecated
-    public void disableGodMode(Player player) {
-        hasGodMode.remove(player.getName());
-    }
-
-    /**
-     * Check to see if god mode is enabled for a player.
-     *
-     * @param player The player to check
-     * @return Whether the player has godmode through WorldGuard or CommandBook
-     */
-    public boolean hasGodMode(Player player) {
-        if (hasCommandBookGodMode) {
-            GodComponent god = CommandBook.inst().getComponentManager().getComponent(GodComponent.class);
-            if (god != null) {
-                return god.hasGodMode(player);
-            }
-        }
-        return hasGodMode.contains(player.getName());
-    }
-
-    /**
-     * Enable amphibious mode for a player.
-     *
-     * @param player The player to enable amphibious mode for
-     */
-    public void enableAmphibiousMode(Player player) {
-        hasAmphibious.add(player.getName());
-    }
-
-    /**
-     * Disable amphibious mode  for a player.
-     *
-     * @param player The player to disable amphibious mode for
-     */
-    public void disableAmphibiousMode(Player player) {
-        hasAmphibious.remove(player.getName());
-    }
-
-    /**
-     * Check to see if amphibious mode is enabled for a player.
-     *
-     * @param player The player to check
-     * @return Whether {@code player} has amphibious mode
-     */
-    public boolean hasAmphibiousMode(Player player) {
-        return hasAmphibious.contains(player.getName());
-    }
-
-    public void updateCommandBookGodMode() {
-        try {
-            if (plugin.getServer().getPluginManager().isPluginEnabled("CommandBook")) {
-                Class.forName("com.sk89q.commandbook.GodComponent");
-                hasCommandBookGodMode = true;
-                return;
-            }
-        } catch (ClassNotFoundException ignore) {}
-        hasCommandBookGodMode = false;
-    }
-
-    public boolean hasCommandBookGodMode() {
-        return hasCommandBookGodMode;
-    }
-}
@@ -1,301 +0,0 @@
-/*
- * WorldGuard, a suite of tools for Minecraft
- * Copyright (C) sk89q <http://www.sk89q.com>
- * Copyright (C) WorldGuard team and contributors
- *
- * This program is free software: you can redistribute it and/or modify it
- * under the terms of the GNU Lesser General Public License as published by the
- * Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License
- * for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-package com.sk89q.worldguard.bukkit;
-
-import com.sk89q.worldguard.LocalPlayer;
-import com.sk89q.worldguard.protection.ApplicableRegionSet;
-import com.sk89q.worldguard.protection.FailedLoadRegionSet;
-import com.sk89q.worldguard.protection.GlobalRegionManager;
-import com.sk89q.worldguard.protection.PermissiveRegionSet;
-import com.sk89q.worldguard.protection.RegionResultSet;
-import com.sk89q.worldguard.protection.association.RegionAssociable;
-import com.sk89q.worldguard.protection.flags.DefaultFlag;
-import com.sk89q.worldguard.protection.flags.Flag;
-import com.sk89q.worldguard.protection.flags.StateFlag;
-import com.sk89q.worldguard.protection.flags.StateFlag.State;
-import com.sk89q.worldguard.protection.managers.RegionManager;
-import org.bukkit.Location;
-import org.bukkit.World;
-import org.bukkit.entity.Player;
-
-import javax.annotation.Nullable;
-import java.util.Collection;
-
-import static com.google.common.base.Preconditions.checkNotNull;
-
-/**
- * This object allows easy spatial queries involving region data for the
- * purpose of implementing protection / region flag checks.
- *
- * <p>Results may be cached for brief amounts of time. If you want to get
- * data for the purposes of changing it, use of this class is not recommended.
- * Some of the return values of the methods may be simulated to reduce
- * boilerplate code related to implementing protection, meaning that false
- * data is returned.</p>
- */
-public class RegionQuery {
-
-    private final WorldGuardPlugin plugin;
-    private final ConfigurationManager config;
-    @SuppressWarnings("deprecation")
-    private final GlobalRegionManager globalManager;
-    private final QueryCache cache;
-
-    /**
-     * Create a new instance.
-     *
-     * @param plugin the plugin
-     * @param cache the query cache
-     */
-    RegionQuery(WorldGuardPlugin plugin, QueryCache cache) {
-        checkNotNull(plugin);
-        checkNotNull(cache);
-
-        this.plugin = plugin;
-        this.config = plugin.getGlobalStateManager();
-        this.cache = cache;
-        //noinspection deprecation
-        this.globalManager = plugin.getGlobalRegionManager();
-    }
-
-    /**
-     * Query for regions containing the given location.
-     *
-     * <p>An instance of {@link RegionResultSet} will always be returned,
-     * even if regions are disabled or region data failed to load. An
-     * appropriate "virtual" set will be returned in such a case
-     * (for example, if regions are disabled, the returned set
-     * would permit all activities).</p>
-     *
-     * @param location the location
-     * @return a region set
-     */
-    public ApplicableRegionSet getApplicableRegions(Location location) {
-        checkNotNull(location);
-
-        World world = location.getWorld();
-        WorldConfiguration worldConfig = config.get(world);
-
-        if (!worldConfig.useRegions) {
-            return PermissiveRegionSet.getInstance();
-        }
-
-        RegionManager manager = globalManager.get(location.getWorld());
-        if (manager != null) {
-            return cache.queryContains(manager, location);
-        } else {
-            return FailedLoadRegionSet.getInstance();
-        }
-    }
-
-    /**
-     * Test whether the (effective) value for a list of state flags equals
-     * {@code ALLOW}.
-     *
-     * <p>{@code player} can be non-null to satisfy region group requirements,
-     * otherwise it will be assumed that the caller that is not a member of any
-     * regions. (Flags on a region can be changed so that they only apply
-     * to certain users.) The player argument is required if the
-     * {@link DefaultFlag#BUILD} flag is in the list of flags.</p>
-     *
-     * <p>This method does not check the region bypass permission. That must
-     * be done by the calling code.</p>
-     *
-     * @param location the location
-     * @param player an optional player, which would be used to determine the region group to apply
-     * @param flag the flag
-     * @return true if the result was {@code ALLOW}
-     * @see RegionResultSet#queryValue(RegionAssociable, Flag)
-     */
-    public boolean testState(Location location, @Nullable Player player, StateFlag... flag) {
-        return StateFlag.test(queryState(location, player, flag));
-    }
-
-    /**
-     * Test whether the (effective) value for a list of state flags equals
-     * {@code ALLOW}.
-     *
-     * <p>{@code player} can be non-null to satisfy region group requirements,
-     * otherwise it will be assumed that the caller that is not a member of any
-     * regions. (Flags on a region can be changed so that they only apply
-     * to certain users.) The player argument is required if the
-     * {@link DefaultFlag#BUILD} flag is in the list of flags.</p>
-     *
-     * <p>This method does not check the region bypass permission. That must
-     * be done by the calling code.</p>
-     *
-     * @param location the location
-     * @param associable an optional associable
-     * @param flag the flag
-     * @return true if the result was {@code ALLOW}
-     * @see RegionResultSet#queryValue(RegionAssociable, Flag)
-     */
-    public boolean testState(Location location, @Nullable RegionAssociable associable, StateFlag... flag) {
-        return StateFlag.test(queryState(location, associable, flag));
-    }
-
-    /**
-     * Get the (effective) value for a list of state flags. The rules of
-     * states is observed here; that is, {@code DENY} overrides {@code ALLOW},
-     * and {@code ALLOW} overrides {@code NONE}. One flag may override another.
-     *
-     * <p>{@code player} can be non-null to satisfy region group requirements,
-     * otherwise it will be assumed that the caller that is not a member of any
-     * regions. (Flags on a region can be changed so that they only apply
-     * to certain users.) The player argument is required if the
-     * {@link DefaultFlag#BUILD} flag is in the list of flags.</p>
-     *
-     * @param location the location
-     * @param player an optional player, which would be used to determine the region groups that apply
-     * @param flags a list of flags to check
-     * @return a state
-     * @see RegionResultSet#queryState(RegionAssociable, StateFlag...)
-     */
-    @Nullable
-    public State queryState(Location location, @Nullable Player player, StateFlag... flags) {
-        LocalPlayer localPlayer = player != null ? plugin.wrapPlayer(player) : null;
-        return getApplicableRegions(location).queryState(localPlayer, flags);
-    }
-
-    /**
-     * Get the (effective) value for a list of state flags. The rules of
-     * states is observed here; that is, {@code DENY} overrides {@code ALLOW},
-     * and {@code ALLOW} overrides {@code NONE}. One flag may override another.
-     *
-     * <p>{@code player} can be non-null to satisfy region group requirements,
-     * otherwise it will be assumed that the caller that is not a member of any
-     * regions. (Flags on a region can be changed so that they only apply
-     * to certain users.) The player argument is required if the
-     * {@link DefaultFlag#BUILD} flag is in the list of flags.</p>
-     *
-     * @param location the location
-     * @param associable an optional associable
-     * @param flags a list of flags to check
-     * @return a state
-     * @see RegionResultSet#queryState(RegionAssociable, StateFlag...)
-     */
-    @Nullable
-    public State queryState(Location location, @Nullable RegionAssociable associable, StateFlag... flags) {
-        return getApplicableRegions(location).queryState(associable, flags);
-    }
-
-    /**
-     * Get the effective value for a flag. If there are multiple values
-     * (for example, multiple overlapping regions with
-     * the same priority may have the same flag set), then the selected
-     * (or "winning") value will depend on the flag type.
-     *
-     * <p>Only some flag types actually have a strategy for picking the
-     * "best value." For most types, the actual value that is chosen to be
-     * returned is undefined (it could be any value). As of writing, the only
-     * type of flag that actually has a strategy for picking a value is the
-     * {@link StateFlag}.</p>
-     *
-     * <p>{@code player} can be non-null to satisfy region group requirements,
-     * otherwise it will be assumed that the caller that is not a member of any
-     * regions. (Flags on a region can be changed so that they only apply
-     * to certain users.) The player argument is required if the
-     * {@link DefaultFlag#BUILD} flag is the flag being queried.</p>
-     *
-     * @param location the location
-     * @param player an optional player, which would be used to determine the region group to apply
-     * @param flag the flag
-     * @return a value, which could be {@code null}
-     * @see RegionResultSet#queryValue(RegionAssociable, Flag)
-     */
-    @Nullable
-    public <V> V queryValue(Location location, @Nullable Player player, Flag<V> flag) {
-        LocalPlayer localPlayer = player != null ? plugin.wrapPlayer(player) : null;
-        return getApplicableRegions(location).queryValue(localPlayer, flag);
-    }
-
-    /**
-     * Get the effective value for a flag. If there are multiple values
-     * (for example, multiple overlapping regions with
-     * the same priority may have the same flag set), then the selected
-     * (or "winning") value will depend on the flag type.
-     *
-     * <p>Only some flag types actually have a strategy for picking the
-     * "best value." For most types, the actual value that is chosen to be
-     * returned is undefined (it could be any value). As of writing, the only
-     * type of flag that actually has a strategy for picking a value is the
-     * {@link StateFlag}.</p>
-     *
-     * <p>{@code player} can be non-null to satisfy region group requirements,
-     * otherwise it will be assumed that the caller that is not a member of any
-     * regions. (Flags on a region can be changed so that they only apply
-     * to certain users.) The player argument is required if the
-     * {@link DefaultFlag#BUILD} flag is the flag being queried.</p>
-     *
-     * @param location the location
-     * @param associable an optional associable
-     * @param flag the flag
-     * @return a value, which could be {@code null}
-     * @see RegionResultSet#queryValue(RegionAssociable, Flag)
-     */
-    @Nullable
-    public <V> V queryValue(Location location, @Nullable RegionAssociable associable, Flag<V> flag) {
-        return getApplicableRegions(location).queryValue(associable, flag);
-    }
-
-    /**
-     * Get the effective values for a flag, returning a collection of all
-     * values. It is up to the caller to determine which value, if any,
-     * from the collection will be used.
-     *
-     * <p>{@code player} can be non-null to satisfy region group requirements,
-     * otherwise it will be assumed that the caller that is not a member of any
-     * regions. (Flags on a region can be changed so that they only apply
-     * to certain users.) The player argument is required if the
-     * {@link DefaultFlag#BUILD} flag is the flag being queried.</p>
-     *
-     * @param location the location
-     * @param player an optional player, which would be used to determine the region group to apply
-     * @param flag the flag
-     * @return a collection of values
-     * @see RegionResultSet#queryAllValues(RegionAssociable, Flag)
-     */
-    public <V> Collection<V> queryAllValues(Location location, @Nullable Player player, Flag<V> flag) {
-        LocalPlayer localPlayer = player != null ? plugin.wrapPlayer(player) : null;
-        return getApplicableRegions(location).queryAllValues(localPlayer, flag);
-    }
-
-    /**
-     * Get the effective values for a flag, returning a collection of all
-     * values. It is up to the caller to determine which value, if any,
-     * from the collection will be used.
-     *
-     * <p>{@code player} can be non-null to satisfy region group requirements,
-     * otherwise it will be assumed that the caller that is not a member of any
-     * regions. (Flags on a region can be changed so that they only apply
-     * to certain users.) The player argument is required if the
-     * {@link DefaultFlag#BUILD} flag is the flag being queried.</p>
-     *
-     * @param location the location
-     * @param associable an optional associable
-     * @param flag the flag
-     * @return a collection of values
-     * @see RegionResultSet#queryAllValues(RegionAssociable, Flag)
-     */
-    public <V> Collection<V> queryAllValues(Location location, @Nullable RegionAssociable associable, Flag<V> flag) {
-        return getApplicableRegions(location).queryAllValues(associable, flag);
-    }
-
-}
@@ -1,71 +0,0 @@
-/*
- * WorldGuard, a suite of tools for Minecraft
- * Copyright (C) sk89q <http://www.sk89q.com>
- * Copyright (C) WorldGuard team and contributors
- *
- * This program is free software: you can redistribute it and/or modify it
- * under the terms of the GNU Lesser General Public License as published by the
- * Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License
- * for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-package com.sk89q.worldguard.bukkit;
-
-import org.bukkit.World;
-
-import com.sk89q.worldguard.protection.managers.RegionManager;
-
-/**
- * Helper class to get a reference to WorldGuard and its components.
- */
-public class WGBukkit {
-
-    private WGBukkit() {
-    }
-
-    /**
-     * Get the WorldGuard plugin. If WorldGuard isn't loaded yet, then this will
-     * return null.
-     * <p>
-     * If you are depending on WorldGuard in your plugin, you should place
-     * <code>softdepend: [WorldGuard]</code> or <code>depend: [WorldGuard]</code>
-     * in your plugin.yml so that this won't return null for you.
-     *
-     * @return the WorldGuard plugin or null
-     */
-    public static WorldGuardPlugin getPlugin() {
-        return WorldGuardPlugin.inst();
-    }
-
-    /**
-     * Set cache to null for reload WorldGuardPlugin
-     * @deprecated instance is now stored directly in {@link WorldGuardPlugin}
-     */
-    @Deprecated
-    public static void cleanCache() {
-        // do nothing - plugin instance is stored in plugin class now
-    }
-
-    /**
-     * Returns the region manager for a given world. May return null if WorldGuard
-     * is not loaded or region protection is not enabled for the given world.
-     *
-     * @param world world
-     * @return a region manager or null
-     */
-    public static RegionManager getRegionManager(World world) {
-        if (getPlugin() == null) {
-            return null;
-        }
-        return WorldGuardPlugin.inst().getRegionManager(world);
-    }
-
-}
@@ -1,243 +0,0 @@
-/*
- * WorldGuard, a suite of tools for Minecraft
- * Copyright (C) sk89q <http://www.sk89q.com>
- * Copyright (C) WorldGuard team and contributors
- *
- * This program is free software: you can redistribute it and/or modify it
- * under the terms of the GNU Lesser General Public License as published by the
- * Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License
- * for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-package com.sk89q.worldguard.bukkit.cause;
-
-import com.google.common.base.Joiner;
-import com.sk89q.worldguard.bukkit.util.WGMetadata;
-import org.bukkit.block.Block;
-import org.bukkit.entity.Entity;
-import org.bukkit.entity.EntityType;
-import org.bukkit.entity.Player;
-import org.bukkit.entity.Projectile;
-import org.bukkit.entity.TNTPrimed;
-import org.bukkit.entity.Tameable;
-import org.bukkit.entity.Vehicle;
-import org.bukkit.metadata.Metadatable;
-
-import javax.annotation.Nullable;
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.List;
-
-import static com.google.common.base.Preconditions.checkNotNull;
-
-/**
- * An instance of this object describes the actors that played a role in
- * causing an event, with the ability to describe a situation where one actor
- * controls several other actors to create the event.
- *
- * <p>For example, if a player fires an arrow that hits an item frame, the player
- * is the initiator, while the arrow is merely controlled by the player to
- * hit the item frame.</p>
- */
-public class Cause {
-
-    private static final String CAUSE_KEY = "worldguard.cause";
-    private static final Cause UNKNOWN = new Cause(Collections.emptyList());
-
-    private final List<Object> causes;
-
-    /**
-     * Create a new instance.
-     *
-     * @param causes a list of causes
-     */
-    private Cause(List<Object> causes) {
-        checkNotNull(causes);
-        this.causes = causes;
-    }
-
-    /**
-     * Return whether a cause is known. This method will return true if
-     * the list of causes is empty or the list of causes only contains
-     * objects that really are not root causes (i.e primed TNT).
-     *
-     * @return true if known
-     */
-    public boolean isKnown() {
-        if (causes.isEmpty()) {
-            return false;
-        }
-
-        boolean found = false;
-        for (Object object : causes) {
-            if (!(object instanceof TNTPrimed)) {
-                found = true;
-                break;
-            }
-        }
-
-        return found;
-    }
-
-    @Nullable
-    public Object getRootCause() {
-        if (!causes.isEmpty()) {
-            return causes.get(0);
-        }
-
-        return null;
-    }
-
-    @Nullable
-    public Player getFirstPlayer() {
-        for (Object object : causes) {
-            if (object instanceof Player) {
-                return (Player) object;
-            }
-        }
-
-        return null;
-    }
-
-    @Nullable
-    public Entity getFirstEntity() {
-        for (Object object : causes) {
-            if (object instanceof Entity) {
-                return (Entity) object;
-            }
-        }
-
-        return null;
-    }
-
-    @Nullable
-    public Block getFirstBlock() {
-        for (Object object : causes) {
-            if (object instanceof Block) {
-                return (Block) object;
-            }
-        }
-
-        return null;
-    }
-
-    /**
-     * Find the first type matching one in the given array.
-     *
-     * @param types an array of types
-     * @return a found type or null
-     */
-    @Nullable
-    public EntityType find(EntityType... types) {
-        for (Object object : causes) {
-            if (object instanceof Entity) {
-                for (EntityType type : types) {
-                    if (((Entity) object).getType() == type) {
-                        return type;
-                    }
-                }
-            }
-        }
-
-        return null;
-    }
-
-    @Override
-    public String toString() {
-        return Joiner.on(" | ").join(causes);
-    }
-
-    /**
-     * Expand an cause object.
-     *
-     * @param list the list to add elements to
-     * @param element an array of objects
-     */
-    private static void expand(List<Object> list, @Nullable Object ... element) {
-        if (element != null) {
-            for (Object o : element) {
-                if (o == null) {
-                    continue;
-                }
-
-                if (o instanceof TNTPrimed) {
-                    expand(list, ((TNTPrimed) o).getSource());
-                } else if (o instanceof Projectile) {
-                    expand(list, ((Projectile) o).getShooter());
-                } else if (o instanceof Vehicle) {
-                    expand(list, ((Vehicle) o).getPassenger());
-                } else if (o instanceof Tameable) {
-                    expand(list, ((Tameable) o).getOwner());
-                }
-
-                // Add manually tracked parent causes
-                Object source = o;
-                int index = list.size();
-                while (source instanceof Metadatable && !(source instanceof Block)) {
-                    source = WGMetadata.getIfPresent((Metadatable) source, CAUSE_KEY, Object.class);
-                    if (source != null) {
-                        list.add(index, source);
-                    }
-                }
-
-                list.add(o);
-            }
-        }
-    }
-
-    /**
-     * Create a new instance with the given objects as the cause,
-     * where the first-most object is the initial initiator and those
-     * following it are controlled by the previous entry.
-     *
-     * @param cause an array of causing objects
-     * @return a cause
-     */
-    public static Cause create(@Nullable Object ... cause) {
-        if (cause != null) {
-            List<Object> causes = new ArrayList<Object>(cause.length);
-            expand(causes, cause);
-            return new Cause(causes);
-        } else {
-            return UNKNOWN;
-        }
-    }
-
-    /**
-     * Create a new instance that indicates that the cause is not known.
-     *
-     * @return a cause
-     */
-    public static Cause unknown() {
-        return UNKNOWN;
-    }
-
-    /**
-     * Add a parent cause to a {@code Metadatable} object.
-     *
-     * <p>Note that {@code target} cannot be an instance of
-     * {@link Block} because {@link #create(Object...)} will not bother
-     * checking for such data on blocks (because it is relatively costly
-     * to do so).</p>
-     *
-     * @param target the target
-     * @param parent the parent cause
-     * @throws IllegalArgumentException thrown if {@code target} is an instance of {@link Block}
-     */
-    public static void trackParentCause(Metadatable target, Object parent) {
-        if (target instanceof Block) {
-            throw new IllegalArgumentException("Can't track causes on Blocks because Cause doesn't check block metadata");
-        }
-
-        WGMetadata.put(target, CAUSE_KEY, parent);
-    }
-
-}
@@ -1,135 +0,0 @@
-/*
- * WorldGuard, a suite of tools for Minecraft
- * Copyright (C) sk89q <http://www.sk89q.com>
- * Copyright (C) WorldGuard team and contributors
- *
- * This program is free software: you can redistribute it and/or modify it
- * under the terms of the GNU Lesser General Public License as published by the
- * Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License
- * for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-package com.sk89q.worldguard.bukkit.commands;
-
-import com.google.common.util.concurrent.Futures;
-import com.google.common.util.concurrent.ListenableFuture;
-import com.sk89q.worldguard.util.task.FutureForwardingTask;
-import com.sk89q.worldguard.bukkit.WorldGuardPlugin;
-import org.bukkit.World;
-import org.bukkit.command.CommandSender;
-
-import javax.annotation.Nullable;
-
-import static com.google.common.base.Preconditions.checkNotNull;
-
-public class AsyncCommandHelper {
-
-    private final ListenableFuture<?> future;
-    private final WorldGuardPlugin plugin;
-    private final CommandSender sender;
-    @Nullable
-    private Object[] formatArgs;
-
-    private AsyncCommandHelper(ListenableFuture<?> future, WorldGuardPlugin plugin, CommandSender sender) {
-        checkNotNull(future);
-        checkNotNull(plugin);
-        checkNotNull(sender);
-
-        this.future = future;
-        this.plugin = plugin;
-        this.sender = sender;
-    }
-
-    public AsyncCommandHelper formatUsing(Object... args) {
-        this.formatArgs = args;
-        return this;
-    }
-
-    private String format(String message) {
-        if (formatArgs != null) {
-            return String.format(message, formatArgs);
-        } else {
-            return message;
-        }
-    }
-
-    public AsyncCommandHelper registerWithSupervisor(String description) {
-        plugin.getSupervisor().monitor(
-                FutureForwardingTask.create(
-                        future, format(description), sender));
-        return this;
-    }
-
-    public AsyncCommandHelper sendMessageAfterDelay(String message) {
-        FutureProgressListener.addProgressListener(future, sender, format(message));
-        return this;
-    }
-
-    public AsyncCommandHelper thenRespondWith(String success, String failure) {
-        // Send a response message
-        Futures.addCallback(
-                future,
-                new MessageFutureCallback.Builder(plugin, sender)
-                        .onSuccess(format(success))
-                        .onFailure(format(failure))
-                        .build());
-        return this;
-    }
-
-    public AsyncCommandHelper thenTellErrorsOnly(String failure) {
-        // Send a response message
-        Futures.addCallback(
-                future,
-                new MessageFutureCallback.Builder(plugin, sender)
-                        .onFailure(format(failure))
-                        .build());
-        return this;
-    }
-
-    public AsyncCommandHelper forRegionDataLoad(World world, boolean silent) {
-        checkNotNull(world);
-
-        formatUsing(world.getName());
-        registerWithSupervisor("Loading region data for '%s'");
-        if (silent) {
-            thenTellErrorsOnly("Failed to load regions '%s'");
-        } else {
-            sendMessageAfterDelay("(Please wait... loading the region data for '%s')");
-            thenRespondWith(
-                    "Loaded region data for '%s'",
-                    "Failed to load regions '%s'");
-        }
-
-        return this;
-    }
-
-    public AsyncCommandHelper forRegionDataSave(World world, boolean silent) {
-        checkNotNull(world);
-
-        formatUsing(world.getName());
-        registerWithSupervisor("Saving region data for '%s'");
-        if (silent) {
-            thenTellErrorsOnly("Failed to save regions '%s'");
-        } else {
-            sendMessageAfterDelay("(Please wait... saving the region data for '%s')");
-            thenRespondWith(
-                    "Saved region data for '%s'",
-                    "Failed to load regions '%s'");
-        }
-
-        return this;
-    }
-
-    public static AsyncCommandHelper wrap(ListenableFuture<?> future, WorldGuardPlugin plugin, CommandSender sender) {
-        return new AsyncCommandHelper(future, plugin, sender);
-    }
-
-}
@@ -1,146 +0,0 @@
-/*
- * WorldGuard, a suite of tools for Minecraft
- * Copyright (C) sk89q <http://www.sk89q.com>
- * Copyright (C) WorldGuard team and contributors
- *
- * This program is free software: you can redistribute it and/or modify it
- * under the terms of the GNU Lesser General Public License as published by the
- * Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License
- * for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-package com.sk89q.worldguard.bukkit.commands;
-
-import com.google.common.base.Function;
-import org.bukkit.ChatColor;
-import org.bukkit.command.BlockCommandSender;
-import org.bukkit.command.CommandSender;
-import org.bukkit.command.ConsoleCommandSender;
-import org.bukkit.entity.Player;
-
-import javax.annotation.Nullable;
-
-/**
- * Command-related utility methods.
- */
-public final class CommandUtils {
-
-    private CommandUtils() {
-    }
-
-    /**
-     * Replace color macros in a string.
-     *
-     * @param str the string
-     * @return the new string
-     */
-    public static String replaceColorMacros(String str) {
-        // TODO: Make this more efficient
-
-        str = str.replace("`r", ChatColor.RED.toString());
-        str = str.replace("`R", ChatColor.DARK_RED.toString());
-
-        str = str.replace("`y", ChatColor.YELLOW.toString());
-        str = str.replace("`Y", ChatColor.GOLD.toString());
-
-        str = str.replace("`g", ChatColor.GREEN.toString());
-        str = str.replace("`G", ChatColor.DARK_GREEN.toString());
-
-        str = str.replace("`c", ChatColor.AQUA.toString());
-        str = str.replace("`C", ChatColor.DARK_AQUA.toString());
-
-        str = str.replace("`b", ChatColor.BLUE.toString());
-        str = str.replace("`B", ChatColor.DARK_BLUE.toString());
-
-        str = str.replace("`p", ChatColor.LIGHT_PURPLE.toString());
-        str = str.replace("`P", ChatColor.DARK_PURPLE.toString());
-
-        str = str.replace("`0", ChatColor.BLACK.toString());
-        str = str.replace("`1", ChatColor.DARK_GRAY.toString());
-        str = str.replace("`2", ChatColor.GRAY.toString());
-        str = str.replace("`w", ChatColor.WHITE.toString());
-
-        str = str.replace("`k", ChatColor.MAGIC.toString());
-
-        str = str.replace("`l", ChatColor.BOLD.toString());
-        str = str.replace("`m", ChatColor.STRIKETHROUGH.toString());
-        str = str.replace("`n", ChatColor.UNDERLINE.toString());
-        str = str.replace("`o", ChatColor.ITALIC.toString());
-
-        str = str.replace("`x", ChatColor.RESET.toString());
-
-        // MC classic
-
-        str = str.replace("&c", ChatColor.RED.toString());
-        str = str.replace("&4", ChatColor.DARK_RED.toString());
-
-        str = str.replace("&e", ChatColor.YELLOW.toString());
-        str = str.replace("&6", ChatColor.GOLD.toString());
-
-        str = str.replace("&a", ChatColor.GREEN.toString());
-        str = str.replace("&2", ChatColor.DARK_GREEN.toString());
-
-        str = str.replace("&b", ChatColor.AQUA.toString());
-        str = str.replace("&3", ChatColor.DARK_AQUA.toString());
-
-        str = str.replace("&9", ChatColor.BLUE.toString());
-        str = str.replace("&1", ChatColor.DARK_BLUE.toString());
-
-        str = str.replace("&d", ChatColor.LIGHT_PURPLE.toString());
-        str = str.replace("&5", ChatColor.DARK_PURPLE.toString());
-
-        str = str.replace("&0", ChatColor.BLACK.toString());
-        str = str.replace("&8", ChatColor.DARK_GRAY.toString());
-        str = str.replace("&7", ChatColor.GRAY.toString());
-        str = str.replace("&f", ChatColor.WHITE.toString());
-
-        return str;
-    }
-
-
-    /**
-     * Get the name of the given owner object.
-     *
-     * @param owner the owner object
-     * @return a name
-     */
-    public static String getOwnerName(@Nullable Object owner) {
-        if (owner == null) {
-            return "?";
-        } else if (owner instanceof Player) {
-            return ((Player) owner).getName();
-        } else if (owner instanceof ConsoleCommandSender) {
-            return "*CONSOLE*";
-        } else if (owner instanceof BlockCommandSender) {
-            return ((BlockCommandSender) owner).getBlock().getLocation().toString();
-        } else {
-            return "?";
-        }
-    }
-
-    /**
-     * Return a function that accepts a string to send a message to the
-     * given sender.
-     *
-     * @param sender the sender
-     * @return a function
-     */
-    public static Function<String, ?> messageFunction(final CommandSender sender) {
-        return new Function<String, Object>() {
-            @Override
-            public Object apply(@Nullable String s) {
-                sender.sendMessage(s);
-                return null;
-            }
-        };
-    }
-
-}
@@ -1,55 +0,0 @@
-/*
- * WorldGuard, a suite of tools for Minecraft
- * Copyright (C) sk89q <http://www.sk89q.com>
- * Copyright (C) WorldGuard team and contributors
- *
- * This program is free software: you can redistribute it and/or modify it
- * under the terms of the GNU Lesser General Public License as published by the
- * Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License
- * for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-package com.sk89q.worldguard.bukkit.commands;
-
-import com.google.common.util.concurrent.ListenableFuture;
-import com.google.common.util.concurrent.MoreExecutors;
-import org.bukkit.ChatColor;
-import org.bukkit.command.CommandSender;
-
-import java.util.Timer;
-
-import static com.google.common.base.Preconditions.checkNotNull;
-
-public class FutureProgressListener implements Runnable {
-
-    private static final Timer timer = new Timer();
-    private static final int MESSAGE_DELAY = 1000;
-
-    private final MessageTimerTask task;
-
-    public FutureProgressListener(CommandSender sender, String message) {
-        checkNotNull(sender);
-        checkNotNull(message);
-
-        task = new MessageTimerTask(sender, ChatColor.GRAY + message);
-        timer.schedule(task, MESSAGE_DELAY);
-    }
-
-    @Override
-    public void run() {
-        task.cancel();
-    }
-
-    public static void addProgressListener(ListenableFuture<?> future, CommandSender sender, String message) {
-        future.addListener(new FutureProgressListener(sender, message), MoreExecutors.sameThreadExecutor());
-    }
-
-}
@@ -1,305 +0,0 @@
-/*
- * WorldGuard, a suite of tools for Minecraft
- * Copyright (C) sk89q <http://www.sk89q.com>
- * Copyright (C) WorldGuard team and contributors
- *
- * This program is free software: you can redistribute it and/or modify it
- * under the terms of the GNU Lesser General Public License as published by the
- * Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License
- * for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-package com.sk89q.worldguard.bukkit.commands;
-
-import org.bukkit.ChatColor;
-import org.bukkit.command.CommandSender;
-import org.bukkit.entity.Player;
-import org.bukkit.inventory.ItemStack;
-
-import com.sk89q.minecraft.util.commands.Command;
-import com.sk89q.minecraft.util.commands.CommandContext;
-import com.sk89q.minecraft.util.commands.CommandException;
-import com.sk89q.minecraft.util.commands.CommandPermissions;
-import com.sk89q.worldedit.blocks.ItemType;
-import com.sk89q.worldguard.bukkit.ConfigurationManager;
-import com.sk89q.worldguard.bukkit.WorldGuardPlugin;
-
-public class GeneralCommands {
-    private final WorldGuardPlugin plugin;
-
-    public GeneralCommands(WorldGuardPlugin plugin) {
-        this.plugin = plugin;
-    }
-    
-    @SuppressWarnings("deprecation")
-    @Command(aliases = {"god"}, usage = "[player]",
-            desc = "Enable godmode on a player", flags = "s", max = 1)
-    public void god(CommandContext args, CommandSender sender) throws CommandException {
-        ConfigurationManager config = plugin.getGlobalStateManager();
-        
-        Iterable<Player> targets = null;
-        boolean included = false;
-        
-        // Detect arguments based on the number of arguments provided
-        if (args.argsLength() == 0) {
-            targets = plugin.matchPlayers(plugin.checkPlayer(sender));
-            
-            // Check permissions!
-            plugin.checkPermission(sender, "worldguard.god");
-        } else if (args.argsLength() == 1) {            
-            targets = plugin.matchPlayers(sender, args.getString(0));
-            
-            // Check permissions!
-            plugin.checkPermission(sender, "worldguard.god.other");
-        }
-
-        for (Player player : targets) {
-            config.enableGodMode(player);
-            player.setFireTicks(0);
-            
-            // Tell the user
-            if (player.equals(sender)) {
-                player.sendMessage(ChatColor.YELLOW + "God mode enabled! Use /ungod to disable.");
-                
-                // Keep track of this
-                included = true;
-            } else {
-                player.sendMessage(ChatColor.YELLOW + "God enabled by "
-                        + plugin.toName(sender) + ".");
-                
-            }
-        }
-        
-        // The player didn't receive any items, then we need to send the
-        // user a message so s/he know that something is indeed working
-        if (!included && args.hasFlag('s')) {
-            sender.sendMessage(ChatColor.YELLOW.toString() + "Players now have god mode.");
-        }
-    }
-    
-    @SuppressWarnings("deprecation")
-    @Command(aliases = {"ungod"}, usage = "[player]",
-            desc = "Disable godmode on a player", flags = "s", max = 1)
-    public void ungod(CommandContext args, CommandSender sender) throws CommandException {
-        ConfigurationManager config = plugin.getGlobalStateManager();
-        
-        Iterable<Player> targets = null;
-        boolean included = false;
-        
-        // Detect arguments based on the number of arguments provided
-        if (args.argsLength() == 0) {
-            targets = plugin.matchPlayers(plugin.checkPlayer(sender));
-            
-            // Check permissions!
-            plugin.checkPermission(sender, "worldguard.god");
-        } else if (args.argsLength() == 1) {            
-            targets = plugin.matchPlayers(sender, args.getString(0));
-            
-            // Check permissions!
-            plugin.checkPermission(sender, "worldguard.god.other");
-        }
-
-        for (Player player : targets) {
-            config.disableGodMode(player);
-            
-            // Tell the user
-            if (player.equals(sender)) {
-                player.sendMessage(ChatColor.YELLOW + "God mode disabled!");
-                
-                // Keep track of this
-                included = true;
-            } else {
-                player.sendMessage(ChatColor.YELLOW + "God disabled by "
-                        + plugin.toName(sender) + ".");
-                
-            }
-        }
-        
-        // The player didn't receive any items, then we need to send the
-        // user a message so s/he know that something is indeed working
-        if (!included && args.hasFlag('s')) {
-            sender.sendMessage(ChatColor.YELLOW.toString() + "Players no longer have god mode.");
-        }
-    }
-    
-    @Command(aliases = {"heal"}, usage = "[player]", desc = "Heal a player", flags = "s", max = 1)
-    public void heal(CommandContext args,CommandSender sender) throws CommandException {
-        
-        Iterable<Player> targets = null;
-        boolean included = false;
-        
-        // Detect arguments based on the number of arguments provided
-        if (args.argsLength() == 0) {
-            targets = plugin.matchPlayers(plugin.checkPlayer(sender));
-            
-            // Check permissions!
-            plugin.checkPermission(sender, "worldguard.heal");
-        } else if (args.argsLength() == 1) {            
-            targets = plugin.matchPlayers(sender, args.getString(0));
-            
-            // Check permissions!
-            plugin.checkPermission(sender, "worldguard.heal.other");
-        }
-
-        for (Player player : targets) {
-            player.setHealth(player.getMaxHealth());
-            player.setFoodLevel(20);
-            
-            // Tell the user
-            if (player.equals(sender)) {
-                player.sendMessage(ChatColor.YELLOW + "Healed!");
-                
-                // Keep track of this
-                included = true;
-            } else {
-                player.sendMessage(ChatColor.YELLOW + "Healed by "
-                        + plugin.toName(sender) + ".");
-                
-            }
-        }
-        
-        // The player didn't receive any items, then we need to send the
-        // user a message so s/he know that something is indeed working
-        if (!included && args.hasFlag('s')) {
-            sender.sendMessage(ChatColor.YELLOW.toString() + "Players healed.");
-        }
-    }
-    
-    @Command(aliases = {"slay"}, usage = "[player]", desc = "Slay a player", flags = "s", max = 1)
-    public void slay(CommandContext args, CommandSender sender) throws CommandException {
-        
-        Iterable<Player> targets = null;
-        boolean included = false;
-        
-        // Detect arguments based on the number of arguments provided
-        if (args.argsLength() == 0) {
-            targets = plugin.matchPlayers(plugin.checkPlayer(sender));
-            
-            // Check permissions!
-            plugin.checkPermission(sender, "worldguard.slay");
-        } else if (args.argsLength() == 1) {            
-            targets = plugin.matchPlayers(sender, args.getString(0));
-            
-            // Check permissions!
-            plugin.checkPermission(sender, "worldguard.slay.other");
-        }
-
-        for (Player player : targets) {
-            player.setHealth(0);
-            
-            // Tell the user
-            if (player.equals(sender)) {
-                player.sendMessage(ChatColor.YELLOW + "Slain!");
-                
-                // Keep track of this
-                included = true;
-            } else {
-                player.sendMessage(ChatColor.YELLOW + "Slain by "
-                        + plugin.toName(sender) + ".");
-                
-            }
-        }
-        
-        // The player didn't receive any items, then we need to send the
-        // user a message so s/he know that something is indeed working
-        if (!included && args.hasFlag('s')) {
-            sender.sendMessage(ChatColor.YELLOW.toString() + "Players slain.");
-        }
-    }
-    
-    @Command(aliases = {"locate"}, usage = "[player]", desc = "Locate a player", max = 1)
-    @CommandPermissions({"worldguard.locate"})
-    public void locate(CommandContext args, CommandSender sender) throws CommandException {
-        
-        Player player = plugin.checkPlayer(sender);
-        
-        if (args.argsLength() == 0) {
-            player.setCompassTarget(player.getWorld().getSpawnLocation());
-            
-            sender.sendMessage(ChatColor.YELLOW.toString() + "Compass reset to spawn.");
-        } else {
-            Player target = plugin.matchSinglePlayer(sender, args.getString(0));
-            player.setCompassTarget(target.getLocation());
-            
-            sender.sendMessage(ChatColor.YELLOW.toString() + "Compass repointed.");
-        }
-    }
-    
-    @Command(aliases = {"stack", ";"}, usage = "", desc = "Stack items", max = 0)
-    @CommandPermissions({"worldguard.stack"})
-    public void stack(CommandContext args, CommandSender sender) throws CommandException {
-        
-        Player player = plugin.checkPlayer(sender);
-        boolean ignoreMax = plugin.hasPermission(player, "worldguard.stack.illegitimate");
-        boolean ignoreDamaged = plugin.hasPermission(player, "worldguard.stack.damaged");
-        
-        ItemStack[] items = player.getInventory().getContents();
-        int len = items.length;
-
-        int affected = 0;
-        
-        for (int i = 0; i < len; i++) {
-            ItemStack item = items[i];
-
-            // Avoid infinite stacks and stacks with durability
-            if (item == null || item.getAmount() <= 0
-                    || (!ignoreMax && item.getMaxStackSize() == 1)) {
-                continue;
-            }
-
-            int max = ignoreMax ? 64 : item.getMaxStackSize();
-
-            if (item.getAmount() < max) {
-                int needed = max - item.getAmount(); // Number of needed items until max
-
-                // Find another stack of the same type
-                for (int j = i + 1; j < len; j++) {
-                    ItemStack item2 = items[j];
-
-                    // Avoid infinite stacks and stacks with durability
-                    if (item2 == null || item2.getAmount() <= 0
-                            || (!ignoreMax && item.getMaxStackSize() == 1)) {
-                        continue;
-                    }
-
-                    // Same type?
-                    // Blocks store their color in the damage value
-                    if (item2.getTypeId() == item.getTypeId() &&
-                            ((!ItemType.usesDamageValue(item.getTypeId()) && ignoreDamaged)
-                                    || item.getDurability() == item2.getDurability()) &&
-                                    ((item.getItemMeta() == null && item2.getItemMeta() == null)
-                                            || (item.getItemMeta() != null &&
-                                                item.getItemMeta().equals(item2.getItemMeta())))) {
-                        // This stack won't fit in the parent stack
-                        if (item2.getAmount() > needed) {
-                            item.setAmount(max);
-                            item2.setAmount(item2.getAmount() - needed);
-                            break;
-                        // This stack will
-                        } else {
-                            items[j] = null;
-                            item.setAmount(item.getAmount() + item2.getAmount());
-                            needed = max - item.getAmount();
-                        }
-
-                        affected++;
-                    }
-                }
-            }
-        }
-
-        if (affected > 0) {
-            player.getInventory().setContents(items);
-        }
-
-        player.sendMessage(ChatColor.YELLOW + "Items compacted into stacks!");
-    }
-}
@@ -1,103 +0,0 @@
-/*
- * WorldGuard, a suite of tools for Minecraft
- * Copyright (C) sk89q <http://www.sk89q.com>
- * Copyright (C) WorldGuard team and contributors
- *
- * This program is free software: you can redistribute it and/or modify it
- * under the terms of the GNU Lesser General Public License as published by the
- * Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License
- * for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-package com.sk89q.worldguard.bukkit.commands;
-
-import com.google.common.util.concurrent.FutureCallback;
-import com.sk89q.worldguard.bukkit.WorldGuardPlugin;
-import org.bukkit.ChatColor;
-import org.bukkit.command.CommandSender;
-
-import javax.annotation.Nullable;
-
-import static com.google.common.base.Preconditions.checkNotNull;
-
-public class MessageFutureCallback<V> implements FutureCallback<V> {
-
-    private final WorldGuardPlugin plugin;
-    private final CommandSender sender;
-    @Nullable
-    private final String success;
-    @Nullable
-    private final String failure;
-
-    private MessageFutureCallback(WorldGuardPlugin plugin, CommandSender sender, @Nullable String success, @Nullable String failure) {
-        this.plugin = plugin;
-        this.sender = sender;
-        this.success = success;
-        this.failure = failure;
-    }
-
-    @Override
-    public void onSuccess(@Nullable V v) {
-        if (success != null) {
-            sender.sendMessage(ChatColor.YELLOW + success);
-        }
-    }
-
-    @Override
-    public void onFailure(@Nullable Throwable throwable) {
-        String failure = this.failure != null ? this.failure : "An error occurred";
-        sender.sendMessage(ChatColor.RED + failure + ": " + plugin.convertThrowable(throwable));
-    }
-
-    public static class Builder {
-        private final WorldGuardPlugin plugin;
-        private final CommandSender sender;
-        @Nullable
-        private String success;
-        @Nullable
-        private String failure;
-
-        public Builder(WorldGuardPlugin plugin, CommandSender sender) {
-            checkNotNull(plugin);
-            checkNotNull(sender);
-
-            this.plugin = plugin;
-            this.sender = sender;
-        }
-
-        public Builder onSuccess(@Nullable String message) {
-            this.success = message;
-            return this;
-        }
-
-        public Builder onFailure(@Nullable String message) {
-            this.failure = message;
-            return this;
-        }
-
-        public <V> MessageFutureCallback<V> build() {
-            return new MessageFutureCallback<V>(plugin, sender, success, failure);
-        }
-    }
-
-    public static <V> MessageFutureCallback<V> createRegionLoadCallback(WorldGuardPlugin plugin, CommandSender sender) {
-        return new Builder(plugin, sender)
-                .onSuccess("Successfully load the region data.")
-                .build();
-    }
-
-    public static <V> MessageFutureCallback<V> createRegionSaveCallback(WorldGuardPlugin plugin, CommandSender sender) {
-        return new Builder(plugin, sender)
-                .onSuccess("Successfully saved the region data.")
-                .build();
-    }
-
-}
@@ -1,145 +0,0 @@
-/*
- * WorldGuard, a suite of tools for Minecraft
- * Copyright (C) sk89q <http://www.sk89q.com>
- * Copyright (C) WorldGuard team and contributors
- *
- * This program is free software: you can redistribute it and/or modify it
- * under the terms of the GNU Lesser General Public License as published by the
- * Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License
- * for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-package com.sk89q.worldguard.bukkit.commands;
-
-import org.bukkit.ChatColor;
-import org.bukkit.World;
-import org.bukkit.command.CommandSender;
-import org.bukkit.entity.Entity;
-import org.bukkit.entity.Player;
-
-import com.sk89q.minecraft.util.commands.Command;
-import com.sk89q.minecraft.util.commands.CommandContext;
-import com.sk89q.minecraft.util.commands.CommandException;
-import com.sk89q.minecraft.util.commands.CommandPermissions;
-import com.sk89q.worldguard.bukkit.BukkitUtil;
-import com.sk89q.worldguard.bukkit.ConfigurationManager;
-import com.sk89q.worldguard.bukkit.WorldConfiguration;
-import com.sk89q.worldguard.bukkit.WorldGuardPlugin;
-
-public class ToggleCommands {
-    private final WorldGuardPlugin plugin;
-
-    public ToggleCommands(WorldGuardPlugin plugin) {
-        this.plugin = plugin;
-    }
-
-    @Command(aliases = {"stopfire"}, usage = "[<world>]",
-            desc = "Disables all fire spread temporarily", max = 1)
-    @CommandPermissions({"worldguard.fire-toggle.stop"})
-    public void stopFire(CommandContext args, CommandSender sender) throws CommandException {
-        
-        World world;
-        
-        if (args.argsLength() == 0) {
-            world = plugin.checkPlayer(sender).getWorld();
-        } else {
-            world = plugin.matchWorld(sender, args.getString(0));
-        }
-        
-        WorldConfiguration wcfg = plugin.getGlobalStateManager().get(world);
-
-        if (!wcfg.fireSpreadDisableToggle) {
-            plugin.getServer().broadcastMessage(
-                    ChatColor.YELLOW
-                    + "Fire spread has been globally disabled for '" + world.getName() + "' by "
-                    + plugin.toName(sender) + ".");
-        } else {
-            sender.sendMessage(
-                    ChatColor.YELLOW
-                    + "Fire spread was already globally disabled.");
-        }
-
-        wcfg.fireSpreadDisableToggle = true;
-    }
-
-    @Command(aliases = {"allowfire"}, usage = "[<world>]",
-            desc = "Allows all fire spread temporarily", max = 1)
-    @CommandPermissions({"worldguard.fire-toggle.stop"})
-    public void allowFire(CommandContext args, CommandSender sender) throws CommandException {
-        
-        World world;
-        
-        if (args.argsLength() == 0) {
-            world = plugin.checkPlayer(sender).getWorld();
-        } else {
-            world = plugin.matchWorld(sender, args.getString(0));
-        }
-        
-        WorldConfiguration wcfg = plugin.getGlobalStateManager().get(world);
-
-        if (wcfg.fireSpreadDisableToggle) {
-            plugin.getServer().broadcastMessage(ChatColor.YELLOW
-                    + "Fire spread has been globally for '" + world.getName() + "' re-enabled by "
-                    + plugin.toName(sender) + ".");
-        } else {
-            sender.sendMessage(ChatColor.YELLOW
-                    + "Fire spread was already globally enabled.");
-        }
-
-        wcfg.fireSpreadDisableToggle = false;
-    }
-
-    @Command(aliases = {"halt-activity", "stoplag", "haltactivity"},
-            desc = "Attempts to cease as much activity in order to stop lag", flags = "c", max = 0)
-    @CommandPermissions({"worldguard.halt-activity"})
-    public void stopLag(CommandContext args, CommandSender sender) throws CommandException {
-
-        ConfigurationManager configManager = plugin.getGlobalStateManager();
-
-        configManager.activityHaltToggle = !args.hasFlag('c');
-
-        if (configManager.activityHaltToggle) {
-            if (!(sender instanceof Player)) {
-                sender.sendMessage(ChatColor.YELLOW
-                        + "ALL intensive server activity halted.");
-            }
-
-            plugin.getServer().broadcastMessage(ChatColor.YELLOW
-                    + "ALL intensive server activity halted by "
-                    + plugin.toName(sender) + ".");
-
-            for (World world : plugin.getServer().getWorlds()) {
-                int removed = 0;
-
-                for (Entity entity : world.getEntities()) {
-                    if (BukkitUtil.isIntensiveEntity(entity)) {
-                        entity.remove();
-                        removed++;
-                    }
-                }
-
-                if (removed > 10) {
-                    sender.sendMessage("" + removed + " entities (>10) auto-removed from "
-                            + world.getName());
-                }
-            }
-
-        } else {
-            if (!(sender instanceof Player)) {
-                sender.sendMessage(ChatColor.YELLOW
-                        + "ALL intensive server activity no longer halted.");
-            }
-
-            plugin.getServer().broadcastMessage(ChatColor.YELLOW
-                    + "ALL intensive server activity is now allowed.");
-        }
-    }
-}
@@ -1,180 +0,0 @@
-/*
- * WorldGuard, a suite of tools for Minecraft
- * Copyright (C) sk89q <http://www.sk89q.com>
- * Copyright (C) WorldGuard team and contributors
- *
- * This program is free software: you can redistribute it and/or modify it
- * under the terms of the GNU Lesser General Public License as published by the
- * Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License
- * for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-package com.sk89q.worldguard.bukkit.commands;
-
-import com.sk89q.minecraft.util.commands.Command;
-import com.sk89q.minecraft.util.commands.CommandContext;
-import com.sk89q.minecraft.util.commands.CommandException;
-import com.sk89q.minecraft.util.commands.CommandPermissions;
-import com.sk89q.worldguard.bukkit.ConfigurationManager;
-import com.sk89q.worldguard.bukkit.WorldGuardPlugin;
-import com.sk89q.worldguard.bukkit.util.LoggerToChatHandler;
-import com.sk89q.worldguard.bukkit.util.ReportWriter;
-import com.sk89q.worldguard.util.PastebinPoster;
-import com.sk89q.worldguard.util.PastebinPoster.PasteCallback;
-import com.sk89q.worldguard.util.task.Task;
-import com.sk89q.worldguard.util.task.TaskStateComparator;
-import org.bukkit.Bukkit;
-import org.bukkit.ChatColor;
-import org.bukkit.World;
-import org.bukkit.command.CommandSender;
-import org.bukkit.entity.Player;
-
-import java.io.File;
-import java.io.IOException;
-import java.util.Collections;
-import java.util.List;
-import java.util.logging.Level;
-import java.util.logging.Logger;
-
-public class WorldGuardCommands {
-    private final WorldGuardPlugin plugin;
-
-    public WorldGuardCommands(WorldGuardPlugin plugin) {
-        this.plugin = plugin;
-    }
-
-    @Command(aliases = {"version"}, desc = "Get the WorldGuard version", max = 0)
-    public void version(CommandContext args, CommandSender sender) throws CommandException {
-        sender.sendMessage(ChatColor.YELLOW
-                + "WorldGuard " + plugin.getDescription().getVersion());
-        sender.sendMessage(ChatColor.YELLOW
-                + "http://www.sk89q.com");
-    }
-
-    @Command(aliases = {"reload"}, desc = "Reload WorldGuard configuration", max = 0)
-    @CommandPermissions({"worldguard.reload"})
-    public void reload(CommandContext args, CommandSender sender) throws CommandException {
-        // TODO: This is subject to a race condition, but at least other commands are not being processed concurrently
-        List<Task<?>> tasks = plugin.getSupervisor().getTasks();
-        if (!tasks.isEmpty()) {
-            throw new CommandException("There are currently pending tasks. Use /wg running to monitor these tasks first.");
-        }
-        
-        LoggerToChatHandler handler = null;
-        Logger minecraftLogger = null;
-        
-        if (sender instanceof Player) {
-            handler = new LoggerToChatHandler(sender);
-            handler.setLevel(Level.ALL);
-            minecraftLogger = Logger.getLogger("com.sk89q.worldguard");
-            minecraftLogger.addHandler(handler);
-        }
-
-        try {
-            ConfigurationManager config = plugin.getGlobalStateManager();
-            config.unload();
-            config.load();
-            for (World world : Bukkit.getServer().getWorlds()) {
-                config.get(world);
-            }
-            plugin.getRegionContainer().reload();
-            // WGBukkit.cleanCache();
-            sender.sendMessage("WorldGuard configuration reloaded.");
-        } catch (Throwable t) {
-            sender.sendMessage("Error while reloading: "
-                    + t.getMessage());
-        } finally {
-            if (minecraftLogger != null) {
-                minecraftLogger.removeHandler(handler);
-            }
-        }
-    }
-    
-    @Command(aliases = {"report"}, desc = "Writes a report on WorldGuard", flags = "p", max = 0)
-    @CommandPermissions({"worldguard.report"})
-    public void report(CommandContext args, final CommandSender sender) throws CommandException {
-        
-        File dest = new File(plugin.getDataFolder(), "report.txt");
-        ReportWriter report = new ReportWriter(plugin);
-        
-        try {
-            report.write(dest);
-            sender.sendMessage(ChatColor.YELLOW + "WorldGuard report written to "
-                    + dest.getAbsolutePath());
-        } catch (IOException e) {
-            throw new CommandException("Failed to write report: " + e.getMessage());
-        }
-        
-        if (args.hasFlag('p')) {
-            plugin.checkPermission(sender, "worldguard.report.pastebin");
-            
-            sender.sendMessage(ChatColor.YELLOW + "Now uploading to Pastebin...");
-            PastebinPoster.paste(report.toString(), new PasteCallback() {
-                
-                public void handleSuccess(String url) {
-                    // Hope we don't have a thread safety issue here
-                    sender.sendMessage(ChatColor.YELLOW + "WorldGuard report (1 hour): " + url);
-                }
-                
-                public void handleError(String err) {
-                    // Hope we don't have a thread safety issue here
-                    sender.sendMessage(ChatColor.YELLOW + "WorldGuard report pastebin error: " + err);
-                }
-            });
-        }
-
-    }
-
-    @Command(aliases = {"flushstates", "clearstates"},
-            usage = "[player]", desc = "Flush the state manager", max = 1)
-    @CommandPermissions("worldguard.flushstates")
-    public void flushStates(CommandContext args, CommandSender sender) throws CommandException {
-        if (args.argsLength() == 0) {
-            plugin.getFlagStateManager().forgetAll();
-            sender.sendMessage("Cleared all states.");
-        } else {
-            Player player = plugin.getServer().getPlayer(args.getString(0));
-            if (player != null) {
-                plugin.getFlagStateManager().forget(player);
-                sender.sendMessage("Cleared states for player \"" + player.getName() + "\".");
-            }
-        }
-    }
-
-    @Command(aliases = {"running", "queue"}, desc = "List running tasks", max = 0)
-    @CommandPermissions("worldguard.running")
-    public void listRunningTasks(CommandContext args, CommandSender sender) throws CommandException {
-        List<Task<?>> tasks = plugin.getSupervisor().getTasks();
-
-        if (!tasks.isEmpty()) {
-            Collections.sort(tasks, new TaskStateComparator());
-            StringBuilder builder = new StringBuilder();
-            builder.append(ChatColor.GRAY);
-            builder.append("\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550");
-            builder.append(" Running tasks ");
-            builder.append("\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550");
-            builder.append("\n").append(ChatColor.GRAY).append("Note: Some 'running' tasks may be waiting to be start.");
-            for (Task task : tasks) {
-                builder.append("\n");
-                builder.append(ChatColor.BLUE).append("(").append(task.getState().name()).append(") ");
-                builder.append(ChatColor.YELLOW);
-                builder.append(CommandUtils.getOwnerName(task.getOwner()));
-                builder.append(": ");
-                builder.append(ChatColor.WHITE);
-                builder.append(task.getName());
-            }
-            sender.sendMessage(builder.toString());
-        } else {
-            sender.sendMessage(ChatColor.YELLOW + "There are currently no running tasks.");
-        }
-    }
-
-}
@@ -1,242 +0,0 @@
-/*
- * WorldGuard, a suite of tools for Minecraft
- * Copyright (C) sk89q <http://www.sk89q.com>
- * Copyright (C) WorldGuard team and contributors
- *
- * This program is free software: you can redistribute it and/or modify it
- * under the terms of the GNU Lesser General Public License as published by the
- * Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License
- * for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-package com.sk89q.worldguard.bukkit.commands.region;
-
-import com.google.common.util.concurrent.Futures;
-import com.google.common.util.concurrent.ListenableFuture;
-import com.sk89q.minecraft.util.commands.Command;
-import com.sk89q.minecraft.util.commands.CommandContext;
-import com.sk89q.minecraft.util.commands.CommandException;
-import com.sk89q.minecraft.util.commands.CommandPermissionsException;
-import com.sk89q.worldguard.LocalPlayer;
-import com.sk89q.worldguard.bukkit.WorldGuardPlugin;
-import com.sk89q.worldguard.bukkit.commands.AsyncCommandHelper;
-import com.sk89q.worldguard.domains.DefaultDomain;
-import com.sk89q.worldguard.protection.util.DomainInputResolver;
-import com.sk89q.worldguard.protection.util.DomainInputResolver.UserLocatorPolicy;
-import com.sk89q.worldguard.protection.flags.DefaultFlag;
-import com.sk89q.worldguard.protection.managers.RegionManager;
-import com.sk89q.worldguard.protection.regions.ProtectedRegion;
-import org.bukkit.World;
-import org.bukkit.command.CommandSender;
-import org.bukkit.entity.Player;
-
-public class MemberCommands extends RegionCommandsBase {
-
-    private final WorldGuardPlugin plugin;
-
-    public MemberCommands(WorldGuardPlugin plugin) {
-        this.plugin = plugin;
-    }
-
-    @Command(aliases = {"addmember", "addmember", "addmem", "am"},
-            usage = "<id> <members...>",
-            flags = "nw:",
-            desc = "Add a member to a region",
-            min = 2)
-    public void addMember(CommandContext args, CommandSender sender) throws CommandException {
-        warnAboutSaveFailures(sender);
-
-        World world = checkWorld(args, sender, 'w'); // Get the world
-        String id = args.getString(0);
-        RegionManager manager = checkRegionManager(plugin, world);
-        ProtectedRegion region = checkExistingRegion(manager, id, true);
-
-        id = region.getId();
-
-        // Check permissions
-        if (!getPermissionModel(sender).mayAddMembers(region)) {
-            throw new CommandPermissionsException();
-        }
-
-        // Resolve members asynchronously
-        DomainInputResolver resolver = new DomainInputResolver(
-                plugin.getProfileService(), args.getParsedPaddedSlice(1, 0));
-        resolver.setLocatorPolicy(args.hasFlag('n') ? UserLocatorPolicy.NAME_ONLY : UserLocatorPolicy.UUID_ONLY);
-
-        // Then add it to the members
-        ListenableFuture<DefaultDomain> future = Futures.transform(
-                plugin.getExecutorService().submit(resolver),
-                resolver.createAddAllFunction(region.getMembers()));
-
-        AsyncCommandHelper.wrap(future, plugin, sender)
-                .formatUsing(region.getId(), world.getName())
-                .registerWithSupervisor("Adding members to the region '%s' on '%s'")
-                .sendMessageAfterDelay("(Please wait... querying player names...)")
-                .thenRespondWith("Region '%s' updated with new members.", "Failed to add new members");
-    }
-
-    @Command(aliases = {"addowner", "addowner", "ao"},
-            usage = "<id> <owners...>",
-            flags = "nw:",
-            desc = "Add an owner to a region",
-            min = 2)
-    public void addOwner(CommandContext args, CommandSender sender) throws CommandException {
-        warnAboutSaveFailures(sender);
-
-        World world = checkWorld(args, sender, 'w'); // Get the world
-
-        Player player = null;
-        LocalPlayer localPlayer = null;
-        if (sender instanceof Player) {
-            player = (Player) sender;
-            localPlayer = plugin.wrapPlayer(player);
-        }
-
-        String id = args.getString(0);
-
-        RegionManager manager = checkRegionManager(plugin, world);
-        ProtectedRegion region = checkExistingRegion(manager, id, true);
-
-        id = region.getId();
-
-        Boolean flag = region.getFlag(DefaultFlag.BUYABLE);
-        DefaultDomain owners = region.getOwners();
-
-        if (localPlayer != null) {
-            if (flag != null && flag && owners != null && owners.size() == 0) {
-                // TODO: Move this to an event
-                if (!plugin.hasPermission(player, "worldguard.region.unlimited")) {
-                    int maxRegionCount = plugin.getGlobalStateManager().get(world).getMaxRegionCount(player);
-                    if (maxRegionCount >= 0 && manager.getRegionCountOfPlayer(localPlayer)
-                            >= maxRegionCount) {
-                        throw new CommandException("You already own the maximum allowed amount of regions.");
-                    }
-                }
-                plugin.checkPermission(sender, "worldguard.region.addowner.unclaimed." + id.toLowerCase());
-            } else {
-                // Check permissions
-                if (!getPermissionModel(sender).mayAddOwners(region)) {
-                    throw new CommandPermissionsException();
-                }
-            }
-        }
-
-        // Resolve owners asynchronously
-        DomainInputResolver resolver = new DomainInputResolver(
-                plugin.getProfileService(), args.getParsedPaddedSlice(1, 0));
-        resolver.setLocatorPolicy(args.hasFlag('n') ? UserLocatorPolicy.NAME_ONLY : UserLocatorPolicy.UUID_ONLY);
-
-        // Then add it to the owners
-        ListenableFuture<DefaultDomain> future = Futures.transform(
-                plugin.getExecutorService().submit(resolver),
-                resolver.createAddAllFunction(region.getOwners()));
-
-        AsyncCommandHelper.wrap(future, plugin, sender)
-                .formatUsing(region.getId(), world.getName())
-                .registerWithSupervisor("Adding owners to the region '%s' on '%s'")
-                .sendMessageAfterDelay("(Please wait... querying player names...)")
-                .thenRespondWith("Region '%s' updated with new owners.", "Failed to add new owners");
-    }
-
-    @Command(aliases = {"removemember", "remmember", "removemem", "remmem", "rm"},
-            usage = "<id> <owners...>",
-            flags = "naw:",
-            desc = "Remove an owner to a region",
-            min = 1)
-    public void removeMember(CommandContext args, CommandSender sender) throws CommandException {
-        warnAboutSaveFailures(sender);
-
-        World world = checkWorld(args, sender, 'w'); // Get the world
-        String id = args.getString(0);
-        RegionManager manager = checkRegionManager(plugin, world);
-        ProtectedRegion region = checkExistingRegion(manager, id, true);
-
-        // Check permissions
-        if (!getPermissionModel(sender).mayRemoveMembers(region)) {
-            throw new CommandPermissionsException();
-        }
-
-        ListenableFuture<?> future;
-
-        if (args.hasFlag('a')) {
-            region.getMembers().removeAll();
-
-            future = Futures.immediateFuture(null);
-        } else {
-            if (args.argsLength() < 2) {
-                throw new CommandException("List some names to remove, or use -a to remove all.");
-            }
-
-            // Resolve members asynchronously
-            DomainInputResolver resolver = new DomainInputResolver(
-                    plugin.getProfileService(), args.getParsedPaddedSlice(1, 0));
-            resolver.setLocatorPolicy(args.hasFlag('n') ? UserLocatorPolicy.NAME_ONLY : UserLocatorPolicy.UUID_AND_NAME);
-
-            // Then remove it from the members
-            future = Futures.transform(
-                    plugin.getExecutorService().submit(resolver),
-                    resolver.createRemoveAllFunction(region.getMembers()));
-        }
-
-        AsyncCommandHelper.wrap(future, plugin, sender)
-                .formatUsing(region.getId(), world.getName())
-                .registerWithSupervisor("Removing members from the region '%s' on '%s'")
-                .sendMessageAfterDelay("(Please wait... querying player names...)")
-                .thenRespondWith("Region '%s' updated with members removed.", "Failed to remove members");
-    }
-
-    @Command(aliases = {"removeowner", "remowner", "ro"},
-            usage = "<id> <owners...>",
-            flags = "naw:",
-            desc = "Remove an owner to a region",
-            min = 1)
-    public void removeOwner(CommandContext args, CommandSender sender) throws CommandException {
-        warnAboutSaveFailures(sender);
-
-        World world = checkWorld(args, sender, 'w'); // Get the world
-        String id = args.getString(0);
-        RegionManager manager = checkRegionManager(plugin, world);
-        ProtectedRegion region = checkExistingRegion(manager, id, true);
-
-        // Check permissions
-        if (!getPermissionModel(sender).mayRemoveOwners(region)) {
-            throw new CommandPermissionsException();
-        }
-
-        ListenableFuture<?> future;
-
-        if (args.hasFlag('a')) {
-            region.getOwners().removeAll();
-
-            future = Futures.immediateFuture(null);
-        } else {
-            if (args.argsLength() < 2) {
-                throw new CommandException("List some names to remove, or use -a to remove all.");
-            }
-
-            // Resolve owners asynchronously
-            DomainInputResolver resolver = new DomainInputResolver(
-                    plugin.getProfileService(), args.getParsedPaddedSlice(1, 0));
-            resolver.setLocatorPolicy(args.hasFlag('n') ? UserLocatorPolicy.NAME_ONLY : UserLocatorPolicy.UUID_AND_NAME);
-
-            // Then remove it from the owners
-            future = Futures.transform(
-                    plugin.getExecutorService().submit(resolver),
-                    resolver.createRemoveAllFunction(region.getOwners()));
-        }
-
-        AsyncCommandHelper.wrap(future, plugin, sender)
-                .formatUsing(region.getId(), world.getName())
-                .registerWithSupervisor("Removing owners from the region '%s' on '%s'")
-                .sendMessageAfterDelay("(Please wait... querying player names...)")
-                .thenRespondWith("Region '%s' updated with owners removed.", "Failed to remove owners");
-    }
-}
@@ -1,397 +0,0 @@
-/*
- * WorldGuard, a suite of tools for Minecraft
- * Copyright (C) sk89q <http://www.sk89q.com>
- * Copyright (C) WorldGuard team and contributors
- *
- * This program is free software: you can redistribute it and/or modify it
- * under the terms of the GNU Lesser General Public License as published by the
- * Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License
- * for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-package com.sk89q.worldguard.bukkit.commands.region;
-
-import com.google.common.base.Function;
-import com.google.common.base.Joiner;
-import com.google.common.collect.Iterables;
-import com.sk89q.minecraft.util.commands.CommandContext;
-import com.sk89q.minecraft.util.commands.CommandException;
-import com.sk89q.worldedit.BlockVector;
-import com.sk89q.worldedit.Vector;
-import com.sk89q.worldedit.bukkit.WorldEditPlugin;
-import com.sk89q.worldedit.bukkit.selections.CuboidSelection;
-import com.sk89q.worldedit.bukkit.selections.Polygonal2DSelection;
-import com.sk89q.worldedit.bukkit.selections.Selection;
-import com.sk89q.worldguard.bukkit.RegionContainer;
-import com.sk89q.worldguard.bukkit.WorldGuardPlugin;
-import com.sk89q.worldguard.bukkit.permission.RegionPermissionModel;
-import com.sk89q.worldguard.protection.ApplicableRegionSet;
-import com.sk89q.worldguard.protection.flags.Flag;
-import com.sk89q.worldguard.protection.flags.InvalidFlagFormat;
-import com.sk89q.worldguard.protection.managers.RegionManager;
-import com.sk89q.worldguard.protection.regions.GlobalProtectedRegion;
-import com.sk89q.worldguard.protection.regions.ProtectedCuboidRegion;
-import com.sk89q.worldguard.protection.regions.ProtectedPolygonalRegion;
-import com.sk89q.worldguard.protection.regions.ProtectedRegion;
-import org.bukkit.ChatColor;
-import org.bukkit.World;
-import org.bukkit.command.CommandSender;
-import org.bukkit.entity.Player;
-
-import java.util.Set;
-
-class RegionCommandsBase {
-
-    protected RegionCommandsBase() {
-    }
-
-    /**
-     * Get the permission model to lookup permissions.
-     *
-     * @param sender the sender
-     * @return the permission model
-     */
-    protected static RegionPermissionModel getPermissionModel(CommandSender sender) {
-        return new RegionPermissionModel(WorldGuardPlugin.inst(), sender);
-    }
-
-    /**
-     * Gets the world from the given flag, or falling back to the the current player
-     * if the sender is a player, otherwise reporting an error.
-     *
-     * @param args the arguments
-     * @param sender the sender
-     * @param flag the flag (such as 'w')
-     * @return a world
-     * @throws CommandException on error
-     */
-    protected static World checkWorld(CommandContext args, CommandSender sender, char flag) throws CommandException {
-        if (args.hasFlag(flag)) {
-            return WorldGuardPlugin.inst().matchWorld(sender, args.getFlag(flag));
-        } else {
-            if (sender instanceof Player) {
-                return WorldGuardPlugin.inst().checkPlayer(sender).getWorld();
-            } else {
-                throw new CommandException("Please specify " + "the world with -" + flag + " world_name.");
-            }
-        }
-    }
-
-    /**
-     * Validate a region ID.
-     *
-     * @param id the id
-     * @param allowGlobal whether __global__ is allowed
-     * @return the id given
-     * @throws CommandException thrown on an error
-     */
-    protected static String checkRegionId(String id, boolean allowGlobal) throws CommandException {
-        if (!ProtectedRegion.isValidId(id)) {
-            throw new CommandException(
-                    "The region name of '" + id + "' contains characters that are not allowed.");
-        }
-
-        if (!allowGlobal && id.equalsIgnoreCase("__global__")) { // Sorry, no global
-            throw new CommandException(
-                    "Sorry, you can't use __global__ here.");
-        }
-
-        return id;
-    }
-
-    /**
-     * Get a protected region by a given name, otherwise throw a
-     * {@link CommandException}.
-     *
-     * <p>This also validates the region ID.</p>
-     *
-     * @param regionManager the region manager
-     * @param id the name to search
-     * @param allowGlobal true to allow selecting __global__
-     * @throws CommandException thrown if no region is found by the given name
-     */
-    protected static ProtectedRegion checkExistingRegion(RegionManager regionManager, String id, boolean allowGlobal) throws CommandException {
-        // Validate the id
-        checkRegionId(id, allowGlobal);
-
-        ProtectedRegion region = regionManager.getRegion(id);
-
-        // No region found!
-        if (region == null) {
-            // But we want a __global__, so let's create one
-            if (id.equalsIgnoreCase("__global__")) {
-                region = new GlobalProtectedRegion(id);
-                regionManager.addRegion(region);
-                return region;
-            }
-
-            throw new CommandException(
-                    "No region could be found with the name of '" + id + "'.");
-        }
-
-        return region;
-    }
-
-
-    /**
-     * Get the region at the player's location, if possible.
-     *
-     * <p>If the player is standing in several regions, an error will be raised
-     * and a list of regions will be provided.</p>
-     *
-     * @param regionManager the region manager
-     * @param player the player
-     * @return a region
-     * @throws CommandException thrown if no region was found
-     */
-    protected static ProtectedRegion checkRegionStandingIn(RegionManager regionManager, Player player) throws CommandException {
-        return checkRegionStandingIn(regionManager, player, false);
-    }
-
-    /**
-     * Get the region at the player's location, if possible.
-     *
-     * <p>If the player is standing in several regions, an error will be raised
-     * and a list of regions will be provided.</p>
-     *
-     * <p>If the player is not standing in any regions, the global region will
-     * returned if allowGlobal is true and it exists.</p>
-     *
-     * @param regionManager the region manager
-     * @param player the player
-     * @param allowGlobal whether to search for a global region if no others are found
-     * @return a region
-     * @throws CommandException thrown if no region was found
-     */
-    protected static ProtectedRegion checkRegionStandingIn(RegionManager regionManager, Player player, boolean allowGlobal) throws CommandException {
-        ApplicableRegionSet set = regionManager.getApplicableRegions(player.getLocation());
-
-        if (set.size() == 0) {
-            if (allowGlobal) {
-                ProtectedRegion global = checkExistingRegion(regionManager, "__global__", true);
-                player.sendMessage(ChatColor.GRAY + "You're not standing in any " +
-                        "regions. Using the global region for this world instead.");
-                return global;
-            }
-            throw new CommandException(
-                    "You're not standing in a region." +
-                            "Specify an ID if you want to select a specific region.");
-        } else if (set.size() > 1) {
-            StringBuilder builder = new StringBuilder();
-            boolean first = true;
-
-            for (ProtectedRegion region : set) {
-                if (!first) {
-                    builder.append(", ");
-                }
-                first = false;
-                builder.append(region.getId());
-            }
-
-            throw new CommandException(
-                    "You're standing in several regions (please pick one).\nYou're in: " + builder.toString());
-        }
-
-        return set.iterator().next();
-    }
-
-    /**
-     * Get a WorldEdit selection for a player, or emit an exception if there is none
-     * available.
-     *
-     * @param player the player
-     * @return the selection
-     * @throws CommandException thrown on an error
-     */
-    protected static Selection checkSelection(Player player) throws CommandException {
-        WorldEditPlugin worldEdit = WorldGuardPlugin.inst().getWorldEdit();
-        Selection selection = worldEdit.getSelection(player);
-
-        if (selection == null) {
-            throw new CommandException(
-                    "Please select an area first. " +
-                            "Use WorldEdit to make a selection! " +
-                            "(wiki: http://wiki.sk89q.com/wiki/WorldEdit).");
-        }
-
-        return selection;
-    }
-
-    /**
-     * Check that a region with the given ID does not already exist.
-     *
-     * @param manager the manager
-     * @param id the ID
-     * @throws CommandException thrown if the ID already exists
-     */
-    protected static void checkRegionDoesNotExist(RegionManager manager, String id, boolean mayRedefine) throws CommandException {
-        if (manager.hasRegion(id)) {
-            throw new CommandException("A region with that name already exists. Please choose another name." +
-                    (mayRedefine ? " To change the shape, use /region redefine " + id + "." : ""));
-        }
-    }
-
-    /**
-     * Check that the given region manager is not null.
-     *
-     * @param plugin the plugin
-     * @param world the world
-     * @throws CommandException thrown if the manager is null
-     */
-    protected static RegionManager checkRegionManager(WorldGuardPlugin plugin, World world) throws CommandException {
-        if (!plugin.getGlobalStateManager().get(world).useRegions) {
-            throw new CommandException("Region support is disabled in the target world. " +
-                    "It can be enabled per-world in WorldGuard's configuration files. " +
-                    "However, you may need to restart your server afterwards.");
-        }
-
-        RegionManager manager = plugin.getRegionContainer().get(world);
-        if (manager == null) {
-            throw new CommandException("Region data failed to load for this world. " +
-                    "Please ask a server administrator to read the logs to identify the reason.");
-        }
-        return manager;
-    }
-
-    /**
-     * Create a {@link ProtectedRegion} from the player's selection.
-     *
-     * @param player the player
-     * @param id the ID of the new region
-     * @return a new region
-     * @throws CommandException thrown on an error
-     */
-    protected static ProtectedRegion checkRegionFromSelection(Player player, String id) throws CommandException {
-        Selection selection = checkSelection(player);
-
-        // Detect the type of region from WorldEdit
-        if (selection instanceof Polygonal2DSelection) {
-            Polygonal2DSelection polySel = (Polygonal2DSelection) selection;
-            int minY = polySel.getNativeMinimumPoint().getBlockY();
-            int maxY = polySel.getNativeMaximumPoint().getBlockY();
-            return new ProtectedPolygonalRegion(id, polySel.getNativePoints(), minY, maxY);
-        } else if (selection instanceof CuboidSelection) {
-            BlockVector min = selection.getNativeMinimumPoint().toBlockVector();
-            BlockVector max = selection.getNativeMaximumPoint().toBlockVector();
-            return new ProtectedCuboidRegion(id, min, max);
-        } else {
-            throw new CommandException("Sorry, you can only use cuboids and polygons for WorldGuard regions.");
-        }
-    }
-
-    /**
-     * Warn the region saving is failing.
-     *
-     * @param sender the sender to send the message to
-     */
-    protected static void warnAboutSaveFailures(CommandSender sender) {
-        RegionContainer container = WorldGuardPlugin.inst().getRegionContainer();
-        Set<RegionManager> failures = container.getSaveFailures();
-
-        if (failures.size() > 0) {
-            String failingList = Joiner.on(", ").join(Iterables.transform(failures, new Function<RegionManager, String>() {
-                @Override
-                public String apply(RegionManager regionManager) {
-                    return "'" + regionManager.getName() + "'";
-                }
-            }));
-
-            sender.sendMessage(ChatColor.GOLD +
-                    "(Warning: The background saving of region data is failing for these worlds: " + failingList + ". " +
-                    "Your changes are getting lost. See the server log for more information.)");
-        }
-    }
-
-    /**
-     * Warn the sender if the dimensions of the given region are worrying.
-     *
-     * @param sender the sender to send the message to
-     * @param region the region
-     */
-    protected static void warnAboutDimensions(CommandSender sender, ProtectedRegion region) {
-        int height = region.getMaximumPoint().getBlockY() - region.getMinimumPoint().getBlockY();
-        if (height <= 2) {
-            sender.sendMessage(ChatColor.GRAY + "(Warning: The height of the region was " + (height + 1) + " block(s).)");
-        }
-    }
-
-    /**
-     * Inform a new user about automatic protection.
-     *
-     * @param sender the sender to send the message to
-     * @param manager the region manager
-     * @param region the region
-     */
-    protected static void informNewUser(CommandSender sender, RegionManager manager, ProtectedRegion region) {
-        if (manager.getRegions().size() <= 2) {
-            sender.sendMessage(ChatColor.GRAY +
-                    "(This region is NOW PROTECTED from modification from others. " +
-                    "Don't want that? Use " +
-                    ChatColor.AQUA + "/rg flag " + region.getId() + " passthrough allow" +
-                    ChatColor.GRAY + ")");
-        }
-    }
-
-    /**
-     * Set a player's selection to a given region.
-     *
-     * @param player the player
-     * @param region the region
-     * @throws CommandException thrown on a command error
-     */
-    protected static void setPlayerSelection(Player player, ProtectedRegion region) throws CommandException {
-        WorldEditPlugin worldEdit = WorldGuardPlugin.inst().getWorldEdit();
-
-        World world = player.getWorld();
-
-        // Set selection
-        if (region instanceof ProtectedCuboidRegion) {
-            ProtectedCuboidRegion cuboid = (ProtectedCuboidRegion) region;
-            Vector pt1 = cuboid.getMinimumPoint();
-            Vector pt2 = cuboid.getMaximumPoint();
-            CuboidSelection selection = new CuboidSelection(world, pt1, pt2);
-            worldEdit.setSelection(player, selection);
-            player.sendMessage(ChatColor.YELLOW + "Region selected as a cuboid.");
-
-        } else if (region instanceof ProtectedPolygonalRegion) {
-            ProtectedPolygonalRegion poly2d = (ProtectedPolygonalRegion) region;
-            Polygonal2DSelection selection = new Polygonal2DSelection(
-                    world, poly2d.getPoints(),
-                    poly2d.getMinimumPoint().getBlockY(),
-                    poly2d.getMaximumPoint().getBlockY() );
-            worldEdit.setSelection(player, selection);
-            player.sendMessage(ChatColor.YELLOW + "Region selected as a polygon.");
-
-        } else if (region instanceof GlobalProtectedRegion) {
-            throw new CommandException(
-                    "Can't select global regions! " +
-                            "That would cover the entire world.");
-
-        } else {
-            throw new CommandException("Unknown region type: " +
-                    region.getClass().getCanonicalName());
-        }
-    }
-
-    /**
-     * Utility method to set a flag.
-     *
-     * @param region the region
-     * @param flag the flag
-     * @param sender the sender
-     * @param value the value
-     * @throws InvalidFlagFormat thrown if the value is invalid
-     */
-    protected static <V> void setFlag(ProtectedRegion region, Flag<V> flag, CommandSender sender, String value) throws InvalidFlagFormat {
-        region.setFlag(flag, flag.parseInput(WorldGuardPlugin.inst(), sender, value));
-    }
-
-}
@@ -1,343 +0,0 @@
-/*
- * WorldGuard, a suite of tools for Minecraft
- * Copyright (C) sk89q <http://www.sk89q.com>
- * Copyright (C) WorldGuard team and contributors
- *
- * This program is free software: you can redistribute it and/or modify it
- * under the terms of the GNU Lesser General Public License as published by the
- * Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License
- * for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-package com.sk89q.worldguard.bukkit.commands.region;
-
-import com.sk89q.squirrelid.cache.ProfileCache;
-import com.sk89q.worldedit.BlockVector;
-import com.sk89q.worldguard.domains.DefaultDomain;
-import com.sk89q.worldguard.protection.flags.DefaultFlag;
-import com.sk89q.worldguard.protection.flags.Flag;
-import com.sk89q.worldguard.protection.flags.RegionGroupFlag;
-import com.sk89q.worldguard.protection.regions.ProtectedRegion;
-import org.bukkit.ChatColor;
-import org.bukkit.command.CommandSender;
-
-import javax.annotation.Nullable;
-import java.util.ArrayList;
-import java.util.List;
-import java.util.ListIterator;
-import java.util.concurrent.Callable;
-
-/**
- * Create a region printout, as used in /region info to show information about
- * a region.
- */
-public class RegionPrintoutBuilder implements Callable<String> {
-    
-    private final ProtectedRegion region;
-    @Nullable
-    private final ProfileCache cache;
-    private final StringBuilder builder = new StringBuilder();
-
-    /**
-     * Create a new instance with a region to report on.
-     *
-     * @param region the region
-     * @param cache a profile cache, or {@code null}
-     */
-    public RegionPrintoutBuilder(ProtectedRegion region, @Nullable ProfileCache cache) {
-        this.region = region;
-        this.cache = cache;
-    }
-
-    /**
-     * Add a new line.
-     */
-    private void newLine() {
-        builder.append("\n");
-    }
-    
-    /**
-     * Add region name, type, and priority.
-     */
-    public void appendBasics() {
-        builder.append(ChatColor.BLUE);
-        builder.append("Region: ");
-        builder.append(ChatColor.YELLOW);
-        builder.append(region.getId());
-        
-        builder.append(ChatColor.GRAY);
-        builder.append(" (type=");
-        builder.append(region.getType().getName());
-        
-        builder.append(ChatColor.GRAY);
-        builder.append(", priority=");
-        builder.append(region.getPriority());
-        builder.append(")");
-
-        newLine();
-    }
-    
-    /**
-     * Add information about flags.
-     */
-    public void appendFlags() {
-        builder.append(ChatColor.BLUE);
-        builder.append("Flags: ");
-        
-        appendFlagsList(true);
-        
-        newLine();
-    }
-    
-    /**
-     * Append just the list of flags (without "Flags:"), including colors.
-     *
-     * @param useColors true to use colors
-     */
-    public void appendFlagsList(boolean useColors) {
-        boolean hasFlags = false;
-        
-        for (Flag<?> flag : DefaultFlag.getFlags()) {
-            Object val = region.getFlag(flag), group = null;
-            
-            // No value
-            if (val == null) {
-                continue;
-            }
-
-            if (hasFlags) {
-                builder.append(", ");
-            } else {
-                if (useColors) {
-                    builder.append(ChatColor.YELLOW);
-                }
-            }
-
-            RegionGroupFlag groupFlag = flag.getRegionGroupFlag();
-            if (groupFlag != null) {
-                group = region.getFlag(groupFlag);
-            }
-
-            if (group == null) {
-                builder.append(flag.getName()).append(": ")
-                        .append(ChatColor.stripColor(String.valueOf(val)));
-            } else {
-                builder.append(flag.getName()).append(" -g ")
-                        .append(group).append(": ")
-                        .append(ChatColor.stripColor(String.valueOf(val)));
-            }
-
-            hasFlags = true;
-        }
-            
-        if (!hasFlags) {
-            if (useColors) {
-                builder.append(ChatColor.RED);
-            }
-            builder.append("(none)");
-        }
-    }
-    
-    /**
-     * Add information about parents.
-     */
-    public void appendParents() {
-        appendParentTree(true);
-    }
-    
-    /**
-     * Add information about parents.
-     * 
-     * @param useColors true to use colors
-     */
-    public void appendParentTree(boolean useColors) {
-        if (region.getParent() == null) {
-            return;
-        }
-        
-        List<ProtectedRegion> inheritance = new ArrayList<ProtectedRegion>();
-
-        ProtectedRegion r = region;
-        inheritance.add(r);
-        while (r.getParent() != null) {
-            r = r.getParent();
-            inheritance.add(r);
-        }
-
-        ListIterator<ProtectedRegion> it = inheritance.listIterator(
-                inheritance.size());
-
-        int indent = 0;
-        while (it.hasPrevious()) {
-            ProtectedRegion cur = it.previous();
-            if (useColors) {
-                builder.append(ChatColor.GREEN);
-            }
-            
-            // Put symbol for child
-            if (indent != 0) {
-                for (int i = 0; i < indent; i++) {
-                    builder.append("  ");
-                }
-                builder.append("\u2517");
-            }
-            
-            // Put name
-            builder.append(cur.getId());
-            
-            // Put (parent)
-            if (!cur.equals(region)) {
-                if (useColors) {
-                    builder.append(ChatColor.GRAY);
-                }
-                builder.append(" (parent, priority=").append(cur.getPriority()).append(")");
-            }
-            
-            indent++;
-            newLine();
-        }
-    }
-    
-    /**
-     * Add information about members.
-     */
-    public void appendDomain() {
-        builder.append(ChatColor.BLUE);
-        builder.append("Owners: ");
-        addDomainString(region.getOwners());
-        newLine();
-
-        builder.append(ChatColor.BLUE);
-        builder.append("Members: ");
-        addDomainString(region.getMembers());
-        newLine();
-    }
-
-    private void addDomainString(DefaultDomain domain) {
-        if (domain.size() != 0) {
-            builder.append(ChatColor.YELLOW);
-            builder.append(domain.toUserFriendlyString(cache));
-        } else {
-            builder.append(ChatColor.RED);
-            builder.append("(none)");
-        }
-    }
-    
-    /**
-     * Add information about coordinates.
-     */
-    public void appendBounds() {
-        BlockVector min = region.getMinimumPoint();
-        BlockVector max = region.getMaximumPoint();
-        builder.append(ChatColor.BLUE);
-        builder.append("Bounds:");
-        builder.append(ChatColor.YELLOW);
-        builder.append(" (").append(min.getBlockX()).append(",").append(min.getBlockY()).append(",").append(min.getBlockZ()).append(")");
-        builder.append(" -> (").append(max.getBlockX()).append(",").append(max.getBlockY()).append(",").append(max.getBlockZ()).append(")");
-        
-        newLine();
-    }
-
-    private void appendRegionInformation() {
-        builder.append(ChatColor.GRAY);
-        builder.append("\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550");
-        builder.append(" Region Info ");
-        builder.append("\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550");
-        newLine();
-        appendBasics();
-        appendFlags();
-        appendParents();
-        appendDomain();
-        appendBounds();
-
-        if (cache != null) {
-            builder.append(ChatColor.GRAY).append("Any names suffixed by * are 'last seen names' and may not be up to date.");
-            newLine();
-        }
-    }
-
-    @Override
-    public String call() throws Exception {
-        appendRegionInformation();
-        return builder.toString();
-    }
-
-    /**
-     * Send the report to a {@link CommandSender}.
-     *
-     * @param sender the recipient
-     */
-    public void send(CommandSender sender) {
-        sender.sendMessage(toString());
-    }
-
-    public StringBuilder append(boolean b) {
-        return builder.append(b);
-    }
-
-    public StringBuilder append(char c) {
-        return builder.append(c);
-    }
-
-    public StringBuilder append(char[] str, int offset, int len) {
-        return builder.append(str, offset, len);
-    }
-
-    public StringBuilder append(char[] str) {
-        return builder.append(str);
-    }
-
-    public StringBuilder append(CharSequence s, int start, int end) {
-        return builder.append(s, start, end);
-    }
-
-    public StringBuilder append(CharSequence s) {
-        return builder.append(s);
-    }
-
-    public StringBuilder append(double d) {
-        return builder.append(d);
-    }
-
-    public StringBuilder append(float f) {
-        return builder.append(f);
-    }
-
-    public StringBuilder append(int i) {
-        return builder.append(i);
-    }
-
-    public StringBuilder append(long lng) {
-        return builder.append(lng);
-    }
-
-    public StringBuilder append(Object obj) {
-        return builder.append(obj);
-    }
-
-    public StringBuilder append(String str) {
-        return builder.append(str);
-    }
-
-    public StringBuilder append(StringBuffer sb) {
-        return builder.append(sb);
-    }
-
-    public StringBuilder appendCodePoint(int codePoint) {
-        return builder.appendCodePoint(codePoint);
-    }
-    
-    @Override
-    public String toString() {
-        return builder.toString().trim();
-    }
-
-}
@@ -1,232 +0,0 @@
-/*
- * WorldGuard, a suite of tools for Minecraft
- * Copyright (C) sk89q <http://www.sk89q.com>
- * Copyright (C) WorldGuard team and contributors
- *
- * This program is free software: you can redistribute it and/or modify it
- * under the terms of the GNU Lesser General Public License as published by the
- * Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License
- * for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-package com.sk89q.worldguard.bukkit.commands.task;
-
-import com.sk89q.minecraft.util.commands.CommandException;
-import com.sk89q.squirrelid.Profile;
-import com.sk89q.worldguard.bukkit.WorldGuardPlugin;
-import com.sk89q.worldguard.domains.DefaultDomain;
-import com.sk89q.worldguard.protection.managers.RegionManager;
-import com.sk89q.worldguard.protection.regions.ProtectedRegion;
-import org.bukkit.ChatColor;
-import org.bukkit.command.CommandSender;
-import org.bukkit.entity.Player;
-
-import java.io.IOException;
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.List;
-import java.util.Map;
-import java.util.UUID;
-import java.util.concurrent.Callable;
-import java.util.logging.Level;
-import java.util.logging.Logger;
-
-import static com.google.common.base.Preconditions.checkNotNull;
-
-public class RegionLister implements Callable<Integer> {
-
-    private static final Logger log = Logger.getLogger(RegionLister.class.getCanonicalName());
-
-    private final WorldGuardPlugin plugin;
-    private final CommandSender sender;
-    private final RegionManager manager;
-    private OwnerMatcher ownerMatcher;
-    private int page;
-
-    public RegionLister(WorldGuardPlugin plugin, RegionManager manager, CommandSender sender) {
-        checkNotNull(plugin);
-        checkNotNull(manager);
-        checkNotNull(sender);
-
-        this.plugin = plugin;
-        this.manager = manager;
-        this.sender = sender;
-    }
-
-    public int getPage() {
-        return page;
-    }
-
-    public void setPage(int page) {
-        this.page = page;
-    }
-
-    public void filterOwnedByPlayer(final Player player) {
-        ownerMatcher = new OwnerMatcher() {
-            @Override
-            public String getName() {
-                return player.getName();
-            }
-
-            @Override
-            public boolean isContainedWithin(DefaultDomain domain) throws CommandException {
-                return domain.contains(player.getUniqueId());
-            }
-        };
-    }
-
-    public void filterOwnedByName(String name, boolean nameOnly) {
-        if (nameOnly) {
-            filterOwnedByName(name);
-        } else {
-            filterOwnedByProfile(name);
-        }
-    }
-
-    private void filterOwnedByName(final String name) {
-        ownerMatcher = new OwnerMatcher() {
-            @Override
-            public String getName() {
-                return name;
-            }
-
-            @Override
-            public boolean isContainedWithin(DefaultDomain domain) throws CommandException {
-                return domain.contains(name);
-            }
-        };
-    }
-
-    private void filterOwnedByProfile(final String name) {
-        ownerMatcher = new OwnerMatcher() {
-            private UUID uniqueId;
-
-            @Override
-            public String getName() {
-                return name;
-            }
-
-            @Override
-            public boolean isContainedWithin(DefaultDomain domain) throws CommandException {
-                if (uniqueId == null) {
-                    Profile profile;
-
-                    try {
-                        profile = plugin.getProfileService().findByName(name);
-                    } catch (IOException e) {
-                        log.log(Level.WARNING, "Failed UUID lookup of '" + name + "'", e);
-                        throw new CommandException("Failed to lookup the UUID of '" + name + "'");
-                    } catch (InterruptedException e) {
-                        log.log(Level.WARNING, "Failed UUID lookup of '" + name + "'", e);
-                        throw new CommandException("The lookup the UUID of '" + name + "' was interrupted");
-                    }
-
-                    if (profile == null) {
-                        throw new CommandException("A user by the name of '" + name + "' does not seem to exist.");
-                    }
-
-                    uniqueId = profile.getUniqueId();
-                }
-
-                return domain.contains(uniqueId);
-            }
-        };
-    }
-
-    @Override
-    public Integer call() throws Exception {
-        Map<String, ProtectedRegion> regions = manager.getRegions();
-
-        // Build a list of regions to show
-        List<RegionListEntry> entries = new ArrayList<RegionListEntry>();
-
-        int index = 0;
-        for (String id : regions.keySet()) {
-            RegionListEntry entry = new RegionListEntry(id, index++);
-
-            // Filtering by owner?
-            ProtectedRegion region = regions.get(id);
-            if (ownerMatcher != null) {
-                entry.isOwner = ownerMatcher.isContainedWithin(region.getOwners());
-                entry.isMember = ownerMatcher.isContainedWithin(region.getMembers());
-
-                if (!entry.isOwner && !entry.isMember) {
-                    continue; // Skip
-                }
-            }
-
-            entries.add(entry);
-        }
-
-        Collections.sort(entries);
-
-        final int totalSize = entries.size();
-        final int pageSize = 10;
-        final int pages = (int) Math.ceil(totalSize / (float) pageSize);
-
-        sender.sendMessage(ChatColor.RED
-                + (ownerMatcher == null ? "Regions (page " : "Regions for " + ownerMatcher.getName() + " (page ")
-                + (page + 1) + " of " + pages + "):");
-
-        if (page < pages) {
-            // Print
-            for (int i = page * pageSize; i < page * pageSize + pageSize; i++) {
-                if (i >= totalSize) {
-                    break;
-                }
-
-                sender.sendMessage(ChatColor.YELLOW.toString() + entries.get(i));
-            }
-        }
-
-        return page;
-    }
-
-    private static interface OwnerMatcher {
-        public String getName();
-
-        public boolean isContainedWithin(DefaultDomain domain) throws CommandException;
-    }
-
-    private class RegionListEntry implements Comparable<RegionListEntry> {
-        private final String id;
-        private final int index;
-        boolean isOwner;
-        boolean isMember;
-
-        private RegionListEntry(String id, int index) {
-            this.id = id;
-            this.index = index;
-        }
-
-        @Override
-        public int compareTo(RegionListEntry o) {
-            if (isOwner != o.isOwner) {
-                return isOwner ? 1 : -1;
-            }
-            if (isMember != o.isMember) {
-                return isMember ? 1 : -1;
-            }
-            return id.compareTo(o.id);
-        }
-
-        @Override
-        public String toString() {
-            if (isOwner) {
-                return (index + 1) + ". +" + id;
-            } else if (isMember) {
-                return (index + 1) + ". -" + id;
-            } else {
-                return (index + 1) + ". " + id;
-            }
-        }
-    }
-}
@@ -1,103 +0,0 @@
-/*
- * WorldGuard, a suite of tools for Minecraft
- * Copyright (C) sk89q <http://www.sk89q.com>
- * Copyright (C) WorldGuard team and contributors
- *
- * This program is free software: you can redistribute it and/or modify it
- * under the terms of the GNU Lesser General Public License as published by the
- * Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License
- * for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-package com.sk89q.worldguard.bukkit.listener;
-
-import com.sk89q.worldguard.bukkit.ConfigurationManager;
-import com.sk89q.worldguard.bukkit.WorldConfiguration;
-import com.sk89q.worldguard.bukkit.WorldGuardPlugin;
-import org.bukkit.World;
-import org.bukkit.entity.Player;
-import org.bukkit.event.Listener;
-
-import static com.google.common.base.Preconditions.checkNotNull;
-
-/**
- * Abstract listener to ease creation of listeners.
- */
-class AbstractListener implements Listener {
-
-    private final WorldGuardPlugin plugin;
-
-    /**
-     * Construct the listener.
-     *
-     * @param plugin an instance of WorldGuardPlugin
-     */
-    public AbstractListener(WorldGuardPlugin plugin) {
-        checkNotNull(plugin);
-        this.plugin = plugin;
-    }
-
-    /**
-     * Register events.
-     */
-    public void registerEvents() {
-        plugin.getServer().getPluginManager().registerEvents(this, plugin);
-    }
-
-    /**
-     * Get the plugin.
-     *
-     * @return the plugin
-     */
-    protected WorldGuardPlugin getPlugin() {
-        return plugin;
-    }
-
-    /**
-     * Get the global configuration.
-     *
-     * @return the configuration
-     */
-    protected ConfigurationManager getConfig() {
-        return plugin.getGlobalStateManager();
-    }
-
-    /**
-     * Get the world configuration given a world.
-     *
-     * @param world The world to get the configuration for.
-     * @return The configuration for {@code world}
-     */
-    protected WorldConfiguration getWorldConfig(World world) {
-        return plugin.getGlobalStateManager().get(world);
-    }
-
-    /**
-     * Get the world configuration given a player.
-     *
-     * @param player The player to get the wold from
-     * @return The {@link WorldConfiguration} for the player's world
-     */
-    protected WorldConfiguration getWorldConfig(Player player) {
-        return getWorldConfig(player.getWorld());
-    }
-
-    /**
-     * Return whether region support is enabled.
-     *
-     * @param world the world
-     * @return true if region support is enabled
-     */
-    protected boolean isRegionSupportEnabled(World world) {
-        return getWorldConfig(world).useRegions;
-    }
-
-}
@@ -1,262 +0,0 @@
-/*
- * WorldGuard, a suite of tools for Minecraft
- * Copyright (C) sk89q <http://www.sk89q.com>
- * Copyright (C) WorldGuard team and contributors
- *
- * This program is free software: you can redistribute it and/or modify it
- * under the terms of the GNU Lesser General Public License as published by the
- * Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License
- * for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-package com.sk89q.worldguard.bukkit.listener;
-
-import com.google.common.base.Predicate;
-import com.sk89q.worldguard.LocalPlayer;
-import com.sk89q.worldguard.blacklist.event.BlockBreakBlacklistEvent;
-import com.sk89q.worldguard.blacklist.event.BlockDispenseBlacklistEvent;
-import com.sk89q.worldguard.blacklist.event.BlockInteractBlacklistEvent;
-import com.sk89q.worldguard.blacklist.event.BlockPlaceBlacklistEvent;
-import com.sk89q.worldguard.blacklist.event.ItemAcquireBlacklistEvent;
-import com.sk89q.worldguard.blacklist.event.ItemDestroyWithBlacklistEvent;
-import com.sk89q.worldguard.blacklist.event.ItemDropBlacklistEvent;
-import com.sk89q.worldguard.blacklist.event.ItemUseBlacklistEvent;
-import com.sk89q.worldguard.bukkit.ConfigurationManager;
-import com.sk89q.worldguard.bukkit.WorldConfiguration;
-import com.sk89q.worldguard.bukkit.WorldGuardPlugin;
-import com.sk89q.worldguard.bukkit.event.block.BreakBlockEvent;
-import com.sk89q.worldguard.bukkit.event.block.PlaceBlockEvent;
-import com.sk89q.worldguard.bukkit.event.block.UseBlockEvent;
-import com.sk89q.worldguard.bukkit.event.entity.DestroyEntityEvent;
-import com.sk89q.worldguard.bukkit.event.entity.SpawnEntityEvent;
-import com.sk89q.worldguard.bukkit.event.inventory.UseItemEvent;
-import com.sk89q.worldguard.bukkit.util.Materials;
-import org.bukkit.Location;
-import org.bukkit.Material;
-import org.bukkit.entity.Entity;
-import org.bukkit.entity.Item;
-import org.bukkit.entity.Player;
-import org.bukkit.event.EventHandler;
-import org.bukkit.event.block.BlockDispenseEvent;
-import org.bukkit.event.player.PlayerDropItemEvent;
-import org.bukkit.inventory.ItemStack;
-
-import static com.sk89q.worldguard.bukkit.BukkitUtil.createTarget;
-import static com.sk89q.worldguard.bukkit.BukkitUtil.toVector;
-
-/**
- * Handle events that need to be processed by the blacklist.
- */
-public class BlacklistListener extends AbstractListener {
-
-    /**
-     * Construct the listener.
-     *
-     * @param plugin an instance of WorldGuardPlugin
-     */
-    public BlacklistListener(WorldGuardPlugin plugin) {
-        super(plugin);
-    }
-
-    @EventHandler(ignoreCancelled = true)
-    public void onBreakBlock(final BreakBlockEvent event) {
-        final Player player = event.getCause().getFirstPlayer();
-
-        if (player == null) {
-            return;
-        }
-
-        final LocalPlayer localPlayer = getPlugin().wrapPlayer(player);
-        final WorldConfiguration wcfg = getWorldConfig(player);
-
-        // Blacklist guard
-        if (wcfg.getBlacklist() == null) {
-            return;
-        }
-
-        event.filter(new Predicate<Location>() {
-            @Override
-            public boolean apply(Location target) {
-                if (!wcfg.getBlacklist().check(
-                        new BlockBreakBlacklistEvent(localPlayer, toVector(target), createTarget(target.getBlock(), event.getEffectiveMaterial())), false, false)) {
-                    return false;
-                } else if (!wcfg.getBlacklist().check(
-                        new ItemDestroyWithBlacklistEvent(localPlayer, toVector(target), createTarget(player.getItemInHand())), false, false)) {
-                    return false;
-                }
-
-                return true;
-            }
-        });
-    }
-
-    @EventHandler(ignoreCancelled = true)
-    public void onPlaceBlock(final PlaceBlockEvent event) {
-        Player player = event.getCause().getFirstPlayer();
-
-        if (player == null) {
-            return;
-        }
-
-        final LocalPlayer localPlayer = getPlugin().wrapPlayer(player);
-        final WorldConfiguration wcfg = getWorldConfig(player);
-
-        // Blacklist guard
-        if (wcfg.getBlacklist() == null) {
-            return;
-        }
-
-        event.filter(new Predicate<Location>() {
-            @Override
-            public boolean apply(Location target) {
-                return wcfg.getBlacklist().check(new BlockPlaceBlacklistEvent(
-                        localPlayer, toVector(target), createTarget(target.getBlock(), event.getEffectiveMaterial())), false, false);
-
-            }
-        });
-    }
-
-    @EventHandler(ignoreCancelled = true)
-    public void onUseBlock(final UseBlockEvent event) {
-        Player player = event.getCause().getFirstPlayer();
-
-        if (player == null) {
-            return;
-        }
-
-        final LocalPlayer localPlayer = getPlugin().wrapPlayer(player);
-        final WorldConfiguration wcfg = getWorldConfig(player);
-
-        // Blacklist guard
-        if (wcfg.getBlacklist() == null) {
-            return;
-        }
-
-        event.filter(new Predicate<Location>() {
-            @Override
-            public boolean apply(Location target) {
-                return wcfg.getBlacklist().check(new BlockInteractBlacklistEvent(
-                        localPlayer, toVector(target), createTarget(target.getBlock(), event.getEffectiveMaterial())), false, false);
-            }
-        });
-    }
-
-    @EventHandler(ignoreCancelled = true)
-    public void onSpawnEntity(SpawnEntityEvent event) {
-        Player player = event.getCause().getFirstPlayer();
-
-        if (player == null) {
-            return;
-        }
-
-        LocalPlayer localPlayer = getPlugin().wrapPlayer(player);
-        WorldConfiguration wcfg = getWorldConfig(player);
-
-        // Blacklist guard
-        if (wcfg.getBlacklist() == null) {
-            return;
-        }
-
-        Material material = Materials.getRelatedMaterial(event.getEffectiveType());
-        if (material != null) {
-            if (!wcfg.getBlacklist().check(new ItemUseBlacklistEvent(localPlayer, toVector(event.getTarget()), createTarget(material)), false, false)) {
-                event.setCancelled(true);
-            }
-        }
-    }
-
-    @EventHandler(ignoreCancelled = true)
-    public void onDestroyEntity(DestroyEntityEvent event) {
-        Player player = event.getCause().getFirstPlayer();
-
-        if (player == null) {
-            return;
-        }
-
-        LocalPlayer localPlayer = getPlugin().wrapPlayer(player);
-        Entity target = event.getEntity();
-        WorldConfiguration wcfg = getWorldConfig(player);
-
-        // Blacklist guard
-        if (wcfg.getBlacklist() == null) {
-            return;
-        }
-
-        if (target instanceof Item) {
-            Item item = (Item) target;
-            if (!wcfg.getBlacklist().check(
-                    new ItemAcquireBlacklistEvent(localPlayer,
-                            toVector(target.getLocation()), createTarget(item.getItemStack())), false, true)) {
-                event.setCancelled(true);
-                return;
-            }
-        }
-
-        Material material = Materials.getRelatedMaterial(target.getType());
-        if (material != null) {
-            // Not really a block but we only have one on-break blacklist event
-            if (!wcfg.getBlacklist().check(new BlockBreakBlacklistEvent(localPlayer, toVector(event.getTarget()), createTarget(material)), false, false)) {
-                event.setCancelled(true);
-            }
-        }
-    }
-
-    @EventHandler(ignoreCancelled = true)
-    public void onUseItem(UseItemEvent event) {
-        Player player = event.getCause().getFirstPlayer();
-
-        if (player == null) {
-            return;
-        }
-
-        LocalPlayer localPlayer = getPlugin().wrapPlayer(player);
-        ItemStack target = event.getItemStack();
-        WorldConfiguration wcfg = getWorldConfig(player);
-
-        // Blacklist guard
-        if (wcfg.getBlacklist() == null) {
-            return;
-        }
-
-        if (!wcfg.getBlacklist().check(new ItemUseBlacklistEvent(localPlayer, toVector(player.getLocation()), createTarget(target)), false, false)) {
-            event.setCancelled(true);
-        }
-    }
-
-    @EventHandler(ignoreCancelled = true)
-    public void onPlayerDropItem(PlayerDropItemEvent event) {
-        ConfigurationManager cfg = getPlugin().getGlobalStateManager();
-        WorldConfiguration wcfg = cfg.get(event.getPlayer().getWorld());
-
-        if (wcfg.getBlacklist() != null) {
-            Item ci = event.getItemDrop();
-
-            if (!wcfg.getBlacklist().check(
-                    new ItemDropBlacklistEvent(getPlugin().wrapPlayer(event.getPlayer()),
-                            toVector(ci.getLocation()), createTarget(ci.getItemStack())), false, false)) {
-                event.setCancelled(true);
-            }
-        }
-    }
-
-    @EventHandler(ignoreCancelled = true)
-    public void onBlockDispense(BlockDispenseEvent event) {
-        ConfigurationManager cfg = getPlugin().getGlobalStateManager();
-        WorldConfiguration wcfg = cfg.get(event.getBlock().getWorld());
-
-        if (wcfg.getBlacklist() != null) {
-            if (!wcfg.getBlacklist().check(new BlockDispenseBlacklistEvent(null, toVector(event.getBlock()), createTarget(event.getItem())), false, false)) {
-                event.setCancelled(true);
-            }
-        }
-    }
-
-}
@@ -1,109 +0,0 @@
-/*
- * WorldGuard, a suite of tools for Minecraft
- * Copyright (C) sk89q <http://www.sk89q.com>
- * Copyright (C) WorldGuard team and contributors
- *
- * This program is free software: you can redistribute it and/or modify it
- * under the terms of the GNU Lesser General Public License as published by the
- * Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License
- * for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-package com.sk89q.worldguard.bukkit.listener;
-
-import com.sk89q.worldguard.bukkit.BukkitUtil;
-import com.sk89q.worldguard.bukkit.ConfigurationManager;
-import com.sk89q.worldguard.bukkit.WorldConfiguration;
-import com.sk89q.worldguard.bukkit.WorldGuardPlugin;
-import com.sk89q.worldguard.bukkit.event.inventory.UseItemEvent;
-import org.bukkit.ChatColor;
-import org.bukkit.Material;
-import org.bukkit.entity.Player;
-import org.bukkit.event.EventHandler;
-import org.bukkit.event.entity.PotionSplashEvent;
-import org.bukkit.inventory.ItemStack;
-import org.bukkit.potion.Potion;
-import org.bukkit.potion.PotionEffect;
-
-/**
- * Handles blocked potions.
- */
-public class BlockedPotionsListener extends AbstractListener {
-
-    /**
-     * Construct the listener.
-     *
-     * @param plugin an instance of WorldGuardPlugin
-     */
-    public BlockedPotionsListener(WorldGuardPlugin plugin) {
-        super(plugin);
-    }
-
-    @EventHandler
-    public void onItemInteract(UseItemEvent event) {
-        // We only care about player caused events
-        if (event.getCause().getFirstPlayer() == null) {
-            return;
-        }
-
-        ConfigurationManager cfg = getPlugin().getGlobalStateManager();
-        WorldConfiguration wcfg = cfg.get(event.getWorld());
-        ItemStack item = event.getItemStack();
-
-        // Only block potions via PotionSplashEvent if "over reliable potion
-        // blocking" is enabled
-        if (!wcfg.blockPotionsAlways && event.getOriginalEvent() instanceof PotionSplashEvent) {
-            return;
-        }
-
-        // We only care about portions
-        if (item.getType() != Material.POTION || BukkitUtil.isWaterPotion(item)) {
-            return;
-        }
-
-        if (!wcfg.blockPotions.isEmpty()) {
-            PotionEffect blockedEffect = null;
-
-            Potion potion = Potion.fromDamage(BukkitUtil.getPotionEffectBits(item));
-
-            // Find the first blocked effect
-            for (PotionEffect effect : potion.getEffects()) {
-                if (wcfg.blockPotions.contains(effect.getType())) {
-                    blockedEffect = effect;
-                    break;
-                }
-            }
-
-            if (blockedEffect != null) {
-                Player player = event.getCause().getFirstPlayer();
-
-                if (player != null) {
-                    if (getPlugin().hasPermission(player, "worldguard.override.potions")) {
-                        if (potion.isSplash() && wcfg.blockPotionsAlways) {
-                            player.sendMessage(ChatColor.RED + "Sorry, potions with " +
-                                    blockedEffect.getType().getName() + " can't be thrown, " +
-                                    "even if you have a permission to bypass it, " +
-                                    "due to limitations (and because overly-reliable potion blocking is on).");
-                            event.setCancelled(true);
-                        }
-                    } else {
-                        player.sendMessage(ChatColor.RED + "Sorry, potions with "
-                                + blockedEffect.getType().getName() + " are presently disabled.");
-                        event.setCancelled(true);
-                    }
-                } else {
-                    event.setCancelled(true);
-                }
-            }
-        }
-    }
-
-}
@@ -1,798 +0,0 @@
-/*
- * WorldGuard, a suite of tools for Minecraft
- * Copyright (C) sk89q <http://www.sk89q.com>
- * Copyright (C) WorldGuard team and contributors
- *
- * This program is free software: you can redistribute it and/or modify it
- * under the terms of the GNU Lesser General Public License as published by the
- * Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License
- * for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-package com.sk89q.worldguard.bukkit.listener;
-
-import com.google.common.collect.Lists;
-import com.sk89q.worldguard.bukkit.WorldConfiguration;
-import com.sk89q.worldguard.bukkit.WorldGuardPlugin;
-import com.sk89q.worldguard.bukkit.cause.Cause;
-import com.sk89q.worldguard.bukkit.event.DelegateEvents;
-import com.sk89q.worldguard.bukkit.event.block.BreakBlockEvent;
-import com.sk89q.worldguard.bukkit.event.block.PlaceBlockEvent;
-import com.sk89q.worldguard.bukkit.event.block.UseBlockEvent;
-import com.sk89q.worldguard.bukkit.event.entity.DamageEntityEvent;
-import com.sk89q.worldguard.bukkit.event.entity.DestroyEntityEvent;
-import com.sk89q.worldguard.bukkit.event.entity.SpawnEntityEvent;
-import com.sk89q.worldguard.bukkit.event.entity.UseEntityEvent;
-import com.sk89q.worldguard.bukkit.event.inventory.UseItemEvent;
-import com.sk89q.worldguard.bukkit.listener.debounce.AbstractEventDebounce.Entry;
-import com.sk89q.worldguard.bukkit.listener.debounce.BlockEntityEventDebounce;
-import com.sk89q.worldguard.bukkit.listener.debounce.EntityEntityEventDebounce;
-import com.sk89q.worldguard.bukkit.listener.debounce.InventoryMoveItemEventDebounce;
-import com.sk89q.worldguard.bukkit.util.BlockStateAsBlockFunction;
-import com.sk89q.worldguard.bukkit.util.Blocks;
-import com.sk89q.worldguard.bukkit.util.Events;
-import com.sk89q.worldguard.bukkit.util.Materials;
-import org.bukkit.Bukkit;
-import org.bukkit.DyeColor;
-import org.bukkit.Material;
-import org.bukkit.World;
-import org.bukkit.block.Block;
-import org.bukkit.block.BlockFace;
-import org.bukkit.block.BlockState;
-import org.bukkit.block.DoubleChest;
-import org.bukkit.block.Hopper;
-import org.bukkit.entity.Entity;
-import org.bukkit.entity.EntityType;
-import org.bukkit.entity.FallingBlock;
-import org.bukkit.entity.Item;
-import org.bukkit.entity.LivingEntity;
-import org.bukkit.entity.Player;
-import org.bukkit.entity.ThrownPotion;
-import org.bukkit.event.Cancellable;
-import org.bukkit.event.Event;
-import org.bukkit.event.Event.Result;
-import org.bukkit.event.EventHandler;
-import org.bukkit.event.block.Action;
-import org.bukkit.event.block.BlockBreakEvent;
-import org.bukkit.event.block.BlockBurnEvent;
-import org.bukkit.event.block.BlockDamageEvent;
-import org.bukkit.event.block.BlockDispenseEvent;
-import org.bukkit.event.block.BlockExpEvent;
-import org.bukkit.event.block.BlockFromToEvent;
-import org.bukkit.event.block.BlockIgniteEvent;
-import org.bukkit.event.block.BlockPistonExtendEvent;
-import org.bukkit.event.block.BlockPistonRetractEvent;
-import org.bukkit.event.block.BlockPlaceEvent;
-import org.bukkit.event.block.SignChangeEvent;
-import org.bukkit.event.entity.CreatureSpawnEvent;
-import org.bukkit.event.entity.EntityChangeBlockEvent;
-import org.bukkit.event.entity.EntityCombustByBlockEvent;
-import org.bukkit.event.entity.EntityCombustByEntityEvent;
-import org.bukkit.event.entity.EntityCombustEvent;
-import org.bukkit.event.entity.EntityDamageByBlockEvent;
-import org.bukkit.event.entity.EntityDamageByEntityEvent;
-import org.bukkit.event.entity.EntityDamageEvent;
-import org.bukkit.event.entity.EntityDeathEvent;
-import org.bukkit.event.entity.EntityExplodeEvent;
-import org.bukkit.event.entity.EntityTameEvent;
-import org.bukkit.event.entity.EntityUnleashEvent;
-import org.bukkit.event.entity.ExpBottleEvent;
-import org.bukkit.event.entity.PotionSplashEvent;
-import org.bukkit.event.hanging.HangingBreakByEntityEvent;
-import org.bukkit.event.hanging.HangingBreakEvent;
-import org.bukkit.event.hanging.HangingPlaceEvent;
-import org.bukkit.event.inventory.InventoryMoveItemEvent;
-import org.bukkit.event.player.PlayerBedEnterEvent;
-import org.bukkit.event.player.PlayerBucketEmptyEvent;
-import org.bukkit.event.player.PlayerBucketFillEvent;
-import org.bukkit.event.player.PlayerDropItemEvent;
-import org.bukkit.event.player.PlayerFishEvent;
-import org.bukkit.event.player.PlayerInteractEntityEvent;
-import org.bukkit.event.player.PlayerInteractEvent;
-import org.bukkit.event.player.PlayerPickupItemEvent;
-import org.bukkit.event.player.PlayerShearEntityEvent;
-import org.bukkit.event.player.PlayerUnleashEntityEvent;
-import org.bukkit.event.vehicle.VehicleDamageEvent;
-import org.bukkit.event.vehicle.VehicleDestroyEvent;
-import org.bukkit.event.world.StructureGrowEvent;
-import org.bukkit.inventory.InventoryHolder;
-import org.bukkit.inventory.ItemStack;
-import org.bukkit.material.Dispenser;
-import org.bukkit.material.MaterialData;
-import org.bukkit.material.SpawnEgg;
-import org.bukkit.util.Vector;
-
-import javax.annotation.Nullable;
-import java.util.ArrayList;
-import java.util.List;
-
-import static com.sk89q.worldguard.bukkit.cause.Cause.create;
-import static com.sk89q.worldguard.bukkit.util.Materials.isBlockModifiedOnClick;
-import static com.sk89q.worldguard.bukkit.util.Materials.isItemAppliedToBlock;
-
-public class EventAbstractionListener extends AbstractListener {
-
-    private final BlockEntityEventDebounce interactDebounce = new BlockEntityEventDebounce(10000);
-    private final EntityEntityEventDebounce pickupDebounce = new EntityEntityEventDebounce(10000);
-    private final BlockEntityEventDebounce entityBreakBlockDebounce = new BlockEntityEventDebounce(10000);
-    private final InventoryMoveItemEventDebounce moveItemDebounce = new InventoryMoveItemEventDebounce(30000);
-
-    /**
-     * Construct the listener.
-     *
-     * @param plugin an instance of WorldGuardPlugin
-     */
-    public EventAbstractionListener(WorldGuardPlugin plugin) {
-        super(plugin);
-    }
-
-    //-------------------------------------------------------------------------
-    // Block break / place
-    //-------------------------------------------------------------------------
-
-    @EventHandler(ignoreCancelled = true)
-    public void onBlockBreak(BlockBreakEvent event) {
-        Events.fireToCancel(event, new BreakBlockEvent(event, create(event.getPlayer()), event.getBlock()));
-    }
-
-    @EventHandler(ignoreCancelled = true)
-    public void onBlockPlace(BlockPlaceEvent event) {
-        BlockState previousState = event.getBlockReplacedState();
-
-        // Some blocks, like tall grass and fire, get replaced
-        if (previousState.getType() != Material.AIR) {
-            Events.fireToCancel(event, new BreakBlockEvent(event, create(event.getPlayer()), previousState.getLocation(), previousState.getType()));
-        }
-
-        if (!event.isCancelled()) {
-            ItemStack itemStack = new ItemStack(event.getBlockPlaced().getType(), 1);
-            Events.fireToCancel(event, new UseItemEvent(event, create(event.getPlayer()), event.getPlayer().getWorld(), itemStack));
-        }
-
-        if (!event.isCancelled()) {
-            Events.fireToCancel(event, new PlaceBlockEvent(event, create(event.getPlayer()), event.getBlock()));
-        }
-    }
-
-    @EventHandler(ignoreCancelled = true)
-    public void onBlockBurn(BlockBurnEvent event) {
-        Block target = event.getBlock();
-
-        Block[] adjacent = new Block[] {
-                target.getRelative(BlockFace.NORTH),
-                target.getRelative(BlockFace.SOUTH),
-                target.getRelative(BlockFace.WEST),
-                target.getRelative(BlockFace.EAST),
-                target.getRelative(BlockFace.UP),
-                target.getRelative(BlockFace.DOWN)};
-
-        int found = 0;
-        boolean allowed = false;
-
-        for (Block source : adjacent) {
-            if (source.getType() == Material.FIRE) {
-                found++;
-                if (Events.fireAndTestCancel(new BreakBlockEvent(event, create(source), target))) {
-                    source.setType(Material.AIR);
-                } else {
-                    allowed = true;
-                }
-            }
-        }
-
-        if (found > 0 && !allowed) {
-            event.setCancelled(true);
-        }
-    }
-
-    @EventHandler(ignoreCancelled = true)
-    public void onStructureGrowEvent(StructureGrowEvent event) {
-        List<Block> blockList = Lists.transform(event.getBlocks(), new BlockStateAsBlockFunction());
-        Events.fireBulkEventToCancel(event, new PlaceBlockEvent(event, create(event.getPlayer()), event.getLocation().getWorld(), blockList, Material.AIR));
-    }
-
-    // TODO: Handle EntityCreatePortalEvent?
-
-    @EventHandler(ignoreCancelled = true)
-    public void onEntityChangeBlock(EntityChangeBlockEvent event) {
-        Block block = event.getBlock();
-        Entity entity = event.getEntity();
-        Material to = event.getTo();
-
-        // Forget about Redstone ore, especially since we handle it in INTERACT
-        if (Materials.isRedstoneOre(block.getType()) && Materials.isRedstoneOre(to)) {
-            return;
-        }
-
-        // Fire two events: one as BREAK and one as PLACE
-        if (event.getTo() != Material.AIR && event.getBlock().getType() != Material.AIR) {
-            Events.fireToCancel(event, new BreakBlockEvent(event, create(entity), block));
-            Events.fireToCancel(event, new PlaceBlockEvent(event, create(entity), block.getLocation(), to));
-        } else {
-            if (event.getTo() == Material.AIR) {
-                // Track the source so later we can create a proper chain of causes
-                if (entity instanceof FallingBlock) {
-                    Cause.trackParentCause(entity, block);
-
-                    // Switch around the event
-                    Events.fireToCancel(event, new SpawnEntityEvent(event, create(block), entity));
-                } else {
-                    entityBreakBlockDebounce.debounce(
-                            event.getBlock(), event.getEntity(), event, new BreakBlockEvent(event, create(entity), event.getBlock()));
-                }
-            } else {
-                boolean wasCancelled = event.isCancelled();
-                Cause cause = create(entity);
-
-                Events.fireToCancel(event, new PlaceBlockEvent(event, cause, event.getBlock().getLocation(), to));
-
-                if (event.isCancelled() && !wasCancelled && entity instanceof FallingBlock) {
-                    FallingBlock fallingBlock = (FallingBlock) entity;
-                    ItemStack itemStack = new ItemStack(fallingBlock.getMaterial(), 1, fallingBlock.getBlockData());
-                    Item item = block.getWorld().dropItem(fallingBlock.getLocation(), itemStack);
-                    item.setVelocity(new Vector());
-                    if (Events.fireAndTestCancel(new SpawnEntityEvent(event, create(block, entity), item))) {
-                        item.remove();
-                    }
-                }
-            }
-        }
-    }
-
-    @EventHandler(ignoreCancelled = true)
-    public void onEntityExplode(EntityExplodeEvent event) {
-        Entity entity = event.getEntity();
-
-        Events.fireBulkEventToCancel(event, new BreakBlockEvent(event, create(entity), event.getLocation().getWorld(), event.blockList(), Material.AIR));
-    }
-
-    @EventHandler(ignoreCancelled = true)
-    public void onBlockPistonRetract(BlockPistonRetractEvent event) {
-        if (event.isSticky()) {
-            Cause cause = create(event.getBlock());
-            Events.fireToCancel(event, new BreakBlockEvent(event, cause, event.getRetractLocation(), Material.AIR));
-            Events.fireToCancel(event, new PlaceBlockEvent(event, cause, event.getBlock().getRelative(event.getDirection())));
-        }
-    }
-
-    @EventHandler(ignoreCancelled = true)
-    public void onBlockPistonExtend(BlockPistonExtendEvent event) {
-        // A hack for now
-        List<Block> blocks = new ArrayList<Block>(event.getBlocks());
-        Block lastBlock = event.getBlock().getRelative(event.getDirection(), event.getLength() + 1);
-        blocks.add(lastBlock);
-        int originalLength = blocks.size();
-        Events.fireBulkEventToCancel(event, new PlaceBlockEvent(event, create(event.getBlock()), event.getBlock().getWorld(), blocks, Material.STONE));
-        if (blocks.size() != originalLength) {
-            event.setCancelled(true);
-        }
-    }
-
-    //-------------------------------------------------------------------------
-    // Block external interaction
-    //-------------------------------------------------------------------------
-
-    @EventHandler(ignoreCancelled = true)
-    public void onBlockDamage(BlockDamageEvent event) {
-        Block target = event.getBlock();
-
-        // Previously, and perhaps still, the only way to catch cake eating
-        // events was through here
-        if (target.getType() == Material.CAKE_BLOCK) {
-            Events.fireToCancel(event, new UseBlockEvent(event, create(event.getPlayer()), target));
-        }
-    }
-
-    @EventHandler(ignoreCancelled = true)
-    public void onPlayerInteract(PlayerInteractEvent event) {
-        Player player = event.getPlayer();
-        @Nullable ItemStack item = player.getItemInHand();
-        Block clicked = event.getClickedBlock();
-        Block placed;
-        boolean silent = false;
-        Cause cause = create(player);
-
-        switch (event.getAction()) {
-            case PHYSICAL:
-                // Forget about Redstone ore
-                if (Materials.isRedstoneOre(clicked.getType())) {
-                    silent = true;
-                }
-
-                interactDebounce.debounce(clicked, event.getPlayer(), event, DelegateEvents.setSilent(new UseBlockEvent(event, cause, clicked), silent));
-                break;
-
-            case RIGHT_CLICK_BLOCK:
-                placed = clicked.getRelative(event.getBlockFace());
-
-                // Re-used for dispensers
-                handleBlockRightClick(event, create(event.getPlayer()), item, clicked, event.getBlockFace(), placed);
-
-            case LEFT_CLICK_BLOCK:
-                placed = clicked.getRelative(event.getBlockFace());
-
-                // As of MC ~1.6, sneaking blocks the use of blocks with right click
-                if (!player.isSneaking() || event.getAction() == Action.LEFT_CLICK_BLOCK) {
-                    // Only fire events for blocks that are modified when right clicked
-                    if (isBlockModifiedOnClick(clicked.getType()) || (item != null && isItemAppliedToBlock(item.getType(), clicked.getType()))) {
-                        if (Events.fireAndTestCancel(new UseBlockEvent(event, cause, clicked))) {
-                            event.setUseInteractedBlock(Result.DENY);
-                        }
-
-                        // Handle connected blocks (i.e. beds, chests)
-                        for (Block connected : Blocks.getConnected(clicked)) {
-                            if (Events.fireAndTestCancel(new UseBlockEvent(event, create(event.getPlayer()), connected))) {
-                                event.setUseInteractedBlock(Result.DENY);
-                                break;
-                            }
-                        }
-                    }
-                }
-
-                // Special handling of putting out fires
-                if (event.getAction() == Action.LEFT_CLICK_BLOCK && placed.getType() == Material.FIRE) {
-                    if (Events.fireAndTestCancel(new BreakBlockEvent(event, create(event.getPlayer()), placed))) {
-                        event.setUseInteractedBlock(Result.DENY);
-                        break;
-                    }
-                }
-
-            case LEFT_CLICK_AIR:
-            case RIGHT_CLICK_AIR:
-                if (item != null && !item.getType().isBlock() && Events.fireAndTestCancel(new UseItemEvent(event, cause, player.getWorld(), item))) {
-                    event.setUseItemInHand(Result.DENY);
-                }
-
-                break;
-        }
-    }
-
-    @EventHandler(ignoreCancelled = true)
-    public void onEntityInteract(org.bukkit.event.entity.EntityInteractEvent event) {
-        interactDebounce.debounce(event.getBlock(), event.getEntity(), event, new UseBlockEvent(event, create(event.getEntity()), event.getBlock()));
-    }
-
-    @EventHandler(ignoreCancelled = true)
-    public void onBlockIgnite(BlockIgniteEvent event) {
-        Block block = event.getBlock();
-        Material type = block.getType();
-        Cause cause;
-
-        // Find the cause
-        if (event.getPlayer() != null) {
-            cause = create(event.getPlayer());
-        } else if (event.getIgnitingEntity() != null) {
-            cause = create(event.getIgnitingEntity());
-        } else if (event.getIgnitingBlock() != null) {
-            cause = create(event.getIgnitingBlock());
-        } else {
-            cause = Cause.unknown();
-        }
-
-        Events.fireToCancel(event, new PlaceBlockEvent(event, cause, block.getLocation(), Material.FIRE));
-    }
-
-    @EventHandler(ignoreCancelled = true)
-    public void onSignChange(SignChangeEvent event) {
-        Events.fireToCancel(event, new UseBlockEvent(event, create(event.getPlayer()), event.getBlock()));
-    }
-
-    @EventHandler(ignoreCancelled = true)
-    public void onBedEnter(PlayerBedEnterEvent event) {
-        Events.fireToCancel(event, new UseBlockEvent(event, create(event.getPlayer()), event.getBed()));
-    }
-
-    @EventHandler(ignoreCancelled = true)
-    public void onPlayerBucketEmpty(PlayerBucketEmptyEvent event) {
-        Player player = event.getPlayer();
-        Block blockAffected = event.getBlockClicked().getRelative(event.getBlockFace());
-
-        // Milk buckets can't be emptied as of writing
-        if (event.getBucket() != Material.MILK_BUCKET) {
-            ItemStack item = new ItemStack(event.getBucket(), 1);
-            Material blockMaterial = Materials.getBucketBlockMaterial(event.getBucket());
-            Events.fireToCancel(event, new PlaceBlockEvent(event, create(player), blockAffected.getLocation(), blockMaterial));
-            Events.fireToCancel(event, new UseItemEvent(event, create(player), player.getWorld(), item));
-        }
-    }
-
-    @EventHandler(ignoreCancelled = true)
-    public void onPlayerBucketFill(PlayerBucketFillEvent event) {
-        Player player = event.getPlayer();
-        Block blockAffected = event.getBlockClicked().getRelative(event.getBlockFace());
-
-        // Milk buckets can't be filled by right clicking the ground as of writing
-        if (event.getBucket() != Material.MILK_BUCKET) {
-            ItemStack item = new ItemStack(event.getBucket(), 1);
-            Events.fireToCancel(event, new BreakBlockEvent(event, create(player), blockAffected));
-            Events.fireToCancel(event, new UseItemEvent(event, create(player), player.getWorld(), item));
-        }
-    }
-
-    // TODO: Handle EntityPortalEnterEvent
-
-    //-------------------------------------------------------------------------
-    // Block self-interaction
-    //-------------------------------------------------------------------------
-
-    @EventHandler(ignoreCancelled = true)
-    public void onBlockFromTo(BlockFromToEvent event) {
-        WorldConfiguration config = getWorldConfig(event.getBlock().getWorld());
-
-        // This only applies to regions but nothing else cares about high
-        // frequency events at the moment
-        if (!config.useRegions || (!config.highFreqFlags && !config.checkLiquidFlow)) {
-            return;
-        }
-
-        Block from = event.getBlock();
-        Block to = event.getToBlock();
-        Material fromType = from.getType();
-        Material toType = to.getType();
-
-        // Liquids pass this event when flowing to solid blocks
-        if (toType.isSolid() && Materials.isLiquid(fromType)) {
-            return;
-        }
-
-        // This significantly reduces the number of events without having
-        // too much effect. Unfortunately it appears that even if this
-        // check didn't exist, you can raise the level of some liquid
-        // flow and the from/to data may not be correct.
-        if ((Materials.isWater(fromType) && Materials.isWater(toType)) || (Materials.isLava(fromType) && Materials.isLava(toType))) {
-            return;
-        }
-
-        Cause cause = create(from);
-
-        // Disable since it's probably not needed
-        /*if (from.getType() != Material.AIR) {
-            Events.fireToCancel(event, new BreakBlockEvent(event, cause, to));
-        }*/
-
-        Events.fireToCancel(event, new PlaceBlockEvent(event, cause, to.getLocation(), from.getType()));
-    }
-
-    //-------------------------------------------------------------------------
-    // Entity break / place
-    //-------------------------------------------------------------------------
-
-    @EventHandler(ignoreCancelled = true)
-    public void onCreatureSpawn(CreatureSpawnEvent event) {
-        switch (event.getSpawnReason()) {
-            case DISPENSE_EGG:
-            case EGG:
-            case SPAWNER_EGG:
-                if (getWorldConfig(event.getEntity().getWorld()).strictEntitySpawn) {
-                    Events.fireToCancel(event, new SpawnEntityEvent(event, Cause.unknown(), event.getEntity()));
-                }
-                break;
-            case NATURAL:
-            case JOCKEY:
-            case CHUNK_GEN:
-            case SPAWNER:
-            case LIGHTNING:
-            case BUILD_SNOWMAN:
-            case BUILD_IRONGOLEM:
-            case BUILD_WITHER:
-            case VILLAGE_DEFENSE:
-            case VILLAGE_INVASION:
-            case BREEDING:
-            case SLIME_SPLIT:
-            case REINFORCEMENTS:
-            case NETHER_PORTAL:
-            case INFECTION:
-            case CURED:
-            case OCELOT_BABY:
-            case SILVERFISH_BLOCK:
-            case MOUNT:
-            case CUSTOM:
-            case DEFAULT:
-        }
-    }
-
-    @EventHandler(ignoreCancelled = true)
-    public void onHangingPlace(HangingPlaceEvent event) {
-        Events.fireToCancel(event, new SpawnEntityEvent(event, create(event.getPlayer()), event.getEntity()));
-    }
-
-    @EventHandler(ignoreCancelled = true)
-    public void onHangingBreak(HangingBreakEvent event) {
-        if (event instanceof HangingBreakByEntityEvent) {
-            Events.fireToCancel(event,  new DestroyEntityEvent(event, create(((HangingBreakByEntityEvent) event).getRemover()), event.getEntity()));
-        } else {
-            Events.fireToCancel(event, new DestroyEntityEvent(event, Cause.unknown(), event.getEntity()));
-        }
-    }
-
-    @EventHandler(ignoreCancelled = true)
-    public void onVehicleDestroy(VehicleDestroyEvent event) {
-        Events.fireToCancel(event, new DestroyEntityEvent(event, create(event.getAttacker()), event.getVehicle()));
-    }
-
-    @EventHandler(ignoreCancelled = true)
-    public void onBlockExp(BlockExpEvent event) {
-        if (event.getExpToDrop() > 0) { // Event is raised even where no XP is being dropped
-            if (Events.fireAndTestCancel(new SpawnEntityEvent(event, create(event.getBlock()), event.getBlock().getLocation(), EntityType.EXPERIENCE_ORB))) {
-                event.setExpToDrop(0);
-            }
-        }
-    }
-
-    @EventHandler(ignoreCancelled = true)
-    public void onPlayerFish(PlayerFishEvent event) {
-        if (Events.fireAndTestCancel(new SpawnEntityEvent(event, create(event.getPlayer(), event.getHook()), event.getCaught().getLocation(), EntityType.EXPERIENCE_ORB))) {
-            event.setExpToDrop(0);
-        }
-    }
-
-    @EventHandler(ignoreCancelled = true)
-    public void onExpBottle(ExpBottleEvent event) {
-        if (Events.fireAndTestCancel(new SpawnEntityEvent(event, create(event.getEntity()), event.getEntity().getLocation(), EntityType.EXPERIENCE_ORB))) {
-            event.setExperience(0);
-        }
-    }
-
-    @EventHandler(ignoreCancelled = true)
-    public void onEntityDeath(EntityDeathEvent event) {
-        if (event.getDroppedExp() > 0) {
-            if (Events.fireAndTestCancel(new SpawnEntityEvent(event, create(event.getEntity()), event.getEntity().getLocation(), EntityType.EXPERIENCE_ORB))) {
-                event.setDroppedExp(0);
-            }
-        }
-    }
-
-    //-------------------------------------------------------------------------
-    // Entity external interaction
-    //-------------------------------------------------------------------------
-
-    @EventHandler(ignoreCancelled = true)
-    public void onPlayerInteractEntity(PlayerInteractEntityEvent event) {
-        Player player = event.getPlayer();
-        World world = player.getWorld();
-        ItemStack item = player.getItemInHand();
-        Entity entity = event.getRightClicked();
-
-        Events.fireToCancel(event, new UseItemEvent(event, create(player), world, item));
-        Events.fireToCancel(event, new UseEntityEvent(event, create(player), entity));
-    }
-
-    @EventHandler(ignoreCancelled = true)
-    public void onEntityDamage(EntityDamageEvent event) {
-        if (event instanceof EntityDamageByBlockEvent) {
-            Events.fireToCancel(event, new DamageEntityEvent(event, create(((EntityDamageByBlockEvent) event).getDamager()), event.getEntity()));
-
-        } else if (event instanceof EntityDamageByEntityEvent) {
-            EntityDamageByEntityEvent entityEvent = (EntityDamageByEntityEvent) event;
-            Entity damager = entityEvent.getDamager();
-            Events.fireToCancel(event, new DamageEntityEvent(event, create(damager), event.getEntity()));
-
-            // Item use event with the item in hand
-            // Older blacklist handler code used this, although it suffers from
-            // race problems
-            if (damager instanceof Player) {
-                ItemStack item = ((Player) damager).getItemInHand();
-
-                if (item != null) {
-                    Events.fireToCancel(event, new UseItemEvent(event, create(damager), event.getEntity().getWorld(), item));
-                }
-            }
-
-        } else {
-            Events.fireToCancel(event, new DamageEntityEvent(event, Cause.unknown(), event.getEntity()));
-        }
-    }
-
-    @EventHandler(ignoreCancelled = true)
-    public void onEntityCombust(EntityCombustEvent event) {
-        if (event instanceof EntityCombustByBlockEvent) {
-            Events.fireToCancel(event, new DamageEntityEvent(event, create(((EntityCombustByBlockEvent) event).getCombuster()), event.getEntity()));
-
-        } else if (event instanceof EntityCombustByEntityEvent) {
-            Events.fireToCancel(event, new DamageEntityEvent(event, create(((EntityCombustByEntityEvent) event).getCombuster()), event.getEntity()));
-
-        } else {
-            Events.fireToCancel(event, new DamageEntityEvent(event, Cause.unknown(), event.getEntity()));
-        }
-    }
-
-    @EventHandler(ignoreCancelled = true)
-    public void onEntityUnleash(EntityUnleashEvent event) {
-        if (event instanceof PlayerUnleashEntityEvent) {
-            PlayerUnleashEntityEvent playerEvent = (PlayerUnleashEntityEvent) event;
-            Events.fireToCancel(playerEvent, new UseEntityEvent(playerEvent, create(playerEvent.getPlayer()), event.getEntity()));
-        } else {
-            // TODO: Raise anyway?
-        }
-    }
-
-    @EventHandler(ignoreCancelled = true)
-    public void onEntityTame(EntityTameEvent event) {
-        Events.fireToCancel(event, new UseEntityEvent(event, create(event.getOwner()), event.getEntity()));
-    }
-
-    @EventHandler(ignoreCancelled = true)
-    public void onPlayerShearEntity(PlayerShearEntityEvent event) {
-        Events.fireToCancel(event, new UseEntityEvent(event, create(event.getPlayer()), event.getEntity()));
-    }
-
-    @EventHandler(ignoreCancelled = true)
-    public void onPlayerPickupItem(PlayerPickupItemEvent event) {
-        Item item = event.getItem();
-        pickupDebounce.debounce(event.getPlayer(), item, event, new DestroyEntityEvent(event, create(event.getPlayer()), event.getItem()));
-    }
-
-    @EventHandler(ignoreCancelled = true)
-    public void onPlayerDropItem(PlayerDropItemEvent event) {
-        Events.fireToCancel(event, new SpawnEntityEvent(event, create(event.getPlayer()), event.getItemDrop()));
-    }
-
-    @EventHandler(ignoreCancelled = true)
-    public void onVehicleDamage(VehicleDamageEvent event) {
-        Events.fireToCancel(event, new DestroyEntityEvent(event, create(event.getAttacker()), event.getVehicle()));
-    }
-
-    @EventHandler(ignoreCancelled = true)
-    public void onVehicleEnter(VehicleDamageEvent event) {
-        Events.fireToCancel(event, new UseEntityEvent(event, create(event.getAttacker()), event.getVehicle()));
-    }
-
-    //-------------------------------------------------------------------------
-    // Composite events
-    //-------------------------------------------------------------------------
-
-    @EventHandler(ignoreCancelled = true)
-    public void onInventoryMoveItem(InventoryMoveItemEvent event) {
-        final InventoryHolder causeHolder = event.getInitiator().getHolder();
-        InventoryHolder sourceHolder = event.getSource().getHolder();
-        InventoryHolder targetHolder = event.getDestination().getHolder();
-
-        Entry entry;
-
-        if ((entry = moveItemDebounce.tryDebounce(event)) != null) {
-            Cause cause;
-
-            if (causeHolder instanceof Entity) {
-                cause = create(causeHolder);
-            } else if (causeHolder instanceof BlockState) {
-                cause = create(((BlockState) causeHolder).getBlock());
-            } else {
-                cause = Cause.unknown();
-            }
-
-            if (!causeHolder.equals(sourceHolder)) {
-                handleInventoryHolderUse(event, cause, sourceHolder);
-            }
-
-            handleInventoryHolderUse(event, cause, targetHolder);
-
-            if (event.isCancelled() && causeHolder instanceof Hopper) {
-                Bukkit.getScheduler().scheduleSyncDelayedTask(getPlugin(), new Runnable() {
-                    @Override
-                    public void run() {
-                        ((Hopper) causeHolder).getBlock().breakNaturally();
-                    }
-                });
-            } else {
-                entry.setCancelled(event.isCancelled());
-            }
-        }
-    }
-
-    @EventHandler(ignoreCancelled = true)
-    public void onPotionSplash(PotionSplashEvent event) {
-        Entity entity = event.getEntity();
-        ThrownPotion potion = event.getPotion();
-        World world = entity.getWorld();
-        Cause cause = create(potion.getShooter());
-
-        // Fire item interaction event
-        Events.fireToCancel(event, new UseItemEvent(event, cause, world, potion.getItem()));
-
-        // Fire entity interaction event
-        if (!event.isCancelled()) {
-            int blocked = 0;
-
-            for (LivingEntity affected : event.getAffectedEntities()) {
-                if (Events.fireAndTestCancel(new DamageEntityEvent(event, cause, affected))) {
-                    event.setIntensity(affected, 0);
-                    blocked++;
-                }
-            }
-
-            if (blocked == event.getAffectedEntities().size()) {
-                event.setCancelled(true);
-            }
-        }
-    }
-
-    @EventHandler(ignoreCancelled = true)
-    public void onBlockDispense(BlockDispenseEvent event) {
-        Cause cause = create(event.getBlock());
-        Block dispenserBlock = event.getBlock();
-        ItemStack item = event.getItem();
-        MaterialData materialData = dispenserBlock.getState().getData();
-
-        Events.fireToCancel(event, new UseItemEvent(event, cause, dispenserBlock.getWorld(), item));
-
-        // Simulate right click event as players have it
-        if (materialData instanceof Dispenser) {
-            Dispenser dispenser = (Dispenser) materialData;
-            Block placed = dispenserBlock.getRelative(dispenser.getFacing());
-            Block clicked = placed.getRelative(dispenser.getFacing());
-            handleBlockRightClick(event, cause, item, clicked, dispenser.getFacing().getOppositeFace(), placed);
-        }
-    }
-
-    /**
-     * Handle the right click of a block while an item is held.
-     *
-     * @param event the original event
-     * @param cause the list of cause
-     * @param item the item
-     * @param clicked the clicked block
-     * @param faceClicked the face of the clicked block
-     * @param placed the placed block
-     * @param <T> the event type
-     */
-    private static <T extends Event & Cancellable> void handleBlockRightClick(T event, Cause cause, @Nullable ItemStack item, Block clicked, BlockFace faceClicked, Block placed) {
-        if (item != null && item.getType() == Material.TNT) {
-            // Workaround for a bug that allowed TNT to trigger instantly if placed
-            // next to redstone, without plugins getting the clicked place event
-            // (not sure if this actually still happens)
-            Events.fireToCancel(event, new UseBlockEvent(event, cause, clicked.getLocation(), Material.TNT));
-        }
-
-        // Handle created Minecarts
-        if (item != null && Materials.isMinecart(item.getType())) {
-            // TODO: Give a more specific Minecart type
-            Events.fireToCancel(event, new SpawnEntityEvent(event, cause, placed.getLocation().add(0.5, 0, 0.5), EntityType.MINECART));
-        }
-
-        // Handle created spawn eggs
-        if (item != null && item.getType() == Material.MONSTER_EGG) {
-            MaterialData data = item.getData();
-            if (data instanceof SpawnEgg) {
-                Events.fireToCancel(event, new SpawnEntityEvent(event, cause, placed.getLocation().add(0.5, 0, 0.5), ((SpawnEgg) data).getSpawnedType()));
-            }
-        }
-
-        // Handle cocoa beans
-        if (item != null && item.getType() == Material.INK_SACK && Materials.isDyeColor(item.getData(), DyeColor.BROWN)) {
-            // CraftBukkit doesn't or didn't throw a clicked place for this
-            if (!(faceClicked == BlockFace.DOWN || faceClicked == BlockFace.UP)) {
-                Events.fireToCancel(event, new PlaceBlockEvent(event, cause, placed.getLocation(), Material.COCOA));
-            }
-        }
-
-        // Workaround for http://leaky.bukkit.org/issues/1034
-        if (item != null && item.getType() == Material.TNT) {
-            Events.fireToCancel(event, new PlaceBlockEvent(event, cause, placed.getLocation(), Material.TNT));
-        }
-    }
-
-    @SuppressWarnings("unchecked")
-    private static <T extends Event & Cancellable> void handleInventoryHolderUse(T originalEvent, Cause cause, InventoryHolder holder) {
-        if (originalEvent.isCancelled()) {
-            return;
-        }
-
-        if (holder instanceof Entity) {
-            Events.fireToCancel(originalEvent, new UseEntityEvent(originalEvent, cause, (Entity) holder));
-        } else if (holder instanceof BlockState) {
-            Events.fireToCancel(originalEvent, new UseBlockEvent(originalEvent, cause, ((BlockState) holder).getBlock()));
-        } else if (holder instanceof DoubleChest) {
-            Events.fireToCancel(originalEvent, new UseBlockEvent(originalEvent, cause, ((BlockState) ((DoubleChest) holder).getLeftSide()).getBlock()));
-            Events.fireToCancel(originalEvent, new UseBlockEvent(originalEvent, cause, ((BlockState) ((DoubleChest) holder).getRightSide()).getBlock()));
-        }
-    }
-
-}
@@ -1,250 +0,0 @@
-/*
- * WorldGuard, a suite of tools for Minecraft
- * Copyright (C) sk89q <http://www.sk89q.com>
- * Copyright (C) WorldGuard team and contributors
- *
- * This program is free software: you can redistribute it and/or modify it
- * under the terms of the GNU Lesser General Public License as published by the
- * Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License
- * for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-package com.sk89q.worldguard.bukkit.listener;
-
-import com.sk89q.worldguard.bukkit.ConfigurationManager;
-import com.sk89q.worldguard.bukkit.WorldConfiguration;
-import com.sk89q.worldguard.bukkit.WorldGuardPlugin;
-import com.sk89q.worldguard.bukkit.util.RegionQueryUtil;
-import com.sk89q.worldguard.protection.ApplicableRegionSet;
-import com.sk89q.worldguard.protection.flags.DefaultFlag;
-import org.bukkit.GameMode;
-import org.bukkit.World;
-import org.bukkit.entity.Player;
-
-import java.util.HashMap;
-import java.util.Map;
-
-/**
- * This processes per-player state information and is also meant to be used
- * as a scheduled task.
- *
- * @author sk89q
- */
-public class FlagStateManager implements Runnable {
-
-    public static final int RUN_DELAY = 20;
-
-    private WorldGuardPlugin plugin;
-    private Map<String, PlayerFlagState> states;
-
-    /**
-     * Construct the object.
-     *
-     * @param plugin The plugin instance
-     */
-    public FlagStateManager(WorldGuardPlugin plugin) {
-        this.plugin = plugin;
-
-        states = new HashMap<String, PlayerFlagState>();
-    }
-
-    /**
-     * Run the task.
-     */
-    @Override
-    public void run() {
-        Player[] players = plugin.getServer().getOnlinePlayers();
-        ConfigurationManager config = plugin.getGlobalStateManager();
-
-        for (Player player : players) {
-            WorldConfiguration worldConfig = config.get(player.getWorld());
-
-            if (!worldConfig.useRegions) {
-                continue;
-            }
-
-            PlayerFlagState state;
-
-            synchronized (this) {
-                state = states.get(player.getName());
-
-                if (state == null) {
-                    state = new PlayerFlagState();
-                    states.put(player.getName(), state);
-                }
-            }
-
-            ApplicableRegionSet applicable = plugin.getRegionContainer().createQuery().getApplicableRegions(player.getLocation());
-
-            if (!RegionQueryUtil.isInvincible(plugin, player, applicable)
-                    && !plugin.getGlobalStateManager().hasGodMode(player)
-                    && !(player.getGameMode() == GameMode.CREATIVE)) {
-                processHeal(applicable, player, state);
-                processFeed(applicable, player, state);
-            }
-        }
-    }
-
-    /**
-     * Process healing for a player.
-     *
-     * @param applicable The set of applicable regions
-     * @param player The player to process healing flags on
-     * @param state The player's state
-     */
-    private void processHeal(ApplicableRegionSet applicable, Player player,
-            PlayerFlagState state) {
-
-        if (player.getHealth() <= 0) {
-            return;
-        }
-
-        long now = System.currentTimeMillis();
-
-        Integer healAmount = applicable.getFlag(DefaultFlag.HEAL_AMOUNT);
-        Integer healDelay = applicable.getFlag(DefaultFlag.HEAL_DELAY);
-        Double minHealth = applicable.getFlag(DefaultFlag.MIN_HEAL);
-        Double maxHealth = applicable.getFlag(DefaultFlag.MAX_HEAL);
-
-        if (healAmount == null || healDelay == null || healAmount == 0 || healDelay < 0) {
-            return;
-        }
-        if (minHealth == null) {
-            minHealth = 0.0;
-        }
-        if (maxHealth == null) {
-            maxHealth = player.getMaxHealth();
-        }
-
-        // Apply a cap to prevent possible exceptions
-        minHealth = Math.min(player.getMaxHealth(), minHealth);
-        maxHealth = Math.min(player.getMaxHealth(), maxHealth);
-
-        if (player.getHealth() >= maxHealth && healAmount > 0) {
-            return;
-        }
-
-        if (healDelay <= 0) {
-            player.setHealth(healAmount > 0 ? maxHealth : minHealth); // this will insta-kill if the flag is unset
-            state.lastHeal = now;
-        } else if (now - state.lastHeal > healDelay * 1000) {
-            // clamp health between minimum and maximum
-            player.setHealth(Math.min(maxHealth, Math.max(minHealth, player.getHealth() + healAmount)));
-            state.lastHeal = now;
-        }
-    }
-
-    /**
-     * Process restoring hunger for a player.
-     *
-     * @param applicable The set of applicable regions
-     * @param player The player to process hunger flags on
-     * @param state The player's state
-     */
-    private void processFeed(ApplicableRegionSet applicable, Player player,
-            PlayerFlagState state) {
-
-        long now = System.currentTimeMillis();
-
-        Integer feedAmount = applicable.getFlag(DefaultFlag.FEED_AMOUNT);
-        Integer feedDelay = applicable.getFlag(DefaultFlag.FEED_DELAY);
-        Integer minHunger = applicable.getFlag(DefaultFlag.MIN_FOOD);
-        Integer maxHunger = applicable.getFlag(DefaultFlag.MAX_FOOD);
-
-        if (feedAmount == null || feedDelay == null || feedAmount == 0 || feedDelay < 0) {
-            return;
-        }
-        if (minHunger == null) {
-            minHunger = 0;
-        }
-        if (maxHunger == null) {
-            maxHunger = 20;
-        }
-
-        // Apply a cap to prevent possible exceptions
-        minHunger = Math.min(20, minHunger);
-        maxHunger = Math.min(20, maxHunger);
-
-        if (player.getFoodLevel() >= maxHunger && feedAmount > 0) {
-            return;
-        }
-
-        if (feedDelay <= 0) {
-            player.setFoodLevel(feedAmount > 0 ? maxHunger : minHunger);
-            player.setSaturation(player.getFoodLevel());
-            state.lastFeed = now;
-        } else if (now - state.lastFeed > feedDelay * 1000) {
-            // clamp health between minimum and maximum
-            player.setFoodLevel(Math.min(maxHunger, Math.max(minHunger, player.getFoodLevel() + feedAmount)));
-            player.setSaturation(player.getFoodLevel());
-            state.lastFeed = now;
-        }
-    }
-
-    /**
-     * Forget a player.
-     *
-     * @param player The player to forget
-     */
-    public synchronized void forget(Player player) {
-        states.remove(player.getName());
-    }
-
-    /**
-     * Forget all managed players. Use with caution.
-     */
-    public synchronized void forgetAll() {
-        states.clear();
-    }
-
-    /**
-     * Get a player's flag state. A new state will be created if there is no existing
-     * state for the player.
-     *
-     * @param player The player to get a state for
-     * @return The {@code player}'s state
-     */
-    public synchronized PlayerFlagState getState(Player player) {
-        PlayerFlagState state = states.get(player.getName());
-
-        if (state == null) {
-            state = new PlayerFlagState();
-            states.put(player.getName(), state);
-        }
-
-        return state;
-    }
-
-    /**
-     * Keeps state per player.
-     */
-    public static class PlayerFlagState {
-        public long lastHeal;
-        public long lastFeed;
-        public String lastGreeting;
-        public String lastFarewell;
-        public Boolean lastExitAllowed = null;
-        public Boolean notifiedForLeave = false;
-        public Boolean notifiedForEnter = false;
-        public GameMode lastGameMode;
-        public World lastWorld;
-        public int lastBlockX;
-        public int lastBlockY;
-        public int lastBlockZ;
-
-        /* Used to cache invincibility status */
-        public World lastInvincibleWorld;
-        public int lastInvincibleX;
-        public int lastInvincibleY;
-        public int lastInvincibleZ;
-        public boolean wasInvincible;
-    }
-}
@@ -1,144 +0,0 @@
-/*
- * WorldGuard, a suite of tools for Minecraft
- * Copyright (C) sk89q <http://www.sk89q.com>
- * Copyright (C) WorldGuard team and contributors
- *
- * This program is free software: you can redistribute it and/or modify it
- * under the terms of the GNU Lesser General Public License as published by the
- * Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License
- * for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-package com.sk89q.worldguard.bukkit.listener;
-
-import com.google.common.base.Predicate;
-import com.sk89q.worldguard.bukkit.RegionQuery;
-import com.sk89q.worldguard.bukkit.WorldConfiguration;
-import com.sk89q.worldguard.bukkit.WorldGuardPlugin;
-import com.sk89q.worldguard.bukkit.event.block.BreakBlockEvent;
-import com.sk89q.worldguard.bukkit.event.block.PlaceBlockEvent;
-import com.sk89q.worldguard.bukkit.event.entity.SpawnEntityEvent;
-import com.sk89q.worldguard.bukkit.util.Materials;
-import com.sk89q.worldguard.protection.association.RegionAssociable;
-import com.sk89q.worldguard.protection.flags.DefaultFlag;
-import com.sk89q.worldguard.protection.flags.StateFlag;
-import org.bukkit.Location;
-import org.bukkit.block.Block;
-import org.bukkit.entity.Creeper;
-import org.bukkit.entity.EnderDragon;
-import org.bukkit.entity.Entity;
-import org.bukkit.entity.EntityType;
-import org.bukkit.event.EventHandler;
-import org.bukkit.event.EventPriority;
-
-import javax.annotation.Nullable;
-
-public class RegionFlagsListener extends AbstractListener {
-
-    /**
-     * Construct the listener.
-     *
-     * @param plugin an instance of WorldGuardPlugin
-     */
-    public RegionFlagsListener(WorldGuardPlugin plugin) {
-        super(plugin);
-    }
-
-    @EventHandler(priority = EventPriority.LOW, ignoreCancelled = true)
-    public void onPlaceBlock(final PlaceBlockEvent event) {
-        if (!isRegionSupportEnabled(event.getWorld())) return; // Region support disabled
-
-        RegionQuery query = getPlugin().getRegionContainer().createQuery();
-
-        Block block;
-        if ((block = event.getCause().getFirstBlock()) != null) {
-            // ================================================================
-            // PISTONS flag
-            // ================================================================
-
-            if (Materials.isPistonBlock(block.getType())) {
-                event.filter(testState(query, DefaultFlag.PISTONS), false);
-            }
-        }
-    }
-
-    @EventHandler(priority = EventPriority.LOW, ignoreCancelled = true)
-    public void onBreakBlock(final BreakBlockEvent event) {
-        if (!isRegionSupportEnabled(event.getWorld())) return; // Region support disabled
-
-        WorldConfiguration config = getWorldConfig(event.getWorld());
-        RegionQuery query = getPlugin().getRegionContainer().createQuery();
-
-        Block block;
-        if ((block = event.getCause().getFirstBlock()) != null) {
-            // ================================================================
-            // PISTONS flag
-            // ================================================================
-
-            if (Materials.isPistonBlock(block.getType())) {
-                event.filter(testState(query, DefaultFlag.PISTONS), false);
-            }
-        }
-
-        Entity entity;
-        if ((entity = event.getCause().getFirstEntity()) != null) {
-            // ================================================================
-            // CREEPER_EXPLOSION flag
-            // ================================================================
-
-            if (entity instanceof Creeper) { // Creeper
-                event.filter(testState(query, DefaultFlag.CREEPER_EXPLOSION), config.explosionFlagCancellation);
-            }
-
-            // ================================================================
-            // ENDERDRAGON_BLOCK_DAMAGE flag
-            // ================================================================
-
-            if (entity instanceof EnderDragon) { // Enderdragon
-                event.filter(testState(query, DefaultFlag.ENDERDRAGON_BLOCK_DAMAGE), config.explosionFlagCancellation);
-            }
-
-        }
-    }
-
-    @EventHandler(priority = EventPriority.LOW, ignoreCancelled = true)
-    public void onSpawnEntity(final SpawnEntityEvent event) {
-        if (!isRegionSupportEnabled(event.getWorld())) return; // Region support disabled
-
-        RegionQuery query = getPlugin().getRegionContainer().createQuery();
-
-        // ================================================================
-        // EXP_DROPS flag
-        // ================================================================
-
-        if (event.getEffectiveType() == EntityType.EXPERIENCE_ORB) {
-            event.filter(testState(query, DefaultFlag.EXP_DROPS), false);
-        }
-    }
-
-    /**
-     * Create a new predicate to test a state flag for each location.
-     *
-     * @param query the query
-     * @param flag the flag
-     * @return a predicate
-     */
-    private Predicate<Location> testState(final RegionQuery query, final StateFlag flag) {
-        return new Predicate<Location>() {
-            @Override
-            public boolean apply(@Nullable Location location) {
-                return query.testState(location, (RegionAssociable) null, flag);
-            }
-        };
-    }
-
-
-}
@@ -1,452 +0,0 @@
-/*
- * WorldGuard, a suite of tools for Minecraft
- * Copyright (C) sk89q <http://www.sk89q.com>
- * Copyright (C) WorldGuard team and contributors
- *
- * This program is free software: you can redistribute it and/or modify it
- * under the terms of the GNU Lesser General Public License as published by the
- * Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License
- * for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-package com.sk89q.worldguard.bukkit.listener;
-
-import com.google.common.base.Predicate;
-import com.sk89q.worldguard.bukkit.RegionQuery;
-import com.sk89q.worldguard.bukkit.WorldConfiguration;
-import com.sk89q.worldguard.bukkit.WorldGuardPlugin;
-import com.sk89q.worldguard.bukkit.cause.Cause;
-import com.sk89q.worldguard.bukkit.event.DelegateEvent;
-import com.sk89q.worldguard.bukkit.event.block.BreakBlockEvent;
-import com.sk89q.worldguard.bukkit.event.block.PlaceBlockEvent;
-import com.sk89q.worldguard.bukkit.event.block.UseBlockEvent;
-import com.sk89q.worldguard.bukkit.event.entity.DamageEntityEvent;
-import com.sk89q.worldguard.bukkit.event.entity.DestroyEntityEvent;
-import com.sk89q.worldguard.bukkit.event.entity.SpawnEntityEvent;
-import com.sk89q.worldguard.bukkit.event.entity.UseEntityEvent;
-import com.sk89q.worldguard.bukkit.permission.RegionPermissionModel;
-import com.sk89q.worldguard.bukkit.util.DelayedRegionOverlapAssociation;
-import com.sk89q.worldguard.bukkit.util.Entities;
-import com.sk89q.worldguard.bukkit.util.Events;
-import com.sk89q.worldguard.bukkit.util.Materials;
-import com.sk89q.worldguard.bukkit.util.WGMetadata;
-import com.sk89q.worldguard.domains.Association;
-import com.sk89q.worldguard.protection.association.Associables;
-import com.sk89q.worldguard.protection.association.RegionAssociable;
-import com.sk89q.worldguard.protection.events.DisallowedPVPEvent;
-import com.sk89q.worldguard.protection.flags.DefaultFlag;
-import com.sk89q.worldguard.protection.flags.StateFlag.State;
-import org.bukkit.ChatColor;
-import org.bukkit.Location;
-import org.bukkit.Material;
-import org.bukkit.OfflinePlayer;
-import org.bukkit.World;
-import org.bukkit.block.Block;
-import org.bukkit.entity.Entity;
-import org.bukkit.entity.EntityType;
-import org.bukkit.entity.Item;
-import org.bukkit.entity.Player;
-import org.bukkit.entity.Tameable;
-import org.bukkit.event.EventHandler;
-import org.bukkit.event.vehicle.VehicleExitEvent;
-
-/**
- * Handle events that need to be processed by region protection.
- */
-public class RegionProtectionListener extends AbstractListener {
-
-    private static final String DENY_MESSAGE_KEY = "worldguard.region.lastMessage";
-    private static final String DISEMBARK_MESSAGE_KEY = "worldguard.region.disembarkMessage";
-    private static final int LAST_MESSAGE_DELAY = 500;
-
-    /**
-     * Construct the listener.
-     *
-     * @param plugin an instance of WorldGuardPlugin
-     */
-    public RegionProtectionListener(WorldGuardPlugin plugin) {
-        super(plugin);
-    }
-
-    /**
-     * Tell a sender that s/he cannot do something 'here'.
-     *
-     * @param event the event
-     * @param cause the cause
-     * @param location the location
-     * @param what what was done
-     */
-    private void tellErrorMessage(DelegateEvent event, Cause cause, Location location, String what) {
-        if (event.isSilent()) {
-            return;
-        }
-
-        Object rootCause = cause.getRootCause();
-
-        if (rootCause instanceof Player) {
-            Player player = (Player) rootCause;
-
-            long now = System.currentTimeMillis();
-            Long lastTime = WGMetadata.getIfPresent(player, DENY_MESSAGE_KEY, Long.class);
-            if (lastTime == null || now - lastTime >= LAST_MESSAGE_DELAY) {
-                RegionQuery query = getPlugin().getRegionContainer().createQuery();
-                String message = query.queryValue(location, player, DefaultFlag.DENY_MESSAGE);
-                if (message != null) {
-                    player.sendMessage(message.replace("%what%", what));
-                }
-                WGMetadata.put(player, DENY_MESSAGE_KEY, now);
-            }
-        }
-    }
-
-    /**
-     * Return whether the given cause is whitelist (should be ignored).
-     *
-     * @param cause the cause
-     * @return true if whitelisted
-     */
-    private boolean isWhitelisted(Cause cause, World world) {
-        Object rootCause = cause.getRootCause();
-
-        if (rootCause instanceof Player) {
-            Player player = (Player) rootCause;
-            WorldConfiguration config = getWorldConfig(world);
-
-            if (config.fakePlayerBuildOverride && Entities.isFakePlayer(player)) {
-                return true;
-            }
-
-            return new RegionPermissionModel(getPlugin(), player).mayIgnoreRegionProtection(world);
-        } else {
-            return false;
-        }
-    }
-
-    private RegionAssociable createRegionAssociable(Cause cause) {
-        Object rootCause = cause.getRootCause();
-
-        if (!cause.isKnown()) {
-            return Associables.constant(Association.NON_MEMBER);
-        } else if (rootCause instanceof Player) {
-            return getPlugin().wrapPlayer((Player) rootCause);
-        } else if (rootCause instanceof OfflinePlayer) {
-            return getPlugin().wrapOfflinePlayer((OfflinePlayer) rootCause);
-        } else if (rootCause instanceof Entity) {
-            RegionQuery query = getPlugin().getRegionContainer().createQuery();
-            return new DelayedRegionOverlapAssociation(query, ((Entity) rootCause).getLocation());
-        } else if (rootCause instanceof Block) {
-            RegionQuery query = getPlugin().getRegionContainer().createQuery();
-            return new DelayedRegionOverlapAssociation(query, ((Block) rootCause).getLocation());
-        } else {
-            return Associables.constant(Association.NON_MEMBER);
-        }
-    }
-
-    @EventHandler(ignoreCancelled = true)
-    public void onPlaceBlock(final PlaceBlockEvent event) {
-        if (!isRegionSupportEnabled(event.getWorld())) return; // Region support disabled
-        if (isWhitelisted(event.getCause(), event.getWorld())) return; // Whitelisted cause
-
-        final Material type = event.getEffectiveMaterial();
-        final RegionQuery query = getPlugin().getRegionContainer().createQuery();
-        final RegionAssociable associable = createRegionAssociable(event.getCause());
-
-        // Don't check liquid flow unless it's enabled
-        if (event.getCause().getRootCause() instanceof Block
-                && Materials.isLiquid(type)
-                && !getWorldConfig(event.getWorld()).checkLiquidFlow) {
-            return;
-        }
-
-        event.filter(new Predicate<Location>() {
-            @Override
-            public boolean apply(Location target) {
-                boolean canPlace;
-                String what;
-
-                /* Flint and steel, fire charge, etc. */
-                if (type == Material.FIRE) {
-                    canPlace = query.testState(target, associable, DefaultFlag.BUILD, DefaultFlag.BLOCK_PLACE)
-                            || query.testState(target, associable, DefaultFlag.LIGHTER);
-                    what = "place fire";
-
-                /* Everything else */
-                } else {
-                    canPlace = query.testState(target, associable, DefaultFlag.BUILD, DefaultFlag.BLOCK_PLACE);
-                    what = "place that block";
-                }
-
-                if (!canPlace) {
-                    tellErrorMessage(event, event.getCause(), target, what);
-                    return false;
-                }
-
-                return true;
-            }
-        });
-    }
-
-    @EventHandler(ignoreCancelled = true)
-    public void onBreakBlock(final BreakBlockEvent event) {
-        if (!isRegionSupportEnabled(event.getWorld())) return; // Region support disabled
-        if (isWhitelisted(event.getCause(), event.getWorld())) return; // Whitelisted cause
-
-        final RegionQuery query = getPlugin().getRegionContainer().createQuery();
-
-        if (!event.isCancelled()) {
-            final RegionAssociable associable = createRegionAssociable(event.getCause());
-
-            event.filter(new Predicate<Location>() {
-                @Override
-                public boolean apply(Location target) {
-                    boolean canBreak;
-                    String what;
-
-                    /* TNT */
-                    if (event.getCause().find(EntityType.PRIMED_TNT, EntityType.PRIMED_TNT) != null) {
-                        canBreak = query.testState(target, associable, DefaultFlag.BUILD, DefaultFlag.BLOCK_BREAK)
-                                || query.testState(target, associable, DefaultFlag.TNT);
-                        what = "dynamite blocks";
-
-                    /* Everything else */
-                    } else {
-                        canBreak = query.testState(target, associable, DefaultFlag.BUILD, DefaultFlag.BLOCK_BREAK);
-                        what = "break that block";
-                    }
-
-                    if (!canBreak) {
-                        tellErrorMessage(event, event.getCause(), target, what);
-                        return false;
-                    }
-
-                    return true;
-                }
-            });
-        }
-    }
-
-    @EventHandler(ignoreCancelled = true)
-    public void onUseBlock(final UseBlockEvent event) {
-        if (!isRegionSupportEnabled(event.getWorld())) return; // Region support disabled
-        if (isWhitelisted(event.getCause(), event.getWorld())) return; // Whitelisted cause
-
-        final Material type = event.getEffectiveMaterial();
-        final RegionQuery query = getPlugin().getRegionContainer().createQuery();
-        final RegionAssociable associable = createRegionAssociable(event.getCause());
-
-        event.filter(new Predicate<Location>() {
-            @Override
-            public boolean apply(Location target) {
-                boolean canUse;
-                String what;
-
-                /* Inventory */
-                if (Materials.isInventoryBlock(type)) {
-                    canUse = query.testState(target, associable, DefaultFlag.BUILD)
-                            || query.testState(target, associable, DefaultFlag.USE, DefaultFlag.CHEST_ACCESS);
-                    what = "open that";
-
-                /* Beds */
-                } else if (type == Material.BED_BLOCK) {
-                    canUse = query.testState(target, associable, DefaultFlag.BUILD)
-                            || query.testState(target, associable, DefaultFlag.USE, DefaultFlag.SLEEP);
-                    what = "sleep";
-
-                /* TNT */
-                } else if (type == Material.TNT) {
-                    canUse = query.testState(target, associable, DefaultFlag.BUILD)
-                            || query.testState(target, associable, DefaultFlag.TNT);
-                    what = "use explosives";
-
-                /* Everything else */
-                } else {
-                    canUse = query.testState(target, associable, DefaultFlag.BUILD)
-                            || query.testState(target, associable, DefaultFlag.USE);
-                    what = "use that";
-                }
-
-                if (!canUse) {
-                    tellErrorMessage(event, event.getCause(), target, what);
-                    return false;
-                }
-
-                return true;
-            }
-        });
-    }
-
-    @EventHandler(ignoreCancelled = true)
-    public void onSpawnEntity(SpawnEntityEvent event) {
-        if (!isRegionSupportEnabled(event.getWorld())) return; // Region support disabled
-        if (isWhitelisted(event.getCause(), event.getWorld())) return; // Whitelisted cause
-
-        Location target = event.getTarget();
-        EntityType type = event.getEffectiveType();
-
-        RegionQuery query = getPlugin().getRegionContainer().createQuery();
-        RegionAssociable associable = createRegionAssociable(event.getCause());
-
-        boolean canSpawn;
-        String what;
-
-        /* Vehicles */
-        if (Entities.isVehicle(type)) {
-            canSpawn = query.testState(target, associable, DefaultFlag.BUILD)
-                    || query.testState(target, associable, DefaultFlag.PLACE_VEHICLE);
-            what = "place vehicles";
-
-        /* Item pickup */
-        } else if (event.getEntity() instanceof Item) {
-            canSpawn = query.testState(target, associable, DefaultFlag.BUILD)
-                    || query.testState(target, associable, DefaultFlag.ITEM_DROP);
-            what = "drop items";
-
-        /* Everything else */
-        } else {
-            canSpawn = query.testState(target, associable, DefaultFlag.BUILD);
-
-            if (event.getEntity() instanceof Item) {
-                what = "drop items";
-            } else {
-                what = "place things";
-            }
-        }
-
-        if (!canSpawn) {
-            tellErrorMessage(event, event.getCause(), target, what);
-            event.setCancelled(true);
-        }
-    }
-
-    @EventHandler(ignoreCancelled = true)
-    public void onDestroyEntity(DestroyEntityEvent event) {
-        if (!isRegionSupportEnabled(event.getWorld())) return; // Region support disabled
-        if (isWhitelisted(event.getCause(), event.getWorld())) return; // Whitelisted cause
-
-        Location target = event.getTarget();
-        EntityType type = event.getEntity().getType();
-        RegionAssociable associable = createRegionAssociable(event.getCause());
-
-        RegionQuery query = getPlugin().getRegionContainer().createQuery();
-        boolean canDestroy;
-        String what;
-
-        /* Vehicles */
-        if (Entities.isVehicle(type)) {
-            canDestroy = query.testState(target, associable, DefaultFlag.BUILD)
-                    || query.testState(target, associable, DefaultFlag.DESTROY_VEHICLE);
-            what = "break vehicles";
-
-        /* Item pickup */
-        } else if (event.getEntity() instanceof Item) {
-            canDestroy = query.testState(target, associable, DefaultFlag.BUILD)
-                    || query.testState(target, associable, DefaultFlag.ITEM_PICKUP);
-            what = "pick up items";
-
-        /* Everything else */
-        } else {
-            canDestroy = query.testState(target, associable, DefaultFlag.BUILD);
-            what = "break things";
-        }
-
-        if (!canDestroy) {
-            tellErrorMessage(event, event.getCause(), target, what);
-            event.setCancelled(true);
-        }
-    }
-
-    @EventHandler(ignoreCancelled = true)
-    public void onUseEntity(UseEntityEvent event) {
-        if (!isRegionSupportEnabled(event.getWorld())) return; // Region support disabled
-        if (isWhitelisted(event.getCause(), event.getWorld())) return; // Whitelisted cause
-
-        Location target = event.getTarget();
-        RegionAssociable associable = createRegionAssociable(event.getCause());
-
-        RegionQuery query = getPlugin().getRegionContainer().createQuery();
-        boolean canUse = query.testState(target, associable, DefaultFlag.BUILD) || query.testState(target, associable, DefaultFlag.USE);
-        String what = "use that";
-
-        if (!canUse) {
-            tellErrorMessage(event, event.getCause(), target, what);
-            event.setCancelled(true);
-        }
-    }
-
-    @EventHandler(ignoreCancelled = true)
-    public void onDamageEntity(DamageEntityEvent event) {
-        if (!isRegionSupportEnabled(event.getWorld())) return; // Region support disabled
-        if (isWhitelisted(event.getCause(), event.getWorld())) return; // Whitelisted cause
-
-        Location target = event.getTarget();
-        RegionAssociable associable = createRegionAssociable(event.getCause());
-
-        RegionQuery query = getPlugin().getRegionContainer().createQuery();
-        Player attacker;
-        boolean canDamage;
-        String what;
-
-        /* Hostile / ambient mob override */
-        if (Entities.isHostile(event.getEntity()) || Entities.isAmbient(event.getEntity())) {
-            canDamage = true;
-            what = "hit that";
-
-        /* PVP */
-        } else if (event.getEntity() instanceof Player && (attacker = event.getCause().getFirstPlayer()) != null && !attacker.equals(event.getEntity())) {
-            Player defender = (Player) event.getEntity();
-
-            canDamage = query.testState(target, associable, DefaultFlag.BUILD) || query.testState(target, associable, DefaultFlag.PVP)
-                    && query.queryState(attacker.getLocation(), attacker, DefaultFlag.PVP) != State.DENY;
-
-            // Fire the disallow PVP event
-            if (!canDamage && Events.fireAndTestCancel(new DisallowedPVPEvent(attacker, defender, event.getOriginalEvent()))) {
-                canDamage = true;
-            }
-
-            what = "PvP";
-
-        /* Everything else */
-        } else {
-            canDamage = query.testState(target, associable, DefaultFlag.BUILD) || query.testState(target, associable, DefaultFlag.USE);
-            what = "hit that";
-        }
-
-        if (!canDamage) {
-            tellErrorMessage(event, event.getCause(), target, what);
-            event.setCancelled(true);
-        }
-    }
-
-    @EventHandler(ignoreCancelled = true)
-    public void onVehicleExit(VehicleExitEvent event) {
-        Entity vehicle = event.getVehicle();
-        Entity exited = event.getExited();
-
-        if (vehicle instanceof Tameable && exited instanceof Player) {
-            Player player = (Player) exited;
-            if (!isWhitelisted(Cause.create(player), vehicle.getWorld())) {
-                RegionQuery query = getPlugin().getRegionContainer().createQuery();
-                Location location = vehicle.getLocation();
-                if (!query.testState(location, player, DefaultFlag.BUILD) && !query.testState(location, player, DefaultFlag.USE)) {
-                    long now = System.currentTimeMillis();
-                    Long lastTime = WGMetadata.getIfPresent(player, DISEMBARK_MESSAGE_KEY, Long.class);
-                    if (lastTime == null || now - lastTime >= LAST_MESSAGE_DELAY) {
-                        player.sendMessage("" + ChatColor.GOLD + "Don't disembark here!" + ChatColor.GRAY + " You can't get back on.");
-                        WGMetadata.put(player, DISEMBARK_MESSAGE_KEY, now);
-                    }
-
-                    event.setCancelled(true);
-                }
-            }
-        }
-    }
-
-}
@@ -1,132 +0,0 @@
-/*
- * WorldGuard, a suite of tools for Minecraft
- * Copyright (C) sk89q <http://www.sk89q.com>
- * Copyright (C) WorldGuard team and contributors
- *
- * This program is free software: you can redistribute it and/or modify it
- * under the terms of the GNU Lesser General Public License as published by the
- * Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License
- * for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-package com.sk89q.worldguard.bukkit.listener;
-
-import com.sk89q.worldguard.bukkit.ConfigurationManager;
-import com.sk89q.worldguard.bukkit.WorldConfiguration;
-import com.sk89q.worldguard.bukkit.WorldGuardPlugin;
-import org.bukkit.World;
-
-import static com.sk89q.worldguard.bukkit.BukkitUtil.isBlockWater;
-import static com.sk89q.worldguard.bukkit.BukkitUtil.setBlockToWater;
-
-public final class SpongeUtil {
-
-    private SpongeUtil() {
-    }
-
-    /**
-     * Remove water around a sponge.
-     *
-     * @param plugin The plugin instace
-     * @param world The world the sponge isin
-     * @param ox The x coordinate of the 'sponge' block
-     * @param oy The y coordinate of the 'sponge' block
-     * @param oz The z coordinate of the 'sponge' block
-     */
-    public static void clearSpongeWater(WorldGuardPlugin plugin, World world, int ox, int oy, int oz) {
-        ConfigurationManager cfg = plugin.getGlobalStateManager();
-        WorldConfiguration wcfg = cfg.get(world);
-
-        for (int cx = -wcfg.spongeRadius; cx <= wcfg.spongeRadius; cx++) {
-            for (int cy = -wcfg.spongeRadius; cy <= wcfg.spongeRadius; cy++) {
-                for (int cz = -wcfg.spongeRadius; cz <= wcfg.spongeRadius; cz++) {
-                    if (isBlockWater(world, ox + cx, oy + cy, oz + cz)) {
-                        world.getBlockAt(ox + cx, oy + cy, oz + cz).setTypeId(0);
-                    }
-                }
-            }
-        }
-    }
-
-    /**
-     * Add water around a sponge.
-     * 
-     * @param plugin The plugin instance
-     * @param world The world the sponge is located in
-     * @param ox The x coordinate of the 'sponge' block
-     * @param oy The y coordinate of the 'sponge' block
-     * @param oz The z coordinate of the 'sponge' block
-     */
-    public static void addSpongeWater(WorldGuardPlugin plugin, World world, int ox, int oy, int oz) {
-        ConfigurationManager cfg = plugin.getGlobalStateManager();
-        WorldConfiguration wcfg = cfg.get(world);
-
-        // The negative x edge
-        int cx = ox - wcfg.spongeRadius - 1;
-        for (int cy = oy - wcfg.spongeRadius - 1; cy <= oy + wcfg.spongeRadius + 1; cy++) {
-            for (int cz = oz - wcfg.spongeRadius - 1; cz <= oz + wcfg.spongeRadius + 1; cz++) {
-                if (isBlockWater(world, cx, cy, cz)) {
-                    setBlockToWater(world, cx + 1, cy, cz);
-                }
-            }
-        }
-
-        // The positive x edge
-        cx = ox + wcfg.spongeRadius + 1;
-        for (int cy = oy - wcfg.spongeRadius - 1; cy <= oy + wcfg.spongeRadius + 1; cy++) {
-            for (int cz = oz - wcfg.spongeRadius - 1; cz <= oz + wcfg.spongeRadius + 1; cz++) {
-                if (isBlockWater(world, cx, cy, cz)) {
-                    setBlockToWater(world, cx - 1, cy, cz);
-                }
-            }
-        }
-
-        // The negative y edge
-        int cy = oy - wcfg.spongeRadius - 1;
-        for (cx = ox - wcfg.spongeRadius - 1; cx <= ox + wcfg.spongeRadius + 1; cx++) {
-            for (int cz = oz - wcfg.spongeRadius - 1; cz <= oz + wcfg.spongeRadius + 1; cz++) {
-                if (isBlockWater(world, cx, cy, cz)) {
-                    setBlockToWater(world, cx, cy + 1, cz);
-                }
-            }
-        }
-
-        // The positive y edge
-        cy = oy + wcfg.spongeRadius + 1;
-        for (cx = ox - wcfg.spongeRadius - 1; cx <= ox + wcfg.spongeRadius + 1; cx++) {
-            for (int cz = oz - wcfg.spongeRadius - 1; cz <= oz + wcfg.spongeRadius + 1; cz++) {
-                if (isBlockWater(world, cx, cy, cz)) {
-                    setBlockToWater(world, cx, cy - 1, cz);
-                }
-            }
-        }
-
-        // The negative z edge
-        int cz = oz - wcfg.spongeRadius - 1;
-        for (cx = ox - wcfg.spongeRadius - 1; cx <= ox + wcfg.spongeRadius + 1; cx++) {
-            for (cy = oy - wcfg.spongeRadius - 1; cy <= oy + wcfg.spongeRadius + 1; cy++) {
-                if (isBlockWater(world, cx, cy, cz)) {
-                    setBlockToWater(world, cx, cy, cz + 1);
-                }
-            }
-        }
-
-        // The positive z edge
-        cz = oz + wcfg.spongeRadius + 1;
-        for (cx = ox - wcfg.spongeRadius - 1; cx <= ox + wcfg.spongeRadius + 1; cx++) {
-            for (cy = oy - wcfg.spongeRadius - 1; cy <= oy + wcfg.spongeRadius + 1; cy++) {
-                if (isBlockWater(world, cx, cy, cz)) {
-                    setBlockToWater(world, cx, cy, cz - 1);
-                }
-            }
-        }
-    }
-}
@@ -1,667 +0,0 @@
-/*
- * WorldGuard, a suite of tools for Minecraft
- * Copyright (C) sk89q <http://www.sk89q.com>
- * Copyright (C) WorldGuard team and contributors
- *
- * This program is free software: you can redistribute it and/or modify it
- * under the terms of the GNU Lesser General Public License as published by the
- * Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License
- * for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-package com.sk89q.worldguard.bukkit.listener;
-
-import com.sk89q.worldedit.blocks.BlockID;
-import com.sk89q.worldedit.blocks.BlockType;
-import com.sk89q.worldedit.blocks.ItemType;
-import com.sk89q.worldguard.bukkit.ConfigurationManager;
-import com.sk89q.worldguard.bukkit.WorldConfiguration;
-import com.sk89q.worldguard.bukkit.WorldGuardPlugin;
-import com.sk89q.worldguard.protection.ApplicableRegionSet;
-import com.sk89q.worldguard.protection.flags.DefaultFlag;
-import org.bukkit.Material;
-import org.bukkit.World;
-import org.bukkit.block.Block;
-import org.bukkit.entity.Player;
-import org.bukkit.entity.Snowman;
-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.BlockBurnEvent;
-import org.bukkit.event.block.BlockFadeEvent;
-import org.bukkit.event.block.BlockFormEvent;
-import org.bukkit.event.block.BlockFromToEvent;
-import org.bukkit.event.block.BlockIgniteEvent;
-import org.bukkit.event.block.BlockIgniteEvent.IgniteCause;
-import org.bukkit.event.block.BlockPhysicsEvent;
-import org.bukkit.event.block.BlockPlaceEvent;
-import org.bukkit.event.block.BlockRedstoneEvent;
-import org.bukkit.event.block.BlockSpreadEvent;
-import org.bukkit.event.block.EntityBlockFormEvent;
-import org.bukkit.event.block.LeavesDecayEvent;
-import org.bukkit.inventory.ItemStack;
-
-/**
- * The listener for block events.
- *
- * @author sk89q
- */
-public class WorldGuardBlockListener implements Listener {
-
-    private WorldGuardPlugin plugin;
-
-    /**
-     * Construct the object.
-     *
-     * @param plugin The plugin instance
-     */
-    public WorldGuardBlockListener(WorldGuardPlugin plugin) {
-        this.plugin = plugin;
-    }
-
-    /**
-     * Register events.
-     */
-    public void registerEvents() {
-        plugin.getServer().getPluginManager().registerEvents(this, plugin);
-    }
-
-    /**
-     * Get the world configuration given a world.
-     *
-     * @param world The world to get the configuration for.
-     * @return The configuration for {@code world}
-     */
-    protected WorldConfiguration getWorldConfig(World world) {
-        return plugin.getGlobalStateManager().get(world);
-    }
-
-    /**
-     * Get the world configuration given a player.
-     *
-     * @param player The player to get the wold from
-     * @return The {@link WorldConfiguration} for the player's world
-     */
-    protected WorldConfiguration getWorldConfig(Player player) {
-        return getWorldConfig(player.getWorld());
-    }
-
-    /*
-     * Called when a block is broken.
-     */
-    @EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
-    public void onBlockBreak(BlockBreakEvent event) {
-        Player player = event.getPlayer();
-        Block target = event.getBlock();
-        WorldConfiguration wcfg = getWorldConfig(player);
-
-        if (!wcfg.itemDurability) {
-            ItemStack held = player.getItemInHand();
-            if (held.getType() != Material.AIR && !(ItemType.usesDamageValue(held.getTypeId())|| BlockType.usesData(held.getTypeId()))) {
-                held.setDurability((short) 0);
-                player.setItemInHand(held);
-            }
-        }
-    }
-
-    /*
-     * Called when fluids flow.
-     */
-    @EventHandler(ignoreCancelled = true)
-    public void onBlockFromTo(BlockFromToEvent event) {
-        World world = event.getBlock().getWorld();
-        Block blockFrom = event.getBlock();
-        Block blockTo = event.getToBlock();
-
-        boolean isWater = blockFrom.getTypeId() == 8 || blockFrom.getTypeId() == 9;
-        boolean isLava = blockFrom.getTypeId() == 10 || blockFrom.getTypeId() == 11;
-        boolean isAir = blockFrom.getTypeId() == 0;
-
-        ConfigurationManager cfg = plugin.getGlobalStateManager();
-        WorldConfiguration wcfg = cfg.get(event.getBlock().getWorld());
-
-        if (cfg.activityHaltToggle) {
-            event.setCancelled(true);
-            return;
-        }
-
-        if (wcfg.simulateSponge && isWater) {
-            int ox = blockTo.getX();
-            int oy = blockTo.getY();
-            int oz = blockTo.getZ();
-
-            for (int cx = -wcfg.spongeRadius; cx <= wcfg.spongeRadius; cx++) {
-                for (int cy = -wcfg.spongeRadius; cy <= wcfg.spongeRadius; cy++) {
-                    for (int cz = -wcfg.spongeRadius; cz <= wcfg.spongeRadius; cz++) {
-                        Block sponge = world.getBlockAt(ox + cx, oy + cy, oz + cz);
-                        if (sponge.getTypeId() == 19
-                                && (!wcfg.redstoneSponges || !sponge.isBlockIndirectlyPowered())) {
-                            event.setCancelled(true);
-                            return;
-                        }
-                    }
-                }
-            }
-        }
-
-        /*if (plugin.classicWater && isWater) {
-        int blockBelow = blockFrom.getRelative(0, -1, 0).getTypeId();
-        if (blockBelow != 0 && blockBelow != 8 && blockBelow != 9) {
-        blockFrom.setTypeId(9);
-        if (blockTo.getTypeId() == 0) {
-        blockTo.setTypeId(9);
-        }
-        return;
-        }
-        }*/
-
-        // Check the fluid block (from) whether it is air.
-        // If so and the target block is protected, cancel the event
-        if (wcfg.preventWaterDamage.size() > 0) {
-            int targetId = blockTo.getTypeId();
-
-            if ((isAir || isWater) &&
-                    wcfg.preventWaterDamage.contains(targetId)) {
-                event.setCancelled(true);
-                return;
-            }
-        }
-
-        if (wcfg.allowedLavaSpreadOver.size() > 0 && isLava) {
-            int targetId = blockTo.getRelative(0, -1, 0).getTypeId();
-
-            if (!wcfg.allowedLavaSpreadOver.contains(targetId)) {
-                event.setCancelled(true);
-                return;
-            }
-        }
-
-        if (wcfg.highFreqFlags && isWater
-                && !plugin.getGlobalRegionManager().allows(DefaultFlag.WATER_FLOW,
-                blockFrom.getLocation())) {
-            event.setCancelled(true);
-            return;
-        }
-
-        if (wcfg.highFreqFlags && isLava
-                && !plugin.getGlobalRegionManager().allows(DefaultFlag.LAVA_FLOW,
-                blockFrom.getLocation())) {
-            event.setCancelled(true);
-            return;
-        }
-
-        if (wcfg.disableObsidianGenerators && (isAir || isLava)
-                && (blockTo.getTypeId() == BlockID.REDSTONE_WIRE
-                    || blockTo.getTypeId() == BlockID.TRIPWIRE)) {
-            blockTo.setTypeId(BlockID.AIR);
-            return;
-        }
-    }
-
-    /*
-     * Called when a block gets ignited.
-     */
-    @EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
-    public void onBlockIgnite(BlockIgniteEvent event) {
-        IgniteCause cause = event.getCause();
-        Block block = event.getBlock();
-        World world = block.getWorld();
-
-        ConfigurationManager cfg = plugin.getGlobalStateManager();
-        WorldConfiguration wcfg = cfg.get(world);
-
-        if (cfg.activityHaltToggle) {
-            event.setCancelled(true);
-            return;
-        }
-        boolean isFireSpread = cause == IgniteCause.SPREAD;
-
-        if (wcfg.preventLightningFire && cause == IgniteCause.LIGHTNING) {
-            event.setCancelled(true);
-            return;
-        }
-
-        if (wcfg.preventLavaFire && cause == IgniteCause.LAVA) {
-            event.setCancelled(true);
-            return;
-        }
-
-        if (wcfg.disableFireSpread && isFireSpread) {
-            event.setCancelled(true);
-            return;
-        }
-
-        if (wcfg.blockLighter && (cause == IgniteCause.FLINT_AND_STEEL || cause == IgniteCause.FIREBALL)
-                && event.getPlayer() != null
-                && !plugin.hasPermission(event.getPlayer(), "worldguard.override.lighter")) {
-            event.setCancelled(true);
-            return;
-        }
-
-        if (wcfg.fireSpreadDisableToggle && isFireSpread) {
-            event.setCancelled(true);
-            return;
-        }
-
-        if (wcfg.disableFireSpreadBlocks.size() > 0 && isFireSpread) {
-            int x = block.getX();
-            int y = block.getY();
-            int z = block.getZ();
-
-            if (wcfg.disableFireSpreadBlocks.contains(world.getBlockTypeIdAt(x, y - 1, z))
-                    || wcfg.disableFireSpreadBlocks.contains(world.getBlockTypeIdAt(x + 1, y, z))
-                    || wcfg.disableFireSpreadBlocks.contains(world.getBlockTypeIdAt(x - 1, y, z))
-                    || wcfg.disableFireSpreadBlocks.contains(world.getBlockTypeIdAt(x, y, z - 1))
-                    || wcfg.disableFireSpreadBlocks.contains(world.getBlockTypeIdAt(x, y, z + 1))) {
-                event.setCancelled(true);
-                return;
-            }
-        }
-
-        if (wcfg.useRegions) {
-            ApplicableRegionSet set = plugin.getRegionContainer().createQuery().getApplicableRegions(block.getLocation());
-
-            if (wcfg.highFreqFlags && isFireSpread
-                    && !set.allows(DefaultFlag.FIRE_SPREAD)) {
-                event.setCancelled(true);
-                return;
-            }
-
-            if (wcfg.highFreqFlags && cause == IgniteCause.LAVA
-                    && !set.allows(DefaultFlag.LAVA_FIRE)) {
-                event.setCancelled(true);
-                return;
-            }
-
-            if (cause == IgniteCause.FIREBALL && event.getPlayer() == null) {
-                // wtf bukkit, FIREBALL is supposed to be reserved to players
-                if (!set.allows(DefaultFlag.GHAST_FIREBALL)) {
-                    event.setCancelled(true);
-                    return;
-                }
-            }
-
-            if (cause == IgniteCause.LIGHTNING && !set.allows(DefaultFlag.LIGHTNING)) {
-                event.setCancelled(true);
-                return;
-            }
-        }
-    }
-
-    /*
-     * Called when a block is destroyed from burning.
-     */
-    @EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
-    public void onBlockBurn(BlockBurnEvent event) {
-        ConfigurationManager cfg = plugin.getGlobalStateManager();
-        WorldConfiguration wcfg = cfg.get(event.getBlock().getWorld());
-
-        if (cfg.activityHaltToggle) {
-            event.setCancelled(true);
-            return;
-        }
-
-        if (wcfg.disableFireSpread) {
-            event.setCancelled(true);
-            return;
-        }
-
-        if (wcfg.fireSpreadDisableToggle) {
-            Block block = event.getBlock();
-            event.setCancelled(true);
-            checkAndDestroyAround(block.getWorld(), block.getX(), block.getY(), block.getZ(), BlockID.FIRE);
-            return;
-        }
-
-        if (wcfg.disableFireSpreadBlocks.size() > 0) {
-            Block block = event.getBlock();
-
-            if (wcfg.disableFireSpreadBlocks.contains(block.getTypeId())) {
-                event.setCancelled(true);
-                checkAndDestroyAround(block.getWorld(), block.getX(), block.getY(), block.getZ(), BlockID.FIRE);
-                return;
-            }
-        }
-
-        if (wcfg.isChestProtected(event.getBlock())) {
-            event.setCancelled(true);
-            return;
-        }
-
-        if (wcfg.useRegions) {
-            Block block = event.getBlock();
-            int x = block.getX();
-            int y = block.getY();
-            int z = block.getZ();
-            ApplicableRegionSet set = plugin.getRegionContainer().createQuery().getApplicableRegions(block.getLocation());
-
-            if (!set.allows(DefaultFlag.FIRE_SPREAD)) {
-                checkAndDestroyAround(block.getWorld(), x, y, z, BlockID.FIRE);
-                event.setCancelled(true);
-            }
-
-        }
-    }
-
-    private void checkAndDestroyAround(World world, int x, int y, int z, int required) {
-        checkAndDestroy(world, x, y, z + 1, required);
-        checkAndDestroy(world, x, y, z - 1, required);
-        checkAndDestroy(world, x, y + 1, z, required);
-        checkAndDestroy(world, x, y - 1, z, required);
-        checkAndDestroy(world, x + 1, y, z, required);
-        checkAndDestroy(world, x - 1, y, z, required);
-    }
-
-    private void checkAndDestroy(World world, int x, int y, int z, int required) {
-        if (world.getBlockTypeIdAt(x, y, z) == required) {
-            world.getBlockAt(x, y, z).setTypeId(BlockID.AIR);
-        }
-    }
-
-    /*
-     * Called when block physics occurs.
-     */
-    @EventHandler(ignoreCancelled = true)
-    public void onBlockPhysics(BlockPhysicsEvent event) {
-        ConfigurationManager cfg = plugin.getGlobalStateManager();
-        WorldConfiguration wcfg = cfg.get(event.getBlock().getWorld());
-
-        if (cfg.activityHaltToggle) {
-            event.setCancelled(true);
-            return;
-        }
-
-        int id = event.getChangedTypeId();
-
-        if (id == 13 && wcfg.noPhysicsGravel) {
-            event.setCancelled(true);
-            return;
-        }
-
-        if (id == 12 && wcfg.noPhysicsSand) {
-            event.setCancelled(true);
-            return;
-        }
-
-        if (id == 90 && wcfg.allowPortalAnywhere) {
-            event.setCancelled(true);
-            return;
-        }
-
-        if (wcfg.ropeLadders && event.getBlock().getType() == Material.LADDER) {
-            if (event.getBlock().getRelative(0, 1, 0).getType() == Material.LADDER) {
-                event.setCancelled(true);
-                return;
-            }
-        }
-    }
-
-    /*
-     * Called when a player places a block.
-     */
-    @EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
-    public void onBlockPlace(BlockPlaceEvent event) {
-        Block target = event.getBlock();
-        World world = target.getWorld();
-
-        ConfigurationManager cfg = plugin.getGlobalStateManager();
-        WorldConfiguration wcfg = cfg.get(world);
-
-        if (wcfg.simulateSponge && target.getType() == Material.SPONGE) {
-            if (wcfg.redstoneSponges && target.isBlockIndirectlyPowered()) {
-                return;
-            }
-
-            int ox = target.getX();
-            int oy = target.getY();
-            int oz = target.getZ();
-
-            SpongeUtil.clearSpongeWater(plugin, world, ox, oy, oz);
-        }
-    }
-
-    /*
-     * Called when redstone changes.
-     */
-    @EventHandler(priority = EventPriority.HIGH)
-    public void onBlockRedstoneChange(BlockRedstoneEvent event) {
-        Block blockTo = event.getBlock();
-        World world = blockTo.getWorld();
-
-        ConfigurationManager cfg = plugin.getGlobalStateManager();
-        WorldConfiguration wcfg = cfg.get(world);
-
-        if (wcfg.simulateSponge && wcfg.redstoneSponges) {
-            int ox = blockTo.getX();
-            int oy = blockTo.getY();
-            int oz = blockTo.getZ();
-
-            for (int cx = -1; cx <= 1; cx++) {
-                for (int cy = -1; cy <= 1; cy++) {
-                    for (int cz = -1; cz <= 1; cz++) {
-                        Block sponge = world.getBlockAt(ox + cx, oy + cy, oz + cz);
-                        if (sponge.getTypeId() == 19
-                                && sponge.isBlockIndirectlyPowered()) {
-                            SpongeUtil.clearSpongeWater(plugin, world, ox + cx, oy + cy, oz + cz);
-                        } else if (sponge.getTypeId() == 19
-                                && !sponge.isBlockIndirectlyPowered()) {
-                            SpongeUtil.addSpongeWater(plugin, world, ox + cx, oy + cy, oz + cz);
-                        }
-                    }
-                }
-            }
-
-            return;
-        }
-    }
-
-    @EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
-    public void onLeavesDecay(LeavesDecayEvent event) {
-        ConfigurationManager cfg = plugin.getGlobalStateManager();
-        WorldConfiguration wcfg = cfg.get(event.getBlock().getWorld());
-
-        if (cfg.activityHaltToggle) {
-            event.setCancelled(true);
-            return;
-        }
-
-        if (wcfg.disableLeafDecay) {
-            event.setCancelled(true);
-            return;
-        }
-
-        if (wcfg.useRegions) {
-            if (!plugin.getGlobalRegionManager().allows(DefaultFlag.LEAF_DECAY,
-                    event.getBlock().getLocation())) {
-                event.setCancelled(true);
-            }
-        }
-    }
-
-    /*
-     * Called when a block is formed based on world conditions.
-     */
-    @EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
-    public void onBlockForm(BlockFormEvent event) {
-        ConfigurationManager cfg = plugin.getGlobalStateManager();
-        WorldConfiguration wcfg = cfg.get(event.getBlock().getWorld());
-
-        if (cfg.activityHaltToggle) {
-            event.setCancelled(true);
-            return;
-        }
-
-        int type = event.getNewState().getTypeId();
-
-        if (event instanceof EntityBlockFormEvent) {
-            if (((EntityBlockFormEvent) event).getEntity() instanceof Snowman) {
-                if (wcfg.disableSnowmanTrails) {
-                    event.setCancelled(true);
-                    return;
-                }
-            }
-            return;
-        }
-
-        if (type == BlockID.ICE) {
-            if (wcfg.disableIceFormation) {
-                event.setCancelled(true);
-                return;
-            }
-            if (wcfg.useRegions && !plugin.getGlobalRegionManager().allows(
-                    DefaultFlag.ICE_FORM, event.getBlock().getLocation())) {
-                event.setCancelled(true);
-                return;
-            }
-        }
-
-        if (type == BlockID.SNOW) {
-            if (wcfg.disableSnowFormation) {
-                event.setCancelled(true);
-                return;
-            }
-            if (wcfg.allowedSnowFallOver.size() > 0) {
-                int targetId = event.getBlock().getRelative(0, -1, 0).getTypeId();
-
-                if (!wcfg.allowedSnowFallOver.contains(targetId)) {
-                    event.setCancelled(true);
-                    return;
-                }
-            }
-            if (wcfg.useRegions && !plugin.getGlobalRegionManager().allows(
-                    DefaultFlag.SNOW_FALL, event.getBlock().getLocation())) {
-                event.setCancelled(true);
-                return;
-            }
-        }
-    }
-
-    /*
-     * Called when a block spreads based on world conditions.
-     */
-    @EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
-    public void onBlockSpread(BlockSpreadEvent event) {
-        ConfigurationManager cfg = plugin.getGlobalStateManager();
-        WorldConfiguration wcfg = cfg.get(event.getBlock().getWorld());
-
-        if (cfg.activityHaltToggle) {
-            event.setCancelled(true);
-            return;
-        }
-
-        int fromType = event.getSource().getTypeId();
-
-        if (fromType == BlockID.RED_MUSHROOM || fromType == BlockID.BROWN_MUSHROOM) {
-            if (wcfg.disableMushroomSpread) {
-                event.setCancelled(true);
-                return;
-            }
-            if (wcfg.useRegions && !plugin.getGlobalRegionManager().allows(
-                    DefaultFlag.MUSHROOMS, event.getBlock().getLocation())) {
-                event.setCancelled(true);
-                return;
-            }
-        }
-
-        if (fromType == BlockID.GRASS) {
-            if (wcfg.disableGrassGrowth) {
-                event.setCancelled(true);
-                return;
-            }
-            if (wcfg.useRegions && !plugin.getGlobalRegionManager().allows(
-                    DefaultFlag.GRASS_SPREAD, event.getBlock().getLocation())) {
-                event.setCancelled(true);
-                return;
-            }
-        }
-
-        if (fromType == BlockID.MYCELIUM) {
-            if (wcfg.disableMyceliumSpread) {
-                event.setCancelled(true);
-                return;
-            }
-
-            if (wcfg.useRegions
-                    && !plugin.getGlobalRegionManager().allows(
-                            DefaultFlag.MYCELIUM_SPREAD, event.getBlock().getLocation())) {
-                event.setCancelled(true);
-                return;
-            }
-        }
-
-        if (fromType == BlockID.VINE) {
-            if (wcfg.disableVineGrowth) {
-                event.setCancelled(true);
-                return;
-            }
-
-            if (wcfg.useRegions
-                    && !plugin.getGlobalRegionManager().allows(
-                            DefaultFlag.VINE_GROWTH, event.getBlock().getLocation())) {
-                event.setCancelled(true);
-                return;
-            }
-        }
-    }
-
-    /*
-     * Called when a block fades.
-     */
-    @EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
-    public void onBlockFade(BlockFadeEvent event) {
-
-        ConfigurationManager cfg = plugin.getGlobalStateManager();
-        WorldConfiguration wcfg = cfg.get(event.getBlock().getWorld());
-
-        switch (event.getBlock().getTypeId()) {
-        case BlockID.ICE:
-            if (wcfg.disableIceMelting) {
-                event.setCancelled(true);
-                return;
-            }
-
-            if (wcfg.useRegions && !plugin.getGlobalRegionManager().allows(
-                    DefaultFlag.ICE_MELT, event.getBlock().getLocation())) {
-                event.setCancelled(true);
-                return;
-            }
-            break;
-
-        case BlockID.SNOW:
-            if (wcfg.disableSnowMelting) {
-                event.setCancelled(true);
-                return;
-            }
-
-            if (wcfg.useRegions && !plugin.getGlobalRegionManager().allows(
-                    DefaultFlag.SNOW_MELT, event.getBlock().getLocation())) {
-                event.setCancelled(true);
-                return;
-            }
-            break;
-
-        case BlockID.SOIL:
-            if (wcfg.disableSoilDehydration) {
-                event.setCancelled(true);
-                return;
-            }
-            if (wcfg.useRegions && !plugin.getGlobalRegionManager().allows(
-                    DefaultFlag.SOIL_DRY, event.getBlock().getLocation())) {
-                event.setCancelled(true);
-                return;
-            }
-            break;
-        }
-
-    }
-
-}
@@ -1,667 +0,0 @@
-/*
- * WorldGuard, a suite of tools for Minecraft
- * Copyright (C) sk89q <http://www.sk89q.com>
- * Copyright (C) WorldGuard team and contributors
- *
- * This program is free software: you can redistribute it and/or modify it
- * under the terms of the GNU Lesser General Public License as published by the
- * Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License
- * for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-package com.sk89q.worldguard.bukkit.listener;
-
-import com.sk89q.worldedit.Vector;
-import com.sk89q.worldedit.blocks.BlockID;
-import com.sk89q.worldguard.LocalPlayer;
-import com.sk89q.worldguard.bukkit.BukkitUtil;
-import com.sk89q.worldguard.bukkit.ConfigurationManager;
-import com.sk89q.worldguard.bukkit.WorldConfiguration;
-import com.sk89q.worldguard.bukkit.WorldGuardPlugin;
-import com.sk89q.worldguard.bukkit.event.player.ProcessPlayerEvent;
-import com.sk89q.worldguard.bukkit.listener.FlagStateManager.PlayerFlagState;
-import com.sk89q.worldguard.bukkit.util.Events;
-import com.sk89q.worldguard.protection.ApplicableRegionSet;
-import com.sk89q.worldguard.protection.flags.DefaultFlag;
-import com.sk89q.worldguard.protection.managers.RegionManager;
-import com.sk89q.worldguard.protection.regions.ProtectedRegion;
-import com.sk89q.worldguard.util.command.CommandFilter;
-import org.bukkit.ChatColor;
-import org.bukkit.GameMode;
-import org.bukkit.Location;
-import org.bukkit.World;
-import org.bukkit.block.Block;
-import org.bukkit.entity.Entity;
-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.Action;
-import org.bukkit.event.player.AsyncPlayerChatEvent;
-import org.bukkit.event.player.PlayerCommandPreprocessEvent;
-import org.bukkit.event.player.PlayerGameModeChangeEvent;
-import org.bukkit.event.player.PlayerInteractEvent;
-import org.bukkit.event.player.PlayerItemHeldEvent;
-import org.bukkit.event.player.PlayerJoinEvent;
-import org.bukkit.event.player.PlayerLoginEvent;
-import org.bukkit.event.player.PlayerMoveEvent;
-import org.bukkit.event.player.PlayerQuitEvent;
-import org.bukkit.event.player.PlayerRespawnEvent;
-import org.bukkit.event.player.PlayerTeleportEvent;
-import org.bukkit.event.player.PlayerTeleportEvent.TeleportCause;
-import org.bukkit.inventory.ItemStack;
-import org.bukkit.plugin.PluginManager;
-
-import java.util.Iterator;
-import java.util.Set;
-import java.util.logging.Logger;
-import java.util.regex.Pattern;
-
-/**
- * Handles all events thrown in relation to a player.
- */
-public class WorldGuardPlayerListener implements Listener {
-
-    private static final Logger log = Logger.getLogger(WorldGuardPlayerListener.class.getCanonicalName());
-    private Pattern opPattern = Pattern.compile("^/op(?:\\s.*)?$", Pattern.CASE_INSENSITIVE);
-    private WorldGuardPlugin plugin;
-
-    /**
-     * Construct the object;
-     *
-     * @param plugin
-     */
-    public WorldGuardPlayerListener(WorldGuardPlugin plugin) {
-        this.plugin = plugin;
-    }
-
-    /**
-     * Register events.
-     */
-    public void registerEvents() {
-        final PluginManager pm = plugin.getServer().getPluginManager();
-        pm.registerEvents(this, plugin);
-
-        if (plugin.getGlobalStateManager().usePlayerMove) {
-            pm.registerEvents(new PlayerMoveHandler(), plugin);
-        }
-    }
-
-    // unsure if anyone actually started using this yet, but just in case...
-    @Deprecated
-    public static boolean checkMove(WorldGuardPlugin plugin, Player player, World world, Location from, Location to) {
-        return checkMove(plugin, player, from, to); // drop world since it used to be mishandled
-    }
-
-    /**
-     * Handles movement related events, including changing gamemode, sending
-     * greeting/farewell messages, etc.
-     * A reference to WorldGuardPlugin is required to keep this method static
-     * although WGBukkit.getPlugin() may be used.
-     * @return true if the movement should not be allowed
-     */
-    public static boolean checkMove(WorldGuardPlugin plugin, Player player, Location from, Location to) {
-        PlayerFlagState state = plugin.getFlagStateManager().getState(player);
-
-        //Flush states in multiworld scenario
-        if (state.lastWorld != null && !state.lastWorld.equals(to.getWorld())) {
-            plugin.getFlagStateManager().forget(player);
-            state = plugin.getFlagStateManager().getState(player);
-        }
-
-        World world = from.getWorld();
-        World toWorld = to.getWorld();
-
-        LocalPlayer localPlayer = plugin.wrapPlayer(player);
-        boolean hasBypass = plugin.getGlobalRegionManager().hasBypass(player, world);
-        boolean hasRemoteBypass;
-        if (world.equals(toWorld)) {
-            hasRemoteBypass = hasBypass;
-        } else {
-            hasRemoteBypass = plugin.getGlobalRegionManager().hasBypass(player, toWorld);
-        }
-
-        RegionManager mgr = plugin.getGlobalRegionManager().get(toWorld);
-        if (mgr == null) {
-            return false;
-        }
-        Vector pt = new Vector(to.getBlockX(), to.getBlockY(), to.getBlockZ());
-        ApplicableRegionSet set = mgr.getApplicableRegions(pt);
-
-        /*
-        // check if region is full
-        // get the lowest number of allowed members in any region
-        boolean regionFull = false;
-        String maxPlayerMessage = null;
-        if (!hasBypass) {
-            for (ProtectedRegion region : set) {
-                if (region instanceof GlobalProtectedRegion) {
-                    continue; // global region can't have a max
-                }
-                // get the max for just this region
-                Integer maxPlayers = region.getFlag(DefaultFlag.MAX_PLAYERS);
-                if (maxPlayers == null) {
-                    continue;
-                }
-                int occupantCount = 0;
-                for(Player occupant : world.getPlayers()) {
-                    // each player in this region counts as one toward the max of just this region
-                    // A person with bypass doesn't count as an occupant of the region
-                    if (!occupant.equals(player) && !plugin.getGlobalRegionManager().hasBypass(occupant, world)) {
-                        if (region.contains(BukkitUtil.toVector(occupant.getLocation()))) {
-                            if (++occupantCount >= maxPlayers) {
-                                regionFull = true;
-                                maxPlayerMessage = region.getFlag(DefaultFlag.MAX_PLAYERS_MESSAGE);
-                                // At least one region in the set is full, we are going to use this message because it
-                                // was the first one we detected as full. In reality we should check them all and then
-                                // resolve the message from full regions, but that is probably a lot laggier (and this
-                                // is already pretty laggy. In practice, we can't really control which one we get first
-                                // right here.
-                                break;
-                            }
-                        }
-                    }
-                }
-            }
-        }
-        */
-
-        boolean entryAllowed = set.allows(DefaultFlag.ENTRY, localPlayer);
-        if (!hasRemoteBypass && (!entryAllowed /*|| regionFull*/)) {
-            String message = /*maxPlayerMessage != null ? maxPlayerMessage :*/ "You are not permitted to enter this area.";
-
-            player.sendMessage(ChatColor.DARK_RED + message);
-            return true;
-        }
-
-        // Have to set this state
-        if (state.lastExitAllowed == null) {
-            state.lastExitAllowed = plugin.getRegionContainer().createQuery().getApplicableRegions(from)
-                        .allows(DefaultFlag.EXIT, localPlayer);
-        }
-
-        boolean exitAllowed = set.allows(DefaultFlag.EXIT, localPlayer);
-        if (!hasBypass && exitAllowed && !state.lastExitAllowed) {
-            player.sendMessage(ChatColor.DARK_RED + "You are not permitted to leave this area.");
-            return true;
-        }
-
-//        WorldGuardRegionMoveEvent event = new WorldGuardRegionMoveEvent(plugin, player, state, set, from, to);
-//        Bukkit.getPluginManager().callEvent(event);
-
-        String greeting = set.getFlag(DefaultFlag.GREET_MESSAGE);//, localPlayer);
-        String farewell = set.getFlag(DefaultFlag.FAREWELL_MESSAGE);//, localPlayer);
-        Boolean notifyEnter = set.getFlag(DefaultFlag.NOTIFY_ENTER);//, localPlayer);
-        Boolean notifyLeave = set.getFlag(DefaultFlag.NOTIFY_LEAVE);//, localPlayer);
-        GameMode gameMode = set.getFlag(DefaultFlag.GAME_MODE);
-
-        if (state.lastFarewell != null && (farewell == null
-                || !state.lastFarewell.equals(farewell))) {
-            String replacedFarewell = plugin.replaceMacros(
-                    player, BukkitUtil.replaceColorMacros(state.lastFarewell));
-            player.sendMessage(replacedFarewell.replaceAll("\\\\n", "\n").split("\\n"));
-        }
-
-        if (greeting != null && (state.lastGreeting == null
-                || !state.lastGreeting.equals(greeting))) {
-            String replacedGreeting = plugin.replaceMacros(
-                    player, BukkitUtil.replaceColorMacros(greeting));
-            player.sendMessage(replacedGreeting.replaceAll("\\\\n", "\n").split("\\n"));
-        }
-
-        if ((notifyLeave == null || !notifyLeave)
-                && state.notifiedForLeave != null && state.notifiedForLeave) {
-            plugin.broadcastNotification(ChatColor.GRAY + "WG: "
-                    + ChatColor.LIGHT_PURPLE + player.getName()
-                    + ChatColor.GOLD + " left NOTIFY region");
-        }
-
-        if (notifyEnter != null && notifyEnter && (state.notifiedForEnter == null
-                || !state.notifiedForEnter)) {
-            StringBuilder regionList = new StringBuilder();
-
-            for (ProtectedRegion region : set) {
-                if (regionList.length() != 0) {
-                    regionList.append(", ");
-                }
-                regionList.append(region.getId());
-            }
-
-            plugin.broadcastNotification(ChatColor.GRAY + "WG: "
-                    + ChatColor.LIGHT_PURPLE + player.getName()
-                    + ChatColor.GOLD + " entered NOTIFY region: "
-                    + ChatColor.WHITE
-                    + regionList);
-        }
-
-        if (!hasBypass && gameMode != null) {
-            if (player.getGameMode() != gameMode) {
-                state.lastGameMode = player.getGameMode();
-                player.setGameMode(gameMode);
-            } else if (state.lastGameMode == null) {
-                state.lastGameMode = player.getServer().getDefaultGameMode();
-            }
-        } else {
-            if (state.lastGameMode != null) {
-                GameMode mode = state.lastGameMode;
-                state.lastGameMode = null;
-                player.setGameMode(mode);
-            }
-        }
-
-        state.lastGreeting = greeting;
-        state.lastFarewell = farewell;
-        state.notifiedForEnter = notifyEnter;
-        state.notifiedForLeave = notifyLeave;
-        state.lastExitAllowed = exitAllowed;
-        state.lastWorld = to.getWorld();
-        state.lastBlockX = to.getBlockX();
-        state.lastBlockY = to.getBlockY();
-        state.lastBlockZ = to.getBlockZ();
-        return false;
-    }
-
-    class PlayerMoveHandler implements Listener {
-        @EventHandler(priority = EventPriority.HIGH)
-        public void onPlayerMove(PlayerMoveEvent event) {
-            final Player player = event.getPlayer();
-            World world = player.getWorld();
-
-            ConfigurationManager cfg = plugin.getGlobalStateManager();
-            WorldConfiguration wcfg = cfg.get(world);
-
-            if (wcfg.useRegions) {
-                // Did we move a block?
-                if (event.getFrom().getBlockX() != event.getTo().getBlockX()
-                        || event.getFrom().getBlockY() != event.getTo().getBlockY()
-                        || event.getFrom().getBlockZ() != event.getTo().getBlockZ()) {
-                    boolean result = checkMove(plugin, player, event.getFrom(), event.getTo());
-                    if (result) {
-                        final Location newLoc = event.getFrom();
-                        newLoc.setX(newLoc.getBlockX() + 0.5);
-                        newLoc.setY(newLoc.getBlockY());
-                        newLoc.setZ(newLoc.getBlockZ() + 0.5);
-                        event.setTo(newLoc);
-
-                        final Entity vehicle = player.getVehicle();
-                        if (vehicle != null) {
-                            vehicle.eject();
-                            vehicle.teleport(newLoc);
-                            player.teleport(newLoc);
-                            vehicle.setPassenger(player);
-                        }
-                    }
-                }
-            }
-        }
-    }
-
-    @EventHandler
-    public void onPlayerGameModeChange(PlayerGameModeChangeEvent event) {
-        Player player = event.getPlayer();
-        WorldConfiguration wcfg = plugin.getGlobalStateManager().get(player.getWorld());
-        if (wcfg.useRegions && !plugin.getGlobalRegionManager().hasBypass(player, player.getWorld())) {
-            GameMode gameMode = plugin.getRegionContainer().createQuery().getApplicableRegions(player.getLocation()).getFlag(DefaultFlag.GAME_MODE);
-            if (plugin.getFlagStateManager().getState(player).lastGameMode != null
-                    && gameMode != null && event.getNewGameMode() != gameMode) {
-                event.setCancelled(true);
-            }
-        }
-    }
-
-    @EventHandler
-    public void onPlayerJoin(PlayerJoinEvent event) {
-        Player player = event.getPlayer();
-        World world = player.getWorld();
-
-        ConfigurationManager cfg = plugin.getGlobalStateManager();
-        WorldConfiguration wcfg = cfg.get(world);
-
-        if (cfg.activityHaltToggle) {
-            player.sendMessage(ChatColor.YELLOW
-                    + "Intensive server activity has been HALTED.");
-
-            int removed = 0;
-
-            for (Entity entity : world.getEntities()) {
-                if (BukkitUtil.isIntensiveEntity(entity)) {
-                    entity.remove();
-                    removed++;
-                }
-            }
-
-            if (removed > 10) {
-                log.info("Halt-Act: " + removed + " entities (>10) auto-removed from "
-                        + player.getWorld().toString());
-            }
-        }
-
-        if (wcfg.fireSpreadDisableToggle) {
-            player.sendMessage(ChatColor.YELLOW
-                    + "Fire spread is currently globally disabled for this world.");
-        }
-
-        Events.fire(new ProcessPlayerEvent(player));
-
-        if (wcfg.useRegions) {
-            PlayerFlagState state = plugin.getFlagStateManager().getState(player);
-            Location loc = player.getLocation();
-            state.lastWorld = loc.getWorld();
-            state.lastBlockX = loc.getBlockX();
-            state.lastBlockY = loc.getBlockY();
-            state.lastBlockZ = loc.getBlockZ();
-        }
-    }
-
-    @EventHandler(ignoreCancelled = true)
-    public void onPlayerChat(AsyncPlayerChatEvent event) {
-        Player player = event.getPlayer();
-        WorldConfiguration wcfg = plugin.getGlobalStateManager().get(player.getWorld());
-        if (wcfg.useRegions) {
-            if (!plugin.getGlobalRegionManager().allows(DefaultFlag.SEND_CHAT, player.getLocation())) {
-                player.sendMessage(ChatColor.RED + "You don't have permission to chat in this region!");
-                event.setCancelled(true);
-                return;
-            }
-
-            for (Iterator<Player> i = event.getRecipients().iterator(); i.hasNext();) {
-                if (!plugin.getGlobalRegionManager().allows(DefaultFlag.RECEIVE_CHAT, i.next().getLocation())) {
-                    i.remove();
-                }
-            }
-            if (event.getRecipients().size() == 0) {
-                event.setCancelled(true);
-            }
-        }
-    }
-
-    @EventHandler(ignoreCancelled = true)
-    public void onPlayerLogin(PlayerLoginEvent event) {
-        Player player = event.getPlayer();
-        ConfigurationManager cfg = plugin.getGlobalStateManager();
-
-        String hostKey = cfg.hostKeys.get(player.getName().toLowerCase());
-        if (hostKey != null) {
-            String hostname = event.getHostname();
-            int colonIndex = hostname.indexOf(':');
-            if (colonIndex != -1) {
-                hostname = hostname.substring(0, colonIndex);
-            }
-
-            if (!hostname.equals(hostKey)) {
-                event.disallow(PlayerLoginEvent.Result.KICK_OTHER,
-                        "You did not join with the valid host key!");
-                log.warning("WorldGuard host key check: " +
-                        player.getName() + " joined with '" + hostname +
-                        "' but '" + hostKey + "' was expected. Kicked!");
-                return;
-            }
-        }
-
-        if (cfg.deopOnJoin) {
-            player.setOp(false);
-        }
-    }
-
-    @EventHandler
-    public void onPlayerQuit(PlayerQuitEvent event) {
-        Player player = event.getPlayer();
-        World world = player.getWorld();
-
-        ConfigurationManager cfg = plugin.getGlobalStateManager();
-        WorldConfiguration wcfg = cfg.get(world);
-
-        // This is to make the enter/exit flags accurate -- move events are not
-        // sent constantly, so it is possible to move just a little enough to
-        // not trigger the event and then rejoin so that you are then considered
-        // outside the border. This should work around that.
-        if (wcfg.useRegions) {
-            boolean hasBypass = plugin.getGlobalRegionManager().hasBypass(player, world);
-            PlayerFlagState state = plugin.getFlagStateManager().getState(player);
-
-            if (state.lastWorld != null && !hasBypass) {
-                LocalPlayer localPlayer = plugin.wrapPlayer(player);
-                Location loc = player.getLocation();
-                ApplicableRegionSet set = plugin.getRegionContainer().createQuery().getApplicableRegions(loc);
-
-                if (state.lastExitAllowed == null) {
-                    state.lastExitAllowed = set.allows(DefaultFlag.EXIT, localPlayer);
-                }
-
-                if (!state.lastExitAllowed || !set.allows(DefaultFlag.ENTRY, localPlayer)) {
-                    // Only if we have the last location cached
-                    if (state.lastWorld.equals(world)) {
-                        Location newLoc = new Location(world, state.lastBlockX + 0.5,
-                                state.lastBlockY, state.lastBlockZ + 0.5);
-                        player.teleport(newLoc);
-                    }
-                }
-            }
-        }
-
-        cfg.forgetPlayer(plugin.wrapPlayer(player));
-        plugin.forgetPlayer(player);
-    }
-
-    @EventHandler(priority = EventPriority.HIGH)
-    public void onPlayerInteract(PlayerInteractEvent event) {
-        Player player = event.getPlayer();
-        World world = player.getWorld();
-
-        if (event.getAction() == Action.RIGHT_CLICK_BLOCK) {
-            handleBlockRightClick(event);
-        } else if (event.getAction() == Action.PHYSICAL) {
-            handlePhysicalInteract(event);
-        }
-
-        ConfigurationManager cfg = plugin.getGlobalStateManager();
-        WorldConfiguration wcfg = cfg.get(world);
-
-        if (wcfg.removeInfiniteStacks
-                && !plugin.hasPermission(player, "worldguard.override.infinite-stack")) {
-            int slot = player.getInventory().getHeldItemSlot();
-            ItemStack heldItem = player.getInventory().getItem(slot);
-            if (heldItem != null && heldItem.getAmount() < 0) {
-                player.getInventory().setItem(slot, null);
-                player.sendMessage(ChatColor.RED + "Infinite stack removed.");
-            }
-        }
-    }
-
-    /**
-     * Called when a player right clicks a block.
-     *
-     * @param event Thrown event
-     */
-    private void handleBlockRightClick(PlayerInteractEvent event) {
-        if (event.isCancelled()) {
-            return;
-        }
-
-        Block block = event.getClickedBlock();
-        World world = block.getWorld();
-        int type = block.getTypeId();
-        Player player = event.getPlayer();
-        ItemStack item = player.getItemInHand();
-
-        ConfigurationManager cfg = plugin.getGlobalStateManager();
-        WorldConfiguration wcfg = cfg.get(world);
-
-        // Infinite stack removal
-        if ((type == BlockID.CHEST
-                || type == BlockID.JUKEBOX
-                || type == BlockID.DISPENSER
-                || type == BlockID.FURNACE
-                || type == BlockID.BURNING_FURNACE
-                || type == BlockID.BREWING_STAND
-                || type == BlockID.ENCHANTMENT_TABLE)
-                && wcfg.removeInfiniteStacks
-                && !plugin.hasPermission(player, "worldguard.override.infinite-stack")) {
-            for (int slot = 0; slot < 40; slot++) {
-                ItemStack heldItem = player.getInventory().getItem(slot);
-                if (heldItem != null && heldItem.getAmount() < 0) {
-                    player.getInventory().setItem(slot, null);
-                    player.sendMessage(ChatColor.RED + "Infinite stack in slot #" + slot + " removed.");
-                }
-            }
-        }
-
-        if (wcfg.useRegions) {
-            Block placedIn = block.getRelative(event.getBlockFace());
-            ApplicableRegionSet set = plugin.getRegionContainer().createQuery().getApplicableRegions(block.getLocation());
-            ApplicableRegionSet placedInSet = plugin.getRegionContainer().createQuery().getApplicableRegions(placedIn.getLocation());
-            LocalPlayer localPlayer = plugin.wrapPlayer(player);
-
-            if (item.getTypeId() == wcfg.regionWand && plugin.hasPermission(player, "worldguard.region.wand")) {
-                if (set.size() > 0) {
-                    player.sendMessage(ChatColor.YELLOW + "Can you build? "
-                            + (set.canBuild(localPlayer) ? "Yes" : "No"));
-
-                    StringBuilder str = new StringBuilder();
-                    for (Iterator<ProtectedRegion> it = set.iterator(); it.hasNext();) {
-                        str.append(it.next().getId());
-                        if (it.hasNext()) {
-                            str.append(", ");
-                        }
-                    }
-
-                    player.sendMessage(ChatColor.YELLOW + "Applicable regions: " + str.toString());
-                } else {
-                    player.sendMessage(ChatColor.YELLOW + "WorldGuard: No defined regions here!");
-                }
-
-                event.setCancelled(true);
-            }
-        }
-    }
-
-    /**
-     * Called when a player steps on a pressure plate or tramples crops.
-     *
-     * @param event Thrown event
-     */
-    private void handlePhysicalInteract(PlayerInteractEvent event) {
-        if (event.isCancelled()) return;
-
-        Player player = event.getPlayer();
-        Block block = event.getClickedBlock(); //not actually clicked but whatever
-        int type = block.getTypeId();
-        World world = player.getWorld();
-
-        ConfigurationManager cfg = plugin.getGlobalStateManager();
-        WorldConfiguration wcfg = cfg.get(world);
-
-        if (block.getTypeId() == BlockID.SOIL && wcfg.disablePlayerCropTrampling) {
-            event.setCancelled(true);
-            return;
-        }
-    }
-
-    @EventHandler(priority = EventPriority.HIGHEST)
-    public void onPlayerRespawn(PlayerRespawnEvent event) {
-        Player player = event.getPlayer();
-        Location location = player.getLocation();
-
-        ConfigurationManager cfg = plugin.getGlobalStateManager();
-        WorldConfiguration wcfg = cfg.get(player.getWorld());
-
-        if (wcfg.useRegions) {
-            ApplicableRegionSet set = plugin.getRegionContainer().createQuery().getApplicableRegions(location);
-
-            LocalPlayer localPlayer = plugin.wrapPlayer(player);
-            com.sk89q.worldedit.Location spawn = set.getFlag(DefaultFlag.SPAWN_LOC, localPlayer);
-
-            if (spawn != null) {
-                event.setRespawnLocation(com.sk89q.worldedit.bukkit.BukkitUtil.toLocation(spawn));
-            }
-        }
-    }
-
-    @EventHandler(priority = EventPriority.HIGH)
-    public void onItemHeldChange(PlayerItemHeldEvent event) {
-        Player player = event.getPlayer();
-
-        ConfigurationManager cfg = plugin.getGlobalStateManager();
-        WorldConfiguration wcfg = cfg.get(player.getWorld());
-
-        if (wcfg.removeInfiniteStacks
-                && !plugin.hasPermission(player, "worldguard.override.infinite-stack")) {
-            int newSlot = event.getNewSlot();
-            ItemStack heldItem = player.getInventory().getItem(newSlot);
-            if (heldItem != null && heldItem.getAmount() < 0) {
-                player.getInventory().setItem(newSlot, null);
-                player.sendMessage(ChatColor.RED + "Infinite stack removed.");
-            }
-        }
-    }
-
-    @EventHandler(priority= EventPriority.LOW, ignoreCancelled = true)
-    public void onPlayerTeleport(PlayerTeleportEvent event) {
-        World world = event.getFrom().getWorld();
-        ConfigurationManager cfg = plugin.getGlobalStateManager();
-        WorldConfiguration wcfg = cfg.get(world);
-
-        if (wcfg.useRegions) {
-            ApplicableRegionSet set = plugin.getRegionContainer().createQuery().getApplicableRegions(event.getTo());
-            ApplicableRegionSet setFrom = plugin.getRegionContainer().createQuery().getApplicableRegions(event.getFrom());
-            LocalPlayer localPlayer = plugin.wrapPlayer(event.getPlayer());
-
-            if (cfg.usePlayerTeleports) {
-                boolean result = checkMove(plugin, event.getPlayer(), event.getFrom(), event.getTo());
-                if (result) {
-                    event.setCancelled(true);
-                    return;
-                }
-            }
-
-            if (event.getCause() == TeleportCause.ENDER_PEARL) {
-                if (!plugin.getGlobalRegionManager().hasBypass(localPlayer, world)
-                        && !(set.allows(DefaultFlag.ENDERPEARL, localPlayer)
-                                && setFrom.allows(DefaultFlag.ENDERPEARL, localPlayer))) {
-                    event.getPlayer().sendMessage(ChatColor.DARK_RED + "You're not allowed to go there.");
-                    event.setCancelled(true);
-                    return;
-                }
-            }
-        }
-    }
-
-    @EventHandler(priority = EventPriority.LOWEST, ignoreCancelled = true)
-    public void onPlayerCommandPreprocess(PlayerCommandPreprocessEvent event) {
-        Player player = event.getPlayer();
-        LocalPlayer localPlayer = plugin.wrapPlayer(player);
-        World world = player.getWorld();
-        ConfigurationManager cfg = plugin.getGlobalStateManager();
-        WorldConfiguration wcfg = cfg.get(world);
-
-        if (wcfg.useRegions && !plugin.getGlobalRegionManager().hasBypass(player, world)) {
-            ApplicableRegionSet set = plugin.getRegionContainer().createQuery().getApplicableRegions(player.getLocation());
-
-            Set<String> allowedCommands = set.getFlag(DefaultFlag.ALLOWED_CMDS, localPlayer);
-            Set<String> blockedCommands = set.getFlag(DefaultFlag.BLOCKED_CMDS, localPlayer);
-            CommandFilter test = new CommandFilter(allowedCommands, blockedCommands);
-
-            if (!test.apply(event.getMessage())) {
-                player.sendMessage(ChatColor.RED + event.getMessage() + " is not allowed in this area.");
-                event.setCancelled(true);
-                return;
-            }
-        }
-
-        if (cfg.blockInGameOp) {
-            if (opPattern.matcher(event.getMessage()).matches()) {
-                player.sendMessage(ChatColor.RED + "/op can only be used in console (as set by a WG setting).");
-                event.setCancelled(true);
-                return;
-            }
-        }
-    }
-}
@@ -1,75 +0,0 @@
-/*
- * WorldGuard, a suite of tools for Minecraft
- * Copyright (C) sk89q <http://www.sk89q.com>
- * Copyright (C) WorldGuard team and contributors
- *
- * This program is free software: you can redistribute it and/or modify it
- * under the terms of the GNU Lesser General Public License as published by the
- * Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License
- * for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-package com.sk89q.worldguard.bukkit.listener;
-
-import com.sk89q.worldguard.bukkit.ConfigurationManager;
-import com.sk89q.worldguard.bukkit.WorldConfiguration;
-import com.sk89q.worldguard.bukkit.WorldGuardPlugin;
-import org.bukkit.World;
-import org.bukkit.entity.Player;
-import org.bukkit.entity.Vehicle;
-import org.bukkit.event.EventHandler;
-import org.bukkit.event.Listener;
-import org.bukkit.event.vehicle.VehicleMoveEvent;
-
-public class WorldGuardVehicleListener implements Listener {
-
-    private WorldGuardPlugin plugin;
-
-    /**
-     * Construct the object;
-     *
-     * @param plugin
-     */
-    public WorldGuardVehicleListener(WorldGuardPlugin plugin) {
-        this.plugin = plugin;
-    }
-
-    /**
-     * Register events.
-     */
-    public void registerEvents() {
-        plugin.getServer().getPluginManager().registerEvents(this, plugin);
-    }
-
-    @EventHandler
-    public void onVehicleMove(VehicleMoveEvent event) {
-        Vehicle vehicle = event.getVehicle();
-        if (vehicle.getPassenger() == null
-                || !(vehicle.getPassenger() instanceof Player)) return;
-        Player player = (Player) vehicle.getPassenger();
-        World world = vehicle.getWorld();
-        ConfigurationManager cfg = plugin.getGlobalStateManager();
-        WorldConfiguration wcfg = cfg.get(world);
-
-        if (wcfg.useRegions) {
-            // Did we move a block?
-            if (event.getFrom().getBlockX() != event.getTo().getBlockX()
-                    || event.getFrom().getBlockY() != event.getTo().getBlockY()
-                    || event.getFrom().getBlockZ() != event.getTo().getBlockZ()) {
-                boolean result = WorldGuardPlayerListener.checkMove(plugin, player, event.getFrom(), event.getTo());
-                if (result) {
-                    vehicle.setVelocity(new org.bukkit.util.Vector(0,0,0));
-                    vehicle.teleport(event.getFrom());
-                }
-            }
-        }
-    }
-}
@@ -1,152 +0,0 @@
-/*
- * WorldGuard, a suite of tools for Minecraft
- * Copyright (C) sk89q <http://www.sk89q.com>
- * Copyright (C) WorldGuard team and contributors
- *
- * This program is free software: you can redistribute it and/or modify it
- * under the terms of the GNU Lesser General Public License as published by the
- * Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License
- * for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-package com.sk89q.worldguard.bukkit.util;
-
-import org.bukkit.entity.Ambient;
-import org.bukkit.entity.Entity;
-import org.bukkit.entity.EntityType;
-import org.bukkit.entity.Monster;
-import org.bukkit.entity.Player;
-import org.bukkit.entity.Projectile;
-import org.bukkit.entity.Slime;
-import org.bukkit.entity.TNTPrimed;
-import org.bukkit.entity.Tameable;
-import org.bukkit.entity.minecart.ExplosiveMinecart;
-import org.bukkit.projectiles.ProjectileSource;
-
-import javax.annotation.Nullable;
-
-public final class Entities {
-
-    private Entities() {
-    }
-
-    /**
-     * Test whether the given entity is tameable and tamed.
-     *
-     * @param entity the entity, or null
-     * @return true if tamed
-     */
-    public static boolean isTamed(@Nullable Entity entity) {
-        return entity instanceof Tameable && ((Tameable) entity).isTamed();
-    }
-
-    /**
-     * Return if the given entity type is TNT-based.
-     *
-     * @param entity the entity
-     * @return true if TNT based
-     */
-    public static boolean isTNTBased(Entity entity) {
-        return entity instanceof TNTPrimed || entity instanceof ExplosiveMinecart;
-    }
-
-    /**
-     * Return if the given entity type is a fireball
-     * (not including wither skulls).
-     *
-     * @param type the type
-     * @return true if a fireball
-     */
-    public static boolean isFireball(EntityType type) {
-        return type == EntityType.FIREBALL || type == EntityType.SMALL_FIREBALL;
-    }
-
-    /**
-     * Test whether the given entity type is a vehicle type.
-     *
-     * @param type the type
-     * @return true if the type is a vehicle type
-     */
-    public static boolean isVehicle(EntityType type) {
-        return type == EntityType.BOAT
-                || isMinecart(type);
-    }
-
-    /**
-     * Test whether the given entity type is a Minecart type.
-     *
-     * @param type the type
-     * @return true if the type is a Minecart type
-     */
-    public static boolean isMinecart(EntityType type) {
-        return type == EntityType.MINECART
-                || type == EntityType.MINECART_CHEST
-                || type == EntityType.MINECART_COMMAND
-                || type == EntityType.MINECART_FURNACE
-                || type == EntityType.MINECART_HOPPER
-                || type == EntityType.MINECART_MOB_SPAWNER
-                || type == EntityType.MINECART_TNT;
-    }
-
-    /**
-     * Get the underlying shooter of a projectile if one exists.
-     *
-     * @param entity the entity
-     * @return the shooter
-     */
-    public static Entity getShooter(Entity entity) {
-
-        while (entity instanceof Projectile) {
-            Projectile projectile = (Projectile) entity;
-            ProjectileSource remover = projectile.getShooter();
-            if (remover instanceof Entity && remover != entity) {
-                entity = (Entity) remover;
-            } else {
-                return entity;
-            }
-        }
-
-        return entity;
-    }
-
-    /**
-     * Return whether the given player is a fake player using the typical
-     * fake player convention of [Mod].
-     *
-     * @param player the player
-     * @return true if a fake player
-     */
-    public static boolean isFakePlayer(Player player) {
-        String name = player.getName();
-        return name.length() >= 3 && name.charAt(0) == '[' && name.charAt(name.length() - 1) == ']';
-    }
-
-    /**
-     * Test whether an entity is hostile.
-     *
-     * @param entity the entity
-     * @return true if hostile
-     */
-    public static boolean isHostile(Entity entity) {
-        return entity instanceof Monster || entity instanceof Slime;
-    }
-
-    /**
-     * Test whether an entity is ambient.
-     *
-     * @param entity the entity
-     * @return true if ambient
-     */
-    public static boolean isAmbient(Entity entity) {
-        return entity instanceof Ambient;
-    }
-
-}
@@ -1,77 +0,0 @@
-/*
- * WorldGuard, a suite of tools for Minecraft
- * Copyright (C) sk89q <http://www.sk89q.com>
- * Copyright (C) WorldGuard team and contributors
- *
- * This program is free software: you can redistribute it and/or modify it
- * under the terms of the GNU Lesser General Public License as published by the
- * Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License
- * for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-package com.sk89q.worldguard.bukkit.util;
-
-import org.bukkit.entity.Entity;
-import org.bukkit.entity.LivingEntity;
-import org.bukkit.event.entity.EntityDamageEvent.DamageCause;
-
-/**
- * Utility methods to deal with event-related enums in Bukkit.
- */
-public final class EventEnums {
-
-    private EventEnums() {
-    }
-
-    /**
-     * Return whether the given damage cause is fire-reltaed.
-     *
-     * @param cause the cause
-     * @return true if fire related
-     */
-    public static boolean isFireCause(DamageCause cause) {
-        return cause == DamageCause.FIRE || cause == DamageCause.FIRE_TICK;
-    }
-
-    /**
-     * Return whether the given cause is an explosion.
-     *
-     * @param cause the cause
-     * @return true if it is an explosion cuase
-     */
-    public static boolean isExplosionCause(DamageCause cause) {
-        return cause == DamageCause.BLOCK_EXPLOSION || cause == DamageCause.ENTITY_EXPLOSION;
-    }
-
-    /**
-     * Restore the statistic associated with the given cause. For example,
-     * for the {@link DamageCause#DROWNING} cause, the entity would have its
-     * air level set to its maximum.
-     *
-     * @param entity the entity
-     * @param cause the cuase
-     */
-    public static void restoreStatistic(Entity entity, DamageCause cause) {
-        if (cause == DamageCause.DROWNING && entity instanceof LivingEntity) {
-            LivingEntity living = (LivingEntity) entity;
-            living.setRemainingAir(living.getMaximumAir());
-        }
-
-        if (isFireCause(cause)) {
-            entity.setFireTicks(0);
-        }
-
-        if (cause == DamageCause.LAVA) {
-            entity.setFireTicks(0);
-        }
-    }
-
-}
@@ -1,619 +0,0 @@
-/*
- * WorldGuard, a suite of tools for Minecraft
- * Copyright (C) sk89q <http://www.sk89q.com>
- * Copyright (C) WorldGuard team and contributors
- *
- * This program is free software: you can redistribute it and/or modify it
- * under the terms of the GNU Lesser General Public License as published by the
- * Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License
- * for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-package com.sk89q.worldguard.bukkit.util;
-
-import com.google.common.collect.BiMap;
-import com.google.common.collect.HashBiMap;
-import org.bukkit.DyeColor;
-import org.bukkit.Material;
-import org.bukkit.entity.EntityType;
-import org.bukkit.material.Dye;
-import org.bukkit.material.MaterialData;
-
-import javax.annotation.Nullable;
-import java.util.HashMap;
-import java.util.Map;
-
-/**
- * Material utility class.
- */
-public final class Materials {
-
-    private static final int MODIFIED_ON_CLICK = 1;
-    private static final int MODIFIES_BLOCKS = 2;
-
-    private static final BiMap<EntityType, Material> ENTITY_ITEMS = HashBiMap.create();
-    private static final Map<Material, Integer> MATERIAL_FLAGS = new HashMap<Material, Integer>();
-
-    static {
-        ENTITY_ITEMS.put(EntityType.PAINTING, Material.PAINTING);
-        ENTITY_ITEMS.put(EntityType.ARROW, Material.ARROW);
-        ENTITY_ITEMS.put(EntityType.SNOWBALL, Material.SNOW_BALL);
-        ENTITY_ITEMS.put(EntityType.FIREBALL, Material.FIREBALL);
-        ENTITY_ITEMS.put(EntityType.SMALL_FIREBALL, Material.FIREWORK_CHARGE);
-        ENTITY_ITEMS.put(EntityType.ENDER_PEARL, Material.ENDER_PEARL);
-        ENTITY_ITEMS.put(EntityType.THROWN_EXP_BOTTLE, Material.EXP_BOTTLE);
-        ENTITY_ITEMS.put(EntityType.ITEM_FRAME, Material.ITEM_FRAME);
-        ENTITY_ITEMS.put(EntityType.PRIMED_TNT, Material.TNT);
-        ENTITY_ITEMS.put(EntityType.FIREWORK, Material.FIREWORK);
-        ENTITY_ITEMS.put(EntityType.MINECART_COMMAND, Material.COMMAND_MINECART);
-        ENTITY_ITEMS.put(EntityType.BOAT, Material.BOAT);
-        ENTITY_ITEMS.put(EntityType.MINECART, Material.MINECART);
-        ENTITY_ITEMS.put(EntityType.MINECART_CHEST, Material.STORAGE_MINECART);
-        ENTITY_ITEMS.put(EntityType.MINECART_FURNACE, Material.POWERED_MINECART);
-        ENTITY_ITEMS.put(EntityType.MINECART_TNT, Material.EXPLOSIVE_MINECART);
-        ENTITY_ITEMS.put(EntityType.MINECART_HOPPER, Material.HOPPER_MINECART);
-        ENTITY_ITEMS.put(EntityType.SPLASH_POTION, Material.POTION);
-        ENTITY_ITEMS.put(EntityType.EGG, Material.EGG);
-
-        MATERIAL_FLAGS.put(Material.AIR, 0);
-        MATERIAL_FLAGS.put(Material.STONE, 0);
-        MATERIAL_FLAGS.put(Material.GRASS, 0);
-        MATERIAL_FLAGS.put(Material.DIRT, 0);
-        MATERIAL_FLAGS.put(Material.COBBLESTONE, 0);
-        MATERIAL_FLAGS.put(Material.WOOD, 0);
-        MATERIAL_FLAGS.put(Material.SAPLING, 0);
-        MATERIAL_FLAGS.put(Material.BEDROCK, 0);
-        MATERIAL_FLAGS.put(Material.WATER, 0);
-        MATERIAL_FLAGS.put(Material.STATIONARY_WATER, 0);
-        MATERIAL_FLAGS.put(Material.LAVA, 0);
-        MATERIAL_FLAGS.put(Material.STATIONARY_LAVA, 0);
-        MATERIAL_FLAGS.put(Material.SAND, 0);
-        MATERIAL_FLAGS.put(Material.GRAVEL, 0);
-        MATERIAL_FLAGS.put(Material.GOLD_ORE, 0);
-        MATERIAL_FLAGS.put(Material.IRON_ORE, 0);
-        MATERIAL_FLAGS.put(Material.COAL_ORE, 0);
-        MATERIAL_FLAGS.put(Material.LOG, 0);
-        MATERIAL_FLAGS.put(Material.LEAVES, 0);
-        MATERIAL_FLAGS.put(Material.SPONGE, 0);
-        MATERIAL_FLAGS.put(Material.GLASS, 0);
-        MATERIAL_FLAGS.put(Material.LAPIS_ORE, 0);
-        MATERIAL_FLAGS.put(Material.LAPIS_BLOCK, 0);
-        MATERIAL_FLAGS.put(Material.DISPENSER, MODIFIED_ON_CLICK);
-        MATERIAL_FLAGS.put(Material.SANDSTONE, 0);
-        MATERIAL_FLAGS.put(Material.NOTE_BLOCK, MODIFIED_ON_CLICK);
-        MATERIAL_FLAGS.put(Material.BED_BLOCK, MODIFIED_ON_CLICK);
-        MATERIAL_FLAGS.put(Material.POWERED_RAIL, 0);
-        MATERIAL_FLAGS.put(Material.DETECTOR_RAIL, 0);
-        MATERIAL_FLAGS.put(Material.PISTON_STICKY_BASE, 0);
-        MATERIAL_FLAGS.put(Material.WEB, 0);
-        MATERIAL_FLAGS.put(Material.LONG_GRASS, 0);
-        MATERIAL_FLAGS.put(Material.DEAD_BUSH, 0);
-        MATERIAL_FLAGS.put(Material.PISTON_BASE, 0);
-        MATERIAL_FLAGS.put(Material.PISTON_EXTENSION, 0);
-        MATERIAL_FLAGS.put(Material.WOOL, 0);
-        MATERIAL_FLAGS.put(Material.PISTON_MOVING_PIECE, 0);
-        MATERIAL_FLAGS.put(Material.YELLOW_FLOWER, 0);
-        MATERIAL_FLAGS.put(Material.RED_ROSE, 0);
-        MATERIAL_FLAGS.put(Material.BROWN_MUSHROOM, 0);
-        MATERIAL_FLAGS.put(Material.RED_MUSHROOM, 0);
-        MATERIAL_FLAGS.put(Material.GOLD_BLOCK, 0);
-        MATERIAL_FLAGS.put(Material.IRON_BLOCK, 0);
-        MATERIAL_FLAGS.put(Material.DOUBLE_STEP, 0);
-        MATERIAL_FLAGS.put(Material.STEP, 0);
-        MATERIAL_FLAGS.put(Material.BRICK, 0);
-        MATERIAL_FLAGS.put(Material.TNT, MODIFIED_ON_CLICK);
-        MATERIAL_FLAGS.put(Material.BOOKSHELF, 0);
-        MATERIAL_FLAGS.put(Material.MOSSY_COBBLESTONE, 0);
-        MATERIAL_FLAGS.put(Material.OBSIDIAN, 0);
-        MATERIAL_FLAGS.put(Material.TORCH, 0);
-        MATERIAL_FLAGS.put(Material.FIRE, 0);
-        MATERIAL_FLAGS.put(Material.MOB_SPAWNER, 0);
-        MATERIAL_FLAGS.put(Material.WOOD_STAIRS, 0);
-        MATERIAL_FLAGS.put(Material.CHEST, MODIFIED_ON_CLICK);
-        MATERIAL_FLAGS.put(Material.REDSTONE_WIRE, 0);
-        MATERIAL_FLAGS.put(Material.DIAMOND_ORE, 0);
-        MATERIAL_FLAGS.put(Material.DIAMOND_BLOCK, 0);
-        MATERIAL_FLAGS.put(Material.WORKBENCH, 0);
-        MATERIAL_FLAGS.put(Material.CROPS, 0);
-        MATERIAL_FLAGS.put(Material.SOIL, 0);
-        MATERIAL_FLAGS.put(Material.FURNACE, MODIFIED_ON_CLICK);
-        MATERIAL_FLAGS.put(Material.BURNING_FURNACE, MODIFIED_ON_CLICK);
-        MATERIAL_FLAGS.put(Material.SIGN_POST, 0);
-        MATERIAL_FLAGS.put(Material.WOODEN_DOOR, MODIFIED_ON_CLICK);
-        MATERIAL_FLAGS.put(Material.LADDER, 0);
-        MATERIAL_FLAGS.put(Material.RAILS, 0);
-        MATERIAL_FLAGS.put(Material.COBBLESTONE_STAIRS, 0);
-        MATERIAL_FLAGS.put(Material.WALL_SIGN, 0);
-        MATERIAL_FLAGS.put(Material.LEVER, MODIFIED_ON_CLICK);
-        MATERIAL_FLAGS.put(Material.STONE_PLATE, 0);
-        MATERIAL_FLAGS.put(Material.IRON_DOOR_BLOCK, MODIFIED_ON_CLICK);
-        MATERIAL_FLAGS.put(Material.WOOD_PLATE, 0);
-        MATERIAL_FLAGS.put(Material.REDSTONE_ORE, 0);
-        MATERIAL_FLAGS.put(Material.GLOWING_REDSTONE_ORE, 0);
-        MATERIAL_FLAGS.put(Material.REDSTONE_TORCH_OFF, 0);
-        MATERIAL_FLAGS.put(Material.REDSTONE_TORCH_ON, 0);
-        MATERIAL_FLAGS.put(Material.STONE_BUTTON, MODIFIED_ON_CLICK);
-        MATERIAL_FLAGS.put(Material.SNOW, 0);
-        MATERIAL_FLAGS.put(Material.ICE, 0);
-        MATERIAL_FLAGS.put(Material.SNOW_BLOCK, 0);
-        MATERIAL_FLAGS.put(Material.CACTUS, 0);
-        MATERIAL_FLAGS.put(Material.CLAY, 0);
-        MATERIAL_FLAGS.put(Material.SUGAR_CANE_BLOCK, 0);
-        MATERIAL_FLAGS.put(Material.JUKEBOX, MODIFIED_ON_CLICK);
-        MATERIAL_FLAGS.put(Material.FENCE, 0);
-        MATERIAL_FLAGS.put(Material.PUMPKIN, 0);
-        MATERIAL_FLAGS.put(Material.NETHERRACK, 0);
-        MATERIAL_FLAGS.put(Material.SOUL_SAND, 0);
-        MATERIAL_FLAGS.put(Material.GLOWSTONE, 0);
-        MATERIAL_FLAGS.put(Material.PORTAL, 0);
-        MATERIAL_FLAGS.put(Material.JACK_O_LANTERN, 0);
-        MATERIAL_FLAGS.put(Material.CAKE_BLOCK, MODIFIED_ON_CLICK);
-        MATERIAL_FLAGS.put(Material.DIODE_BLOCK_OFF, MODIFIED_ON_CLICK);
-        MATERIAL_FLAGS.put(Material.DIODE_BLOCK_ON, MODIFIED_ON_CLICK);
-        MATERIAL_FLAGS.put(Material.STAINED_GLASS, 0);
-        MATERIAL_FLAGS.put(Material.TRAP_DOOR, MODIFIED_ON_CLICK);
-        MATERIAL_FLAGS.put(Material.MONSTER_EGGS, 0);
-        MATERIAL_FLAGS.put(Material.SMOOTH_BRICK, 0);
-        MATERIAL_FLAGS.put(Material.HUGE_MUSHROOM_1, 0);
-        MATERIAL_FLAGS.put(Material.HUGE_MUSHROOM_2, 0);
-        MATERIAL_FLAGS.put(Material.IRON_FENCE, 0);
-        MATERIAL_FLAGS.put(Material.THIN_GLASS, 0);
-        MATERIAL_FLAGS.put(Material.MELON_BLOCK, 0);
-        MATERIAL_FLAGS.put(Material.PUMPKIN_STEM, 0);
-        MATERIAL_FLAGS.put(Material.MELON_STEM, 0);
-        MATERIAL_FLAGS.put(Material.VINE, 0);
-        MATERIAL_FLAGS.put(Material.FENCE_GATE, MODIFIED_ON_CLICK);
-        MATERIAL_FLAGS.put(Material.BRICK_STAIRS, 0);
-        MATERIAL_FLAGS.put(Material.SMOOTH_STAIRS, 0);
-        MATERIAL_FLAGS.put(Material.MYCEL, 0);
-        MATERIAL_FLAGS.put(Material.WATER_LILY, 0);
-        MATERIAL_FLAGS.put(Material.NETHER_BRICK, 0);
-        MATERIAL_FLAGS.put(Material.NETHER_FENCE, 0);
-        MATERIAL_FLAGS.put(Material.NETHER_BRICK_STAIRS, 0);
-        MATERIAL_FLAGS.put(Material.NETHER_WARTS, 0);
-        MATERIAL_FLAGS.put(Material.ENCHANTMENT_TABLE, 0);
-        MATERIAL_FLAGS.put(Material.BREWING_STAND, MODIFIED_ON_CLICK);
-        MATERIAL_FLAGS.put(Material.CAULDRON, MODIFIED_ON_CLICK);
-        MATERIAL_FLAGS.put(Material.ENDER_PORTAL, 0);
-        MATERIAL_FLAGS.put(Material.ENDER_PORTAL_FRAME, 0);
-        MATERIAL_FLAGS.put(Material.ENDER_STONE, 0);
-        MATERIAL_FLAGS.put(Material.DRAGON_EGG, MODIFIED_ON_CLICK);
-        MATERIAL_FLAGS.put(Material.REDSTONE_LAMP_OFF, 0);
-        MATERIAL_FLAGS.put(Material.REDSTONE_LAMP_ON, 0);
-        MATERIAL_FLAGS.put(Material.WOOD_DOUBLE_STEP, 0);
-        MATERIAL_FLAGS.put(Material.WOOD_STEP, 0);
-        MATERIAL_FLAGS.put(Material.COCOA, 0);
-        MATERIAL_FLAGS.put(Material.SANDSTONE_STAIRS, 0);
-        MATERIAL_FLAGS.put(Material.EMERALD_ORE, 0);
-        MATERIAL_FLAGS.put(Material.ENDER_CHEST, 0);
-        MATERIAL_FLAGS.put(Material.TRIPWIRE_HOOK, 0);
-        MATERIAL_FLAGS.put(Material.TRIPWIRE, 0);
-        MATERIAL_FLAGS.put(Material.EMERALD_BLOCK, 0);
-        MATERIAL_FLAGS.put(Material.SPRUCE_WOOD_STAIRS, 0);
-        MATERIAL_FLAGS.put(Material.BIRCH_WOOD_STAIRS, 0);
-        MATERIAL_FLAGS.put(Material.JUNGLE_WOOD_STAIRS, 0);
-        MATERIAL_FLAGS.put(Material.COMMAND, MODIFIED_ON_CLICK);
-        MATERIAL_FLAGS.put(Material.BEACON, MODIFIED_ON_CLICK);
-        MATERIAL_FLAGS.put(Material.COBBLE_WALL, 0);
-        MATERIAL_FLAGS.put(Material.FLOWER_POT, MODIFIED_ON_CLICK);
-        MATERIAL_FLAGS.put(Material.CARROT, 0);
-        MATERIAL_FLAGS.put(Material.POTATO, 0);
-        MATERIAL_FLAGS.put(Material.WOOD_BUTTON, MODIFIED_ON_CLICK);
-        MATERIAL_FLAGS.put(Material.SKULL, 0);
-        MATERIAL_FLAGS.put(Material.ANVIL, MODIFIED_ON_CLICK);
-        MATERIAL_FLAGS.put(Material.TRAPPED_CHEST, MODIFIED_ON_CLICK);
-        MATERIAL_FLAGS.put(Material.GOLD_PLATE, 0);
-        MATERIAL_FLAGS.put(Material.IRON_PLATE, 0);
-        MATERIAL_FLAGS.put(Material.REDSTONE_COMPARATOR_OFF, MODIFIED_ON_CLICK);
-        MATERIAL_FLAGS.put(Material.REDSTONE_COMPARATOR_ON, MODIFIED_ON_CLICK);
-        MATERIAL_FLAGS.put(Material.DAYLIGHT_DETECTOR, MODIFIED_ON_CLICK);
-        MATERIAL_FLAGS.put(Material.REDSTONE_BLOCK, 0);
-        MATERIAL_FLAGS.put(Material.QUARTZ_ORE, 0);
-        MATERIAL_FLAGS.put(Material.HOPPER, MODIFIED_ON_CLICK);
-        MATERIAL_FLAGS.put(Material.QUARTZ_BLOCK, 0);
-        MATERIAL_FLAGS.put(Material.QUARTZ_STAIRS, 0);
-        MATERIAL_FLAGS.put(Material.ACTIVATOR_RAIL, 0);
-        MATERIAL_FLAGS.put(Material.DROPPER, MODIFIED_ON_CLICK);
-        MATERIAL_FLAGS.put(Material.STAINED_CLAY, 0);
-        MATERIAL_FLAGS.put(Material.STAINED_GLASS_PANE, 0);
-        MATERIAL_FLAGS.put(Material.LEAVES_2, 0);
-        MATERIAL_FLAGS.put(Material.LOG_2, 0);
-        MATERIAL_FLAGS.put(Material.ACACIA_STAIRS, 0);
-        MATERIAL_FLAGS.put(Material.DARK_OAK_STAIRS, 0);
-        MATERIAL_FLAGS.put(Material.HAY_BLOCK, 0);
-        MATERIAL_FLAGS.put(Material.CARPET, 0);
-        MATERIAL_FLAGS.put(Material.HARD_CLAY, 0);
-        MATERIAL_FLAGS.put(Material.COAL_BLOCK, 0);
-        MATERIAL_FLAGS.put(Material.PACKED_ICE, 0);
-        MATERIAL_FLAGS.put(Material.DOUBLE_PLANT, 0);
-
-        MATERIAL_FLAGS.put(Material.IRON_SPADE, 0);
-        MATERIAL_FLAGS.put(Material.IRON_PICKAXE, 0);
-        MATERIAL_FLAGS.put(Material.IRON_AXE, 0);
-        MATERIAL_FLAGS.put(Material.FLINT_AND_STEEL, 0);
-        MATERIAL_FLAGS.put(Material.APPLE, 0);
-        MATERIAL_FLAGS.put(Material.BOW, 0);
-        MATERIAL_FLAGS.put(Material.ARROW, 0);
-        MATERIAL_FLAGS.put(Material.COAL, 0);
-        MATERIAL_FLAGS.put(Material.DIAMOND, 0);
-        MATERIAL_FLAGS.put(Material.IRON_INGOT, 0);
-        MATERIAL_FLAGS.put(Material.GOLD_INGOT, 0);
-        MATERIAL_FLAGS.put(Material.IRON_SWORD, 0);
-        MATERIAL_FLAGS.put(Material.WOOD_SWORD, 0);
-        MATERIAL_FLAGS.put(Material.WOOD_SPADE, 0);
-        MATERIAL_FLAGS.put(Material.WOOD_PICKAXE, 0);
-        MATERIAL_FLAGS.put(Material.WOOD_AXE, 0);
-        MATERIAL_FLAGS.put(Material.STONE_SWORD, 0);
-        MATERIAL_FLAGS.put(Material.STONE_SPADE, 0);
-        MATERIAL_FLAGS.put(Material.STONE_PICKAXE, 0);
-        MATERIAL_FLAGS.put(Material.STONE_AXE, 0);
-        MATERIAL_FLAGS.put(Material.DIAMOND_SWORD, 0);
-        MATERIAL_FLAGS.put(Material.DIAMOND_SPADE, 0);
-        MATERIAL_FLAGS.put(Material.DIAMOND_PICKAXE, 0);
-        MATERIAL_FLAGS.put(Material.DIAMOND_AXE, 0);
-        MATERIAL_FLAGS.put(Material.STICK, 0);
-        MATERIAL_FLAGS.put(Material.BOWL, 0);
-        MATERIAL_FLAGS.put(Material.MUSHROOM_SOUP, 0);
-        MATERIAL_FLAGS.put(Material.GOLD_SWORD, 0);
-        MATERIAL_FLAGS.put(Material.GOLD_SPADE, 0);
-        MATERIAL_FLAGS.put(Material.GOLD_PICKAXE, 0);
-        MATERIAL_FLAGS.put(Material.GOLD_AXE, 0);
-        MATERIAL_FLAGS.put(Material.STRING, 0);
-        MATERIAL_FLAGS.put(Material.FEATHER, 0);
-        MATERIAL_FLAGS.put(Material.SULPHUR, 0);
-        MATERIAL_FLAGS.put(Material.WOOD_HOE, MODIFIES_BLOCKS);
-        MATERIAL_FLAGS.put(Material.STONE_HOE, MODIFIES_BLOCKS);
-        MATERIAL_FLAGS.put(Material.IRON_HOE, MODIFIES_BLOCKS);
-        MATERIAL_FLAGS.put(Material.DIAMOND_HOE, MODIFIES_BLOCKS);
-        MATERIAL_FLAGS.put(Material.GOLD_HOE, MODIFIES_BLOCKS);
-        MATERIAL_FLAGS.put(Material.SEEDS, MODIFIES_BLOCKS);
-        MATERIAL_FLAGS.put(Material.WHEAT, 0);
-        MATERIAL_FLAGS.put(Material.BREAD, 0);
-        MATERIAL_FLAGS.put(Material.LEATHER_HELMET, 0);
-        MATERIAL_FLAGS.put(Material.LEATHER_CHESTPLATE, 0);
-        MATERIAL_FLAGS.put(Material.LEATHER_LEGGINGS, 0);
-        MATERIAL_FLAGS.put(Material.LEATHER_BOOTS, 0);
-        MATERIAL_FLAGS.put(Material.CHAINMAIL_HELMET, 0);
-        MATERIAL_FLAGS.put(Material.CHAINMAIL_CHESTPLATE, 0);
-        MATERIAL_FLAGS.put(Material.CHAINMAIL_LEGGINGS, 0);
-        MATERIAL_FLAGS.put(Material.CHAINMAIL_BOOTS, 0);
-        MATERIAL_FLAGS.put(Material.IRON_HELMET, 0);
-        MATERIAL_FLAGS.put(Material.IRON_CHESTPLATE, 0);
-        MATERIAL_FLAGS.put(Material.IRON_LEGGINGS, 0);
-        MATERIAL_FLAGS.put(Material.IRON_BOOTS, 0);
-        MATERIAL_FLAGS.put(Material.DIAMOND_HELMET, 0);
-        MATERIAL_FLAGS.put(Material.DIAMOND_CHESTPLATE, 0);
-        MATERIAL_FLAGS.put(Material.DIAMOND_LEGGINGS, 0);
-        MATERIAL_FLAGS.put(Material.DIAMOND_BOOTS, 0);
-        MATERIAL_FLAGS.put(Material.GOLD_HELMET, 0);
-        MATERIAL_FLAGS.put(Material.GOLD_CHESTPLATE, 0);
-        MATERIAL_FLAGS.put(Material.GOLD_LEGGINGS, 0);
-        MATERIAL_FLAGS.put(Material.GOLD_BOOTS, 0);
-        MATERIAL_FLAGS.put(Material.FLINT, 0);
-        MATERIAL_FLAGS.put(Material.PORK, 0);
-        MATERIAL_FLAGS.put(Material.GRILLED_PORK, 0);
-        MATERIAL_FLAGS.put(Material.PAINTING, 0);
-        MATERIAL_FLAGS.put(Material.GOLDEN_APPLE, 0);
-        MATERIAL_FLAGS.put(Material.SIGN, 0);
-        MATERIAL_FLAGS.put(Material.WOOD_DOOR, 0);
-        MATERIAL_FLAGS.put(Material.BUCKET, 0);
-        MATERIAL_FLAGS.put(Material.WATER_BUCKET, 0);
-        MATERIAL_FLAGS.put(Material.LAVA_BUCKET, 0);
-        MATERIAL_FLAGS.put(Material.MINECART, 0);
-        MATERIAL_FLAGS.put(Material.SADDLE, 0);
-        MATERIAL_FLAGS.put(Material.IRON_DOOR, 0);
-        MATERIAL_FLAGS.put(Material.REDSTONE, 0);
-        MATERIAL_FLAGS.put(Material.SNOW_BALL, 0);
-        MATERIAL_FLAGS.put(Material.BOAT, 0);
-        MATERIAL_FLAGS.put(Material.LEATHER, 0);
-        MATERIAL_FLAGS.put(Material.MILK_BUCKET, 0);
-        MATERIAL_FLAGS.put(Material.CLAY_BRICK, 0);
-        MATERIAL_FLAGS.put(Material.CLAY_BALL, 0);
-        MATERIAL_FLAGS.put(Material.SUGAR_CANE, 0);
-        MATERIAL_FLAGS.put(Material.PAPER, 0);
-        MATERIAL_FLAGS.put(Material.BOOK, 0);
-        MATERIAL_FLAGS.put(Material.SLIME_BALL, 0);
-        MATERIAL_FLAGS.put(Material.STORAGE_MINECART, 0);
-        MATERIAL_FLAGS.put(Material.POWERED_MINECART, 0);
-        MATERIAL_FLAGS.put(Material.EGG, 0);
-        MATERIAL_FLAGS.put(Material.COMPASS, 0);
-        MATERIAL_FLAGS.put(Material.FISHING_ROD, 0);
-        MATERIAL_FLAGS.put(Material.WATCH, 0);
-        MATERIAL_FLAGS.put(Material.GLOWSTONE_DUST, 0);
-        MATERIAL_FLAGS.put(Material.RAW_FISH, 0);
-        MATERIAL_FLAGS.put(Material.COOKED_FISH, 0);
-        MATERIAL_FLAGS.put(Material.INK_SACK, 0);
-        MATERIAL_FLAGS.put(Material.BONE, 0);
-        MATERIAL_FLAGS.put(Material.SUGAR, 0);
-        MATERIAL_FLAGS.put(Material.CAKE, 0);
-        MATERIAL_FLAGS.put(Material.BED, 0);
-        MATERIAL_FLAGS.put(Material.DIODE, 0);
-        MATERIAL_FLAGS.put(Material.COOKIE, 0);
-        MATERIAL_FLAGS.put(Material.MAP, 0);
-        MATERIAL_FLAGS.put(Material.SHEARS, MODIFIES_BLOCKS);
-        MATERIAL_FLAGS.put(Material.MELON, 0);
-        MATERIAL_FLAGS.put(Material.PUMPKIN_SEEDS, 0);
-        MATERIAL_FLAGS.put(Material.MELON_SEEDS, 0);
-        MATERIAL_FLAGS.put(Material.RAW_BEEF, 0);
-        MATERIAL_FLAGS.put(Material.COOKED_BEEF, 0);
-        MATERIAL_FLAGS.put(Material.RAW_CHICKEN, 0);
-        MATERIAL_FLAGS.put(Material.COOKED_CHICKEN, 0);
-        MATERIAL_FLAGS.put(Material.ROTTEN_FLESH, 0);
-        MATERIAL_FLAGS.put(Material.ENDER_PEARL, 0);
-        MATERIAL_FLAGS.put(Material.BLAZE_ROD, 0);
-        MATERIAL_FLAGS.put(Material.GHAST_TEAR, 0);
-        MATERIAL_FLAGS.put(Material.GOLD_NUGGET, 0);
-        MATERIAL_FLAGS.put(Material.NETHER_STALK, 0);
-        MATERIAL_FLAGS.put(Material.POTION, 0);
-        MATERIAL_FLAGS.put(Material.GLASS_BOTTLE, 0);
-        MATERIAL_FLAGS.put(Material.SPIDER_EYE, 0);
-        MATERIAL_FLAGS.put(Material.FERMENTED_SPIDER_EYE, 0);
-        MATERIAL_FLAGS.put(Material.BLAZE_POWDER, 0);
-        MATERIAL_FLAGS.put(Material.MAGMA_CREAM, 0);
-        MATERIAL_FLAGS.put(Material.BREWING_STAND_ITEM, 0);
-        MATERIAL_FLAGS.put(Material.CAULDRON_ITEM, 0);
-        MATERIAL_FLAGS.put(Material.EYE_OF_ENDER, 0);
-        MATERIAL_FLAGS.put(Material.SPECKLED_MELON, 0);
-        MATERIAL_FLAGS.put(Material.MONSTER_EGG, 0);
-        MATERIAL_FLAGS.put(Material.EXP_BOTTLE, 0);
-        MATERIAL_FLAGS.put(Material.FIREBALL, 0);
-        MATERIAL_FLAGS.put(Material.BOOK_AND_QUILL, 0);
-        MATERIAL_FLAGS.put(Material.WRITTEN_BOOK, 0);
-        MATERIAL_FLAGS.put(Material.EMERALD, 0);
-        MATERIAL_FLAGS.put(Material.ITEM_FRAME, 0);
-        MATERIAL_FLAGS.put(Material.FLOWER_POT_ITEM, 0);
-        MATERIAL_FLAGS.put(Material.CARROT_ITEM, 0);
-        MATERIAL_FLAGS.put(Material.POTATO_ITEM, 0);
-        MATERIAL_FLAGS.put(Material.BAKED_POTATO, 0);
-        MATERIAL_FLAGS.put(Material.POISONOUS_POTATO, 0);
-        MATERIAL_FLAGS.put(Material.EMPTY_MAP, 0);
-        MATERIAL_FLAGS.put(Material.GOLDEN_CARROT, 0);
-        MATERIAL_FLAGS.put(Material.SKULL_ITEM, 0);
-        MATERIAL_FLAGS.put(Material.CARROT_STICK, 0);
-        MATERIAL_FLAGS.put(Material.NETHER_STAR, 0);
-        MATERIAL_FLAGS.put(Material.PUMPKIN_PIE, 0);
-        MATERIAL_FLAGS.put(Material.FIREWORK, 0);
-        MATERIAL_FLAGS.put(Material.FIREWORK_CHARGE, 0);
-        MATERIAL_FLAGS.put(Material.ENCHANTED_BOOK, 0);
-        MATERIAL_FLAGS.put(Material.REDSTONE_COMPARATOR, 0);
-        MATERIAL_FLAGS.put(Material.NETHER_BRICK_ITEM, 0);
-        MATERIAL_FLAGS.put(Material.QUARTZ, 0);
-        MATERIAL_FLAGS.put(Material.EXPLOSIVE_MINECART, 0);
-        MATERIAL_FLAGS.put(Material.HOPPER_MINECART, 0);
-        MATERIAL_FLAGS.put(Material.IRON_BARDING, 0);
-        MATERIAL_FLAGS.put(Material.GOLD_BARDING, 0);
-        MATERIAL_FLAGS.put(Material.DIAMOND_BARDING, 0);
-        MATERIAL_FLAGS.put(Material.LEASH, 0);
-        MATERIAL_FLAGS.put(Material.NAME_TAG, 0);
-        MATERIAL_FLAGS.put(Material.COMMAND_MINECART, 0);
-        MATERIAL_FLAGS.put(Material.GOLD_RECORD, 0);
-        MATERIAL_FLAGS.put(Material.GREEN_RECORD, 0);
-        MATERIAL_FLAGS.put(Material.RECORD_3, 0);
-        MATERIAL_FLAGS.put(Material.RECORD_4, 0);
-        MATERIAL_FLAGS.put(Material.RECORD_5, 0);
-        MATERIAL_FLAGS.put(Material.RECORD_6, 0);
-        MATERIAL_FLAGS.put(Material.RECORD_7, 0);
-        MATERIAL_FLAGS.put(Material.RECORD_8, 0);
-        MATERIAL_FLAGS.put(Material.RECORD_9, 0);
-        MATERIAL_FLAGS.put(Material.RECORD_10, 0);
-        MATERIAL_FLAGS.put(Material.RECORD_11, 0);
-        MATERIAL_FLAGS.put(Material.RECORD_12, 0);
-    }
-
-    private Materials() {
-    }
-
-    /**
-     * Get the related material for an entity type.
-     *
-     * @param type the entity type
-     * @return the related material or {@code null} if one is not known or exists
-     */
-    @Nullable
-    public static Material getRelatedMaterial(EntityType type) {
-        return ENTITY_ITEMS.get(type);
-    }
-
-    /**
-     * Get the material of the block placed by the given bucket, defaulting
-     * to water if the bucket type is not known.
-     *
-     * <p>If a non-bucket material is given, it will be assumed to be
-     * an unknown bucket type. If the given bucket doesn't have a block form
-     * (it can't be placed), then water will be returned (i.e. for milk).
-     * Be aware that either the stationary or non-stationary material may be
-     * returned.</p>
-     *
-     * @param type the bucket material
-     * @return the block material
-     */
-    public static Material getBucketBlockMaterial(Material type) {
-        switch (type) {
-            case LAVA_BUCKET:
-                return Material.LAVA;
-            case MILK_BUCKET:
-                return Material.WATER;
-            default:
-                return Material.WATER;
-        }
-    }
-
-    /**
-     * Test whether the given material is a mushroom.
-     *
-     * @param material the material
-     * @return true if a mushroom block
-     */
-    public static boolean isMushroom(Material material) {
-        return material == Material.RED_MUSHROOM || material == Material.BROWN_MUSHROOM;
-    }
-
-    /**
-     * Test whether the given material is a leaf block.
-     *
-     * @param material the material
-     * @return true if a leaf block
-     */
-    public static boolean isLeaf(Material material) {
-        return material == Material.LEAVES || material == Material.LEAVES_2;
-    }
-
-    /**
-     * Test whether the given material is a liquid block.
-     *
-     * @param material the material
-     * @return true if a liquid block
-     */
-    public static boolean isLiquid(Material material) {
-        return isWater(material) || isLava(material);
-    }
-
-    /**
-     * Test whether the given material is water.
-     *
-     * @param material the material
-     * @return true if a water block
-     */
-    public static boolean isWater(Material material) {
-        return material == Material.WATER || material == Material.STATIONARY_WATER;
-    }
-
-    /**
-     * Test whether the given material is lava.
-     *
-     * @param material the material
-     * @return true if a lava block
-     */
-    public static boolean isLava(Material material) {
-        return material == Material.LAVA || material == Material.STATIONARY_LAVA;
-    }
-
-    /**
-     * Test whether the given material is a portal material.
-     *
-     * @param material the material
-     * @return true if a portal block
-     */
-    public static boolean isPortal(Material material) {
-        return material == Material.PORTAL || material == Material.ENDER_PORTAL;
-    }
-
-    /**
-     * Test whether the given material data is of the given dye color.
-     *
-     * <p>Returns false for non-dyed items.</p>
-     *
-     * @param data the data
-     * @return true if it is the provided dye color
-     */
-    public static boolean isDyeColor(MaterialData data, DyeColor color) {
-        return data instanceof Dye && ((Dye) data).getColor() == color;
-    }
-
-    /**
-     * Test whether the given material is a rail block.
-     *
-     * @param material the material
-     * @return true if a rail block
-     */
-    public static boolean isRailBlock(Material material) {
-        return material == Material.RAILS
-                || material == Material.ACTIVATOR_RAIL
-                || material == Material.DETECTOR_RAIL
-                || material == Material.POWERED_RAIL;
-    }
-
-    /**
-     * Test whether the given material is a piston block, not including
-     * the "technical blocks" such as the piston extension block.
-     *
-     * @param material the material
-     * @return true if a piston block
-     */
-    public static boolean isPistonBlock(Material material) {
-        return material == Material.PISTON_BASE
-                || material == Material.PISTON_STICKY_BASE;
-    }
-
-    /**
-     * Test whether the given material is a Minecart.
-     *
-     * @param material the material
-     * @return true if a Minecart item
-     */
-    public static boolean isMinecart(Material material) {
-        return material == Material.MINECART
-                || material == Material.COMMAND_MINECART
-                || material == Material.EXPLOSIVE_MINECART
-                || material == Material.HOPPER_MINECART
-                || material == Material.POWERED_MINECART
-                || material == Material.STORAGE_MINECART;
-    }
-
-    /**
-     * Test whether the given material is an inventory block.
-     *
-     * @param material the material
-     * @return true if an inventory block
-     */
-    public static boolean isInventoryBlock(Material material) {
-        return material == Material.CHEST
-                || material == Material.JUKEBOX
-                || material == Material.DISPENSER
-                || material == Material.FURNACE
-                || material == Material.BURNING_FURNACE
-                || material == Material.BREWING_STAND
-                || material == Material.TRAPPED_CHEST
-                || material == Material.HOPPER
-                || material == Material.DROPPER;
-    }
-
-    /**
-     * Test whether the given type is Redstone ore.
-     *
-     * @param type the material
-     * @return true if Redstone ore
-     */
-    public static boolean isRedstoneOre(Material type) {
-        return type == Material.GLOWING_REDSTONE_ORE || type == Material.REDSTONE_ORE;
-    }
-
-    /**
-     * Test whether the given material is a block that is modified when it is
-     * left or right clicked.
-     *
-     * <p>This test is conservative, returning true for blocks that it is not
-     * aware of.</p>
-     *
-     * @param material the material
-     * @return true if the block is modified
-     */
-    public static boolean isBlockModifiedOnClick(Material material) {
-        Integer flags = MATERIAL_FLAGS.get(material);
-        return flags == null || (flags & MODIFIED_ON_CLICK) == MODIFIED_ON_CLICK;
-    }
-
-    /**
-     * Test whether the given item modifies a given block when right clicked.
-     *
-     * <p>This test is conservative, returning true for items that it is not
-     * aware of or does not have the details for.</p>
-     *
-     * @param item the item
-     * @param block the block
-     * @return true if the item is applied to the block
-     */
-    public static boolean isItemAppliedToBlock(Material item, Material block) {
-        Integer flags = MATERIAL_FLAGS.get(item);
-        return flags == null || (flags & MODIFIES_BLOCKS) == MODIFIES_BLOCKS;
-    }
-
-}
@@ -1,88 +0,0 @@
-/*
- * WorldGuard, a suite of tools for Minecraft
- * Copyright (C) sk89q <http://www.sk89q.com>
- * Copyright (C) WorldGuard team and contributors
- *
- * This program is free software: you can redistribute it and/or modify it
- * under the terms of the GNU Lesser General Public License as published by the
- * Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License
- * for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-package com.sk89q.worldguard.bukkit.util;
-
-import com.sk89q.worldguard.bukkit.WorldGuardPlugin;
-import com.sk89q.worldguard.bukkit.listener.FlagStateManager;
-import org.bukkit.Location;
-import org.bukkit.World;
-import org.bukkit.entity.Player;
-
-import com.sk89q.worldedit.Vector;
-import com.sk89q.worldguard.protection.ApplicableRegionSet;
-import com.sk89q.worldguard.protection.flags.DefaultFlag;
-import com.sk89q.worldguard.protection.flags.StateFlag;
-import com.sk89q.worldguard.protection.managers.RegionManager;
-
-public final class RegionQueryUtil {
-
-    private RegionQueryUtil() {
-    }
-
-    public static boolean isInvincible(WorldGuardPlugin plugin, Player player) {
-        return isInvincible(plugin, player, null);
-    }
-
-    public static boolean isInvincible(WorldGuardPlugin plugin, Player player,
-                                       ApplicableRegionSet set) {
-        Location loc = player.getLocation();
-        World world = player.getWorld();
-        
-        FlagStateManager.PlayerFlagState state = plugin.getFlagStateManager().getState(player);
-
-        if (state.lastInvincibleWorld == null ||
-                !state.lastInvincibleWorld.equals(world) ||
-                state.lastInvincibleX != loc.getBlockX() ||
-                state.lastInvincibleY != loc.getBlockY() ||
-                state.lastInvincibleZ != loc.getBlockZ()) {
-            state.lastInvincibleX = loc.getBlockX();
-            state.lastInvincibleY = loc.getBlockY();
-            state.lastInvincibleZ = loc.getBlockZ();
-            state.lastInvincibleWorld = world;
-
-            if (set == null) {
-                Vector vec = new Vector(state.lastInvincibleX,
-                        state.lastInvincibleY, state.lastInvincibleZ);
-                RegionManager mgr = plugin.getGlobalRegionManager().get(world);
-                set = mgr.getApplicableRegions(vec);
-            }
-
-            state.wasInvincible = set.allows(DefaultFlag.INVINCIBILITY, plugin.wrapPlayer(player));
-        }
-
-        return state.wasInvincible;
-    }
-
-    public static Boolean isAllowedInvinciblity(WorldGuardPlugin plugin, Player player) {
-        World world = player.getWorld();
-        FlagStateManager.PlayerFlagState state = plugin.getFlagStateManager().getState(player);
-        Vector vec = new Vector(state.lastInvincibleX, state.lastInvincibleY, state.lastInvincibleZ);
-
-        StateFlag.State regionState = plugin.getGlobalRegionManager().get(world).
-                getApplicableRegions(vec).getFlag(DefaultFlag.INVINCIBILITY, plugin.wrapPlayer(player));
-        if (regionState == StateFlag.State.ALLOW) {
-            return Boolean.TRUE;
-        } else if (regionState == StateFlag.State.DENY) {
-            return Boolean.FALSE;
-        } else {
-            return null;
-        }
-    }
-}
@@ -1,346 +0,0 @@
-/*
- * WorldGuard, a suite of tools for Minecraft
- * Copyright (C) sk89q <http://www.sk89q.com>
- * Copyright (C) WorldGuard team and contributors
- *
- * This program is free software: you can redistribute it and/or modify it
- * under the terms of the GNU Lesser General Public License as published by the
- * Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License
- * for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-package com.sk89q.worldguard.bukkit.util;
-
-import java.io.BufferedWriter;
-import java.io.File;
-import java.io.FileWriter;
-import java.io.IOException;
-import java.lang.reflect.Field;
-import java.text.SimpleDateFormat;
-import java.util.Date;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-
-import com.sk89q.worldguard.bukkit.ConfigurationManager;
-import com.sk89q.worldguard.bukkit.WorldConfiguration;
-import com.sk89q.worldguard.bukkit.WorldGuardPlugin;
-import org.bukkit.Server;
-import org.bukkit.World;
-import org.bukkit.entity.Entity;
-import org.bukkit.plugin.Plugin;
-
-import com.sk89q.worldguard.protection.GlobalRegionManager;
-import com.sk89q.worldguard.protection.flags.DefaultFlag;
-import com.sk89q.worldguard.protection.flags.Flag;
-import com.sk89q.worldguard.protection.flags.StateFlag;
-import com.sk89q.worldguard.protection.managers.RegionManager;
-import com.sk89q.worldguard.protection.regions.ProtectedRegion;
-import com.sk89q.worldguard.util.LogListBlock;
-
-public class ReportWriter {
-
-    private static final SimpleDateFormat dateFmt =
-        new SimpleDateFormat("yyyy-MM-dd kk:mm Z");
-    
-    private Date date = new Date();
-    private StringBuilder output = new StringBuilder();
-    
-    public ReportWriter(WorldGuardPlugin plugin) {
-        appendReportHeader(plugin);
-        appendServerInformation(plugin.getServer());
-        appendPluginInformation(plugin.getServer().getPluginManager().getPlugins());
-        appendWorldInformation(plugin.getServer().getWorlds());
-        appendGlobalConfiguration(plugin.getGlobalStateManager());
-        appendWorldConfigurations(plugin, plugin.getServer().getWorlds(),
-                plugin.getGlobalRegionManager(), plugin.getGlobalStateManager());
-        appendln("-------------");
-        appendln("END OF REPORT");
-        appendln();
-    }
-    
-    protected static String repeat(String str, int n) {
-        if(str == null) {
-            return null;
-        }
-        
-        StringBuilder sb = new StringBuilder();
-        for (int i = 0; i < n; i++) {
-            sb.append(str);
-        }
-        
-        return sb.toString();
-    }
-    
-    protected void appendln(String text) {
-        output.append(text);
-        output.append("\r\n");
-    }
-    
-    protected void appendln(String text, Object ... args) {
-        output.append(String.format(text, args));
-        output.append("\r\n");
-    }
-    
-    protected void append(LogListBlock log) {
-        output.append(log.toString());
-    }
-    
-    protected void appendln() {
-        output.append("\r\n");
-    }
-    
-    protected void appendHeader(String text) {
-        String rule = repeat("-", text.length());
-        output.append(rule);
-        output.append("\r\n");
-        appendln(text);
-        output.append(rule);
-        output.append("\r\n");
-        appendln();
-    }
-    
-    private void appendReportHeader(WorldGuardPlugin plugin) {
-        appendln("WorldGuard Configuration Report");
-        appendln("Generated " + dateFmt.format(date));
-        appendln();
-        appendln("Version: " + plugin.getDescription().getVersion());
-        appendln();
-    }
-    
-    private void appendGlobalConfiguration(ConfigurationManager config) {
-        appendHeader("Global Configuration");
-        
-        LogListBlock log = new LogListBlock();
-        LogListBlock configLog = log.putChild("Configuration");
-        
-        Class<? extends ConfigurationManager> cls = config.getClass();
-        for (Field field : cls.getFields()) {
-            try {
-                String name = field.getName();
-                // store these elsewhere maybe?
-                if (name.equals("CONFIG_HEADER")
-                    || name.equals("hostKeys")
-                    || name.equals("sqlPassword")) {
-                        continue;
-                }
-                Object val = field.get(config);
-                configLog.put(name, val);
-            } catch (IllegalArgumentException e) {
-                e.printStackTrace();
-            } catch (IllegalAccessException ignore) {
-            }
-        }
-        
-        append(log);
-        appendln();
-    }
-    
-    private void appendServerInformation(Server server) {
-        appendHeader("Server Information");
-        
-        LogListBlock log = new LogListBlock();
-        
-        Runtime runtime = Runtime.getRuntime();
-
-        log.put("Java", "%s %s (%s)",
-                System.getProperty("java.vendor"),
-                System.getProperty("java.version"),
-                System.getProperty("java.vendor.url"));
-        log.put("Operating system", "%s %s (%s)",
-                System.getProperty("os.name"),
-                System.getProperty("os.version"),
-                System.getProperty("os.arch"));
-        log.put("Available processors", runtime.availableProcessors());
-        log.put("Free memory", runtime.freeMemory() / 1024 / 1024 + " MB");
-        log.put("Max memory", runtime.maxMemory() / 1024 / 1024 + " MB");
-        log.put("Total memory", runtime.totalMemory() / 1024 / 1024 + " MB");
-        log.put("Server ID", server.getServerId());
-        log.put("Server name", server.getServerName());
-        log.put("Implementation", server.getVersion());
-        //log.put("Address", server.getIp(), server.getPort());
-        log.put("Player count", "%d/%d",
-                server.getOnlinePlayers().length, server.getMaxPlayers());
-
-        append(log);
-        appendln();
-    }
-    
-    private void appendPluginInformation(Plugin[] plugins) {
-        appendHeader("Plugins (" + plugins.length + ")");
-        
-        LogListBlock log = new LogListBlock();
-        
-        for (Plugin plugin : plugins) {
-            log.put(plugin.getDescription().getName(), plugin.getDescription().getVersion());
-        }
-
-        append(log);
-        appendln();
-        
-        /*appendHeader("Plugin Information");
-        
-        log = new LogListBlock();
-        
-        for (Plugin plugin : plugins) {
-            log.putChild(plugin.getDescription().getName())
-                .put("Data folder", plugin.getDataFolder())
-                .put("Website", plugin.getDescription().getWebsite())
-                .put("Entry point", plugin.getDescription().getMain());
-        }
-
-        append(log);
-        appendln();*/
-    }
-    
-    private void appendWorldInformation(List<World> worlds) {
-        appendHeader("Worlds");
-        
-        LogListBlock log = new LogListBlock();
-        
-        int i = 0;
-        for (World world : worlds) {
-            int loadedChunkCount = world.getLoadedChunks().length;
-            
-            LogListBlock worldLog = log.putChild(world.getName() + " (" +  i + ")");
-            LogListBlock infoLog = worldLog.putChild("Information");
-            LogListBlock entitiesLog = worldLog.putChild("Entities");
-            
-            infoLog.put("Seed", world.getSeed());
-            infoLog.put("Environment", world.getEnvironment().toString());
-            infoLog.put("Player count", world.getPlayers().size());
-            infoLog.put("Entity count", world.getEntities().size());
-            infoLog.put("Loaded chunk count", loadedChunkCount);
-            infoLog.put("Spawn location", world.getSpawnLocation());
-            infoLog.put("Raw time", world.getFullTime());
-            
-            Map<Class<? extends Entity>, Integer> entityCounts =
-                    new HashMap<Class<? extends Entity>, Integer>();
-            
-            // Collect entities
-            for (Entity entity : world.getEntities()) {
-                Class<? extends Entity> cls = entity.getClass();
-                
-                if (entityCounts.containsKey(cls)) {
-                    entityCounts.put(cls, entityCounts.get(cls) + 1);
-                } else {
-                    entityCounts.put(cls, 1);
-                }
-            }
-            
-            // Print entities
-            for (Map.Entry<Class<? extends Entity>, Integer> entry
-                    : entityCounts.entrySet()) {
-                entitiesLog.put(entry.getKey().getSimpleName(),
-                        "%d [%f/chunk]",
-                        entry.getValue(),
-                        (float) (entry.getValue() / (double) loadedChunkCount));
-            }
-            
-            i++;
-        }
-
-        append(log);
-        appendln();
-    }
-    
-    private void appendWorldConfigurations(WorldGuardPlugin plugin, List<World> worlds,
-            GlobalRegionManager regionMgr, ConfigurationManager mgr) {
-        appendHeader("World Configurations");
-        
-        LogListBlock log = new LogListBlock();
-
-        int i = 0;
-        for (World world : worlds) {
-            LogListBlock worldLog = log.putChild(world.getName() + " (" +  i + ")");
-            LogListBlock infoLog = worldLog.putChild("Information");
-            LogListBlock configLog = worldLog.putChild("Configuration");
-            LogListBlock blacklistLog = worldLog.putChild("Blacklist");
-            LogListBlock regionsLog = worldLog.putChild("Region manager");
-
-            infoLog.put("Configuration file", (new File(plugin.getDataFolder(), "worlds/"
-                    + world.getName() + "/config.yml")).getAbsoluteFile());
-
-            infoLog.put("Blacklist file", (new File(plugin.getDataFolder(), "worlds/"
-                    + world.getName() + "/blacklist.txt")).getAbsoluteFile());
-            infoLog.put("Regions file", (new File(plugin.getDataFolder(), "worlds/"
-                    + world.getName() + "/regions.yml")).getAbsoluteFile());
-            
-            WorldConfiguration config = mgr.get(world);
-            
-            Class<? extends WorldConfiguration> cls = config.getClass();
-            for (Field field : cls.getFields()) {
-                try {
-                    Object val = field.get(config);
-                    configLog.put(field.getName(), String.valueOf(val));
-                } catch (IllegalArgumentException e) {
-                    e.printStackTrace();
-                } catch (IllegalAccessException ignore) {
-                }
-            }
-            
-            if (config.getBlacklist() == null) {
-                blacklistLog.put("State", "DISABLED");
-            } else {
-                blacklistLog.put("State", "Enabled");
-                blacklistLog.put("Number of items",
-                        config.getBlacklist().getItemCount());
-                blacklistLog.put("Is whitelist",
-                        config.getBlacklist().isWhitelist());
-            }
-
-            RegionManager worldRegions = regionMgr.get(world);
-
-            regionsLog.put("Type", worldRegions.getClass().getCanonicalName());
-            regionsLog.put("Number of regions", worldRegions.getRegions().size());
-            LogListBlock globalRegionLog = regionsLog.putChild("Global region");
-            
-            ProtectedRegion globalRegion = worldRegions.matchRegion("__global__");
-            if (globalRegion == null) {
-                globalRegionLog.put("Status", "UNDEFINED");
-            } else {
-                for (Flag<?> flag : DefaultFlag.getFlags()) {
-                    if (flag instanceof StateFlag) {
-                        globalRegionLog.put(flag.getName(),
-                                globalRegion.getFlag(flag));
-                    }
-                }
-            }
-        }
-
-        append(log);
-        appendln();
-    }
-    
-    public void write(File file) throws IOException {
-        FileWriter writer = null;
-        BufferedWriter out;
-        
-        try {
-            writer = new FileWriter(file);
-            out = new BufferedWriter(writer);
-            out.write(output.toString());
-            out.close();
-        } finally {
-            if (writer != null) {
-                try {
-                    writer.close();
-                } catch (IOException ignore) {
-                }
-            }
-        }
-    }
-    
-    @Override
-    public String toString() {
-        return output.toString();
-    }
-}
@@ -1,159 +0,0 @@
-/*
- * WorldGuard, a suite of tools for Minecraft
- * Copyright (C) sk89q <http://www.sk89q.com>
- * Copyright (C) WorldGuard team and contributors
- *
- * This program is free software: you can redistribute it and/or modify it
- * under the terms of the GNU Lesser General Public License as published by the
- * Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License
- * for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-package com.sk89q.worldguard.chest;
-
-import com.sk89q.worldedit.blocks.BlockID;
-import org.bukkit.Material;
-import org.bukkit.block.Block;
-import org.bukkit.block.BlockState;
-import org.bukkit.block.Sign;
-import org.bukkit.entity.Player;
-
-/**
- * Sign-based chest protection.
- * 
- * @author sk89q
- */
-public class SignChestProtection implements ChestProtection {
-    
-    public boolean isProtected(Block block, Player player) {
-        if (isChest(block.getTypeId())) {
-            Block below = block.getRelative(0, -1, 0);
-            return isProtectedSignAround(below, player);
-        } else if (block.getTypeId() == BlockID.SIGN_POST) {
-            return isProtectedSignAndChestBinary(block, player);
-        } else {
-            Block above = block.getRelative(0, 1, 0);
-            Boolean res = isProtectedSign(above, player);
-            if (res != null) return res;
-            return false;
-        }
-    }
-    
-    public boolean isProtectedPlacement(Block block, Player player) {
-        return isProtectedSignAround(block, player);
-    }
-    
-    private boolean isProtectedSignAround(Block searchBlock, Player player) {
-        Block side;
-        Boolean res;
-        
-        side = searchBlock;
-        res = isProtectedSign(side, player);
-        if (res != null && res) return res;
-        
-        side = searchBlock.getRelative(-1, 0, 0);
-        res = isProtectedSignAndChest(side, player);
-        if (res != null && res) return res;
-        
-        side = searchBlock.getRelative(1, 0, 0);
-        res = isProtectedSignAndChest(side, player);
-        if (res != null && res) return res;
-        
-        side = searchBlock.getRelative(0, 0, -1);
-        res = isProtectedSignAndChest(side, player);
-        if (res != null && res) return res;
-        
-        side = searchBlock.getRelative(0, 0, 1);
-        res = isProtectedSignAndChest(side, player);
-        if (res != null && res) return res;
-        
-        return false;
-    }
-    
-    private Boolean isProtectedSign(Sign sign, Player player) {
-        if (sign.getLine(0).equalsIgnoreCase("[Lock]")) {
-            if (player == null) { // No player, no access
-                return true;
-            }
-            
-            String name = player.getName();
-            if (name.equalsIgnoreCase(sign.getLine(1).trim())
-                    || name.equalsIgnoreCase(sign.getLine(2).trim())
-                    || name.equalsIgnoreCase(sign.getLine(3).trim())) {
-                return false;
-            }
-            
-            // No access!
-            return true;
-        }
-        
-        return null;
-    }
-    
-    private Boolean isProtectedSign(Block block, Player player) {
-        BlockState state = block.getState();
-        if (state == null || !(state instanceof Sign)) {
-            return null;
-        }
-        return isProtectedSign((Sign) state, player);
-    }
-    
-    private Boolean isProtectedSignAndChest(Block block, Player player) {
-        if (!isChest(block.getRelative(0, 1, 0).getTypeId())) {
-            return null;
-        }
-        return isProtectedSign(block, player);
-    }
-    
-    private boolean isProtectedSignAndChestBinary(Block block, Player player) {
-        Boolean res = isProtectedSignAndChest(block, player);
-        return !(res == null || !res);
-    }
-
-    public boolean isAdjacentChestProtected(Block searchBlock, Player player) {
-        Block side;
-        Boolean res;
-        
-        side = searchBlock;
-        res = isProtected(side, player);
-        if (res != null && res) return res;
-        
-        side = searchBlock.getRelative(-1, 0, 0);
-        res = isProtected(side, player);
-        if (res != null && res) return res;
-        
-        side = searchBlock.getRelative(1, 0, 0);
-        res = isProtected(side, player);
-        if (res != null && res) return res;
-        
-        side = searchBlock.getRelative(0, 0, -1);
-        res = isProtected(side, player);
-        if (res != null && res) return res;
-        
-        side = searchBlock.getRelative(0, 0, 1);
-        res = isProtected(side, player);
-        if (res != null && res) return res;
-        
-        return false;
-    }
-
-    @Deprecated
-    public boolean isChest(Material material) {
-        return isChest(material.getId());
-    }
-
-    public boolean isChest(int type) {
-        return type == BlockID.CHEST
-                || type == BlockID.DISPENSER
-                || type == BlockID.FURNACE
-                || type == BlockID.BURNING_FURNACE;
-    }
-}
@@ -1,347 +0,0 @@
-/*
- * WorldGuard, a suite of tools for Minecraft
- * Copyright (C) sk89q <http://www.sk89q.com>
- * Copyright (C) WorldGuard team and contributors
- *
- * This program is free software: you can redistribute it and/or modify it
- * under the terms of the GNU Lesser General Public License as published by the
- * Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License
- * for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-package com.sk89q.worldguard.domains;
-
-import com.google.common.collect.ImmutableMap;
-import com.sk89q.squirrelid.Profile;
-import com.sk89q.squirrelid.cache.ProfileCache;
-import com.sk89q.worldguard.LocalPlayer;
-import com.sk89q.worldguard.util.ChangeTracked;
-
-import javax.annotation.Nullable;
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.Iterator;
-import java.util.List;
-import java.util.Set;
-import java.util.UUID;
-
-import static com.google.common.base.Preconditions.checkNotNull;
-
-/**
- * A combination of a {@link PlayerDomain} and a {@link GroupDomain}.
- */
-public class DefaultDomain implements Domain, ChangeTracked {
-
-    private PlayerDomain playerDomain = new PlayerDomain();
-    private GroupDomain groupDomain = new GroupDomain();
-
-    /**
-     * Get the domain that holds the players.
-     *
-     * @return a domain
-     */
-    public PlayerDomain getPlayerDomain() {
-        return playerDomain;
-    }
-
-    /**
-     * Set a new player domain.
-     *
-     * @param playerDomain a domain
-     */
-    public void setPlayerDomain(PlayerDomain playerDomain) {
-        checkNotNull(playerDomain);
-        this.playerDomain = playerDomain;
-    }
-
-    /**
-     * Set the domain that holds the groups.
-     *
-     * @return a domain
-     */
-    public GroupDomain getGroupDomain() {
-        return groupDomain;
-    }
-
-    /**
-     * Set a new group domain.
-     *
-     * @param groupDomain a domain
-     */
-    public void setGroupDomain(GroupDomain groupDomain) {
-        checkNotNull(groupDomain);
-        this.groupDomain = groupDomain;
-    }
-
-    /**
-     * Add the given player to the domain, identified by the player's name.
-     *
-     * @param name the name of the player
-     */
-    public void addPlayer(String name) {
-        playerDomain.addPlayer(name);
-    }
-
-    /**
-     * Remove the given player from the domain, identified by the player's name.
-     *
-     * @param name the name of the player
-     */
-    public void removePlayer(String name) {
-        playerDomain.removePlayer(name);
-    }
-
-    /**
-     * Remove the given player from the domain, identified by the player's UUID.
-     *
-     * @param uuid the UUID of the player
-     */
-    public void removePlayer(UUID uuid) {
-        playerDomain.removePlayer(uuid);
-    }
-
-    /**
-     * Add the given player to the domain, identified by the player's UUID.
-     *
-     * @param uniqueId the UUID of the player
-     */
-    public void addPlayer(UUID uniqueId) {
-        playerDomain.addPlayer(uniqueId);
-    }
-
-    /**
-     * Remove the given player from the domain, identified by either the
-     * player's name, the player's unique ID, or both.
-     *
-     * @param player the player
-     */
-    public void removePlayer(LocalPlayer player) {
-        playerDomain.removePlayer(player);
-    }
-
-    /**
-     * Add the given player to the domain, identified by the player's UUID.
-     *
-     * @param player the player
-     */
-    public void addPlayer(LocalPlayer player) {
-        playerDomain.addPlayer(player);
-    }
-
-    /**
-     * Add all the entries from another domain.
-     *
-     * @param other the other domain
-     */
-    public void addAll(DefaultDomain other) {
-        checkNotNull(other);
-        for (String player : other.getPlayers()) {
-            addPlayer(player);
-        }
-        for (UUID uuid : other.getUniqueIds()) {
-            addPlayer(uuid);
-        }
-        for (String group : other.getGroups()) {
-            addGroup(group);
-        }
-    }
-
-    /**
-     * Remove all the entries from another domain.
-     *
-     * @param other the other domain
-     */
-    public void removeAll(DefaultDomain other) {
-        checkNotNull(other);
-        for (String player : other.getPlayers()) {
-            removePlayer(player);
-        }
-        for (UUID uuid : other.getUniqueIds()) {
-            removePlayer(uuid);
-        }
-        for (String group : other.getGroups()) {
-            removeGroup(group);
-        }
-    }
-
-    /**
-     * Get the set of player names.
-     *
-     * @return the set of player names
-     */
-    public Set<String> getPlayers() {
-        return playerDomain.getPlayers();
-    }
-
-    /**
-     * Get the set of player UUIDs.
-     *
-     * @return the set of player UUIDs
-     */
-    public Set<UUID> getUniqueIds() {
-        return playerDomain.getUniqueIds();
-    }
-
-    /**
-     * Add the name of the group to the domain.
-     *
-     * @param name the name of the group.
-     */
-    public void addGroup(String name) {
-        groupDomain.addGroup(name);
-    }
-
-    /**
-     * Remove the given group from the domain.
-     *
-     * @param name the name of the group
-     */
-    public void removeGroup(String name) {
-        groupDomain.removeGroup(name);
-    }
-
-    /**
-     * Get the set of group names.
-     *
-     * @return the set of group names
-     */
-    public Set<String> getGroups() {
-        return groupDomain.getGroups();
-    }
-
-    @Override
-    public boolean contains(LocalPlayer player) {
-        return playerDomain.contains(player) || groupDomain.contains(player);
-    }
-
-    @Override
-    public boolean contains(UUID uniqueId) {
-        return playerDomain.contains(uniqueId);
-    }
-
-    @Override
-    public boolean contains(String playerName) {
-        return playerDomain.contains(playerName);
-    }
-
-    @Override
-    public int size() {
-        return groupDomain.size() + playerDomain.size();
-    }
-
-    @Override
-    public void clear() {
-        playerDomain.clear();
-        groupDomain.clear();
-    }
-
-    public void removeAll() {
-        clear();
-    }
-
-    public String toPlayersString() {
-        return toPlayersString(null);
-    }
-
-    @SuppressWarnings("deprecation")
-    public String toPlayersString(@Nullable ProfileCache cache) {
-        StringBuilder str = new StringBuilder();
-        List<String> output = new ArrayList<String>();
-
-        for (String name : playerDomain.getPlayers()) {
-            output.add("name:" + name);
-        }
-
-        if (cache != null) {
-            ImmutableMap<UUID, Profile> results = cache.getAllPresent(playerDomain.getUniqueIds());
-            for (UUID uuid : playerDomain.getUniqueIds()) {
-                Profile profile = results.get(uuid);
-                if (profile != null) {
-                    output.add(profile.getName() + "*");
-                } else {
-                    output.add("uuid:" + uuid);
-                }
-            }
-        } else {
-            for (UUID uuid : playerDomain.getUniqueIds()) {
-                output.add("uuid:" + uuid);
-            }
-        }
-
-        Collections.sort(output, String.CASE_INSENSITIVE_ORDER);
-        for (Iterator<String> it = output.iterator(); it.hasNext();) {
-            str.append(it.next());
-            if (it.hasNext()) {
-                str.append(", ");
-            }
-        }
-        return str.toString();
-    }
-    
-    public String toGroupsString() {
-        StringBuilder str = new StringBuilder();
-        for (Iterator<String> it = groupDomain.getGroups().iterator(); it.hasNext(); ) {
-            str.append("*");
-            str.append(it.next());
-            if (it.hasNext()) {
-                str.append(", ");
-            }
-        }
-        return str.toString();
-    }
-
-    public String toUserFriendlyString() {
-        StringBuilder str = new StringBuilder();
-
-        if (playerDomain.size() > 0) {
-            str.append(toPlayersString());
-        }
-
-        if (groupDomain.size() > 0) {
-            if (str.length() > 0) {
-                str.append("; ");
-            }
-
-            str.append(toGroupsString());
-        }
-
-        return str.toString();
-    }
-
-    public String toUserFriendlyString(ProfileCache cache) {
-        StringBuilder str = new StringBuilder();
-
-        if (playerDomain.size() > 0) {
-            str.append(toPlayersString(cache));
-        }
-
-        if (groupDomain.size() > 0) {
-            if (str.length() > 0) {
-                str.append("; ");
-            }
-
-            str.append(toGroupsString());
-        }
-
-        return str.toString();
-    }
-
-    @Override
-    public boolean isDirty() {
-        return playerDomain.isDirty() || groupDomain.isDirty();
-    }
-
-    @Override
-    public void setDirty(boolean dirty) {
-        playerDomain.setDirty(dirty);
-        groupDomain.setDirty(dirty);
-    }
-}
@@ -1,230 +0,0 @@
-/*
- * WorldGuard, a suite of tools for Minecraft
- * Copyright (C) sk89q <http://www.sk89q.com>
- * Copyright (C) WorldGuard team and contributors
- *
- * This program is free software: you can redistribute it and/or modify it
- * under the terms of the GNU Lesser General Public License as published by the
- * Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License
- * for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-package com.sk89q.worldguard.protection;
-
-import com.sk89q.worldguard.LocalPlayer;
-import com.sk89q.worldguard.bukkit.BukkitPlayer;
-import com.sk89q.worldguard.bukkit.RegionContainer;
-import com.sk89q.worldguard.bukkit.RegionQuery;
-import com.sk89q.worldguard.bukkit.WorldGuardPlugin;
-import com.sk89q.worldguard.protection.association.RegionAssociable;
-import com.sk89q.worldguard.protection.flags.DefaultFlag;
-import com.sk89q.worldguard.protection.flags.StateFlag;
-import com.sk89q.worldguard.protection.managers.RegionManager;
-import org.bukkit.Location;
-import org.bukkit.World;
-import org.bukkit.block.Block;
-import org.bukkit.entity.Player;
-
-import javax.annotation.Nullable;
-import java.util.Collections;
-import java.util.List;
-
-import static com.google.common.base.Preconditions.checkNotNull;
-
-/**
- * This is the legacy class for accessing region data.
- *
- * @deprecated use {@link WorldGuardPlugin#getRegionContainer()}
- */
-@Deprecated
-public class GlobalRegionManager {
-
-    private final WorldGuardPlugin plugin;
-    private final RegionContainer container;
-
-    /**
-     * Create a new instance.
-     *
-     * @param plugin the plugin
-     * @param container the container
-     */
-    public GlobalRegionManager(WorldGuardPlugin plugin, RegionContainer container) {
-        checkNotNull(plugin);
-        checkNotNull(container);
-        this.plugin = plugin;
-        this.container = container;
-    }
-
-    /**
-     * Get the region manager for a world if one exists.
-     *
-     * <p>This method may return {@code null} if region data for the given
-     * world has not been loaded, has failed to load, or support for regions
-     * has been disabled.</p>
-     *
-     * @param world the world
-     * @return a region manager, or {@code null} if one is not available
-     */
-    @Nullable
-    public RegionManager get(World world) {
-        return container.get(world);
-    }
-
-    /**
-     * Get an immutable list of loaded {@link RegionManager}s.
-     *
-     * @return a list of managers
-     */
-    public List<RegionManager> getLoaded() {
-        return Collections.unmodifiableList(container.getLoaded());
-    }
-
-    /**
-     * Create a new region query.
-     *
-     * @return a new query
-     */
-    private RegionQuery createQuery() {
-        return container.createQuery();
-    }
-
-    /**
-     * Test whether the given player has region protection bypass permission.
-     *
-     * @param player the player
-     * @param world the world
-     * @return true if a bypass is permitted
-     * @deprecated use {@link RegionContainer#createQuery()}
-     */
-    @Deprecated
-    public boolean hasBypass(LocalPlayer player, World world) {
-        return player.hasPermission("worldguard.region.bypass." + world.getName());
-    }
-
-    /**
-     * Test whether the given player has region protection bypass permission.
-     *
-     * @param player the player
-     * @param world the world
-     * @return true if a bypass is permitted
-     * @deprecated use {@link RegionContainer#createQuery()}
-     */
-    @Deprecated
-    public boolean hasBypass(Player player, World world) {
-        return plugin.hasPermission(player, "worldguard.region.bypass." + world.getName());
-    }
-
-    /**
-     * Test whether the player can build (place, use, destroy blocks and
-     * entities) at the given position, considering only the build flag
-     * and the region's members.
-     *
-     * <p>This method is not an absolute test as to whether WorldGuard
-     * would allow or block an event because this method doesn't
-     * consider flags (i.e. chest-access flags when concerning a chest) or
-     * other modules in WorldGuard (i.e chest protection).</p>
-     *
-     * @param player the player
-     * @param block the block
-     * @return true if a bypass is permitted
-     * @deprecated use {@link RegionContainer#createQuery()}
-     */
-    @SuppressWarnings("deprecation")
-    @Deprecated
-    public boolean canBuild(Player player, Block block) {
-        return canBuild(player, block.getLocation());
-    }
-
-    /**
-     * Test whether the player can build (place, use, destroy blocks and
-     * entities) at the given position, considering only the build flag
-     * and the region's members.
-     *
-     * <p>This method is not an absolute test as to whether WorldGuard
-     * would allow or block an event because this method doesn't
-     * consider flags (i.e. chest-access flags when concerning a chest) or
-     * other modules in WorldGuard (i.e chest protection).</p>
-     *
-     * @param player the player
-     * @param location the location
-     * @return true if a bypass is permitted
-     * @deprecated use {@link RegionContainer#createQuery()}
-     */
-    @Deprecated
-    public boolean canBuild(Player player, Location location) {
-        return hasBypass(player, location.getWorld()) || createQuery().testState(location, player, DefaultFlag.BUILD);
-
-    }
-
-    /**
-     * Test whether the player can place blocks at the given position.
-     *
-     * @param player the player
-     * @param block the block
-     * @return true if permitted
-     * @deprecated the construct flag is being removed
-     */
-    @Deprecated
-    @SuppressWarnings("deprecation")
-    public boolean canConstruct(Player player, Block block) {
-        return canBuild(player, block.getLocation());
-    }
-
-    /**
-     * Test whether the player can place blocks at the given position.
-     *
-     * @param player the player
-     * @param location the location
-     * @return true if permitted
-     * @deprecated the construct flag is being removed
-     */
-    @Deprecated
-    public boolean canConstruct(Player player, Location location) {
-        return canBuild(player, location);
-    }
-
-    /**
-     * Test the value of a state flag at a location.
-     *
-     * @param flag the flag
-     * @param location the location
-     * @return true if set to true
-     * @deprecated use {@link RegionContainer#createQuery()}
-     */
-    @Deprecated
-    @SuppressWarnings("deprecation")
-    public boolean allows(StateFlag flag, Location location) {
-        return allows(flag, location, null);
-    }
-
-    /**
-     * Test the value of a state flag at a location, using the player as the
-     * relevant actor.
-     *
-     * @param flag the flag
-     * @param location the location
-     * @param player the actor
-     * @return true if set to true
-     * @deprecated use {@link RegionContainer#createQuery()}
-     */
-    @Deprecated
-    public boolean allows(StateFlag flag, Location location, @Nullable LocalPlayer player) {
-        if (player == null) {
-            return StateFlag.test(createQuery().queryState(location, (RegionAssociable) null, flag));
-        } else if (player instanceof BukkitPlayer) {
-            Player p = ((BukkitPlayer) player).getPlayer();
-            return StateFlag.test(createQuery().queryState(location, p, flag));
-        } else {
-            throw new IllegalArgumentException("Can't take a non-Bukkit player");
-        }
-    }
-
-}
@@ -1,168 +0,0 @@
-/*
- * WorldGuard, a suite of tools for Minecraft
- * Copyright (C) sk89q <http://www.sk89q.com>
- * Copyright (C) WorldGuard team and contributors
- *
- * This program is free software: you can redistribute it and/or modify it
- * under the terms of the GNU Lesser General Public License as published by the
- * Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License
- * for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-package com.sk89q.worldguard.protection.flags;
-
-import org.bukkit.ChatColor;
-import org.bukkit.GameMode;
-import org.bukkit.entity.EntityType;
-
-/**
- * The flags that are used in WorldGuard.
- */
-public final class DefaultFlag {
-
-    // Overrides membership check
-    public static final StateFlag PASSTHROUGH = new StateFlag("passthrough", false);
-
-    /**
-     * @deprecated This flag is being removed because group flags can now be
-     *             set on all flags.
-     */
-    @Deprecated
-    public static final RegionGroupFlag CONSTRUCT = new RegionGroupFlag("construct", RegionGroup.MEMBERS);
-
-    // This flag is unlike the others. It forces the checking of region membership
-    public static final StateFlag BUILD = new StateFlag("build", true);
-
-    // These flags are used in tandem with the BUILD flag - if the player can
-    // build, then the following flags do not need to be checked (although they
-    // are still checked for DENY), so they are false by default
-    public static final StateFlag BLOCK_BREAK = new StateFlag("block-break", false);
-    public static final StateFlag BLOCK_PLACE = new StateFlag("block-place", false);
-    public static final StateFlag USE = new StateFlag("use", false);
-    public static final StateFlag PVP = new StateFlag("pvp", false);
-    public static final StateFlag SLEEP = new StateFlag("sleep", false);
-    public static final StateFlag TNT = new StateFlag("tnt", false);
-    public static final StateFlag CHEST_ACCESS = new StateFlag("chest-access", false);
-    public static final StateFlag PLACE_VEHICLE = new StateFlag("vehicle-place", false);
-    public static final StateFlag DESTROY_VEHICLE = new StateFlag("vehicle-destroy", false);
-    public static final StateFlag LIGHTER = new StateFlag("lighter", false);
-
-    // These flags are similar to the ones above (used in tandem with BUILD),
-    // but their defaults are set to TRUE because it is more user friendly.
-    // However, it is not possible to disable these flags by default in all
-    // regions because setting DENY in __global__ would also override the
-    // BUILD flag. In the future, StateFlags will need a DISALLOW state.
-    public static final StateFlag ITEM_PICKUP = new StateFlag("item-pickup", true); // Intentionally true
-    public static final StateFlag ITEM_DROP = new StateFlag("item-drop", true); // Intentionally true
-
-    // These flags adjust behavior and are not checked in tandem with the
-    // BUILD flag so they need to be TRUE for their defaults.
-    public static final StateFlag MOB_DAMAGE = new StateFlag("mob-damage", true);
-    public static final StateFlag MOB_SPAWNING = new StateFlag("mob-spawning", true);
-    public static final StateFlag CREEPER_EXPLOSION = new StateFlag("creeper-explosion", true);
-    public static final StateFlag ENDERDRAGON_BLOCK_DAMAGE = new StateFlag("enderdragon-block-damage", true);
-    public static final StateFlag GHAST_FIREBALL = new StateFlag("ghast-fireball", true);
-    public static final StateFlag OTHER_EXPLOSION = new StateFlag("other-explosion", true);
-    public static final StateFlag FIRE_SPREAD = new StateFlag("fire-spread", true);
-    public static final StateFlag LAVA_FIRE = new StateFlag("lava-fire", true);
-    public static final StateFlag LIGHTNING = new StateFlag("lightning", true);
-    public static final StateFlag WATER_FLOW = new StateFlag("water-flow", true);
-    public static final StateFlag LAVA_FLOW = new StateFlag("lava-flow", true);
-    public static final StateFlag PISTONS = new StateFlag("pistons", true);
-    public static final StateFlag SNOW_FALL = new StateFlag("snow-fall", true);
-    public static final StateFlag SNOW_MELT = new StateFlag("snow-melt", true);
-    public static final StateFlag ICE_FORM = new StateFlag("ice-form", true);
-    public static final StateFlag ICE_MELT = new StateFlag("ice-melt", true);
-    public static final StateFlag MUSHROOMS = new StateFlag("mushroom-growth", true);
-    public static final StateFlag LEAF_DECAY = new StateFlag("leaf-decay", true);
-    public static final StateFlag GRASS_SPREAD = new StateFlag("grass-growth", true);
-    public static final StateFlag MYCELIUM_SPREAD = new StateFlag("mycelium-spread", true);
-    public static final StateFlag VINE_GROWTH = new StateFlag("vine-growth", true);
-    public static final StateFlag SOIL_DRY = new StateFlag("soil-dry", true);
-    public static final StateFlag ENDER_BUILD = new StateFlag("enderman-grief", true);
-    public static final StateFlag INVINCIBILITY = new StateFlag("invincible", false);
-    public static final StateFlag EXP_DROPS = new StateFlag("exp-drops", true);
-    public static final StateFlag SEND_CHAT = new StateFlag("send-chat", true);
-    public static final StateFlag RECEIVE_CHAT = new StateFlag("receive-chat", true);
-    public static final StateFlag ENTRY = new StateFlag("entry", true, RegionGroup.NON_MEMBERS);
-    public static final StateFlag EXIT = new StateFlag("exit", true, RegionGroup.NON_MEMBERS);
-    public static final StateFlag ENDERPEARL = new StateFlag("enderpearl", true);
-    public static final StateFlag ENTITY_PAINTING_DESTROY = new StateFlag("entity-painting-destroy", true);
-    public static final StateFlag ENTITY_ITEM_FRAME_DESTROY = new StateFlag("entity-item-frame-destroy", true);
-    public static final StateFlag POTION_SPLASH = new StateFlag("potion-splash", true);
-
-    // Flags that adjust behaviors that aren't state flags
-    public static final StringFlag DENY_MESSAGE = new StringFlag("deny-message",
-            "" + ChatColor.RED + ChatColor.BOLD + "Hey!" + ChatColor.GRAY + " Sorry, but you can't %what% here.");
-    public static final StringFlag GREET_MESSAGE = new StringFlag("greeting");
-    public static final StringFlag FAREWELL_MESSAGE = new StringFlag("farewell");
-    public static final BooleanFlag NOTIFY_ENTER = new BooleanFlag("notify-enter");
-    public static final BooleanFlag NOTIFY_LEAVE = new BooleanFlag("notify-leave");
-    public static final SetFlag<EntityType> DENY_SPAWN = new SetFlag<EntityType>("deny-spawn", new EntityTypeFlag(null));
-    public static final EnumFlag<GameMode> GAME_MODE = new EnumFlag<GameMode>("game-mode", GameMode.class);
-    public static final IntegerFlag HEAL_DELAY = new IntegerFlag("heal-delay");
-    public static final IntegerFlag HEAL_AMOUNT = new IntegerFlag("heal-amount");
-    public static final DoubleFlag MIN_HEAL = new DoubleFlag("heal-min-health");
-    public static final DoubleFlag MAX_HEAL = new DoubleFlag("heal-max-health");
-    public static final IntegerFlag FEED_DELAY = new IntegerFlag("feed-delay");
-    public static final IntegerFlag FEED_AMOUNT = new IntegerFlag("feed-amount");
-    public static final IntegerFlag MIN_FOOD = new IntegerFlag("feed-min-hunger");
-    public static final IntegerFlag MAX_FOOD = new IntegerFlag("feed-max-hunger");
-    // public static final IntegerFlag MAX_PLAYERS = new IntegerFlag("max-players-allowed");
-    // public static final StringFlag MAX_PLAYERS_MESSAGE = new StringFlag("max-players-reject-message");
-    public static final LocationFlag TELE_LOC = new LocationFlag("teleport", RegionGroup.MEMBERS);
-    public static final LocationFlag SPAWN_LOC = new LocationFlag("spawn", RegionGroup.MEMBERS);
-    public static final StateFlag ENABLE_SHOP = new StateFlag("allow-shop", false);
-    public static final BooleanFlag BUYABLE = new BooleanFlag("buyable");
-    public static final DoubleFlag PRICE = new DoubleFlag("price");
-    public static final SetFlag<String> BLOCKED_CMDS = new SetFlag<String>("blocked-cmds", new CommandStringFlag(null));
-    public static final SetFlag<String> ALLOWED_CMDS = new SetFlag<String>("allowed-cmds", new CommandStringFlag(null));
-
-    public static final Flag<?>[] flagsList = new Flag<?>[] {
-            PASSTHROUGH, BUILD, CONSTRUCT, BLOCK_BREAK, BLOCK_PLACE, PVP, CHEST_ACCESS, PISTONS,
-            TNT, LIGHTER, USE, PLACE_VEHICLE, DESTROY_VEHICLE, SLEEP,
-            MOB_DAMAGE, MOB_SPAWNING, DENY_SPAWN, INVINCIBILITY, EXP_DROPS,
-            CREEPER_EXPLOSION, OTHER_EXPLOSION, ENDERDRAGON_BLOCK_DAMAGE, GHAST_FIREBALL, ENDER_BUILD,
-            DENY_MESSAGE, GREET_MESSAGE, FAREWELL_MESSAGE, NOTIFY_ENTER, NOTIFY_LEAVE,
-            EXIT, ENTRY, LIGHTNING, ENTITY_PAINTING_DESTROY, ENDERPEARL,
-            ENTITY_ITEM_FRAME_DESTROY, ITEM_PICKUP, ITEM_DROP, /*MAX_PLAYERS, MAX_PLAYERS_MESSAGE,*/
-            HEAL_AMOUNT, HEAL_DELAY, MIN_HEAL, MAX_HEAL,
-            FEED_DELAY, FEED_AMOUNT, MIN_FOOD, MAX_FOOD,
-            SNOW_FALL, SNOW_MELT, ICE_FORM, ICE_MELT, SOIL_DRY, GAME_MODE,
-            MUSHROOMS, LEAF_DECAY, GRASS_SPREAD, MYCELIUM_SPREAD, VINE_GROWTH,
-            SEND_CHAT, RECEIVE_CHAT, FIRE_SPREAD, LAVA_FIRE, LAVA_FLOW, WATER_FLOW,
-            TELE_LOC, SPAWN_LOC, POTION_SPLASH,
-            BLOCKED_CMDS, ALLOWED_CMDS, PRICE, BUYABLE, ENABLE_SHOP
-    };
-
-    private DefaultFlag() {
-    }
-
-    public static Flag<?>[] getFlags() {
-        return flagsList;
-    }
-
-    /**
-     * Try to match the flag with the given ID using a fuzzy name match.
-     *
-     * @param id the flag ID
-     * @return a flag, or null
-     */
-    public static Flag<?> fuzzyMatchFlag(String id) {
-        for (Flag<?> flag : DefaultFlag.getFlags()) {
-            if (flag.getName().replace("-", "").equalsIgnoreCase(id.replace("-", ""))) {
-                return flag;
-            }
-        }
-
-        return null;
-    }
-}
@@ -1,55 +0,0 @@
-/*
- * WorldGuard, a suite of tools for Minecraft
- * Copyright (C) sk89q <http://www.sk89q.com>
- * Copyright (C) WorldGuard team and contributors
- *
- * This program is free software: you can redistribute it and/or modify it
- * under the terms of the GNU Lesser General Public License as published by the
- * Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License
- * for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-package com.sk89q.worldguard.protection.flags;
-
-import org.bukkit.entity.EntityType;
-
-/**
- * Represents an entity type.
- *
- * @author sk89q
- */
-public class EntityTypeFlag extends EnumFlag<EntityType> {
-
-    public EntityTypeFlag(String name, RegionGroup defaultGroup) {
-        super(name, EntityType.class, defaultGroup);
-    }
-
-    public EntityTypeFlag(String name) {
-        super(name, EntityType.class);
-    }
-
-    @Override
-    public EntityType detectValue(String input) {
-        EntityType lowMatch = null;
-
-        for (EntityType type : EntityType.values()) {
-            if (type.name().equalsIgnoreCase(input.trim())) {
-                return type;
-            }
-
-            if (type.name().toLowerCase().startsWith(input.toLowerCase().trim())) {
-                lowMatch = type;
-            }
-        }
-
-        return lowMatch;
-    }
-}
@@ -1,89 +0,0 @@
-/*
- * WorldGuard, a suite of tools for Minecraft
- * Copyright (C) sk89q <http://www.sk89q.com>
- * Copyright (C) WorldGuard team and contributors
- *
- * This program is free software: you can redistribute it and/or modify it
- * under the terms of the GNU Lesser General Public License as published by the
- * Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License
- * for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-package com.sk89q.worldguard.protection.flags;
-
-import com.sk89q.worldguard.bukkit.WorldGuardPlugin;
-import org.bukkit.command.CommandSender;
-
-import javax.annotation.Nullable;
-import java.util.Collection;
-
-/**
- *
- * @author sk89q
- * @param <T>
- */
-public abstract class Flag<T> {
-
-    private String name;
-    private RegionGroupFlag regionGroup;
-    
-    public Flag(String name, RegionGroup defaultGroup) {
-        this.name = name;
-
-        if (defaultGroup != null) {
-            this.regionGroup = new RegionGroupFlag(name + "-group", defaultGroup);
-        }
-    }
-
-    public Flag(String name) {
-        this(name, RegionGroup.ALL);
-    }
-
-    public String getName() {
-        return name;
-    }
-
-    /**
-     * Get the default value.
-     *
-     * @return the default value, if one exists, otherwise {@code null} may be returned
-     */
-    @Nullable
-    public T getDefault() {
-        return null;
-    }
-
-    @Nullable
-    public T chooseValue(Collection<T> values) {
-        if (!values.isEmpty()) {
-            return values.iterator().next();
-        } else {
-            return null;
-        }
-    }
-    
-    public RegionGroupFlag getRegionGroupFlag() {
-        return regionGroup;
-    }
-
-    public abstract T parseInput(WorldGuardPlugin plugin, CommandSender sender, String input) throws InvalidFlagFormat;
-
-    public abstract T unmarshal(@Nullable Object o);
-
-    public abstract Object marshal(T o);
-
-    @Override
-    public String toString() {
-        return getClass().getName() + "{" +
-                "name='" + name + '\'' +
-                '}';
-    }
-}
@@ -1,163 +0,0 @@
-/*
- * WorldGuard, a suite of tools for Minecraft
- * Copyright (C) sk89q <http://www.sk89q.com>
- * Copyright (C) WorldGuard team and contributors
- *
- * This program is free software: you can redistribute it and/or modify it
- * under the terms of the GNU Lesser General Public License as published by the
- * Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License
- * for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-package com.sk89q.worldguard.protection.regions;
-
-import com.sk89q.worldedit.BlockVector;
-import com.sk89q.worldedit.BlockVector2D;
-import com.sk89q.worldedit.Vector;
-import com.sk89q.worldguard.util.MathUtils;
-
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.List;
-
-import static com.google.common.base.Preconditions.checkNotNull;
-
-/**
- * Represents a cuboid region that can be protected.
- *
- * @author sk89q
- */
-public class ProtectedCuboidRegion extends ProtectedRegion {
-
-    /**
-     * Construct a new instance of this cuboid region.
-     *
-     * @param id the region id
-     * @param pt1 the first point of this region
-     * @param pt2 the second point of this region
-     */
-    public ProtectedCuboidRegion(String id, BlockVector pt1, BlockVector pt2) {
-        super(id);
-        setMinMaxPoints(pt1, pt2);
-    }
-
-    /**
-     * Given any two points, sets the minimum and maximum points.
-     *
-     * @param position1 the first point of this region
-     * @param position2 the second point of this region
-     */
-    private void setMinMaxPoints(BlockVector position1, BlockVector position2) {
-        checkNotNull(position1);
-        checkNotNull(position2);
-
-        List<Vector> points = new ArrayList<Vector>();
-        points.add(position1);
-        points.add(position2);
-        setMinMaxPoints(points);
-    }
-
-    /**
-     * Set the lower point of the cuboid.
-     *
-     * @param position the point to set as the minimum point
-     */
-    public void setMinimumPoint(BlockVector position) {
-        setMinMaxPoints(position, max);
-    }
-
-    /**
-     * Set the upper point of the cuboid.
-     *
-     * @param position the point to set as the maximum point
-     */
-    public void setMaximumPoint(BlockVector position) {
-        setMinMaxPoints(min, position);
-    }
-
-    @Override
-    public List<BlockVector2D> getPoints() {
-        List<BlockVector2D> pts = new ArrayList<BlockVector2D>();
-        int x1 = min.getBlockX();
-        int x2 = max.getBlockX();
-        int z1 = min.getBlockZ();
-        int z2 = max.getBlockZ();
-
-        pts.add(new BlockVector2D(x1, z1));
-        pts.add(new BlockVector2D(x2, z1));
-        pts.add(new BlockVector2D(x2, z2));
-        pts.add(new BlockVector2D(x1, z2));
-
-        return pts;
-    }
-
-    @Override
-    public boolean contains(Vector pt) {
-        final double x = pt.getX();
-        final double y = pt.getY();
-        final double z = pt.getZ();
-        return x >= min.getBlockX() && x < max.getBlockX()+1
-                && y >= min.getBlockY() && y < max.getBlockY()+1
-                && z >= min.getBlockZ() && z < max.getBlockZ()+1;
-    }
-
-    @Override
-    public RegionType getType() {
-        return RegionType.CUBOID;
-    }
-
-    @Override
-    public List<ProtectedRegion> getIntersectingRegions(Collection<ProtectedRegion> regions) {
-        checkNotNull(regions);
-
-        List<ProtectedRegion> intersectingRegions = new ArrayList<ProtectedRegion>();
-
-        for (ProtectedRegion region : regions) {
-            if (!intersectsBoundingBox(region)) continue;
-
-            // If both regions are Cuboids and their bounding boxes intersect, they intersect
-            if (region instanceof ProtectedCuboidRegion) {
-                intersectingRegions.add(region);
-            } else if (region instanceof ProtectedPolygonalRegion) {
-                // If either region contains the points of the other,
-                // or if any edges intersect, the regions intersect
-                if (containsAny(region.getPoints()) || region.containsAny(getPoints()) || intersectsEdges(region)) {
-                    intersectingRegions.add(region);
-                }
-            } else if (region instanceof GlobalProtectedRegion) {
-                // Never intersects
-            } else {
-                throw new IllegalArgumentException("Not supported yet.");
-            }
-        }
-        return intersectingRegions;
-    }
-
-    @Override
-    public int volume() {
-        int xLength = max.getBlockX() - min.getBlockX() + 1;
-        int yLength = max.getBlockY() - min.getBlockY() + 1;
-        int zLength = max.getBlockZ() - min.getBlockZ() + 1;
-
-        try {
-            long v = MathUtils.checkedMultiply(xLength, yLength);
-            v = MathUtils.checkedMultiply(v, zLength);
-            if (v > Integer.MAX_VALUE) {
-                return Integer.MAX_VALUE;
-            } else {
-                return (int) v;
-            }
-        } catch (ArithmeticException e) {
-            return Integer.MAX_VALUE;
-        }
-    }
-
-}
@@ -1,130 +0,0 @@
-/*
- * WorldGuard, a suite of tools for Minecraft
- * Copyright (C) sk89q <http://www.sk89q.com>
- * Copyright (C) WorldGuard team and contributors
- *
- * This program is free software: you can redistribute it and/or modify it
- * under the terms of the GNU Lesser General Public License as published by the
- * Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License
- * for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-package com.sk89q.worldguard.util;
-
-import java.util.LinkedHashMap;
-import java.util.Map;
-
-public class LogListBlock {
-
-    private LinkedHashMap<String, Object> items = new LinkedHashMap<String, Object>();
-
-    private int maxKeyLength = 0;
-    
-    private void updateKey(String key) {
-        if (key.length() > maxKeyLength) {
-            maxKeyLength = key.length();
-        }
-    }
-    
-    public LogListBlock put(String key, String value) {
-        updateKey(key);
-        items.put(key, String.valueOf(value));
-        return this;
-    }
-    
-    public LogListBlock put(String key, LogListBlock value) {
-        updateKey(key);
-        items.put(key, value);
-        return this;
-    }
-    
-    public LogListBlock put(String key, Object value) {
-        put(key, String.valueOf(value));
-        return this;
-    }
-    
-    public LogListBlock put(String key, String value, Object ... args) {
-        put(key, String.format(value, args));
-        return this;
-    }
-    
-    public LogListBlock put(String key, int value) {
-        put(key, String.valueOf(value));
-        return this;
-    }
-    
-    public LogListBlock put(String key, byte value) {
-        put(key, String.valueOf(value));
-        return this;
-    }
-    
-    public LogListBlock put(String key, double value) {
-        put(key, String.valueOf(value));
-        return this;
-    }
-    
-    public LogListBlock put(String key, float value) {
-        put(key, String.valueOf(value));
-        return this;
-    }
-    
-    public LogListBlock put(String key, short value) {
-        put(key, String.valueOf(value));
-        return this;
-    }
-    
-    public LogListBlock put(String key, long value) {
-        put(key, String.valueOf(value));
-        return this;
-    }
-    
-    public LogListBlock put(String key, boolean value) {
-        put(key, String.valueOf(value));
-        return this;
-    }
-    
-    public LogListBlock putChild(String key) {
-        updateKey(key);
-        LogListBlock block = new LogListBlock();
-        items.put(key, block);
-        return block;
-    }
-    
-    private String padKey(String key, int len) {
-        return String.format("%-" + len + "s", key);
-    }
-    
-    protected String getOutput(String prefix) {
-        StringBuilder out = new StringBuilder();
-        for (Map.Entry<String, Object> entry : items.entrySet()) {
-            Object val = entry.getValue();
-            if (val instanceof LogListBlock) {
-                out.append(prefix);
-                out.append(padKey(entry.getKey(), maxKeyLength));
-                out.append(":\r\n");
-                out.append(((LogListBlock) val).getOutput(prefix + "    "));
-            } else {
-                out.append(prefix);
-                out.append(padKey(entry.getKey(), maxKeyLength));
-                out.append(": ");
-                out.append(val.toString());
-                out.append("\r\n");
-            }
-        }
-        return out.toString();
-    }
-    
-    @Override
-    public String toString() {
-        return getOutput("");
-    }
-
-}
@@ -1,134 +0,0 @@
-/*
- * WorldGuard, a suite of tools for Minecraft
- * Copyright (C) sk89q <http://www.sk89q.com>
- * Copyright (C) WorldGuard team and contributors
- *
- * This program is free software: you can redistribute it and/or modify it
- * under the terms of the GNU Lesser General Public License as published by the
- * Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License
- * for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-package com.sk89q.worldguard.util;
-
-import java.io.BufferedReader;
-import java.io.IOException;
-import java.io.InputStream;
-import java.io.InputStreamReader;
-import java.io.OutputStream;
-import java.net.HttpURLConnection;
-import java.net.URL;
-import java.net.URLEncoder;
-
-public final class PastebinPoster {
-    private static final int CONNECT_TIMEOUT = 5000;
-    private static final int READ_TIMEOUT = 5000;
-
-    private PastebinPoster() {
-    }
-
-    public static void paste(String code, PasteCallback callback) {
-        PasteProcessor processor = new PasteProcessor(code, callback);
-        Thread thread = new Thread(processor);
-        thread.start();
-    }
-    
-    public static interface PasteCallback {
-        public void handleSuccess(String url);
-        public void handleError(String err);
-    }
-    
-    private static class PasteProcessor implements Runnable {
-        private String code;
-        private PasteCallback callback;
-        
-        public PasteProcessor(String code, PasteCallback callback) {
-            this.code = code;
-            this.callback = callback;
-        }
-        
-        public void run() {
-            HttpURLConnection conn = null;
-            OutputStream out = null; 
-            InputStream in = null;
-            
-            try {
-                URL url = new URL("http://pastebin.com/api/api_post.php");
-                conn = (HttpURLConnection) url.openConnection();
-                conn.setConnectTimeout(CONNECT_TIMEOUT);
-                conn.setReadTimeout(READ_TIMEOUT);
-                conn.setRequestMethod("POST");
-                conn.addRequestProperty("Content-type",
-                        "application/x-www-form-urlencoded");
-                conn.setInstanceFollowRedirects(false);
-                conn.setDoOutput(true);
-                out = conn.getOutputStream();
-                
-                out.write(("api_option=paste"
-                        + "&api_dev_key=" + URLEncoder.encode("4867eae74c6990dbdef07c543cf8f805", "utf-8")
-                        + "&api_paste_code=" + URLEncoder.encode(code, "utf-8")
-                        + "&api_paste_private=" + URLEncoder.encode("0", "utf-8")
-                        + "&api_paste_name=" + URLEncoder.encode("", "utf-8")
-                        + "&api_paste_expire_date=" + URLEncoder.encode("1D", "utf-8")
-                        + "&api_paste_format=" + URLEncoder.encode("text", "utf-8")
-                        + "&api_user_key=" + URLEncoder.encode("", "utf-8")).getBytes());
-                out.flush();
-                out.close();
-                
-                if (conn.getResponseCode() == 200) {//Get Response        
-                    in = conn.getInputStream();
-                    BufferedReader reader = new BufferedReader(new InputStreamReader(in));
-                    String line;
-                    StringBuilder response = new StringBuilder();
-                    while ((line = reader.readLine()) != null) {
-                        response.append(line);
-                        response.append("\r\n");
-                    }
-                    reader.close();
-                    
-                    String result = response.toString().trim();
-                    
-                    if (result.matches("^https?://.*")) {
-                        callback.handleSuccess(result.trim());
-                    } else {
-                        String err =result.trim();
-                        if (err.length() > 100) {
-                            err = err.substring(0, 100);
-                        }
-                        callback.handleError(err);
-                    }
-                } else {
-                    callback.handleError("didn't get a 200 response code!");
-                }
-            } catch (IOException e) {
-                callback.handleError(e.getMessage());
-            } finally {
-                if (conn != null) {
-                    conn.disconnect();
-                }
-                if (in != null) {
-                    try {
-                        in.close();
-                    } catch (IOException ignored) {
-                    }
-                }
-                if (out != null) {
-                    try {
-                        out.close();
-                    } catch (IOException ignored) {
-                    }
-                }
-            }
-        }
-        
-    }
-    
-}
@@ -1,74 +0,0 @@
-/*
- * WorldGuard, a suite of tools for Minecraft
- * Copyright (C) sk89q <http://www.sk89q.com>
- * Copyright (C) WorldGuard team and contributors
- *
- * This program is free software: you can redistribute it and/or modify it
- * under the terms of the GNU Lesser General Public License as published by the
- * Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License
- * for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-package com.sk89q.worldguard.util.task;
-
-import com.google.common.util.concurrent.AbstractFuture;
-
-import javax.annotation.Nullable;
-import java.util.Date;
-import java.util.UUID;
-
-import static com.google.common.base.Preconditions.checkNotNull;
-
-/**
- * An abstract task that stores a name and owner.
- *
- * @param <V> the type returned
- */
-public abstract class AbstractTask<V> extends AbstractFuture<V> implements Task<V> {
-
-    private final UUID uniqueId = UUID.randomUUID();
-    private final String name;
-    private final Object owner;
-    private final Date creationDate = new Date();
-
-    /**
-     * Create a new instance.
-     *
-     * @param name the name
-     * @param owner the owner
-     */
-    protected AbstractTask(String name, @Nullable Object owner) {
-        checkNotNull(name);
-        this.name = name;
-        this.owner = owner;
-    }
-
-    @Override
-    public UUID getUniqueId() {
-        return uniqueId;
-    }
-
-    @Override
-    public String getName() {
-        return name;
-    }
-
-    @Nullable
-    @Override
-    public Object getOwner() {
-        return owner;
-    }
-
-    @Override
-    public Date getCreationDate() {
-        return creationDate;
-    }
-}
@@ -1,121 +0,0 @@
-/*
- * WorldGuard, a suite of tools for Minecraft
- * Copyright (C) sk89q <http://www.sk89q.com>
- * Copyright (C) WorldGuard team and contributors
- *
- * This program is free software: you can redistribute it and/or modify it
- * under the terms of the GNU Lesser General Public License as published by the
- * Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License
- * for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-package com.sk89q.worldguard.util.task;
-
-import com.google.common.util.concurrent.ListenableFuture;
-import com.sk89q.worldguard.util.task.progress.Progress;
-
-import javax.annotation.Nullable;
-import java.util.concurrent.ExecutionException;
-import java.util.concurrent.Executor;
-import java.util.concurrent.TimeUnit;
-import java.util.concurrent.TimeoutException;
-
-import static com.google.common.base.Preconditions.checkNotNull;
-
-/**
- * A task that wraps a {@code ListenableFuture}.
- *
- * <p>{@link State#SCHEDULED} is never returned because it is not possible
- * to test whether the future has "started," so {@link State#RUNNING} is
- * returned in its place.</p>
- *
- * <p>Use {@link #create(ListenableFuture, String, Object)} to create a new
- * instance.</p>
- *
- * @param <V> the type returned
- */
-public class FutureForwardingTask<V> extends AbstractTask<V> {
-
-    private final ListenableFuture<V> future;
-
-    private FutureForwardingTask(ListenableFuture<V> future, String name, @Nullable Object owner) {
-        super(name, owner);
-        checkNotNull(future);
-        this.future = future;
-    }
-
-    @Override
-    public void addListener(Runnable listener, Executor executor) {
-        future.addListener(listener, executor);
-    }
-
-    @Override
-    public boolean cancel(boolean mayInterruptIfRunning) {
-        return future.cancel(mayInterruptIfRunning);
-    }
-
-    @Override
-    public boolean isCancelled() {
-        return future.isCancelled();
-    }
-
-    @Override
-    public boolean isDone() {
-        return future.isDone();
-    }
-
-    @Override
-    public V get() throws InterruptedException, ExecutionException {
-        return future.get();
-    }
-
-    @Override
-    public V get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException {
-        return future.get(timeout, unit);
-    }
-
-    @Override
-    public State getState() {
-        if (isCancelled()) {
-            return State.CANCELLED;
-        } else if (isDone()) {
-            try {
-                get();
-                return State.SUCCEEDED;
-            } catch (InterruptedException e) {
-                return State.CANCELLED;
-            } catch (ExecutionException e) {
-                return State.FAILED;
-            }
-        } else {
-            return State.RUNNING;
-        }
-    }
-
-    @Override
-    public Progress getProgress() {
-        return Progress.indeterminate();
-    }
-
-    /**
-     * Create a new instance.
-     *
-     * @param future the future
-     * @param name the name of the task
-     * @param owner the owner of the task, or {@code null}
-     * @param <V> the type returned by the future
-     * @return a new instance
-     */
-    public static <V> com.sk89q.worldguard.util.task.FutureForwardingTask<V> create(ListenableFuture<V> future, String name, @Nullable Object owner) {
-        return new com.sk89q.worldguard.util.task.FutureForwardingTask<V>(future, name, owner);
-    }
-
-}
@@ -1,62 +0,0 @@
-/*
- * WorldGuard, a suite of tools for Minecraft
- * Copyright (C) sk89q <http://www.sk89q.com>
- * Copyright (C) WorldGuard team and contributors
- *
- * This program is free software: you can redistribute it and/or modify it
- * under the terms of the GNU Lesser General Public License as published by the
- * Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License
- * for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-package com.sk89q.worldguard.util.task;
-
-import com.google.common.util.concurrent.MoreExecutors;
-
-import java.util.ArrayList;
-import java.util.List;
-
-import static com.google.common.base.Preconditions.checkNotNull;
-
-/**
- * An implementation of a {@code Supervisor}.
- */
-public class SimpleSupervisor implements Supervisor {
-
-    private final List<Task<?>> monitored = new ArrayList<Task<?>>();
-    private final Object lock = new Object();
-
-    @Override
-    public List<Task<?>> getTasks() {
-        synchronized (lock) {
-            return new ArrayList<Task<?>>(monitored);
-        }
-    }
-
-    @Override
-    public void monitor(final Task<?> task) {
-        checkNotNull(task);
-
-        synchronized (lock) {
-            monitored.add(task);
-        }
-
-        task.addListener(new Runnable() {
-            @Override
-            public void run() {
-                synchronized (lock) {
-                    monitored.remove(task);
-                }
-            }
-        }, MoreExecutors.sameThreadExecutor());
-    }
-
-}
@@ -1,97 +0,0 @@
-/*
- * WorldGuard, a suite of tools for Minecraft
- * Copyright (C) sk89q <http://www.sk89q.com>
- * Copyright (C) WorldGuard team and contributors
- *
- * This program is free software: you can redistribute it and/or modify it
- * under the terms of the GNU Lesser General Public License as published by the
- * Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License
- * for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-package com.sk89q.worldguard.util.task;
-
-import com.google.common.util.concurrent.ListenableFuture;
-import com.sk89q.worldguard.util.task.progress.ProgressObservable;
-
-import javax.annotation.Nullable;
-import java.util.Date;
-import java.util.UUID;
-
-/**
- * A task is a job that can be scheduled, run, or cancelled. Tasks can report
- * on their own status. Tasks have owners.
- */
-public interface Task<V> extends ListenableFuture<V>, ProgressObservable {
-
-    /**
-     * Get the unique ID of this task.
-     *
-     * @return this task's unique ID
-     */
-    UUID getUniqueId();
-
-    /**
-     * Get the name of the task so it can be printed to the user.
-     *
-     * @return the name of the task
-     */
-    String getName();
-
-    /**
-     * Get the owner of the task.
-     *
-     * @return an owner object, if one is known or valid, otherwise {@code null}
-     */
-    @Nullable
-    Object getOwner();
-
-    /**
-     * Get the state of the task.
-     *
-     * @return the state of the task
-     */
-    State getState();
-
-    /**
-     * Get the time at which the task was created.
-     *
-     * @return a date
-     */
-    Date getCreationDate();
-
-    /**
-     * Represents the state of a task.
-     */
-    public enum State {
-        /**
-         * The task has been scheduled to run but is not running yet.
-         */
-        SCHEDULED,
-        /**
-         * The task has been cancelled and may be stopped or will stop.
-         */
-        CANCELLED,
-        /**
-         * The task is currently running.
-         */
-        RUNNING,
-        /**
-         * The task has failed.
-         */
-        FAILED,
-        /**
-         * The task has succeeded.
-         */
-        SUCCEEDED
-    }
-
-}
@@ -1,183 +0,0 @@
-/*
- * WorldGuard, a suite of tools for Minecraft
- * Copyright (C) sk89q <http://www.sk89q.com>
- * Copyright (C) WorldGuard team and contributors
- *
- * This program is free software: you can redistribute it and/or modify it
- * under the terms of the GNU Lesser General Public License as published by the
- * Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License
- * for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-package com.sk89q.worldguard.util.task.progress;
-
-import java.util.Arrays;
-import java.util.Collection;
-
-/**
- * A progress object describes the progress of an operation, specifying
- * either a percentage of completion or a status of indeterminacy.
- *
- * <p>Progress objects are immutable.</p>
- *
- * <p>To create a new instance, use one of the static constructors
- * on this class.</p>
- */
-public abstract class Progress {
-
-    /**
-     * Create a new instance.
-     */
-    private Progress() {
-    }
-
-    /**
-     * Return whether the current progress is indeterminate.
-     *
-     * @return true if indeterminate
-     */
-    public abstract boolean isIndeterminate();
-
-    /**
-     * Get the progress percentage.
-     *
-     * <p>If {@link #isIndeterminate()} returns {@code true}, the behavior
-     * of this method is undefined.</p>
-     *
-     * @return a number in the range [0, 1]
-     */
-    public abstract double getProgress();
-
-    /**
-     * Get a static progress object that is indeterminate.
-     *
-     * @return a progress object
-     */
-    public static com.sk89q.worldguard.util.task.progress.Progress indeterminate() {
-        return INDETERMINATE;
-    }
-
-    /**
-     * Get a static progress object that is complete.
-     *
-     * @return a progress object
-     */
-    public static com.sk89q.worldguard.util.task.progress.Progress completed() {
-        return COMPLETED;
-    }
-
-    /**
-     * Create a new progress object with the given percentage.
-     *
-     * @param value the percentage, which will be clamped to [0, 1]
-     * @return a progress object
-     */
-    public static com.sk89q.worldguard.util.task.progress.Progress of(double value) {
-        if (value < 0) {
-            value = 0;
-        } else if (value > 1) {
-            value = 1;
-        }
-
-        final double finalValue = value;
-        return new com.sk89q.worldguard.util.task.progress.Progress() {
-            @Override
-            public boolean isIndeterminate() {
-                return false;
-            }
-
-            @Override
-            public double getProgress() {
-                return finalValue;
-            }
-        };
-    }
-
-    /**
-     * Create a new progress object with progress split equally between the
-     * given progress objects.
-     *
-     * @param objects an array of progress objects
-     * @return a new progress value
-     */
-    public static com.sk89q.worldguard.util.task.progress.Progress split(com.sk89q.worldguard.util.task.progress.Progress... objects) {
-        return split(Arrays.asList(objects));
-    }
-
-    /**
-     * Create a new progress object with progress split equally between the
-     * given progress objects.
-     *
-     * @param progress a collection of progress objects
-     * @return a new progress value
-     */
-    public static com.sk89q.worldguard.util.task.progress.Progress split(Collection<com.sk89q.worldguard.util.task.progress.Progress> progress) {
-        int count = 0;
-        double total = 0;
-
-        for (com.sk89q.worldguard.util.task.progress.Progress p : progress) {
-            if (p.isIndeterminate()) {
-                return indeterminate();
-            }
-            total += p.getProgress();
-        }
-
-        return of(total / count);
-    }
-
-    /**
-     * Create a new progress object with progress split equally between the
-     * given {@link com.sk89q.worldguard.util.task.progress.ProgressObservable}s.
-     *
-     * @param observables an array of observables
-     * @return a new progress value
-     */
-    public static com.sk89q.worldguard.util.task.progress.Progress splitObservables(com.sk89q.worldguard.util.task.progress.ProgressObservable... observables) {
-        return splitObservables(Arrays.asList(observables));
-    }
-
-    /**
-     * Create a new progress object with progress split equally between the
-     * given {@link com.sk89q.worldguard.util.task.progress.ProgressObservable}s.
-     *
-     * @param observables a collection of observables
-     * @return a new progress value
-     */
-    public static com.sk89q.worldguard.util.task.progress.Progress splitObservables(Collection<? extends com.sk89q.worldguard.util.task.progress.ProgressObservable> observables) {
-        int count = 0;
-        double total = 0;
-
-        for (ProgressObservable observable : observables) {
-            com.sk89q.worldguard.util.task.progress.Progress p = observable.getProgress();
-            if (p.isIndeterminate()) {
-                return indeterminate();
-            }
-            total += p.getProgress();
-        }
-
-        return of(total / count);
-    }
-
-    private static final com.sk89q.worldguard.util.task.progress.Progress COMPLETED = of(1);
-
-    private static final com.sk89q.worldguard.util.task.progress.Progress INDETERMINATE = new com.sk89q.worldguard.util.task.progress.Progress() {
-        @Override
-        public boolean isIndeterminate() {
-            return true;
-        }
-
-        @Override
-        public double getProgress() {
-            return 0;
-        }
-    };
-
-}
@@ -1,100 +0,0 @@
-/*
- * WorldGuard, a suite of tools for Minecraft
- * Copyright (C) sk89q <http://www.sk89q.com>
- * Copyright (C) WorldGuard team and contributors
- *
- * This program is free software: you can redistribute it and/or modify it
- * under the terms of the GNU Lesser General Public License as published by the
- * Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License
- * for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-package com.sk89q.worldguard.util.task.progress;
-
-import java.util.Iterator;
-import java.util.List;
-
-import static com.google.common.base.Preconditions.checkNotNull;
-
-/**
- * An iterator that keeps track of how many entries have been visited and
- * calculates a "percent completed" using a provided total count.
- *
- * <p>The returned progress percentage will always be between 0 or 1
- * (inclusive). If the iterator returns more entries than the total count,
- * then 100% will be returned for the progress.</p>
- *
- * @param <V> the type
- */
-public class ProgressIterator<V> implements Iterator<V>, ProgressObservable {
-
-    private final Iterator<V> iterator;
-    private final int count;
-    private int visited = 0;
-
-    /**
-     * Create a new instance.
-     *
-     * @param iterator the iterator
-     * @param count the count
-     */
-    private ProgressIterator(Iterator<V> iterator, int count) {
-        checkNotNull(iterator);
-        this.iterator = iterator;
-        this.count = count;
-    }
-
-    @Override
-    public boolean hasNext() {
-        return iterator.hasNext();
-    }
-
-    @Override
-    public V next() {
-        V value = iterator.next();
-        visited++;
-        return value;
-    }
-
-    @Override
-    public void remove() {
-        iterator.remove();
-    }
-
-    @Override
-    public Progress getProgress() {
-        return Progress.of(count > 0 ? Math.min(1, Math.max(0, (visited / (double) count))) : 1);
-    }
-
-    /**
-     * Create a new instance.
-     *
-     * @param iterator the iterator
-     * @param count the number of objects
-     * @param <V> the type
-     * @return an instance
-     */
-    public static <V> com.sk89q.worldguard.util.task.progress.ProgressIterator<V> create(Iterator<V> iterator, int count) {
-        return new com.sk89q.worldguard.util.task.progress.ProgressIterator<V>(iterator, count);
-    }
-
-    /**
-     * Create a new instance from a list.
-     *
-     * @param list a list
-     * @param <V> the type
-     * @return an instance
-     */
-    public static <V> com.sk89q.worldguard.util.task.progress.ProgressIterator<V> create(List<V> list) {
-        return create(list.iterator(), list.size());
-    }
-
-}
@@ -1,4 +0,0 @@
-name: WorldGuard
-main: com.sk89q.worldguard.bukkit.WorldGuardPlugin
-version: "${project.version}"
-softdepend: [WorldEdit, CommandBook]
@@ -1,87 +0,0 @@
-/*
- * WorldGuard, a suite of tools for Minecraft
- * Copyright (C) sk89q <http://www.sk89q.com>
- * Copyright (C) WorldGuard team and contributors
- *
- * This program is free software: you can redistribute it and/or modify it
- * under the terms of the GNU Lesser General Public License as published by the
- * Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License
- * for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-package com.sk89q.worldguard;
-
-import com.sk89q.worldedit.Vector;
-
-import java.util.HashSet;
-import java.util.Set;
-import java.util.UUID;
-
-@org.junit.Ignore
-public class TestPlayer extends LocalPlayer {
-
-    private final UUID uuid = UUID.randomUUID();
-    private final String name;
-    private final Set<String> groups = new HashSet<String>();
-    
-    public TestPlayer(String name) {
-        this.name = name;
-    }
-    
-    public void addGroup(String group) {
-        groups.add(group.toLowerCase());
-    }
-
-    @Override
-    public String getName() {
-        return name;
-    }
-
-    @Override
-    public UUID getUniqueId() {
-        return uuid;
-    }
-
-    @Override
-    public boolean hasGroup(String group) {
-        return groups.contains(group.toLowerCase());
-    }
-
-    @Override
-    public Vector getPosition() {
-        return new Vector(0, 0, 0);
-    }
-
-    @Override
-    public void kick(String msg) {
-        System.out.println("TestPlayer{" + this.name + "} kicked!");
-    }
-
-    @Override
-    public void ban(String msg) {
-        System.out.println("TestPlayer{" + this.name + "} banned!");
-    }
-
-    @Override
-    public void printRaw(String msg) {
-        System.out.println("-> TestPlayer{" + this.name + "}: " + msg);
-    }
-
-    @Override
-    public String[] getGroups() {
-        return groups.toArray(new String[groups.size()]);
-    }
-
-    @Override
-    public boolean hasPermission(String perm) {
-        return true;
-    }
-}
@@ -1,181 +0,0 @@
-/*
- * WorldGuard, a suite of tools for Minecraft
- * Copyright (C) sk89q <http://www.sk89q.com>
- * Copyright (C) WorldGuard team and contributors
- *
- * This program is free software: you can redistribute it and/or modify it
- * under the terms of the GNU Lesser General Public License as published by the
- * Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License
- * for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-package com.sk89q.worldguard.protection;
-
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
-
-import java.util.ArrayList;
-import java.util.HashSet;
-
-import org.junit.Before;
-import org.junit.Test;
-
-import com.sk89q.worldedit.BlockVector;
-import com.sk89q.worldedit.BlockVector2D;
-import com.sk89q.worldedit.Vector;
-import com.sk89q.worldguard.TestPlayer;
-import com.sk89q.worldguard.domains.DefaultDomain;
-import com.sk89q.worldguard.protection.flags.DefaultFlag;
-import com.sk89q.worldguard.protection.flags.StateFlag;
-import com.sk89q.worldguard.protection.managers.RegionManager;
-import com.sk89q.worldguard.protection.regions.GlobalProtectedRegion;
-import com.sk89q.worldguard.protection.regions.ProtectedCuboidRegion;
-import com.sk89q.worldguard.protection.regions.ProtectedPolygonalRegion;
-import com.sk89q.worldguard.protection.regions.ProtectedRegion;
-
-public abstract class RegionOverlapTest {
-    static String COURTYARD_ID = "courtyard";
-    static String FOUNTAIN_ID = "fountain";
-    static String NO_FIRE_ID = "nofire";
-    static String MEMBER_GROUP = "member";
-    static String COURTYARD_GROUP = "courtyard";
-
-    Vector inFountain = new Vector(2, 2, 2);
-    Vector inCourtyard = new Vector(7, 7, 7);
-    Vector outside = new Vector(15, 15, 15);
-    Vector inNoFire = new Vector(150, 150, 150);
-    RegionManager manager;
-    ProtectedRegion globalRegion;
-    ProtectedRegion courtyard;
-    ProtectedRegion fountain;
-    TestPlayer player1;
-    TestPlayer player2;
-    
-    protected abstract RegionManager createRegionManager() throws Exception;
-
-    @Before
-    public void setUp() throws Exception {
-        setUpGlobalRegion();
-        
-        manager = createRegionManager();
-
-        setUpPlayers();
-        setUpCourtyardRegion();
-        setUpFountainRegion();
-        setUpNoFireRegion();
-    }
-
-    void setUpPlayers() {
-        player1 = new TestPlayer("tetsu");
-        player1.addGroup(MEMBER_GROUP);
-        player1.addGroup(COURTYARD_GROUP);
-
-        player2 = new TestPlayer("alex");
-        player2.addGroup(MEMBER_GROUP);
-    }
-
-    void setUpGlobalRegion() {
-        globalRegion = new GlobalProtectedRegion("__global__");
-    }
-
-    void setUpCourtyardRegion() {
-        DefaultDomain domain = new DefaultDomain();
-        domain.addGroup(COURTYARD_GROUP);
-
-        ArrayList<BlockVector2D> points = new ArrayList<BlockVector2D>();
-        points.add(new BlockVector2D(0, 0));
-        points.add(new BlockVector2D(10, 0));
-        points.add(new BlockVector2D(10, 10));
-        points.add(new BlockVector2D(0, 10));
-
-        //ProtectedRegion region = new ProtectedCuboidRegion(COURTYARD_ID, new BlockVector(0, 0, 0), new BlockVector(10, 10, 10));
-        ProtectedRegion region = new ProtectedPolygonalRegion(COURTYARD_ID, points, 0, 10);
-
-        region.setOwners(domain);
-        manager.addRegion(region);
-
-        courtyard = region;
-    }
-
-    void setUpFountainRegion() throws Exception {
-        DefaultDomain domain = new DefaultDomain();
-        domain.addGroup(MEMBER_GROUP);
-
-        ProtectedRegion region = new ProtectedCuboidRegion(FOUNTAIN_ID,
-                new BlockVector(0, 0, 0), new BlockVector(5, 5, 5));
-        region.setMembers(domain);
-        manager.addRegion(region);
-
-        fountain = region;
-        fountain.setParent(courtyard);
-        fountain.setFlag(DefaultFlag.FIRE_SPREAD, StateFlag.State.DENY);
-    }
-
-    void setUpNoFireRegion() throws Exception {
-        ProtectedRegion region = new ProtectedCuboidRegion(NO_FIRE_ID,
-                new BlockVector(100, 100, 100), new BlockVector(200, 200, 200));
-        manager.addRegion(region);
-        region.setFlag(DefaultFlag.FIRE_SPREAD, StateFlag.State.DENY);
-    }
-
-    @Test
-    public void testNonBuildFlag() {
-        ApplicableRegionSet appl;
-
-        // Outside
-        appl = manager.getApplicableRegions(outside);
-        assertTrue(appl.allows(DefaultFlag.FIRE_SPREAD));
-        // Inside courtyard
-        appl = manager.getApplicableRegions(inCourtyard);
-        assertTrue(appl.allows(DefaultFlag.FIRE_SPREAD));
-        // Inside fountain
-        appl = manager.getApplicableRegions(inFountain);
-        assertFalse(appl.allows(DefaultFlag.FIRE_SPREAD));
-
-        // Inside no fire zone
-        appl = manager.getApplicableRegions(inNoFire);
-        assertFalse(appl.allows(DefaultFlag.FIRE_SPREAD));
-    }
-
-    @Test
-    public void testPlayer1BuildAccess() {
-        ApplicableRegionSet appl;
-
-        // Outside
-        appl = manager.getApplicableRegions(outside);
-        assertTrue(appl.canBuild(player1));
-        // Inside courtyard
-        appl = manager.getApplicableRegions(inCourtyard);
-        assertTrue(appl.canBuild(player1));
-        // Inside fountain
-        appl = manager.getApplicableRegions(inFountain);
-        assertTrue(appl.canBuild(player1));
-    }
-
-    @Test
-    public void testPlayer2BuildAccess() {
-        ApplicableRegionSet appl;
-
-        HashSet<ProtectedRegion> test = new HashSet<ProtectedRegion>();
-        test.add(courtyard);
-        test.add(fountain);
-
-        // Outside
-        appl = manager.getApplicableRegions(outside);
-        assertTrue(appl.canBuild(player2));
-        // Inside courtyard
-        appl = manager.getApplicableRegions(inCourtyard);
-        assertFalse(appl.canBuild(player2));
-        // Inside fountain
-        appl = manager.getApplicableRegions(inFountain);
-        assertTrue(appl.canBuild(player2));
-    }
-}
@@ -0,0 +1,68 @@
+import com.github.jengelman.gradle.plugins.shadow.tasks.ShadowJar
+
+plugins {
+    `java-library`
+    id("buildlogic.platform")
+}
+
+val localImplementation = configurations.create("localImplementation") {
+    description = "Dependencies used locally, but provided by the runtime Bukkit implementation"
+    isCanBeConsumed = false
+    isCanBeResolved = false
+}
+configurations["compileOnly"].extendsFrom(localImplementation)
+configurations["testImplementation"].extendsFrom(localImplementation)
+
+dependencies {
+    "api"(project(":worldguard-core"))
+    "api"(libs.worldedit.bukkit) { isTransitive = false }
+    "compileOnly"(libs.commandbook) { isTransitive = false }
+    // Technically this is api, but everyone should already have some form of the bukkit API
+    // Avoid pulling in another one, especially one so outdated.
+    "localImplementation"(libs.spigot) {
+        exclude("junit", "junit")
+    }
+
+    "compileOnly"(libs.jetbrains.annotations) {
+        because("Resolving Spigot annotations")
+    }
+    "testCompileOnly"(libs.jetbrains.annotations) {
+        because("Resolving Spigot annotations")
+    }
+    "compileOnly"(libs.paperApi) {
+        exclude("org.slf4j", "slf4j-api")
+        exclude("junit", "junit")
+    }
+
+    "implementation"(libs.paperLib)
+    "implementation"(libs.bstats.bukkit)
+}
+
+tasks.named<Copy>("processResources") {
+    val internalVersion = project.ext["internalVersion"]
+    inputs.property("internalVersion", internalVersion)
+    filesMatching("plugin.yml") {
+        expand("internalVersion" to internalVersion)
+    }
+}
+
+tasks.named<ShadowJar>("shadowJar") {
+    dependencies {
+        include(dependency(":worldguard-core"))
+        include(dependency("org.bstats:"))
+        include(dependency("io.papermc:paperlib"))
+
+        relocate("org.bstats", "com.sk89q.worldguard.bukkit.bstats")
+        relocate("io.papermc.lib", "com.sk89q.worldguard.bukkit.paperlib")
+    }
+}
+
+tasks.named("assemble").configure {
+    dependsOn("shadowJar")
+}
+
+configure<PublishingExtension> {
+    publications.named<MavenPublication>("maven") {
+        from(components["java"])
+    }
+}