Bump to 7.0.0. Rename -legacy to -bukkit.

fix syntax

.gitattributes

@@ -1,2 +1,2 @@
-*.java   diff=java
-
+*.java   diff=java
+

.gitignore

@@ -1,17 +1,17 @@
-/.classpath
-/.project
-/.settings
-/target
+.classpath
+.project
+.settings/
+target/
 
 .DS_Store
 
 **/*.iml
 **/.idea
 
-/bin
-/dependency-reduced-pom.xml
+bin/
+dependency-reduced-pom.xml
 *-private.sh
 
-/.gradle
-**/build
-
+.gradle/
+**/build/
+out/

CHANGELOG.md

@@ -1,5 +1,44 @@
 # Changelog
 
+## 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`).

CONTRIBUTING.md

@@ -4,7 +4,7 @@ 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

LICENSE.txt

@@ -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.

README.md

@@ -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
-[Gradle](http://gradle.org). Detailed compilation information
-[can be found on the wiki](http://wiki.sk89q.com/wiki/WorldGuard/Development#Compiling).
-
-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](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)
+# ![WorldGuard](worldguard-logo.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 8 and our build process makes use of
+[Gradle](http://gradle.org). Detailed compilation information
+[can be found on the wiki](http://wiki.sk89q.com/wiki/WorldGuard/Development#Compiling).
+
+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](http://enginehub.org/worldguard)
+* [Discord](https://discord.gg/enginehub)
+* [IRC channel](https://webchat.esper.net/?join=sk89q) (#sk89q on irc.esper.net)
+* [Issue tracker](https://dev.enginehub.org/issues/WORLDGUARD)
+* [Continuous integration](http://builds.enginehub.org) [![Build Status](https://travis-ci.org/EngineHub/WorldGuard.svg?branch=master)](https://travis-ci.org/EngineHub/WorldGuard)
+* [End-user documentation](https://worldguard.readthedocs.io/en/latest/) / [Older Wiki](http://wiki.sk89q.com/wiki/WorldGuard)

build.gradle

@@ -21,17 +21,22 @@ buildscript {
 
     configurations.all {
         resolutionStrategy {
-            force 'com.google.guava:guava:17.0'
+            force 'com.google.guava:guava:21.0'
         }
     }
 
     dependencies {
-        classpath 'com.github.jengelman.gradle.plugins:shadow:1.2.1'
-        classpath 'org.jfrog.buildinfo:build-info-extractor-gradle:3.0.1'
-        classpath 'org.ajoberstar:gradle-git:0.12.0'
+        classpath "com.github.jengelman.gradle.plugins:shadow:4.0.3"
+        classpath 'org.jfrog.buildinfo:build-info-extractor-gradle:4.7.5'
+        classpath 'org.ajoberstar:gradle-git:1.7.2'
     }
 }
 
+allprojects {
+    group = 'com.sk89q.worldguard'
+    version = '7.0.0'
+}
+
 if (!project.hasProperty("artifactory_contextUrl")) ext.artifactory_contextUrl = "http://localhost"
 if (!project.hasProperty("artifactory_user")) ext.artifactory_user = "guest"
 if (!project.hasProperty("artifactory_password")) ext.artifactory_password = ""
@@ -45,28 +50,44 @@ if (!project.hasProperty("gitCommitHash")) {
     }
 }
 
+apply plugin: 'com.jfrog.artifactory'
+artifactory {
+    contextUrl = "${artifactory_contextUrl}"
+    publish {
+        repository {
+            repoKey = project.version.contains("SNAPSHOT") ? 'libs-snapshot-local' : 'libs-release-local'
+            username = "${artifactory_user}"
+            password = "${artifactory_password}"
+            maven = true
+
+        }
+    }
+}
+artifactoryPublish.skip = true
+
 subprojects {
     apply plugin: 'java'
+    apply plugin: 'java-library'
     apply plugin: 'maven'
     apply plugin: 'checkstyle'
     apply plugin: 'com.github.johnrengelman.shadow'
-    apply plugin: 'com.jfrog.artifactory-upload'
+    apply plugin: 'com.jfrog.artifactory'
 
-    group = 'com.sk89q.worldguard'
-    version = '7.0.0-SNAPSHOT'
     ext.internalVersion = version + ";" + gitCommitHash
 
-    sourceCompatibility = 1.8
-    targetCompatibility = 1.8
+    sourceCompatibility = JavaVersion.VERSION_1_8
+    targetCompatibility = JavaVersion.VERSION_1_8
 
     checkstyle.configFile = new File(rootProject.projectDir, "config/checkstyle/checkstyle.xml")
+    checkstyle.toolVersion = '7.6.1'
 
     repositories {
+        mavenLocal()
         mavenCentral()
-        maven { url "http://repo.spongepowered.org/maven/" }
+        maven { url "https://repo.spongepowered.org/maven/" }
         maven { url "https://hub.spigotmc.org/nexus/content/groups/public" }
-        maven { url "http://maven.sk89q.com/repo/" }
-        maven { url "http://repo.maven.apache.org/maven2" }
+        maven { url "https://maven.sk89q.com/repo/" }
+        maven { url "https://repo.maven.apache.org/maven2" }
     }
 
     if (JavaVersion.current().isJava8Compatible()) {
@@ -101,31 +122,15 @@ subprojects {
         classifier 'dist'
         dependencies {
             include(dependency('org.khelekore:prtree:1.5.0'))
+            include(dependency('com.sk89q:squirrelid:0.2.0'))
+            include(dependency('org.flywaydb:flyway-core:3.0'))
         }
         exclude 'GradleStart**'
         exclude '.cache'
         exclude 'LICENSE*'
     }
 
-    artifactory {
-        contextUrl = "${artifactory_contextUrl}"
-        publish {
-            repository {
-                repoKey = project.version.contains("SNAPSHOT") ? 'libs-snapshot-local' : 'libs-release-local'
-                username = "${artifactory_user}"
-                password = "${artifactory_password}"
-                maven = true
-                
-            }
-        }
-
-        resolve {
-            repository {
-                repoKey = 'repo'
-                username = "${artifactory_user}"
-                password = "${artifactory_password}"
-                maven = true
-            }
-        }
+    artifactoryPublish {
+        publishConfigs('archives')
     }
 }

config/checkstyle/checkstyle.xml

@@ -1,22 +1,26 @@
 <?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">
+        "-//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="${basedir}/config/checkstyle/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 WE where it shouldn't belong, etc.
+    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/checkstyle/import-control.xml"/>
+      <property name="file" value="${basedir}/config/checkstyle/import-control.xml"/>
     </module>
 
     <!-- Code -->
@@ -27,7 +31,6 @@
       <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 -->
@@ -58,7 +61,7 @@
   <!-- 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="config/checkstyle/header.txt"/>
+    <property name="headerFile" value="${basedir}/config/checkstyle/header.txt"/>
     <property name="fileExtensions" value="java"/>
   </module>
 </module>

config/checkstyle/import-control.xml

@@ -8,20 +8,25 @@
   <allow pkg="org.junit"/>
   <allow pkg="org.hamcrest"/>
   <allow pkg="org.mockito"/>
+  <allow pkg="junit.framework"/>
   <allow pkg="com.sk89q"/>
   <allow pkg="com.google.common"/>
 
   <subpackage name="worldguard">
     <allow pkg="org.khelekore"/>
     <allow pkg="org.flywaydb"/>
+    <allow pkg="org.yaml"/>
+    <allow pkg="org.json"/>
+    <allow pkg="org.enginehub.piston"/>
 
     <subpackage name="bukkit">
       <allow pkg="org.bukkit"/>
-      <allow pkg="net.minecraft.server"/>
+      <allow pkg="org.bstats.bukkit"/>
     </subpackage>
 
     <subpackage name="sponge">
       <allow pkg="org.spongepowered"/>
+      <allow pkg="org.bstats.sponge"/>
       <allow pkg="com.flowpowered"/>
     </subpackage>
 

config/checkstyle/suppressions.xml

@@ -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>

gradle/wrapper/gradle-wrapper.properties

@@ -1,6 +1,5 @@
-#Fri Nov 13 12:12:21 EST 2015
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
+distributionUrl=https\://services.gradle.org/distributions/gradle-5.0-bin.zip
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-2.0-bin.zip

gradlew

@@ -1,4 +1,4 @@
-#!/usr/bin/env bash
+#!/usr/bin/env sh
 
 ##############################################################################
 ##
@@ -6,47 +6,6 @@
 ##
 ##############################################################################
 
-# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
-DEFAULT_JVM_OPTS=""
-
-APP_NAME="Gradle"
-APP_BASE_NAME=`basename "$0"`
-
-# Use the maximum available, or set MAX_FD != -1 to use that value.
-MAX_FD="maximum"
-
-warn ( ) {
-    echo "$*"
-}
-
-die ( ) {
-    echo
-    echo "$*"
-    echo
-    exit 1
-}
-
-# OS specific support (must be 'true' or 'false').
-cygwin=false
-msys=false
-darwin=false
-case "`uname`" in
-  CYGWIN* )
-    cygwin=true
-    ;;
-  Darwin* )
-    darwin=true
-    ;;
-  MINGW* )
-    msys=true
-    ;;
-esac
-
-# For Cygwin, ensure paths are in UNIX format before anything is touched.
-if $cygwin ; then
-    [ -n "$JAVA_HOME" ] && JAVA_HOME=`cygpath --unix "$JAVA_HOME"`
-fi
-
 # Attempt to set APP_HOME
 # Resolve links: $0 may be a link
 PRG="$0"
@@ -61,9 +20,49 @@ while [ -h "$PRG" ] ; do
     fi
 done
 SAVED="`pwd`"
-cd "`dirname \"$PRG\"`/" >&-
+cd "`dirname \"$PRG\"`/" >/dev/null
 APP_HOME="`pwd -P`"
-cd "$SAVED" >&-
+cd "$SAVED" >/dev/null
+
+APP_NAME="Gradle"
+APP_BASE_NAME=`basename "$0"`
+
+# 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"'
+
+# Use the maximum available, or set MAX_FD != -1 to use that value.
+MAX_FD="maximum"
+
+warn () {
+    echo "$*"
+}
+
+die () {
+    echo
+    echo "$*"
+    echo
+    exit 1
+}
+
+# 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
+    ;;
+  MINGW* )
+    msys=true
+    ;;
+  NONSTOP* )
+    nonstop=true
+    ;;
+esac
 
 CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
 
@@ -90,7 +89,7 @@ location of your Java installation."
 fi
 
 # Increase the maximum file descriptors if we can.
-if [ "$cygwin" = "false" -a "$darwin" = "false" ] ; then
+if [ "$cygwin" = "false" -a "$darwin" = "false" -a "$nonstop" = "false" ] ; then
     MAX_FD_LIMIT=`ulimit -H -n`
     if [ $? -eq 0 ] ; then
         if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then
@@ -114,6 +113,7 @@ fi
 if $cygwin ; then
     APP_HOME=`cygpath --path --mixed "$APP_HOME"`
     CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
+    JAVACMD=`cygpath --unix "$JAVACMD"`
 
     # We build the pattern for arguments to be converted via cygpath
     ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null`
@@ -154,11 +154,19 @@ if $cygwin ; then
     esac
 fi
 
-# Split up the JVM_OPTS And GRADLE_OPTS values into an array, following the shell quoting and substitution rules
-function splitJvmOpts() {
-    JVM_OPTS=("$@")
+# Escape application args
+save () {
+    for i do printf %s\\n "$i" | sed "s/'/'\\\\''/g;1s/^/'/;\$s/\$/' \\\\/" ; done
+    echo " "
 }
-eval splitJvmOpts $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS
-JVM_OPTS[${#JVM_OPTS[*]}]="-Dorg.gradle.appname=$APP_BASE_NAME"
+APP_ARGS=$(save "$@")
 
-exec "$JAVACMD" "${JVM_OPTS[@]}" -classpath "$CLASSPATH" org.gradle.wrapper.GradleWrapperMain "$@"
+# Collect all arguments for the java command, following the shell quoting and substitution rules
+eval set -- $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS "\"-Dorg.gradle.appname=$APP_BASE_NAME\"" -classpath "\"$CLASSPATH\"" org.gradle.wrapper.GradleWrapperMain "$APP_ARGS"
+
+# by default we should be in the correct project dir, but when run from Finder on Mac, the cwd is wrong
+if [ "$(uname)" = "Darwin" ] && [ "$HOME" = "$PWD" ]; then
+  cd "$(dirname "$0")"
+fi
+
+exec "$JAVACMD" "$@"

gradlew.bat

@@ -8,14 +8,14 @@
 @rem Set local scope for the variables with windows NT shell
 if "%OS%"=="Windows_NT" setlocal
 
-@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=
-
 set DIRNAME=%~dp0
 if "%DIRNAME%" == "" set DIRNAME=.
 set APP_BASE_NAME=%~n0
 set APP_HOME=%DIRNAME%
 
+@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"
+
 @rem Find java.exe
 if defined JAVA_HOME goto findJavaFromJavaHome
 
@@ -46,10 +46,9 @@ echo location of your Java installation.
 goto fail
 
 :init
-@rem Get command-line arguments, handling Windowz variants
+@rem Get command-line arguments, handling Windows variants
 
 if not "%OS%" == "Windows_NT" goto win9xME_args
-if "%@eval[2+2]" == "4" goto 4NT_args
 
 :win9xME_args
 @rem Slurp the command line arguments.
@@ -60,11 +59,6 @@ set _SKIP=2
 if "x%~1" == "x" goto execute
 
 set CMD_LINE_ARGS=%*
-goto execute
-
-:4NT_args
-@rem Get arguments from the 4NT Shell from JP Software
-set CMD_LINE_ARGS=%$
 
 :execute
 @rem Setup the command line

settings.gradle

@@ -1,3 +1,3 @@
 rootProject.name = 'worldguard'
 
-include 'worldguard-core', 'worldguard-sponge', 'worldguard-legacy'
+include 'worldguard-core', 'worldguard-bukkit'

worldguard-bukkit/build.gradle

@@ -0,0 +1,55 @@
+apply plugin: 'eclipse'
+apply plugin: 'idea'
+
+repositories {
+    maven {
+        name = 'bstats repo'
+        url = 'https://repo.codemc.org/repository/maven-public'
+    }
+}
+
+dependencies {
+    compile project(path: ':worldguard-core', configuration: 'shadow')
+    api 'org.bukkit:bukkit:1.13-R0.1-SNAPSHOT'
+    api ('com.sk89q.worldedit:worldedit-bukkit:7.0.0-SNAPSHOT') {
+        exclude group: 'io.papermc', module: 'paperlib'
+    }
+    implementation ('com.sk89q:commandbook:2.3') {
+        exclude group: 'com.sk89q', module: 'worldedit'
+        exclude group: 'com.zachsthings.libcomponents'
+        exclude group: 'org.bukkit'
+        exclude group: 'net.sf.opencsv'
+    }
+    implementation 'org.bstats:bstats-bukkit:1.4'
+}
+
+processResources {
+    from (sourceSets.main.resources.srcDirs) {
+        expand project.properties
+        include 'plugin.yml'
+    }
+
+    from (sourceSets.main.resources.srcDirs) {
+        exclude 'plugin.yml'
+    }
+}
+
+jar {
+    manifest {
+        attributes("Implementation-Version": version)
+    }
+}
+
+shadowJar {
+    dependencies {
+        include(dependency(':worldguard-core'))
+        relocate ("org.bstats", "com.sk89q.worldguard.bukkit.bstats") {
+            include(dependency("org.bstats:bstats-bukkit:1.4"))
+        }
+    }
+
+    relocate('org.flywaydb', 'com.sk89q.worldguard.internal.flywaydb')
+
+}
+
+build.dependsOn(shadowJar)

worldguard-bukkit/src/main/java/com/sk89q/worldguard/bukkit/BukkitConfigurationManager.java

@@ -0,0 +1,110 @@
+/*
+ * 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.WorldEdit;
+import com.sk89q.worldedit.extension.platform.Capability;
+import com.sk89q.worldedit.world.World;
+import com.sk89q.worldguard.config.YamlConfigurationManager;
+import com.sk89q.worldedit.util.report.Unreported;
+
+import java.io.File;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+
+public class BukkitConfigurationManager extends YamlConfigurationManager {
+
+    @Unreported private WorldGuardPlugin plugin;
+    @Unreported private ConcurrentMap<String, BukkitWorldConfiguration> worlds = new ConcurrentHashMap<>();
+
+    private boolean hasCommandBookGodMode;
+
+    /**
+     * Construct the object.
+     *
+     * @param plugin The plugin instance
+     */
+    public BukkitConfigurationManager(WorldGuardPlugin plugin) {
+        super();
+        this.plugin = plugin;
+    }
+
+    @Override
+    public File getDataFolder() {
+        return plugin.getDataFolder();
+    }
+
+    @Override
+    public void copyDefaults() {
+        // Create the default configuration file
+        plugin.createDefaultConfiguration(new File(plugin.getDataFolder(), "config.yml"), "config.yml");
+    }
+
+    @Override
+    public void unload() {
+        worlds.clear();
+    }
+
+    @Override
+    public void postLoad() {
+        // Load configurations for each world
+        for (World world : WorldEdit.getInstance().getPlatformManager().queryCapability(Capability.GAME_HOOKS).getWorlds()) {
+            get(world);
+        }
+    }
+
+    /**
+     * Get the configuration for a world.
+     *
+     * @param world The world to get the configuration for
+     * @return {@code world}'s configuration
+     */
+    @Override
+    public BukkitWorldConfiguration get(World world) {
+        String worldName = world.getName();
+        BukkitWorldConfiguration config = worlds.get(worldName);
+        BukkitWorldConfiguration newConfig = null;
+
+        while (config == null) {
+            if (newConfig == null) {
+                newConfig = new BukkitWorldConfiguration(plugin, worldName, this.getConfig());
+            }
+            worlds.putIfAbsent(world.getName(), newConfig);
+            config = worlds.get(world.getName());
+        }
+
+        return config;
+    }
+
+    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;
+    }
+}

worldguard-bukkit/src/main/java/com/sk89q/worldguard/bukkit/BukkitDebugHandler.java

@@ -17,12 +17,24 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
-package com.sk89q.worldguard.bukkit.commands;
+package com.sk89q.worldguard.bukkit;
 
-import com.sk89q.minecraft.util.commands.*;
-import com.sk89q.worldguard.bukkit.WorldGuardPlugin;
-import com.sk89q.worldguard.bukkit.event.debug.*;
-import com.sk89q.worldguard.util.report.CancelReport;
+import com.sk89q.minecraft.util.commands.CommandException;
+import com.sk89q.minecraft.util.commands.CommandPermissionsException;
+import com.sk89q.worldedit.bukkit.BukkitAdapter;
+import com.sk89q.worldedit.extension.platform.Actor;
+import com.sk89q.worldedit.util.formatting.text.TextComponent;
+import com.sk89q.worldedit.util.formatting.text.format.TextColor;
+import com.sk89q.worldedit.util.paste.ActorCallbackPaste;
+import com.sk89q.worldguard.LocalPlayer;
+import com.sk89q.worldguard.WorldGuard;
+import com.sk89q.worldguard.bukkit.event.debug.CancelLogging;
+import com.sk89q.worldguard.bukkit.event.debug.LoggingBlockBreakEvent;
+import com.sk89q.worldguard.bukkit.event.debug.LoggingBlockPlaceEvent;
+import com.sk89q.worldguard.bukkit.event.debug.LoggingEntityDamageByEntityEvent;
+import com.sk89q.worldguard.bukkit.event.debug.LoggingPlayerInteractEvent;
+import com.sk89q.worldguard.bukkit.util.report.CancelReport;
+import com.sk89q.worldguard.internal.platform.DebugHandler;
 import org.bukkit.Bukkit;
 import org.bukkit.ChatColor;
 import org.bukkit.Material;
@@ -34,68 +46,22 @@ import org.bukkit.entity.Entity;
 import org.bukkit.entity.Player;
 import org.bukkit.event.Event;
 import org.bukkit.event.block.Action;
-import org.bukkit.event.entity.EntityDamageEvent.DamageCause;
+import org.bukkit.event.entity.EntityDamageEvent;
 import org.bukkit.util.BlockIterator;
 
 import java.util.logging.Logger;
 
-public class DebuggingCommands {
+public class BukkitDebugHandler implements DebugHandler {
 
-    private static final Logger log = Logger.getLogger(DebuggingCommands.class.getCanonicalName());
+    private static final Logger log = Logger.getLogger(BukkitDebugHandler.class.getCanonicalName());
     private static final int MAX_TRACE_DISTANCE = 20;
 
     private final WorldGuardPlugin plugin;
 
-    /**
-     * Create a new instance.
-     *
-     * @param plugin The plugin instance
-     */
-    public DebuggingCommands(WorldGuardPlugin plugin) {
+    BukkitDebugHandler(WorldGuardPlugin plugin) {
         this.plugin = plugin;
     }
 
-    @Command(aliases = {"testbreak"}, usage = "[player]", desc = "Simulate a block break", min = 1, max = 1, flags = "ts")
-    @CommandPermissions("worldguard.debug.event")
-    public void fireBreakEvent(CommandContext args, final CommandSender sender) throws CommandException {
-        Player target = plugin.matchSinglePlayer(sender, args.getString(0));
-        Block block = traceBlock(sender, target, args.hasFlag('t'));
-        sender.sendMessage(ChatColor.AQUA + "Testing BLOCK BREAK at " + ChatColor.DARK_AQUA + block);
-        LoggingBlockBreakEvent event = new LoggingBlockBreakEvent(block, target);
-        testEvent(sender, target, event, args.hasFlag('s'));
-    }
-
-
-    @Command(aliases = {"testplace"}, usage = "[player]", desc = "Simulate a block place", min = 1, max = 1, flags = "ts")
-    @CommandPermissions("worldguard.debug.event")
-    public void firePlaceEvent(CommandContext args, final CommandSender sender) throws CommandException {
-        Player target = plugin.matchSinglePlayer(sender, args.getString(0));
-        Block block = traceBlock(sender, target, args.hasFlag('t'));
-        sender.sendMessage(ChatColor.AQUA + "Testing BLOCK PLACE at " + ChatColor.DARK_AQUA + block);
-        LoggingBlockPlaceEvent event = new LoggingBlockPlaceEvent(block, block.getState(), block.getRelative(BlockFace.DOWN), target.getItemInHand(), target, true);
-        testEvent(sender, target, event, args.hasFlag('s'));
-    }
-
-    @Command(aliases = {"testinteract"}, usage = "[player]", desc = "Simulate a block interact", min = 1, max = 1, flags = "ts")
-    @CommandPermissions("worldguard.debug.event")
-    public void fireInteractEvent(CommandContext args, final CommandSender sender) throws CommandException {
-        Player target = plugin.matchSinglePlayer(sender, args.getString(0));
-        Block block = traceBlock(sender, target, args.hasFlag('t'));
-        sender.sendMessage(ChatColor.AQUA + "Testing BLOCK INTERACT at " + ChatColor.DARK_AQUA + block);
-        LoggingPlayerInteractEvent event = new LoggingPlayerInteractEvent(target, Action.RIGHT_CLICK_BLOCK, target.getItemInHand(), block, BlockFace.SOUTH);
-        testEvent(sender, target, event, args.hasFlag('s'));
-    }
-
-    @Command(aliases = {"testdamage"}, usage = "[player]", desc = "Simulate an entity damage", min = 1, max = 1, flags = "ts")
-    @CommandPermissions("worldguard.debug.event")
-    public void fireDamageEvent(CommandContext args, final CommandSender sender) throws CommandException {
-        Player target = plugin.matchSinglePlayer(sender, args.getString(0));
-        Entity entity = traceEntity(sender, target, args.hasFlag('t'));
-        sender.sendMessage(ChatColor.AQUA + "Testing ENTITY DAMAGE on " + ChatColor.DARK_AQUA + entity);
-        LoggingEntityDamageByEntityEvent event = new LoggingEntityDamageByEntityEvent(target, entity, DamageCause.ENTITY_ATTACK, 1);
-        testEvent(sender, target, event, args.hasFlag('s'));
-    }
-
     /**
      * Simulate an event and print its report.
      *
@@ -105,7 +71,8 @@ public class DebuggingCommands {
      * @param stacktraceMode Whether stack traces should be generated and posted
      * @param <T> The type of event
      */
-    private <T extends Event & CancelLogging> void testEvent(CommandSender receiver, Player target, T event, boolean stacktraceMode) throws CommandPermissionsException {
+    private <T extends Event & CancelLogging> void testEvent(CommandSender receiver, Player target, T event, boolean stacktraceMode) throws
+            CommandPermissionsException {
         boolean isConsole = receiver instanceof ConsoleCommandSender;
 
         if (!receiver.equals(target)) {
@@ -128,7 +95,8 @@ public class DebuggingCommands {
             log.info("Event report for " + receiver.getName() + ":\n\n" + result);
 
             plugin.checkPermission(receiver, "worldguard.debug.pastebin");
-            CommandUtils.pastebin(plugin, receiver, result, "Event debugging report: %s.txt");
+            ActorCallbackPaste.pastebin(WorldGuard.getInstance().getSupervisor(), plugin.wrapCommandSender(receiver),
+                    result, "Event debugging report: %s.txt");
         } else {
             receiver.sendMessage(result.replaceAll("(?m)^", ChatColor.AQUA.toString()));
 
@@ -217,4 +185,46 @@ public class DebuggingCommands {
         throw new CommandException("Not currently looking at an entity that is close enough.");
     }
 
+    @Override
+    public void testBreak(Actor sender, LocalPlayer target, boolean fromTarget, boolean stackTraceMode) throws CommandException {
+        CommandSender bukkitSender = plugin.unwrapActor(sender);
+        Player bukkitTarget = BukkitAdapter.adapt(target);
+
+        Block block = traceBlock(bukkitSender, bukkitTarget, fromTarget);
+        sender.print(TextComponent.of("Testing BLOCK BREAK at ", TextColor.AQUA).append(TextComponent.of(block.toString(), TextColor.DARK_AQUA)));
+        LoggingBlockBreakEvent event = new LoggingBlockBreakEvent(block, bukkitTarget);
+        testEvent(bukkitSender, bukkitTarget, event, stackTraceMode);
+    }
+
+    @Override
+    public void testPlace(Actor sender, LocalPlayer target, boolean fromTarget, boolean stackTraceMode) throws CommandException {
+        CommandSender bukkitSender = plugin.unwrapActor(sender);
+        Player bukkitTarget = BukkitAdapter.adapt(target);
+
+        Block block = traceBlock(bukkitSender, bukkitTarget, fromTarget);
+        sender.print(TextComponent.of("Testing BLOCK PLACE at ", TextColor.AQUA).append(TextComponent.of(block.toString(), TextColor.DARK_AQUA)));
+        LoggingBlockPlaceEvent event = new LoggingBlockPlaceEvent(block, block.getState(), block.getRelative(BlockFace.DOWN), bukkitTarget.getItemInHand(), bukkitTarget, true);
+        testEvent(bukkitSender, bukkitTarget, event, stackTraceMode);
+    }
+
+    @Override
+    public void testInteract(Actor sender, LocalPlayer target, boolean fromTarget, boolean stackTraceMode) throws CommandException {
+        CommandSender bukkitSender = plugin.unwrapActor(sender);
+        Player bukkitTarget = BukkitAdapter.adapt(target);
+
+        Block block = traceBlock(bukkitSender, bukkitTarget, fromTarget);
+        sender.print(TextComponent.of("Testing BLOCK INTERACT at ", TextColor.AQUA).append(TextComponent.of(block.toString(), TextColor.DARK_AQUA)));
+        LoggingPlayerInteractEvent event = new LoggingPlayerInteractEvent(bukkitTarget, Action.RIGHT_CLICK_BLOCK, bukkitTarget.getItemInHand(), block, BlockFace.SOUTH);
+        testEvent(bukkitSender, bukkitTarget, event, stackTraceMode);
+    }
+
+    @Override
+    public void testDamage(Actor sender, LocalPlayer target, boolean fromTarget, boolean stackTraceMode) throws CommandException {
+        CommandSender bukkitSender = plugin.unwrapActor(sender);
+        Player bukkitTarget = BukkitAdapter.adapt(target);
+        Entity entity = traceEntity(bukkitSender, bukkitTarget, fromTarget);
+        sender.print(TextComponent.of("Testing ENTITY DAMAGE at ", TextColor.AQUA).append(TextComponent.of(entity.toString(), TextColor.DARK_AQUA)));
+        LoggingEntityDamageByEntityEvent event = new LoggingEntityDamageByEntityEvent(bukkitTarget, entity, EntityDamageEvent.DamageCause.ENTITY_ATTACK, 1);
+        testEvent(bukkitSender, bukkitTarget, event, stackTraceMode);
+    }
 }

worldguard-bukkit/src/main/java/com/sk89q/worldguard/bukkit/BukkitOfflinePlayer.java

@@ -0,0 +1,241 @@
+/*
+ * 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.blocks.BaseItemStack;
+import com.sk89q.worldedit.entity.BaseEntity;
+import com.sk89q.worldedit.extent.inventory.BlockBag;
+import com.sk89q.worldedit.math.Vector3;
+import com.sk89q.worldedit.session.SessionKey;
+import com.sk89q.worldedit.util.HandSide;
+import com.sk89q.worldedit.util.Location;
+import com.sk89q.worldedit.world.World;
+import com.sk89q.worldedit.world.weather.WeatherType;
+import org.bukkit.OfflinePlayer;
+
+import java.util.UUID;
+
+import javax.annotation.Nullable;
+
+class BukkitOfflinePlayer extends BukkitPlayer {
+
+    private final OfflinePlayer player;
+
+    BukkitOfflinePlayer(WorldGuardPlugin plugin, OfflinePlayer offlinePlayer) {
+        super(plugin, offlinePlayer.getPlayer()); // null if they are offline
+        this.player = offlinePlayer;
+    }
+
+    /// ========================================
+    /// These are checked for RegionAssociable
+    /// (to see if a player belongs to a region)
+    /// ========================================
+
+    @Override
+    public String getName() {
+        return player.getName();
+    }
+
+    @Override
+    public UUID getUniqueId() {
+        return player.getUniqueId();
+    }
+
+    @Override
+    public boolean hasGroup(String group) {
+        return plugin.inGroup(player, group);
+    }
+
+    @Override
+    public String[] getGroups() {
+        return plugin.getGroups(player);
+    }
+
+    /// ==========================================
+    /// None of the following should ever be used.
+    /// ==========================================
+
+    @Override
+    public boolean hasPermission(String perm) {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override
+    public void kick(String msg) {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override
+    public void ban(String msg) {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override
+    public double getHealth() {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override
+    public void setHealth(double health) {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override
+    public double getMaxHealth() {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override
+    public double getFoodLevel() {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override
+    public void setFoodLevel(double foodLevel) {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override
+    public double getSaturation() {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override
+    public void setSaturation(double saturation) {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override
+    public float getExhaustion() {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override
+    public void setExhaustion(float exhaustion) {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override
+    public WeatherType getPlayerWeather() {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override
+    public void setPlayerWeather(WeatherType weather) {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override
+    public void resetPlayerWeather() {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override
+    public boolean isPlayerTimeRelative() {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override
+    public long getPlayerTimeOffset() {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override
+    public void setPlayerTime(long time, boolean relative) {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override
+    public void resetPlayerTime() {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override
+    public void printRaw(String msg) {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override
+    public void printDebug(String msg) {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override
+    public void print(String msg) {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override
+    public void printError(String msg) {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override
+    public World getWorld() {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override
+    public BaseItemStack getItemInHand(HandSide handSide) {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override
+    public void giveItem(BaseItemStack itemStack) {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override
+    public BlockBag getInventoryBlockBag() {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override
+    public void setPosition(Vector3 pos, float pitch, float yaw) {
+        throw new UnsupportedOperationException();
+    }
+
+    @Nullable
+    @Override
+    public BaseEntity getState() {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override
+    public Location getLocation() {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override
+    public void setCompassTarget(Location location) {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override
+    public SessionKey getSessionKey() {
+        throw new UnsupportedOperationException();
+    }
+
+    @Nullable
+    @Override
+    public <T> T getFacet(Class<? extends T> cls) {
+        throw new UnsupportedOperationException();
+    }
+}

worldguard-bukkit/src/main/java/com/sk89q/worldguard/bukkit/BukkitPlayer.java

@@ -0,0 +1,192 @@
+/*
+ * 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.bukkit.BukkitAdapter;
+import com.sk89q.worldedit.util.Location;
+import com.sk89q.worldedit.world.weather.WeatherType;
+import com.sk89q.worldedit.world.weather.WeatherTypes;
+import com.sk89q.worldguard.LocalPlayer;
+import org.bukkit.BanList.Type;
+import org.bukkit.Bukkit;
+import org.bukkit.entity.Player;
+
+public class BukkitPlayer extends com.sk89q.worldedit.bukkit.BukkitPlayer implements LocalPlayer {
+
+    protected final WorldGuardPlugin plugin;
+    private final boolean silenced;
+    private String name;
+
+    public BukkitPlayer(WorldGuardPlugin plugin, Player player) {
+        this(plugin, player, false);
+    }
+
+    BukkitPlayer(WorldGuardPlugin plugin, Player player, boolean silenced) {
+        super(player);
+        this.plugin = plugin;
+        this.silenced = silenced;
+    }
+
+    @Override
+    public String getName() {
+        if (this.name == null) {
+            // getName() takes longer than before in newer versions of Minecraft
+            this.name = getPlayer().getName();
+        }
+        return name;
+    }
+
+    @Override
+    public boolean hasGroup(String group) {
+        return plugin.inGroup(getPlayer(), group);
+    }
+
+    @Override
+    public void kick(String msg) {
+        if (!silenced) {
+            getPlayer().kickPlayer(msg);
+        }
+    }
+
+    @Override
+    public void ban(String msg) {
+        if (!silenced) {
+            Bukkit.getBanList(Type.NAME).addBan(getName(), null, null, null);
+            getPlayer().kickPlayer(msg);
+        }
+    }
+
+    @Override
+    public double getHealth() {
+        return getPlayer().getHealth();
+    }
+
+    @Override
+    public void setHealth(double health) {
+        getPlayer().setHealth(health);
+    }
+
+    @Override
+    public double getMaxHealth() {
+        return getPlayer().getMaxHealth();
+    }
+
+    @Override
+    public double getFoodLevel() {
+        return getPlayer().getFoodLevel();
+    }
+
+    @Override
+    public void setFoodLevel(double foodLevel) {
+        getPlayer().setFoodLevel((int) foodLevel);
+    }
+
+    @Override
+    public double getSaturation() {
+        return getPlayer().getSaturation();
+    }
+
+    @Override
+    public void setSaturation(double saturation) {
+        getPlayer().setSaturation((float) saturation);
+    }
+
+    @Override
+    public float getExhaustion() {
+        return getPlayer().getExhaustion();
+    }
+
+    @Override
+    public void setExhaustion(float exhaustion) {
+        getPlayer().setExhaustion(exhaustion);
+    }
+
+    @Override
+    public WeatherType getPlayerWeather() {
+        return null;
+    }
+
+    @Override
+    public void setPlayerWeather(WeatherType weather) {
+        getPlayer().setPlayerWeather(weather == WeatherTypes.CLEAR ? org.bukkit.WeatherType.CLEAR : org.bukkit.WeatherType.DOWNFALL);
+    }
+
+    @Override
+    public void resetPlayerWeather() {
+        getPlayer().resetPlayerWeather();
+    }
+
+    @Override
+    public boolean isPlayerTimeRelative() {
+        return getPlayer().isPlayerTimeRelative();
+    }
+
+    @Override
+    public long getPlayerTimeOffset() {
+        return getPlayer().getPlayerTimeOffset();
+    }
+
+    @Override
+    public void setPlayerTime(long time, boolean relative) {
+        getPlayer().setPlayerTime(time, relative);
+    }
+
+    @Override
+    public void resetPlayerTime() {
+        getPlayer().resetPlayerTime();
+    }
+
+    @Override
+    public int getFireTicks() {
+        return getPlayer().getFireTicks();
+    }
+
+    @Override
+    public void setFireTicks(int fireTicks) {
+        getPlayer().setFireTicks(fireTicks);
+    }
+
+    @Override
+    public void setCompassTarget(Location location) {
+        getPlayer().setCompassTarget(BukkitAdapter.adapt(location));
+    }
+
+    @Override
+    public void sendTitle(String title, String subtitle) {
+        getPlayer().sendTitle(title, subtitle, -1, -1, -1);
+    }
+
+    @Override
+    public String[] getGroups() {
+        return plugin.getGroups(getPlayer());
+    }
+
+    @Override
+    public void printRaw(String msg) {
+        if (!silenced) {
+            super.printRaw(msg);
+        }
+    }
+
+    @Override
+    public boolean hasPermission(String perm) {
+        return plugin.hasPermission(getPlayer(), perm);
+    }
+}

worldguard-bukkit/src/main/java/com/sk89q/worldguard/bukkit/BukkitRegionContainer.java

@@ -0,0 +1,128 @@
+/*
+ * 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 static com.google.common.base.Preconditions.checkNotNull;
+
+import com.sk89q.worldedit.bukkit.BukkitAdapter;
+import com.sk89q.worldedit.bukkit.BukkitWorld;
+import com.sk89q.worldedit.math.BlockVector2;
+import com.sk89q.worldedit.world.World;
+import com.sk89q.worldguard.WorldGuard;
+import com.sk89q.worldguard.config.WorldConfiguration;
+import com.sk89q.worldguard.protection.managers.RegionManager;
+import com.sk89q.worldguard.protection.regions.RegionContainer;
+import org.bukkit.Bukkit;
+import org.bukkit.Chunk;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.world.ChunkLoadEvent;
+import org.bukkit.event.world.ChunkUnloadEvent;
+import org.bukkit.event.world.WorldLoadEvent;
+import org.bukkit.event.world.WorldUnloadEvent;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import javax.annotation.Nullable;
+
+public class BukkitRegionContainer extends RegionContainer {
+
+    /**
+     * Invalidation frequency in ticks.
+     */
+    private static final int CACHE_INVALIDATION_INTERVAL = 2;
+
+    private final WorldGuardPlugin plugin;
+
+    /**
+     * Create a new instance.
+     *
+     * @param plugin the plugin
+     */
+    public BukkitRegionContainer(WorldGuardPlugin plugin) {
+        this.plugin = plugin;
+    }
+
+    @Override
+    public void initialize() {
+        super.initialize();
+        Bukkit.getPluginManager().registerEvents(new Listener() {
+            @EventHandler
+            public void onWorldLoad(WorldLoadEvent event) {
+                load(BukkitAdapter.adapt(event.getWorld()));
+            }
+
+            @EventHandler
+            public void onWorldUnload(WorldUnloadEvent event) {
+                unload(BukkitAdapter.adapt(event.getWorld()));
+            }
+
+            @EventHandler
+            public void onChunkLoad(ChunkLoadEvent event) {
+                RegionManager manager = get(BukkitAdapter.adapt(event.getWorld()));
+                if (manager != null) {
+                    Chunk chunk = event.getChunk();
+                    manager.loadChunk(BlockVector2.at(chunk.getX(), chunk.getZ()));
+                }
+            }
+
+            @EventHandler
+            public void onChunkUnload(ChunkUnloadEvent event) {
+                RegionManager manager = get(BukkitAdapter.adapt(event.getWorld()));
+                if (manager != null) {
+                    Chunk chunk = event.getChunk();
+                    manager.unloadChunk(BlockVector2.at(chunk.getX(), chunk.getZ()));
+                }
+            }
+        }, plugin);
+
+        Bukkit.getScheduler().scheduleSyncRepeatingTask(plugin, cache::invalidateAll, CACHE_INVALIDATION_INTERVAL, CACHE_INVALIDATION_INTERVAL);
+    }
+
+    @Override
+    @Nullable
+    protected RegionManager load(World world) {
+        checkNotNull(world);
+
+        WorldConfiguration config = WorldGuard.getInstance().getPlatform().getGlobalStateManager().get(world);
+        if (!config.useRegions) {
+            return null;
+        }
+
+        RegionManager manager;
+
+        synchronized (lock) {
+            manager = container.load(world.getName());
+
+            if (manager != null) {
+                // Bias the region data for loaded chunks
+                List<BlockVector2> positions = new ArrayList<>();
+                for (Chunk chunk : ((BukkitWorld) world).getWorld().getLoadedChunks()) {
+                    positions.add(BlockVector2.at(chunk.getX(), chunk.getZ()));
+                }
+                manager.loadChunks(positions);
+            }
+        }
+
+        return manager;
+    }
+
+}

worldguard-bukkit/src/main/java/com/sk89q/worldguard/bukkit/BukkitStringMatcher.java

@@ -0,0 +1,246 @@
+/*
+ * 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.minecraft.util.commands.CommandException;
+import com.sk89q.worldedit.WorldEdit;
+import com.sk89q.worldedit.bukkit.BukkitAdapter;
+import com.sk89q.worldedit.extension.platform.Actor;
+import com.sk89q.worldedit.extension.platform.Capability;
+import com.sk89q.worldedit.math.Vector3;
+import com.sk89q.worldedit.world.World;
+import com.sk89q.worldguard.LocalPlayer;
+import com.sk89q.worldguard.WorldGuard;
+import com.sk89q.worldguard.internal.platform.StringMatcher;
+import org.bukkit.Bukkit;
+import org.bukkit.entity.Player;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+import java.util.stream.Collectors;
+
+public class BukkitStringMatcher implements StringMatcher {
+
+    @Override
+    public World matchWorld(Actor sender, String filter) throws CommandException {
+        List<? extends World> worlds = WorldEdit.getInstance().getPlatformManager().queryCapability(Capability.GAME_HOOKS).getWorlds();
+
+        // Handle special hash tag groups
+        if (filter.charAt(0) == '#') {
+            // #main for the main world
+            if (filter.equalsIgnoreCase("#main")) {
+                return worlds.get(0);
+
+                // #normal for the first normal world
+            } else if (filter.equalsIgnoreCase("#normal")) {
+                for (World world : worlds) {
+                    if (BukkitAdapter.adapt(world).getEnvironment() == org.bukkit.World.Environment.NORMAL) {
+                        return world;
+                    }
+                }
+
+                throw new CommandException("No normal world found.");
+
+                // #nether for the first nether world
+            } else if (filter.equalsIgnoreCase("#nether")) {
+                for (World world : worlds) {
+                    if (BukkitAdapter.adapt(world).getEnvironment() == org.bukkit.World.Environment.NETHER) {
+                        return world;
+                    }
+                }
+
+                throw new CommandException("No nether world found.");
+
+                // #end for the first nether world
+            } else if (filter.equalsIgnoreCase("#end")) {
+                for (World world : worlds) {
+                    if (BukkitAdapter.adapt(world).getEnvironment() == org.bukkit.World.Environment.THE_END) {
+                        return world;
+                    }
+                }
+
+                throw new CommandException("No end world found.");
+
+                // Handle getting a world from a player
+            } else if (filter.matches("^#player$")) {
+                String[] parts = filter.split(":", 2);
+
+                // They didn't specify an argument for the player!
+                if (parts.length == 1) {
+                    throw new CommandException("Argument expected for #player.");
+                }
+
+                return matchPlayers(sender, parts[1]).iterator().next().getWorld();
+            } else {
+                throw new CommandException("Invalid identifier '" + filter + "'.");
+            }
+        }
+
+        for (World world : worlds) {
+            if (world.getName().equals(filter)) {
+                return world;
+            }
+        }
+
+        throw new CommandException("No world by that exact name found.");
+    }
+
+    @Override
+    public List<LocalPlayer> matchPlayerNames(String filter) {
+        List<LocalPlayer> wgPlayers = Bukkit.getServer().getOnlinePlayers().stream().map(player -> WorldGuardPlugin.inst().wrapPlayer(player)).collect(Collectors.toList());
+
+        filter = filter.toLowerCase();
+
+        // Allow exact name matching
+        if (filter.charAt(0) == '@' && filter.length() >= 2) {
+            filter = filter.substring(1);
+
+            for (LocalPlayer player : wgPlayers) {
+                if (player.getName().equalsIgnoreCase(filter)) {
+                    List<LocalPlayer> list = new ArrayList<>();
+                    list.add(player);
+                    return list;
+                }
+            }
+
+            return new ArrayList<>();
+            // Allow partial name matching
+        } else if (filter.charAt(0) == '*' && filter.length() >= 2) {
+            filter = filter.substring(1);
+
+            List<LocalPlayer> list = new ArrayList<>();
+
+            for (LocalPlayer player : wgPlayers) {
+                if (player.getName().toLowerCase().contains(filter)) {
+                    list.add(player);
+                }
+            }
+
+            return list;
+
+            // Start with name matching
+        } else {
+            List<LocalPlayer> list = new ArrayList<>();
+
+            for (LocalPlayer player : wgPlayers) {
+                if (player.getName().toLowerCase().startsWith(filter)) {
+                    list.add(player);
+                }
+            }
+
+            return list;
+        }
+    }
+
+    @Override
+    public Iterable<? extends LocalPlayer> matchPlayers(Actor source, String filter) throws CommandException {
+        if (Bukkit.getServer().getOnlinePlayers().isEmpty()) {
+            throw new CommandException("No players matched query.");
+        }
+
+        List<LocalPlayer> wgPlayers = Bukkit.getServer().getOnlinePlayers().stream().map(player -> WorldGuardPlugin.inst().wrapPlayer(player)).collect(Collectors.toList());
+
+        if (filter.equals("*")) {
+            return checkPlayerMatch(wgPlayers);
+        }
+
+        // Handle special hash tag groups
+        if (filter.charAt(0) == '#') {
+            // Handle #world, which matches player of the same world as the
+            // calling source
+            if (filter.equalsIgnoreCase("#world")) {
+                List<LocalPlayer> players = new ArrayList<>();
+                LocalPlayer sourcePlayer = WorldGuard.getInstance().checkPlayer(source);
+                World sourceWorld = sourcePlayer.getWorld();
+
+                for (LocalPlayer player : wgPlayers) {
+                    if (player.getWorld().equals(sourceWorld)) {
+                        players.add(player);
+                    }
+                }
+
+                return checkPlayerMatch(players);
+
+                // Handle #near, which is for nearby players.
+            } else if (filter.equalsIgnoreCase("#near")) {
+                List<LocalPlayer> players = new ArrayList<>();
+                LocalPlayer sourcePlayer = WorldGuard.getInstance().checkPlayer(source);
+                World sourceWorld = sourcePlayer.getWorld();
+                Vector3 sourceVector = sourcePlayer.getLocation().toVector();
+
+                for (LocalPlayer player : wgPlayers) {
+                    if (player.getWorld().equals(sourceWorld) && player.getLocation().toVector().distanceSq(sourceVector) < 900) {
+                        players.add(player);
+                    }
+                }
+
+                return checkPlayerMatch(players);
+
+            } else {
+                throw new CommandException("Invalid group '" + filter + "'.");
+            }
+        }
+
+        List<LocalPlayer> players = matchPlayerNames(filter);
+
+        return checkPlayerMatch(players);
+    }
+
+    @Override
+    public Actor matchPlayerOrConsole(Actor sender, String filter) throws CommandException {
+        // Let's see if console is wanted
+        if (filter.equalsIgnoreCase("#console")
+                || filter.equalsIgnoreCase("*console*")
+                || filter.equalsIgnoreCase("!")) {
+            return WorldGuardPlugin.inst().wrapCommandSender(Bukkit.getServer().getConsoleSender());
+        }
+
+        return matchSinglePlayer(sender, filter);
+    }
+
+    @Override
+    public World getWorldByName(String worldName) {
+        final org.bukkit.World bukkitW = Bukkit.getServer().getWorld(worldName);
+        if (bukkitW == null) {
+            return null;
+        }
+        return BukkitAdapter.adapt(bukkitW);
+    }
+
+    @Override
+    public String replaceMacros(Actor sender, String message) {
+        Collection<? extends Player> online = Bukkit.getServer().getOnlinePlayers();
+
+        message = message.replace("%name%", sender.getName());
+        message = message.replace("%id%", sender.getUniqueId().toString());
+        message = message.replace("%online%", String.valueOf(online.size()));
+
+        if (sender instanceof LocalPlayer) {
+            LocalPlayer player = (LocalPlayer) sender;
+            World world = (World) player.getExtent();
+
+            message = message.replace("%world%", world.getName());
+            message = message.replace("%health%", String.valueOf(player.getHealth()));
+        }
+
+        return message;
+    }
+}

worldguard-bukkit/src/main/java/com/sk89q/worldguard/bukkit/BukkitUtil.java

@@ -0,0 +1,113 @@
+/*
+ * 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 static com.google.common.base.Preconditions.checkNotNull;
+
+import com.sk89q.worldedit.bukkit.BukkitAdapter;
+import com.sk89q.worldguard.blacklist.target.BlockTarget;
+import com.sk89q.worldguard.blacklist.target.ItemTarget;
+import com.sk89q.worldguard.blacklist.target.Target;
+import org.bukkit.Material;
+import org.bukkit.block.Block;
+import org.bukkit.inventory.ItemStack;
+
+public class BukkitUtil {
+
+    private BukkitUtil() {
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * Get a blacklist target for the given block.
+     *
+     * @param block the block
+     * @param effectiveMaterial The effective material, if different
+     * @return a target
+     */
+    public static Target createTarget(Block block, Material effectiveMaterial) {
+        checkNotNull(block);
+        checkNotNull(block.getType());
+        if (block.getType() == effectiveMaterial) {
+            return createTarget(block.getType());
+        } else {
+            return createTarget(effectiveMaterial);
+        }
+    }
+
+    /**
+     * Get a blacklist target for the given block.
+     *
+     * @param block the block
+     * @return a target
+     */
+    public static Target createTarget(Block block) {
+        checkNotNull(block);
+        checkNotNull(block.getType());
+        return createTarget(block.getType());
+    }
+
+    /**
+     * Get a blacklist target for the given item.
+     *
+     * @param item the item
+     * @return a target
+     */
+    public static Target createTarget(ItemStack item) {
+        checkNotNull(item);
+        checkNotNull(item.getType());
+        return createTarget(item.getType()); // Delegate it, ItemStacks can contain both Blocks and Items in Spigot
+    }
+
+    /**
+     * Get a blacklist target for the given material.
+     *
+     * @param material the material
+     * @return a target
+     */
+    public static Target createTarget(Material material) {
+        checkNotNull(material);
+        if (material.isBlock()) {
+            return new BlockTarget(BukkitAdapter.asBlockType(material));
+        } else {
+            return new ItemTarget(BukkitAdapter.asItemType(material));
+        }
+    }
+}

worldguard-bukkit/src/main/java/com/sk89q/worldguard/bukkit/BukkitWorldConfiguration.java

@@ -21,6 +21,12 @@ package com.sk89q.worldguard.bukkit;
 
 import com.sk89q.util.yaml.YAMLFormat;
 import com.sk89q.util.yaml.YAMLProcessor;
+import com.sk89q.worldedit.util.Location;
+import com.sk89q.worldedit.util.report.Unreported;
+import com.sk89q.worldedit.world.entity.EntityType;
+import com.sk89q.worldedit.world.entity.EntityTypes;
+import com.sk89q.worldedit.world.item.ItemTypes;
+import com.sk89q.worldguard.LocalPlayer;
 import com.sk89q.worldguard.blacklist.Blacklist;
 import com.sk89q.worldguard.blacklist.BlacklistLoggerHandler;
 import com.sk89q.worldguard.blacklist.logger.ConsoleHandler;
@@ -28,24 +34,23 @@ import com.sk89q.worldguard.blacklist.logger.DatabaseHandler;
 import com.sk89q.worldguard.blacklist.logger.FileHandler;
 import com.sk89q.worldguard.blacklist.target.TargetMatcherParseException;
 import com.sk89q.worldguard.blacklist.target.TargetMatcherParser;
-import com.sk89q.worldguard.bukkit.commands.CommandUtils;
-import com.sk89q.worldguard.bukkit.internal.BukkitBlacklist;
+import com.sk89q.worldguard.bukkit.chest.BukkitSignChestProtection;
 import com.sk89q.worldguard.bukkit.internal.TargetMatcherSet;
 import com.sk89q.worldguard.chest.ChestProtection;
-import com.sk89q.worldguard.chest.SignChestProtection;
-import com.sk89q.worldguard.util.report.Unreported;
-import org.bukkit.block.Block;
-import org.bukkit.entity.EntityType;
-import org.bukkit.entity.Player;
+import com.sk89q.worldguard.commands.CommandUtils;
+import com.sk89q.worldguard.config.YamlWorldConfiguration;
 import org.bukkit.potion.PotionEffectType;
 import org.yaml.snakeyaml.parser.ParserException;
 
 import java.io.File;
 import java.io.FileNotFoundException;
 import java.io.IOException;
-import java.util.*;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
 import java.util.logging.Level;
-import java.util.logging.Logger;
 
 /**
  * Holds the configuration for individual worlds.
@@ -53,153 +58,32 @@ import java.util.logging.Logger;
  * @author sk89q
  * @author Michael
  */
-public class WorldConfiguration {
+public class BukkitWorldConfiguration extends YamlWorldConfiguration {
 
-    private static final Logger log = Logger.getLogger(WorldConfiguration.class.getCanonicalName());
     private static final TargetMatcherParser matcherParser = new TargetMatcherParser();
 
-    public static final String CONFIG_HEADER = "#\r\n" +
-            "# WorldGuard's world configuration file\r\n" +
-            "#\r\n" +
-            "# This is a world configuration file. Anything placed into here will only\r\n" +
-            "# affect this world. If you don't put anything in this file, then the\r\n" +
-            "# settings will be inherited from the main configuration file.\r\n" +
-            "#\r\n" +
-            "# If you see {} below, that means that there are NO entries in this file.\r\n" +
-            "# Remove the {} and add your own entries.\r\n" +
-            "#\r\n";
-
-    @Unreported private WorldGuardPlugin plugin;
-
     @Unreported private String worldName;
-    @Unreported private YAMLProcessor parentConfig;
-    @Unreported private YAMLProcessor config;
-    private File blacklistFile;
 
-    @Unreported private Blacklist blacklist;
-    @Unreported private ChestProtection chestProtection = new SignChestProtection();
+    @Unreported private ChestProtection chestProtection = new BukkitSignChestProtection();
 
     /* Configuration data start */
-    public boolean summaryOnStart;
-    public boolean opPermissions;
-    public boolean buildPermissions;
-    public String buildPermissionDenyMessage = "";
-    public boolean fireSpreadDisableToggle;
-    public boolean itemDurability;
-    public boolean simulateSponge;
-    public int spongeRadius;
-    public boolean disableExpDrops;
     public Set<PotionEffectType> blockPotions;
-    public boolean blockPotionsAlways;
-    public boolean pumpkinScuba;
-    public boolean redstoneSponges;
-    public boolean noPhysicsGravel;
-    public boolean noPhysicsSand;
-    public boolean ropeLadders;
-    public boolean allowPortalAnywhere;
-    public Set<Integer> preventWaterDamage;
-    public boolean blockLighter;
-    public boolean disableFireSpread;
-    public Set<Integer> disableFireSpreadBlocks;
-    public boolean preventLavaFire;
-    public Set<Integer> allowedLavaSpreadOver;
-    public boolean blockTNTExplosions;
-    public boolean blockTNTBlockDamage;
-    public boolean blockCreeperExplosions;
-    public boolean blockCreeperBlockDamage;
-    public boolean blockWitherExplosions;
-    public boolean blockWitherBlockDamage;
-    public boolean blockWitherSkullExplosions;
-    public boolean blockWitherSkullBlockDamage;
-    public boolean blockEnderDragonBlockDamage;
-    public boolean blockEnderDragonPortalCreation;
-    public boolean blockFireballExplosions;
-    public boolean blockFireballBlockDamage;
-    public boolean blockOtherExplosions;
-    public boolean blockEntityPaintingDestroy;
-    public boolean blockEntityItemFrameDestroy;
-    public boolean blockPluginSpawning;
-    public boolean blockGroundSlimes;
-    public boolean blockZombieDoorDestruction;
-    public boolean disableContactDamage;
-    public boolean disableFallDamage;
-    public boolean disableLavaDamage;
-    public boolean disableFireDamage;
-    public boolean disableLightningDamage;
-    public boolean disableDrowningDamage;
-    public boolean disableSuffocationDamage;
-    public boolean teleportOnSuffocation;
-    public boolean disableVoidDamage;
-    public boolean teleportOnVoid;
-    public boolean disableExplosionDamage;
-    public boolean disableMobDamage;
-    public boolean useRegions;
-    public boolean highFreqFlags;
-    public boolean checkLiquidFlow;
-    public int regionWand;
-    public Set<EntityType> blockCreatureSpawn;
-    public boolean allowTamedSpawns;
-    // public boolean useiConomy;
-    // public boolean buyOnClaim;
-    // public double buyOnClaimPrice;
-    public int maxClaimVolume;
-    public boolean claimOnlyInsideExistingRegions;
-    public int maxRegionCountPerPlayer;
-    public boolean antiWolfDumbness;
-    public boolean signChestProtection;
-    public boolean disableSignChestProtectionCheck;
-    public boolean removeInfiniteStacks;
-    public boolean disableCreatureCropTrampling;
-    public boolean disablePlayerCropTrampling;
-    public boolean preventLightningFire;
-    public Set<Integer> disallowedLightningBlocks;
-    public boolean disableThunder;
-    public boolean disableWeather;
-    public boolean alwaysRaining;
-    public boolean alwaysThundering;
-    public boolean disablePigZap;
-    public boolean disableCreeperPower;
-    public boolean disableHealthRegain;
-    public boolean disableMushroomSpread;
-    public boolean disableIceMelting;
-    public boolean disableSnowMelting;
-    public boolean disableSnowFormation;
-    public boolean disableIceFormation;
-    public boolean disableLeafDecay;
-    public boolean disableGrassGrowth;
-    public boolean disableMyceliumSpread;
-    public boolean disableVineGrowth;
-    public boolean disableEndermanGriefing;
-    public boolean disableSnowmanTrails;
-    public boolean disableSoilDehydration;
-    public Set<Integer> allowedSnowFallOver;
-    public boolean regionInvinciblityRemovesMobs;
-    public boolean regionNetherPortalProtection;
-    public boolean fakePlayerBuildOverride;
-    public boolean explosionFlagCancellation;
-    public boolean disableDeathMessages;
-    public boolean disableObsidianGenerators;
-    public boolean strictEntitySpawn;
     public TargetMatcherSet allowAllInteract;
     public TargetMatcherSet blockUseAtFeet;
-
-    private Map<String, Integer> maxRegionCounts;
-
     /* Configuration data end */
 
     /**
      * Construct the object.
      *
      * @param plugin The WorldGuardPlugin instance
-     * @param worldName The world name that this WorldConfiguration is for.
+     * @param worldName The world name that this BukkitWorldConfiguration is for.
      * @param parentConfig The parent configuration to read defaults from
      */
-    public WorldConfiguration(WorldGuardPlugin plugin, String worldName, YAMLProcessor parentConfig) {
+    public BukkitWorldConfiguration(WorldGuardPlugin plugin, String worldName, YAMLProcessor parentConfig) {
         File baseFolder = new File(plugin.getDataFolder(), "worlds/" + worldName);
         File configFile = new File(baseFolder, "config.yml");
         blacklistFile = new File(baseFolder, "blacklist.txt");
 
-        this.plugin = plugin;
         this.worldName = worldName;
         this.parentConfig = parentConfig;
 
@@ -214,66 +98,11 @@ public class WorldConfiguration {
         }
     }
 
-    private boolean getBoolean(String node, boolean def) {
-        boolean val = parentConfig.getBoolean(node, def);
-
-        if (config.getProperty(node) != null) {
-            return config.getBoolean(node, def);
-        } else {
-            return val;
-        }
-    }
-
-    private String getString(String node, String def) {
-        String val = parentConfig.getString(node, def);
-
-        if (config.getProperty(node) != null) {
-            return config.getString(node, def);
-        } else {
-            return val;
-        }
-    }
-
-    private int getInt(String node, int def) {
-        int val = parentConfig.getInt(node, def);
-
-        if (config.getProperty(node) != null) {
-            return config.getInt(node, def);
-        } else {
-            return val;
-        }
-    }
-
-    @SuppressWarnings("unused")
-    private double getDouble(String node, double def) {
-        double val = parentConfig.getDouble(node, def);
-
-        if (config.getProperty(node) != null) {
-            return config.getDouble(node, def);
-        } else {
-            return val;
-        }
-    }
-
-    private List<Integer> getIntList(String node, List<Integer> def) {
-        List<Integer> res = parentConfig.getIntList(node, def);
-
-        if (res == null || res.size() == 0) {
-            parentConfig.setProperty(node, new ArrayList<Integer>());
-        }
-
-        if (config.getProperty(node) != null) {
-            res = config.getIntList(node, def);
-        }
-
-        return res;
-    }
-
     private TargetMatcherSet getTargetMatchers(String node) {
         TargetMatcherSet set = new TargetMatcherSet();
         List<String> inputs = parentConfig.getStringList(node, null);
 
-        if (inputs == null || inputs.size() == 0) {
+        if (inputs == null || inputs.isEmpty()) {
             parentConfig.setProperty(node, new ArrayList<String>());
             return set;
         }
@@ -289,52 +118,15 @@ public class WorldConfiguration {
         return set;
     }
 
-    private List<String> getStringList(String node, List<String> def) {
-        List<String> res = parentConfig.getStringList(node, def);
-
-        if (res == null || res.size() == 0) {
-            parentConfig.setProperty(node, new ArrayList<String>());
-        }
-
-        if (config.getProperty(node) != null) {
-            res = config.getStringList(node, def);
-        }
-
-        return res;
-    }
-
-    private List<String> getKeys(String node) {
-        List<String> res = parentConfig.getKeys(node);
-
-        if (res == null || res.size() == 0) {
-            res = config.getKeys(node);
-        }
-        if (res == null) {
-            res = new ArrayList<String>();
-        }
-
-        return res;
-    }
-
-    private Object getProperty(String node) {
-        Object res = parentConfig.getProperty(node);
-
-        if (config.getProperty(node) != null) {
-            res = config.getProperty(node);
-        }
-
-        return res;
-    }
-
     /**
      * Load the configuration.
      */
-    private void loadConfiguration() {
+    @Override
+    public void loadConfiguration() {
         try {
             config.load();
         } catch (IOException e) {
-            log.severe("Error reading configuration for world " + worldName + ": ");
-            e.printStackTrace();
+            log.log(Level.SEVERE, "Error reading configuration for world " + worldName + ": ", e);
         } catch (ParserException e) {
             log.severe("Error parsing configuration for world " + worldName + ". ");
             throw e;
@@ -350,13 +142,14 @@ public class WorldConfiguration {
         strictEntitySpawn = getBoolean("event-handling.block-entity-spawns-with-untraceable-cause", false);
         allowAllInteract = getTargetMatchers("event-handling.interaction-whitelist");
         blockUseAtFeet = getTargetMatchers("event-handling.emit-block-use-at-feet");
+        ignoreHopperMoveEvents = getBoolean("event-handling.ignore-hopper-item-move-events", false);
 
         itemDurability = getBoolean("protection.item-durability", true);
         removeInfiniteStacks = getBoolean("protection.remove-infinite-stacks", false);
         disableExpDrops = getBoolean("protection.disable-xp-orb-drops", false);
         disableObsidianGenerators = getBoolean("protection.disable-obsidian-generators", false);
 
-        blockPotions = new HashSet<PotionEffectType>();
+        blockPotions = new HashSet<>();
         for (String potionName : getStringList("gameplay.block-potions", null)) {
             PotionEffectType effect = PotionEffectType.getByName(potionName);
 
@@ -367,6 +160,7 @@ public class WorldConfiguration {
             }
         }
         blockPotionsAlways = getBoolean("gameplay.block-potions-overly-reliably", false);
+        disableConduitEffects = getBoolean("gameplay.disable-conduit-effects", false);
 
         simulateSponge = getBoolean("simulation.sponge.enable", false);
         spongeRadius = Math.max(1, getInt("simulation.sponge.radius", 3)) - 1;
@@ -379,7 +173,7 @@ public class WorldConfiguration {
         noPhysicsSand = getBoolean("physics.no-physics-sand", false);
         ropeLadders = getBoolean("physics.vine-like-rope-ladders", false);
         allowPortalAnywhere = getBoolean("physics.allow-portal-anywhere", false);
-        preventWaterDamage = new HashSet<Integer>(getIntList("physics.disable-water-damage-blocks", null));
+        preventWaterDamage = new HashSet<>(convertLegacyBlocks(getStringList("physics.disable-water-damage-blocks", null)));
 
         blockTNTExplosions = getBoolean("ignition.block-tnt", false);
         blockTNTBlockDamage = getBoolean("ignition.block-tnt-block-damage", false);
@@ -387,8 +181,8 @@ public class WorldConfiguration {
 
         preventLavaFire = getBoolean("fire.disable-lava-fire-spread", true);
         disableFireSpread = getBoolean("fire.disable-all-fire-spread", false);
-        disableFireSpreadBlocks = new HashSet<Integer>(getIntList("fire.disable-fire-spread-blocks", null));
-        allowedLavaSpreadOver = new HashSet<Integer>(getIntList("fire.lava-spread-blocks", null));
+        disableFireSpreadBlocks = new HashSet<>(convertLegacyBlocks(getStringList("fire.disable-fire-spread-blocks", null)));
+        allowedLavaSpreadOver = new HashSet<>(convertLegacyBlocks(getStringList("fire.lava-spread-blocks", null)));
 
         blockCreeperExplosions = getBoolean("mobs.block-creeper-explosions", false);
         blockCreeperBlockDamage = getBoolean("mobs.block-creeper-block-damage", false);
@@ -406,6 +200,7 @@ public class WorldConfiguration {
         disableSnowmanTrails = getBoolean("mobs.disable-snowman-trails", false);
         blockEntityPaintingDestroy = getBoolean("mobs.block-painting-destroy", false);
         blockEntityItemFrameDestroy = getBoolean("mobs.block-item-frame-destroy", false);
+        blockEntityArmorStandDestroy = getBoolean("mobs.block-armor-stand-destroy", false);
         blockPluginSpawning = getBoolean("mobs.block-plugin-spawning", true);
         blockGroundSlimes = getBoolean("mobs.block-above-ground-slimes", false);
         blockOtherExplosions = getBoolean("mobs.block-other-explosions", false);
@@ -431,7 +226,7 @@ public class WorldConfiguration {
         disableCreatureCropTrampling = getBoolean("crops.disable-creature-trampling", false);
         disablePlayerCropTrampling = getBoolean("crops.disable-player-trampling", false);
 
-        disallowedLightningBlocks = new HashSet<Integer>(getIntList("weather.prevent-lightning-strike-blocks", null));
+        disallowedLightningBlocks = new HashSet<>(convertLegacyBlocks(getStringList("weather.prevent-lightning-strike-blocks", null)));
         preventLightningFire = getBoolean("weather.disable-lightning-strike-fire", false);
         disableThunder = getBoolean("weather.disable-thunderstorm", false);
         disableWeather = getBoolean("weather.disable-weather", false);
@@ -449,28 +244,31 @@ public class WorldConfiguration {
         disableGrassGrowth = getBoolean("dynamics.disable-grass-growth", false);
         disableMyceliumSpread = getBoolean("dynamics.disable-mycelium-spread", false);
         disableVineGrowth = getBoolean("dynamics.disable-vine-growth", false);
+        disableCropGrowth = getBoolean("dynamics.disable-crop-growth", false);
         disableSoilDehydration = getBoolean("dynamics.disable-soil-dehydration", false);
-        allowedSnowFallOver = new HashSet<Integer>(getIntList("dynamics.snow-fall-blocks", null));
+        allowedSnowFallOver = new HashSet<>(convertLegacyBlocks(getStringList("dynamics.snow-fall-blocks", null)));
 
         useRegions = getBoolean("regions.enable", true);
         regionInvinciblityRemovesMobs = getBoolean("regions.invincibility-removes-mobs", false);
+        regionCancelEmptyChatEvents = getBoolean("regions.cancel-chat-without-recipients", true);
         regionNetherPortalProtection = getBoolean("regions.nether-portal-protection", false);
         fakePlayerBuildOverride = getBoolean("regions.fake-player-build-override", true);
         explosionFlagCancellation = getBoolean("regions.explosion-flags-block-entity-damage", true);
         highFreqFlags = getBoolean("regions.high-frequency-flags", false);
         checkLiquidFlow = getBoolean("regions.protect-against-liquid-flow", false);
-        regionWand = getInt("regions.wand", 334);
+        regionWand = convertLegacyItem(getString("regions.wand", ItemTypes.LEATHER.getId()));
         maxClaimVolume = getInt("regions.max-claim-volume", 30000);
         claimOnlyInsideExistingRegions = getBoolean("regions.claim-only-inside-existing-regions", false);
+        boundedLocationFlags = getBoolean("regions.location-flags-only-inside-regions", false);
 
         maxRegionCountPerPlayer = getInt("regions.max-region-count-per-player.default", 7);
-        maxRegionCounts = new HashMap<String, Integer>();
+        maxRegionCounts = new HashMap<>();
         maxRegionCounts.put(null, maxRegionCountPerPlayer);
 
         for (String key : getKeys("regions.max-region-count-per-player")) {
             if (!key.equalsIgnoreCase("default")) {
                 Object val = getProperty("regions.max-region-count-per-player." + key);
-                if (val != null && val instanceof Number) {
+                if (val instanceof Number) {
                     maxRegionCounts.put(key, ((Number) val).intValue());
                 }
             }
@@ -480,14 +278,12 @@ public class WorldConfiguration {
         // buyOnClaim = getBoolean("iconomy.buy-on-claim", false);
         // buyOnClaimPrice = getDouble("iconomy.buy-on-claim-price", 1.0);
 
-        blockCreatureSpawn = new HashSet<EntityType>();
+        blockCreatureSpawn = new HashSet<>();
         for (String creatureName : getStringList("mobs.block-creature-spawn", null)) {
-            EntityType creature = EntityType.fromName(creatureName);
+            EntityType creature = EntityTypes.get(creatureName.toLowerCase());
 
             if (creature == null) {
-                log.warning("Unknown mob type '" + creatureName + "'");
-            } else if (!creature.isAlive()) {
-                log.warning("Entity type '" + creatureName + "' is not a creature");
+                log.warning("Unknown entity type '" + creatureName + "'");
             } else {
                 blockCreatureSpawn.add(creature);
             }
@@ -518,7 +314,7 @@ public class WorldConfiguration {
             }
 
             // First load the blacklist data from worldguard-blacklist.txt
-            Blacklist blist = new BukkitBlacklist(useBlacklistAsWhitelist, plugin);
+            Blacklist blist = new Blacklist(useBlacklistAsWhitelist);
             blist.load(blacklistFile);
 
             // If the blacklist is empty, then set the field to null
@@ -528,7 +324,8 @@ public class WorldConfiguration {
             } else {
                 this.blacklist = blist;
                 if (summaryOnStart) {
-                    log.log(Level.INFO, "Blacklist loaded.");
+                    log.log(Level.INFO, "({0}) Blacklist loaded with {1} entries.",
+                            new Object[]{worldName, blacklist.getItemCount()});
                 }
 
                 BlacklistLoggerHandler blacklistLogger = blist.getLogger();
@@ -569,7 +366,7 @@ public class WorldConfiguration {
             if (disableFireSpread) {
                 log.log(Level.INFO, "(" + worldName + ") All fire spread is disabled.");
             } else {
-                if (disableFireSpreadBlocks.size() > 0) {
+                if (!disableFireSpreadBlocks.isEmpty()) {
                     log.log(Level.INFO, "(" + worldName
                             + ") Fire spread is limited to "
                             + disableFireSpreadBlocks.size() + " block types.");
@@ -585,47 +382,39 @@ public class WorldConfiguration {
         config.save();
     }
 
-    public Blacklist getBlacklist() {
-        return this.blacklist;
-    }
-
-    public String getWorldName() {
-        return this.worldName;
-    }
-
-    public boolean isChestProtected(Block block, Player player) {
+    public boolean isChestProtected(Location block, LocalPlayer player) {
         if (!signChestProtection) {
             return false;
         }
-        if (plugin.hasPermission(player, "worldguard.chest-protection.override")
-                || plugin.hasPermission(player, "worldguard.override.chest-protection")) {
+        if (player.hasPermission("worldguard.chest-protection.override")
+                || player.hasPermission("worldguard.override.chest-protection")) {
             return false;
         }
         return chestProtection.isProtected(block, player);
     }
 
-    public boolean isChestProtected(Block block) {
+    public boolean isChestProtected(Location block) {
 
         return signChestProtection && chestProtection.isProtected(block, null);
     }
 
-    public boolean isChestProtectedPlacement(Block block, Player player) {
+    public boolean isChestProtectedPlacement(Location block, LocalPlayer player) {
         if (!signChestProtection) {
             return false;
         }
-        if (plugin.hasPermission(player, "worldguard.chest-protection.override")
-                || plugin.hasPermission(player, "worldguard.override.chest-protection")) {
+        if (player.hasPermission("worldguard.chest-protection.override")
+                || player.hasPermission("worldguard.override.chest-protection")) {
             return false;
         }
         return chestProtection.isProtectedPlacement(block, player);
     }
 
-    public boolean isAdjacentChestProtected(Block block, Player player) {
+    public boolean isAdjacentChestProtected(Location block, LocalPlayer player) {
         if (!signChestProtection) {
             return false;
         }
-        if (plugin.hasPermission(player, "worldguard.chest-protection.override")
-                || plugin.hasPermission(player, "worldguard.override.chest-protection")) {
+        if (player.hasPermission("worldguard.chest-protection.override")
+                || player.hasPermission("worldguard.override.chest-protection")) {
             return false;
         }
         return chestProtection.isAdjacentChestProtected(block, player);
@@ -635,19 +424,4 @@ public class WorldConfiguration {
         return chestProtection;
     }
 
-    public int getMaxRegionCount(Player player) {
-        int max = -1;
-        for (String group : plugin.getGroups(player)) {
-            if (maxRegionCounts.containsKey(group)) {
-                int groupMax = maxRegionCounts.get(group);
-                if (max < groupMax) {
-                    max = groupMax;
-                }
-            }
-        }
-        if (max <= -1) {
-            max = maxRegionCountPerPlayer;
-        }
-        return max;
-    }
 }

worldguard-bukkit/src/main/java/com/sk89q/worldguard/bukkit/BukkitWorldGuardPlatform.java

@@ -0,0 +1,231 @@
+/*
+ * 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.util.formatting.text.TextComponent;
+import com.sk89q.worldedit.util.report.ReportList;
+import com.sk89q.worldedit.world.gamemode.GameMode;
+import com.sk89q.worldedit.world.gamemode.GameModes;
+import com.sk89q.worldguard.LocalPlayer;
+import com.sk89q.worldguard.WorldGuard;
+import com.sk89q.worldguard.bukkit.protection.events.flags.FlagContextCreateEvent;
+import com.sk89q.worldguard.bukkit.session.BukkitSessionManager;
+import com.sk89q.worldguard.bukkit.util.report.PerformanceReport;
+import com.sk89q.worldguard.bukkit.util.report.PluginReport;
+import com.sk89q.worldguard.bukkit.util.report.SchedulerReport;
+import com.sk89q.worldguard.bukkit.util.report.ServerReport;
+import com.sk89q.worldguard.bukkit.util.report.ServicesReport;
+import com.sk89q.worldguard.bukkit.util.report.WorldReport;
+import com.sk89q.worldguard.internal.platform.DebugHandler;
+import com.sk89q.worldguard.internal.platform.StringMatcher;
+import com.sk89q.worldguard.internal.platform.WorldGuardPlatform;
+import com.sk89q.worldguard.protection.flags.FlagContext;
+import com.sk89q.worldguard.protection.regions.RegionContainer;
+import com.sk89q.worldguard.session.SessionManager;
+import org.bukkit.Bukkit;
+import org.bukkit.entity.Player;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.permissions.Permissible;
+
+import java.nio.file.Path;
+import java.util.List;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+public class BukkitWorldGuardPlatform implements WorldGuardPlatform {
+
+    private SessionManager sessionManager;
+    private BukkitConfigurationManager configuration;
+    private BukkitRegionContainer regionContainer;
+    private BukkitDebugHandler debugHandler;
+    private StringMatcher stringMatcher;
+
+    public BukkitWorldGuardPlatform() {
+    }
+
+    @Override
+    public String getPlatformName() {
+        return "Bukkit-Official";
+    }
+
+    @Override
+    public String getPlatformVersion() {
+        return WorldGuardPlugin.inst().getDescription().getVersion();
+    }
+
+    @Override
+    public void notifyFlagContextCreate(FlagContext.FlagContextBuilder flagContextBuilder) {
+        Bukkit.getServer().getPluginManager().callEvent(new FlagContextCreateEvent(flagContextBuilder));
+    }
+
+    @Override
+    public BukkitConfigurationManager getGlobalStateManager() {
+        return configuration;
+    }
+
+    @Override
+    public StringMatcher getMatcher() {
+        return stringMatcher;
+    }
+
+    @Override
+    public SessionManager getSessionManager() {
+        return this.sessionManager;
+    }
+
+    @Override
+    public void broadcastNotification(String message) {
+        Bukkit.broadcast(message, "worldguard.notify");
+        Set<Permissible> subs = Bukkit.getPluginManager().getPermissionSubscriptions("worldguard.notify");
+        for (Player player : Bukkit.getServer().getOnlinePlayers()) {
+            if (!(subs.contains(player) && player.hasPermission("worldguard.notify")) &&
+                    WorldGuardPlugin.inst().hasPermission(player, "worldguard.notify")) { // Make sure the player wasn't already broadcasted to.
+                player.sendMessage(message);
+            }
+        }
+        WorldGuard.logger.info(message);
+    }
+
+    @Override
+    public void broadcastNotification(TextComponent component) {
+        List<LocalPlayer>
+                wgPlayers = Bukkit.getServer().getOnlinePlayers().stream().map(player -> WorldGuardPlugin.inst().wrapPlayer(player)).collect(
+                Collectors.toList());
+
+        for (LocalPlayer player : wgPlayers) {
+            if (player.hasPermission("worldguard.notify")) {
+                player.print(component);
+            }
+        }
+    }
+
+    @Override
+    public void load() {
+        stringMatcher = new BukkitStringMatcher();
+        sessionManager = new BukkitSessionManager();
+        configuration = new BukkitConfigurationManager(WorldGuardPlugin.inst());
+        configuration.load();
+        regionContainer = new BukkitRegionContainer(WorldGuardPlugin.inst());
+        regionContainer.initialize();
+        debugHandler = new BukkitDebugHandler(WorldGuardPlugin.inst());
+    }
+
+    @Override
+    public void unload() {
+        configuration.unload();
+        regionContainer.unload();
+    }
+
+    @Override
+    public RegionContainer getRegionContainer() {
+        return this.regionContainer;
+    }
+
+    @Override
+    public DebugHandler getDebugHandler() {
+        return debugHandler;
+    }
+
+    @Override
+    public GameMode getDefaultGameMode() {
+        return GameModes.get(Bukkit.getServer().getDefaultGameMode().name().toLowerCase());
+    }
+
+    @Override
+    public Path getConfigDir() {
+        return WorldGuardPlugin.inst().getDataFolder().toPath();
+    }
+
+    @Override
+    public void stackPlayerInventory(LocalPlayer localPlayer) {
+        boolean ignoreMax = localPlayer.hasPermission("worldguard.stack.illegitimate");
+        boolean ignoreDamaged = localPlayer.hasPermission("worldguard.stack.damaged");
+
+        Player player = ((BukkitPlayer) localPlayer).getPlayer();
+
+        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.getType() == item.getType() &&
+                            (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);
+        }
+    }
+
+    @Override
+    public void addPlatformReports(ReportList report) {
+        report.add(new ServerReport());
+        report.add(new PluginReport());
+        report.add(new SchedulerReport());
+        report.add(new ServicesReport());
+        report.add(new WorldReport());
+        report.add(new PerformanceReport());
+    }
+}

worldguard-bukkit/src/main/java/com/sk89q/worldguard/bukkit/WorldGuardPlugin.java

@@ -0,0 +1,483 @@
+/*
+ * 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.ImmutableList;
+import com.sk89q.bukkit.util.CommandsManagerRegistration;
+import com.sk89q.minecraft.util.commands.CommandException;
+import com.sk89q.minecraft.util.commands.CommandPermissionsException;
+import com.sk89q.minecraft.util.commands.CommandUsageException;
+import com.sk89q.minecraft.util.commands.CommandsManager;
+import com.sk89q.minecraft.util.commands.MissingNestedCommandException;
+import com.sk89q.minecraft.util.commands.SimpleInjector;
+import com.sk89q.minecraft.util.commands.WrappedCommandException;
+import com.sk89q.wepif.PermissionsResolverManager;
+import com.sk89q.worldedit.bukkit.BukkitAdapter;
+import com.sk89q.worldedit.bukkit.BukkitCommandSender;
+import com.sk89q.worldedit.bukkit.WorldEditPlugin;
+import com.sk89q.worldedit.extension.platform.Actor;
+import com.sk89q.worldguard.LocalPlayer;
+import com.sk89q.worldguard.WorldGuard;
+import com.sk89q.worldguard.commands.GeneralCommands;
+import com.sk89q.worldguard.commands.ProtectionCommands;
+import com.sk89q.worldguard.commands.ToggleCommands;
+import com.sk89q.worldguard.bukkit.event.player.ProcessPlayerEvent;
+import com.sk89q.worldguard.bukkit.listener.BlacklistListener;
+import com.sk89q.worldguard.bukkit.listener.BlockedPotionsListener;
+import com.sk89q.worldguard.bukkit.listener.BuildPermissionListener;
+import com.sk89q.worldguard.bukkit.listener.ChestProtectionListener;
+import com.sk89q.worldguard.bukkit.listener.DebuggingListener;
+import com.sk89q.worldguard.bukkit.listener.EventAbstractionListener;
+import com.sk89q.worldguard.bukkit.listener.InvincibilityListener;
+import com.sk89q.worldguard.bukkit.listener.PlayerModesListener;
+import com.sk89q.worldguard.bukkit.listener.PlayerMoveListener;
+import com.sk89q.worldguard.bukkit.listener.RegionFlagsListener;
+import com.sk89q.worldguard.bukkit.listener.RegionProtectionListener;
+import com.sk89q.worldguard.bukkit.listener.WorldGuardBlockListener;
+import com.sk89q.worldguard.bukkit.listener.WorldGuardCommandBookListener;
+import com.sk89q.worldguard.bukkit.listener.WorldGuardEntityListener;
+import com.sk89q.worldguard.bukkit.listener.WorldGuardHangingListener;
+import com.sk89q.worldguard.bukkit.listener.WorldGuardPlayerListener;
+import com.sk89q.worldguard.bukkit.listener.WorldGuardServerListener;
+import com.sk89q.worldguard.bukkit.listener.WorldGuardVehicleListener;
+import com.sk89q.worldguard.bukkit.listener.WorldGuardWeatherListener;
+import com.sk89q.worldguard.bukkit.listener.WorldGuardWorldListener;
+import com.sk89q.worldguard.bukkit.listener.WorldRulesListener;
+import com.sk89q.worldguard.bukkit.session.BukkitSessionManager;
+import com.sk89q.worldguard.bukkit.util.Events;
+import com.sk89q.worldguard.bukkit.util.logging.ClassSourceValidator;
+import com.sk89q.worldguard.protection.flags.Flag;
+import com.sk89q.worldguard.protection.flags.registry.SimpleFlagRegistry;
+import com.sk89q.worldguard.protection.regions.ProtectedCuboidRegion;
+import com.sk89q.worldguard.protection.regions.ProtectedRegion;
+import com.sk89q.worldguard.util.logging.RecordMessagePrefixer;
+import org.bstats.bukkit.Metrics;
+import org.bukkit.Bukkit;
+import org.bukkit.ChatColor;
+import org.bukkit.OfflinePlayer;
+import org.bukkit.World;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+import org.bukkit.plugin.Plugin;
+import org.bukkit.plugin.java.JavaPlugin;
+
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.jar.JarFile;
+import java.util.logging.Logger;
+import java.util.zip.ZipEntry;
+
+/**
+ * The main class for WorldGuard as a Bukkit plugin.
+ */
+public class WorldGuardPlugin extends JavaPlugin {
+
+    private static WorldGuardPlugin inst;
+    private static BukkitWorldGuardPlatform platform;
+    private final CommandsManager<Actor> commands;
+    private PlayerMoveListener playerMoveListener;
+
+    /**
+     * Construct objects. Actual loading occurs when the plugin is enabled, so
+     * this merely instantiates the objects.
+     */
+    public WorldGuardPlugin() {
+        inst = this;
+        commands = new CommandsManager<Actor>() {
+            @Override
+            public boolean hasPermission(Actor player, String perm) {
+                return player.hasPermission(perm);
+            }
+        };
+    }
+
+    /**
+     * Get the current instance of WorldGuard
+     * @return WorldGuardPlugin instance
+     */
+    public static WorldGuardPlugin inst() {
+        return inst;
+    }
+
+    /**
+     * Called on plugin enable.
+     */
+    @Override
+    public void onEnable() {
+        configureLogger();
+
+        getDataFolder().mkdirs(); // Need to create the plugins/WorldGuard folder
+
+        PermissionsResolverManager.initialize(this);
+
+        WorldGuard.getInstance().setPlatform(platform = new BukkitWorldGuardPlatform()); // Initialise WorldGuard
+        WorldGuard.getInstance().setup();
+        BukkitSessionManager sessionManager = (BukkitSessionManager) platform.getSessionManager();
+
+        // Set the proper command injector
+        commands.setInjector(new SimpleInjector(WorldGuard.getInstance()));
+
+        // Catch bad things being done by naughty plugins that include
+        // WorldGuard's classes
+        ClassSourceValidator verifier = new ClassSourceValidator(this);
+        verifier.reportMismatches(ImmutableList.of(ProtectedRegion.class, ProtectedCuboidRegion.class, Flag.class));
+
+        // Register command classes
+        final CommandsManagerRegistration reg = new CommandsManagerRegistration(this, commands);
+        reg.register(ToggleCommands.class);
+        reg.register(ProtectionCommands.class);
+
+        getServer().getScheduler().scheduleSyncDelayedTask(this, () -> {
+            if (!platform.getGlobalStateManager().hasCommandBookGodMode()) {
+                reg.register(GeneralCommands.class);
+            }
+        }, 0L);
+
+        getServer().getScheduler().scheduleSyncRepeatingTask(this, sessionManager, BukkitSessionManager.RUN_DELAY, BukkitSessionManager.RUN_DELAY);
+
+        // Register events
+        getServer().getPluginManager().registerEvents(sessionManager, this);
+        (new WorldGuardPlayerListener(this)).registerEvents();
+        (new WorldGuardBlockListener(this)).registerEvents();
+        (new WorldGuardEntityListener(this)).registerEvents();
+        (new WorldGuardWeatherListener(this)).registerEvents();
+        (new WorldGuardVehicleListener(this)).registerEvents();
+        (new WorldGuardServerListener(this)).registerEvents();
+        (new WorldGuardHangingListener(this)).registerEvents();
+
+        // Modules
+        (playerMoveListener = new PlayerMoveListener(this)).registerEvents();
+        (new BlacklistListener(this)).registerEvents();
+        (new ChestProtectionListener(this)).registerEvents();
+        (new RegionProtectionListener(this)).registerEvents();
+        (new RegionFlagsListener(this)).registerEvents();
+        (new WorldRulesListener(this)).registerEvents();
+        (new BlockedPotionsListener(this)).registerEvents();
+        (new EventAbstractionListener(this)).registerEvents();
+        (new PlayerModesListener(this)).registerEvents();
+        (new BuildPermissionListener(this)).registerEvents();
+        (new InvincibilityListener(this)).registerEvents();
+        if ("true".equalsIgnoreCase(System.getProperty("worldguard.debug.listener"))) {
+            (new DebuggingListener(this, WorldGuard.logger)).registerEvents();
+        }
+
+        platform.getGlobalStateManager().updateCommandBookGodMode();
+
+        if (getServer().getPluginManager().isPluginEnabled("CommandBook")) {
+            getServer().getPluginManager().registerEvents(new WorldGuardCommandBookListener(this), this);
+        }
+
+        // handle worlds separately to initialize already loaded worlds
+        WorldGuardWorldListener worldListener = (new WorldGuardWorldListener(this));
+        for (World world : getServer().getWorlds()) {
+            worldListener.initWorld(world);
+        }
+        worldListener.registerEvents();
+
+        Bukkit.getScheduler().runTask(this, () -> {
+            for (Player player : Bukkit.getServer().getOnlinePlayers()) {
+                ProcessPlayerEvent event = new ProcessPlayerEvent(player);
+                Events.fire(event);
+            }
+        });
+
+        ((SimpleFlagRegistry) WorldGuard.getInstance().getFlagRegistry()).setInitialized(true);
+
+        // Enable metrics
+        new Metrics(this);
+    }
+
+    @Override
+    public void onDisable() {
+        WorldGuard.getInstance().disable();
+        this.getServer().getScheduler().cancelTasks(this);
+    }
+
+    @Override
+    public boolean onCommand(CommandSender sender, Command cmd, String label, String[] args) {
+        try {
+            Actor actor = wrapCommandSender(sender);
+            try {
+                commands.execute(cmd.getName(), args, actor, actor);
+            } catch (Throwable t) {
+                Throwable next = t;
+                do {
+                    try {
+                        WorldGuard.getInstance().getExceptionConverter().convert(next);
+                    } catch (org.enginehub.piston.exception.CommandException pce) {
+                        if (pce.getCause() instanceof CommandException) {
+                            throw ((CommandException) pce.getCause());
+                        }
+                    }
+                    next = next.getCause();
+                } while (next != null);
+
+                throw t;
+            }
+        } catch (CommandPermissionsException e) {
+            sender.sendMessage(ChatColor.RED + "You don't have permission.");
+        } catch (MissingNestedCommandException e) {
+            sender.sendMessage(ChatColor.RED + e.getUsage());
+        } catch (CommandUsageException e) {
+            sender.sendMessage(ChatColor.RED + e.getMessage());
+            sender.sendMessage(ChatColor.RED + e.getUsage());
+        } catch (WrappedCommandException e) {
+            sender.sendMessage(ChatColor.RED + e.getCause().getMessage());
+        } catch (CommandException e) {
+            sender.sendMessage(ChatColor.RED + e.getMessage());
+        }
+
+        return true;
+    }
+
+    /**
+     * Check whether a player is in a group.
+     * This calls the corresponding method in PermissionsResolverManager
+     *
+     * @param player The player to check
+     * @param group The group
+     * @return whether {@code player} is in {@code group}
+     */
+    public boolean inGroup(OfflinePlayer player, String group) {
+        try {
+            return PermissionsResolverManager.getInstance().inGroup(player, group);
+        } catch (Throwable t) {
+            t.printStackTrace();
+            return false;
+        }
+    }
+
+    /**
+     * Get the groups of a player.
+     * This calls the corresponding method in PermissionsResolverManager.
+     * @param player The player to check
+     * @return The names of each group the playe is in.
+     */
+    public String[] getGroups(OfflinePlayer player) {
+        try {
+            return PermissionsResolverManager.getInstance().getGroups(player);
+        } catch (Throwable t) {
+            t.printStackTrace();
+            return new String[0];
+        }
+    }
+
+    /**
+     * Checks permissions.
+     *
+     * @param sender The sender to check the permission on.
+     * @param perm The permission to check the permission on.
+     * @return whether {@code sender} has {@code perm}
+     */
+    public boolean hasPermission(CommandSender sender, String perm) {
+        if (sender.isOp()) {
+            if (sender instanceof Player) {
+                if (platform.getGlobalStateManager().get(BukkitAdapter.adapt(((Player) sender).getWorld())).opPermissions) {
+                    return true;
+                }
+            } else {
+                return true;
+            }
+        }
+
+        // Invoke the permissions resolver
+        if (sender instanceof Player) {
+            Player player = (Player) sender;
+            return PermissionsResolverManager.getInstance().hasPermission(player.getWorld().getName(), player, perm);
+        }
+
+        return false;
+    }
+
+    /**
+     * Checks permissions and throws an exception if permission is not met.
+     *
+     * @param sender The sender to check the permission on.
+     * @param perm The permission to check the permission on.
+     * @throws CommandPermissionsException if {@code sender} doesn't have {@code perm}
+     */
+    public void checkPermission(CommandSender sender, String perm)
+            throws CommandPermissionsException {
+        if (!hasPermission(sender, perm)) {
+            throw new CommandPermissionsException();
+        }
+    }
+
+    /**
+     * Gets a copy of the WorldEdit plugin.
+     *
+     * @return The WorldEditPlugin instance
+     * @throws CommandException If there is no WorldEditPlugin available
+     */
+    public WorldEditPlugin getWorldEdit() throws CommandException {
+        Plugin worldEdit = getServer().getPluginManager().getPlugin("WorldEdit");
+        if (worldEdit == null) {
+            throw new CommandException("WorldEdit does not appear to be installed.");
+        }
+
+        if (worldEdit instanceof WorldEditPlugin) {
+            return (WorldEditPlugin) worldEdit;
+        } else {
+            throw new CommandException("WorldEdit detection failed (report error).");
+        }
+    }
+
+    /**
+     * Wrap a player as a LocalPlayer.
+     *
+     * @param player The player to wrap
+     * @return The wrapped player
+     */
+    public LocalPlayer wrapPlayer(Player player) {
+        return new BukkitPlayer(this, player);
+    }
+
+    /**
+     * Wrap a player as a LocalPlayer.
+     *
+     * @param player The player to wrap
+     * @param silenced True to silence messages
+     * @return The wrapped player
+     */
+    public LocalPlayer wrapPlayer(Player player, boolean silenced) {
+        return new BukkitPlayer(this, player, silenced);
+    }
+
+    public Actor wrapCommandSender(CommandSender sender) {
+        if (sender instanceof Player) {
+            return wrapPlayer((Player) sender);
+        }
+
+        try {
+            return new BukkitCommandSender(getWorldEdit(), sender);
+        } catch (CommandException e) {
+            e.printStackTrace();
+        }
+        return null;
+    }
+
+    public CommandSender unwrapActor(Actor sender) {
+        if (sender instanceof BukkitPlayer) {
+            return ((BukkitPlayer) sender).getPlayer();
+        } else if (sender instanceof BukkitCommandSender) {
+            return Bukkit.getConsoleSender(); // TODO Fix
+        } else {
+            throw new IllegalArgumentException("Unknown actor type. Please report");
+        }
+    }
+
+    /**
+     * Wrap a player as a LocalPlayer.
+     *
+     * <p>This implementation is incomplete -- permissions cannot be checked.</p>
+     *
+     * @param player The player to wrap
+     * @return The wrapped player
+     */
+    public LocalPlayer wrapOfflinePlayer(OfflinePlayer player) {
+        return new BukkitOfflinePlayer(this, player);
+    }
+
+    /**
+     * Return a protection query helper object that can be used by another
+     * plugin to test whether WorldGuard permits an action at a particular
+     * place.
+     *
+     * @return an instance
+     */
+    public ProtectionQuery createProtectionQuery() {
+        return new ProtectionQuery();
+    }
+
+    /**
+     * Configure WorldGuard's loggers.
+     */
+    private void configureLogger() {
+        RecordMessagePrefixer.register(Logger.getLogger("com.sk89q.worldguard"), "[WorldGuard] ");
+    }
+
+    /**
+     * Create a default configuration file from the .jar.
+     *
+     * @param actual The destination file
+     * @param defaultName The name of the file inside the jar's defaults folder
+     */
+    public void createDefaultConfiguration(File actual, String defaultName) {
+
+        // Make parent directories
+        File parent = actual.getParentFile();
+        if (!parent.exists()) {
+            parent.mkdirs();
+        }
+
+        if (actual.exists()) {
+            return;
+        }
+
+        InputStream input = null;
+        try {
+            JarFile file = new JarFile(getFile());
+            ZipEntry copy = file.getEntry("defaults/" + defaultName);
+            if (copy == null) throw new FileNotFoundException();
+            input = file.getInputStream(copy);
+        } catch (IOException e) {
+            WorldGuard.logger.severe("Unable to read default configuration: " + defaultName);
+        }
+
+        if (input != null) {
+            FileOutputStream output = null;
+
+            try {
+                output = new FileOutputStream(actual);
+                byte[] buf = new byte[8192];
+                int length = 0;
+                while ((length = input.read(buf)) > 0) {
+                    output.write(buf, 0, length);
+                }
+
+                WorldGuard.logger.info("Default configuration file written: "
+                        + actual.getAbsolutePath());
+            } catch (IOException e) {
+                e.printStackTrace();
+            } finally {
+                try {
+                    input.close();
+                } catch (IOException ignore) {
+                }
+
+                try {
+                    if (output != null) {
+                        output.close();
+                    }
+                } catch (IOException ignore) {
+                }
+            }
+        }
+    }
+
+    public PlayerMoveListener getPlayerMoveListener() {
+        return playerMoveListener;
+    }
+
+}

worldguard-bukkit/src/main/java/com/sk89q/worldguard/bukkit/cause/Cause.java

@@ -233,7 +233,7 @@ public final class Cause {
         private boolean indirect;
 
         private Builder(int expectedSize) {
-            this.causes = new ArrayList<Object>(expectedSize);
+            this.causes = new ArrayList<>(expectedSize);
         }
 
         private void addAll(@Nullable Object... element) {
@@ -250,7 +250,10 @@ public final class Cause {
                     } else if (o instanceof Projectile) {
                         addAll(((Projectile) o).getShooter());
                     } else if (o instanceof Vehicle) {
-                        addAll(((Vehicle) o).getPassenger());
+                        addAll(((Vehicle) o).getPassengers());
+                    } else if (o instanceof AreaEffectCloud) {
+                        indirect = true;
+                        addAll(((AreaEffectCloud) o).getSource());
                     } else if (o instanceof Creature && ((Creature) o).getTarget() != null) {
                         indirect = true;
                         addAll(((Creature) o).getTarget());

worldguard-bukkit/src/main/java/com/sk89q/worldguard/bukkit/chest/BukkitSignChestProtection.java

@@ -0,0 +1,54 @@
+/*
+ * 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.chest;
+
+import com.sk89q.worldedit.bukkit.BukkitAdapter;
+import com.sk89q.worldedit.util.Location;
+import com.sk89q.worldguard.LocalPlayer;
+import com.sk89q.worldguard.chest.SignChestProtection;
+import org.bukkit.block.BlockState;
+import org.bukkit.block.Sign;
+
+public class BukkitSignChestProtection extends SignChestProtection {
+
+    private Boolean isProtectedSign(Sign sign, LocalPlayer player) {
+        if (sign.getLine(0).equalsIgnoreCase("[Lock]")) {
+            if (player == null) { // No player, no access
+                return true;
+            }
+            
+            String name = player.getName();
+            return !name.equalsIgnoreCase(sign.getLine(1).trim())
+                    && !name.equalsIgnoreCase(sign.getLine(2).trim())
+                    && !name.equalsIgnoreCase(sign.getLine(3).trim());
+        }
+        
+        return null;
+    }
+
+    @Override
+    public Boolean isProtectedSign(Location block, LocalPlayer player) {
+        BlockState state = BukkitAdapter.adapt(block).getBlock().getState();
+        if (!(state instanceof Sign)) {
+            return null;
+        }
+        return isProtectedSign((Sign) state, player);
+    }
+}

worldguard-bukkit/src/main/java/com/sk89q/worldguard/bukkit/event/DelegateEvent.java

@@ -126,7 +126,7 @@ public abstract class DelegateEvent extends Event implements Cancellable, Handle
     }
 
     /**
-     * Set the event to {@link Result#ALLOW} if {@code allowed} is true.
+     * Set the event to {@link org.bukkit.event.Event.Result#ALLOW} if {@code allowed} is true.
      *
      * @param allowed true to set the result
      * @return the same event

worldguard-bukkit/src/main/java/com/sk89q/worldguard/bukkit/event/block/AbstractBlockEvent.java

@@ -19,22 +19,23 @@
 
 package com.sk89q.worldguard.bukkit.event.block;
 
-import com.google.common.base.Predicate;
+import static com.google.common.base.Preconditions.checkNotNull;
+
 import com.sk89q.worldguard.bukkit.cause.Cause;
-import com.sk89q.worldguard.bukkit.event.DelegateEvent;
 import com.sk89q.worldguard.bukkit.event.BulkEvent;
+import com.sk89q.worldguard.bukkit.event.DelegateEvent;
 import org.bukkit.Location;
 import org.bukkit.Material;
 import org.bukkit.World;
 import org.bukkit.block.Block;
 import org.bukkit.event.Event;
 
-import javax.annotation.Nullable;
 import java.util.ArrayList;
 import java.util.Iterator;
 import java.util.List;
+import java.util.function.Predicate;
 
-import static com.google.common.base.Preconditions.checkNotNull;
+import javax.annotation.Nullable;
 
 /**
  * This event is an internal event. We do not recommend handling or throwing
@@ -65,7 +66,7 @@ abstract class AbstractBlockEvent extends DelegateEvent implements BulkEvent {
     }
 
     private static List<Block> createList(Block block) {
-        List<Block> blocks = new ArrayList<Block>();
+        List<Block> blocks = new ArrayList<>();
         blocks.add(block);
         return blocks;
     }
@@ -102,7 +103,7 @@ abstract class AbstractBlockEvent extends DelegateEvent implements BulkEvent {
 
         Iterator<Block> it = blocks.iterator();
         while (it.hasNext()) {
-            if (!predicate.apply(it.next().getLocation())) {
+            if (!predicate.test(it.next().getLocation())) {
                 hasRemoval = true;
 
                 if (cancelEventOnFalse) {

worldguard-bukkit/src/main/java/com/sk89q/worldguard/bukkit/event/debug/CancelLogger.java

@@ -29,7 +29,7 @@ import java.util.List;
  */
 public class CancelLogger {
 
-    private List<CancelAttempt> entries = new ArrayList<CancelAttempt>();
+    private List<CancelAttempt> entries = new ArrayList<>();
 
     /**
      * Log a call.

worldguard-bukkit/src/main/java/com/sk89q/worldguard/bukkit/event/debug/LoggingPlayerInteractEvent.java

@@ -36,10 +36,23 @@ public class LoggingPlayerInteractEvent extends PlayerInteractEvent implements C
         super(who, action, item, clickedBlock, clickedFace);
     }
 
+    @Override
     public List<CancelAttempt> getCancels() {
         return logger.getCancels();
     }
 
+    @Override
+    public void setUseInteractedBlock(Result useInteractedBlock) {
+        this.logger.log(useInteractedBlock() == Result.DENY, useInteractedBlock == Result.DENY, new Exception().getStackTrace());
+        super.setUseInteractedBlock(useInteractedBlock);
+    }
+
+    @Override
+    public void setUseItemInHand(Result useItemInHand) {
+        this.logger.log(useItemInHand() == Result.DENY, useItemInHand == Result.DENY, new Exception().getStackTrace());
+        super.setUseItemInHand(useItemInHand);
+    }
+
     @Override
     public void setCancelled(boolean cancel) {
         this.logger.log(isCancelled(), cancel, new Exception().getStackTrace());

worldguard-bukkit/src/main/java/com/sk89q/worldguard/bukkit/internal/TargetMatcherSet.java

@@ -21,7 +21,9 @@ package com.sk89q.worldguard.bukkit.internal;
 
 import com.google.common.collect.HashMultimap;
 import com.google.common.collect.Multimap;
-import com.sk89q.worldguard.blacklist.target.MaterialTarget;
+import com.sk89q.worldedit.bukkit.BukkitAdapter;
+import com.sk89q.worldguard.blacklist.target.BlockTarget;
+import com.sk89q.worldguard.blacklist.target.ItemTarget;
 import com.sk89q.worldguard.blacklist.target.Target;
 import com.sk89q.worldguard.blacklist.target.TargetMatcher;
 import org.bukkit.Material;
@@ -35,7 +37,7 @@ import static com.google.common.base.Preconditions.checkNotNull;
 
 public class TargetMatcherSet {
 
-    private final Multimap<Integer, TargetMatcher> entries = HashMultimap.create();
+    private final Multimap<String, TargetMatcher> entries = HashMultimap.create();
 
     public boolean add(TargetMatcher matcher) {
         checkNotNull(matcher);
@@ -55,19 +57,23 @@ public class TargetMatcherSet {
     }
 
     public boolean test(Material material) {
-        return test(new MaterialTarget(material.getId(), (short) 0));
+        if (material.isBlock()) {
+            return test(new BlockTarget(BukkitAdapter.asBlockType(material)));
+        } else {
+            return test(new ItemTarget(BukkitAdapter.asItemType(material)));
+        }
     }
 
     public boolean test(Block block) {
-        return test(new MaterialTarget(block.getTypeId(), block.getData()));
+        return test(new BlockTarget(BukkitAdapter.asBlockType(block.getType())));
     }
 
     public boolean test(BlockState state) {
-        return test(new MaterialTarget(state.getTypeId(), state.getRawData()));
+        return test(new BlockTarget(BukkitAdapter.asBlockType(state.getType())));
     }
 
     public boolean test(ItemStack itemStack) {
-        return test(new MaterialTarget(itemStack.getTypeId(), itemStack.getDurability()));
+        return test(new ItemTarget(BukkitAdapter.asItemType(itemStack.getType())));
     }
 
     @Override

worldguard-bukkit/src/main/java/com/sk89q/worldguard/bukkit/listener/AbstractListener.java

@@ -19,15 +19,16 @@
 
 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;
 
+import com.sk89q.worldedit.world.World;
+import com.sk89q.worldguard.LocalPlayer;
+import com.sk89q.worldguard.WorldGuard;
+import com.sk89q.worldguard.bukkit.WorldGuardPlugin;
+import com.sk89q.worldguard.config.ConfigurationManager;
+import com.sk89q.worldguard.config.WorldConfiguration;
+import org.bukkit.event.Listener;
+
 /**
  * Abstract listener to ease creation of listeners.
  */
@@ -67,7 +68,7 @@ class AbstractListener implements Listener {
      * @return the configuration
      */
     protected ConfigurationManager getConfig() {
-        return plugin.getGlobalStateManager();
+        return WorldGuard.getInstance().getPlatform().getGlobalStateManager();
     }
 
     /**
@@ -77,7 +78,7 @@ class AbstractListener implements Listener {
      * @return The configuration for {@code world}
      */
     protected WorldConfiguration getWorldConfig(World world) {
-        return plugin.getGlobalStateManager().get(world);
+        return getConfig().get(world);
     }
 
     /**
@@ -86,8 +87,8 @@ class AbstractListener implements Listener {
      * @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());
+    protected WorldConfiguration getWorldConfig(LocalPlayer player) {
+        return getWorldConfig((World) player.getExtent());
     }
 
     /**

worldguard-bukkit/src/main/java/com/sk89q/worldguard/bukkit/listener/BlacklistListener.java

@@ -19,11 +19,19 @@
 
 package com.sk89q.worldguard.bukkit.listener;
 
-import com.google.common.base.Predicate;
+import static com.sk89q.worldguard.bukkit.BukkitUtil.createTarget;
+
+import com.sk89q.worldedit.bukkit.BukkitAdapter;
 import com.sk89q.worldguard.LocalPlayer;
-import com.sk89q.worldguard.blacklist.event.*;
-import com.sk89q.worldguard.bukkit.ConfigurationManager;
-import com.sk89q.worldguard.bukkit.WorldConfiguration;
+import com.sk89q.worldguard.WorldGuard;
+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.WorldGuardPlugin;
 import com.sk89q.worldguard.bukkit.event.block.BreakBlockEvent;
 import com.sk89q.worldguard.bukkit.event.block.PlaceBlockEvent;
@@ -32,12 +40,14 @@ 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 com.sk89q.worldguard.config.ConfigurationManager;
+import com.sk89q.worldguard.config.WorldConfiguration;
 import org.bukkit.Material;
 import org.bukkit.entity.Entity;
 import org.bukkit.entity.HumanEntity;
 import org.bukkit.entity.Item;
 import org.bukkit.entity.Player;
+import org.bukkit.event.Event;
 import org.bukkit.event.EventHandler;
 import org.bukkit.event.block.BlockDispenseEvent;
 import org.bukkit.event.inventory.InventoryClickEvent;
@@ -47,9 +57,6 @@ import org.bukkit.event.player.PlayerItemHeldEvent;
 import org.bukkit.inventory.Inventory;
 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.
  */
@@ -73,26 +80,23 @@ public class BlacklistListener extends AbstractListener {
         }
 
         final LocalPlayer localPlayer = getPlugin().wrapPlayer(player);
-        final WorldConfiguration wcfg = getWorldConfig(player);
+        final WorldConfiguration wcfg = getWorldConfig(localPlayer);
 
         // 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;
+        event.filter(target -> {
+            if (!wcfg.getBlacklist().check(
+                    new BlockBreakBlacklistEvent(localPlayer, BukkitAdapter.asBlockVector(target), createTarget(target.getBlock(), event.getEffectiveMaterial())), false, false)) {
+                return false;
+            } else if (!wcfg.getBlacklist().check(
+                    new ItemDestroyWithBlacklistEvent(localPlayer, BukkitAdapter.asBlockVector(target), createTarget(player.getItemInHand())), false, false)) {
+                return false;
             }
+
+            return true;
         });
     }
 
@@ -105,25 +109,22 @@ public class BlacklistListener extends AbstractListener {
         }
 
         final LocalPlayer localPlayer = getPlugin().wrapPlayer(player);
-        final WorldConfiguration wcfg = getWorldConfig(player);
+        final WorldConfiguration wcfg = getWorldConfig(localPlayer);
 
         // 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);
-
-            }
-        });
+        event.filter(target -> wcfg.getBlacklist().check(new BlockPlaceBlacklistEvent(
+                localPlayer, BukkitAdapter.asBlockVector(target), createTarget(target.getBlock(), event.getEffectiveMaterial())), false, false));
     }
 
     @EventHandler(ignoreCancelled = true)
     public void onUseBlock(final UseBlockEvent event) {
+        if (event.getResult() == Event.Result.ALLOW) {
+            return;
+        }
         Player player = event.getCause().getFirstPlayer();
 
         if (player == null) {
@@ -131,20 +132,15 @@ public class BlacklistListener extends AbstractListener {
         }
 
         final LocalPlayer localPlayer = getPlugin().wrapPlayer(player);
-        final WorldConfiguration wcfg = getWorldConfig(player);
+        final WorldConfiguration wcfg = getWorldConfig(localPlayer);
 
         // 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);
-            }
-        });
+        event.filter(target -> wcfg.getBlacklist().check(new BlockInteractBlacklistEvent(
+                localPlayer, BukkitAdapter.asBlockVector(target), createTarget(target.getBlock(), event.getEffectiveMaterial())), false, false));
     }
 
     @EventHandler(ignoreCancelled = true)
@@ -156,7 +152,7 @@ public class BlacklistListener extends AbstractListener {
         }
 
         LocalPlayer localPlayer = getPlugin().wrapPlayer(player);
-        WorldConfiguration wcfg = getWorldConfig(player);
+        WorldConfiguration wcfg = getWorldConfig(localPlayer);
 
         // Blacklist guard
         if (wcfg.getBlacklist() == null) {
@@ -165,7 +161,7 @@ public class BlacklistListener extends AbstractListener {
 
         Material material = Materials.getRelatedMaterial(event.getEffectiveType());
         if (material != null) {
-            if (!wcfg.getBlacklist().check(new ItemUseBlacklistEvent(localPlayer, toVector(event.getTarget()), createTarget(material)), false, false)) {
+            if (!wcfg.getBlacklist().check(new ItemUseBlacklistEvent(localPlayer, BukkitAdapter.asBlockVector(event.getTarget()), createTarget(material)), false, false)) {
                 event.setCancelled(true);
             }
         }
@@ -181,7 +177,7 @@ public class BlacklistListener extends AbstractListener {
 
         LocalPlayer localPlayer = getPlugin().wrapPlayer(player);
         Entity target = event.getEntity();
-        WorldConfiguration wcfg = getWorldConfig(player);
+        WorldConfiguration wcfg = getWorldConfig(localPlayer);
 
         // Blacklist guard
         if (wcfg.getBlacklist() == null) {
@@ -192,7 +188,7 @@ public class BlacklistListener extends AbstractListener {
             Item item = (Item) target;
             if (!wcfg.getBlacklist().check(
                     new ItemAcquireBlacklistEvent(localPlayer,
-                            toVector(target.getLocation()), createTarget(item.getItemStack())), false, true)) {
+                            BukkitAdapter.asBlockVector(target.getLocation()), createTarget(item.getItemStack())), false, true)) {
                 event.setCancelled(true);
                 return;
             }
@@ -201,7 +197,7 @@ public class BlacklistListener extends AbstractListener {
         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)) {
+            if (!wcfg.getBlacklist().check(new BlockBreakBlacklistEvent(localPlayer, BukkitAdapter.asBlockVector(event.getTarget()), createTarget(material)), false, false)) {
                 event.setCancelled(true);
             }
         }
@@ -217,29 +213,29 @@ public class BlacklistListener extends AbstractListener {
 
         LocalPlayer localPlayer = getPlugin().wrapPlayer(player);
         ItemStack target = event.getItemStack();
-        WorldConfiguration wcfg = getWorldConfig(player);
+        WorldConfiguration wcfg = getWorldConfig(localPlayer);
 
         // Blacklist guard
         if (wcfg.getBlacklist() == null) {
             return;
         }
 
-        if (!wcfg.getBlacklist().check(new ItemUseBlacklistEvent(localPlayer, toVector(player.getLocation()), createTarget(target)), false, false)) {
+        if (!wcfg.getBlacklist().check(new ItemUseBlacklistEvent(localPlayer, BukkitAdapter.asBlockVector(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());
+        ConfigurationManager cfg = WorldGuard.getInstance().getPlatform().getGlobalStateManager();
+        WorldConfiguration wcfg = cfg.get(BukkitAdapter.adapt(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)) {
+                            BukkitAdapter.asBlockVector(ci.getLocation()), createTarget(ci.getItemStack())), false, false)) {
                 event.setCancelled(true);
             }
         }
@@ -247,11 +243,12 @@ public class BlacklistListener extends AbstractListener {
 
     @EventHandler(ignoreCancelled = true)
     public void onBlockDispense(BlockDispenseEvent event) {
-        ConfigurationManager cfg = getPlugin().getGlobalStateManager();
-        WorldConfiguration wcfg = cfg.get(event.getBlock().getWorld());
+        ConfigurationManager cfg = WorldGuard.getInstance().getPlatform().getGlobalStateManager();
+        WorldConfiguration wcfg = cfg.get(BukkitAdapter.adapt(event.getBlock().getWorld()));
 
         if (wcfg.getBlacklist() != null) {
-            if (!wcfg.getBlacklist().check(new BlockDispenseBlacklistEvent(null, toVector(event.getBlock()), createTarget(event.getItem())), false, false)) {
+            if (!wcfg.getBlacklist().check(new BlockDispenseBlacklistEvent(null, BukkitAdapter.asBlockVector(event.getBlock().getLocation()),
+                    createTarget(event.getItem())), false, false)) {
                 event.setCancelled(true);
             }
         }
@@ -263,14 +260,14 @@ public class BlacklistListener extends AbstractListener {
         Inventory inventory = event.getInventory();
         ItemStack item = event.getCurrentItem();
 
-        if (item != null && entity instanceof Player) {
+        if (item != null && inventory != null && inventory.getHolder() != null && entity instanceof Player) {
             Player player = (Player) entity;
-            ConfigurationManager cfg = getPlugin().getGlobalStateManager();
-            WorldConfiguration wcfg = cfg.get(entity.getWorld());
+            ConfigurationManager cfg = WorldGuard.getInstance().getPlatform().getGlobalStateManager();
+            WorldConfiguration wcfg = cfg.get(BukkitAdapter.adapt(entity.getWorld()));
             LocalPlayer localPlayer = getPlugin().wrapPlayer(player);
 
             if (wcfg.getBlacklist() != null && !wcfg.getBlacklist().check(
-                    new ItemAcquireBlacklistEvent(localPlayer, toVector(entity.getLocation()), createTarget(item)), false, false)) {
+                    new ItemAcquireBlacklistEvent(localPlayer, BukkitAdapter.asBlockVector(entity.getLocation()), createTarget(item)), false, false)) {
                 event.setCancelled(true);
 
                 if (inventory.getHolder().equals(player)) {
@@ -287,12 +284,12 @@ public class BlacklistListener extends AbstractListener {
 
         if (item != null && entity instanceof Player) {
             Player player = (Player) entity;
-            ConfigurationManager cfg = getPlugin().getGlobalStateManager();
-            WorldConfiguration wcfg = cfg.get(entity.getWorld());
+            ConfigurationManager cfg = WorldGuard.getInstance().getPlatform().getGlobalStateManager();
+            WorldConfiguration wcfg = cfg.get(BukkitAdapter.adapt(entity.getWorld()));
             LocalPlayer localPlayer = getPlugin().wrapPlayer(player);
 
             if (wcfg.getBlacklist() != null && !wcfg.getBlacklist().check(
-                    new ItemAcquireBlacklistEvent(localPlayer, toVector(entity.getLocation()), createTarget(item)), false, false)) {
+                    new ItemAcquireBlacklistEvent(localPlayer, BukkitAdapter.asBlockVector(entity.getLocation()), createTarget(item)), false, false)) {
                 event.setCancelled(true);
                 event.setCursor(null);
             }
@@ -306,12 +303,12 @@ public class BlacklistListener extends AbstractListener {
         ItemStack item = inventory.getItem(event.getNewSlot());
 
         if (item != null) {
-            ConfigurationManager cfg = getPlugin().getGlobalStateManager();
-            WorldConfiguration wcfg = cfg.get(player.getWorld());
+            ConfigurationManager cfg = WorldGuard.getInstance().getPlatform().getGlobalStateManager();
+            WorldConfiguration wcfg = cfg.get(BukkitAdapter.adapt(player.getWorld()));
             LocalPlayer localPlayer = getPlugin().wrapPlayer(player);
 
             if (wcfg.getBlacklist() != null && !wcfg.getBlacklist().check(
-                    new ItemAcquireBlacklistEvent(localPlayer, toVector(player.getLocation()), createTarget(item)), false, false)) {
+                    new ItemAcquireBlacklistEvent(localPlayer, BukkitAdapter.asBlockVector(player.getLocation()), createTarget(item)), false, false)) {
                 inventory.setItem(event.getNewSlot(), null);
             }
         }

worldguard-bukkit/src/main/java/com/sk89q/worldguard/bukkit/listener/BlockedPotionsListener.java

@@ -19,8 +19,10 @@
 
 package com.sk89q.worldguard.bukkit.listener;
 
-import com.sk89q.worldguard.bukkit.ConfigurationManager;
-import com.sk89q.worldguard.bukkit.WorldConfiguration;
+import com.sk89q.worldedit.bukkit.BukkitAdapter;
+import com.sk89q.worldguard.WorldGuard;
+import com.sk89q.worldguard.bukkit.BukkitWorldConfiguration;
+import com.sk89q.worldguard.config.ConfigurationManager;
 import com.sk89q.worldguard.bukkit.WorldGuardPlugin;
 import com.sk89q.worldguard.bukkit.event.entity.DamageEntityEvent;
 import com.sk89q.worldguard.bukkit.event.inventory.UseItemEvent;
@@ -57,8 +59,8 @@ public class BlockedPotionsListener extends AbstractListener {
         if (event.getOriginalEvent() instanceof EntityDamageByEntityEvent) {
             EntityDamageByEntityEvent originalEvent = (EntityDamageByEntityEvent) event.getOriginalEvent();
             if (Entities.isPotionArrow(originalEvent.getDamager())) { // should take care of backcompat
-                ConfigurationManager cfg = getPlugin().getGlobalStateManager();
-                WorldConfiguration wcfg = cfg.get(event.getWorld());
+                ConfigurationManager cfg = WorldGuard.getInstance().getPlatform().getGlobalStateManager();
+                BukkitWorldConfiguration wcfg = (BukkitWorldConfiguration) cfg.get(BukkitAdapter.adapt(event.getWorld()));
                 PotionEffectType blockedEffect = null;
                 if (originalEvent.getDamager() instanceof SpectralArrow) {
                     if (wcfg.blockPotions.contains(PotionEffectType.GLOWING)) {
@@ -95,8 +97,8 @@ public class BlockedPotionsListener extends AbstractListener {
 
     @EventHandler
     public void onItemInteract(UseItemEvent event) {
-        ConfigurationManager cfg = getPlugin().getGlobalStateManager();
-        WorldConfiguration wcfg = cfg.get(event.getWorld());
+        ConfigurationManager cfg = WorldGuard.getInstance().getPlatform().getGlobalStateManager();
+        BukkitWorldConfiguration wcfg = (BukkitWorldConfiguration) cfg.get(BukkitAdapter.adapt(event.getWorld()));
         ItemStack item = event.getItemStack();
 
         // We only care about potions

worldguard-bukkit/src/main/java/com/sk89q/worldguard/bukkit/listener/BuildPermissionListener.java

@@ -19,6 +19,7 @@
 
 package com.sk89q.worldguard.bukkit.listener;
 
+import com.sk89q.worldedit.bukkit.BukkitAdapter;
 import com.sk89q.worldguard.bukkit.WorldGuardPlugin;
 import com.sk89q.worldguard.bukkit.event.block.BreakBlockEvent;
 import com.sk89q.worldguard.bukkit.event.block.PlaceBlockEvent;
@@ -51,7 +52,7 @@ public class BuildPermissionListener extends AbstractListener {
     }
 
     private void tellErrorMessage(CommandSender sender, World world) {
-        String message = getWorldConfig(world).buildPermissionDenyMessage;
+        String message = getWorldConfig(BukkitAdapter.adapt(world)).buildPermissionDenyMessage;
         if (!message.isEmpty()) {
             sender.sendMessage(message);
         }
@@ -59,7 +60,7 @@ public class BuildPermissionListener extends AbstractListener {
 
     @EventHandler(ignoreCancelled = true)
     public void onPlaceBlock(final PlaceBlockEvent event) {
-        if (!getWorldConfig(event.getWorld()).buildPermissions) return;
+        if (!getWorldConfig(BukkitAdapter.adapt(event.getWorld())).buildPermissions) return;
 
         Object rootCause = event.getCause().getRootCause();
 
@@ -77,7 +78,7 @@ public class BuildPermissionListener extends AbstractListener {
 
     @EventHandler(ignoreCancelled = true)
     public void onBreakBlock(final BreakBlockEvent event) {
-        if (!getWorldConfig(event.getWorld()).buildPermissions) return;
+        if (!getWorldConfig(BukkitAdapter.adapt(event.getWorld())).buildPermissions) return;
 
         Object rootCause = event.getCause().getRootCause();
 
@@ -95,7 +96,7 @@ public class BuildPermissionListener extends AbstractListener {
 
     @EventHandler(ignoreCancelled = true)
     public void onUseBlock(final UseBlockEvent event) {
-        if (!getWorldConfig(event.getWorld()).buildPermissions) return;
+        if (!getWorldConfig(BukkitAdapter.adapt(event.getWorld())).buildPermissions) return;
 
         Object rootCause = event.getCause().getRootCause();
 
@@ -113,7 +114,7 @@ public class BuildPermissionListener extends AbstractListener {
 
     @EventHandler(ignoreCancelled = true)
     public void onSpawnEntity(SpawnEntityEvent event) {
-        if (!getWorldConfig(event.getWorld()).buildPermissions) return;
+        if (!getWorldConfig(BukkitAdapter.adapt(event.getWorld())).buildPermissions) return;
 
         Object rootCause = event.getCause().getRootCause();
 
@@ -131,7 +132,7 @@ public class BuildPermissionListener extends AbstractListener {
 
     @EventHandler(ignoreCancelled = true)
     public void onDestroyEntity(DestroyEntityEvent event) {
-        if (!getWorldConfig(event.getWorld()).buildPermissions) return;
+        if (!getWorldConfig(BukkitAdapter.adapt(event.getWorld())).buildPermissions) return;
 
         Object rootCause = event.getCause().getRootCause();
 
@@ -149,7 +150,7 @@ public class BuildPermissionListener extends AbstractListener {
 
     @EventHandler(ignoreCancelled = true)
     public void onUseEntity(UseEntityEvent event) {
-        if (!getWorldConfig(event.getWorld()).buildPermissions) return;
+        if (!getWorldConfig(BukkitAdapter.adapt(event.getWorld())).buildPermissions) return;
 
         Object rootCause = event.getCause().getRootCause();
 
@@ -167,7 +168,7 @@ public class BuildPermissionListener extends AbstractListener {
 
     @EventHandler(ignoreCancelled = true)
     public void onDamageEntity(DamageEntityEvent event) {
-        if (!getWorldConfig(event.getWorld()).buildPermissions) return;
+        if (!getWorldConfig(BukkitAdapter.adapt(event.getWorld())).buildPermissions) return;
 
         Object rootCause = event.getCause().getRootCause();
 
@@ -185,7 +186,7 @@ public class BuildPermissionListener extends AbstractListener {
 
     @EventHandler(ignoreCancelled = true)
     public void onUseItem(UseItemEvent event) {
-        if (!getWorldConfig(event.getWorld()).buildPermissions) return;
+        if (!getWorldConfig(BukkitAdapter.adapt(event.getWorld())).buildPermissions) return;
 
         Object rootCause = event.getCause().getRootCause();
 

worldguard-bukkit/src/main/java/com/sk89q/worldguard/bukkit/listener/ChestProtectionListener.java

@@ -19,16 +19,16 @@
 
 package com.sk89q.worldguard.bukkit.listener;
 
-import com.google.common.base.Predicate;
-import com.sk89q.worldedit.blocks.BlockID;
-import com.sk89q.worldguard.bukkit.WorldConfiguration;
+import com.sk89q.worldedit.bukkit.BukkitAdapter;
+import com.sk89q.worldguard.LocalPlayer;
+import com.sk89q.worldguard.bukkit.BukkitWorldConfiguration;
 import com.sk89q.worldguard.bukkit.WorldGuardPlugin;
 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 org.bukkit.ChatColor;
-import org.bukkit.Location;
+import org.bukkit.Material;
 import org.bukkit.entity.Player;
 import org.bukkit.event.EventHandler;
 import org.bukkit.event.block.SignChangeEvent;
@@ -58,23 +58,21 @@ public class ChestProtectionListener extends AbstractListener {
         final Player player = event.getCause().getFirstPlayer();
 
         if (player != null) {
-            final WorldConfiguration wcfg = getWorldConfig(player);
+            final BukkitWorldConfiguration wcfg = (BukkitWorldConfiguration) getWorldConfig(WorldGuardPlugin.inst().wrapPlayer(player));
 
             // Early guard
             if (!wcfg.signChestProtection) {
                 return;
             }
 
-            event.filter(new Predicate<Location>() {
-                @Override
-                public boolean apply(Location target) {
-                    if (wcfg.getChestProtection().isChest(event.getEffectiveMaterial().getId()) && wcfg.isChestProtected(target.getBlock(), player)) {
-                        sendMessage(event, player, ChatColor.DARK_RED + "This spot is for a chest that you don't have permission for.");
-                        return false;
-                    }
-
-                    return true;
+            event.filter(target -> {
+                if (wcfg.getChestProtection().isChest(BukkitAdapter.asBlockType(event.getEffectiveMaterial())) && wcfg.isChestProtected(BukkitAdapter.adapt(target.getBlock().getLocation()),
+                        WorldGuardPlugin.inst().wrapPlayer(player))) {
+                    sendMessage(event, player, ChatColor.DARK_RED + "This spot is for a chest that you don't have permission for.");
+                    return false;
                 }
+
+                return true;
             }, true);
         }
     }
@@ -83,7 +81,7 @@ public class ChestProtectionListener extends AbstractListener {
     public void onBreakBlock(final BreakBlockEvent event) {
         final Player player = event.getCause().getFirstPlayer();
 
-        final WorldConfiguration wcfg = getWorldConfig(event.getWorld());
+        final BukkitWorldConfiguration wcfg = (BukkitWorldConfiguration) getWorldConfig(BukkitAdapter.adapt(event.getWorld()));
 
         // Early guard
         if (!wcfg.signChestProtection) {
@@ -91,25 +89,17 @@ public class ChestProtectionListener extends AbstractListener {
         }
 
         if (player != null) {
-            event.filter(new Predicate<Location>() {
-                @Override
-                public boolean apply(Location target) {
-                    if (wcfg.isChestProtected(target.getBlock(), player)) {
-                        sendMessage(event, player, ChatColor.DARK_RED + "This chest is protected.");
-                        return false;
-                    }
-
-                    return true;
+            final LocalPlayer localPlayer = WorldGuardPlugin.inst().wrapPlayer(player);
+            event.filter(target -> {
+                if (wcfg.isChestProtected(BukkitAdapter.adapt(target.getBlock().getLocation()), localPlayer)) {
+                    sendMessage(event, player, ChatColor.DARK_RED + "This chest is protected.");
+                    return false;
                 }
+
+                return true;
             }, true);
         } else {
-            event.filter(new Predicate<Location>() {
-                @Override
-                public boolean apply(Location target) {
-                    return !wcfg.isChestProtected(target.getBlock());
-
-                }
-            });
+            event.filter(target -> !wcfg.isChestProtected(BukkitAdapter.adapt(target.getBlock().getLocation())));
         }
     }
 
@@ -117,7 +107,7 @@ public class ChestProtectionListener extends AbstractListener {
     public void onUseBlock(final UseBlockEvent event) {
         final Player player = event.getCause().getFirstPlayer();
 
-        final WorldConfiguration wcfg = getWorldConfig(event.getWorld());
+        final BukkitWorldConfiguration wcfg = (BukkitWorldConfiguration) getWorldConfig(BukkitAdapter.adapt(event.getWorld()));
 
         // Early guard
         if (!wcfg.signChestProtection) {
@@ -125,43 +115,35 @@ public class ChestProtectionListener extends AbstractListener {
         }
 
         if (player != null) {
-            event.filter(new Predicate<Location>() {
-                @Override
-                public boolean apply(Location target) {
-                    if (wcfg.isChestProtected(target.getBlock(), player)) {
-                        sendMessage(event, player, ChatColor.DARK_RED + "This chest is protected.");
-                        return false;
-                    }
-
-                    return true;
+            final LocalPlayer localPlayer = WorldGuardPlugin.inst().wrapPlayer(player);
+            event.filter(target -> {
+                if (wcfg.isChestProtected(BukkitAdapter.adapt(target.getBlock().getLocation()), localPlayer)) {
+                    sendMessage(event, player, ChatColor.DARK_RED + "This chest is protected.");
+                    return false;
                 }
+
+                return true;
             }, true);
         } else {
-            event.filter(new Predicate<Location>() {
-                @Override
-                public boolean apply(Location target) {
-                    return !wcfg.isChestProtected(target.getBlock());
-
-                }
-            });
+            event.filter(target -> !wcfg.isChestProtected(BukkitAdapter.adapt(target.getBlock().getLocation())));
         }
     }
 
     @EventHandler(ignoreCancelled = true)
     public void onSignChange(SignChangeEvent event) {
         Player player = event.getPlayer();
-        WorldConfiguration wcfg = getWorldConfig(player);
+        BukkitWorldConfiguration wcfg = (BukkitWorldConfiguration) getWorldConfig(WorldGuardPlugin.inst().wrapPlayer(player));
 
         if (wcfg.signChestProtection) {
             if (event.getLine(0).equalsIgnoreCase("[Lock]")) {
-                if (wcfg.isChestProtectedPlacement(event.getBlock(), player)) {
+                if (wcfg.isChestProtectedPlacement(BukkitAdapter.adapt(event.getBlock().getLocation()), WorldGuardPlugin.inst().wrapPlayer(player))) {
                     player.sendMessage(ChatColor.DARK_RED + "You do not own the adjacent chest.");
                     event.getBlock().breakNaturally();
                     event.setCancelled(true);
                     return;
                 }
 
-                if (event.getBlock().getTypeId() != BlockID.SIGN_POST) {
+                if (event.getBlock().getType() != Material.SIGN) {
                     player.sendMessage(ChatColor.RED
                             + "The [Lock] sign must be a sign post, not a wall sign.");
 
@@ -179,10 +161,10 @@ public class ChestProtectionListener extends AbstractListener {
                     return;
                 }
 
-                int below = event.getBlock().getRelative(0, -1, 0).getTypeId();
+                Material below = event.getBlock().getRelative(0, -1, 0).getType();
 
-                if (below == BlockID.TNT || below == BlockID.SAND
-                        || below == BlockID.GRAVEL || below == BlockID.SIGN_POST) {
+                if (below == Material.TNT || below == Material.SAND
+                        || below == Material.GRAVEL || below == Material.SIGN) {
                     player.sendMessage(ChatColor.RED
                             + "That is not a safe block that you're putting this sign on.");
 

worldguard-bukkit/src/main/java/com/sk89q/worldguard/bukkit/listener/DebuggingListener.java

@@ -23,6 +23,7 @@ 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.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;
@@ -33,6 +34,7 @@ import org.bukkit.event.Event;
 import org.bukkit.event.Event.Result;
 import org.bukkit.event.EventHandler;
 import org.bukkit.event.EventPriority;
+import org.bukkit.event.player.PlayerInteractEvent;
 
 import javax.annotation.Nullable;
 import java.util.List;
@@ -61,13 +63,13 @@ public class DebuggingListener extends AbstractListener {
         StringBuilder builder = new StringBuilder();
         builder.append("PLACE");
         builder.append(" ");
-        builder.append("").append(event.getEffectiveMaterial());
+        builder.append(event.getEffectiveMaterial());
         builder.append(" ");
         builder.append("@").append(toBlockString(event.getBlocks()));
         builder.append(" ");
         builder.append("[").append(event.getCause()).append("]");
         builder.append(" ");
-        builder.append(":").append(getEventName(event.getOriginalEvent()));
+        builder.append(": ").append(getEventName(event.getOriginalEvent()));
         if (event.getResult() != Result.DEFAULT) {
             builder.append(" [").append(event.getResult()).append("]");
         }
@@ -79,13 +81,13 @@ public class DebuggingListener extends AbstractListener {
         StringBuilder builder = new StringBuilder();
         builder.append("DIG");
         builder.append(" ");
-        builder.append("").append(event.getEffectiveMaterial());
+        builder.append(event.getEffectiveMaterial());
         builder.append(" ");
         builder.append("[").append(event.getCause()).append("]");
         builder.append(" ");
         builder.append("@").append(toBlockString(event.getBlocks()));
         builder.append(" ");
-        builder.append(":").append(getEventName(event.getOriginalEvent()));
+        builder.append(": ").append(getEventName(event.getOriginalEvent()));
         if (event.getResult() != Result.DEFAULT) {
             builder.append(" [").append(event.getResult()).append("]");
         }
@@ -97,13 +99,16 @@ public class DebuggingListener extends AbstractListener {
         StringBuilder builder = new StringBuilder();
         builder.append("INTERACT");
         builder.append(" ");
-        builder.append("").append(event.getEffectiveMaterial());
+        builder.append(event.getEffectiveMaterial());
         builder.append(" ");
         builder.append("[").append(event.getCause()).append("]");
         builder.append(" ");
         builder.append("@").append(toBlockString(event.getBlocks()));
         builder.append(" ");
-        builder.append(":").append(getEventName(event.getOriginalEvent()));
+        builder.append(": ").append(getEventName(event.getOriginalEvent()));
+        if (event.getOriginalEvent() instanceof PlayerInteractEvent) {
+            builder.append(".").append(((PlayerInteractEvent) event.getOriginalEvent()).getAction());
+        }
         if (event.getResult() != Result.DEFAULT) {
             builder.append(" [").append(event.getResult()).append("]");
         }
@@ -115,13 +120,13 @@ public class DebuggingListener extends AbstractListener {
         StringBuilder builder = new StringBuilder();
         builder.append("SPAWN");
         builder.append(" ");
-        builder.append("").append(event.getEffectiveType());
+        builder.append(event.getEffectiveType());
         builder.append(" ");
         builder.append("[").append(event.getCause()).append("]");
         builder.append(" ");
         builder.append("@").append(toBlockString(event.getTarget()));
         builder.append(" ");
-        builder.append(":").append(getEventName(event.getOriginalEvent()));
+        builder.append(": ").append(getEventName(event.getOriginalEvent()));
         if (event.getResult() != Result.DEFAULT) {
             builder.append(" [").append(event.getResult()).append("]");
         }
@@ -133,13 +138,13 @@ public class DebuggingListener extends AbstractListener {
         StringBuilder builder = new StringBuilder();
         builder.append("DESTROY");
         builder.append(" ");
-        builder.append("").append(event.getEntity().getType());
+        builder.append(event.getEntity().getType());
         builder.append(" ");
         builder.append("[").append(event.getCause()).append("]");
         builder.append(" ");
         builder.append("@").append(toBlockString(event.getTarget()));
         builder.append(" ");
-        builder.append(":").append(getEventName(event.getOriginalEvent()));
+        builder.append(": ").append(getEventName(event.getOriginalEvent()));
         if (event.getResult() != Result.DEFAULT) {
             builder.append(" [").append(event.getResult()).append("]");
         }
@@ -151,13 +156,31 @@ public class DebuggingListener extends AbstractListener {
         StringBuilder builder = new StringBuilder();
         builder.append("INTERACT");
         builder.append(" ");
-        builder.append("").append(event.getEntity().getType());
+        builder.append(event.getEntity().getType());
         builder.append(" ");
         builder.append("[").append(event.getCause()).append("]");
         builder.append(" ");
         builder.append("@").append(toBlockString(event.getTarget()));
         builder.append(" ");
-        builder.append(":").append(getEventName(event.getOriginalEvent()));
+        builder.append(": ").append(getEventName(event.getOriginalEvent()));
+        if (event.getResult() != Result.DEFAULT) {
+            builder.append(" [").append(event.getResult()).append("]");
+        }
+        logger.info(builder.toString());
+    }
+
+    @EventHandler(priority = EventPriority.MONITOR)
+    public void onDamageEntity(DamageEntityEvent event) {
+        StringBuilder builder = new StringBuilder();
+        builder.append("DAMAGE");
+        builder.append(" ");
+        builder.append(event.getEntity().getType());
+        builder.append(" ");
+        builder.append("[").append(event.getCause()).append("]");
+        builder.append(" ");
+        builder.append("@").append(toBlockString(event.getTarget()));
+        builder.append(" ");
+        builder.append(": ").append(getEventName(event.getOriginalEvent()));
         if (event.getResult() != Result.DEFAULT) {
             builder.append(" [").append(event.getResult()).append("]");
         }
@@ -169,13 +192,13 @@ public class DebuggingListener extends AbstractListener {
         StringBuilder builder = new StringBuilder();
         builder.append("USE");
         builder.append(" ");
-        builder.append("").append(event.getItemStack().getType());
+        builder.append(event.getItemStack().getType());
         builder.append(" ");
         builder.append("[").append(event.getCause()).append("]");
         builder.append(" ");
         builder.append("@").append(event.getWorld().getName());
         builder.append(" ");
-        builder.append(":").append(getEventName(event.getOriginalEvent()));
+        builder.append(": ").append(getEventName(event.getOriginalEvent()));
         if (event.getResult() != Result.DEFAULT) {
             builder.append(" [").append(event.getResult()).append("]");
         }

worldguard-bukkit/src/main/java/com/sk89q/worldguard/bukkit/listener/EventAbstractionListener.java

@@ -19,8 +19,12 @@
 
 package com.sk89q.worldguard.bukkit.listener;
 
+import static com.sk89q.worldguard.bukkit.cause.Cause.create;
+
 import com.google.common.collect.Lists;
-import com.sk89q.worldguard.bukkit.WorldConfiguration;
+import com.sk89q.worldedit.bukkit.BukkitAdapter;
+import com.sk89q.worldguard.WorldGuard;
+import com.sk89q.worldguard.bukkit.BukkitWorldConfiguration;
 import com.sk89q.worldguard.bukkit.WorldGuardPlugin;
 import com.sk89q.worldguard.bukkit.cause.Cause;
 import com.sk89q.worldguard.bukkit.event.DelegateEvent;
@@ -43,43 +47,99 @@ import com.sk89q.worldguard.bukkit.util.Blocks;
 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.protection.flags.DefaultFlag;
-import org.bukkit.*;
+import com.sk89q.worldguard.config.WorldConfiguration;
+import com.sk89q.worldguard.protection.flags.Flags;
+import org.bukkit.Bukkit;
+import org.bukkit.Effect;
+import org.bukkit.GameMode;
+import org.bukkit.Location;
+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.Chest;
+import org.bukkit.block.Container;
 import org.bukkit.block.DoubleChest;
+import org.bukkit.block.Dropper;
 import org.bukkit.block.Hopper;
-import org.bukkit.entity.*;
+import org.bukkit.block.PistonMoveReaction;
+import org.bukkit.block.data.type.Dispenser;
+import org.bukkit.entity.AreaEffectCloud;
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.EntityType;
+import org.bukkit.entity.FallingBlock;
+import org.bukkit.entity.Item;
+import org.bukkit.entity.LingeringPotion;
+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.Listener;
-import org.bukkit.event.block.*;
-import org.bukkit.event.entity.*;
+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.BlockExplodeEvent;
+import org.bukkit.event.block.BlockFromToEvent;
+import org.bukkit.event.block.BlockIgniteEvent;
+import org.bukkit.event.block.BlockMultiPlaceEvent;
+import org.bukkit.event.block.BlockPistonExtendEvent;
+import org.bukkit.event.block.BlockPistonRetractEvent;
+import org.bukkit.event.block.BlockPlaceEvent;
+import org.bukkit.event.block.EntityBlockFormEvent;
+import org.bukkit.event.block.SignChangeEvent;
+import org.bukkit.event.entity.AreaEffectCloudApplyEvent;
+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.EntityInteractEvent;
+import org.bukkit.event.entity.EntityTameEvent;
+import org.bukkit.event.entity.EntityUnleashEvent;
+import org.bukkit.event.entity.ExpBottleEvent;
+import org.bukkit.event.entity.LingeringPotionSplashEvent;
+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.inventory.InventoryOpenEvent;
-import org.bukkit.event.player.*;
+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.PlayerInteractAtEntityEvent;
+import org.bukkit.event.player.PlayerInteractEntityEvent;
+import org.bukkit.event.player.PlayerInteractEvent;
+import org.bukkit.event.player.PlayerItemConsumeEvent;
+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.EquipmentSlot;
 import org.bukkit.inventory.InventoryHolder;
 import org.bukkit.inventory.ItemStack;
-import org.bukkit.material.*;
-import org.bukkit.material.Dispenser;
 import org.bukkit.projectiles.ProjectileSource;
 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 javax.annotation.Nullable;
 
 public class EventAbstractionListener extends AbstractListener {
 
@@ -99,16 +159,6 @@ public class EventAbstractionListener extends AbstractListener {
         super(plugin);
     }
 
-    @Override
-    public void registerEvents() {
-        super.registerEvents();
-
-        try {
-            getPlugin().getServer().getPluginManager().registerEvents(new SpigotCompatListener(), getPlugin());
-        } catch (LinkageError ignored) {
-        }
-    }
-
     //-------------------------------------------------------------------------
     // Block break / place
     //-------------------------------------------------------------------------
@@ -124,7 +174,7 @@ public class EventAbstractionListener extends AbstractListener {
 
     @EventHandler(ignoreCancelled = true)
     public void onBlockMultiPlace(BlockMultiPlaceEvent event) {
-        List<Block> blocks = new ArrayList<Block>();
+        List<Block> blocks = new ArrayList<>();
         for (BlockState bs : event.getReplacedBlockStates()) {
             blocks.add(bs.getBlock());
         }
@@ -160,7 +210,7 @@ public class EventAbstractionListener extends AbstractListener {
     public void onBlockBurn(BlockBurnEvent event) {
         Block target = event.getBlock();
 
-        Block[] adjacent = new Block[] {
+        Block[] adjacent = {
                 target.getRelative(BlockFace.NORTH),
                 target.getRelative(BlockFace.SOUTH),
                 target.getRelative(BlockFace.WEST),
@@ -213,7 +263,7 @@ public class EventAbstractionListener extends AbstractListener {
         Material to = event.getTo();
 
         // Forget about Redstone ore, especially since we handle it in INTERACT
-        if (Materials.isRedstoneOre(block.getType()) && Materials.isRedstoneOre(to)) {
+        if (block.getType() == Material.REDSTONE_ORE && to == Material.REDSTONE_ORE) {
             return;
         }
 
@@ -241,7 +291,7 @@ public class EventAbstractionListener extends AbstractListener {
 
                 if (event.isCancelled() && !wasCancelled && entity instanceof FallingBlock) {
                     FallingBlock fallingBlock = (FallingBlock) entity;
-                    ItemStack itemStack = new ItemStack(fallingBlock.getMaterial(), 1, fallingBlock.getBlockData());
+                    ItemStack itemStack = new ItemStack(fallingBlock.getBlockData().getMaterial(), 1);
                     Item item = block.getWorld().dropItem(fallingBlock.getLocation(), itemStack);
                     item.setVelocity(new Vector());
                     if (Events.fireAndTestCancel(new SpawnEntityEvent(event, create(block, entity), item))) {
@@ -255,11 +305,14 @@ public class EventAbstractionListener extends AbstractListener {
     @EventHandler(ignoreCancelled = true)
     public void onEntityExplode(EntityExplodeEvent event) {
         Entity entity = event.getEntity();
+        if (event.getYield() == 0 && event.blockList().isEmpty()) {
+            // avoids ender dragon spam
+            return;
+        }
 
         Events.fireBulkEventToCancel(event, new BreakBlockEvent(event, create(entity), event.getLocation().getWorld(), event.blockList(), Material.AIR));
     }
 
-    @SuppressWarnings("deprecation")
     @EventHandler(ignoreCancelled = true)
     public void onBlockPistonRetract(BlockPistonRetractEvent event) {
         if (event.isSticky()) {
@@ -270,15 +323,7 @@ public class EventAbstractionListener extends AbstractListener {
 
                 BlockFace direction = event.getDirection();
 
-                ArrayList<Block> blocks;
-                try {
-                    blocks = new ArrayList<Block>(event.getBlocks());
-                } catch (NoSuchMethodError e) {
-                    blocks = Lists.newArrayList(event.getRetractLocation().getBlock());
-                    if (piston.getType() == Material.PISTON_MOVING_PIECE) {
-                        direction = new PistonExtensionMaterial(Material.PISTON_STICKY_BASE.getId(), piston.getData()).getFacing();
-                    }
-                }
+                ArrayList<Block> blocks = new ArrayList<>(event.getBlocks());
                 int originalSize = blocks.size();
                 Events.fireBulkEventToCancel(event, new BreakBlockEvent(event, cause, event.getBlock().getWorld(), blocks, Material.AIR));
                 if (originalSize != blocks.size()) {
@@ -302,11 +347,15 @@ public class EventAbstractionListener extends AbstractListener {
     public void onBlockPistonExtend(BlockPistonExtendEvent event) {
         EventDebounce.Entry entry = pistonExtendDebounce.getIfNotPresent(new BlockPistonExtendKey(event), event);
         if (entry != null) {
-            List<Block> blocks = new ArrayList<Block>(event.getBlocks());
+            List<Block> blocks = new ArrayList<>(event.getBlocks());
             int originalLength = blocks.size();
             BlockFace dir = event.getDirection();
             for (int i = 0; i < blocks.size(); i++) {
-                blocks.set(i, blocks.get(i).getRelative(dir));
+                Block existing = blocks.get(i);
+                if (existing.getPistonMoveReaction() == PistonMoveReaction.MOVE
+                    || existing.getPistonMoveReaction() == PistonMoveReaction.PUSH_ONLY) {
+                    blocks.set(i, existing.getRelative(dir));
+                }
             }
             Events.fireBulkEventToCancel(event, new PlaceBlockEvent(event, create(event.getBlock()), event.getBlock().getWorld(), blocks, Material.STONE));
             if (blocks.size() != originalLength) {
@@ -330,12 +379,12 @@ public class EventAbstractionListener extends AbstractListener {
 
         // Previously, and perhaps still, the only way to catch cake eating
         // events was through here
-        if (target.getType() == Material.CAKE_BLOCK) {
+        if (target.getType() == Material.CAKE) {
             Events.fireToCancel(event, new UseBlockEvent(event, create(event.getPlayer()), target));
         }
     }
 
-    @EventHandler(ignoreCancelled = true)
+    @EventHandler
     public void onPlayerInteract(PlayerInteractEvent event) {
         Player player = event.getPlayer();
         @Nullable ItemStack item = event.getItem();
@@ -347,65 +396,84 @@ public class EventAbstractionListener extends AbstractListener {
 
         switch (event.getAction()) {
             case PHYSICAL:
-                // Forget about Redstone ore
-                if (Materials.isRedstoneOre(clicked.getType()) || clicked.getType() == Material.SOIL) {
-                    silent = true;
+                if (event.useInteractedBlock() != Result.DENY) {
+                    DelegateEvent firedEvent = new UseBlockEvent(event, cause, clicked).setAllowed(hasInteractBypass(clicked));
+                    if (clicked.getType() == Material.REDSTONE_ORE) {
+                        silent = true;
+                    }
+                    if (clicked.getType() == Material.FARMLAND || clicked.getType() == Material.TURTLE_EGG) {
+                        silent = true;
+                        firedEvent.getRelevantFlags().add(Flags.TRAMPLE_BLOCKS);
+                    }
+                    firedEvent.setSilent(silent);
+                    interactDebounce.debounce(clicked, event.getPlayer(), event, firedEvent);
                 }
-
-                interactDebounce.debounce(clicked, event.getPlayer(), event,
-                        new UseBlockEvent(event, cause, clicked).setSilent(silent).setAllowed(hasInteractBypass(clicked)));
                 break;
 
             case RIGHT_CLICK_BLOCK:
-                placed = clicked.getRelative(event.getBlockFace());
+                if (event.useInteractedBlock() != Result.DENY) {
+                    placed = clicked.getRelative(event.getBlockFace());
 
-                // Re-used for dispensers
-                handleBlockRightClick(event, create(event.getPlayer()), item, clicked, event.getBlockFace(), placed);
+                    // Re-used for dispensers
+                    handleBlockRightClick(event, create(event.getPlayer()), item, clicked, placed);
+                }
 
             case LEFT_CLICK_BLOCK:
-                placed = clicked.getRelative(event.getBlockFace());
+                if (event.useInteractedBlock() != Result.DENY) {
+                    placed = clicked.getRelative(event.getBlockFace());
 
-                // Only fire events for blocks that are modified when right clicked
-                modifiesWorld = isBlockModifiedOnClick(clicked, event.getAction() == Action.RIGHT_CLICK_BLOCK) || (item != null && isItemAppliedToBlock(item, clicked));
+                    // Only fire events for blocks that are modified when right clicked
+                    final boolean hasItemInteraction = item != null && isItemAppliedToBlock(item, clicked)
+                            && event.getAction() == Action.RIGHT_CLICK_BLOCK;
+                    modifiesWorld = isBlockModifiedOnClick(clicked, event.getAction() == Action.RIGHT_CLICK_BLOCK)
+                            || hasItemInteraction;
 
-                if (Events.fireAndTestCancel(new UseBlockEvent(event, cause, clicked).setAllowed(!modifiesWorld))) {
-                    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).setAllowed(!modifiesWorld))) {
+                    if (Events.fireAndTestCancel(new UseBlockEvent(event, cause, clicked).setAllowed(!modifiesWorld))) {
                         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;
+                    // Handle connected blocks (i.e. beds, chests)
+                    for (Block connected : Blocks.getConnected(clicked)) {
+                        if (Events.fireAndTestCancel(new UseBlockEvent(event, create(event.getPlayer()), connected).setAllowed(!modifiesWorld))) {
+                            event.setUseInteractedBlock(Result.DENY);
+                            break;
+                        }
                     }
-                }
 
-                if (event.isCancelled()) {
-                    playDenyEffect(event.getPlayer(), clicked.getLocation().add(0.5, 1, 0.5));
+                    if (hasItemInteraction) {
+                        if (Events.fireAndTestCancel(new PlaceBlockEvent(event, cause, clicked.getLocation(), clicked.getType()))) {
+                            event.setUseItemInHand(Result.DENY);
+                        }
+                    }
+
+                    // 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;
+                        }
+                    }
+
+                    if (event.isCancelled()) {
+                        playDenyEffect(event.getPlayer(), clicked.getLocation().add(0.5, 1, 0.5));
+                    }
                 }
 
             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);
-                    event.setCancelled(true); // The line above does not appear to work with spawn eggs
+                if (event.useItemInHand() != Result.DENY) {
+                    if (item != null && !item.getType().isBlock() && Events.fireAndTestCancel(new UseItemEvent(event, cause, player.getWorld(), item))) {
+                        event.setUseItemInHand(Result.DENY);
+                    }
                 }
 
                 // Check for items that the administrator has configured to
                 // emit a "use block here" event where the player is
                 // standing, which is a hack to protect items that don't
                 // throw events
-                if (item != null && getWorldConfig(player.getWorld()).blockUseAtFeet.test(item)) {
+                if (item != null && ((BukkitWorldConfiguration) getWorldConfig(BukkitAdapter.adapt(player.getWorld()))).blockUseAtFeet.test(item)) {
                     if (Events.fireAndTestCancel(new UseBlockEvent(event, cause, player.getLocation().getBlock()))) {
-                        event.setCancelled(true);
+                        event.setUseInteractedBlock(Result.DENY);
                     }
                 }
 
@@ -415,17 +483,16 @@ public class EventAbstractionListener extends AbstractListener {
 
     @EventHandler(ignoreCancelled = true)
     public void onEntityBlockForm(EntityBlockFormEvent event) {
-        if (event.getEntity() instanceof Player) {
-            // should just be frostwalker...other uses of EntityBlockForm are in BlockListener
-            Events.fireToCancel(event, new PlaceBlockEvent(event, create(event.getEntity()),
-                    event.getBlock().getLocation(), event.getNewState().getType()));
-        }
+        entityBreakBlockDebounce.debounce(event.getBlock(), event.getEntity(), event,
+                new PlaceBlockEvent(event, create(event.getEntity()),
+                        event.getBlock().getLocation(), event.getNewState().getType()));
     }
 
     @EventHandler(ignoreCancelled = true)
-    public void onEntityInteract(org.bukkit.event.entity.EntityInteractEvent event) {
+    public void onEntityInteract(EntityInteractEvent event) {
         interactDebounce.debounce(event.getBlock(), event.getEntity(), event,
-                new UseBlockEvent(event, create(event.getEntity()), event.getBlock()).setAllowed(hasInteractBypass(event.getBlock())));
+                new UseBlockEvent(event, create(event.getEntity()),
+                        event.getBlock()).setAllowed(hasInteractBypass(event.getBlock())));
     }
 
     @EventHandler(ignoreCancelled = true)
@@ -510,7 +577,7 @@ public class EventAbstractionListener extends AbstractListener {
 
     @EventHandler(ignoreCancelled = true)
     public void onBlockFromTo(BlockFromToEvent event) {
-        WorldConfiguration config = getWorldConfig(event.getBlock().getWorld());
+        WorldConfiguration config = getWorldConfig(BukkitAdapter.adapt(event.getBlock().getWorld()));
 
         // This only applies to regions but nothing else cares about high
         // frequency events at the moment
@@ -556,7 +623,7 @@ public class EventAbstractionListener extends AbstractListener {
             case DISPENSE_EGG:
             case EGG:
             case SPAWNER_EGG:
-                if (getWorldConfig(event.getEntity().getWorld()).strictEntitySpawn) {
+                if (getWorldConfig(BukkitAdapter.adapt(event.getEntity().getWorld())).strictEntitySpawn) {
                     Events.fireToCancel(event, new SpawnEntityEvent(event, Cause.unknown(), event.getEntity()));
                 }
                 break;
@@ -622,7 +689,12 @@ public class EventAbstractionListener extends AbstractListener {
 
     @EventHandler(ignoreCancelled = true)
     public void onPlayerFish(PlayerFishEvent event) {
-        if (event.getState() == PlayerFishEvent.State.CAUGHT_FISH) {
+        if (event.getState() == PlayerFishEvent.State.FISHING) {
+            if (Events.fireAndTestCancel(new UseItemEvent(event, create(event.getPlayer(), event.getHook()),
+                    event.getPlayer().getWorld(), event.getPlayer().getInventory().getItemInMainHand()))) {
+                event.setCancelled(true);
+            }
+        } else if (event.getState() == PlayerFishEvent.State.CAUGHT_FISH) {
             if (Events.fireAndTestCancel(new SpawnEntityEvent(event, create(event.getPlayer(), event.getHook()), event.getHook().getLocation(), EntityType.EXPERIENCE_ORB))) {
                 event.setExpToDrop(0);
             }
@@ -633,7 +705,7 @@ public class EventAbstractionListener extends AbstractListener {
                 Events.fireToCancel(event, new DestroyEntityEvent(event, create(event.getPlayer(), event.getHook()), caught));
             } else if (Entities.isConsideredBuildingIfUsed(caught)) {
                 Events.fireToCancel(event, new UseEntityEvent(event, create(event.getPlayer(), event.getHook()), caught));
-            } else if (Entities.isNonHostile(caught)) {
+            } else if (Entities.isNonHostile(caught) || caught instanceof Player) {
                 Events.fireToCancel(event, new DamageEntityEvent(event, create(event.getPlayer(), event.getHook()), caught));
             }
         }
@@ -649,7 +721,7 @@ public class EventAbstractionListener extends AbstractListener {
             if (shooter instanceof Player) {
                 Player player = (Player) shooter;
                 if (player.getGameMode() != GameMode.CREATIVE) {
-                    player.getInventory().addItem(new ItemStack(Material.EXP_BOTTLE, 1));
+                    player.getInventory().addItem(new ItemStack(Material.EXPERIENCE_BOTTLE, 1));
                 }
             }
         }
@@ -672,7 +744,8 @@ public class EventAbstractionListener extends AbstractListener {
     public void onPlayerInteractEntity(PlayerInteractEntityEvent event) {
         Player player = event.getPlayer();
         World world = player.getWorld();
-        ItemStack item = player.getItemInHand();
+        ItemStack item = event.getHand() == EquipmentSlot.OFF_HAND
+                ? player.getInventory().getItemInOffHand() : player.getInventory().getItemInMainHand();
         Entity entity = event.getRightClicked();
 
         Events.fireToCancel(event, new UseItemEvent(event, create(player), world, item));
@@ -699,9 +772,10 @@ public class EventAbstractionListener extends AbstractListener {
             // Older blacklist handler code used this, although it suffers from
             // race problems
             if (damager instanceof Player) {
-                ItemStack item = ((Player) damager).getItemInHand();
+                // this event doesn't tell us which hand the weapon was in
+                ItemStack item = ((Player) damager).getInventory().getItemInMainHand();
 
-                if (item != null) {
+                if (item.getType() != Material.AIR) {
                     Events.fireToCancel(event, new UseItemEvent(event, create(damager), event.getEntity().getWorld(), item));
                 }
             }
@@ -711,8 +785,9 @@ public class EventAbstractionListener extends AbstractListener {
     @EventHandler(ignoreCancelled = true)
     public void onEntityCombust(EntityCombustEvent event) {
         if (event instanceof EntityCombustByBlockEvent) {
-            Events.fireToCancel(event, new DamageEntityEvent(event, create(((EntityCombustByBlockEvent) event).getCombuster()), event.getEntity()));
-
+            // at the time of writing, spigot is throwing null for the event's combuster. this causes lots of issues downstream.
+            // whenever (i mean if ever) it is fixed, use getCombuster again instead of the current block
+            Events.fireToCancel(event, new DamageEntityEvent(event, create(event.getEntity().getLocation().getBlock()), event.getEntity()));
         } else if (event instanceof EntityCombustByEntityEvent) {
             Events.fireToCancel(event, new DamageEntityEvent(event, create(((EntityCombustByEntityEvent) event).getCombuster()), event.getEntity()));
         }
@@ -723,9 +798,7 @@ public class EventAbstractionListener extends AbstractListener {
         if (event instanceof PlayerUnleashEntityEvent) {
             PlayerUnleashEntityEvent playerEvent = (PlayerUnleashEntityEvent) event;
             Events.fireToCancel(playerEvent, new UseEntityEvent(playerEvent, create(playerEvent.getPlayer()), event.getEntity()));
-        } else {
-            // TODO: Raise anyway?
-        }
+        }  // TODO: Raise anyway?
     }
 
     @EventHandler(ignoreCancelled = true)
@@ -755,11 +828,6 @@ public class EventAbstractionListener extends AbstractListener {
         Events.fireToCancel(event, new DamageEntityEvent(event, create(attacker), event.getVehicle()));
     }
 
-    @EventHandler(ignoreCancelled = true)
-    public void onVehicleEnter(VehicleDamageEvent event) {
-        Events.fireToCancel(event, new UseEntityEvent(event, create(event.getAttacker()), event.getVehicle()));
-    }
-
     //-------------------------------------------------------------------------
     // Composite events
     //-------------------------------------------------------------------------
@@ -787,6 +855,12 @@ public class EventAbstractionListener extends AbstractListener {
         InventoryHolder sourceHolder = event.getSource().getHolder();
         InventoryHolder targetHolder = event.getDestination().getHolder();
 
+        if ((causeHolder instanceof Hopper || causeHolder instanceof Dropper)
+                && ((BukkitWorldConfiguration) WorldGuard.getInstance().getPlatform().getGlobalStateManager().get(
+                        BukkitAdapter.adapt(((Container) causeHolder).getWorld()))).ignoreHopperMoveEvents) {
+            return;
+        }
+
         Entry entry;
 
         if ((entry = moveItemDebounce.tryDebounce(event)) != null) {
@@ -800,19 +874,15 @@ public class EventAbstractionListener extends AbstractListener {
                 cause = Cause.unknown();
             }
 
-            if (!causeHolder.equals(sourceHolder)) {
+            if (causeHolder != null && !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();
-                    }
-                });
+                Bukkit.getScheduler().scheduleSyncDelayedTask(getPlugin(),
+                        () -> ((Hopper) causeHolder).getBlock().breakNaturally());
             } else {
                 entry.setCancelled(event.isCancelled());
             }
@@ -832,6 +902,7 @@ public class EventAbstractionListener extends AbstractListener {
         // Fire entity interaction event
         if (!event.isCancelled()) {
             int blocked = 0;
+            int affectedSize = event.getAffectedEntities().size();
             boolean hasDamageEffect = Materials.hasDamageEffect(potion.getEffects());
 
             for (LivingEntity affected : event.getAffectedEntities()) {
@@ -840,7 +911,7 @@ public class EventAbstractionListener extends AbstractListener {
                         new UseEntityEvent(event, cause, affected);
 
                 // Consider the potion splash flag
-                delegate.getRelevantFlags().add(DefaultFlag.POTION_SPLASH);
+                delegate.getRelevantFlags().add(Flags.POTION_SPLASH);
 
                 if (Events.fireAndTestCancel(delegate)) {
                     event.setIntensity(affected, 0);
@@ -848,7 +919,7 @@ public class EventAbstractionListener extends AbstractListener {
                 }
             }
 
-            if (blocked == event.getAffectedEntities().size()) {
+            if (blocked == affectedSize) { // server does weird things with this if the event is modified, so use cached number
                 event.setCancelled(true);
             }
         }
@@ -859,82 +930,112 @@ public class EventAbstractionListener extends AbstractListener {
         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;
+        if (dispenserBlock.getBlockData() instanceof Dispenser) {
+            Dispenser dispenser = (Dispenser) dispenserBlock.getBlockData();
             Block placed = dispenserBlock.getRelative(dispenser.getFacing());
             Block clicked = placed.getRelative(dispenser.getFacing());
-            handleBlockRightClick(event, cause, item, clicked, dispenser.getFacing().getOppositeFace(), placed);
+            handleBlockRightClick(event, cause, item, clicked, placed);
         }
     }
 
+    @EventHandler(ignoreCancelled = true)
+    public void onLingeringSplash(LingeringPotionSplashEvent event) {
+        AreaEffectCloud aec = event.getAreaEffectCloud();
+        ThrownPotion potion = event.getEntity();
+        World world = potion.getWorld();
+        Cause cause = create(event.getEntity());
+
+        // Fire item interaction event
+        Events.fireToCancel(event, new UseItemEvent(event, cause, world, potion.getItem()));
+
+        // Fire entity spawn event
+        if (!event.isCancelled()) {
+            // radius unfortunately doesn't go through with this, so only a single location is tested
+            Events.fireToCancel(event, new SpawnEntityEvent(event, cause, aec.getLocation().add(0.5, 0, 0.5), EntityType.AREA_EFFECT_CLOUD));
+        }
+    }
+
+    @EventHandler(ignoreCancelled = true)
+    public void onLingeringApply(AreaEffectCloudApplyEvent event) {
+        if (!Materials.hasDamageEffect(event.getEntity().getCustomEffects())) {
+            return;
+        }
+        Cause cause = create(event.getEntity());
+        event.getAffectedEntities()
+                .removeIf(victim -> Events.fireAndTestCancel(new DamageEntityEvent(event, cause, victim)));
+    }
+
+    @EventHandler(ignoreCancelled = true)
+    public void onPlayerInteractAtEntity(PlayerInteractAtEntityEvent event){
+        onPlayerInteractEntity(event);
+    }
+
+    @EventHandler(ignoreCancelled = true)
+    public void onBlockExplode(BlockExplodeEvent event) {
+        final BreakBlockEvent eventToFire = new BreakBlockEvent(event, create(event.getBlock()),
+                event.getBlock().getLocation().getWorld(), event.blockList(), Material.AIR);
+        eventToFire.getRelevantFlags().add(Flags.OTHER_EXPLOSION);
+        Events.fireBulkEventToCancel(event, eventToFire);
+    }
+
     /**
      * 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) {
+    private static <T extends Event & Cancellable> void handleBlockRightClick(T event, Cause cause, @Nullable ItemStack item, Block clicked, 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)
+            // (not sure if this actually still happens) -- note Jun 2019 - happens with dispensers still, tho not players
             Events.fireToCancel(event, new UseBlockEvent(event, cause, clicked.getLocation(), Material.TNT));
+
+            // Workaround for http://leaky.bukkit.org/issues/1034
+            Events.fireToCancel(event, new PlaceBlockEvent(event, cause, placed.getLocation(), Material.TNT));
+            return;
         }
 
         // 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));
+            return;
         }
 
         // Handle created boats
         if (item != null && Materials.isBoat(item.getType())) {
             // TODO as above
             Events.fireToCancel(event, new SpawnEntityEvent(event, cause, placed.getLocation().add(0.5, 0, 0.5), EntityType.BOAT));
+            return;
         }
 
         // Handle created armor stands
-        if (item != null && item.getType() == Materials.ARMOR_STAND) {
+        if (item != null && item.getType() == Material.ARMOR_STAND) {
             Events.fireToCancel(event, new SpawnEntityEvent(event, cause, placed.getLocation().add(0.5, 0, 0.5), EntityType.ARMOR_STAND));
+            return;
+        }
+
+        if (item != null && item.getType() == Material.END_CRYSTAL) { /*&& placed.getType() == Material.BEDROCK) {*/ // in vanilla you can only place them on bedrock but who knows what plugins will add
+                                                                                                                        // may be overprotective as a result, but better than being underprotective
+            Events.fireToCancel(event, new SpawnEntityEvent(event, cause, placed.getLocation().add(0.5, 0, 0.5), EntityType.ENDER_CRYSTAL));
+            return;
         }
 
         // Handle created spawn eggs
-        if (item != null && item.getType() == Material.MONSTER_EGG) {
-            MaterialData data = item.getData();
-            if (data instanceof SpawnEgg) {
-                @Nullable EntityType type = ((SpawnEgg) data).getSpawnedType();
-                if (type == null) {
-                    type = EntityType.SHEEP; // Haven't investigated why it's sometimes null
-                }
-                Events.fireToCancel(event, new SpawnEntityEvent(event, cause, placed.getLocation().add(0.5, 0, 0.5), type));
-            }
-        }
-
-        // 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));
+        if (item != null && Materials.isSpawnEgg(item.getType())) {
+            Events.fireToCancel(event, new SpawnEntityEvent(event, cause, placed.getLocation().add(0.5, 0, 0.5), Materials.getEntitySpawnEgg(item.getType())));
+            return;
         }
     }
 
-    @SuppressWarnings("unchecked")
     private static <T extends Event & Cancellable> void handleInventoryHolderUse(T originalEvent, Cause cause, InventoryHolder holder) {
         if (originalEvent.isCancelled()) {
             return;
@@ -945,17 +1046,23 @@ public class EventAbstractionListener extends AbstractListener {
         } 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, (((Chest) ((DoubleChest) holder).getLeftSide()).getBlock())));
-            Events.fireToCancel(originalEvent, new UseBlockEvent(originalEvent, cause, (((Chest) ((DoubleChest) holder).getRightSide()).getBlock())));
+            InventoryHolder left = ((DoubleChest) holder).getLeftSide();
+            InventoryHolder right = ((DoubleChest) holder).getRightSide();
+            if (left instanceof Chest) {
+                Events.fireToCancel(originalEvent, new UseBlockEvent(originalEvent, cause, ((Chest) left).getBlock()));
+            }
+            if (right instanceof Chest) {
+                Events.fireToCancel(originalEvent, new UseBlockEvent(originalEvent, cause, ((Chest) right).getBlock()));
+            }
         }
     }
 
     private boolean hasInteractBypass(Block block) {
-        return getWorldConfig(block.getWorld()).allowAllInteract.test(block);
+        return ((BukkitWorldConfiguration) getWorldConfig(BukkitAdapter.adapt(block.getWorld()))).allowAllInteract.test(block);
     }
 
     private boolean hasInteractBypass(World world, ItemStack item) {
-        return getWorldConfig(world).allowAllInteract.test(item);
+        return ((BukkitWorldConfiguration) getWorldConfig(BukkitAdapter.adapt(world))).allowAllInteract.test(item);
     }
 
     private boolean isBlockModifiedOnClick(Block block, boolean rightClick) {
@@ -970,23 +1077,14 @@ public class EventAbstractionListener extends AbstractListener {
 
     private void playDenyEffect(Player player, Location location) {
         //player.playSound(location, Sound.SUCCESSFUL_HIT, 0.2f, 0.4f);
-        player.playEffect(location, Effect.SMOKE, BlockFace.UP);
+        if (WorldGuard.getInstance().getPlatform().getGlobalStateManager().particleEffects) {
+            player.playEffect(location, Effect.SMOKE, BlockFace.UP);
+        }
     }
 
     private void playDenyEffect(Location location) {
-        location.getWorld().playEffect(location, Effect.SMOKE, BlockFace.UP);
-    }
-
-    public class SpigotCompatListener implements Listener {
-        @EventHandler(ignoreCancelled = true)
-        public void onPlayerInteractAtEntity(PlayerInteractAtEntityEvent event){
-            onPlayerInteractEntity(event);
-        }
-
-        @EventHandler(ignoreCancelled = true)
-        public void onBlockExplode(BlockExplodeEvent event) {
-            Events.fireBulkEventToCancel(event, new BreakBlockEvent(event, create(event.getBlock()),
-                    event.getBlock().getLocation().getWorld(), event.blockList(), Material.AIR));
+        if (WorldGuard.getInstance().getPlatform().getGlobalStateManager().particleEffects) {
+            location.getWorld().playEffect(location, Effect.SMOKE, BlockFace.UP);
         }
     }
 

worldguard-bukkit/src/main/java/com/sk89q/worldguard/bukkit/listener/InvincibilityListener.java

@@ -19,11 +19,15 @@
 
 package com.sk89q.worldguard.bukkit.listener;
 
-import com.sk89q.worldguard.bukkit.WorldConfiguration;
+import com.sk89q.worldedit.world.World;
+import com.sk89q.worldguard.LocalPlayer;
+import com.sk89q.worldguard.WorldGuard;
+import com.sk89q.worldguard.bukkit.BukkitWorldConfiguration;
 import com.sk89q.worldguard.bukkit.WorldGuardPlugin;
 import org.bukkit.entity.Entity;
 import org.bukkit.entity.LivingEntity;
 import org.bukkit.entity.Player;
+import org.bukkit.entity.Projectile;
 import org.bukkit.entity.Tameable;
 import org.bukkit.event.EventHandler;
 import org.bukkit.event.entity.EntityCombustEvent;
@@ -48,19 +52,22 @@ public class InvincibilityListener extends AbstractListener {
      * @param player The player
      * @return True if invincible
      */
-    private boolean isInvincible(Player player) {
-        return getPlugin().getSessionManager().get(player).isInvincible(player);
+    private boolean isInvincible(LocalPlayer player) {
+        return WorldGuard.getInstance().getPlatform().getSessionManager().get(player).isInvincible(player);
     }
 
     @EventHandler(ignoreCancelled = true)
     public void onEntityDamage(EntityDamageEvent event) {
         Entity victim = event.getEntity();
-        WorldConfiguration worldConfig = getPlugin().getGlobalStateManager().get(victim.getWorld());
 
         if (victim instanceof Player) {
             Player player = (Player) victim;
+            LocalPlayer localPlayer = WorldGuardPlugin.inst().wrapPlayer(player);
 
-            if (isInvincible(player)) {
+            BukkitWorldConfiguration worldConfig =
+                    (BukkitWorldConfiguration) WorldGuard.getInstance().getPlatform().getGlobalStateManager().get((World) localPlayer.getExtent());
+
+            if (isInvincible(localPlayer)) {
                 player.setFireTicks(0);
                 event.setCancelled(true);
 
@@ -68,6 +75,10 @@ public class InvincibilityListener extends AbstractListener {
                     EntityDamageByEntityEvent byEntityEvent = (EntityDamageByEntityEvent) event;
                     Entity attacker = byEntityEvent.getDamager();
 
+                    if (attacker instanceof Projectile && ((Projectile) attacker).getShooter() instanceof Entity) {
+                        attacker = (Entity) ((Projectile) attacker).getShooter();
+                    }
+
                     if (worldConfig.regionInvinciblityRemovesMobs
                             && attacker instanceof LivingEntity && !(attacker instanceof Player)
                             && !(attacker instanceof Tameable && ((Tameable) attacker).isTamed())) {
@@ -84,8 +95,9 @@ public class InvincibilityListener extends AbstractListener {
 
         if (entity instanceof Player) {
             Player player = (Player) entity;
+            LocalPlayer localPlayer = WorldGuardPlugin.inst().wrapPlayer(player);
 
-            if (isInvincible(player)) {
+            if (isInvincible(localPlayer)) {
                 event.setCancelled(true);
             }
         }
@@ -95,8 +107,9 @@ public class InvincibilityListener extends AbstractListener {
     public void onFoodLevelChange(FoodLevelChangeEvent event) {
         if (event.getEntity() instanceof Player) {
             Player player = (Player) event.getEntity();
+            LocalPlayer localPlayer = WorldGuardPlugin.inst().wrapPlayer(player);
 
-            if (event.getFoodLevel() < player.getFoodLevel() && isInvincible(player)) {
+            if (event.getFoodLevel() < player.getFoodLevel() && isInvincible(localPlayer)) {
                 event.setCancelled(true);
             }
         }

worldguard-bukkit/src/main/java/com/sk89q/worldguard/bukkit/listener/PlayerModesListener.java

@@ -19,7 +19,8 @@
 
 package com.sk89q.worldguard.bukkit.listener;
 
-import com.sk89q.worldguard.bukkit.ConfigurationManager;
+import com.sk89q.worldguard.LocalPlayer;
+import com.sk89q.worldguard.WorldGuard;
 import com.sk89q.worldguard.bukkit.WorldGuardPlugin;
 import com.sk89q.worldguard.bukkit.event.player.ProcessPlayerEvent;
 import com.sk89q.worldguard.session.Session;
@@ -62,18 +63,18 @@ public class PlayerModesListener extends AbstractListener {
 
     @EventHandler
     public void onProcessPlayer(ProcessPlayerEvent event) {
-        ConfigurationManager config = getConfig();
         Player player = event.getPlayer();
-        Session session = getPlugin().getSessionManager().get(player);
+        LocalPlayer localPlayer = WorldGuardPlugin.inst().wrapPlayer(player);
+        Session session = WorldGuard.getInstance().getPlatform().getSessionManager().get(localPlayer);
 
         if (hasGodModeGroup(player) || hasGodModePermission(player)) {
-            if (GodMode.set(player, session, true)) {
+            if (GodMode.set(localPlayer, session, true)) {
                 log.log(Level.INFO, "Enabled auto-god mode for " + player.getName());
             }
         }
 
         if (hasAmphibiousGroup(player)) {
-            if (WaterBreathing.set(player, session, true)) {
+            if (WaterBreathing.set(localPlayer, session, true)) {
                 log.log(Level.INFO, "Enabled water breathing mode for " + player.getName() + " (player is in group 'wg-amphibious')");
             }
         }

worldguard-bukkit/src/main/java/com/sk89q/worldguard/bukkit/listener/PlayerMoveListener.java

@@ -19,12 +19,16 @@
 
 package com.sk89q.worldguard.bukkit.listener;
 
+import com.sk89q.worldedit.bukkit.BukkitAdapter;
+import com.sk89q.worldguard.LocalPlayer;
+import com.sk89q.worldguard.WorldGuard;
 import com.sk89q.worldguard.bukkit.WorldGuardPlugin;
 import com.sk89q.worldguard.session.MoveType;
 import com.sk89q.worldguard.session.Session;
 import org.bukkit.Bukkit;
 import org.bukkit.Location;
 import org.bukkit.entity.Entity;
+import org.bukkit.entity.Horse;
 import org.bukkit.entity.LivingEntity;
 import org.bukkit.entity.Player;
 import org.bukkit.event.EventHandler;
@@ -45,7 +49,7 @@ public class PlayerMoveListener implements Listener {
     }
 
     public void registerEvents() {
-        if (plugin.getGlobalStateManager().usePlayerMove) {
+        if (WorldGuard.getInstance().getPlatform().getGlobalStateManager().usePlayerMove) {
             PluginManager pm = plugin.getServer().getPluginManager();
             pm.registerEvents(this, plugin);
         }
@@ -53,19 +57,19 @@ public class PlayerMoveListener implements Listener {
 
     @EventHandler
     public void onPlayerRespawn(PlayerRespawnEvent event) {
-        Player player = event.getPlayer();
+        LocalPlayer player = plugin.wrapPlayer(event.getPlayer());
 
-        Session session = plugin.getSessionManager().get(player);
-        session.testMoveTo(player, event.getRespawnLocation(), MoveType.RESPAWN, true);
+        Session session = WorldGuard.getInstance().getPlatform().getSessionManager().get(player);
+        session.testMoveTo(player, BukkitAdapter.adapt(event.getRespawnLocation()), MoveType.RESPAWN, true);
     }
 
     @EventHandler
     public void onVehicleEnter(VehicleEnterEvent event) {
         Entity entity = event.getEntered();
         if (entity instanceof Player) {
-            Player player = (Player) entity;
-            Session session = plugin.getSessionManager().get(player);
-            if (null != session.testMoveTo(player, event.getVehicle().getLocation(), MoveType.EMBARK, true)) {
+            LocalPlayer player = plugin.wrapPlayer((Player) entity);
+            Session session = WorldGuard.getInstance().getPlatform().getSessionManager().get(player);
+            if (null != session.testMoveTo(player, BukkitAdapter.adapt(event.getVehicle().getLocation()), MoveType.EMBARK, true)) {
                 event.setCancelled(true);
             }
         }
@@ -74,11 +78,21 @@ public class PlayerMoveListener implements Listener {
     @EventHandler(priority = EventPriority.HIGH)
     public void onPlayerMove(PlayerMoveEvent event) {
         final Player player = event.getPlayer();
+        LocalPlayer localPlayer = plugin.wrapPlayer(player);
 
-        Session session = plugin.getSessionManager().get(player);
-        final Location override = session.testMoveTo(player, event.getTo(), MoveType.MOVE);
+        Session session = WorldGuard.getInstance().getPlatform().getSessionManager().get(localPlayer);
+        MoveType moveType = MoveType.MOVE;
+        if (event.getPlayer().isGliding()) {
+            moveType = MoveType.GLIDE;
+        } else if (event.getPlayer().isSwimming()) {
+            moveType = MoveType.SWIM;
+        } else if (event.getPlayer().getVehicle() != null && event.getPlayer().getVehicle() instanceof Horse) {
+            moveType = MoveType.RIDE;
+        }
+        com.sk89q.worldedit.util.Location weLocation = session.testMoveTo(localPlayer, BukkitAdapter.adapt(event.getTo()), moveType);
 
-        if (override != null) {
+        if (weLocation != null) {
+            final Location override = BukkitAdapter.adapt(weLocation);
             override.setX(override.getBlockX() + 0.5);
             override.setY(override.getBlockY());
             override.setZ(override.getBlockZ() + 0.5);
@@ -105,12 +119,7 @@ public class PlayerMoveListener implements Listener {
 
                 player.teleport(override.clone().add(0, 1, 0));
 
-                Bukkit.getScheduler().runTaskLater(plugin, new Runnable() {
-                    @Override
-                    public void run() {
-                        player.teleport(override.clone().add(0, 1, 0));
-                    }
-                }, 1);
+                Bukkit.getScheduler().runTaskLater(plugin, () -> player.teleport(override.clone().add(0, 1, 0)), 1);
             }
         }
     }

worldguard-bukkit/src/main/java/com/sk89q/worldguard/bukkit/listener/RegionFlagsListener.java

@@ -19,16 +19,18 @@
 
 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.worldedit.bukkit.BukkitAdapter;
+import com.sk89q.worldguard.LocalPlayer;
+import com.sk89q.worldguard.WorldGuard;
 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.util.Materials;
+import com.sk89q.worldguard.config.WorldConfiguration;
 import com.sk89q.worldguard.protection.association.RegionAssociable;
-import com.sk89q.worldguard.protection.flags.DefaultFlag;
+import com.sk89q.worldguard.protection.flags.Flags;
 import com.sk89q.worldguard.protection.flags.StateFlag;
+import com.sk89q.worldguard.protection.regions.RegionQuery;
 import org.bukkit.Location;
 import org.bukkit.World;
 import org.bukkit.block.Block;
@@ -37,10 +39,11 @@ import org.bukkit.entity.EntityType;
 import org.bukkit.entity.Player;
 import org.bukkit.event.EventHandler;
 import org.bukkit.event.EventPriority;
+import org.bukkit.event.entity.EntityDamageByEntityEvent;
 import org.bukkit.event.entity.EntityDamageEvent;
 import org.bukkit.event.entity.EntityDamageEvent.DamageCause;
 
-import javax.annotation.Nullable;
+import java.util.function.Predicate;
 
 public class RegionFlagsListener extends AbstractListener {
 
@@ -55,56 +58,57 @@ public class RegionFlagsListener extends AbstractListener {
 
     @EventHandler(priority = EventPriority.LOW, ignoreCancelled = true)
     public void onPlaceBlock(final PlaceBlockEvent event) {
-        if (!isRegionSupportEnabled(event.getWorld())) return; // Region support disabled
+        com.sk89q.worldedit.world.World weWorld = BukkitAdapter.adapt(event.getWorld());
+        if (!isRegionSupportEnabled(weWorld)) return; // Region support disabled
 
-        RegionQuery query = getPlugin().getRegionContainer().createQuery();
+        RegionQuery query = WorldGuard.getInstance().getPlatform().getRegionContainer().createQuery();
 
         Block block;
         if ((block = event.getCause().getFirstBlock()) != null) {
-            // ================================================================
-            // PISTONS flag
-            // ================================================================
-
             if (Materials.isPistonBlock(block.getType())) {
-                event.filter(testState(query, DefaultFlag.PISTONS), false);
+                event.filter(testState(query, Flags.PISTONS), false);
             }
         }
+
+        if (event.getCause().find(EntityType.SNOWMAN) != null) {
+            event.filter(testState(query, Flags.SNOWMAN_TRAILS), false);
+        }
+
+        if (event.getCause().find(EntityType.ENDERMAN) != null) {
+            event.filter(testState(query, Flags.ENDER_BUILD), false);
+        }
     }
 
     @EventHandler(priority = EventPriority.LOW, ignoreCancelled = true)
     public void onBreakBlock(final BreakBlockEvent event) {
-        if (!isRegionSupportEnabled(event.getWorld())) return; // Region support disabled
+        com.sk89q.worldedit.world.World weWorld = BukkitAdapter.adapt(event.getWorld());
+        if (!isRegionSupportEnabled(weWorld)) return; // Region support disabled
 
-        WorldConfiguration config = getWorldConfig(event.getWorld());
-        RegionQuery query = getPlugin().getRegionContainer().createQuery();
+        WorldConfiguration config = getWorldConfig(weWorld);
+        RegionQuery query = WorldGuard.getInstance().getPlatform().getRegionContainer().createQuery();
 
         Block block;
         if ((block = event.getCause().getFirstBlock()) != null) {
-            // ================================================================
-            // PISTONS flag
-            // ================================================================
-
             if (Materials.isPistonBlock(block.getType())) {
-                event.filter(testState(query, DefaultFlag.PISTONS), false);
+                event.filter(testState(query, Flags.PISTONS), false);
             }
         }
 
-        // ================================================================
-        // CREEPER_EXPLOSION flag
-        // ================================================================
-
         if (event.getCause().find(EntityType.CREEPER) != null) { // Creeper
-            event.filter(testState(query, DefaultFlag.CREEPER_EXPLOSION), config.explosionFlagCancellation);
+            event.filter(testState(query, Flags.CREEPER_EXPLOSION), config.explosionFlagCancellation);
         }
 
-        // ================================================================
-        // ENDERDRAGON_BLOCK_DAMAGE flag
-        // ================================================================
-
         if (event.getCause().find(EntityType.ENDER_DRAGON) != null) { // Enderdragon
-            event.filter(testState(query, DefaultFlag.ENDERDRAGON_BLOCK_DAMAGE), config.explosionFlagCancellation);
+            event.filter(testState(query, Flags.ENDERDRAGON_BLOCK_DAMAGE), config.explosionFlagCancellation);
         }
 
+        if (event.getCause().find(EntityType.ENDER_CRYSTAL) != null) { // EnderCrystal
+            event.filter(testState(query, Flags.OTHER_EXPLOSION), config.explosionFlagCancellation);
+        }
+
+        if (event.getCause().find(EntityType.ENDERMAN) != null) {
+            event.filter(testState(query, Flags.ENDER_BUILD), false);
+        }
     }
 
     @EventHandler(priority = EventPriority.LOW, ignoreCancelled = true)
@@ -112,23 +116,37 @@ public class RegionFlagsListener extends AbstractListener {
         Entity entity = event.getEntity();
         World world = entity.getWorld();
 
-        if (!isRegionSupportEnabled(world)) return; // Region support disabled
-        RegionQuery query = getPlugin().getRegionContainer().createQuery();
+        if (!isRegionSupportEnabled(BukkitAdapter.adapt(world))) return; // Region support disabled
+        RegionQuery query = WorldGuard.getInstance().getPlatform().getRegionContainer().createQuery();
 
         if (entity instanceof Player && event.getCause() == DamageCause.FALL) {
-            if (!query.testState(entity.getLocation(), (Player) entity, DefaultFlag.FALL_DAMAGE)) {
+            LocalPlayer localPlayer = WorldGuardPlugin.inst().wrapPlayer((Player) entity);
+            if (!query.testState(BukkitAdapter.adapt(entity.getLocation()), localPlayer, Flags.FALL_DAMAGE)) {
                 event.setCancelled(true);
+                return;
             }
         } else {
             try {
                 if (entity instanceof Player && event.getCause() == DamageCause.FLY_INTO_WALL) {
-                    if (!query.testState(entity.getLocation(), (Player) entity, DefaultFlag.FALL_DAMAGE)) {
+                    LocalPlayer localPlayer = WorldGuardPlugin.inst().wrapPlayer((Player) entity);
+                    if (!query.testState(BukkitAdapter.adapt(entity.getLocation()), localPlayer, Flags.FALL_DAMAGE)) {
                         event.setCancelled(true);
+                        return;
                     }
                 }
             } catch (NoSuchFieldError ignored) {
             }
         }
+
+        if (event instanceof EntityDamageByEntityEvent) {
+            Entity damager = (((EntityDamageByEntityEvent) event)).getDamager();
+            if (damager != null && damager.getType() == EntityType.FIREWORK) {
+                if (!query.testState(BukkitAdapter.adapt(entity.getLocation()), (RegionAssociable) null, Flags.FIREWORK_DAMAGE)) {
+                    event.setCancelled(true);
+                    return;
+                }
+            }
+        }
     }
 
     /**
@@ -139,12 +157,7 @@ public class RegionFlagsListener extends AbstractListener {
      * @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);
-            }
-        };
+        return location -> query.testState(BukkitAdapter.adapt(location), (RegionAssociable) null, flag);
     }
 
 

worldguard-bukkit/src/main/java/com/sk89q/worldguard/bukkit/listener/RegionProtectionListener.java

@@ -20,8 +20,9 @@
 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.worldedit.bukkit.BukkitAdapter;
+import com.sk89q.worldguard.LocalPlayer;
+import com.sk89q.worldguard.WorldGuard;
 import com.sk89q.worldguard.bukkit.WorldGuardPlugin;
 import com.sk89q.worldguard.bukkit.cause.Cause;
 import com.sk89q.worldguard.bukkit.event.DelegateEvent;
@@ -33,19 +34,22 @@ 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.internal.WGMetadata;
-import com.sk89q.worldguard.bukkit.permission.RegionPermissionModel;
-import com.sk89q.worldguard.bukkit.protection.DelayedRegionOverlapAssociation;
+import com.sk89q.worldguard.bukkit.protection.events.DisallowedPVPEvent;
 import com.sk89q.worldguard.bukkit.util.Entities;
 import com.sk89q.worldguard.bukkit.util.Events;
 import com.sk89q.worldguard.bukkit.util.InteropUtils;
 import com.sk89q.worldguard.bukkit.util.Materials;
+import com.sk89q.worldguard.commands.CommandUtils;
+import com.sk89q.worldguard.config.WorldConfiguration;
 import com.sk89q.worldguard.domains.Association;
+import com.sk89q.worldguard.internal.permission.RegionPermissionModel;
+import com.sk89q.worldguard.protection.DelayedRegionOverlapAssociation;
 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.Flags;
 import com.sk89q.worldguard.protection.flags.StateFlag;
 import com.sk89q.worldguard.protection.flags.StateFlag.State;
+import com.sk89q.worldguard.protection.regions.RegionQuery;
 import org.bukkit.ChatColor;
 import org.bukkit.Location;
 import org.bukkit.Material;
@@ -56,6 +60,7 @@ import org.bukkit.entity.Entity;
 import org.bukkit.entity.EntityType;
 import org.bukkit.entity.ExperienceOrb;
 import org.bukkit.entity.Item;
+import org.bukkit.entity.ItemFrame;
 import org.bukkit.entity.Player;
 import org.bukkit.entity.Tameable;
 import org.bukkit.event.Event.Result;
@@ -105,16 +110,22 @@ public class RegionProtectionListener extends AbstractListener {
             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 && !message.isEmpty()) {
-                    player.sendMessage(message.replace("%what%", what));
-                }
+                RegionQuery query = WorldGuard.getInstance().getPlatform().getRegionContainer().createQuery();
+                LocalPlayer localPlayer = getPlugin().wrapPlayer(player);
+                String message = query.queryValue(BukkitAdapter.adapt(location), localPlayer, Flags.DENY_MESSAGE);
+                formatAndSendDenyMessage(what, localPlayer, message);
                 WGMetadata.put(player, DENY_MESSAGE_KEY, now);
             }
         }
     }
 
+    static void formatAndSendDenyMessage(String what, LocalPlayer localPlayer, String message) {
+        if (message == null || message.isEmpty()) return;
+        message = WorldGuard.getInstance().getPlatform().getMatcher().replaceMacros(localPlayer, message);
+        message = CommandUtils.replaceColorMacros(message);
+        localPlayer.printRaw(message.replace("%what%", what));
+    }
+
     /**
      * Return whether the given cause is whitelist (should be ignored).
      *
@@ -126,18 +137,16 @@ public class RegionProtectionListener extends AbstractListener {
     private boolean isWhitelisted(Cause cause, World world, boolean pvp) {
         Object rootCause = cause.getRootCause();
 
-        if (rootCause instanceof Block) {
-            Material type = ((Block) rootCause).getType();
-            return type == Material.HOPPER || type == Material.DROPPER;
-        } else if (rootCause instanceof Player) {
+        if (rootCause instanceof Player) {
             Player player = (Player) rootCause;
-            WorldConfiguration config = getWorldConfig(world);
+            LocalPlayer localPlayer = WorldGuardPlugin.inst().wrapPlayer(player);
+            WorldConfiguration config = getWorldConfig(BukkitAdapter.adapt(world));
 
             if (config.fakePlayerBuildOverride && InteropUtils.isFakePlayer(player)) {
                 return true;
             }
 
-            return !pvp && new RegionPermissionModel(getPlugin(), player).mayIgnoreRegionProtection(world);
+            return !pvp && new RegionPermissionModel(localPlayer).mayIgnoreRegionProtection(BukkitAdapter.adapt(world));
         } else {
             return false;
         }
@@ -153,11 +162,11 @@ public class RegionProtectionListener extends AbstractListener {
         } 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());
+            RegionQuery query = WorldGuard.getInstance().getPlatform().getRegionContainer().createQuery();
+            return new DelayedRegionOverlapAssociation(query, BukkitAdapter.adapt(((Entity) rootCause).getLocation()));
         } else if (rootCause instanceof Block) {
-            RegionQuery query = getPlugin().getRegionContainer().createQuery();
-            return new DelayedRegionOverlapAssociation(query, ((Block) rootCause).getLocation());
+            RegionQuery query = WorldGuard.getInstance().getPlatform().getRegionContainer().createQuery();
+            return new DelayedRegionOverlapAssociation(query, BukkitAdapter.adapt(((Block) rootCause).getLocation()));
         } else {
             return Associables.constant(Association.NON_MEMBER);
         }
@@ -166,93 +175,88 @@ public class RegionProtectionListener extends AbstractListener {
     @EventHandler(ignoreCancelled = true)
     public void onPlaceBlock(final PlaceBlockEvent event) {
         if (event.getResult() == Result.ALLOW) return; // Don't care about events that have been pre-allowed
-        if (!isRegionSupportEnabled(event.getWorld())) return; // Region support disabled
+        if (!isRegionSupportEnabled(BukkitAdapter.adapt(event.getWorld()))) return; // Region support disabled
         if (isWhitelisted(event.getCause(), event.getWorld(), false)) return; // Whitelisted cause
 
         final Material type = event.getEffectiveMaterial();
-        final RegionQuery query = getPlugin().getRegionContainer().createQuery();
+        final RegionQuery query = WorldGuard.getInstance().getPlatform().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) {
+                && !getWorldConfig(BukkitAdapter.adapt(event.getWorld())).checkLiquidFlow) {
             return;
         }
 
-        event.filter(new Predicate<Location>() {
-            @Override
-            public boolean apply(Location target) {
-                boolean canPlace;
-                String what;
+        event.filter((Predicate<Location>) target -> {
+            boolean canPlace;
+            String what;
 
-                /* Flint and steel, fire charge, etc. */
-                if (type == Material.FIRE) {
-                    Block block = event.getCause().getFirstBlock();
-                    boolean fire = block != null && block.getType() == Material.FIRE;
-                    boolean lava = block != null && Materials.isLava(block.getType());
-                    List<StateFlag> flags = new ArrayList<StateFlag>();
-                    flags.add(DefaultFlag.BLOCK_PLACE);
-                    flags.add(DefaultFlag.LIGHTER);
-                    if (fire) flags.add(DefaultFlag.FIRE_SPREAD);
-                    if (lava) flags.add(DefaultFlag.LAVA_FIRE);
-                    canPlace = query.testBuild(target, associable, combine(event, flags.toArray(new StateFlag[flags.size()])));
-                    what = "place fire";
+            /* Flint and steel, fire charge, etc. */
+            if (type == Material.FIRE) {
+                Block block = event.getCause().getFirstBlock();
+                boolean fire = block != null && block.getType() == Material.FIRE;
+                boolean lava = block != null && Materials.isLava(block.getType());
+                List<StateFlag> flags = new ArrayList<>();
+                flags.add(Flags.BLOCK_PLACE);
+                flags.add(Flags.LIGHTER);
+                if (fire) flags.add(Flags.FIRE_SPREAD);
+                if (lava) flags.add(Flags.LAVA_FIRE);
+                canPlace = query.testBuild(BukkitAdapter.adapt(target), associable, combine(event, flags.toArray(new StateFlag[flags.size()])));
+                what = "place fire";
 
-                /* Everything else */
-                } else {
-                    canPlace = query.testBuild(target, associable, combine(event, DefaultFlag.BLOCK_PLACE));
-                    try {
-                        event.setSilent(type == Material.FROSTED_ICE);
-                    } catch (NoSuchFieldError ignored) {} // back compat
-                    what = "place that block";
-                }
-
-                if (!canPlace) {
-                    tellErrorMessage(event, event.getCause(), target, what);
-                    return false;
-                }
-
-                return true;
+            } else if (type == Material.FROSTED_ICE) {
+                event.setSilent(true); // gets spammy
+                canPlace = query.testBuild(BukkitAdapter.adapt(target), associable, combine(event, Flags.BLOCK_PLACE, Flags.FROSTED_ICE_FORM));
+                what = "use frostwalker"; // hidden anyway
+            /* Everything else */
+            } else {
+                canPlace = query.testBuild(BukkitAdapter.adapt(target), associable, combine(event, Flags.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 (event.getResult() == Result.ALLOW) return; // Don't care about events that have been pre-allowed
-        if (!isRegionSupportEnabled(event.getWorld())) return; // Region support disabled
+        if (!isRegionSupportEnabled(BukkitAdapter.adapt(event.getWorld()))) return; // Region support disabled
         if (isWhitelisted(event.getCause(), event.getWorld(), false)) return; // Whitelisted cause
 
-        final RegionQuery query = getPlugin().getRegionContainer().createQuery();
+        final RegionQuery query = WorldGuard.getInstance().getPlatform().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;
+            event.filter((Predicate<Location>) target -> {
+                boolean canBreak;
+                String what;
 
-                    /* TNT */
-                    if (event.getCause().find(EntityType.PRIMED_TNT, EntityType.MINECART_TNT) != null) {
-                        canBreak = query.testBuild(target, associable, combine(event, DefaultFlag.BLOCK_BREAK, DefaultFlag.TNT));
-                        what = "use dynamite";
+                /* TNT */
+                if (event.getCause().find(EntityType.PRIMED_TNT, EntityType.MINECART_TNT) != null) {
+                    canBreak = query.testBuild(BukkitAdapter.adapt(target), associable, combine(event, Flags.BLOCK_BREAK, Flags.TNT));
+                    what = "use dynamite";
 
-                    /* Everything else */
-                    } else {
-                        canBreak = query.testBuild(target, associable, combine(event, DefaultFlag.BLOCK_BREAK));
-                        what = "break that block";
-                    }
-
-                    if (!canBreak) {
-                        tellErrorMessage(event, event.getCause(), target, what);
-                        return false;
-                    }
-
-                    return true;
+                /* Everything else */
+                } else {
+                    canBreak = query.testBuild(BukkitAdapter.adapt(target), associable, combine(event, Flags.BLOCK_BREAK));
+                    what = "break that block";
                 }
+
+                if (!canBreak) {
+                    tellErrorMessage(event, event.getCause(), target, what);
+                    return false;
+                }
+
+                return true;
             });
         }
     }
@@ -260,70 +264,67 @@ public class RegionProtectionListener extends AbstractListener {
     @EventHandler(ignoreCancelled = true)
     public void onUseBlock(final UseBlockEvent event) {
         if (event.getResult() == Result.ALLOW) return; // Don't care about events that have been pre-allowed
-        if (!isRegionSupportEnabled(event.getWorld())) return; // Region support disabled
+        if (!isRegionSupportEnabled(BukkitAdapter.adapt(event.getWorld()))) return; // Region support disabled
         if (isWhitelisted(event.getCause(), event.getWorld(), false)) return; // Whitelisted cause
 
         final Material type = event.getEffectiveMaterial();
-        final RegionQuery query = getPlugin().getRegionContainer().createQuery();
+        final RegionQuery query = WorldGuard.getInstance().getPlatform().getRegionContainer().createQuery();
         final RegionAssociable associable = createRegionAssociable(event.getCause());
 
-        event.filter(new Predicate<Location>() {
-            @Override
-            public boolean apply(Location target) {
-                boolean canUse;
-                String what;
+        event.filter((Predicate<Location>) target -> {
+            boolean canUse;
+            String what;
 
-                /* Saplings, etc. */
-                if (Materials.isConsideredBuildingIfUsed(type)) {
-                    canUse = query.testBuild(target, associable, combine(event));
-                    what = "use that";
+            /* Saplings, etc. */
+            if (Materials.isConsideredBuildingIfUsed(type)) {
+                canUse = query.testBuild(BukkitAdapter.adapt(target), associable, combine(event));
+                what = "use that";
 
-                /* Inventory */
-                } else if (Materials.isInventoryBlock(type)) {
-                    canUse = query.testBuild(target, associable, combine(event, DefaultFlag.INTERACT, DefaultFlag.CHEST_ACCESS));
-                    what = "open that";
+            /* Inventory */
+            } else if (Materials.isInventoryBlock(type)) {
+                canUse = query.testBuild(BukkitAdapter.adapt(target), associable, combine(event, Flags.INTERACT, Flags.CHEST_ACCESS));
+                what = "open that";
 
-                /* Beds */
-                } else if (type == Material.BED_BLOCK) {
-                    canUse = query.testBuild(target, associable, combine(event, DefaultFlag.INTERACT, DefaultFlag.SLEEP));
-                    what = "sleep";
+            /* Beds */
+            } else if (Materials.isBed(type)) {
+                canUse = query.testBuild(BukkitAdapter.adapt(target), associable, combine(event, Flags.INTERACT, Flags.SLEEP));
+                what = "sleep";
 
-                /* TNT */
-                } else if (type == Material.TNT) {
-                    canUse = query.testBuild(target, associable, combine(event, DefaultFlag.INTERACT, DefaultFlag.TNT));
-                    what = "use explosives";
+            /* TNT */
+            } else if (type == Material.TNT) {
+                canUse = query.testBuild(BukkitAdapter.adapt(target), associable, combine(event, Flags.INTERACT, Flags.TNT));
+                what = "use explosives";
 
-                /* Legacy USE flag */
-                } else if (Materials.isUseFlagApplicable(type)) {
-                    canUse = query.testBuild(target, associable, combine(event, DefaultFlag.INTERACT, DefaultFlag.USE));
-                    what = "use that";
+            /* Legacy USE flag */
+            } else if (Materials.isUseFlagApplicable(type)) {
+                canUse = query.testBuild(BukkitAdapter.adapt(target), associable, combine(event, Flags.INTERACT, Flags.USE));
+                what = "use that";
 
-                /* Everything else */
-                } else {
-                    canUse = query.testBuild(target, associable, combine(event, DefaultFlag.INTERACT));
-                    what = "use that";
-                }
-
-                if (!canUse) {
-                    tellErrorMessage(event, event.getCause(), target, what);
-                    return false;
-                }
-
-                return true;
+            /* Everything else */
+            } else {
+                canUse = query.testBuild(BukkitAdapter.adapt(target), associable, combine(event, Flags.INTERACT));
+                what = "use that";
             }
+
+            if (!canUse) {
+                tellErrorMessage(event, event.getCause(), target, what);
+                return false;
+            }
+
+            return true;
         });
     }
 
     @EventHandler(ignoreCancelled = true)
     public void onSpawnEntity(SpawnEntityEvent event) {
         if (event.getResult() == Result.ALLOW) return; // Don't care about events that have been pre-allowed
-        if (!isRegionSupportEnabled(event.getWorld())) return; // Region support disabled
+        if (!isRegionSupportEnabled(BukkitAdapter.adapt(event.getWorld()))) return; // Region support disabled
         if (isWhitelisted(event.getCause(), event.getWorld(), false)) return; // Whitelisted cause
 
         Location target = event.getTarget();
         EntityType type = event.getEffectiveType();
 
-        RegionQuery query = getPlugin().getRegionContainer().createQuery();
+        RegionQuery query = WorldGuard.getInstance().getPlatform().getRegionContainer().createQuery();
         RegionAssociable associable = createRegionAssociable(event.getCause());
 
         boolean canSpawn;
@@ -331,22 +332,26 @@ public class RegionProtectionListener extends AbstractListener {
 
         /* Vehicles */
         if (Entities.isVehicle(type)) {
-            canSpawn = query.testBuild(target, associable, combine(event, DefaultFlag.PLACE_VEHICLE));
+            canSpawn = query.testBuild(BukkitAdapter.adapt(target), associable, combine(event, Flags.PLACE_VEHICLE));
             what = "place vehicles";
 
         /* Item pickup */
         } else if (event.getEntity() instanceof Item) {
-            canSpawn = query.testBuild(target, associable, combine(event, DefaultFlag.ITEM_DROP));
+            canSpawn = query.testBuild(BukkitAdapter.adapt(target), associable, combine(event, Flags.ITEM_DROP));
             what = "drop items";
 
         /* XP drops */
-        } else if (event.getEffectiveType() == EntityType.EXPERIENCE_ORB) {
-            canSpawn = query.testBuild(target, associable, combine(event, DefaultFlag.EXP_DROPS));
+        } else if (type == EntityType.EXPERIENCE_ORB) {
+            canSpawn = query.testBuild(BukkitAdapter.adapt(target), associable, combine(event, Flags.EXP_DROPS));
             what = "drop XP";
 
+        } else if (Entities.isAoECloud(type)) {
+            canSpawn = query.testBuild(BukkitAdapter.adapt(target), associable, combine(event, Flags.POTION_SPLASH));
+            what = "use lingering potions";
+
         /* Everything else */
         } else {
-            canSpawn = query.testBuild(target, associable, combine(event));
+            canSpawn = query.testBuild(BukkitAdapter.adapt(target), associable, combine(event));
 
             if (event.getEntity() instanceof Item) {
                 what = "drop items";
@@ -364,30 +369,30 @@ public class RegionProtectionListener extends AbstractListener {
     @EventHandler(ignoreCancelled = true)
     public void onDestroyEntity(DestroyEntityEvent event) {
         if (event.getResult() == Result.ALLOW) return; // Don't care about events that have been pre-allowed
-        if (!isRegionSupportEnabled(event.getWorld())) return; // Region support disabled
+        if (!isRegionSupportEnabled(BukkitAdapter.adapt(event.getWorld()))) return; // Region support disabled
         if (isWhitelisted(event.getCause(), event.getWorld(), false)) return; // Whitelisted cause
 
         Location target = event.getTarget();
         EntityType type = event.getEntity().getType();
         RegionAssociable associable = createRegionAssociable(event.getCause());
 
-        RegionQuery query = getPlugin().getRegionContainer().createQuery();
+        RegionQuery query = WorldGuard.getInstance().getPlatform().getRegionContainer().createQuery();
         boolean canDestroy;
         String what;
 
         /* Vehicles */
         if (Entities.isVehicle(type)) {
-            canDestroy = query.testBuild(target, associable, combine(event, DefaultFlag.DESTROY_VEHICLE));
+            canDestroy = query.testBuild(BukkitAdapter.adapt(target), associable, combine(event, Flags.DESTROY_VEHICLE));
             what = "break vehicles";
 
         /* Item pickup */
         } else if (event.getEntity() instanceof Item || event.getEntity() instanceof ExperienceOrb) {
-            canDestroy = query.testBuild(target, associable, combine(event, DefaultFlag.ITEM_PICKUP));
+            canDestroy = query.testBuild(BukkitAdapter.adapt(target), associable, combine(event, Flags.ITEM_PICKUP));
             what = "pick up items";
 
         /* Everything else */
         } else {
-            canDestroy = query.testBuild(target, associable, combine(event));
+            canDestroy = query.testBuild(BukkitAdapter.adapt(target), associable, combine(event));
             what = "break things";
         }
 
@@ -400,35 +405,43 @@ public class RegionProtectionListener extends AbstractListener {
     @EventHandler(ignoreCancelled = true)
     public void onUseEntity(UseEntityEvent event) {
         if (event.getResult() == Result.ALLOW) return; // Don't care about events that have been pre-allowed
-        if (!isRegionSupportEnabled(event.getWorld())) return; // Region support disabled
+        if (!isRegionSupportEnabled(BukkitAdapter.adapt(event.getWorld()))) return; // Region support disabled
         if (isWhitelisted(event.getCause(), event.getWorld(), false)) return; // Whitelisted cause
 
         Location target = event.getTarget();
         RegionAssociable associable = createRegionAssociable(event.getCause());
 
-        RegionQuery query = getPlugin().getRegionContainer().createQuery();
+        RegionQuery query = WorldGuard.getInstance().getPlatform().getRegionContainer().createQuery();
         boolean canUse;
         String what;
 
         /* Hostile / ambient mob override */
+        final EntityType type = event.getEntity().getType();
         if (Entities.isHostile(event.getEntity()) || Entities.isAmbient(event.getEntity())
-                || Entities.isNPC(event.getEntity()) || Entities.isVehicle(event.getEntity().getType())) {
-            canUse = event.getRelevantFlags().isEmpty() || query.queryState(target, associable, combine(event)) != State.DENY;
+                || Entities.isNPC(event.getEntity())) {
+            canUse = event.getRelevantFlags().isEmpty() || query.queryState(BukkitAdapter.adapt(target), associable, combine(event)) != State.DENY;
             what = "use that";
-
         /* Paintings, item frames, etc. */
         } else if (Entities.isConsideredBuildingIfUsed(event.getEntity())) {
-            canUse = query.testBuild(target, associable, combine(event));
-            what = "change that";
-
+            if (type == EntityType.ITEM_FRAME && event.getCause().getFirstPlayer() != null
+                    && ((ItemFrame) event.getEntity()).getItem().getType() != Material.AIR) {
+                canUse = query.testBuild(BukkitAdapter.adapt(target), associable, combine(event, Flags.ITEM_FRAME_ROTATE));
+                what = "change that";
+            } else if (Entities.isMinecart(type)) {
+                canUse = query.testBuild(BukkitAdapter.adapt(target), associable, combine(event, Flags.CHEST_ACCESS));
+                what = "open that";
+            } else {
+                canUse = query.testBuild(BukkitAdapter.adapt(target), associable, combine(event));
+                what = "change that";
+            }
         /* Ridden on use */
         } else if (Entities.isRiddenOnUse(event.getEntity())) {
-            canUse = query.testBuild(target, associable, combine(event, DefaultFlag.RIDE, DefaultFlag.INTERACT));
+            canUse = query.testBuild(BukkitAdapter.adapt(target), associable, combine(event, Flags.RIDE, Flags.INTERACT));
             what = "ride that";
 
         /* Everything else */
         } else {
-            canUse = query.testBuild(target, associable, combine(event, DefaultFlag.INTERACT));
+            canUse = query.testBuild(BukkitAdapter.adapt(target), associable, combine(event, Flags.INTERACT));
             what = "use that";
         }
 
@@ -441,13 +454,13 @@ public class RegionProtectionListener extends AbstractListener {
     @EventHandler(ignoreCancelled = true)
     public void onDamageEntity(DamageEntityEvent event) {
         if (event.getResult() == Result.ALLOW) return; // Don't care about events that have been pre-allowed
-        if (!isRegionSupportEnabled(event.getWorld())) return; // Region support disabled
+        if (!isRegionSupportEnabled(BukkitAdapter.adapt(event.getWorld()))) return; // Region support disabled
         // Whitelist check is below
 
-        Location target = event.getTarget();
+        com.sk89q.worldedit.util.Location target = BukkitAdapter.adapt(event.getTarget());
         RegionAssociable associable = createRegionAssociable(event.getCause());
 
-        RegionQuery query = getPlugin().getRegionContainer().createQuery();
+        RegionQuery query = WorldGuard.getInstance().getPlatform().getRegionContainer().createQuery();
         Player playerAttacker = event.getCause().getFirstPlayer();
         boolean canDamage;
         String what;
@@ -473,11 +486,17 @@ public class RegionProtectionListener extends AbstractListener {
 
         /* PVP */
         } else if (pvp) {
+            LocalPlayer localAttacker = WorldGuardPlugin.inst().wrapPlayer(playerAttacker);
             Player defender = (Player) event.getEntity();
 
-            canDamage = query.testBuild(target, associable, combine(event, DefaultFlag.PVP))
-                    && query.queryState(playerAttacker.getLocation(), playerAttacker, combine(event, DefaultFlag.PVP)) != State.DENY
-                    && query.queryState(target, playerAttacker, combine(event, DefaultFlag.PVP)) != State.DENY;
+            // if defender is an NPC
+            if (Entities.isNPC(defender)) {
+                return;
+            }
+
+            canDamage = query.testBuild(target, associable, combine(event, Flags.PVP))
+                    && query.queryState(localAttacker.getLocation(), localAttacker, combine(event, Flags.PVP)) != State.DENY
+                    && query.queryState(target, localAttacker, combine(event, Flags.PVP)) != State.DENY;
 
             // Fire the disallow PVP event
             if (!canDamage && Events.fireAndTestCancel(new DisallowedPVPEvent(playerAttacker, defender, event.getOriginalEvent()))) {
@@ -493,17 +512,17 @@ public class RegionProtectionListener extends AbstractListener {
 
         /* damage to non-hostile mobs (e.g. animals) */
         } else if (Entities.isNonHostile(event.getEntity())) {
-            canDamage = query.testBuild(target, associable, combine(event, DefaultFlag.DAMAGE_ANIMALS));
+            canDamage = query.testBuild(target, associable, combine(event, Flags.DAMAGE_ANIMALS));
             what = "harm that";
 
         /* Everything else */
         } else {
-            canDamage = query.testBuild(target, associable, combine(event, DefaultFlag.INTERACT));
+            canDamage = query.testBuild(target, associable, combine(event, Flags.INTERACT));
             what = "hit that";
         }
 
         if (!canDamage) {
-            tellErrorMessage(event, event.getCause(), target, what);
+            tellErrorMessage(event, event.getCause(), event.getTarget(), what);
             event.setCancelled(true);
         }
     }
@@ -511,14 +530,16 @@ public class RegionProtectionListener extends AbstractListener {
     @EventHandler(ignoreCancelled = true)
     public void onVehicleExit(VehicleExitEvent event) {
         Entity vehicle = event.getVehicle();
+        if (!isRegionSupportEnabled(BukkitAdapter.adapt(vehicle.getWorld()))) return; // Region support disabled
         Entity exited = event.getExited();
 
         if (vehicle instanceof Tameable && exited instanceof Player) {
             Player player = (Player) exited;
+            LocalPlayer localPlayer = WorldGuardPlugin.inst().wrapPlayer(player);
             if (!isWhitelisted(Cause.create(player), vehicle.getWorld(), false)) {
-                RegionQuery query = getPlugin().getRegionContainer().createQuery();
+                RegionQuery query = WorldGuard.getInstance().getPlatform().getRegionContainer().createQuery();
                 Location location = vehicle.getLocation();
-                if (!query.testBuild(location, player, DefaultFlag.RIDE, DefaultFlag.INTERACT)) {
+                if (!query.testBuild(BukkitAdapter.adapt(location), localPlayer, Flags.RIDE, Flags.INTERACT)) {
                     long now = System.currentTimeMillis();
                     Long lastTime = WGMetadata.getIfPresent(player, DISEMBARK_MESSAGE_KEY, Long.class);
                     if (lastTime == null || now - lastTime >= LAST_MESSAGE_DELAY) {

worldguard-bukkit/src/main/java/com/sk89q/worldguard/bukkit/listener/WorldGuardBlockListener.java

@@ -19,14 +19,18 @@
 
 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.worldedit.bukkit.BukkitAdapter;
+import com.sk89q.worldguard.WorldGuard;
+import com.sk89q.worldguard.bukkit.BukkitWorldConfiguration;
 import com.sk89q.worldguard.bukkit.WorldGuardPlugin;
+import com.sk89q.worldguard.bukkit.util.Materials;
+import com.sk89q.worldguard.config.ConfigurationManager;
+import com.sk89q.worldguard.config.WorldConfiguration;
 import com.sk89q.worldguard.protection.ApplicableRegionSet;
-import com.sk89q.worldguard.protection.flags.DefaultFlag;
+import com.sk89q.worldguard.protection.association.RegionAssociable;
+import com.sk89q.worldguard.protection.flags.Flags;
+import com.sk89q.worldguard.protection.flags.StateFlag;
+import com.sk89q.worldguard.util.SpongeUtil;
 import org.bukkit.Material;
 import org.bukkit.World;
 import org.bukkit.block.Block;
@@ -37,9 +41,11 @@ 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.BlockExplodeEvent;
 import org.bukkit.event.block.BlockFadeEvent;
 import org.bukkit.event.block.BlockFormEvent;
 import org.bukkit.event.block.BlockFromToEvent;
+import org.bukkit.event.block.BlockGrowEvent;
 import org.bukkit.event.block.BlockIgniteEvent;
 import org.bukkit.event.block.BlockIgniteEvent.IgniteCause;
 import org.bukkit.event.block.BlockPhysicsEvent;
@@ -49,6 +55,8 @@ import org.bukkit.event.block.BlockSpreadEvent;
 import org.bukkit.event.block.EntityBlockFormEvent;
 import org.bukkit.event.block.LeavesDecayEvent;
 import org.bukkit.inventory.ItemStack;
+import org.bukkit.inventory.meta.Damageable;
+import org.bukkit.inventory.meta.ItemMeta;
 
 /**
  * The listener for block events.
@@ -81,17 +89,17 @@ public class WorldGuardBlockListener implements Listener {
      * @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);
+    private WorldConfiguration getWorldConfig(World world) {
+        return WorldGuard.getInstance().getPlatform().getGlobalStateManager().get(BukkitAdapter.adapt(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
+     * @return The {@link BukkitWorldConfiguration} for the player's world
      */
-    protected WorldConfiguration getWorldConfig(Player player) {
+    private WorldConfiguration getWorldConfig(Player player) {
         return getWorldConfig(player.getWorld());
     }
 
@@ -101,14 +109,15 @@ public class WorldGuardBlockListener implements Listener {
     @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);
+            ItemStack held = player.getInventory().getItemInMainHand();
+            ItemMeta meta = held.getItemMeta();
+            if (meta != null) {
+                ((Damageable) meta).setDamage(0);
+                held.setItemMeta(meta);
+                player.getInventory().setItemInMainHand(held);
             }
         }
     }
@@ -122,12 +131,12 @@ public class WorldGuardBlockListener implements Listener {
         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;
+        boolean isWater = blockFrom.getType() == Material.WATER;
+        boolean isLava = blockFrom.getType() == Material.LAVA;
+        boolean isAir = blockFrom.getType() == Material.AIR;
 
-        ConfigurationManager cfg = plugin.getGlobalStateManager();
-        WorldConfiguration wcfg = cfg.get(event.getBlock().getWorld());
+        ConfigurationManager cfg = WorldGuard.getInstance().getPlatform().getGlobalStateManager();
+        WorldConfiguration wcfg = getWorldConfig(event.getBlock().getWorld());
 
         if (cfg.activityHaltToggle) {
             event.setCancelled(true);
@@ -143,7 +152,7 @@ public class WorldGuardBlockListener implements Listener {
                 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
+                        if (sponge.getType() == Material.SPONGE
                                 && (!wcfg.redstoneSponges || !sponge.isBlockIndirectlyPowered())) {
                             event.setCancelled(true);
                             return;
@@ -166,43 +175,41 @@ public class WorldGuardBlockListener implements Listener {
 
         // 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 (!wcfg.preventWaterDamage.isEmpty()) {
+            Material targetId = blockTo.getType();
 
             if ((isAir || isWater) &&
-                    wcfg.preventWaterDamage.contains(targetId)) {
+                    wcfg.preventWaterDamage.contains(BukkitAdapter.asBlockType(targetId).getId())) {
                 event.setCancelled(true);
                 return;
             }
         }
 
-        if (wcfg.allowedLavaSpreadOver.size() > 0 && isLava) {
-            int targetId = blockTo.getRelative(0, -1, 0).getTypeId();
+        if (!wcfg.allowedLavaSpreadOver.isEmpty() && isLava) {
+            Material targetId = blockTo.getRelative(0, -1, 0).getType();
 
-            if (!wcfg.allowedLavaSpreadOver.contains(targetId)) {
+            if (!wcfg.allowedLavaSpreadOver.contains(BukkitAdapter.asBlockType(targetId).getId())) {
                 event.setCancelled(true);
                 return;
             }
         }
 
         if (wcfg.highFreqFlags && isWater
-                && !plugin.getGlobalRegionManager().allows(DefaultFlag.WATER_FLOW,
-                blockFrom.getLocation())) {
+                && WorldGuard.getInstance().getPlatform().getRegionContainer().createQuery().queryState(BukkitAdapter.adapt(blockFrom.getLocation()), (RegionAssociable) null, Flags.WATER_FLOW) == StateFlag.State.DENY) {
             event.setCancelled(true);
             return;
         }
 
         if (wcfg.highFreqFlags && isLava
-                && !plugin.getGlobalRegionManager().allows(DefaultFlag.LAVA_FLOW,
-                blockFrom.getLocation())) {
+                && !StateFlag.test(WorldGuard.getInstance().getPlatform().getRegionContainer().createQuery().queryState(BukkitAdapter.adapt(blockFrom.getLocation()), (RegionAssociable) null, Flags.LAVA_FLOW))) {
             event.setCancelled(true);
             return;
         }
 
         if (wcfg.disableObsidianGenerators && (isAir || isLava)
-                && (blockTo.getTypeId() == BlockID.REDSTONE_WIRE
-                    || blockTo.getTypeId() == BlockID.TRIPWIRE)) {
-            blockTo.setTypeId(BlockID.AIR);
+                && (blockTo.getType() == Material.REDSTONE_WIRE
+                    || blockTo.getType() == Material.TRIPWIRE)) {
+            blockTo.setType(Material.AIR);
             return;
         }
     }
@@ -216,8 +223,8 @@ public class WorldGuardBlockListener implements Listener {
         Block block = event.getBlock();
         World world = block.getWorld();
 
-        ConfigurationManager cfg = plugin.getGlobalStateManager();
-        WorldConfiguration wcfg = cfg.get(world);
+        ConfigurationManager cfg = WorldGuard.getInstance().getPlatform().getGlobalStateManager();
+        WorldConfiguration wcfg = getWorldConfig(world);
 
         if (cfg.activityHaltToggle) {
             event.setCancelled(true);
@@ -252,45 +259,46 @@ public class WorldGuardBlockListener implements Listener {
             return;
         }
 
-        if (wcfg.disableFireSpreadBlocks.size() > 0 && isFireSpread) {
+        if (!wcfg.disableFireSpreadBlocks.isEmpty() && 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))) {
+            if (wcfg.disableFireSpreadBlocks.contains(BukkitAdapter.asBlockType(world.getBlockAt(x, y - 1, z).getType()).getId())
+                    || wcfg.disableFireSpreadBlocks.contains(BukkitAdapter.asBlockType(world.getBlockAt(x + 1, y, z).getType()).getId())
+                    || wcfg.disableFireSpreadBlocks.contains(BukkitAdapter.asBlockType(world.getBlockAt(x - 1, y, z).getType()).getId())
+                    || wcfg.disableFireSpreadBlocks.contains(BukkitAdapter.asBlockType(world.getBlockAt(x, y, z - 1).getType()).getId())
+                    || wcfg.disableFireSpreadBlocks.contains(BukkitAdapter.asBlockType(world.getBlockAt(x, y, z + 1).getType()).getId())) {
                 event.setCancelled(true);
                 return;
             }
         }
 
         if (wcfg.useRegions) {
-            ApplicableRegionSet set = plugin.getRegionContainer().createQuery().getApplicableRegions(block.getLocation());
+            ApplicableRegionSet set =
+                    WorldGuard.getInstance().getPlatform().getRegionContainer().createQuery().getApplicableRegions(BukkitAdapter.adapt(block.getLocation()));
 
             if (wcfg.highFreqFlags && isFireSpread
-                    && !set.allows(DefaultFlag.FIRE_SPREAD)) {
+                    && !set.testState(null, Flags.FIRE_SPREAD)) {
                 event.setCancelled(true);
                 return;
             }
 
             if (wcfg.highFreqFlags && cause == IgniteCause.LAVA
-                    && !set.allows(DefaultFlag.LAVA_FIRE)) {
+                    && !set.testState(null, Flags.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)) {
+                if (!set.testState(null, Flags.GHAST_FIREBALL)) {
                     event.setCancelled(true);
                     return;
                 }
             }
 
-            if (cause == IgniteCause.LIGHTNING && !set.allows(DefaultFlag.LIGHTNING)) {
+            if (cause == IgniteCause.LIGHTNING && !set.testState(null, Flags.LIGHTNING)) {
                 event.setCancelled(true);
                 return;
             }
@@ -302,8 +310,8 @@ public class WorldGuardBlockListener implements Listener {
      */
     @EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
     public void onBlockBurn(BlockBurnEvent event) {
-        ConfigurationManager cfg = plugin.getGlobalStateManager();
-        WorldConfiguration wcfg = cfg.get(event.getBlock().getWorld());
+        ConfigurationManager cfg = WorldGuard.getInstance().getPlatform().getGlobalStateManager();
+        BukkitWorldConfiguration wcfg = (BukkitWorldConfiguration) getWorldConfig(event.getBlock().getWorld());
 
         if (cfg.activityHaltToggle) {
             event.setCancelled(true);
@@ -318,21 +326,21 @@ public class WorldGuardBlockListener implements Listener {
         if (wcfg.fireSpreadDisableToggle) {
             Block block = event.getBlock();
             event.setCancelled(true);
-            checkAndDestroyAround(block.getWorld(), block.getX(), block.getY(), block.getZ(), BlockID.FIRE);
+            checkAndDestroyAround(block.getWorld(), block.getX(), block.getY(), block.getZ(), Material.FIRE);
             return;
         }
 
-        if (wcfg.disableFireSpreadBlocks.size() > 0) {
+        if (!wcfg.disableFireSpreadBlocks.isEmpty()) {
             Block block = event.getBlock();
 
-            if (wcfg.disableFireSpreadBlocks.contains(block.getTypeId())) {
+            if (wcfg.disableFireSpreadBlocks.contains(BukkitAdapter.asBlockType(block.getType()).getId())) {
                 event.setCancelled(true);
-                checkAndDestroyAround(block.getWorld(), block.getX(), block.getY(), block.getZ(), BlockID.FIRE);
+                checkAndDestroyAround(block.getWorld(), block.getX(), block.getY(), block.getZ(), Material.FIRE);
                 return;
             }
         }
 
-        if (wcfg.isChestProtected(event.getBlock())) {
+        if (wcfg.isChestProtected(BukkitAdapter.adapt(event.getBlock().getLocation()))) {
             event.setCancelled(true);
             return;
         }
@@ -342,17 +350,18 @@ public class WorldGuardBlockListener implements Listener {
             int x = block.getX();
             int y = block.getY();
             int z = block.getZ();
-            ApplicableRegionSet set = plugin.getRegionContainer().createQuery().getApplicableRegions(block.getLocation());
+            ApplicableRegionSet set =
+                    WorldGuard.getInstance().getPlatform().getRegionContainer().createQuery().getApplicableRegions(BukkitAdapter.adapt(block.getLocation()));
 
-            if (!set.allows(DefaultFlag.FIRE_SPREAD)) {
-                checkAndDestroyAround(block.getWorld(), x, y, z, BlockID.FIRE);
+            if (!set.testState(null, Flags.FIRE_SPREAD)) {
+                checkAndDestroyAround(block.getWorld(), x, y, z, Material.FIRE);
                 event.setCancelled(true);
             }
 
         }
     }
 
-    private void checkAndDestroyAround(World world, int x, int y, int z, int required) {
+    private void checkAndDestroyAround(World world, int x, int y, int z, Material required) {
         checkAndDestroy(world, x, y, z + 1, required);
         checkAndDestroy(world, x, y, z - 1, required);
         checkAndDestroy(world, x, y + 1, z, required);
@@ -361,9 +370,9 @@ public class WorldGuardBlockListener implements Listener {
         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);
+    private void checkAndDestroy(World world, int x, int y, int z, Material required) {
+        if (world.getBlockAt(x, y, z).getType() == required) {
+            world.getBlockAt(x, y, z).setType(Material.AIR);
         }
     }
 
@@ -372,27 +381,27 @@ public class WorldGuardBlockListener implements Listener {
      */
     @EventHandler(ignoreCancelled = true)
     public void onBlockPhysics(BlockPhysicsEvent event) {
-        ConfigurationManager cfg = plugin.getGlobalStateManager();
-        WorldConfiguration wcfg = cfg.get(event.getBlock().getWorld());
+        ConfigurationManager cfg = WorldGuard.getInstance().getPlatform().getGlobalStateManager();
+        WorldConfiguration wcfg = getWorldConfig(event.getBlock().getWorld());
 
         if (cfg.activityHaltToggle) {
             event.setCancelled(true);
             return;
         }
 
-        int id = event.getBlock().getTypeId();
+        Material id = event.getBlock().getType();
 
-        if (id == 13 && wcfg.noPhysicsGravel) {
+        if (id == Material.GRAVEL && wcfg.noPhysicsGravel) {
             event.setCancelled(true);
             return;
         }
 
-        if (id == 12 && wcfg.noPhysicsSand) {
+        if (id == Material.SAND && wcfg.noPhysicsSand) {
             event.setCancelled(true);
             return;
         }
 
-        if (id == 90 && wcfg.allowPortalAnywhere) {
+        if (id == Material.NETHER_PORTAL && wcfg.allowPortalAnywhere) {
             event.setCancelled(true);
             return;
         }
@@ -413,8 +422,7 @@ public class WorldGuardBlockListener implements Listener {
         Block target = event.getBlock();
         World world = target.getWorld();
 
-        ConfigurationManager cfg = plugin.getGlobalStateManager();
-        WorldConfiguration wcfg = cfg.get(world);
+        WorldConfiguration wcfg = getWorldConfig(world);
 
         if (wcfg.simulateSponge && target.getType() == Material.SPONGE) {
             if (wcfg.redstoneSponges && target.isBlockIndirectlyPowered()) {
@@ -425,7 +433,7 @@ public class WorldGuardBlockListener implements Listener {
             int oy = target.getY();
             int oz = target.getZ();
 
-            SpongeUtil.clearSpongeWater(plugin, world, ox, oy, oz);
+            SpongeUtil.clearSpongeWater(BukkitAdapter.adapt(world), ox, oy, oz);
         }
     }
 
@@ -437,8 +445,7 @@ public class WorldGuardBlockListener implements Listener {
         Block blockTo = event.getBlock();
         World world = blockTo.getWorld();
 
-        ConfigurationManager cfg = plugin.getGlobalStateManager();
-        WorldConfiguration wcfg = cfg.get(world);
+        WorldConfiguration wcfg = getWorldConfig(world);
 
         if (wcfg.simulateSponge && wcfg.redstoneSponges) {
             int ox = blockTo.getX();
@@ -449,12 +456,12 @@ public class WorldGuardBlockListener implements Listener {
                 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
+                        if (sponge.getType() == Material.SPONGE
                                 && sponge.isBlockIndirectlyPowered()) {
-                            SpongeUtil.clearSpongeWater(plugin, world, ox + cx, oy + cy, oz + cz);
-                        } else if (sponge.getTypeId() == 19
+                            SpongeUtil.clearSpongeWater(BukkitAdapter.adapt(world), ox + cx, oy + cy, oz + cz);
+                        } else if (sponge.getType() == Material.SPONGE
                                 && !sponge.isBlockIndirectlyPowered()) {
-                            SpongeUtil.addSpongeWater(plugin, world, ox + cx, oy + cy, oz + cz);
+                            SpongeUtil.addSpongeWater(BukkitAdapter.adapt(world), ox + cx, oy + cy, oz + cz);
                         }
                     }
                 }
@@ -466,8 +473,8 @@ public class WorldGuardBlockListener implements Listener {
 
     @EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
     public void onLeavesDecay(LeavesDecayEvent event) {
-        ConfigurationManager cfg = plugin.getGlobalStateManager();
-        WorldConfiguration wcfg = cfg.get(event.getBlock().getWorld());
+        ConfigurationManager cfg = WorldGuard.getInstance().getPlatform().getGlobalStateManager();
+        WorldConfiguration wcfg = getWorldConfig(event.getBlock().getWorld());
 
         if (cfg.activityHaltToggle) {
             event.setCancelled(true);
@@ -480,8 +487,7 @@ public class WorldGuardBlockListener implements Listener {
         }
 
         if (wcfg.useRegions) {
-            if (!plugin.getGlobalRegionManager().allows(DefaultFlag.LEAF_DECAY,
-                    event.getBlock().getLocation())) {
+            if (!StateFlag.test(WorldGuard.getInstance().getPlatform().getRegionContainer().createQuery().queryState(BukkitAdapter.adapt(event.getBlock().getLocation()), (RegionAssociable) null, Flags.LEAF_DECAY))) {
                 event.setCancelled(true);
             }
         }
@@ -492,15 +498,15 @@ public class WorldGuardBlockListener implements Listener {
      */
     @EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
     public void onBlockForm(BlockFormEvent event) {
-        ConfigurationManager cfg = plugin.getGlobalStateManager();
-        WorldConfiguration wcfg = cfg.get(event.getBlock().getWorld());
+        ConfigurationManager cfg = WorldGuard.getInstance().getPlatform().getGlobalStateManager();
+        WorldConfiguration wcfg = getWorldConfig(event.getBlock().getWorld());
 
         if (cfg.activityHaltToggle) {
             event.setCancelled(true);
             return;
         }
 
-        int type = event.getNewState().getTypeId();
+        Material type = event.getNewState().getType();
 
         if (event instanceof EntityBlockFormEvent) {
             if (((EntityBlockFormEvent) event).getEntity() instanceof Snowman) {
@@ -512,33 +518,33 @@ public class WorldGuardBlockListener implements Listener {
             return;
         }
 
-        if (type == BlockID.ICE) {
+        if (type == Material.ICE) {
             if (wcfg.disableIceFormation) {
                 event.setCancelled(true);
                 return;
             }
-            if (wcfg.useRegions && !plugin.getGlobalRegionManager().allows(
-                    DefaultFlag.ICE_FORM, event.getBlock().getLocation())) {
+            if (wcfg.useRegions && !StateFlag.test(WorldGuard.getInstance().getPlatform().getRegionContainer().createQuery()
+                    .queryState(BukkitAdapter.adapt(event.getBlock().getLocation()), (RegionAssociable) null, Flags.ICE_FORM))) {
                 event.setCancelled(true);
                 return;
             }
         }
 
-        if (type == BlockID.SNOW) {
+        if (type == Material.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.isEmpty()) {
+                Material targetId = event.getBlock().getRelative(0, -1, 0).getType();
 
-                if (!wcfg.allowedSnowFallOver.contains(targetId)) {
+                if (!wcfg.allowedSnowFallOver.contains(BukkitAdapter.asBlockType(targetId).getId())) {
                     event.setCancelled(true);
                     return;
                 }
             }
-            if (wcfg.useRegions && !plugin.getGlobalRegionManager().allows(
-                    DefaultFlag.SNOW_FALL, event.getBlock().getLocation())) {
+            if (wcfg.useRegions && !StateFlag.test(WorldGuard.getInstance().getPlatform().getRegionContainer().createQuery()
+                    .queryState(BukkitAdapter.adapt(event.getBlock().getLocation()), (RegionAssociable) null, Flags.SNOW_FALL))) {
                 event.setCancelled(true);
                 return;
             }
@@ -550,63 +556,80 @@ public class WorldGuardBlockListener implements Listener {
      */
     @EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
     public void onBlockSpread(BlockSpreadEvent event) {
-        ConfigurationManager cfg = plugin.getGlobalStateManager();
-        WorldConfiguration wcfg = cfg.get(event.getBlock().getWorld());
+        ConfigurationManager cfg = WorldGuard.getInstance().getPlatform().getGlobalStateManager();
+        WorldConfiguration wcfg = getWorldConfig(event.getBlock().getWorld());
 
         if (cfg.activityHaltToggle) {
             event.setCancelled(true);
             return;
         }
 
-        int fromType = event.getSource().getTypeId();
+        Material newType = event.getNewState().getType(); // craftbukkit randomly gives AIR as event.getSource even if that block is not air
 
-        if (fromType == BlockID.RED_MUSHROOM || fromType == BlockID.BROWN_MUSHROOM) {
+        if (Materials.isMushroom(newType)) {
             if (wcfg.disableMushroomSpread) {
                 event.setCancelled(true);
                 return;
             }
-            if (wcfg.useRegions && !plugin.getGlobalRegionManager().allows(
-                    DefaultFlag.MUSHROOMS, event.getBlock().getLocation())) {
+            if (wcfg.useRegions && !StateFlag.test(WorldGuard.getInstance().getPlatform().getRegionContainer().createQuery()
+                    .queryState(BukkitAdapter.adapt(event.getBlock().getLocation()), (RegionAssociable) null, Flags.MUSHROOMS))) {
                 event.setCancelled(true);
                 return;
             }
         }
 
-        if (fromType == BlockID.GRASS) {
+        if (newType == Material.GRASS_BLOCK) {
             if (wcfg.disableGrassGrowth) {
                 event.setCancelled(true);
                 return;
             }
-            if (wcfg.useRegions && !plugin.getGlobalRegionManager().allows(
-                    DefaultFlag.GRASS_SPREAD, event.getBlock().getLocation())) {
+            if (wcfg.useRegions && !StateFlag.test(WorldGuard.getInstance().getPlatform().getRegionContainer().createQuery()
+                    .queryState(BukkitAdapter.adapt(event.getBlock().getLocation()), (RegionAssociable) null, Flags.GRASS_SPREAD))) {
                 event.setCancelled(true);
                 return;
             }
         }
 
-        if (fromType == BlockID.MYCELIUM) {
+        if (newType == Material.MYCELIUM) {
             if (wcfg.disableMyceliumSpread) {
                 event.setCancelled(true);
                 return;
             }
 
-            if (wcfg.useRegions
-                    && !plugin.getGlobalRegionManager().allows(
-                            DefaultFlag.MYCELIUM_SPREAD, event.getBlock().getLocation())) {
+            if (wcfg.useRegions && !StateFlag.test(WorldGuard.getInstance().getPlatform().getRegionContainer().createQuery()
+                    .queryState(BukkitAdapter.adapt(event.getBlock().getLocation()), (RegionAssociable) null, Flags.MYCELIUM_SPREAD))) {
                 event.setCancelled(true);
                 return;
             }
         }
 
-        if (fromType == BlockID.VINE) {
+        if (newType == Material.VINE || newType == Material.KELP) {
             if (wcfg.disableVineGrowth) {
                 event.setCancelled(true);
                 return;
             }
 
-            if (wcfg.useRegions
-                    && !plugin.getGlobalRegionManager().allows(
-                            DefaultFlag.VINE_GROWTH, event.getBlock().getLocation())) {
+            if (wcfg.useRegions && !StateFlag.test(WorldGuard.getInstance().getPlatform().getRegionContainer().createQuery()
+                    .queryState(BukkitAdapter.adapt(event.getBlock().getLocation()), (RegionAssociable) null, Flags.VINE_GROWTH))) {
+                event.setCancelled(true);
+                return;
+            }
+        }
+    }
+
+    @EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
+    public void onBlockGrow(BlockGrowEvent event) {
+        WorldConfiguration wcfg = getWorldConfig(event.getBlock().getWorld());
+        final Material type = event.getBlock().getType();
+
+        if (Materials.isCrop(type)) {
+            if (wcfg.disableCropGrowth) {
+                event.setCancelled(false);
+                return;
+            }
+
+            if (wcfg.useRegions && !StateFlag.test(WorldGuard.getInstance().getPlatform().getRegionContainer().createQuery()
+                .queryState(BukkitAdapter.adapt(event.getBlock().getLocation()), (RegionAssociable) null, Flags.CROP_GROWTH))) {
                 event.setCancelled(true);
                 return;
             }
@@ -619,49 +642,62 @@ public class WorldGuardBlockListener implements Listener {
     @EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
     public void onBlockFade(BlockFadeEvent event) {
 
-        ConfigurationManager cfg = plugin.getGlobalStateManager();
-        WorldConfiguration wcfg = cfg.get(event.getBlock().getWorld());
+        WorldConfiguration wcfg = getWorldConfig(event.getBlock().getWorld());
 
-        switch (event.getBlock().getTypeId()) {
-        case BlockID.ICE:
+        if (event.getBlock().getType() == Material.ICE) {
             if (wcfg.disableIceMelting) {
                 event.setCancelled(true);
                 return;
             }
 
-            if (wcfg.useRegions && !plugin.getGlobalRegionManager().allows(
-                    DefaultFlag.ICE_MELT, event.getBlock().getLocation())) {
+            if (wcfg.useRegions && !StateFlag.test(WorldGuard.getInstance().getPlatform().getRegionContainer().createQuery()
+                    .queryState(BukkitAdapter.adapt(event.getBlock().getLocation()), (RegionAssociable) null, Flags.ICE_MELT))) {
                 event.setCancelled(true);
                 return;
             }
-            break;
-
-        case BlockID.SNOW:
+        } else if (event.getBlock().getType() == Material.FROSTED_ICE) {
+            if (wcfg.useRegions && !StateFlag.test(WorldGuard.getInstance().getPlatform().getRegionContainer().createQuery()
+                    .queryState(BukkitAdapter.adapt(event.getBlock().getLocation()), (RegionAssociable) null, Flags.FROSTED_ICE_MELT))) {
+                event.setCancelled(true);
+                return;
+            }
+        } else if (event.getBlock().getType() == Material.SNOW) {
             if (wcfg.disableSnowMelting) {
                 event.setCancelled(true);
                 return;
             }
 
-            if (wcfg.useRegions && !plugin.getGlobalRegionManager().allows(
-                    DefaultFlag.SNOW_MELT, event.getBlock().getLocation())) {
+            if (wcfg.useRegions && !StateFlag.test(WorldGuard.getInstance().getPlatform().getRegionContainer().createQuery()
+                    .queryState(BukkitAdapter.adapt(event.getBlock().getLocation()), (RegionAssociable) null, Flags.SNOW_MELT))) {
                 event.setCancelled(true);
                 return;
             }
-            break;
-
-        case BlockID.SOIL:
+        } else if (event.getBlock().getType() == Material.FARMLAND) {
             if (wcfg.disableSoilDehydration) {
                 event.setCancelled(true);
                 return;
             }
-            if (wcfg.useRegions && !plugin.getGlobalRegionManager().allows(
-                    DefaultFlag.SOIL_DRY, event.getBlock().getLocation())) {
+            if (wcfg.useRegions && !StateFlag.test(WorldGuard.getInstance().getPlatform().getRegionContainer().createQuery()
+                    .queryState(BukkitAdapter.adapt(event.getBlock().getLocation()), (RegionAssociable) null, Flags.SOIL_DRY))) {
                 event.setCancelled(true);
                 return;
             }
-            break;
+        }
+    }
+
+    @EventHandler(ignoreCancelled = true)
+    public void onBlockExplode(BlockExplodeEvent event) {
+        ConfigurationManager cfg = WorldGuard.getInstance().getPlatform().getGlobalStateManager();
+
+        if (cfg.activityHaltToggle) {
+            event.setCancelled(true);
+            return;
         }
 
+        WorldConfiguration wcfg = getWorldConfig(event.getBlock().getWorld());
+        if (wcfg.blockOtherExplosions) {
+            event.setCancelled(true);
+        }
     }
 
 }

worldguard-bukkit/src/main/java/com/sk89q/worldguard/bukkit/listener/WorldGuardCommandBookListener.java

@@ -21,8 +21,10 @@ package com.sk89q.worldguard.bukkit.listener;
 
 import com.sk89q.commandbook.InfoComponent;
 import com.sk89q.worldguard.LocalPlayer;
+import com.sk89q.worldguard.WorldGuard;
 import com.sk89q.worldguard.bukkit.WorldGuardPlugin;
 import com.sk89q.worldguard.protection.ApplicableRegionSet;
+import com.sk89q.worldguard.protection.flags.Flags;
 import com.sk89q.worldguard.protection.regions.ProtectedRegion;
 import org.bukkit.entity.Player;
 import org.bukkit.event.EventHandler;
@@ -43,8 +45,9 @@ public class WorldGuardCommandBookListener implements Listener {
         if (event.getPlayer() instanceof Player) {
             Player player = (Player) event.getPlayer();
             LocalPlayer localPlayer = plugin.wrapPlayer(player);
-            if (plugin.getGlobalStateManager().get(player.getWorld()).useRegions) {
-                ApplicableRegionSet regions = plugin.getRegionContainer().createQuery().getApplicableRegions(player.getLocation());
+            if (WorldGuard.getInstance().getPlatform().getGlobalStateManager().get(localPlayer.getWorld()).useRegions) {
+                ApplicableRegionSet regions =
+                        WorldGuard.getInstance().getPlatform().getRegionContainer().createQuery().getApplicableRegions(localPlayer.getLocation());
                 
                 // Current regions
                 StringBuilder regionStr = new StringBuilder();
@@ -69,7 +72,7 @@ public class WorldGuardCommandBookListener implements Listener {
                 if (regions.size() > 0) {
                     event.addWhoisInformation("Current Regions", regionStr);
                 }
-                event.addWhoisInformation("Can build", regions.canBuild(localPlayer));
+                event.addWhoisInformation("Can build", regions.testState(localPlayer, Flags.BUILD));
             }
         }
     }

worldguard-bukkit/src/main/java/com/sk89q/worldguard/bukkit/listener/WorldGuardEntityListener.java

@@ -19,24 +19,61 @@
 
 package com.sk89q.worldguard.bukkit.listener;
 
-import com.sk89q.worldedit.blocks.BlockID;
+import com.sk89q.worldedit.bukkit.BukkitAdapter;
 import com.sk89q.worldguard.LocalPlayer;
-import com.sk89q.worldguard.bukkit.*;
+import com.sk89q.worldguard.WorldGuard;
+import com.sk89q.worldguard.bukkit.BukkitWorldConfiguration;
+import com.sk89q.worldguard.bukkit.WorldGuardPlugin;
 import com.sk89q.worldguard.bukkit.util.Entities;
+import com.sk89q.worldguard.config.ConfigurationManager;
+import com.sk89q.worldguard.config.WorldConfiguration;
 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.association.RegionAssociable;
+import com.sk89q.worldguard.protection.flags.Flags;
+import com.sk89q.worldguard.protection.flags.StateFlag;
+import com.sk89q.worldguard.protection.regions.RegionQuery;
 import org.bukkit.Location;
+import org.bukkit.Material;
 import org.bukkit.World;
 import org.bukkit.block.Block;
-import org.bukkit.entity.*;
+import org.bukkit.entity.ArmorStand;
+import org.bukkit.entity.Creeper;
+import org.bukkit.entity.EnderCrystal;
+import org.bukkit.entity.EnderDragon;
+import org.bukkit.entity.Enderman;
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.EntityType;
+import org.bukkit.entity.Fireball;
+import org.bukkit.entity.ItemFrame;
+import org.bukkit.entity.LivingEntity;
+import org.bukkit.entity.Player;
+import org.bukkit.entity.Projectile;
+import org.bukkit.entity.TNTPrimed;
+import org.bukkit.entity.Tameable;
+import org.bukkit.entity.Wither;
+import org.bukkit.entity.WitherSkull;
+import org.bukkit.entity.Wolf;
 import org.bukkit.entity.minecart.ExplosiveMinecart;
 import org.bukkit.event.EventHandler;
 import org.bukkit.event.EventPriority;
 import org.bukkit.event.Listener;
-import org.bukkit.event.entity.*;
+import org.bukkit.event.entity.CreatureSpawnEvent;
 import org.bukkit.event.entity.CreatureSpawnEvent.SpawnReason;
+import org.bukkit.event.entity.CreeperPowerEvent;
+import org.bukkit.event.entity.EntityBreakDoorEvent;
+import org.bukkit.event.entity.EntityChangeBlockEvent;
+import org.bukkit.event.entity.EntityCreatePortalEvent;
+import org.bukkit.event.entity.EntityDamageByBlockEvent;
+import org.bukkit.event.entity.EntityDamageByEntityEvent;
+import org.bukkit.event.entity.EntityDamageEvent;
 import org.bukkit.event.entity.EntityDamageEvent.DamageCause;
+import org.bukkit.event.entity.EntityDeathEvent;
+import org.bukkit.event.entity.EntityExplodeEvent;
+import org.bukkit.event.entity.EntityInteractEvent;
+import org.bukkit.event.entity.EntityRegainHealthEvent;
+import org.bukkit.event.entity.ExplosionPrimeEvent;
+import org.bukkit.event.entity.PigZapEvent;
+import org.bukkit.event.entity.PlayerDeathEvent;
 import org.bukkit.inventory.ItemStack;
 import org.bukkit.projectiles.ProjectileSource;
 
@@ -65,6 +102,9 @@ public class WorldGuardEntityListener implements Listener {
      */
     public void registerEvents() {
         plugin.getServer().getPluginManager().registerEvents(this, plugin);
+        if (!EntityCreatePortalEvent.class.isAnnotationPresent(Deprecated.class)) {
+            plugin.getServer().getPluginManager().registerEvents(new UselessIn114Listener(), plugin);
+        }
     }
 
     @EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
@@ -72,10 +112,10 @@ public class WorldGuardEntityListener implements Listener {
         Entity entity = event.getEntity();
         Block block = event.getBlock();
 
-        ConfigurationManager cfg = plugin.getGlobalStateManager();
-        WorldConfiguration wcfg = cfg.get(entity.getWorld());
+        ConfigurationManager cfg = WorldGuard.getInstance().getPlatform().getGlobalStateManager();
+        WorldConfiguration wcfg = cfg.get(BukkitAdapter.adapt(entity.getWorld()));
 
-        if (block.getTypeId() == BlockID.SOIL) {
+        if (block.getType() == Material.FARMLAND) {
             if (/* entity instanceof Creature && // catch for any entity (not thrown for players) */
                 wcfg.disableCreatureCropTrampling) {
                 event.setCancelled(true);
@@ -85,7 +125,8 @@ public class WorldGuardEntityListener implements Listener {
 
     @EventHandler(priority = EventPriority.HIGH)
     public void onEntityDeath(EntityDeathEvent event) {
-        WorldConfiguration wcfg = plugin.getGlobalStateManager().get(event.getEntity().getWorld());
+        WorldConfiguration wcfg =
+                WorldGuard.getInstance().getPlatform().getGlobalStateManager().get(BukkitAdapter.adapt(event.getEntity().getWorld()));
 
         if (event instanceof PlayerDeathEvent && wcfg.disableDeathMessages) {
             ((PlayerDeathEvent) event).setDeathMessage("");
@@ -96,8 +137,8 @@ public class WorldGuardEntityListener implements Listener {
         Entity defender = event.getEntity();
         DamageCause type = event.getCause();
 
-        ConfigurationManager cfg = plugin.getGlobalStateManager();
-        WorldConfiguration wcfg = cfg.get(defender.getWorld());
+        ConfigurationManager cfg = WorldGuard.getInstance().getPlatform().getGlobalStateManager();
+        WorldConfiguration wcfg = cfg.get(BukkitAdapter.adapt(defender.getWorld()));
 
         if (defender instanceof Wolf && ((Wolf) defender).isTamed()) {
             if (wcfg.antiWolfDumbness && !(type == DamageCause.VOID)) {
@@ -106,6 +147,7 @@ public class WorldGuardEntityListener implements Listener {
             }
         } else if (defender instanceof Player) {
             Player player = (Player) defender;
+            LocalPlayer localPlayer = WorldGuardPlugin.inst().wrapPlayer(player);
 
             if (wcfg.disableLavaDamage && type == DamageCause.LAVA) {
                 event.setCancelled(true);
@@ -119,7 +161,7 @@ public class WorldGuardEntityListener implements Listener {
             }
 
             if (wcfg.teleportOnVoid && type == DamageCause.VOID) {
-                BukkitUtil.findFreePosition(player);
+                localPlayer.findFreePosition();
                 event.setCancelled(true);
                 return;
             }
@@ -132,7 +174,8 @@ public class WorldGuardEntityListener implements Listener {
             if (type == DamageCause.BLOCK_EXPLOSION
                     && (wcfg.disableExplosionDamage || wcfg.blockOtherExplosions
                             || (wcfg.explosionFlagCancellation
-                                && !plugin.getGlobalRegionManager().allows(DefaultFlag.OTHER_EXPLOSION, player.getLocation())))) {
+                                && !StateFlag.test(WorldGuard.getInstance().getPlatform().getRegionContainer().createQuery()
+                    .queryState(localPlayer.getLocation(), (RegionAssociable) null, Flags.OTHER_EXPLOSION))))) {
                 event.setCancelled(true);
                 return;
             }
@@ -143,9 +186,11 @@ public class WorldGuardEntityListener implements Listener {
             if (type == DamageCause.BLOCK_EXPLOSION
                     && (wcfg.blockOtherExplosions
                             || (wcfg.explosionFlagCancellation
-                                && !plugin.getGlobalRegionManager().allows(DefaultFlag.OTHER_EXPLOSION, defender.getLocation())))) {
+                                && !StateFlag.test(WorldGuard.getInstance().getPlatform().getRegionContainer().createQuery()
+                    .queryState(BukkitAdapter.adapt(defender.getLocation()), (RegionAssociable) null, Flags.OTHER_EXPLOSION))))) {
                 event.setCancelled(true);
                 return;
+
             }
         }
     }
@@ -160,20 +205,37 @@ public class WorldGuardEntityListener implements Listener {
         Entity attacker = event.getDamager();
         Entity defender = event.getEntity();
 
+        WorldConfiguration wcfg =
+                WorldGuard.getInstance().getPlatform().getGlobalStateManager().get(BukkitAdapter.adapt(defender.getWorld()));
+
         if (defender instanceof ItemFrame) {
             if (checkItemFrameProtection(attacker, (ItemFrame) defender)) {
                 event.setCancelled(true);
                 return;
             }
+        } else if (defender instanceof ArmorStand && !(attacker instanceof Player)) {
+            if (wcfg.blockEntityArmorStandDestroy) {
+                event.setCancelled(true);
+                return;
+            }
+        }
+
+        if (attacker instanceof EnderCrystal) {
+            // this isn't handled elsewhere because ender crystal explosions don't carry a player cause
+            // in the same way that creepers or tnt can
+            if (wcfg.useRegions && wcfg.explosionFlagCancellation) {
+                if (!WorldGuard.getInstance().getPlatform().getRegionContainer().createQuery().getApplicableRegions(BukkitAdapter.adapt(defender.getLocation()))
+                        .testState(null, Flags.OTHER_EXPLOSION)) {
+                    event.setCancelled(true);
+                    return;
+                }
+            }
         }
 
         if (defender instanceof Player) {
             Player player = (Player) defender;
             LocalPlayer localPlayer = plugin.wrapPlayer(player);
 
-            ConfigurationManager cfg = plugin.getGlobalStateManager();
-            WorldConfiguration wcfg = cfg.get(player.getWorld());
-
             if (wcfg.disableLightningDamage && event.getCause() == DamageCause.LIGHTNING) {
                 event.setCancelled(true);
                 return;
@@ -209,16 +271,15 @@ public class WorldGuardEntityListener implements Listener {
                     }
 
                     if (wcfg.useRegions) {
-                        RegionManager mgr = plugin.getGlobalRegionManager().get(player.getWorld());
-                        ApplicableRegionSet set = plugin.getRegionContainer().createQuery().getApplicableRegions(defender.getLocation());
+                        ApplicableRegionSet set = WorldGuard.getInstance().getPlatform().getRegionContainer().createQuery().getApplicableRegions(localPlayer.getLocation());
 
-                        if (!set.allows(DefaultFlag.MOB_DAMAGE, localPlayer) && !(attacker instanceof Tameable)) {
+                        if (!set.testState(localPlayer, Flags.MOB_DAMAGE) && !(attacker instanceof Tameable)) {
                             event.setCancelled(true);
                             return;
                         }
 
                         if (attacker instanceof Creeper) {
-                            if (!set.allows(DefaultFlag.CREEPER_EXPLOSION, localPlayer) && wcfg.explosionFlagCancellation) {
+                            if (!set.testState(localPlayer, Flags.CREEPER_EXPLOSION) && wcfg.explosionFlagCancellation) {
                                 event.setCancelled(true);
                                 return;
                             }
@@ -239,21 +300,21 @@ public class WorldGuardEntityListener implements Listener {
             return;
         }
 
+        ConfigurationManager cfg = WorldGuard.getInstance().getPlatform().getGlobalStateManager();
+        WorldConfiguration wcfg = cfg.get(BukkitAdapter.adapt(defender.getWorld()));
         if (defender instanceof Player) {
             Player player = (Player) defender;
             LocalPlayer localPlayer = plugin.wrapPlayer(player);
 
-            ConfigurationManager cfg = plugin.getGlobalStateManager();
-            WorldConfiguration wcfg = cfg.get(player.getWorld());
 
             // Check Mob
-            if (attacker != null && !(attacker instanceof Player)) {
+            if (!(attacker instanceof Player)) {
                 if (wcfg.disableMobDamage) {
                     event.setCancelled(true);
                     return;
                 }
                 if (wcfg.useRegions) {
-                    if (!plugin.getRegionContainer().createQuery().getApplicableRegions(defender.getLocation()).allows(DefaultFlag.MOB_DAMAGE, localPlayer)) {
+                    if (!WorldGuard.getInstance().getPlatform().getRegionContainer().createQuery().getApplicableRegions(localPlayer.getLocation()).testState(localPlayer, Flags.MOB_DAMAGE)) {
                         event.setCancelled(true);
                         return;
                     }
@@ -272,8 +333,8 @@ public class WorldGuardEntityListener implements Listener {
                         }
                     }
                     if (wcfg.useRegions) {
-                        RegionQuery query = plugin.getRegionContainer().createQuery();
-                        if (!query.testState(defender.getLocation(), (Player) defender, DefaultFlag.GHAST_FIREBALL) && wcfg.explosionFlagCancellation) {
+                        RegionQuery query = WorldGuard.getInstance().getPlatform().getRegionContainer().createQuery();
+                        if (!query.testState(localPlayer.getLocation(), localPlayer, Flags.GHAST_FIREBALL) && wcfg.explosionFlagCancellation) {
                             event.setCancelled(true);
                             return;
                         }
@@ -286,6 +347,10 @@ public class WorldGuardEntityListener implements Listener {
                 event.setCancelled(true);
                 return;
             }
+        } else if (defender instanceof ArmorStand && Entities.isNonPlayerCreature(attacker)) {
+            if (wcfg.blockEntityArmorStandDestroy) {
+                event.setCancelled(true);
+            }
         }
 
     }
@@ -304,8 +369,8 @@ public class WorldGuardEntityListener implements Listener {
         Entity defender = event.getEntity();
         DamageCause type = event.getCause();
 
-        ConfigurationManager cfg = plugin.getGlobalStateManager();
-        WorldConfiguration wcfg = cfg.get(defender.getWorld());
+        ConfigurationManager cfg = WorldGuard.getInstance().getPlatform().getGlobalStateManager();
+        WorldConfiguration wcfg = cfg.get(BukkitAdapter.adapt(defender.getWorld()));
 
         if (defender instanceof Wolf && ((Wolf) defender).isTamed()) {
             if (wcfg.antiWolfDumbness) {
@@ -314,6 +379,7 @@ public class WorldGuardEntityListener implements Listener {
             }
         } else if (defender instanceof Player) {
             Player player = (Player) defender;
+            LocalPlayer localPlayer = WorldGuardPlugin.inst().wrapPlayer(player);
 
             if (type == DamageCause.WITHER) {
                 // wither boss DoT tick
@@ -323,16 +389,16 @@ public class WorldGuardEntityListener implements Listener {
                 }
 
                 if (wcfg.useRegions) {
-                    ApplicableRegionSet set = plugin.getRegionContainer().createQuery().getApplicableRegions(defender.getLocation());
+                    ApplicableRegionSet set = WorldGuard.getInstance().getPlatform().getRegionContainer().createQuery().getApplicableRegions(localPlayer.getLocation());
 
-                    if (!set.allows(DefaultFlag.MOB_DAMAGE, plugin.wrapPlayer(player))) {
+                    if (!set.testState(plugin.wrapPlayer(player), Flags.MOB_DAMAGE)) {
                         event.setCancelled(true);
                         return;
                     }
                 }
             }
 
-            if (type == DamageCause.DROWNING && cfg.hasAmphibiousMode(player)) {
+            if (type == DamageCause.DROWNING && cfg.hasAmphibiousMode(localPlayer)) {
                 player.setRemainingAir(player.getMaximumAir());
                 event.setCancelled(true);
                 return;
@@ -342,8 +408,8 @@ public class WorldGuardEntityListener implements Listener {
 
             if (type == DamageCause.DROWNING && wcfg.pumpkinScuba
                     && helmet != null
-                    && (helmet.getTypeId() == BlockID.PUMPKIN
-                    || helmet.getTypeId() == BlockID.JACKOLANTERN)) {
+                    && (helmet.getType() == Material.CARVED_PUMPKIN
+                    || helmet.getType() == Material.JACK_O_LANTERN)) {
                 player.setRemainingAir(player.getMaximumAir());
                 event.setCancelled(true);
                 return;
@@ -367,7 +433,7 @@ public class WorldGuardEntityListener implements Listener {
             }
 
             if (wcfg.teleportOnSuffocation && type == DamageCause.SUFFOCATION) {
-                BukkitUtil.findFreePosition(player);
+                localPlayer.findFreePosition();
                 event.setCancelled(true);
                 return;
             }
@@ -384,16 +450,14 @@ public class WorldGuardEntityListener implements Listener {
      */
     @EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
     public void onEntityExplode(EntityExplodeEvent event) {
-        ConfigurationManager cfg = plugin.getGlobalStateManager();
+        ConfigurationManager cfg = WorldGuard.getInstance().getPlatform().getGlobalStateManager();
         Location l = event.getLocation();
         World world = l.getWorld();
-        WorldConfiguration wcfg = cfg.get(world);
+        BukkitWorldConfiguration wcfg = (BukkitWorldConfiguration) cfg.get(BukkitAdapter.adapt(world));
         Entity ent = event.getEntity();
 
         if (cfg.activityHaltToggle) {
-            if (ent != null) {
-                ent.remove();
-            }
+            ent.remove();
             event.setCancelled(true);
             return;
         }
@@ -443,10 +507,8 @@ public class WorldGuardEntityListener implements Listener {
             }
             // allow wither skull blocking since there is no dedicated flag atm
             if (wcfg.useRegions) {
-                RegionManager mgr = plugin.getGlobalRegionManager().get(world);
-
                 for (Block block : event.blockList()) {
-                    if (!plugin.getRegionContainer().createQuery().getApplicableRegions(block.getLocation()).allows(DefaultFlag.GHAST_FIREBALL)) {
+                    if (!WorldGuard.getInstance().getPlatform().getRegionContainer().createQuery().getApplicableRegions(BukkitAdapter.adapt(block.getLocation())).testState(null, Flags.GHAST_FIREBALL)) {
                         event.blockList().clear();
                         if (wcfg.explosionFlagCancellation) event.setCancelled(true);
                         return;
@@ -462,6 +524,16 @@ public class WorldGuardEntityListener implements Listener {
                 event.blockList().clear();
                 return;
             }
+            if (wcfg.useRegions) {
+                for (Block block : event.blockList()) {
+                    if (!StateFlag.test(WorldGuard.getInstance().getPlatform().getRegionContainer().createQuery().queryState(BukkitAdapter.adapt(block.getLocation()),
+                            (RegionAssociable) null, Flags.WITHER_DAMAGE))) {
+                        event.blockList().clear();
+                        event.setCancelled(true);
+                        return;
+                    }
+                }
+            }
         } else {
             // unhandled entity
             if (wcfg.blockOtherExplosions) {
@@ -469,9 +541,8 @@ public class WorldGuardEntityListener implements Listener {
                 return;
             }
             if (wcfg.useRegions) {
-                RegionManager mgr = plugin.getGlobalRegionManager().get(world);
                 for (Block block : event.blockList()) {
-                    if (!plugin.getRegionContainer().createQuery().getApplicableRegions(block.getLocation()).allows(DefaultFlag.OTHER_EXPLOSION)) {
+                    if (!WorldGuard.getInstance().getPlatform().getRegionContainer().createQuery().getApplicableRegions(BukkitAdapter.adapt(block.getLocation())).testState(null, Flags.OTHER_EXPLOSION)) {
                         event.blockList().clear();
                         if (wcfg.explosionFlagCancellation) event.setCancelled(true);
                         return;
@@ -483,7 +554,7 @@ public class WorldGuardEntityListener implements Listener {
 
         if (wcfg.signChestProtection) {
             for (Block block : event.blockList()) {
-                if (wcfg.isChestProtected(block)) {
+                if (wcfg.isChestProtected(BukkitAdapter.adapt(block.getLocation()))) {
                     event.blockList().clear();
                     return;
                 }
@@ -497,8 +568,8 @@ public class WorldGuardEntityListener implements Listener {
      */
     @EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
     public void onExplosionPrime(ExplosionPrimeEvent event) {
-        ConfigurationManager cfg = plugin.getGlobalStateManager();
-        WorldConfiguration wcfg = cfg.get(event.getEntity().getWorld());
+        ConfigurationManager cfg = WorldGuard.getInstance().getPlatform().getGlobalStateManager();
+        WorldConfiguration wcfg = cfg.get(BukkitAdapter.adapt(event.getEntity().getWorld()));
         Entity ent = event.getEntity();
 
         if (cfg.activityHaltToggle) {
@@ -538,14 +609,14 @@ public class WorldGuardEntityListener implements Listener {
 
     @EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
     public void onCreatureSpawn(CreatureSpawnEvent event) {
-        ConfigurationManager cfg = plugin.getGlobalStateManager();
+        ConfigurationManager cfg = WorldGuard.getInstance().getPlatform().getGlobalStateManager();
 
         if (cfg.activityHaltToggle) {
             event.setCancelled(true);
             return;
         }
 
-        WorldConfiguration wcfg = cfg.get(event.getEntity().getWorld());
+        WorldConfiguration wcfg = cfg.get(BukkitAdapter.adapt(event.getEntity().getWorld()));
 
         // allow spawning of creatures from plugins
         if (!wcfg.blockPluginSpawning && event.getSpawnReason() == CreatureSpawnEvent.SpawnReason.CUSTOM) {
@@ -565,7 +636,9 @@ public class WorldGuardEntityListener implements Listener {
 
         EntityType entityType = event.getEntityType();
 
-        if (wcfg.blockCreatureSpawn.contains(entityType)) {
+        com.sk89q.worldedit.world.entity.EntityType weEntityType = BukkitAdapter.adapt(entityType);
+
+        if (weEntityType != null && wcfg.blockCreatureSpawn.contains(weEntityType)) {
             event.setCancelled(true);
             return;
         }
@@ -573,15 +646,16 @@ public class WorldGuardEntityListener implements Listener {
         Location eventLoc = event.getLocation();
 
         if (wcfg.useRegions && cfg.useRegionsCreatureSpawnEvent) {
-            ApplicableRegionSet set = plugin.getRegionContainer().createQuery().getApplicableRegions(eventLoc);
+            ApplicableRegionSet set =
+                    WorldGuard.getInstance().getPlatform().getRegionContainer().createQuery().getApplicableRegions(BukkitAdapter.adapt(eventLoc));
 
-            if (!set.allows(DefaultFlag.MOB_SPAWNING)) {
+            if (!set.testState(null, Flags.MOB_SPAWNING)) {
                 event.setCancelled(true);
                 return;
             }
 
-            Set<EntityType> entityTypes = set.getFlag(DefaultFlag.DENY_SPAWN);
-            if (entityTypes != null && entityTypes.contains(entityType)) {
+            Set<com.sk89q.worldedit.world.entity.EntityType> entityTypes = set.queryValue(null, Flags.DENY_SPAWN);
+            if (entityTypes != null && weEntityType != null && entityTypes.contains(weEntityType)) {
                 event.setCancelled(true);
                 return;
             }
@@ -595,22 +669,24 @@ public class WorldGuardEntityListener implements Listener {
         }
     }
 
-    @EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
-    public void onCreatePortal(EntityCreatePortalEvent event) {
-        ConfigurationManager cfg = plugin.getGlobalStateManager();
-        WorldConfiguration wcfg = cfg.get(event.getEntity().getWorld());
+    private static class UselessIn114Listener implements Listener {
+        @EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
+        public void onCreatePortal(EntityCreatePortalEvent event) {
+            ConfigurationManager cfg = WorldGuard.getInstance().getPlatform().getGlobalStateManager();
+            WorldConfiguration wcfg = cfg.get(BukkitAdapter.adapt(event.getEntity().getWorld()));
 
-        switch (event.getEntityType()) {
-            case ENDER_DRAGON:
-                if (wcfg.blockEnderDragonPortalCreation) event.setCancelled(true);
-                break;
+            switch (event.getEntityType()) {
+                case ENDER_DRAGON:
+                    if (wcfg.blockEnderDragonPortalCreation) event.setCancelled(true);
+                    break;
+            }
         }
     }
 
     @EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
     public void onPigZap(PigZapEvent event) {
-        ConfigurationManager cfg = plugin.getGlobalStateManager();
-        WorldConfiguration wcfg = cfg.get(event.getEntity().getWorld());
+        ConfigurationManager cfg = WorldGuard.getInstance().getPlatform().getGlobalStateManager();
+        WorldConfiguration wcfg = cfg.get(BukkitAdapter.adapt(event.getEntity().getWorld()));
 
         if (wcfg.disablePigZap) {
             event.setCancelled(true);
@@ -619,8 +695,8 @@ public class WorldGuardEntityListener implements Listener {
 
     @EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
     public void onCreeperPower(CreeperPowerEvent event) {
-        ConfigurationManager cfg = plugin.getGlobalStateManager();
-        WorldConfiguration wcfg = cfg.get(event.getEntity().getWorld());
+        ConfigurationManager cfg = WorldGuard.getInstance().getPlatform().getGlobalStateManager();
+        WorldConfiguration wcfg = cfg.get(BukkitAdapter.adapt(event.getEntity().getWorld()));
 
         if (wcfg.disableCreeperPower) {
             event.setCancelled(true);
@@ -633,8 +709,8 @@ public class WorldGuardEntityListener implements Listener {
         Entity ent = event.getEntity();
         World world = ent.getWorld();
 
-        ConfigurationManager cfg = plugin.getGlobalStateManager();
-        WorldConfiguration wcfg = cfg.get(world);
+        ConfigurationManager cfg = WorldGuard.getInstance().getPlatform().getGlobalStateManager();
+        WorldConfiguration wcfg = cfg.get(BukkitAdapter.adapt(world));
 
         if (wcfg.disableHealthRegain) {
             event.setCancelled(true);
@@ -653,25 +729,24 @@ public class WorldGuardEntityListener implements Listener {
         Block block = event.getBlock();
         Location location = block.getLocation();
 
-        ConfigurationManager cfg = plugin.getGlobalStateManager();
-        WorldConfiguration wcfg = cfg.get(ent.getWorld());
+        ConfigurationManager cfg = WorldGuard.getInstance().getPlatform().getGlobalStateManager();
+        WorldConfiguration wcfg = cfg.get(BukkitAdapter.adapt(ent.getWorld()));
         if (ent instanceof Enderman) {
             if (wcfg.disableEndermanGriefing) {
                 event.setCancelled(true);
                 return;
             }
-
-            if (wcfg.useRegions) {
-                if (!plugin.getGlobalRegionManager().allows(DefaultFlag.ENDER_BUILD, location)) {
-                    event.setCancelled(true);
-                    return;
-                }
-            }
         } else if (ent.getType() == EntityType.WITHER) {
             if (wcfg.blockWitherBlockDamage || wcfg.blockWitherExplosions) {
                 event.setCancelled(true);
                 return;
             }
+            if (wcfg.useRegions) {
+                if (!StateFlag.test(WorldGuard.getInstance().getPlatform().getRegionContainer().createQuery().queryState(BukkitAdapter.adapt(location), (RegionAssociable) null, Flags.WITHER_DAMAGE))) {
+                    event.setCancelled(true);
+                    return;
+                }
+            }
         } else if (/*ent instanceof Zombie && */event instanceof EntityBreakDoorEvent) {
             if (wcfg.blockZombieDoorDestruction) {
                 event.setCancelled(true);
@@ -689,14 +764,12 @@ public class WorldGuardEntityListener implements Listener {
      */
     private boolean checkItemFrameProtection(Entity attacker, ItemFrame defender) {
         World world = attacker.getWorld();
-        ConfigurationManager cfg = plugin.getGlobalStateManager();
-        WorldConfiguration wcfg = cfg.get(world);
+        ConfigurationManager cfg = WorldGuard.getInstance().getPlatform().getGlobalStateManager();
+        WorldConfiguration wcfg = cfg.get(BukkitAdapter.adapt(world));
         if (wcfg.useRegions) {
-        // bukkit throws this event when a player attempts to remove an item from a frame
-            RegionManager mgr = plugin.getGlobalRegionManager().get(world);
+            // bukkit throws this event when a player attempts to remove an item from a frame
             if (!(attacker instanceof Player)) {
-                if (!plugin.getGlobalRegionManager().allows(
-                        DefaultFlag.ENTITY_ITEM_FRAME_DESTROY, defender.getLocation())) {
+                if (!StateFlag.test(WorldGuard.getInstance().getPlatform().getRegionContainer().createQuery().queryState(BukkitAdapter.adapt(defender.getLocation()), (RegionAssociable) null, Flags.ENTITY_ITEM_FRAME_DESTROY))) {
                     return true;
                 }
             }

worldguard-bukkit/src/main/java/com/sk89q/worldguard/bukkit/listener/WorldGuardHangingListener.java

@@ -19,10 +19,14 @@
 
 package com.sk89q.worldguard.bukkit.listener;
 
-import com.sk89q.worldguard.bukkit.ConfigurationManager;
-import com.sk89q.worldguard.bukkit.WorldConfiguration;
+import com.sk89q.worldedit.bukkit.BukkitAdapter;
+import com.sk89q.worldguard.WorldGuard;
 import com.sk89q.worldguard.bukkit.WorldGuardPlugin;
-import com.sk89q.worldguard.protection.flags.DefaultFlag;
+import com.sk89q.worldguard.config.ConfigurationManager;
+import com.sk89q.worldguard.config.WorldConfiguration;
+import com.sk89q.worldguard.protection.association.RegionAssociable;
+import com.sk89q.worldguard.protection.flags.Flags;
+import com.sk89q.worldguard.protection.flags.StateFlag;
 import org.bukkit.World;
 import org.bukkit.entity.Creeper;
 import org.bukkit.entity.Entity;
@@ -69,8 +73,8 @@ public class WorldGuardHangingListener implements Listener {
     public void onHangingBreak(HangingBreakEvent event) {
         Hanging hanging = event.getEntity();
         World world = hanging.getWorld();
-        ConfigurationManager cfg = plugin.getGlobalStateManager();
-        WorldConfiguration wcfg = cfg.get(world);
+        ConfigurationManager cfg = WorldGuard.getInstance().getPlatform().getGlobalStateManager();
+        WorldConfiguration wcfg = cfg.get(BukkitAdapter.adapt(world));
 
         if (event instanceof HangingBreakByEntityEvent) {
             HangingBreakByEntityEvent entityEvent = (HangingBreakByEntityEvent) event;
@@ -87,7 +91,7 @@ public class WorldGuardHangingListener implements Listener {
                         event.setCancelled(true);
                         return;
                     }
-                    if (wcfg.useRegions && !plugin.getGlobalRegionManager().allows(DefaultFlag.CREEPER_EXPLOSION, hanging.getLocation())) {
+                    if (wcfg.useRegions && !StateFlag.test(WorldGuard.getInstance().getPlatform().getRegionContainer().createQuery().queryState(BukkitAdapter.adapt(hanging.getLocation()), (RegionAssociable) null, Flags.CREEPER_EXPLOSION))) {
                         event.setCancelled(true);
                         return;
                     }
@@ -98,12 +102,12 @@ public class WorldGuardHangingListener implements Listener {
                 if (hanging instanceof Painting
                         && (wcfg.blockEntityPaintingDestroy
                         || (wcfg.useRegions
-                        && !plugin.getGlobalRegionManager().allows(DefaultFlag.ENTITY_PAINTING_DESTROY, hanging.getLocation())))) {
+                        && !StateFlag.test(WorldGuard.getInstance().getPlatform().getRegionContainer().createQuery().queryState(BukkitAdapter.adapt(hanging.getLocation()), (RegionAssociable) null, Flags.ENTITY_PAINTING_DESTROY))))) {
                     event.setCancelled(true);
                 } else if (hanging instanceof ItemFrame
                         && (wcfg.blockEntityItemFrameDestroy
                         || (wcfg.useRegions
-                        && !plugin.getGlobalRegionManager().allows(DefaultFlag.ENTITY_ITEM_FRAME_DESTROY, hanging.getLocation())))) {
+                        && !StateFlag.test(WorldGuard.getInstance().getPlatform().getRegionContainer().createQuery().queryState(BukkitAdapter.adapt(hanging.getLocation()), (RegionAssociable) null, Flags.ENTITY_ITEM_FRAME_DESTROY))))) {
                     event.setCancelled(true);
                 }
             }

worldguard-bukkit/src/main/java/com/sk89q/worldguard/bukkit/listener/WorldGuardPlayerListener.java

@@ -19,31 +19,36 @@
 
 package com.sk89q.worldguard.bukkit.listener;
 
-import com.sk89q.worldedit.blocks.BlockID;
+import com.sk89q.worldedit.bukkit.BukkitAdapter;
+import com.sk89q.worldedit.world.gamemode.GameMode;
 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.WorldGuard;
 import com.sk89q.worldguard.bukkit.WorldGuardPlugin;
 import com.sk89q.worldguard.bukkit.event.player.ProcessPlayerEvent;
 import com.sk89q.worldguard.bukkit.util.Events;
+import com.sk89q.worldguard.bukkit.util.Materials;
+import com.sk89q.worldguard.config.ConfigurationManager;
+import com.sk89q.worldguard.config.WorldConfiguration;
 import com.sk89q.worldguard.protection.ApplicableRegionSet;
-import com.sk89q.worldguard.protection.flags.DefaultFlag;
+import com.sk89q.worldguard.protection.flags.Flags;
 import com.sk89q.worldguard.protection.managers.RegionManager;
 import com.sk89q.worldguard.protection.regions.ProtectedCuboidRegion;
 import com.sk89q.worldguard.protection.regions.ProtectedRegion;
+import com.sk89q.worldguard.protection.regions.RegionQuery;
 import com.sk89q.worldguard.session.MoveType;
 import com.sk89q.worldguard.session.Session;
 import com.sk89q.worldguard.session.handler.GameModeFlag;
+import com.sk89q.worldguard.util.Entities;
 import com.sk89q.worldguard.util.command.CommandFilter;
 import org.bukkit.ChatColor;
-import org.bukkit.GameMode;
 import org.bukkit.Location;
+import org.bukkit.Material;
 import org.bukkit.TravelAgent;
 import org.bukkit.World;
 import org.bukkit.block.Block;
 import org.bukkit.entity.Entity;
 import org.bukkit.entity.Player;
+import org.bukkit.event.Event;
 import org.bukkit.event.EventHandler;
 import org.bukkit.event.EventPriority;
 import org.bukkit.event.Listener;
@@ -62,19 +67,20 @@ import org.bukkit.event.player.PlayerTeleportEvent.TeleportCause;
 import org.bukkit.inventory.ItemStack;
 import org.bukkit.plugin.PluginManager;
 
-import javax.annotation.Nullable;
 import java.util.Iterator;
 import java.util.Set;
 import java.util.logging.Logger;
 import java.util.regex.Pattern;
 
+import javax.annotation.Nullable;
+
 /**
  * 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 static final Pattern opPattern = Pattern.compile("^/(?:bukkit:)?op(?:\\s.*)?$", Pattern.CASE_INSENSITIVE);
+    private static final Pattern opPattern = Pattern.compile("^/(?:minecraft:)?(?:bukkit:)?(?:de)?op(?:\\s.*)?$", Pattern.CASE_INSENSITIVE);
     private WorldGuardPlugin plugin;
 
     /**
@@ -97,13 +103,15 @@ public class WorldGuardPlayerListener implements Listener {
     @EventHandler
     public void onPlayerGameModeChange(PlayerGameModeChangeEvent event) {
         Player player = event.getPlayer();
-        WorldConfiguration wcfg = plugin.getGlobalStateManager().get(player.getWorld());
-        Session session = plugin.getSessionManager().getIfPresent(player);
+        LocalPlayer localPlayer = plugin.wrapPlayer(player);
+        WorldConfiguration wcfg = WorldGuard.getInstance().getPlatform().getGlobalStateManager().get(localPlayer.getWorld());
+        Session session = WorldGuard.getInstance().getPlatform().getSessionManager().getIfPresent(localPlayer);
         if (session != null) {
             GameModeFlag handler = session.getHandler(GameModeFlag.class);
-            if (handler != null && wcfg.useRegions && !plugin.getGlobalRegionManager().hasBypass(player, player.getWorld())) {
+            if (handler != null && wcfg.useRegions && !WorldGuard.getInstance().getPlatform().getSessionManager().hasBypass(localPlayer,
+                    localPlayer.getWorld())) {
                 GameMode expected = handler.getSetGameMode();
-                if (handler.getOriginalGameMode() != null && expected != null && expected != event.getNewGameMode()) {
+                if (handler.getOriginalGameMode() != null && expected != null && expected != BukkitAdapter.adapt(event.getNewGameMode())) {
                     log.info("Game mode change on " + player.getName() + " has been blocked due to the region GAMEMODE flag");
                     event.setCancelled(true);
                 }
@@ -114,10 +122,11 @@ public class WorldGuardPlayerListener implements Listener {
     @EventHandler
     public void onPlayerJoin(PlayerJoinEvent event) {
         Player player = event.getPlayer();
+        LocalPlayer localPlayer = plugin.wrapPlayer(player);
         World world = player.getWorld();
 
-        ConfigurationManager cfg = plugin.getGlobalStateManager();
-        WorldConfiguration wcfg = cfg.get(world);
+        ConfigurationManager cfg = WorldGuard.getInstance().getPlatform().getGlobalStateManager();
+        WorldConfiguration wcfg = cfg.get(localPlayer.getWorld());
 
         if (cfg.activityHaltToggle) {
             player.sendMessage(ChatColor.YELLOW
@@ -126,7 +135,7 @@ public class WorldGuardPlayerListener implements Listener {
             int removed = 0;
 
             for (Entity entity : world.getEntities()) {
-                if (BukkitUtil.isIntensiveEntity(entity)) {
+                if (Entities.isIntensiveEntity(BukkitAdapter.adapt(entity))) {
                     entity.remove();
                     removed++;
                 }
@@ -144,27 +153,35 @@ public class WorldGuardPlayerListener implements Listener {
         }
 
         Events.fire(new ProcessPlayerEvent(player));
-
-        plugin.getSessionManager().get(player); // Initializes a session
     }
 
     @EventHandler(ignoreCancelled = true)
     public void onPlayerChat(AsyncPlayerChatEvent event) {
         Player player = event.getPlayer();
-        WorldConfiguration wcfg = plugin.getGlobalStateManager().get(player.getWorld());
+        LocalPlayer localPlayer = plugin.wrapPlayer(player);
+        WorldConfiguration wcfg =
+                WorldGuard.getInstance().getPlatform().getGlobalStateManager().get(localPlayer.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!");
+            RegionQuery query = WorldGuard.getInstance().getPlatform().getRegionContainer().createQuery();
+            ApplicableRegionSet chatFrom = query.getApplicableRegions(localPlayer.getLocation());
+
+            if (!chatFrom.testState(localPlayer, Flags.SEND_CHAT)) {
+                String message = chatFrom.queryValue(localPlayer, Flags.DENY_MESSAGE);
+                RegionProtectionListener.formatAndSendDenyMessage("chat", localPlayer, message);
                 event.setCancelled(true);
                 return;
             }
 
+            boolean anyRemoved = false;
             for (Iterator<Player> i = event.getRecipients().iterator(); i.hasNext();) {
-                if (!plugin.getGlobalRegionManager().allows(DefaultFlag.RECEIVE_CHAT, i.next().getLocation())) {
+                Player rPlayer = i.next();
+                LocalPlayer rLocal = plugin.wrapPlayer(rPlayer);
+                if (!query.testState(rLocal.getLocation(), rLocal, Flags.RECEIVE_CHAT)) {
                     i.remove();
+                    anyRemoved = true;
                 }
             }
-            if (event.getRecipients().size() == 0) {
+            if (anyRemoved && event.getRecipients().size() == 0 && wcfg.regionCancelEmptyChatEvents) {
                 event.setCancelled(true);
             }
         }
@@ -173,9 +190,13 @@ public class WorldGuardPlayerListener implements Listener {
     @EventHandler(ignoreCancelled = true)
     public void onPlayerLogin(PlayerLoginEvent event) {
         Player player = event.getPlayer();
-        ConfigurationManager cfg = plugin.getGlobalStateManager();
+        ConfigurationManager cfg = WorldGuard.getInstance().getPlatform().getGlobalStateManager();
+
+        String hostKey = cfg.hostKeys.get(player.getUniqueId().toString());
+        if (hostKey == null) {
+            hostKey = cfg.hostKeys.get(player.getName().toLowerCase());
+        }
 
-        String hostKey = cfg.hostKeys.get(player.getName().toLowerCase());
         if (hostKey != null) {
             String hostname = event.getHostname();
             int colonIndex = hostname.indexOf(':');
@@ -183,7 +204,8 @@ public class WorldGuardPlayerListener implements Listener {
                 hostname = hostname.substring(0, colonIndex);
             }
 
-            if (!hostname.equals(hostKey)) {
+            if (!hostname.equals(hostKey)
+                    && !(cfg.hostKeysAllowFMLClients && hostname.equals(hostKey + "\u0000FML\u0000"))) {
                 event.disallow(PlayerLoginEvent.Result.KICK_OTHER,
                         "You did not join with the valid host key!");
                 log.warning("WorldGuard host key check: " +
@@ -209,8 +231,8 @@ public class WorldGuardPlayerListener implements Listener {
             handlePhysicalInteract(event);
         }
 
-        ConfigurationManager cfg = plugin.getGlobalStateManager();
-        WorldConfiguration wcfg = cfg.get(world);
+        ConfigurationManager cfg = WorldGuard.getInstance().getPlatform().getGlobalStateManager();
+        WorldConfiguration wcfg = cfg.get(BukkitAdapter.adapt(world));
 
         if (wcfg.removeInfiniteStacks
                 && !plugin.hasPermission(player, "worldguard.override.infinite-stack")) {
@@ -229,27 +251,21 @@ public class WorldGuardPlayerListener implements Listener {
      * @param event Thrown event
      */
     private void handleBlockRightClick(PlayerInteractEvent event) {
-        if (event.isCancelled()) {
+        if (event.useItemInHand() == Event.Result.DENY) {
             return;
         }
 
         Block block = event.getClickedBlock();
         World world = block.getWorld();
-        int type = block.getTypeId();
+        Material type = block.getType();
         Player player = event.getPlayer();
         @Nullable ItemStack item = event.getItem();
 
-        ConfigurationManager cfg = plugin.getGlobalStateManager();
-        WorldConfiguration wcfg = cfg.get(world);
+        ConfigurationManager cfg = WorldGuard.getInstance().getPlatform().getGlobalStateManager();
+        WorldConfiguration wcfg = cfg.get(BukkitAdapter.adapt(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)
+        if (Materials.isInventoryBlock(type)
                 && wcfg.removeInfiniteStacks
                 && !plugin.hasPermission(player, "worldguard.override.infinite-stack")) {
             for (int slot = 0; slot < 40; slot++) {
@@ -263,14 +279,14 @@ public class WorldGuardPlayerListener implements Listener {
 
         if (wcfg.useRegions) {
             //Block placedIn = block.getRelative(event.getBlockFace());
-            ApplicableRegionSet set = plugin.getRegionContainer().createQuery().getApplicableRegions(block.getLocation());
+            ApplicableRegionSet set =
+                    WorldGuard.getInstance().getPlatform().getRegionContainer().createQuery().getApplicableRegions(BukkitAdapter.adapt(block.getLocation()));
             //ApplicableRegionSet placedInSet = plugin.getRegionContainer().createQuery().getApplicableRegions(placedIn.getLocation());
             LocalPlayer localPlayer = plugin.wrapPlayer(player);
 
-            if (item != null && item.getTypeId() == wcfg.regionWand && plugin.hasPermission(player, "worldguard.region.wand")) {
+            if (item != null && item.getType().getKey().toString().equals(wcfg.regionWand) && plugin.hasPermission(player, "worldguard.region.wand")) {
                 if (set.size() > 0) {
-                    player.sendMessage(ChatColor.YELLOW + "Can you build? "
-                            + (set.canBuild(localPlayer) ? "Yes" : "No"));
+                    player.sendMessage(ChatColor.YELLOW + "Can you build? " + (set.testState(localPlayer, Flags.BUILD) ? "Yes" : "No"));
 
                     StringBuilder str = new StringBuilder();
                     for (Iterator<ProtectedRegion> it = set.iterator(); it.hasNext();) {
@@ -280,12 +296,12 @@ public class WorldGuardPlayerListener implements Listener {
                         }
                     }
 
-                    player.sendMessage(ChatColor.YELLOW + "Applicable regions: " + str.toString());
+                    localPlayer.print("Applicable regions: " + str);
                 } else {
-                    player.sendMessage(ChatColor.YELLOW + "WorldGuard: No defined regions here!");
+                    localPlayer.print("WorldGuard: No defined regions here!");
                 }
 
-                event.setCancelled(true);
+                event.setUseItemInHand(Event.Result.DENY);
             }
         }
     }
@@ -296,17 +312,17 @@ public class WorldGuardPlayerListener implements Listener {
      * @param event Thrown event
      */
     private void handlePhysicalInteract(PlayerInteractEvent event) {
-        if (event.isCancelled()) return;
+        if (event.useInteractedBlock() == Event.Result.DENY) 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);
+        ConfigurationManager cfg = WorldGuard.getInstance().getPlatform().getGlobalStateManager();
+        WorldConfiguration wcfg = cfg.get(BukkitAdapter.adapt(world));
 
-        if (block.getTypeId() == BlockID.SOIL && wcfg.disablePlayerCropTrampling) {
+        if (block.getType() == Material.FARMLAND && wcfg.disablePlayerCropTrampling) {
             event.setCancelled(true);
             return;
         }
@@ -315,19 +331,19 @@ public class WorldGuardPlayerListener implements Listener {
     @EventHandler(priority = EventPriority.HIGHEST)
     public void onPlayerRespawn(PlayerRespawnEvent event) {
         Player player = event.getPlayer();
-        Location location = player.getLocation();
+        LocalPlayer localPlayer = plugin.wrapPlayer(player);
 
-        ConfigurationManager cfg = plugin.getGlobalStateManager();
-        WorldConfiguration wcfg = cfg.get(player.getWorld());
+        ConfigurationManager cfg = WorldGuard.getInstance().getPlatform().getGlobalStateManager();
+        WorldConfiguration wcfg = cfg.get(localPlayer.getWorld());
 
         if (wcfg.useRegions) {
-            ApplicableRegionSet set = plugin.getRegionContainer().createQuery().getApplicableRegions(location);
+            ApplicableRegionSet set =
+                    WorldGuard.getInstance().getPlatform().getRegionContainer().createQuery().getApplicableRegions(localPlayer.getLocation());
 
-            LocalPlayer localPlayer = plugin.wrapPlayer(player);
-            com.sk89q.worldedit.Location spawn = set.getFlag(DefaultFlag.SPAWN_LOC, localPlayer);
+            com.sk89q.worldedit.util.Location spawn = set.queryValue(localPlayer, Flags.SPAWN_LOC);
 
             if (spawn != null) {
-                event.setRespawnLocation(com.sk89q.worldedit.bukkit.BukkitUtil.toLocation(spawn));
+                event.setRespawnLocation(BukkitAdapter.adapt(spawn));
             }
         }
     }
@@ -336,8 +352,8 @@ public class WorldGuardPlayerListener implements Listener {
     public void onItemHeldChange(PlayerItemHeldEvent event) {
         Player player = event.getPlayer();
 
-        ConfigurationManager cfg = plugin.getGlobalStateManager();
-        WorldConfiguration wcfg = cfg.get(player.getWorld());
+        ConfigurationManager cfg = WorldGuard.getInstance().getPlatform().getGlobalStateManager();
+        WorldConfiguration wcfg = cfg.get(BukkitAdapter.adapt(player.getWorld()));
 
         if (wcfg.removeInfiniteStacks
                 && !plugin.hasPermission(player, "worldguard.override.infinite-stack")) {
@@ -354,44 +370,58 @@ public class WorldGuardPlayerListener implements Listener {
     public void onPlayerTeleport(PlayerTeleportEvent event) {
         World world = event.getFrom().getWorld();
         Player player = event.getPlayer();
-        ConfigurationManager cfg = plugin.getGlobalStateManager();
-        WorldConfiguration wcfg = cfg.get(world);
+        LocalPlayer localPlayer = plugin.wrapPlayer(player);
+        ConfigurationManager cfg = WorldGuard.getInstance().getPlatform().getGlobalStateManager();
+        WorldConfiguration wcfg = cfg.get(localPlayer.getWorld());
 
-        if (wcfg.useRegions) {
-            ApplicableRegionSet set = plugin.getRegionContainer().createQuery().getApplicableRegions(event.getTo());
-            ApplicableRegionSet setFrom = plugin.getRegionContainer().createQuery().getApplicableRegions(event.getFrom());
-            LocalPlayer localPlayer = plugin.wrapPlayer(player);
-
-            if (cfg.usePlayerTeleports) {
-                if (null != plugin.getSessionManager().get(player).testMoveTo(player, event.getTo(), MoveType.TELEPORT)) {
-                    event.setCancelled(true);
-                    return;
-                }
-            }
+        if (wcfg.useRegions && cfg.usePlayerTeleports) {
+            ApplicableRegionSet set =
+                    WorldGuard.getInstance().getPlatform().getRegionContainer().createQuery().getApplicableRegions(BukkitAdapter.adapt(event.getTo()));
+            ApplicableRegionSet setFrom =
+                    WorldGuard.getInstance().getPlatform().getRegionContainer().createQuery().getApplicableRegions(BukkitAdapter.adapt(event.getFrom()));
 
             if (event.getCause() == TeleportCause.ENDER_PEARL) {
-                if (!plugin.getGlobalRegionManager().hasBypass(localPlayer, world)
-                        && !(set.allows(DefaultFlag.ENDERPEARL, localPlayer)
-                                && setFrom.allows(DefaultFlag.ENDERPEARL, localPlayer))) {
-                    player.sendMessage(ChatColor.DARK_RED + "You're not allowed to go there.");
-                    event.setCancelled(true);
-                    return;
-                }
-            }
-            try {
-                if (event.getCause() == TeleportCause.CHORUS_FRUIT) {
-                    if (!plugin.getGlobalRegionManager().hasBypass(localPlayer, world)) {
-                        boolean allowFrom = setFrom.allows(DefaultFlag.CHORUS_TELEPORT, localPlayer);
-                        boolean allowTo = set.allows(DefaultFlag.CHORUS_TELEPORT, localPlayer);
-                        if (!allowFrom || !allowTo) {
-                            player.sendMessage(ChatColor.DARK_RED + "You're not allowed to teleport " +
-                                    (!allowFrom ? "from here." : "there."));
-                            event.setCancelled(true);
-                            return;
-                        }
+                if (!WorldGuard.getInstance().getPlatform().getSessionManager().hasBypass(localPlayer, localPlayer.getWorld())) {
+                    boolean cancel = false;
+                    String message = null;
+                    if (!setFrom.testState(localPlayer, Flags.ENDERPEARL)) {
+                        cancel = true;
+                        message = set.queryValue(localPlayer, Flags.EXIT_DENY_MESSAGE);
+                    } else if (!set.testState(localPlayer, Flags.ENDERPEARL)) {
+                        cancel = true;
+                        message = set.queryValue(localPlayer, Flags.ENTRY_DENY_MESSAGE);
+                    }
+                    if (cancel) {
+                        player.sendMessage(message);
+                        event.setCancelled(true);
+                        return;
                     }
                 }
-            } catch (NoSuchFieldError ignored) {}
+            }
+            if (event.getCause() == TeleportCause.CHORUS_FRUIT) {
+                if (!WorldGuard.getInstance().getPlatform().getSessionManager().hasBypass(localPlayer, localPlayer.getWorld())) {
+                    boolean cancel = false;
+                    String message = null;
+                    if (!setFrom.testState(localPlayer, Flags.CHORUS_TELEPORT)) {
+                        cancel = true;
+                        message = set.queryValue(localPlayer, Flags.EXIT_DENY_MESSAGE);
+                    } else if (!set.testState(localPlayer, Flags.CHORUS_TELEPORT)) {
+                        cancel = true;
+                        message = set.queryValue(localPlayer, Flags.ENTRY_DENY_MESSAGE);
+                    }
+                    if (cancel) {
+                        player.sendMessage(message);
+                        event.setCancelled(true);
+                        return;
+                    }
+                }
+            }
+            if (null != WorldGuard.getInstance().getPlatform().getSessionManager().get(localPlayer).testMoveTo(localPlayer,
+                    BukkitAdapter.adapt(event.getTo()),
+                    MoveType.TELEPORT)) {
+                event.setCancelled(true);
+                return;
+            }
         }
     }
 
@@ -400,13 +430,18 @@ public class WorldGuardPlayerListener implements Listener {
         if (event.getTo() == null) { // apparently this counts as a cancelled event, implementation specific though
             return;
         }
-        ConfigurationManager cfg = plugin.getGlobalStateManager();
-        WorldConfiguration wcfg = cfg.get(event.getTo().getWorld());
+        ConfigurationManager cfg = WorldGuard.getInstance().getPlatform().getGlobalStateManager();
+        LocalPlayer localPlayer = plugin.wrapPlayer(event.getPlayer());
+        WorldConfiguration wcfg = cfg.get(BukkitAdapter.adapt(event.getTo().getWorld()));
         if (!wcfg.regionNetherPortalProtection) return;
         if (event.getCause() != TeleportCause.NETHER_PORTAL) {
             return;
         }
-        if (!event.useTravelAgent()) { // either end travel (even though we checked cause) or another plugin is fucking with us, shouldn't create a portal though
+        try {
+            if (!event.useTravelAgent()) { // either end travel (even though we checked cause) or another plugin is fucking with us, shouldn't create a portal though
+                return;
+            }
+        } catch (NoSuchMethodError ignored) {
             return;
         }
         TravelAgent pta = event.getPortalTravelAgent();
@@ -423,15 +458,16 @@ public class WorldGuardPlayerListener implements Listener {
         int radius = pta.getCreationRadius();
         Location min = event.getTo().clone().subtract(radius, radius, radius);
         Location max = event.getTo().clone().add(radius, radius, radius);
-        World world = event.getTo().getWorld();
+        com.sk89q.worldedit.world.World world = BukkitAdapter.adapt(event.getTo().getWorld());
 
-        ProtectedRegion check = new ProtectedCuboidRegion("__portalcheck__", BukkitUtil.toVector(min.getBlock()), BukkitUtil.toVector(max.getBlock()));
+        ProtectedRegion check = new ProtectedCuboidRegion("__portalcheck__", BukkitAdapter.adapt(min.getBlock().getLocation()).toVector().toBlockPoint(),
+                BukkitAdapter.adapt(max.getBlock().getLocation()).toVector().toBlockPoint());
 
-        if (wcfg.useRegions && !plugin.getGlobalRegionManager().hasBypass(event.getPlayer(), world)) {
-            RegionManager mgr = plugin.getRegionContainer().get(event.getTo().getWorld());
+        if (wcfg.useRegions && !WorldGuard.getInstance().getPlatform().getSessionManager().hasBypass(localPlayer, world)) {
+            RegionManager mgr = WorldGuard.getInstance().getPlatform().getRegionContainer().get(world);
             if (mgr == null) return;
             ApplicableRegionSet set = mgr.getApplicableRegions(check);
-            if (!set.testState(plugin.wrapPlayer(event.getPlayer()), DefaultFlag.BUILD)) {
+            if (!set.testState(plugin.wrapPlayer(event.getPlayer()), Flags.BUILD)) {
                 event.getPlayer().sendMessage(ChatColor.RED + "Destination is in a protected area.");
                 event.setCancelled(true);
                 return;
@@ -443,19 +479,20 @@ public class WorldGuardPlayerListener implements Listener {
     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);
+        ConfigurationManager cfg = WorldGuard.getInstance().getPlatform().getGlobalStateManager();
+        WorldConfiguration wcfg = cfg.get(localPlayer.getWorld());
 
-        if (wcfg.useRegions && !plugin.getGlobalRegionManager().hasBypass(player, world)) {
-            ApplicableRegionSet set = plugin.getRegionContainer().createQuery().getApplicableRegions(player.getLocation());
+        if (wcfg.useRegions && !WorldGuard.getInstance().getPlatform().getSessionManager().hasBypass(localPlayer, localPlayer.getWorld())) {
+            ApplicableRegionSet set =
+                    WorldGuard.getInstance().getPlatform().getRegionContainer().createQuery().getApplicableRegions(localPlayer.getLocation());
 
-            Set<String> allowedCommands = set.queryValue(localPlayer, DefaultFlag.ALLOWED_CMDS);
-            Set<String> blockedCommands = set.queryValue(localPlayer, DefaultFlag.BLOCKED_CMDS);
+            Set<String> allowedCommands = set.queryValue(localPlayer, Flags.ALLOWED_CMDS);
+            Set<String> blockedCommands = set.queryValue(localPlayer, Flags.BLOCKED_CMDS);
             CommandFilter test = new CommandFilter(allowedCommands, blockedCommands);
 
             if (!test.apply(event.getMessage())) {
-                player.sendMessage(ChatColor.RED + event.getMessage() + " is not allowed in this area.");
+                String message = set.queryValue(localPlayer, Flags.DENY_MESSAGE);
+                RegionProtectionListener.formatAndSendDenyMessage("use " + event.getMessage(), localPlayer, message);
                 event.setCancelled(true);
                 return;
             }
@@ -463,7 +500,7 @@ public class WorldGuardPlayerListener implements Listener {
 
         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).");
+                player.sendMessage(ChatColor.RED + "/op and /deop can only be used in console (as set by a WG setting).");
                 event.setCancelled(true);
                 return;
             }

worldguard-bukkit/src/main/java/com/sk89q/worldguard/bukkit/listener/WorldGuardServerListener.java

@@ -19,6 +19,8 @@
 
 package com.sk89q.worldguard.bukkit.listener;
 
+import com.sk89q.worldguard.WorldGuard;
+import com.sk89q.worldguard.bukkit.BukkitConfigurationManager;
 import com.sk89q.worldguard.bukkit.WorldGuardPlugin;
 import org.bukkit.event.EventHandler;
 import org.bukkit.event.Listener;
@@ -45,14 +47,14 @@ public class WorldGuardServerListener implements Listener {
     @EventHandler
     public void onPluginEnable(PluginEnableEvent event) {
         if (event.getPlugin().getDescription().getName().equalsIgnoreCase("CommandBook")) {
-            plugin.getGlobalStateManager().updateCommandBookGodMode();
+            ((BukkitConfigurationManager) WorldGuard.getInstance().getPlatform().getGlobalStateManager()).updateCommandBookGodMode();
         }
     }
 
     @EventHandler
     public void onPluginDisable(PluginDisableEvent event) {
         if (event.getPlugin().getDescription().getName().equalsIgnoreCase("CommandBook")) {
-            plugin.getGlobalStateManager().updateCommandBookGodMode();
+            ((BukkitConfigurationManager) WorldGuard.getInstance().getPlatform().getGlobalStateManager()).updateCommandBookGodMode();
         }
     }
 }

worldguard-bukkit/src/main/java/com/sk89q/worldguard/bukkit/listener/WorldGuardVehicleListener.java

@@ -19,11 +19,15 @@
 
 package com.sk89q.worldguard.bukkit.listener;
 
-import com.sk89q.worldguard.bukkit.ConfigurationManager;
-import com.sk89q.worldguard.bukkit.WorldConfiguration;
+import com.sk89q.worldedit.bukkit.BukkitAdapter;
+import com.sk89q.worldedit.util.Location;
+import com.sk89q.worldguard.LocalPlayer;
+import com.sk89q.worldguard.WorldGuard;
 import com.sk89q.worldguard.bukkit.WorldGuardPlugin;
-import com.sk89q.worldguard.bukkit.util.Locations;
+import com.sk89q.worldguard.config.ConfigurationManager;
+import com.sk89q.worldguard.config.WorldConfiguration;
 import com.sk89q.worldguard.session.MoveType;
+import com.sk89q.worldguard.util.Locations;
 import org.bukkit.World;
 import org.bukkit.entity.Player;
 import org.bukkit.entity.Vehicle;
@@ -32,6 +36,9 @@ import org.bukkit.event.Listener;
 import org.bukkit.event.vehicle.VehicleMoveEvent;
 import org.bukkit.util.Vector;
 
+import java.util.List;
+import java.util.stream.Collectors;
+
 public class WorldGuardVehicleListener implements Listener {
 
     private WorldGuardPlugin plugin;
@@ -55,18 +62,32 @@ public class WorldGuardVehicleListener implements Listener {
     @EventHandler
     public void onVehicleMove(VehicleMoveEvent event) {
         Vehicle vehicle = event.getVehicle();
-        if (vehicle.getPassenger() == null || !(vehicle.getPassenger() instanceof Player)) return;
-        Player player = (Player) vehicle.getPassenger();
+        if (vehicle.getPassengers().isEmpty()) return;
+        List<Player> playerPassengers = vehicle.getPassengers().stream()
+                .filter(ent -> ent instanceof Player).map(ent -> (Player) ent).collect(Collectors.toList());
+        if (playerPassengers.isEmpty()) {
+            return;
+        }
         World world = vehicle.getWorld();
-        ConfigurationManager cfg = plugin.getGlobalStateManager();
-        WorldConfiguration wcfg = cfg.get(world);
+        ConfigurationManager cfg = WorldGuard.getInstance().getPlatform().getGlobalStateManager();
+        WorldConfiguration wcfg = cfg.get(BukkitAdapter.adapt(world));
 
         if (wcfg.useRegions) {
             // Did we move a block?
-            if (Locations.isDifferentBlock(event.getFrom(), event.getTo())) {
-                if (null != plugin.getSessionManager().get(player).testMoveTo(player, event.getTo(), MoveType.RIDE)) {
-                    vehicle.setVelocity(new Vector(0,0,0));
-                    vehicle.teleport(event.getFrom());
+            if (Locations.isDifferentBlock(BukkitAdapter.adapt(event.getFrom()), BukkitAdapter.adapt(event.getTo()))) {
+                for (Player player : playerPassengers) {
+                    LocalPlayer localPlayer = plugin.wrapPlayer(player);
+                    Location lastValid;
+                    if ((lastValid = WorldGuard.getInstance().getPlatform().getSessionManager().get(localPlayer)
+                            .testMoveTo(localPlayer, BukkitAdapter.adapt(event.getTo()), MoveType.RIDE)) != null) {
+                        vehicle.setVelocity(new Vector(0, 0, 0));
+                        vehicle.teleport(event.getFrom());
+                        if (Locations.isDifferentBlock(lastValid, BukkitAdapter.adapt(event.getFrom()))) {
+                            Vector dir = player.getLocation().getDirection();
+                            player.teleport(BukkitAdapter.adapt(lastValid).setDirection(dir));
+                        }
+                        return;
+                    }
                 }
             }
         }

worldguard-bukkit/src/main/java/com/sk89q/worldguard/bukkit/listener/WorldGuardWeatherListener.java

@@ -19,12 +19,16 @@
 
 package com.sk89q.worldguard.bukkit.listener;
 
-import com.sk89q.worldguard.bukkit.ConfigurationManager;
-import com.sk89q.worldguard.bukkit.WorldConfiguration;
+import com.sk89q.worldedit.bukkit.BukkitAdapter;
+import com.sk89q.worldguard.WorldGuard;
 import com.sk89q.worldguard.bukkit.WorldGuardPlugin;
-import com.sk89q.worldguard.protection.ApplicableRegionSet;
-import com.sk89q.worldguard.protection.flags.DefaultFlag;
+import com.sk89q.worldguard.config.ConfigurationManager;
+import com.sk89q.worldguard.config.WorldConfiguration;
+import com.sk89q.worldguard.protection.association.RegionAssociable;
+import com.sk89q.worldguard.protection.flags.Flags;
+import com.sk89q.worldguard.protection.flags.StateFlag;
 import org.bukkit.Location;
+import org.bukkit.Material;
 import org.bukkit.event.EventHandler;
 import org.bukkit.event.EventPriority;
 import org.bukkit.event.Listener;
@@ -54,8 +58,8 @@ public class WorldGuardWeatherListener implements Listener {
 
     @EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
     public void onWeatherChange(WeatherChangeEvent event) {
-        ConfigurationManager cfg = plugin.getGlobalStateManager();
-        WorldConfiguration wcfg = cfg.get(event.getWorld());
+        ConfigurationManager cfg = WorldGuard.getInstance().getPlatform().getGlobalStateManager();
+        WorldConfiguration wcfg = cfg.get(BukkitAdapter.adapt(event.getWorld()));
 
         if (event.toWeatherState()) {
             if (wcfg.disableWeather) {
@@ -70,8 +74,8 @@ public class WorldGuardWeatherListener implements Listener {
 
     @EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
     public void onThunderChange(ThunderChangeEvent event) {
-        ConfigurationManager cfg = plugin.getGlobalStateManager();
-        WorldConfiguration wcfg = cfg.get(event.getWorld());
+        ConfigurationManager cfg = WorldGuard.getInstance().getPlatform().getGlobalStateManager();
+        WorldConfiguration wcfg = cfg.get(BukkitAdapter.adapt(event.getWorld()));
 
         if (event.toThunderState()) {
             if (wcfg.disableThunder) {
@@ -86,21 +90,19 @@ public class WorldGuardWeatherListener implements Listener {
 
     @EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
     public void onLightningStrike(LightningStrikeEvent event) {
-        ConfigurationManager cfg = plugin.getGlobalStateManager();
-        WorldConfiguration wcfg = cfg.get(event.getWorld());
+        ConfigurationManager cfg = WorldGuard.getInstance().getPlatform().getGlobalStateManager();
+        WorldConfiguration wcfg = cfg.get(BukkitAdapter.adapt(event.getWorld()));
 
         if (wcfg.disallowedLightningBlocks.size() > 0) {
-            int targetId = event.getLightning().getLocation().getBlock().getTypeId();
-            if (wcfg.disallowedLightningBlocks.contains(targetId)) {
+            Material targetId = event.getLightning().getLocation().getBlock().getType();
+            if (wcfg.disallowedLightningBlocks.contains(BukkitAdapter.asBlockType(targetId).getId())) {
                 event.setCancelled(true);
             }
         }
 
         Location loc = event.getLightning().getLocation();
         if (wcfg.useRegions) {
-            ApplicableRegionSet set = plugin.getRegionContainer().createQuery().getApplicableRegions(loc);
-
-            if (!set.allows(DefaultFlag.LIGHTNING)) {
+            if (!StateFlag.test(WorldGuard.getInstance().getPlatform().getRegionContainer().createQuery().queryState(BukkitAdapter.adapt(loc), (RegionAssociable) null, Flags.LIGHTNING))) {
                 event.setCancelled(true);
             }
         }

worldguard-bukkit/src/main/java/com/sk89q/worldguard/bukkit/listener/WorldGuardWorldListener.java

@@ -19,10 +19,12 @@
 
 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.worldedit.bukkit.BukkitAdapter;
+import com.sk89q.worldguard.WorldGuard;
 import com.sk89q.worldguard.bukkit.WorldGuardPlugin;
+import com.sk89q.worldguard.config.ConfigurationManager;
+import com.sk89q.worldguard.config.WorldConfiguration;
+import com.sk89q.worldguard.util.Entities;
 import org.bukkit.World;
 import org.bukkit.entity.Entity;
 import org.bukkit.event.EventHandler;
@@ -55,13 +57,13 @@ public class WorldGuardWorldListener implements Listener {
 
     @EventHandler
     public void onChunkLoad(ChunkLoadEvent event) {
-        ConfigurationManager cfg = plugin.getGlobalStateManager();
+        ConfigurationManager cfg = WorldGuard.getInstance().getPlatform().getGlobalStateManager();
 
         if (cfg.activityHaltToggle) {
             int removed = 0;
 
             for (Entity entity : event.getChunk().getEntities()) {
-                if (BukkitUtil.isIntensiveEntity(entity)) {
+                if (Entities.isIntensiveEntity(BukkitAdapter.adapt(entity))) {
                     entity.remove();
                     removed++;
                 }
@@ -87,8 +89,8 @@ public class WorldGuardWorldListener implements Listener {
      * @param world The specified world
      */
     public void initWorld(World world) {
-        ConfigurationManager cfg = plugin.getGlobalStateManager();
-        WorldConfiguration wcfg = cfg.get(world);
+        ConfigurationManager cfg = WorldGuard.getInstance().getPlatform().getGlobalStateManager();
+        WorldConfiguration wcfg = cfg.get(BukkitAdapter.adapt(world));
         if (wcfg.alwaysRaining && !wcfg.disableWeather) {
             world.setStorm(true);
         } else if (wcfg.disableWeather && !wcfg.alwaysRaining) {

worldguard-bukkit/src/main/java/com/sk89q/worldguard/bukkit/listener/WorldRulesListener.java

@@ -19,12 +19,14 @@
 
 package com.sk89q.worldguard.bukkit.listener;
 
-import com.sk89q.worldguard.bukkit.WorldConfiguration;
+import com.sk89q.worldedit.bukkit.BukkitAdapter;
 import com.sk89q.worldguard.bukkit.WorldGuardPlugin;
 import com.sk89q.worldguard.bukkit.event.entity.SpawnEntityEvent;
+import com.sk89q.worldguard.config.WorldConfiguration;
 import org.bukkit.entity.EntityType;
 import org.bukkit.event.EventHandler;
 import org.bukkit.event.EventPriority;
+import org.bukkit.event.entity.EntityPotionEffectEvent;
 
 public class WorldRulesListener extends AbstractListener {
 
@@ -39,17 +41,24 @@ public class WorldRulesListener extends AbstractListener {
 
     @EventHandler(priority = EventPriority.LOWEST, ignoreCancelled = true)
     public void onSpawnEntity(final SpawnEntityEvent event) {
-        WorldConfiguration config = getWorldConfig(event.getWorld());
-
-        // ================================================================
-        // EXP_DROPS flag
-        // ================================================================
-
         if (event.getEffectiveType() == EntityType.EXPERIENCE_ORB) {
+            WorldConfiguration config = getWorldConfig(BukkitAdapter.adapt(event.getWorld()));
+
             if (config.disableExpDrops) {
                 event.setCancelled(true);
             }
         }
     }
 
+    @EventHandler(priority = EventPriority.LOWEST, ignoreCancelled = true)
+    public void onPotionEffect(EntityPotionEffectEvent event) {
+        if (event.getCause() == EntityPotionEffectEvent.Cause.CONDUIT) {
+            WorldConfiguration config = getWorldConfig(BukkitAdapter.adapt(event.getEntity().getWorld()));
+
+            if (config.disableConduitEffects) {
+                event.setCancelled(true);
+            }
+        }
+    }
+
 }

worldguard-bukkit/src/main/java/com/sk89q/worldguard/bukkit/listener/debounce/EventDebounce.java

@@ -20,9 +20,9 @@
 package com.sk89q.worldguard.bukkit.listener.debounce;
 
 import com.sk89q.worldguard.bukkit.util.Events;
-import com.sk89q.guavabackport.cache.CacheBuilder;
-import com.sk89q.guavabackport.cache.CacheLoader;
-import com.sk89q.guavabackport.cache.LoadingCache;
+import com.google.common.cache.CacheBuilder;
+import com.google.common.cache.CacheLoader;
+import com.google.common.cache.LoadingCache;
 import org.bukkit.event.Cancellable;
 import org.bukkit.event.Event;
 
@@ -75,7 +75,7 @@ public class EventDebounce<K> {
     }
 
     public static <K> EventDebounce<K> create(int debounceTime) {
-        return new EventDebounce<K>(debounceTime);
+        return new EventDebounce<>(debounceTime);
     }
 
     public static class Entry {

worldguard-bukkit/src/main/java/com/sk89q/worldguard/bukkit/listener/debounce/legacy/AbstractEventDebounce.java

@@ -20,9 +20,9 @@
 package com.sk89q.worldguard.bukkit.listener.debounce.legacy;
 
 import com.sk89q.worldguard.bukkit.util.Events;
-import com.sk89q.guavabackport.cache.CacheBuilder;
-import com.sk89q.guavabackport.cache.CacheLoader;
-import com.sk89q.guavabackport.cache.LoadingCache;
+import com.google.common.cache.CacheBuilder;
+import com.google.common.cache.CacheLoader;
+import com.google.common.cache.LoadingCache;
 import org.bukkit.event.Cancellable;
 import org.bukkit.event.Event;
 

worldguard-bukkit/src/main/java/com/sk89q/worldguard/bukkit/listener/debounce/legacy/InventoryMoveItemEventDebounce.java

@@ -53,7 +53,12 @@ public class InventoryMoveItemEventDebounce extends AbstractEventDebounce<Key> {
             if (holder instanceof BlockState) {
                 return new BlockMaterialKey(((BlockState) holder).getBlock());
             } else if (holder instanceof DoubleChest) {
-                return new BlockMaterialKey((((Chest) ((DoubleChest) holder).getLeftSide())).getBlock());
+                InventoryHolder left = ((DoubleChest) holder).getLeftSide();
+                if (left instanceof Chest) {
+                    return new BlockMaterialKey(((Chest) left).getBlock());
+                } else {
+                    return holder;
+                }
             } else {
                 return holder;
             }

worldguard-bukkit/src/main/java/com/sk89q/worldguard/bukkit/protection/events/DisallowedPVPEvent.java

@@ -17,7 +17,7 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
-package com.sk89q.worldguard.protection.events;
+package com.sk89q.worldguard.bukkit.protection.events;
 
 import org.bukkit.entity.Player;
 import org.bukkit.event.Cancellable;

worldguard-bukkit/src/main/java/com/sk89q/worldguard/bukkit/protection/events/flags/FlagContextCreateEvent.java

@@ -0,0 +1,56 @@
+/*
+ * 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.protection.events.flags;
+
+import com.sk89q.worldguard.protection.flags.FlagContext.FlagContextBuilder;
+import org.bukkit.event.Event;
+import org.bukkit.event.HandlerList;
+
+public class FlagContextCreateEvent extends Event {
+
+    private FlagContextBuilder builder;
+
+    public FlagContextCreateEvent(FlagContextBuilder builder) {
+        this.builder = builder;
+    }
+
+    /**
+     * Add an object to the flag context with the given key. Keys must be unique.
+     *
+     * @param key a unique string to identify the object
+     * @param value the object to store in the context
+     * @return true if added successfully, false if the key was already used
+     */
+    public boolean addObject(String key, Object value) {
+        return builder.tryAddToMap(key, value);
+    }
+
+    private static final HandlerList handlers = new HandlerList();
+
+    @Override
+    public HandlerList getHandlers() {
+        return handlers;
+    }
+
+    public static HandlerList getHandlerList() {
+        return handlers;
+    }
+
+}

worldguard-bukkit/src/main/java/com/sk89q/worldguard/bukkit/session/BukkitSessionManager.java

@@ -0,0 +1,83 @@
+/*
+ * 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.session;
+
+import com.sk89q.worldedit.world.World;
+import com.sk89q.worldguard.LocalPlayer;
+import com.sk89q.worldguard.WorldGuard;
+import com.sk89q.worldguard.bukkit.BukkitPlayer;
+import com.sk89q.worldguard.bukkit.WorldGuardPlugin;
+import com.sk89q.worldguard.session.AbstractSessionManager;
+import com.sk89q.worldguard.session.Session;
+import org.bukkit.Bukkit;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.player.PlayerJoinEvent;
+
+import java.util.Collection;
+
+/**
+ * Keeps tracks of sessions and also does session-related handling
+ * (flags, etc.).
+ */
+public class BukkitSessionManager extends AbstractSessionManager implements Runnable, Listener {
+
+    /**
+     * Re-initialize handlers and clear "last position," "last state," etc.
+     * information for all players.
+     */
+    @Override
+    public void resetAllStates() {
+        Collection<? extends Player> players = Bukkit.getServer().getOnlinePlayers();
+        for (Player player : players) {
+            BukkitPlayer bukkitPlayer = new BukkitPlayer(WorldGuardPlugin.inst(), player);
+            Session session = getIfPresent(bukkitPlayer);
+            if (session != null) {
+                session.resetState(bukkitPlayer);
+            }
+        }
+    }
+
+    @EventHandler
+    public void onPlayerJoin(PlayerJoinEvent event) {
+        // Pre-load a session
+        LocalPlayer player = WorldGuardPlugin.inst().wrapPlayer(event.getPlayer());
+        get(player).initialize(player);
+    }
+
+    @Override
+    public void run() {
+        for (Player player : Bukkit.getServer().getOnlinePlayers()) {
+            LocalPlayer localPlayer = WorldGuardPlugin.inst().wrapPlayer(player);
+            get(localPlayer).tick(localPlayer);
+        }
+    }
+
+    @Override
+    public boolean hasBypass(LocalPlayer player, World world) {
+        if (player instanceof BukkitPlayer) {
+            if (((BukkitPlayer) player).getPlayer().hasMetadata("NPC")
+                && WorldGuard.getInstance().getPlatform().getGlobalStateManager().get(world).fakePlayerBuildOverride)
+                return true;
+        }
+        return super.hasBypass(player, world);
+    }
+}

worldguard-bukkit/src/main/java/com/sk89q/worldguard/bukkit/util/Blocks.java

@@ -20,14 +20,12 @@
 package com.sk89q.worldguard.bukkit.util;
 
 import org.bukkit.block.Block;
-import org.bukkit.block.BlockFace;
 import org.bukkit.block.BlockState;
-import org.bukkit.material.Bed;
-import org.bukkit.material.Chest;
-import org.bukkit.material.MaterialData;
+import org.bukkit.block.data.BlockData;
+import org.bukkit.block.data.type.Bed;
+import org.bukkit.block.data.type.Chest;
+import org.bukkit.util.Vector;
 
-import java.util.ArrayList;
-import java.util.Arrays;
 import java.util.Collections;
 import java.util.List;
 
@@ -48,37 +46,20 @@ public final class Blocks {
      */
     public static List<Block> getConnected(Block block) {
         BlockState state = block.getState();
-        MaterialData data = state.getData();
+        BlockData data = state.getBlockData();
 
         if (data instanceof Bed) {
             Bed bed = (Bed) data;
-            if (bed.isHeadOfBed()) {
-                return Arrays.asList(block.getRelative(bed.getFacing().getOppositeFace()));
-            } else {
-                return Arrays.asList(block.getRelative(bed.getFacing()));
-            }
+            return Collections.singletonList(block.getRelative(bed.getPart() == Bed.Part.FOOT
+                    ? bed.getFacing() : bed.getFacing().getOppositeFace()));
         } else if (data instanceof Chest) {
-            BlockFace facing = ((Chest) data).getFacing();
-            ArrayList<Block> chests = new ArrayList<Block>();
-            if (facing == BlockFace.NORTH || facing == BlockFace.SOUTH) {
-                if (block.getRelative(BlockFace.EAST).getState().getData() instanceof Chest) {
-                    chests.add(block.getRelative(BlockFace.EAST));
-                }
-                if (block.getRelative(BlockFace.WEST).getState().getData() instanceof Chest) {
-                    chests.add(block.getRelative(BlockFace.WEST));
-                }
-            } else if (facing == BlockFace.EAST || facing == BlockFace.WEST) {
-                if (block.getRelative(BlockFace.NORTH).getState().getData() instanceof Chest) {
-                    chests.add(block.getRelative(BlockFace.NORTH));
-                }
-                if (block.getRelative(BlockFace.SOUTH).getState().getData() instanceof Chest) {
-                    chests.add(block.getRelative(BlockFace.SOUTH));
-                }
-            } else {
-                // don't know how to handle diagonal chests
+            final Chest chest = (Chest) data;
+            Chest.Type type = chest.getType();
+            if (type == Chest.Type.SINGLE) {
                 return Collections.emptyList();
             }
-            return chests;
+            Vector offset = chest.getFacing().getDirection().rotateAroundY(Math.PI / 2 * (type == Chest.Type.LEFT ? -1 : 1));
+            return Collections.singletonList(block.getRelative((int) Math.round(offset.getX()), 0, (int) Math.round(offset.getZ())));
         } else {
             return Collections.emptyList();
         }

worldguard-bukkit/src/main/java/com/sk89q/worldguard/bukkit/util/Entities.java

@@ -19,9 +19,31 @@
 
 package com.sk89q.worldguard.bukkit.util;
 
-import com.sk89q.worldguard.util.Enums;
-import org.bukkit.entity.*;
+import org.bukkit.entity.Ambient;
+import org.bukkit.entity.ArmorStand;
+import org.bukkit.entity.Creature;
+import org.bukkit.entity.EnderCrystal;
+import org.bukkit.entity.EnderDragon;
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.EntityType;
+import org.bukkit.entity.Flying;
+import org.bukkit.entity.Hanging;
+import org.bukkit.entity.LivingEntity;
+import org.bukkit.entity.Minecart;
+import org.bukkit.entity.Monster;
+import org.bukkit.entity.NPC;
+import org.bukkit.entity.Player;
+import org.bukkit.entity.Projectile;
+import org.bukkit.entity.Shulker;
+import org.bukkit.entity.Slime;
+import org.bukkit.entity.SpectralArrow;
+import org.bukkit.entity.TNTPrimed;
+import org.bukkit.entity.Tameable;
+import org.bukkit.entity.TippedArrow;
+import org.bukkit.entity.Vehicle;
+import org.bukkit.entity.WaterMob;
 import org.bukkit.entity.minecart.ExplosiveMinecart;
+import org.bukkit.inventory.InventoryHolder;
 import org.bukkit.projectiles.ProjectileSource;
 
 import javax.annotation.Nullable;
@@ -120,10 +142,6 @@ public final class Entities {
         return entity;
     }
 
-
-    private static final EntityType shulkerType =
-            Enums.findByValue(EntityType.class, "SHULKER");
-
     /**
      * Test whether an entity is hostile.
      *
@@ -135,7 +153,7 @@ public final class Entities {
                 || entity instanceof Slime
                 || entity instanceof Flying
                 || entity instanceof EnderDragon
-                || entity.getType() == shulkerType;
+                || entity instanceof Shulker;
     }
 
     /**
@@ -180,9 +198,6 @@ public final class Entities {
         return entity instanceof LivingEntity && !(entity instanceof Player);
     }
 
-    private static final EntityType armorStandType =
-            Enums.findByValue(EntityType.class, "ARMOR_STAND");
-
     /**
      * Test whether using the given entity should be considered "building"
      * rather than merely using an entity.
@@ -192,13 +207,16 @@ public final class Entities {
      */
     public static boolean isConsideredBuildingIfUsed(Entity entity) {
         return entity instanceof Hanging
-                || entity.getType() == armorStandType;
+                || entity instanceof ArmorStand
+                || entity instanceof EnderCrystal
+                || entity instanceof Minecart && entity instanceof InventoryHolder;
     }
 
-    private static final EntityType tippedArrow = Enums.findByValue(EntityType.class, "TIPPED_ARROW");
-    private static final EntityType spectralArrow = Enums.findByValue(EntityType.class, "SPECTRAL_ARROW");
     public static boolean isPotionArrow(Entity entity) {
-        return (entity != null &&
-                (entity.getType() == tippedArrow || entity.getType() == spectralArrow));
+        return entity instanceof TippedArrow || entity instanceof SpectralArrow;
+    }
+
+    public static boolean isAoECloud(EntityType type) {
+        return type == EntityType.AREA_EFFECT_CLOUD;
     }
 }

worldguard-bukkit/src/main/java/com/sk89q/worldguard/bukkit/util/InteropUtils.java

@@ -23,11 +23,10 @@ import com.google.common.base.Function;
 import org.bukkit.Bukkit;
 import org.bukkit.entity.Player;
 
-import javax.annotation.Nullable;
 import java.lang.reflect.Method;
 import java.util.UUID;
-import java.util.logging.Level;
-import java.util.logging.Logger;
+
+import javax.annotation.Nullable;
 
 public final class InteropUtils {
 
@@ -71,6 +70,10 @@ public final class InteropUtils {
         UUID uuid = player.getUniqueId();
         String name = player.getName();
 
+        if (player.hasMetadata("NPC")) {
+            return true;
+        }
+
         if (uuid.equals(forgeFakePlayerUuid)) {
             return true;
         }

worldguard-bukkit/src/main/java/com/sk89q/worldguard/bukkit/util/logging/ClassSourceValidator.java

@@ -17,7 +17,7 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
-package com.sk89q.worldguard.util.logging;
+package com.sk89q.worldguard.bukkit.util.logging;
 
 import com.google.common.base.Strings;
 import com.google.common.collect.Maps;

worldguard-bukkit/src/main/java/com/sk89q/worldguard/bukkit/util/report/CancelReport.java

@@ -17,10 +17,12 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
-package com.sk89q.worldguard.util.report;
+package com.sk89q.worldguard.bukkit.util.report;
 
 import com.sk89q.worldguard.bukkit.event.debug.CancelAttempt;
 import com.sk89q.worldguard.bukkit.util.HandlerTracer;
+import com.sk89q.worldedit.util.report.Report;
+import com.sk89q.worldedit.util.report.StackTraceReport;
 import org.bukkit.event.Cancellable;
 import org.bukkit.event.Event;
 import org.bukkit.plugin.Plugin;

worldguard-bukkit/src/main/java/com/sk89q/worldguard/bukkit/util/report/PerformanceReport.java

@@ -20,7 +20,7 @@
 package com.sk89q.worldguard.bukkit.util.report;
 
 import com.google.common.collect.Maps;
-import com.sk89q.worldguard.util.report.DataReport;
+import com.sk89q.worldedit.util.report.DataReport;
 import org.bukkit.Bukkit;
 import org.bukkit.Chunk;
 import org.bukkit.World;

worldguard-bukkit/src/main/java/com/sk89q/worldguard/bukkit/util/report/PluginReport.java

@@ -19,7 +19,7 @@
 
 package com.sk89q.worldguard.bukkit.util.report;
 
-import com.sk89q.worldguard.util.report.DataReport;
+import com.sk89q.worldedit.util.report.DataReport;
 import org.bukkit.Bukkit;
 import org.bukkit.plugin.Plugin;
 

worldguard-bukkit/src/main/java/com/sk89q/worldguard/bukkit/util/report/SchedulerReport.java

@@ -19,18 +19,18 @@
 
 package com.sk89q.worldguard.bukkit.util.report;
 
-import com.google.common.base.Optional;
 import com.google.common.reflect.TypeToken;
-import com.sk89q.guavabackport.cache.CacheBuilder;
-import com.sk89q.guavabackport.cache.CacheLoader;
-import com.sk89q.guavabackport.cache.LoadingCache;
-import com.sk89q.worldguard.util.report.DataReport;
+import com.google.common.cache.CacheBuilder;
+import com.google.common.cache.CacheLoader;
+import com.google.common.cache.LoadingCache;
+import com.sk89q.worldedit.util.report.DataReport;
 import org.bukkit.Bukkit;
 import org.bukkit.scheduler.BukkitTask;
 
 import javax.annotation.Nullable;
 import java.lang.reflect.Field;
 import java.util.List;
+import java.util.Optional;
 import java.util.Set;
 
 public class SchedulerReport extends DataReport {
@@ -42,9 +42,9 @@ public class SchedulerReport extends DataReport {
                     try {
                         Field field = clazz.getDeclaredField("task");
                         field.setAccessible(true);
-                        return Optional.fromNullable(field);
+                        return Optional.ofNullable(field);
                     } catch (NoSuchFieldException ignored) {
-                        return Optional.absent();
+                        return Optional.empty();
                     }
                 }
             });
@@ -81,8 +81,7 @@ public class SchedulerReport extends DataReport {
                     return res == null ? null : res.getClass();
                 }
             }
-        } catch (IllegalAccessException ignored) {
-        } catch (NoClassDefFoundError ignored) {
+        } catch (IllegalAccessException | NoClassDefFoundError ignored) {
         }
 
         return null;

worldguard-bukkit/src/main/java/com/sk89q/worldguard/bukkit/util/report/ServerReport.java

@@ -19,8 +19,7 @@
 
 package com.sk89q.worldguard.bukkit.util.report;
 
-import com.sk89q.worldguard.bukkit.BukkitUtil;
-import com.sk89q.worldguard.util.report.DataReport;
+import com.sk89q.worldedit.util.report.DataReport;
 import org.bukkit.Bukkit;
 import org.bukkit.Server;
 
@@ -31,11 +30,14 @@ public class ServerReport extends DataReport {
 
         Server server = Bukkit.getServer();
 
-        append("Server ID", server.getServerId());
-        append("Server Name", server.getServerName());
+        try {
+            append("Server ID", server.getServerId());
+            append("Server Name", server.getServerName());
+        } catch (NoSuchMethodError ignored) {
+        }
         append("Bukkit Version", server.getBukkitVersion());
         append("Implementation", server.getVersion());
-        append("Player Count", "%d/%d", BukkitUtil.getOnlinePlayers().size(), server.getMaxPlayers());
+        append("Player Count", "%d/%d", Bukkit.getOnlinePlayers().size(), server.getMaxPlayers());
 
         append("Server Class Source", server.getClass().getProtectionDomain().getCodeSource().getLocation());