Update WorldGuard for CommandBook 3

Fixes WORLDGUARD-4161.

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

.travis.yml

@@ -1,4 +1,5 @@
 language: java
+dist: trusty
 jdk:
   - oraclejdk8
 notifications:

CHANGELOG.md

@@ -1,5 +1,87 @@
 # Changelog
 
+## 7.0.1
+* Add `/rg toggle-bypass` command which temporarily turns off region bypassing until used again.
+* More improvements to `/rg flag` and `/rg flags` commands.
+* Fix some checks for adding owners to unclaimed regions.
+* Fix an issue with time-/weather-lock flags when logging in to a region with the flag set.
+* Fix cause tracking in vehicles (incl. breaking lilypads in a boat)
+* Use async teleports on Paper.
+* Include hopper minecarts in the ignore hoppers config setting.
+* Add sugar cane and cacti to the crop-growth flag. Bamboo is also included pending Spigot throwing an event for it.
+* Specifically track when players ignite creepers with flint and steel.
+* Fix fuzziness when using bonemeal near a protected region.
+* Fix color codes not applying in greeting, etc flags when placed after a newline (\n).
+* Add applicable region information to `/wg report`.
+* Fix pistons flag not applying to sticky pistons pulling blocks.
+* Add some custom metrics for bStats.
+* Everything in the RC/beta changelog below.
+
+## 7.0.1 RC 2 (inc. beta 1)
+* Due to breaking changes in important Bukkit API, this is not compatible with MC 1.13!
+* Update to MC 1.14. Adds protection for new blocks, etc.
+* To allow players to read from lecterns, but not take the book, flag interact allow, and then flag chest-access -g nonmembers deny.
+* Add ravager-grief flag.
+* Fix overprotection of unsaddled pigs with the ride flag.
+* Fix lava fire defaulting to off (won't change existing configs).
+* Fix damaged/chipped anvils not respecting use flag like regular anvils.
+* Add on-equip blacklist event. Note that it is overprotective due to deficiencies in Bukkit API.
+* Update WorldEdit CUI when using /rg select.
+* Add config option to disable villagers getting zapped into witches. ("weather.disable-villager-witchification")
+* Add entity support to interact-whitelist config option (use the Material of the corresponding item).
+* Fix vehicle-place protecting the rails at the very top of region boundaries incorrectly.
+* Fix for emptying buckets on waterloggable blocks.
+* Whitelist all player -> player interactions (previously was spammy in pvp).
+* Fix sleep flag not protecting against explosions in nether/end.
+* Add config for the teleport-on-void to reset fall distance.
+* Fix config options taking material lists requiring "minecraft:" namespace.
+* Fix disallowed-lightning-blocks situationally not working.
+* Fix errors that occurred when plugins used falling block entities with non-item materials.
+* Add special support for Paper servers (papermc.io): Paper's API allows us to track who launched fireworks.
+* Fireworks are now protected by default. On Paper servers, members can use them by default (to deal damage), 
+on non-Paper servers, flag firework-damage allow to revert to old behavior (everyone can deal damage with fireworks by default).
+* Misc performance enhancements for Paper servers.
+* Add 'regions.use-paper-entity-origin' as an experimental setting (default off) for Paper servers. Enabling it will make non-player entities be treated as members of the place they spawned, instead of their current location when flags are checked.
+
+## 7.0.0
+* Added support for MC 1.13, dropped support for previous versions.
+* Added lots of interactive text in e.g. `/rg info` command.
+* Added `/rg flags` command which allows viewing and interactively setting all flags on a region.
+* Large behind-the-scenes changes to WorldGuard's API (developers, see https://worldguard.enginehub.org/en/latest/developer/)
+* Places that used numeric block ids (e.g. blacklist) should now use Minecraft's new string IDs.
+* Fix various interactions with NPCs and region protection.
+* Sponge-simulation now destroys kelp and seagrass, and de-waterlogs blocks.
+* Added an option to block conduit effects.
+* Fix using newlines in string flags such as greeting and farewell.
+* Add item-frame-rotation flag.
+* Ender chests no longer require chest-access (since they don't have inventories).
+* Add kelp to vine-growth flag/config.
+* Add block-trampling flag (for turtle eggs and farmland).
+* Add snowman-trails flag.
+* Track potion area-of-effect cloud causes for pvp etc. protection.
+* Add confirmation to /stoplag command.
+* Forcefully eject players from vehicles trying to force their way into entry deny regions (and out of exit deny).
+* Fix removing child regions when removing a region with children.
+* Fix some over-protectiveness of pistons.
+* Chat and command flags (send-/receive- and allowed-/blocked-) now respect deny-message flag.
+* Misc fixes.
+
+## 6.2.2
+* Added support for MC 1.12.
+* Changed flower pots to fall under the build flag.
+* Fix heal flag not functioning.
+* Add option to allow Forge clients with host-keys setting.
+* Add mobs.block-armor-stand-destroy config.
+* Add firework-damage flag.
+* Add config option to ignore hopper checks.
+* Misc fixes.
+
+## 6.2
+* Added support for MC 1.11.
+* Add a custom flag and session API (for developers, see https://worldguard.enginehub.org/en/latest/developer/)
+* Add a config option to ensure location flags (teleport, spawn) are inside their region.
+* Misc fixes.
+
 ## 6.1.2
 * Added support for new blocks in 1.8, 1.9, and 1.10.
 * Added protection from nether portals being created in protected region (enable via config `nether-portal-protection`).

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

HEADER.txt

@@ -0,0 +1,16 @@
+WorldGuard, a suite of tools for Minecraft
+Copyright (C) sk89q <http://www.sk89q.com>
+Copyright (C) WorldGuard team and contributors
+
+This program is free software: you can redistribute it and/or modify it
+under the terms of the GNU Lesser General Public License as published by the
+Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License
+for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this program. If not, see <http://www.gnu.org/licenses/>.

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,46 @@
-# ![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).
+
+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://ci.enginehub.org/app/rest/builds/buildType:bt11,branch:master/statusIcon.svg)](http://ci.enginehub.org/viewType.html?buildTypeId=bt11&guest=1)
+* [End-user documentation](https://worldguard.enginehub.org/en/latest/)

build.gradle

@@ -1,131 +0,0 @@
-println """
-*******************************************
- You are building WorldGuard! 
-
- If you encounter trouble:
- 1) Read COMPILING.md if you haven't yet
- 2) Try running 'build' in a separate Gradle run
- 3) Use gradlew and not gradle
- 4) If you still need help, ask on IRC! irc.esper.net #sk89q
-
- Output files will be in [subproject]/build/libs
-*******************************************
-"""
-
-buildscript {
-    repositories {
-        mavenCentral()
-        maven { url = "https://oss.sonatype.org/content/repositories/snapshots/" }
-        jcenter()
-    }
-
-    configurations.all {
-        resolutionStrategy {
-            force 'com.google.guava:guava:17.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'
-    }
-}
-
-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 = ""
-
-if (!project.hasProperty("gitCommitHash")) {
-    try {
-        def repo = org.ajoberstar.grgit.Grgit.open(project.file('.'))
-        ext.gitCommitHash = repo.head().abbreviatedId
-    } catch (Exception e) {
-        ext.gitCommitHash = "no_git_id"
-    }
-}
-
-subprojects {
-    apply plugin: 'java'
-    apply plugin: 'maven'
-    apply plugin: 'checkstyle'
-    apply plugin: 'com.github.johnrengelman.shadow'
-    apply plugin: 'com.jfrog.artifactory-upload'
-
-    group = 'com.sk89q.worldguard'
-    version = '7.0.0-SNAPSHOT'
-    ext.internalVersion = version + ";" + gitCommitHash
-
-    sourceCompatibility = 1.8
-    targetCompatibility = 1.8
-
-    checkstyle.configFile = new File(rootProject.projectDir, "config/checkstyle/checkstyle.xml")
-
-    repositories {
-        mavenCentral()
-        maven { url "http://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" }
-    }
-
-    if (JavaVersion.current().isJava8Compatible()) {
-        // Java 8 turns on doclint which we fail
-        tasks.withType(Javadoc) {
-            options.addStringOption('Xdoclint:none', '-quiet')
-        }
-    }
-
-    task sourcesJar(type: Jar, dependsOn: classes) {
-        classifier = 'sources'
-        from sourceSets.main.allSource
-    }
-
-    task javadocJar(type: Jar, dependsOn: javadoc) {
-        classifier = 'javadoc'
-        from javadoc.destinationDir
-    }
-
-    artifacts {
-        archives jar
-        archives sourcesJar
-        archives javadocJar
-    }
-
-    build.dependsOn(checkstyleMain)
-    build.dependsOn(checkstyleTest)
-    build.dependsOn(sourcesJar)
-    build.dependsOn(javadocJar)
-
-    shadowJar {
-        classifier 'dist'
-        dependencies {
-            include(dependency('org.khelekore:prtree:1.5.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
-            }
-        }
-    }
-}

build.gradle.kts

@@ -0,0 +1,26 @@
+import org.ajoberstar.grgit.Grgit
+
+logger.lifecycle("""
+*******************************************
+ You are building WorldGuard!
+ If you encounter trouble:
+ 1) Try running 'build' in a separate Gradle run
+ 2) Use gradlew and not gradle
+ 3) If you still need help, ask on Discord! https://discord.gg/enginehub
+
+ Output files will be in [subproject]/build/libs
+*******************************************
+""")
+
+applyRootArtifactoryConfig()
+
+if (!project.hasProperty("gitCommitHash")) {
+    apply(plugin = "org.ajoberstar.grgit")
+    ext["gitCommitHash"] = try {
+        (ext["grgit"] as Grgit?)?.head()?.abbreviatedId
+    } catch (e: Exception) {
+        logger.warn("Error getting commit hash", e)
+
+        "no_git_id"
+    }
+}

buildSrc/build.gradle.kts

@@ -0,0 +1,19 @@
+plugins {
+    `kotlin-dsl`
+    kotlin("jvm") version embeddedKotlinVersion
+}
+
+repositories {
+    jcenter()
+    gradlePluginPortal()
+}
+
+dependencies {
+    implementation(gradleApi())
+    implementation("gradle.plugin.net.minecrell:licenser:0.4.1")
+    implementation("org.ajoberstar.grgit:grgit-gradle:3.1.1")
+    implementation("com.github.jengelman.gradle.plugins:shadow:5.1.0")
+    implementation("net.ltgt.apt-eclipse:net.ltgt.apt-eclipse.gradle.plugin:0.21")
+    implementation("net.ltgt.apt-idea:net.ltgt.apt-idea.gradle.plugin:0.21")
+    implementation("org.jfrog.buildinfo:build-info-extractor-gradle:4.9.7")
+}

buildSrc/src/main/kotlin/ArtifactoryConfig.kt

@@ -0,0 +1,40 @@
+import org.gradle.api.Project
+import org.gradle.kotlin.dsl.apply
+import org.gradle.kotlin.dsl.configure
+import org.gradle.kotlin.dsl.named
+import org.jfrog.gradle.plugin.artifactory.dsl.ArtifactoryPluginConvention
+import org.jfrog.gradle.plugin.artifactory.task.ArtifactoryTask
+
+private const val ARTIFACTORY_CONTEXT_URL = "artifactory_contextUrl"
+private const val ARTIFACTORY_USER = "artifactory_user"
+private const val ARTIFACTORY_PASSWORD = "artifactory_password"
+
+fun Project.applyRootArtifactoryConfig() {
+    if (!project.hasProperty(ARTIFACTORY_CONTEXT_URL)) ext[ARTIFACTORY_CONTEXT_URL] = "http://localhost"
+    if (!project.hasProperty(ARTIFACTORY_USER)) ext[ARTIFACTORY_USER] = "guest"
+    if (!project.hasProperty(ARTIFACTORY_PASSWORD)) ext[ARTIFACTORY_PASSWORD] = ""
+
+    apply(plugin = "com.jfrog.artifactory")
+    configure<ArtifactoryPluginConvention> {
+        setContextUrl("${project.property(ARTIFACTORY_CONTEXT_URL)}")
+        clientConfig.publisher.run {
+            repoKey = when {
+                "${project.version}".contains("SNAPSHOT") -> "libs-snapshot-local"
+                else -> "libs-release-local"
+            }
+            username = "${project.property(ARTIFACTORY_USER)}"
+            password = "${project.property(ARTIFACTORY_PASSWORD)}"
+            isMaven = true
+            isIvy = false
+        }
+    }
+    tasks.named<ArtifactoryTask>("artifactoryPublish") {
+        isSkip = true
+    }
+}
+
+fun Project.applyCommonArtifactoryConfig() {
+    val named = tasks.named<ArtifactoryTask>("artifactoryPublish") {
+        publishConfigs("archives")
+    }
+}

buildSrc/src/main/kotlin/CommonConfig.kt

@@ -0,0 +1,18 @@
+import org.gradle.api.Project
+import org.gradle.kotlin.dsl.repositories
+
+fun Project.applyCommonConfiguration() {
+    group = rootProject.group
+    version = rootProject.version
+
+    repositories {
+        mavenCentral()
+        maven { url = uri("https://maven.sk89q.com/repo/") }
+        maven { url = uri("https://oss.sonatype.org/content/repositories/snapshots/") }
+    }
+    configurations.all {
+        resolutionStrategy {
+            cacheChangingModulesFor(5, "minutes")
+        }
+    }
+}

buildSrc/src/main/kotlin/GradleExtras.kt

@@ -0,0 +1,12 @@
+import org.gradle.api.Project
+import org.gradle.api.plugins.ExtraPropertiesExtension
+import org.gradle.api.plugins.JavaPluginConvention
+import org.gradle.api.tasks.SourceSetContainer
+import org.gradle.kotlin.dsl.getByType
+import org.gradle.kotlin.dsl.the
+
+val Project.ext: ExtraPropertiesExtension
+    get() = extensions.getByType()
+
+val Project.sourceSets: SourceSetContainer
+    get() = the<JavaPluginConvention>().sourceSets

buildSrc/src/main/kotlin/LibsConfig.kt

@@ -0,0 +1,96 @@
+import com.github.jengelman.gradle.plugins.shadow.tasks.ShadowJar
+import org.gradle.api.Project
+import org.gradle.api.artifacts.ModuleDependency
+import org.gradle.api.internal.HasConvention
+import org.gradle.api.plugins.MavenRepositoryHandlerConvention
+import org.gradle.api.tasks.Upload
+import org.gradle.api.tasks.bundling.Jar
+import org.gradle.kotlin.dsl.apply
+import org.gradle.kotlin.dsl.get
+import org.gradle.kotlin.dsl.getPlugin
+import org.gradle.kotlin.dsl.invoke
+import org.gradle.kotlin.dsl.register
+
+fun Project.applyLibrariesConfiguration() {
+    applyCommonConfiguration()
+    apply(plugin = "java-base")
+    apply(plugin = "maven")
+    apply(plugin = "com.github.johnrengelman.shadow")
+    apply(plugin = "com.jfrog.artifactory")
+
+    configurations {
+        create("shade")
+        getByName("archives").extendsFrom(getByName("default"))
+    }
+
+    group = "${rootProject.group}.worldguard-libs"
+
+    tasks.register<ShadowJar>("jar") {
+        configurations = listOf(project.configurations["shade"])
+        archiveClassifier.set("")
+
+        dependencies {
+            exclude(dependency("com.google.code.findbugs:jsr305:1.3.9"))
+        }
+
+        relocate("com.sk89q.squirrelid", "com.sk89q.worldguard.util.profile")
+    }
+    val altConfigFiles = { artifactType: String ->
+        val deps = configurations["shade"].incoming.dependencies
+                .filterIsInstance<ModuleDependency>()
+                .map { it.copy() }
+                .map { dependency ->
+                    dependency.artifact {
+                        name = dependency.name
+                        type = artifactType
+                        extension = "jar"
+                        classifier = artifactType
+                    }
+                    dependency
+                }
+
+        files(configurations.detachedConfiguration(*deps.toTypedArray())
+                .resolvedConfiguration.lenientConfiguration.artifacts
+                .filter { it.classifier == artifactType }
+                .map { zipTree(it.file) })
+    }
+    tasks.register<Jar>("sourcesJar") {
+        from({
+            altConfigFiles("sources")
+        })
+        val filePattern = Regex("(.*)com/sk89q/squirrelid((?:/|$).*)")
+        val textPattern = Regex("com\\.sk89q\\.squirrelid")
+        eachFile {
+            filter {
+                it.replaceFirst(textPattern, "com.sk89q.worldguard.util.profile")
+            }
+            path = path.replaceFirst(filePattern, "$1com/sk89q/worldguard/util/profile$2")
+        }
+        archiveClassifier.set("sources")
+    }
+
+    tasks.named("assemble").configure {
+        dependsOn("jar", "sourcesJar")
+    }
+
+    artifacts {
+        val jar = tasks.named("jar")
+        add("default", jar) {
+            builtBy(jar)
+        }
+        val sourcesJar = tasks.named("sourcesJar")
+        add("archives", sourcesJar) {
+            builtBy(sourcesJar)
+        }
+    }
+
+    tasks.register<Upload>("install") {
+        configuration = configurations["archives"]
+        (repositories as HasConvention).convention.getPlugin<MavenRepositoryHandlerConvention>().mavenInstaller {
+            pom.version = project.version.toString()
+            pom.artifactId = project.name
+        }
+    }
+
+    applyCommonArtifactoryConfig()
+}

buildSrc/src/main/kotlin/PlatformConfig.kt

@@ -0,0 +1,119 @@
+import com.github.jengelman.gradle.plugins.shadow.tasks.ShadowJar
+import net.minecrell.gradle.licenser.LicenseExtension
+import org.gradle.api.JavaVersion
+import org.gradle.api.Project
+import org.gradle.api.plugins.JavaPluginConvention
+import org.gradle.api.plugins.quality.CheckstyleExtension
+import org.gradle.api.tasks.bundling.Jar
+import org.gradle.api.tasks.javadoc.Javadoc
+import org.gradle.api.tasks.testing.Test
+import org.gradle.external.javadoc.CoreJavadocOptions
+import org.gradle.kotlin.dsl.apply
+import org.gradle.kotlin.dsl.configure
+import org.gradle.kotlin.dsl.dependencies
+import org.gradle.kotlin.dsl.get
+import org.gradle.kotlin.dsl.getByName
+import org.gradle.kotlin.dsl.named
+import org.gradle.kotlin.dsl.register
+import org.gradle.kotlin.dsl.withType
+
+fun Project.applyPlatformAndCoreConfiguration() {
+    applyCommonConfiguration()
+    apply(plugin = "java")
+    apply(plugin = "eclipse")
+    apply(plugin = "idea")
+    apply(plugin = "maven")
+    apply(plugin = "checkstyle")
+    apply(plugin = "com.github.johnrengelman.shadow")
+    apply(plugin = "com.jfrog.artifactory")
+    apply(plugin = "net.minecrell.licenser")
+
+    ext["internalVersion"] = "$version;${rootProject.ext["gitCommitHash"]}"
+
+    configure<JavaPluginConvention> {
+        sourceCompatibility = JavaVersion.VERSION_1_8
+        targetCompatibility = JavaVersion.VERSION_1_8
+    }
+
+    configure<CheckstyleExtension> {
+        configFile = rootProject.file("config/checkstyle/checkstyle.xml")
+        toolVersion = "7.6.1"
+    }
+
+    tasks.withType<Test>().configureEach {
+        useJUnit()
+    }
+
+    dependencies {
+        "testCompile"("junit:junit:${Versions.JUNIT}")
+        // TODO switch to jupiter - doesn't support abstract test classes so tests need rewriting
+        //"testImplementation"("org.junit.jupiter:junit-jupiter-api:${Versions.JUNIT}")
+        //"testRuntime"("org.junit.jupiter:junit-jupiter-engine:${Versions.JUNIT}")
+    }
+
+    // Java 8 turns on doclint which we fail
+    tasks.withType<Javadoc>().configureEach {
+        (options as CoreJavadocOptions).addStringOption("Xdoclint:none", "-quiet")
+    }
+
+    tasks.register<Jar>("javadocJar") {
+        dependsOn("javadoc")
+        archiveClassifier.set("javadoc")
+        from(tasks.getByName<Javadoc>("javadoc").destinationDir)
+    }
+
+    tasks.named("assemble").configure {
+        dependsOn("javadocJar")
+    }
+
+    artifacts {
+        add("archives", tasks.named("jar"))
+        add("archives", tasks.named("javadocJar"))
+    }
+
+    if (name == "worldguard-core" || name == "worldguard-bukkit") {
+        tasks.register<Jar>("sourcesJar") {
+            dependsOn("classes")
+            archiveClassifier.set("sources")
+            from(sourceSets["main"].allSource)
+        }
+
+        artifacts {
+            add("archives", tasks.named("sourcesJar"))
+        }
+        tasks.named("assemble").configure {
+            dependsOn("sourcesJar")
+        }
+    }
+
+    tasks.named("check").configure {
+        dependsOn("checkstyleMain", "checkstyleTest")
+    }
+
+    applyCommonArtifactoryConfig()
+
+    configure<LicenseExtension> {
+        header = rootProject.file("HEADER.txt")
+        include("**/*.java")
+    }
+
+}
+
+fun Project.applyShadowConfiguration() {
+    tasks.named<ShadowJar>("shadowJar") {
+        archiveClassifier.set("dist")
+        dependencies {
+            include(project(":worldguard-libs:core"))
+            //include(project(":worldguard-libs:${project.name.replace("worldguard-", "")}"))
+            include(project(":worldguard-core"))
+
+            relocate("org.flywaydb", "com.sk89q.worldguard.internal.flywaydb") {
+                include(dependency("org.flywaydb:flyway-core:3.0"))
+            }
+            relocate("com.sk89q.squirrelid", "com.sk89q.worldguard.util.profile")
+        }
+        exclude("GradleStart**")
+        exclude(".cache")
+        exclude("LICENSE*")
+    }
+}

buildSrc/src/main/kotlin/Versions.kt

@@ -0,0 +1,7 @@
+object Versions {
+//    const val PISTON = "0.4.3"
+//    const val AUTO_VALUE = "1.6.5"
+    const val WORLDEDIT = "7.1.0-SNAPSHOT"
+    const val JUNIT = "4.11"
+    const val SQUIRRELID = "0.2.0"
+}

config/checkstyle/checkstyle.xml

@@ -1,22 +1,28 @@
 <?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="${config_loc}/suppressions.xml"/>
+  </module>
+
+
+
   <module name="TreeWalker">
     <!-- Important basics -->
     <!-- <module name="PackageDeclaration"/> Unlikely that we would miss this in a PR -->
     <module name="OuterTypeFilename"/> <!-- TypeName -> TypeName.java -->
 
     <!--
-    Control package usage, so people don't insert Bukkit into 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="${config_loc}/import-control.xml"/>
     </module>
 
     <!-- Code -->
@@ -27,7 +33,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 -->
@@ -55,10 +60,4 @@
     <!-- <module name="TypeName"/> Unlikely that we would miss this in a PR -->
   </module>
 
-  <!-- Require the header, something that many people forget and we hate to fix -->
-  <!-- You should configure the header in your IDE -->
-  <module name="Header">
-    <property name="headerFile" value="config/checkstyle/header.txt"/>
-    <property name="fileExtensions" value="java"/>
-  </module>
 </module>

config/checkstyle/header.txt

@@ -1,18 +0,0 @@
-/*
- * WorldGuard, a suite of tools for Minecraft
- * Copyright (C) sk89q <http://www.sk89q.com>
- * Copyright (C) WorldGuard team and contributors
- *
- * This program is free software: you can redistribute it and/or modify it
- * under the terms of the GNU Lesser General Public License as published by the
- * Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License
- * for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */

config/checkstyle/import-control.xml

@@ -8,27 +8,29 @@
   <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.enginehub.piston"/>
+
+    <subpackage name="util.profile.resolver">
+      <allow pkg="org.bukkit"/>
+      <allow pkg="io.papermc.lib"/>
+      <allow pkg="com.destroystokyo.paper"/>
+    </subpackage>
 
     <subpackage name="bukkit">
       <allow pkg="org.bukkit"/>
-      <allow pkg="net.minecraft.server"/>
+      <allow pkg="org.bstats.bukkit"/>
+      <allow pkg="io.papermc.lib"/>
+      <allow pkg="com.destroystokyo.paper"/>
     </subpackage>
 
-    <subpackage name="sponge">
-      <allow pkg="org.spongepowered"/>
-      <allow pkg="com.flowpowered"/>
-    </subpackage>
-
-    <subpackage name="forge">
-      <allow pkg="net.minecraft"/>
-      <allow pkg="net.minecraftforge"/>
-    </subpackage>
   </subpackage>
 
 </import-control>

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

@@ -0,0 +1,2 @@
+group=com.sk89q.worldguard
+version=7.0.2-SNAPSHOT

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.5.1-all.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 +0,0 @@
-rootProject.name = 'worldguard'
-
-include 'worldguard-core', 'worldguard-sponge', 'worldguard-legacy'

settings.gradle.kts

@@ -0,0 +1,7 @@
+rootProject.name = "worldguard"
+
+include("worldguard-libs")
+include("worldguard-libs:core")
+include("worldguard-core")
+//include("worldguard-libs:bukkit")
+include("worldguard-bukkit")

worldguard-bukkit/build.gradle.kts

@@ -0,0 +1,75 @@
+import com.github.jengelman.gradle.plugins.shadow.tasks.ShadowJar
+import org.gradle.api.internal.HasConvention
+
+plugins {
+    id("java-library")
+    id("net.ltgt.apt-eclipse")
+    id("net.ltgt.apt-idea")
+}
+
+applyPlatformAndCoreConfiguration()
+applyShadowConfiguration()
+
+repositories {
+    mavenLocal()
+    maven {
+        name = "paper"
+        url = uri("https://papermc.io/repo/repository/maven-public/")
+    }
+    maven {
+        name = "bstats"
+        url = uri("https://repo.codemc.org/repository/maven-public")
+    }
+}
+
+dependencies {
+    "compile"(project(":worldguard-core"))
+    //"compile"(project(":worldguard-libs:bukkit"))
+    "api"("com.destroystokyo.paper:paper-api:1.15-R0.1-SNAPSHOT")
+    "implementation"("io.papermc:paperlib:1.0.2")
+    "api"("com.sk89q.worldedit:worldedit-bukkit:${Versions.WORLDEDIT}") { isTransitive = false }
+    "implementation"("com.sk89q:commandbook:3.0-SNAPSHOT") { isTransitive = false }
+    "implementation"("org.bstats:bstats-bukkit:1.5")
+}
+
+tasks.named<Upload>("install") {
+    (repositories as HasConvention).convention.getPlugin<MavenRepositoryHandlerConvention>().mavenInstaller {
+        pom.whenConfigured {
+            dependencies.firstOrNull { dep ->
+                dep!!.withGroovyBuilder {
+                    getProperty("groupId") == "com.destroystokyo.paper" && getProperty("artifactId") == "paper-api"
+                }
+            }?.withGroovyBuilder {
+                setProperty("groupId", "org.bukkit")
+                setProperty("artifactId", "bukkit")
+            }
+        }
+    }
+}
+
+tasks.named<Copy>("processResources") {
+    filesMatching("plugin.yml") {
+        expand("internalVersion" to project.ext["internalVersion"])
+    }
+}
+
+tasks.named<Jar>("jar") {
+    manifest {
+        attributes("Implementation-Version" to project.version)
+    }
+}
+
+tasks.named<ShadowJar>("shadowJar") {
+    dependencies {
+        relocate("org.bstats", "com.sk89q.worldguard.bukkit.bstats") {
+            include(dependency("org.bstats:bstats-bukkit:1.5"))
+        }
+        relocate ("io.papermc.lib", "com.sk89q.worldguard.bukkit.paperlib") {
+            include(dependency("io.papermc:paperlib:1.0.2"))
+        }
+    }
+}
+
+tasks.named("assemble").configure {
+    dependsOn("shadowJar")
+}

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

@@ -0,0 +1,123 @@
+/*
+ * 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.Collection;
+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;
+    boolean extraStats;
+
+    /**
+     * Construct the object.
+     *
+     * @param plugin The plugin instance
+     */
+    public BukkitConfigurationManager(WorldGuardPlugin plugin) {
+        super();
+        this.plugin = plugin;
+    }
+
+    public Collection<BukkitWorldConfiguration> getWorldConfigs() {
+        return worlds.values();
+    }
+
+    @Override
+    public void load() {
+        super.load();
+        this.extraStats = getConfig().getBoolean("custom-metrics-charts", true);
+    }
+
+    @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);
+        }
+        getConfig().save();
+    }
+
+    /**
+     * 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,212 @@
+/*
+ * 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 io.papermc.lib.PaperLib;
+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() {
+        org.bukkit.WeatherType playerWeather = getPlayer().getPlayerWeather();
+        return playerWeather == null ? null : playerWeather == org.bukkit.WeatherType.CLEAR ? WeatherTypes.CLEAR : WeatherTypes.RAIN;
+    }
+
+    @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 void resetFallDistance() {
+        getPlayer().setFallDistance(0);
+    }
+
+    @Override
+    public void teleport(Location location, String successMessage, String failMessage) {
+        PaperLib.teleportAsync(getPlayer(), BukkitAdapter.adapt(location))
+                .thenApply(success -> {
+                    if (success) {
+                        print(successMessage);
+                    } else {
+                        printError(failMessage);
+                    }
+                    return success;
+                });
+    }
+
+    @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,132 @@
+/*
+ * 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);
+    }
+
+    public void shutdown() {
+        container.shutdown();
+    }
+
+    @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,154 +58,33 @@ 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 boundedLocationFlags;
-    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;
-
+    public boolean usePaperEntityOrigin;
     /* 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;
 
@@ -215,66 +99,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;
         }
@@ -290,52 +119,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;
@@ -351,13 +143,16 @@ 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);
+
+        usePaperEntityOrigin = getBoolean("regions.use-paper-entity-origin", 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);
 
@@ -368,6 +163,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;
@@ -380,16 +176,16 @@ 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);
         blockLighter = getBoolean("ignition.block-lighter", false);
 
-        preventLavaFire = getBoolean("fire.disable-lava-fire-spread", true);
+        preventLavaFire = getBoolean("fire.disable-lava-fire-spread", false);
         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);
@@ -407,6 +203,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);
@@ -422,6 +219,7 @@ public class WorldConfiguration {
         teleportOnSuffocation = getBoolean("player-damage.teleport-on-suffocation", false);
         disableVoidDamage = getBoolean("player-damage.disable-void-damage", false);
         teleportOnVoid = getBoolean("player-damage.teleport-on-void-falling", false);
+        safeFallOnVoid = getBoolean("player-damage.reset-fall-on-void-teleport", false);
         disableExplosionDamage = getBoolean("player-damage.disable-explosion-damage", false);
         disableMobDamage = getBoolean("player-damage.disable-mob-damage", false);
         disableDeathMessages = getBoolean("player-damage.disable-death-messages", false);
@@ -432,11 +230,12 @@ 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);
         disablePigZap = getBoolean("weather.disable-pig-zombification", false);
+        disableVillagerZap = getBoolean("weather.disable-villager-witchification", false);
         disableCreeperPower = getBoolean("weather.disable-powered-creepers", false);
         alwaysRaining = getBoolean("weather.always-raining", false);
         alwaysThundering = getBoolean("weather.always-thundering", false);
@@ -450,29 +249,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());
                 }
             }
@@ -482,14 +283,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);
             }
@@ -520,7 +319,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
@@ -530,7 +329,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();
@@ -571,7 +371,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.");
@@ -587,47 +387,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);
@@ -637,19 +429,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,279 @@
+/*
+ * 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.bukkit.BukkitWorld;
+import com.sk89q.worldedit.math.BlockVector3;
+import com.sk89q.worldedit.util.formatting.text.TextComponent;
+import com.sk89q.worldedit.util.report.ReportList;
+import com.sk89q.worldedit.world.World;
+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.protection.regions.ProtectedCuboidRegion;
+import com.sk89q.worldguard.protection.regions.ProtectedRegion;
+import com.sk89q.worldguard.util.profile.resolver.PaperProfileService;
+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 com.sk89q.worldguard.util.profile.cache.ProfileCache;
+import com.sk89q.worldguard.util.profile.resolver.BukkitPlayerService;
+import com.sk89q.worldguard.util.profile.resolver.CacheForwardingService;
+import com.sk89q.worldguard.util.profile.resolver.CombinedProfileService;
+import com.sk89q.worldguard.util.profile.resolver.HttpRepositoryService;
+import com.sk89q.worldguard.util.profile.resolver.ProfileService;
+import io.papermc.lib.PaperLib;
+import org.bukkit.Bukkit;
+import org.bukkit.entity.Player;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.permissions.Permissible;
+
+import javax.annotation.Nullable;
+import java.nio.file.Path;
+import java.util.ArrayList;
+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.shutdown();
+    }
+
+    @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());
+    }
+
+    @Override
+    public ProfileService createProfileService(ProfileCache profileCache) {
+        List<ProfileService> services = new ArrayList<>();
+        if (PaperLib.isPaper()) {
+            // Paper has a shared cache
+            services.add(PaperProfileService.getInstance());
+        } else {
+            services.add(BukkitPlayerService.getInstance());
+        }
+        services.add(HttpRepositoryService.forMinecraft());
+        return new CacheForwardingService(new CombinedProfileService(services),
+                profileCache);
+    }
+
+    @Nullable
+    @Override
+    public ProtectedRegion getSpawnProtection(World world) {
+        if (world instanceof BukkitWorld) {
+            org.bukkit.World bWorld = ((BukkitWorld) world).getWorld();
+            if (bWorld.getUID().equals(Bukkit.getServer().getWorlds().get(0).getUID())) {
+                int radius = Bukkit.getServer().getSpawnRadius();
+                if (radius > 0) {
+                    BlockVector3 spawnLoc = BukkitAdapter.asBlockVector(bWorld.getSpawnLocation());
+                    return new ProtectedCuboidRegion("__spawn_protection__",
+                            spawnLoc.subtract(radius, 0, radius).withY(world.getMinimumPoint().getY()),
+                            spawnLoc.add(radius, 0, radius).withY(world.getMaxY()));
+                }
+            }
+        }
+        return null;
+    }
+}

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

@@ -0,0 +1,536 @@
+/*
+ * 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.google.common.collect.Streams;
+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.blacklist.Blacklist;
+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.commands.GeneralCommands;
+import com.sk89q.worldguard.commands.ProtectionCommands;
+import com.sk89q.worldguard.commands.ToggleCommands;
+import com.sk89q.worldguard.protection.flags.Flag;
+import com.sk89q.worldguard.protection.flags.Flags;
+import com.sk89q.worldguard.protection.flags.registry.SimpleFlagRegistry;
+import com.sk89q.worldguard.protection.managers.RegionManager;
+import com.sk89q.worldguard.protection.managers.storage.RegionDriver;
+import com.sk89q.worldguard.protection.managers.storage.file.DirectoryYamlDriver;
+import com.sk89q.worldguard.protection.managers.storage.sql.SQLDriver;
+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.HashMap;
+import java.util.Map;
+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
+        final Metrics metrics = new Metrics(this);
+        if (metrics.isEnabled() && platform.getGlobalStateManager().extraStats) {
+            setupCustomCharts(metrics);
+        }
+    }
+
+    private void setupCustomCharts(Metrics metrics) {
+        metrics.addCustomChart(new Metrics.SingleLineChart("region_count", () ->
+                platform.getRegionContainer().getLoaded().stream().mapToInt(RegionManager::size).sum()));
+        metrics.addCustomChart(new Metrics.SimplePie("region_driver", () -> {
+            RegionDriver driver = platform.getGlobalStateManager().selectedRegionStoreDriver;
+            return driver instanceof DirectoryYamlDriver ? "yaml" : driver instanceof SQLDriver ? "sql" : "unknown";
+        }));
+        metrics.addCustomChart(new Metrics.DrilldownPie("blacklist", () -> {
+            int empty = 0;
+            Map<String, Integer> blacklistMap = new HashMap<>();
+            Map<String, Integer> whitelistMap = new HashMap<>();
+            for (BukkitWorldConfiguration worldConfig : platform.getGlobalStateManager().getWorldConfigs()) {
+                Blacklist blacklist = worldConfig.getBlacklist();
+                if (blacklist != null && !blacklist.isEmpty()) {
+                    Map<String, Integer> target = blacklist.isWhitelist() ? whitelistMap : blacklistMap;
+                    int floor = ((blacklist.getItemCount() - 1) / 10) * 10;
+                    String range = floor >= 100 ? "101+" : (floor + 1) + " - " + (floor + 10);
+                    target.merge(range, 1, Integer::sum);
+                } else {
+                    empty++;
+                }
+            }
+            Map<String, Map<String, Integer>> blacklistCounts = new HashMap<>();
+            Map<String, Integer> emptyMap = new HashMap<>();
+            emptyMap.put("empty", empty);
+            blacklistCounts.put("empty", emptyMap);
+            blacklistCounts.put("blacklist", blacklistMap);
+            blacklistCounts.put("whitelist", whitelistMap);
+            return blacklistCounts;
+        }));
+        metrics.addCustomChart(new Metrics.SimplePie("chest_protection", () ->
+                "" + platform.getGlobalStateManager().getWorldConfigs().stream().anyMatch(cfg -> cfg.signChestProtection)));
+        metrics.addCustomChart(new Metrics.SimplePie("build_permissions", () ->
+                "" + platform.getGlobalStateManager().getWorldConfigs().stream().anyMatch(cfg -> cfg.buildPermissions)));
+
+        metrics.addCustomChart(new Metrics.SimplePie("custom_flags", () ->
+                "" + (WorldGuard.getInstance().getFlagRegistry().size() > Flags.INBUILT_FLAGS.size())));
+        metrics.addCustomChart(new Metrics.SimplePie("custom_handlers", () ->
+                "" + (WorldGuard.getInstance().getPlatform().getSessionManager().customHandlersRegistered())));
+    }
+
+    @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

@@ -22,8 +22,19 @@ package com.sk89q.worldguard.bukkit.cause;
 import com.google.common.base.Joiner;
 import com.google.common.collect.Sets;
 import com.sk89q.worldguard.bukkit.internal.WGMetadata;
+import io.papermc.lib.PaperLib;
+import org.bukkit.Bukkit;
 import org.bukkit.block.Block;
-import org.bukkit.entity.*;
+import org.bukkit.entity.AreaEffectCloud;
+import org.bukkit.entity.Creature;
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.EntityType;
+import org.bukkit.entity.Firework;
+import org.bukkit.entity.Player;
+import org.bukkit.entity.Projectile;
+import org.bukkit.entity.TNTPrimed;
+import org.bukkit.entity.Tameable;
+import org.bukkit.entity.Vehicle;
 import org.bukkit.metadata.Metadatable;
 
 import javax.annotation.Nullable;
@@ -31,6 +42,7 @@ import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
 import java.util.Set;
+import java.util.UUID;
 
 import static com.google.common.base.Preconditions.checkNotNull;
 
@@ -233,7 +245,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) {
@@ -249,8 +261,19 @@ public final class Cause {
                         addAll(((TNTPrimed) o).getSource());
                     } else if (o instanceof Projectile) {
                         addAll(((Projectile) o).getShooter());
+                    } else if (o instanceof Firework && PaperLib.isPaper()) {
+                        UUID spawningUUID = ((Firework) o).getSpawningEntity();
+                        if (spawningUUID != null) {
+                            Entity spawningEntity = Bukkit.getEntity(spawningUUID);
+                            if (spawningEntity != null) {
+                                addAll(spawningEntity);
+                            }
+                        }
                     } else if (o instanceof Vehicle) {
-                        addAll(((Vehicle) o).getPassenger());
+                        ((Vehicle) o).getPassengers().forEach(this::addAll);
+                    } 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,27 @@
 
 package com.sk89q.worldguard.bukkit.event.block;
 
-import com.google.common.base.Predicate;
+import static com.google.common.base.Preconditions.checkArgument;
+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.block.BlockState;
 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.Function;
+import java.util.function.Predicate;
+import java.util.stream.Collectors;
 
-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
@@ -43,7 +48,8 @@ import static com.google.common.base.Preconditions.checkNotNull;
 abstract class AbstractBlockEvent extends DelegateEvent implements BulkEvent {
 
     private final World world;
-    private final List<Block> blocks;
+    private List<Block> blocks;
+    private final List<BlockState> blockStates;
     private final Material effectiveMaterial;
 
     protected AbstractBlockEvent(@Nullable Event originalEvent, Cause cause, World world, List<Block> blocks, Material effectiveMaterial) {
@@ -54,6 +60,18 @@ abstract class AbstractBlockEvent extends DelegateEvent implements BulkEvent {
         this.world = world;
         this.blocks = blocks;
         this.effectiveMaterial = effectiveMaterial;
+        this.blockStates = null;
+    }
+
+    protected AbstractBlockEvent(@Nullable Event originalEvent, Cause cause, World world, List<BlockState> blocks) {
+        super(originalEvent, cause);
+        checkNotNull(world);
+        checkNotNull(blocks);
+        checkArgument(!blocks.isEmpty());
+        this.world = world;
+        this.blockStates = blocks;
+        this.blocks = null;
+        this.effectiveMaterial = blocks.get(0).getType();
     }
 
     protected AbstractBlockEvent(@Nullable Event originalEvent, Cause cause, Block block) {
@@ -65,7 +83,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;
     }
@@ -85,6 +103,9 @@ abstract class AbstractBlockEvent extends DelegateEvent implements BulkEvent {
      * @return a list of affected block
      */
     public List<Block> getBlocks() {
+        if (blocks == null) { // be lazy here because we often don't call getBlocks internally, just filter
+            blocks = blockStates.stream().map(BlockState::getBlock).collect(Collectors.toList());
+        }
         return blocks;
     }
 
@@ -98,15 +119,21 @@ abstract class AbstractBlockEvent extends DelegateEvent implements BulkEvent {
      * @return true if one or more blocks were filtered out
      */
     public boolean filter(Predicate<Location> predicate, boolean cancelEventOnFalse) {
-        boolean hasRemoval = false;
+        return blocks == null
+                ? filterInternal(blockStates, BlockState::getLocation, predicate, cancelEventOnFalse)
+                : filterInternal(blocks, Block::getLocation, predicate, cancelEventOnFalse);
+    }
 
-        Iterator<Block> it = blocks.iterator();
+    private <B> boolean filterInternal(List<B> blockList, Function<B, Location> locFunc,
+                                       Predicate<Location> predicate, boolean cancelEventOnFalse) {
+        boolean hasRemoval = false;
+        Iterator<B> it = blockList.iterator();
         while (it.hasNext()) {
-            if (!predicate.apply(it.next().getLocation())) {
+            if (!predicate.test(locFunc.apply(it.next()))) {
                 hasRemoval = true;
 
                 if (cancelEventOnFalse) {
-                    getBlocks().clear();
+                    blockList.clear();
                     setCancelled(true);
                     break;
                 } else {
@@ -114,7 +141,6 @@ abstract class AbstractBlockEvent extends DelegateEvent implements BulkEvent {
                 }
             }
         }
-
         return hasRemoval;
     }
 
@@ -146,7 +172,7 @@ abstract class AbstractBlockEvent extends DelegateEvent implements BulkEvent {
 
     @Override
     public Result getResult() {
-        if (blocks.isEmpty()) {
+        if (blocks == null ? blockStates.isEmpty() : blocks.isEmpty()) {
             return Result.DENY;
         }
         return super.getResult();

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

@@ -24,6 +24,7 @@ import org.bukkit.Location;
 import org.bukkit.Material;
 import org.bukkit.World;
 import org.bukkit.block.Block;
+import org.bukkit.block.BlockState;
 import org.bukkit.event.Event;
 import org.bukkit.event.HandlerList;
 
@@ -40,6 +41,10 @@ public class PlaceBlockEvent extends AbstractBlockEvent {
 
     private static final HandlerList handlers = new HandlerList();
 
+    public PlaceBlockEvent(@Nullable Event originalEvent, Cause cause, World world, List<BlockState> blocks) {
+        super(originalEvent, cause, world, blocks);
+    }
+
     public PlaceBlockEvent(@Nullable Event originalEvent, Cause cause, World world, List<Block> blocks, Material effectiveMaterial) {
         super(originalEvent, cause, world, blocks, effectiveMaterial);
     }

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

@@ -0,0 +1,148 @@
+/*
+ * WorldGuard, a suite of tools for Minecraft
+ * Copyright (C) sk89q <http://www.sk89q.com>
+ * Copyright (C) WorldGuard team and contributors
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published by the
+ * Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License
+ * for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package com.sk89q.worldguard.bukkit.listener;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+
+import com.sk89q.worldedit.bukkit.BukkitAdapter;
+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 com.sk89q.worldguard.bukkit.cause.Cause;
+import com.sk89q.worldguard.config.ConfigurationManager;
+import com.sk89q.worldguard.config.WorldConfiguration;
+import com.sk89q.worldguard.domains.Association;
+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.regions.RegionQuery;
+import io.papermc.lib.PaperLib;
+import org.bukkit.Location;
+import org.bukkit.OfflinePlayer;
+import org.bukkit.block.Block;
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.Player;
+import org.bukkit.event.Listener;
+
+/**
+ * Abstract listener to ease creation of listeners.
+ */
+class AbstractListener implements Listener {
+
+    private final WorldGuardPlugin plugin;
+
+    /**
+     * Construct the listener.
+     *
+     * @param plugin an instance of WorldGuardPlugin
+     */
+    public AbstractListener(WorldGuardPlugin plugin) {
+        checkNotNull(plugin);
+        this.plugin = plugin;
+    }
+
+    /**
+     * Register events.
+     */
+    public void registerEvents() {
+        plugin.getServer().getPluginManager().registerEvents(this, plugin);
+    }
+
+    /**
+     * Get the plugin.
+     *
+     * @return the plugin
+     */
+    protected WorldGuardPlugin getPlugin() {
+        return plugin;
+    }
+
+    /**
+     * Get the global configuration.
+     *
+     * @return the configuration
+     */
+    protected static ConfigurationManager getConfig() {
+        return WorldGuard.getInstance().getPlatform().getGlobalStateManager();
+    }
+
+    /**
+     * Get the world configuration given a world.
+     *
+     * @param world The world to get the configuration for.
+     * @return The configuration for {@code world}
+     */
+    protected static WorldConfiguration getWorldConfig(World world) {
+        return getConfig().get(world);
+    }
+
+    /**
+     * Get the world configuration given a player.
+     *
+     * @param player The player to get the wold from
+     * @return The {@link WorldConfiguration} for the player's world
+     */
+    protected static WorldConfiguration getWorldConfig(LocalPlayer player) {
+        return getWorldConfig((World) player.getExtent());
+    }
+
+    /**
+     * Return whether region support is enabled.
+     *
+     * @param world the world
+     * @return true if region support is enabled
+     */
+    protected static boolean isRegionSupportEnabled(World world) {
+        return getWorldConfig(world).useRegions;
+    }
+
+    protected RegionAssociable createRegionAssociable(Cause cause) {
+        Object rootCause = cause.getRootCause();
+
+        if (!cause.isKnown()) {
+            return Associables.constant(Association.NON_MEMBER);
+        } else if (rootCause instanceof Player) {
+            return getPlugin().wrapPlayer((Player) rootCause);
+        } else if (rootCause instanceof OfflinePlayer) {
+            return getPlugin().wrapOfflinePlayer((OfflinePlayer) rootCause);
+        } else if (rootCause instanceof Entity) {
+            RegionQuery query = WorldGuard.getInstance().getPlatform().getRegionContainer().createQuery();
+            final Entity entity = (Entity) rootCause;
+            Location loc;
+            if (PaperLib.isPaper()
+                    && ((BukkitWorldConfiguration) getWorldConfig(BukkitAdapter.adapt(entity.getWorld()))).usePaperEntityOrigin) {
+                loc = entity.getOrigin();
+                if (loc == null) {
+                    loc = entity.getLocation();
+                }
+            } else {
+                loc = entity.getLocation();
+            }
+            return new DelayedRegionOverlapAssociation(query, BukkitAdapter.adapt(loc));
+        } else if (rootCause instanceof Block) {
+            RegionQuery query = WorldGuard.getInstance().getPlatform().getRegionContainer().createQuery();
+            return new DelayedRegionOverlapAssociation(query, BukkitAdapter.adapt(((Block) rootCause).getLocation()));
+        } else {
+            return Associables.constant(Association.NON_MEMBER);
+        }
+    }
+}

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

@@ -0,0 +1,395 @@
+/*
+ * WorldGuard, a suite of tools for Minecraft
+ * Copyright (C) sk89q <http://www.sk89q.com>
+ * Copyright (C) WorldGuard team and contributors
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published by the
+ * Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License
+ * for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package com.sk89q.worldguard.bukkit.listener;
+
+import com.sk89q.worldedit.bukkit.BukkitAdapter;
+import com.sk89q.worldguard.LocalPlayer;
+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.ItemEquipBlacklistEvent;
+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;
+import com.sk89q.worldguard.bukkit.event.block.UseBlockEvent;
+import com.sk89q.worldguard.bukkit.event.entity.DestroyEntityEvent;
+import com.sk89q.worldguard.bukkit.event.entity.SpawnEntityEvent;
+import com.sk89q.worldguard.bukkit.event.inventory.UseItemEvent;
+import com.sk89q.worldguard.bukkit.util.Materials;
+import 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.EventHandler;
+import org.bukkit.event.block.BlockDispenseArmorEvent;
+import org.bukkit.event.block.BlockDispenseEvent;
+import org.bukkit.event.inventory.InventoryAction;
+import org.bukkit.event.inventory.InventoryClickEvent;
+import org.bukkit.event.inventory.InventoryCreativeEvent;
+import org.bukkit.event.inventory.InventoryDragEvent;
+import org.bukkit.event.inventory.InventoryType;
+import org.bukkit.event.player.PlayerDropItemEvent;
+import org.bukkit.event.player.PlayerItemHeldEvent;
+import org.bukkit.inventory.Inventory;
+import org.bukkit.inventory.ItemStack;
+
+import static com.sk89q.worldguard.bukkit.BukkitUtil.createTarget;
+
+/**
+ * Handle events that need to be processed by the blacklist.
+ */
+public class BlacklistListener extends AbstractListener {
+
+    /**
+     * Construct the listener.
+     *
+     * @param plugin an instance of WorldGuardPlugin
+     */
+    public BlacklistListener(WorldGuardPlugin plugin) {
+        super(plugin);
+    }
+
+    @EventHandler(ignoreCancelled = true)
+    public void onBreakBlock(final BreakBlockEvent event) {
+        final Player player = event.getCause().getFirstPlayer();
+
+        if (player == null) {
+            return;
+        }
+
+        final LocalPlayer localPlayer = getPlugin().wrapPlayer(player);
+        final WorldConfiguration wcfg = getWorldConfig(localPlayer);
+
+        // Blacklist guard
+        if (wcfg.getBlacklist() == null) {
+            return;
+        }
+
+        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.getInventory().getItemInMainHand())), false, false)) {
+                return false;
+            }
+
+            return true;
+        });
+    }
+
+    @EventHandler(ignoreCancelled = true)
+    public void onPlaceBlock(final PlaceBlockEvent event) {
+        Player player = event.getCause().getFirstPlayer();
+
+        if (player == null) {
+            return;
+        }
+
+        final LocalPlayer localPlayer = getPlugin().wrapPlayer(player);
+        final WorldConfiguration wcfg = getWorldConfig(localPlayer);
+
+        // Blacklist guard
+        if (wcfg.getBlacklist() == null) {
+            return;
+        }
+
+        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) {
+        Player player = event.getCause().getFirstPlayer();
+
+        if (player == null) {
+            return;
+        }
+
+        final LocalPlayer localPlayer = getPlugin().wrapPlayer(player);
+        final WorldConfiguration wcfg = getWorldConfig(localPlayer);
+
+        // Blacklist guard
+        if (wcfg.getBlacklist() == null) {
+            return;
+        }
+
+        event.filter(target -> wcfg.getBlacklist().check(new BlockInteractBlacklistEvent(
+                localPlayer, BukkitAdapter.asBlockVector(target), createTarget(target.getBlock(), event.getEffectiveMaterial())), false, false));
+    }
+
+    @EventHandler(ignoreCancelled = true)
+    public void onSpawnEntity(SpawnEntityEvent event) {
+        Player player = event.getCause().getFirstPlayer();
+
+        if (player == null) {
+            return;
+        }
+
+        LocalPlayer localPlayer = getPlugin().wrapPlayer(player);
+        WorldConfiguration wcfg = getWorldConfig(localPlayer);
+
+        // Blacklist guard
+        if (wcfg.getBlacklist() == null) {
+            return;
+        }
+
+        Material material = Materials.getRelatedMaterial(event.getEffectiveType());
+        if (material != null) {
+            if (!wcfg.getBlacklist().check(new ItemUseBlacklistEvent(
+                    localPlayer, BukkitAdapter.asBlockVector(event.getTarget()), createTarget(material)), false, false)) {
+                event.setCancelled(true);
+            }
+        }
+    }
+
+    @EventHandler(ignoreCancelled = true)
+    public void onDestroyEntity(DestroyEntityEvent event) {
+        Player player = event.getCause().getFirstPlayer();
+
+        if (player == null) {
+            return;
+        }
+
+        LocalPlayer localPlayer = getPlugin().wrapPlayer(player);
+        Entity target = event.getEntity();
+        WorldConfiguration wcfg = getWorldConfig(localPlayer);
+
+        // Blacklist guard
+        if (wcfg.getBlacklist() == null) {
+            return;
+        }
+
+        if (target instanceof Item) {
+            Item item = (Item) target;
+            if (!wcfg.getBlacklist().check(
+                    new ItemAcquireBlacklistEvent(localPlayer,
+                            BukkitAdapter.asBlockVector(target.getLocation()), createTarget(item.getItemStack())), false, true)) {
+                event.setCancelled(true);
+                return;
+            }
+        }
+
+        Material material = Materials.getRelatedMaterial(target.getType());
+        if (material != null) {
+            // Not really a block but we only have one on-break blacklist event
+            if (!wcfg.getBlacklist().check(new BlockBreakBlacklistEvent(
+                    localPlayer, BukkitAdapter.asBlockVector(event.getTarget()), createTarget(material)), false, false)) {
+                event.setCancelled(true);
+            }
+        }
+    }
+
+    @EventHandler(ignoreCancelled = true)
+    public void onUseItem(UseItemEvent event) {
+        Player player = event.getCause().getFirstPlayer();
+
+        if (player == null) {
+            return;
+        }
+
+        LocalPlayer localPlayer = getPlugin().wrapPlayer(player);
+        ItemStack target = event.getItemStack();
+        WorldConfiguration wcfg = getWorldConfig(localPlayer);
+
+        // Blacklist guard
+        if (wcfg.getBlacklist() == null) {
+            return;
+        }
+
+        if (!wcfg.getBlacklist().check(new ItemUseBlacklistEvent(
+                localPlayer, BukkitAdapter.asBlockVector(player.getLocation()), createTarget(target)), false, false)) {
+            event.setCancelled(true);
+            return;
+        }
+
+        if (Materials.isArmor(target.getType()) && !wcfg.getBlacklist().check(new ItemEquipBlacklistEvent(
+                localPlayer, BukkitAdapter.asBlockVector(player.getLocation()), createTarget(target)), false, false)) {
+            event.setCancelled(true);
+        }
+    }
+
+    @EventHandler(ignoreCancelled = true)
+    public void onPlayerDropItem(PlayerDropItemEvent event) {
+        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()),
+                            BukkitAdapter.asBlockVector(ci.getLocation()), createTarget(ci.getItemStack())), false, false)) {
+                event.setCancelled(true);
+            }
+        }
+    }
+
+    @EventHandler(ignoreCancelled = true)
+    public void onBlockDispense(BlockDispenseEvent event) {
+        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, BukkitAdapter.asBlockVector(event.getBlock().getLocation()),
+                    createTarget(event.getItem())), false, false)) {
+                event.setCancelled(true);
+            }
+        }
+    }
+
+    @EventHandler(ignoreCancelled = true)
+    public void onInventoryClick(InventoryClickEvent event) {
+        HumanEntity entity = event.getWhoClicked();
+        if (!(entity instanceof Player)) return;
+        Inventory inventory = event.getInventory();
+        ItemStack item = event.getCurrentItem();
+
+        if (item != null && inventory.getHolder() != null) {
+            Player player = (Player) entity;
+            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, BukkitAdapter.asBlockVector(entity.getLocation()), createTarget(item)), false, false)) {
+                event.setCancelled(true);
+
+                if (inventory.getHolder().equals(player)) {
+                    event.setCurrentItem(null);
+                }
+            }
+
+
+            ItemStack equipped = checkEquipped(event);
+            if (equipped != null) {
+                if (wcfg.getBlacklist() != null && !wcfg.getBlacklist().check(new ItemEquipBlacklistEvent(localPlayer,
+                        BukkitAdapter.asBlockVector(player.getLocation()), createTarget(equipped)), false, false)) {
+                    event.setCancelled(true);
+                }
+            }
+        }
+    }
+
+    @EventHandler(ignoreCancelled = true)
+    public void onInventoryDrag(InventoryDragEvent event) {
+        HumanEntity entity = event.getWhoClicked();
+        if (!(entity instanceof Player)) return;
+        if (event.getInventory().getType() != InventoryType.PLAYER
+                && event.getInventory().getType() != InventoryType.CRAFTING) return;
+        if (event.getRawSlots().stream().anyMatch(i -> i >= 5 && i <= 8)) { // dropped on armor slots
+            Player player = (Player) entity;
+            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 ItemEquipBlacklistEvent(localPlayer,
+                    BukkitAdapter.asBlockVector(player.getLocation()), createTarget(event.getOldCursor())), false, false)) {
+                event.setCancelled(true);
+            }
+        }
+    }
+
+    private ItemStack checkEquipped(InventoryClickEvent event) {
+        final Inventory clickedInventory = event.getClickedInventory();
+        if (event.getSlotType() == InventoryType.SlotType.ARMOR) {
+            switch (event.getAction()) {
+                case PLACE_ONE:
+                case PLACE_SOME:
+                case PLACE_ALL:
+                case SWAP_WITH_CURSOR:
+                    final ItemStack cursor = event.getCursor();
+                    if (cursor != null) {
+                        return cursor;
+                    }
+                case HOTBAR_SWAP:
+                    return clickedInventory == null ? null : clickedInventory.getItem(event.getHotbarButton());
+                default:
+                    break;
+            }
+        } else if (clickedInventory != null && clickedInventory.getType() == InventoryType.PLAYER
+                && event.getView().getTopInventory().getType() == InventoryType.PLAYER
+                && event.getAction() == InventoryAction.MOVE_TO_OTHER_INVENTORY) {
+            return event.getCurrentItem();
+        }
+        return null;
+    }
+
+    @EventHandler(ignoreCancelled = true)
+    public void onInventoryCreative(InventoryCreativeEvent event) {
+        HumanEntity entity = event.getWhoClicked();
+        ItemStack item = event.getCursor();
+
+        if (item.getType() != Material.AIR && entity instanceof Player) {
+            Player player = (Player) entity;
+            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, BukkitAdapter.asBlockVector(entity.getLocation()), createTarget(item)), false, false)) {
+                event.setCancelled(true);
+            }
+        }
+    }
+
+    @EventHandler(ignoreCancelled = true)
+    public void onPlayerItemHeld(PlayerItemHeldEvent event) {
+        Player player = event.getPlayer();
+        Inventory inventory = player.getInventory();
+        ItemStack item = inventory.getItem(event.getNewSlot());
+
+        if (item != null) {
+            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, BukkitAdapter.asBlockVector(player.getLocation()), createTarget(item)), false, false)) {
+                inventory.setItem(event.getNewSlot(), null);
+            }
+        }
+    }
+
+    @EventHandler(ignoreCancelled = true)
+    public void onBlockDispenseArmor(BlockDispenseArmorEvent event) {
+        if (!(event.getTargetEntity() instanceof Player)) return;
+        Player player = ((Player) event.getTargetEntity());
+        ItemStack stack = event.getItem();
+
+        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 ItemEquipBlacklistEvent(localPlayer, BukkitAdapter.asBlockVector(player.getLocation()), createTarget(stack)), false, true)) {
+            event.setCancelled(true);
+        }
+    }
+}

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

@@ -19,22 +19,23 @@
 
 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.bukkit.WorldGuardPlugin;
 import com.sk89q.worldguard.bukkit.event.entity.DamageEntityEvent;
 import com.sk89q.worldguard.bukkit.event.inventory.UseItemEvent;
 import com.sk89q.worldguard.bukkit.util.Entities;
+import com.sk89q.worldguard.config.ConfigurationManager;
 import org.bukkit.ChatColor;
 import org.bukkit.Material;
+import org.bukkit.entity.Arrow;
 import org.bukkit.entity.Player;
 import org.bukkit.entity.SpectralArrow;
-import org.bukkit.entity.TippedArrow;
 import org.bukkit.event.EventHandler;
 import org.bukkit.event.entity.EntityDamageByEntityEvent;
 import org.bukkit.inventory.ItemStack;
 import org.bukkit.inventory.meta.PotionMeta;
-import org.bukkit.potion.Potion;
 import org.bukkit.potion.PotionEffect;
 import org.bukkit.potion.PotionEffectType;
 
@@ -57,15 +58,15 @@ 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)) {
                         blockedEffect = PotionEffectType.GLOWING;
                     }
-                } else if (originalEvent.getDamager() instanceof TippedArrow) {
-                    TippedArrow tippedArrow = (TippedArrow) originalEvent.getDamager();
+                } else if (originalEvent.getDamager() instanceof Arrow) {
+                    Arrow tippedArrow = (Arrow) originalEvent.getDamager();
                     PotionEffectType baseEffect = tippedArrow.getBasePotionData().getType().getEffectType();
                     if (wcfg.blockPotions.contains(baseEffect)) {
                         blockedEffect = baseEffect;
@@ -95,28 +96,16 @@ 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
-        boolean oldPotions = false;
-        try {
-            if (item.getType() != Material.POTION
-                    && item.getType() != Material.SPLASH_POTION
-                    && item.getType() != Material.LINGERING_POTION) {
-                return;
-            }
-        } catch (NoSuchFieldError ignored) {
-            // PotionMeta technically has been around since 1.7, so the code below
-            // *should* work still. we just have different materials now.
-            if (item.getType() != Material.POTION) {
-                return;
-            }
-            oldPotions = true;
+        if (item.getType() != Material.POTION
+                && item.getType() != Material.SPLASH_POTION
+                && item.getType() != Material.LINGERING_POTION) {
+            return;
         }
 
-
         if (!wcfg.blockPotions.isEmpty()) {
             PotionEffectType blockedEffect = null;
 
@@ -147,13 +136,8 @@ public class BlockedPotionsListener extends AbstractListener {
 
                 if (player != null) {
                     if (getPlugin().hasPermission(player, "worldguard.override.potions")) {
-                        boolean isSplash = false;
-                        try {
-                            isSplash = (!oldPotions && (item.getType() == Material.SPLASH_POTION || item.getType() == Material.LINGERING_POTION));
-                        } catch (NoSuchFieldError ignored) {
-                        }
-                        isSplash |= (oldPotions && (Potion.fromItemStack(item).isSplash()));
-                        if (isSplash && wcfg.blockPotionsAlways) {
+                        if (wcfg.blockPotionsAlways && (item.getType() == Material.SPLASH_POTION
+                                || item.getType() == Material.LINGERING_POTION)) {
                             player.sendMessage(ChatColor.RED + "Sorry, potions with " +
                                     blockedEffect.getName() + " can't be thrown, " +
                                     "even if you have a permission to bypass it, " +

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,17 @@
 
 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.Tag;
 import org.bukkit.entity.Player;
 import org.bukkit.event.EventHandler;
 import org.bukkit.event.block.SignChangeEvent;
@@ -58,23 +59,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 +82,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 +90,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 +108,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 +116,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 ("[Lock]".equalsIgnoreCase(event.getLine(0))) {
+                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 (!Tag.STANDING_SIGNS.isTagged(event.getBlock().getType())) {
                     player.sendMessage(ChatColor.RED
                             + "The [Lock] sign must be a sign post, not a wall sign.");
 
@@ -170,7 +153,7 @@ public class ChestProtectionListener extends AbstractListener {
                     return;
                 }
 
-                if (!event.getLine(1).equalsIgnoreCase(player.getName())) {
+                if (!player.getName().equalsIgnoreCase(event.getLine(1))) {
                     player.sendMessage(ChatColor.RED
                             + "The first owner line must be your name.");
 
@@ -179,10 +162,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 || Tag.STANDING_SIGNS.isTagged(below)) {
                     player.sendMessage(ChatColor.RED
                             + "That is not a safe block that you're putting this sign on.");
 
@@ -196,7 +179,7 @@ public class ChestProtectionListener extends AbstractListener {
                         + "A chest or double chest above is now protected.");
             }
         } else if (!wcfg.disableSignChestProtectionCheck) {
-            if (event.getLine(0).equalsIgnoreCase("[Lock]")) {
+            if ("[Lock]".equalsIgnoreCase(event.getLine(0))) {
                 player.sendMessage(ChatColor.RED
                         + "WorldGuard's sign chest protection is disabled.");
 

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,11 @@
 
 package com.sk89q.worldguard.bukkit.listener;
 
-import com.google.common.collect.Lists;
-import com.sk89q.worldguard.bukkit.WorldConfiguration;
+import static com.sk89q.worldguard.bukkit.cause.Cause.create;
+
+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,45 +46,104 @@ 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.DoubleChest;
 import org.bukkit.block.Hopper;
-import org.bukkit.entity.*;
+import org.bukkit.block.PistonMoveReaction;
+import org.bukkit.block.data.Waterlogged;
+import org.bukkit.block.data.type.Dispenser;
+import org.bukkit.entity.AreaEffectCloud;
+import org.bukkit.entity.Creeper;
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.EntityType;
+import org.bukkit.entity.FallingBlock;
+import org.bukkit.entity.Firework;
+import org.bukkit.entity.Item;
+import org.bukkit.entity.ItemFrame;
+import org.bukkit.entity.LivingEntity;
+import org.bukkit.entity.Painting;
+import org.bukkit.entity.Player;
+import org.bukkit.entity.ThrownPotion;
+import org.bukkit.entity.minecart.HopperMinecart;
 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.BlockFertilizeEvent;
+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.PlayerTakeLecternBookEvent;
+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.Dispenser;
-import org.bukkit.material.MaterialData;
-import org.bukkit.material.PistonExtensionMaterial;
-import org.bukkit.material.SpawnEgg;
 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 java.util.stream.Collectors;
 
 public class EventAbstractionListener extends AbstractListener {
 
@@ -101,20 +163,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) {
-        }
-        try {
-            getPlugin().getServer().getPluginManager().registerEvents(new LingeringPotionListener(), getPlugin());
-        } catch (NoClassDefFoundError ignored) {
-        }
-    }
-
     //-------------------------------------------------------------------------
     // Block break / place
     //-------------------------------------------------------------------------
@@ -130,12 +178,14 @@ public class EventAbstractionListener extends AbstractListener {
 
     @EventHandler(ignoreCancelled = true)
     public void onBlockMultiPlace(BlockMultiPlaceEvent event) {
-        List<Block> blocks = new ArrayList<Block>();
-        for (BlockState bs : event.getReplacedBlockStates()) {
-            blocks.add(bs.getBlock());
+        List<Block> placed = event.getReplacedBlockStates().stream().map(BlockState::getBlock).collect(Collectors.toList());
+        int origAmt = placed.size();
+        PlaceBlockEvent delegateEvent = new PlaceBlockEvent(event, create(event.getPlayer()), event.getBlock().getWorld(),
+                placed, event.getBlockPlaced().getType());
+        Events.fireToCancel(event, delegateEvent);
+        if (origAmt != placed.size()) {
+            event.setCancelled(true);
         }
-        Events.fireToCancel(event, new PlaceBlockEvent(event, create(event.getPlayer()),
-                event.getBlock().getWorld(), blocks, event.getBlock().getType()));
     }
 
     @EventHandler(ignoreCancelled = true)
@@ -144,7 +194,7 @@ public class EventAbstractionListener extends AbstractListener {
         BlockState previousState = event.getBlockReplacedState();
 
         // Some blocks, like tall grass and fire, get replaced
-        if (previousState.getType() != Material.AIR) {
+        if (previousState.getType() != Material.AIR && previousState.getType() != event.getBlockReplacedState().getType()) {
             Events.fireToCancel(event, new BreakBlockEvent(event, create(event.getPlayer()), previousState.getLocation(), previousState.getType()));
         }
 
@@ -166,7 +216,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),
@@ -196,39 +246,41 @@ public class EventAbstractionListener extends AbstractListener {
     @EventHandler(ignoreCancelled = true)
     public void onStructureGrowEvent(StructureGrowEvent event) {
         int originalCount = event.getBlocks().size();
-        List<Block> blockList = Lists.transform(event.getBlocks(), new BlockStateAsBlockFunction());
 
         Player player = event.getPlayer();
-        if (player != null) {
-            Events.fireBulkEventToCancel(event, new PlaceBlockEvent(event, create(player), event.getLocation().getWorld(), blockList, Material.AIR));
-        } else {
-            Events.fireBulkEventToCancel(event, new PlaceBlockEvent(event, create(event.getLocation().getBlock()), event.getLocation().getWorld(), blockList, Material.AIR));
-        }
+        Events.fireBulkEventToCancel(event, new PlaceBlockEvent(event,
+                create(player == null ? event.getLocation().getBlock() : player),
+                event.getLocation().getWorld(), event.getBlocks()));
 
         if (!event.isCancelled() && event.getBlocks().size() != originalCount) {
             event.getLocation().getBlock().setType(Material.AIR);
         }
     }
 
-    // TODO: Handle EntityCreatePortalEvent?
-
     @EventHandler(ignoreCancelled = true)
     public void onEntityChangeBlock(EntityChangeBlockEvent event) {
         Block block = event.getBlock();
         Entity entity = event.getEntity();
-        Material to = event.getTo();
-
-        // Forget about Redstone ore, especially since we handle it in INTERACT
-        if (Materials.isRedstoneOre(block.getType()) && Materials.isRedstoneOre(to)) {
-            return;
-        }
+        Material toType = event.getTo();
+        Material fromType = block.getType();
+        Cause cause = create(entity);
 
         // Fire two events: one as BREAK and one as PLACE
-        if (event.getTo() != Material.AIR && event.getBlock().getType() != Material.AIR) {
-            Events.fireToCancel(event, new BreakBlockEvent(event, create(entity), block));
-            Events.fireToCancel(event, new PlaceBlockEvent(event, create(entity), block.getLocation(), to));
+        if (toType != Material.AIR && fromType != Material.AIR) {
+            boolean trample = fromType == Material.FARMLAND && toType == Material.DIRT;
+            BreakBlockEvent breakDelagate = new BreakBlockEvent(event, cause, block);
+            if (trample) {
+                breakDelagate.getRelevantFlags().add(Flags.TRAMPLE_BLOCKS);
+            }
+            if (!Events.fireToCancel(event, breakDelagate)) {
+                PlaceBlockEvent placeDelegate = new PlaceBlockEvent(event, cause, block.getLocation(), toType);
+                if (trample) {
+                    placeDelegate.getRelevantFlags().add(Flags.TRAMPLE_BLOCKS);
+                }
+                Events.fireToCancel(event, placeDelegate);
+            }
         } else {
-            if (event.getTo() == Material.AIR) {
+            if (toType == Material.AIR) {
                 // Track the source so later we can create a proper chain of causes
                 if (entity instanceof FallingBlock) {
                     Cause.trackParentCause(entity, block);
@@ -237,17 +289,18 @@ public class EventAbstractionListener extends AbstractListener {
                     Events.fireToCancel(event, new SpawnEntityEvent(event, create(block), entity));
                 } else {
                     entityBreakBlockDebounce.debounce(
-                            event.getBlock(), event.getEntity(), event, new BreakBlockEvent(event, create(entity), event.getBlock()));
+                            block, event.getEntity(), event, new BreakBlockEvent(event, cause, block));
                 }
             } else {
                 boolean wasCancelled = event.isCancelled();
-                Cause cause = create(entity);
 
-                Events.fireToCancel(event, new PlaceBlockEvent(event, cause, event.getBlock().getLocation(), to));
+                Events.fireToCancel(event, new PlaceBlockEvent(event, cause, block.getLocation(), toType));
 
                 if (event.isCancelled() && !wasCancelled && entity instanceof FallingBlock) {
                     FallingBlock fallingBlock = (FallingBlock) entity;
-                    ItemStack itemStack = new ItemStack(fallingBlock.getMaterial(), 1, fallingBlock.getBlockData());
+                    final Material material = fallingBlock.getBlockData().getMaterial();
+                    if (!material.isItem()) return;
+                    ItemStack itemStack = new ItemStack(material, 1);
                     Item item = block.getWorld().dropItem(fallingBlock.getLocation(), itemStack);
                     item.setVelocity(new Vector());
                     if (Events.fireAndTestCancel(new SpawnEntityEvent(event, create(block, entity), item))) {
@@ -261,11 +314,9 @@ public class EventAbstractionListener extends AbstractListener {
     @EventHandler(ignoreCancelled = true)
     public void onEntityExplode(EntityExplodeEvent event) {
         Entity entity = event.getEntity();
-
         Events.fireBulkEventToCancel(event, new BreakBlockEvent(event, create(entity), event.getLocation().getWorld(), event.blockList(), Material.AIR));
     }
 
-    @SuppressWarnings("deprecation")
     @EventHandler(ignoreCancelled = true)
     public void onBlockPistonRetract(BlockPistonRetractEvent event) {
         if (event.isSticky()) {
@@ -276,15 +327,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()) {
@@ -308,11 +351,16 @@ 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
+                    || existing.getType() == Material.PISTON || existing.getType() == Material.STICKY_PISTON) {
+                    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) {
@@ -336,12 +384,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();
@@ -353,65 +401,85 @@ 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 = hasItemInteraction
+                            || isBlockModifiedOnClick(clicked, event.getAction() == Action.RIGHT_CLICK_BLOCK);
 
-                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);
+                            event.setUseInteractedBlock(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);
                     }
                 }
 
@@ -421,17 +489,22 @@ 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)
+    public void onBlockFertilize(BlockFertilizeEvent event) {
+        Cause cause = create(event.getPlayer(), event.getBlock());
+        Events.fireToCancel(event, new PlaceBlockEvent(event, cause, event.getBlock().getWorld(), event.getBlocks()));
     }
 
     @EventHandler(ignoreCancelled = true)
@@ -470,7 +543,15 @@ public class EventAbstractionListener extends AbstractListener {
     @EventHandler(ignoreCancelled = true)
     public void onPlayerBucketEmpty(PlayerBucketEmptyEvent event) {
         Player player = event.getPlayer();
-        Block blockAffected = event.getBlockClicked().getRelative(event.getBlockFace());
+        Block blockClicked = event.getBlockClicked();
+        Block blockAffected;
+
+        if (blockClicked.getBlockData() instanceof Waterlogged) {
+            blockAffected = blockClicked;
+        } else {
+            blockAffected = blockClicked.getRelative(event.getBlockFace());
+        }
+
         boolean allowed = false;
 
         // Milk buckets can't be emptied as of writing
@@ -516,7 +597,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
@@ -530,7 +611,7 @@ public class EventAbstractionListener extends AbstractListener {
         Material toType = to.getType();
 
         // Liquids pass this event when flowing to solid blocks
-        if (toType.isSolid() && Materials.isLiquid(fromType)) {
+        if (Materials.isLiquid(fromType) && toType.isSolid()) {
             return;
         }
 
@@ -562,31 +643,11 @@ 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;
-            case NATURAL:
-            case JOCKEY:
-            case CHUNK_GEN:
-            case SPAWNER:
-            case LIGHTNING:
-            case BUILD_SNOWMAN:
-            case BUILD_IRONGOLEM:
-            case BUILD_WITHER:
-            case VILLAGE_DEFENSE:
-            case VILLAGE_INVASION:
-            case BREEDING:
-            case SLIME_SPLIT:
-            case REINFORCEMENTS:
-            case NETHER_PORTAL:
-            case INFECTION:
-            case CURED:
-            case OCELOT_BABY:
-            case SILVERFISH_BLOCK:
-            case MOUNT:
-            case CUSTOM:
-            case DEFAULT:
+            default:
         }
     }
 
@@ -609,6 +670,15 @@ public class EventAbstractionListener extends AbstractListener {
             if (event.isCancelled() && remover instanceof Player) {
                 playDenyEffect((Player) remover, event.getEntity().getLocation());
             }
+        } else if (event.getCause() == HangingBreakEvent.RemoveCause.EXPLOSION){
+            DestroyEntityEvent destroyEntityEvent = new DestroyEntityEvent(event, Cause.unknown(), event.getEntity());
+            destroyEntityEvent.getRelevantFlags().add(Flags.OTHER_EXPLOSION);
+            if (event.getEntity() instanceof ItemFrame) {
+                destroyEntityEvent.getRelevantFlags().add(Flags.ENTITY_ITEM_FRAME_DESTROY);
+            } else if (event.getEntity() instanceof Painting) {
+                destroyEntityEvent.getRelevantFlags().add(Flags.ENTITY_PAINTING_DESTROY);
+            }
+            Events.fireToCancel(event, destroyEntityEvent);
         }
     }
 
@@ -628,7 +698,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);
             }
@@ -655,7 +730,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));
                 }
             }
         }
@@ -678,11 +753,24 @@ 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));
-        Events.fireToCancel(event, new UseEntityEvent(event, create(player), entity));
+        if (Events.fireToCancel(event, new UseItemEvent(event, create(player), world, item))) {
+            return;
+        }
+        final UseEntityEvent useEntityEvent = new UseEntityEvent(event, create(player), entity);
+        Material matchingItem = Materials.getRelatedMaterial(entity.getType());
+        if (matchingItem != null && hasInteractBypass(world, matchingItem)) {
+            useEntityEvent.setAllowed(true);
+        }
+        if (!Events.fireToCancel(event, useEntityEvent)) {
+            // so this is a hack but CreeperIgniteEvent doesn't actually tell us who, so we need to do it here
+            if (item.getType() == Material.FLINT_AND_STEEL && entity.getType() == EntityType.CREEPER) {
+                Cause.trackParentCause(entity, player);
+            }
+        }
     }
 
     @EventHandler(ignoreCancelled = true)
@@ -699,15 +787,22 @@ public class EventAbstractionListener extends AbstractListener {
         } else if (event instanceof EntityDamageByEntityEvent) {
             EntityDamageByEntityEvent entityEvent = (EntityDamageByEntityEvent) event;
             Entity damager = entityEvent.getDamager();
-            Events.fireToCancel(event, new DamageEntityEvent(event, create(damager), event.getEntity()));
+            final DamageEntityEvent eventToFire = new DamageEntityEvent(event, create(damager), event.getEntity());
+            if (damager instanceof Firework) {
+                eventToFire.getRelevantFlags().add(Flags.FIREWORK_DAMAGE);
+            } else if (damager instanceof Creeper) {
+                eventToFire.getRelevantFlags().add(Flags.CREEPER_EXPLOSION);
+            }
+            Events.fireToCancel(event, eventToFire);
 
             // Item use event with the item in hand
             // Older blacklist handler code used this, although it suffers from
             // race problems
             if (damager instanceof Player) {
-                ItemStack item = ((Player) damager).getItemInHand();
+                // 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));
                 }
             }
@@ -730,8 +825,6 @@ 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?
         }
     }
 
@@ -762,11 +855,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
     //-------------------------------------------------------------------------
@@ -779,24 +867,28 @@ public class EventAbstractionListener extends AbstractListener {
     @EventHandler(ignoreCancelled = true)
     public void onInventoryOpen(InventoryOpenEvent event) {
         InventoryHolder holder = event.getInventory().getHolder();
-        if (holder instanceof BlockState) {
-            Events.fireToCancel(event, new UseBlockEvent(event, create(event.getPlayer()), ((BlockState) holder).getBlock()));
-        } else if (holder instanceof Entity) {
-            if (!(holder instanceof Player)) {
-                Events.fireToCancel(event, new UseEntityEvent(event, create(event.getPlayer()), (Entity) holder));
-            }
-        }
+        if (holder instanceof Entity && holder == event.getPlayer()) return;
+
+        handleInventoryHolderUse(event, create(event.getPlayer()), holder);
     }
 
     @EventHandler(ignoreCancelled = true)
     public void onInventoryMoveItem(InventoryMoveItemEvent event) {
         final InventoryHolder causeHolder = event.getInitiator().getHolder();
-        InventoryHolder sourceHolder = event.getSource().getHolder();
-        InventoryHolder targetHolder = event.getDestination().getHolder();
+
+        if (causeHolder instanceof Hopper
+                && getWorldConfig(BukkitAdapter.adapt((((Hopper) causeHolder).getWorld()))).ignoreHopperMoveEvents) {
+            return;
+        } else if (causeHolder instanceof HopperMinecart
+                && getWorldConfig(BukkitAdapter.adapt((((HopperMinecart) causeHolder).getWorld()))).ignoreHopperMoveEvents) {
+            return;
+        }
 
         Entry entry;
 
         if ((entry = moveItemDebounce.tryDebounce(event)) != null) {
+            InventoryHolder sourceHolder = event.getSource().getHolder();
+            InventoryHolder targetHolder = event.getDestination().getHolder();
             Cause cause;
 
             if (causeHolder instanceof Entity) {
@@ -807,19 +899,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());
             }
@@ -848,7 +936,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);
@@ -867,35 +955,79 @@ 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);
+    }
+
+    @EventHandler(ignoreCancelled = true)
+    public void onTakeLecternBook(PlayerTakeLecternBookEvent event) {
+        final UseBlockEvent useEvent = new UseBlockEvent(event, create(event.getPlayer()), event.getLectern().getBlock());
+        useEvent.getRelevantFlags().add(Flags.CHEST_ACCESS);
+        Events.fireToCancel(event, useEvent);
+    }
+
     /**
      * 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
@@ -905,125 +1037,113 @@ public class EventAbstractionListener extends AbstractListener {
 
         // 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));
+            EntityType entityType = Materials.getRelatedEntity(item.getType());
+            if (entityType == null) {
+                entityType = EntityType.MINECART;
+            }
+            Events.fireToCancel(event, new SpawnEntityEvent(event, cause, clicked.getLocation().add(0.5, 0, 0.5), entityType));
             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() == Materials.END_CRYSTAL) { /*&& placed.getType() == Material.BEDROCK) {*/ // in vanilla you can only place them on bedrock but who knows what plugins will add
+        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));
-            }
+        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;
         }
 
-        // 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));
-            }
+        // handle water/lava placement
+        if (item != null && (item.getType() == Material.WATER_BUCKET || item.getType() == Material.LAVA_BUCKET)) {
+            Events.fireToCancel(event, new PlaceBlockEvent(event, cause, placed.getLocation(),
+                    item.getType() == Material.WATER_BUCKET ? Material.WATER : Material.LAVA));
             return;
         }
     }
 
-    @SuppressWarnings("unchecked")
     private static <T extends Event & Cancellable> void handleInventoryHolderUse(T originalEvent, Cause cause, InventoryHolder holder) {
         if (originalEvent.isCancelled()) {
             return;
         }
 
         if (holder instanceof Entity) {
-            Events.fireToCancel(originalEvent, new UseEntityEvent(originalEvent, cause, (Entity) holder));
-        } else if (holder instanceof BlockState) {
-            Events.fireToCancel(originalEvent, new UseBlockEvent(originalEvent, cause, ((BlockState) holder).getBlock()));
-        } else if (holder instanceof DoubleChest) {
-            Events.fireToCancel(originalEvent, new UseBlockEvent(originalEvent, cause, (((Chest) ((DoubleChest) holder).getLeftSide()).getBlock())));
-            Events.fireToCancel(originalEvent, new UseBlockEvent(originalEvent, cause, (((Chest) ((DoubleChest) holder).getRightSide()).getBlock())));
+            Entity entity = (Entity) holder;
+            Material mat = Materials.getRelatedMaterial((entity).getType());
+            UseEntityEvent useEntityEvent = new UseEntityEvent(originalEvent, cause, entity);
+            if (mat != null && hasInteractBypass((entity).getWorld(), mat)) {
+                useEntityEvent.setAllowed(true);
+            }
+            Events.fireToCancel(originalEvent, useEntityEvent);
+        } else {
+            if (holder instanceof BlockState) {
+                final BlockState block = (BlockState) holder;
+                final UseBlockEvent useBlockEvent = new UseBlockEvent(originalEvent, cause, block.getBlock());
+                if (hasInteractBypass(block.getWorld(), block.getType())) {
+                    useBlockEvent.setAllowed(true);
+                }
+                Events.fireToCancel(originalEvent, useBlockEvent);
+            } else if (holder instanceof DoubleChest) {
+                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);
+    private static boolean hasInteractBypass(Block block) {
+        return ((BukkitWorldConfiguration) getWorldConfig(BukkitAdapter.adapt(block.getWorld()))).allowAllInteract.test(block);
     }
 
-    private boolean hasInteractBypass(World world, ItemStack item) {
-        return getWorldConfig(world).allowAllInteract.test(item);
+    private static boolean hasInteractBypass(World world, Material material) {
+        return ((BukkitWorldConfiguration) getWorldConfig(BukkitAdapter.adapt(world))).allowAllInteract.test(material);
     }
 
-    private boolean isBlockModifiedOnClick(Block block, boolean rightClick) {
+    private static boolean hasInteractBypass(World world, ItemStack item) {
+        return ((BukkitWorldConfiguration) getWorldConfig(BukkitAdapter.adapt(world))).allowAllInteract.test(item);
+    }
+
+    private static boolean isBlockModifiedOnClick(Block block, boolean rightClick) {
         return Materials.isBlockModifiedOnClick(block.getType(), rightClick) && !hasInteractBypass(block);
     }
 
-    private boolean isItemAppliedToBlock(ItemStack item, Block clicked) {
+    private static boolean isItemAppliedToBlock(ItemStack item, Block clicked) {
         return Materials.isItemAppliedToBlock(item.getType(), clicked.getType())
                 && !hasInteractBypass(clicked)
                 && !hasInteractBypass(clicked.getWorld(), item);
     }
 
-    private void playDenyEffect(Player player, Location location) {
+    private static void playDenyEffect(Player player, Location location) {
         //player.playSound(location, Sound.SUCCESSFUL_HIT, 0.2f, 0.4f);
-        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) {
+            player.playEffect(location, Effect.SMOKE, BlockFace.UP);
         }
     }
 
-    public class LingeringPotionListener implements Listener {
-        @EventHandler(ignoreCancelled = true)
-        public void onLingeringSplash(LingeringPotionSplashEvent event) {
-            AreaEffectCloud aec = event.getAreaEffectCloud();
-            LingeringPotion 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));
-            }
+    private static void playDenyEffect(Location location) {
+        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,17 +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.Entities;
 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;
@@ -41,7 +42,7 @@ import org.bukkit.event.EventPriority;
 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 {
 
@@ -56,42 +57,60 @@ 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) {
             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) {
             if (Materials.isPistonBlock(block.getType())) {
-                event.filter(testState(query, DefaultFlag.PISTONS), false);
+                event.filter(testState(query, Flags.PISTONS), false);
             }
         }
 
         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);
         }
 
         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(Entities.enderCrystalType) != null) { // should be nullsafe even if enderCrystalType field is null
-            event.filter(testState(query, DefaultFlag.OTHER_EXPLOSION), 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);
+        }
+
+        if (event.getCause().find(EntityType.RAVAGER) != null) {
+            event.filter(testState(query, Flags.RAVAGER_RAVAGE), false);
         }
     }
 
@@ -100,23 +119,25 @@ 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)) {
-                        event.setCancelled(true);
-                    }
+            if (entity instanceof Player && event.getCause() == DamageCause.FLY_INTO_WALL) {
+                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) {
             }
         }
+
     }
 
     /**
@@ -127,12 +148,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,29 +34,29 @@ 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.domains.Association;
-import com.sk89q.worldguard.protection.association.Associables;
+import com.sk89q.worldguard.commands.CommandUtils;
+import com.sk89q.worldguard.config.WorldConfiguration;
+import com.sk89q.worldguard.internal.permission.RegionPermissionModel;
 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;
-import org.bukkit.OfflinePlayer;
 import org.bukkit.World;
 import org.bukkit.block.Block;
 import org.bukkit.entity.Entity;
 import org.bukkit.entity.EntityType;
 import org.bukkit.entity.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 +106,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,133 +133,107 @@ 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);
+            com.sk89q.worldedit.world.World localWorld = BukkitAdapter.adapt(world);
+            WorldConfiguration config = getWorldConfig(localWorld);
 
             if (config.fakePlayerBuildOverride && InteropUtils.isFakePlayer(player)) {
                 return true;
             }
 
-            return !pvp && new RegionPermissionModel(getPlugin(), player).mayIgnoreRegionProtection(world);
+            return !pvp && WorldGuard.getInstance().getPlatform().getSessionManager().hasBypass(localPlayer, localWorld);
         } else {
             return false;
         }
     }
 
-    private RegionAssociable createRegionAssociable(Cause cause) {
-        Object rootCause = cause.getRootCause();
-
-        if (!cause.isKnown()) {
-            return Associables.constant(Association.NON_MEMBER);
-        } else if (rootCause instanceof Player) {
-            return getPlugin().wrapPlayer((Player) rootCause);
-        } else if (rootCause instanceof OfflinePlayer) {
-            return getPlugin().wrapOfflinePlayer((OfflinePlayer) rootCause);
-        } else if (rootCause instanceof Entity) {
-            RegionQuery query = getPlugin().getRegionContainer().createQuery();
-            return new DelayedRegionOverlapAssociation(query, ((Entity) rootCause).getLocation());
-        } else if (rootCause instanceof Block) {
-            RegionQuery query = getPlugin().getRegionContainer().createQuery();
-            return new DelayedRegionOverlapAssociation(query, ((Block) rootCause).getLocation());
-        } else {
-            return Associables.constant(Association.NON_MEMBER);
-        }
-    }
-
     @EventHandler(ignoreCancelled = true)
     public void onPlaceBlock(final PlaceBlockEvent event) {
         if (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 +241,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,26 +309,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 (type == EntityType.EXPERIENCE_ORB) {
-            canSpawn = query.testBuild(target, associable, combine(event, DefaultFlag.EXP_DROPS));
+            canSpawn = query.testBuild(BukkitAdapter.adapt(target), associable, combine(event, Flags.EXP_DROPS));
             what = "drop XP";
 
         } else if (Entities.isAoECloud(type)) {
-            canSpawn = query.testBuild(target, associable, combine(event, DefaultFlag.POTION_SPLASH));
+            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";
@@ -368,30 +346,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";
         }
 
@@ -404,35 +382,44 @@ 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 */
-        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;
+        final Entity entity = event.getEntity();
+        final EntityType type = entity.getType();
+        if (Entities.isHostile(entity) || Entities.isAmbient(entity)
+                || Entities.isNPC(entity) || entity instanceof Player) {
+            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";
-
+        } else if (Entities.isConsideredBuildingIfUsed(entity)) {
+            if (type == EntityType.ITEM_FRAME && event.getCause().getFirstPlayer() != null
+                    && ((ItemFrame) entity).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));
+        } else if (Entities.isRiddenOnUse(entity)) {
+            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";
         }
 
@@ -445,13 +432,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;
@@ -477,11 +464,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()))) {
@@ -497,17 +490,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);
         }
     }
@@ -515,14 +508,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.getNewState().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

@@ -19,10 +19,12 @@
 
 package com.sk89q.worldguard.bukkit.listener;
 
-import com.sk89q.commandbook.InfoComponent;
+import com.sk89q.commandbook.component.info.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,66 @@
 
 package com.sk89q.worldguard.bukkit.listener;
 
-import com.sk89q.worldedit.blocks.BlockID;
+import com.sk89q.worldedit.bukkit.BukkitAdapter;
+import com.sk89q.worldedit.math.BlockVector3;
 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.association.RegionAssociable;
+import com.sk89q.worldguard.protection.flags.Flags;
+import com.sk89q.worldguard.protection.flags.StateFlag;
 import com.sk89q.worldguard.protection.managers.RegionManager;
+import com.sk89q.worldguard.protection.regions.ProtectedCuboidRegion;
+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.block.BlockState;
+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.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.EntityTransformEvent;
+import org.bukkit.event.entity.ExplosionPrimeEvent;
+import org.bukkit.event.entity.PigZapEvent;
+import org.bukkit.event.entity.PlayerDeathEvent;
+import org.bukkit.event.world.PortalCreateEvent;
 import org.bukkit.inventory.ItemStack;
 import org.bukkit.projectiles.ProjectileSource;
 
@@ -72,10 +114,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 +127,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 +139,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 +149,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 +163,10 @@ public class WorldGuardEntityListener implements Listener {
             }
 
             if (wcfg.teleportOnVoid && type == DamageCause.VOID) {
-                BukkitUtil.findFreePosition(player);
+                localPlayer.findFreePosition();
+                if (wcfg.safeFallOnVoid) {
+                    localPlayer.resetFallDistance();
+                }
                 event.setCancelled(true);
                 return;
             }
@@ -132,7 +179,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 +191,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 +210,27 @@ 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.getType() == Entities.enderCrystalType) {
+        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
-            WorldConfiguration wcfg = plugin.getGlobalStateManager().get(defender.getWorld());
             if (wcfg.useRegions && wcfg.explosionFlagCancellation) {
-                if (!plugin.getRegionContainer().createQuery().getApplicableRegions(defender.getLocation())
-                        .testState(null, DefaultFlag.OTHER_EXPLOSION)) {
+                if (!WorldGuard.getInstance().getPlatform().getRegionContainer().createQuery().getApplicableRegions(BukkitAdapter.adapt(defender.getLocation()))
+                        .testState(null, Flags.OTHER_EXPLOSION)) {
                     event.setCancelled(true);
                     return;
                 }
@@ -184,9 +241,6 @@ public class WorldGuardEntityListener implements Listener {
             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;
@@ -222,20 +276,12 @@ 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) {
-                                event.setCancelled(true);
-                                return;
-                            }
-                        }
                     }
                 }
             }
@@ -252,21 +298,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;
                     }
@@ -285,8 +331,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;
                         }
@@ -299,6 +345,10 @@ public class WorldGuardEntityListener implements Listener {
                 event.setCancelled(true);
                 return;
             }
+        } else if (defender instanceof ArmorStand && Entities.isNonPlayerCreature(attacker)) {
+            if (wcfg.blockEntityArmorStandDestroy) {
+                event.setCancelled(true);
+            }
         }
 
     }
@@ -317,8 +367,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) {
@@ -327,6 +377,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
@@ -336,16 +387,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;
@@ -355,8 +406,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;
@@ -380,7 +431,7 @@ public class WorldGuardEntityListener implements Listener {
             }
 
             if (wcfg.teleportOnSuffocation && type == DamageCause.SUFFOCATION) {
-                BukkitUtil.findFreePosition(player);
+                localPlayer.findFreePosition();
                 event.setCancelled(true);
                 return;
             }
@@ -397,16 +448,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;
         }
@@ -456,10 +505,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;
@@ -475,6 +522,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) {
@@ -482,9 +539,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;
@@ -496,7 +552,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;
                 }
@@ -510,8 +566,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) {
@@ -551,14 +607,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) {
@@ -578,7 +634,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;
         }
@@ -586,15 +644,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;
             }
@@ -609,21 +668,68 @@ 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());
+    public void onCreatePortal(PortalCreateEvent event) {
+        ConfigurationManager cfg = WorldGuard.getInstance().getPlatform().getGlobalStateManager();
+        final com.sk89q.worldedit.world.World world = BukkitAdapter.adapt(event.getWorld());
+        WorldConfiguration wcfg = cfg.get(world);
 
-        switch (event.getEntityType()) {
-            case ENDER_DRAGON:
-                if (wcfg.blockEnderDragonPortalCreation) event.setCancelled(true);
-                break;
+        if (wcfg.regionNetherPortalProtection
+                && event.getReason() == PortalCreateEvent.CreateReason.NETHER_PAIR
+                && !event.getBlocks().isEmpty()) {
+            final RegionManager regionManager = WorldGuard.getInstance().getPlatform().getRegionContainer()
+                    .get(world);
+            if (regionManager == null) return;
+            LocalPlayer associable = null;
+            if (event.getEntity() instanceof Player) {
+                associable = plugin.wrapPlayer(((Player) event.getEntity()));
+                if (WorldGuard.getInstance().getPlatform().getSessionManager().hasBypass(associable, world)) {
+                    return;
+                }
+            }
+            BlockVector3 min = null;
+            BlockVector3 max = null;
+            for (BlockState block : event.getBlocks()) {
+                BlockVector3 loc = BlockVector3.at(block.getX(), block.getY(), block.getZ());
+                min = min == null ? loc : loc.getMinimum(min);
+                max = max == null ? loc : loc.getMaximum(max);
+            }
+            ProtectedCuboidRegion target = new ProtectedCuboidRegion("__portal_check", true, min, max);
+            final ApplicableRegionSet regions = regionManager.getApplicableRegions(target);
+            if (!regions.testState(associable, Flags.BUILD, Flags.BLOCK_PLACE)) {
+                if (associable != null) {
+                    // NB there is no way to cancel the teleport without PTA (since PlayerPortal doesn't have block info)
+                    // removing PTA was a mistake
+                    associable.print("Destination is an a protected area.");
+                }
+                event.setCancelled(true);
+            }
+        }
+
+        // NOTE: as of right now, bukkit doesn't fire this event for this (despite deprecating EntityCreatePortalEvent for it)
+        // maybe one day this code will be useful
+        if (event.getEntity() instanceof EnderDragon && wcfg.blockEnderDragonPortalCreation) {
+            event.setCancelled(true);
+        }
+    }
+
+    @EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
+    public void onEntityTransform(EntityTransformEvent event) {
+        ConfigurationManager cfg = WorldGuard.getInstance().getPlatform().getGlobalStateManager();
+        final Entity entity = event.getEntity();
+        WorldConfiguration wcfg = cfg.get(BukkitAdapter.adapt(entity.getWorld()));
+
+        final EntityType type = entity.getType();
+        if (wcfg.disableVillagerZap && type == EntityType.VILLAGER
+                && event.getTransformReason() == EntityTransformEvent.TransformReason.LIGHTNING) {
+            event.setCancelled(true);
         }
     }
 
     @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();
+        final Entity entity = event.getEntity();
+        WorldConfiguration wcfg = cfg.get(BukkitAdapter.adapt(entity.getWorld()));
 
         if (wcfg.disablePigZap) {
             event.setCancelled(true);
@@ -632,8 +738,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);
@@ -646,8 +752,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);
@@ -666,25 +772,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);
@@ -702,14 +807,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,32 @@
 
 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.managers.RegionManager;
-import com.sk89q.worldguard.protection.regions.ProtectedCuboidRegion;
+import com.sk89q.worldguard.protection.flags.Flags;
 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.TravelAgent;
+import org.bukkit.Material;
 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;
@@ -55,7 +56,6 @@ import org.bukkit.event.player.PlayerInteractEvent;
 import org.bukkit.event.player.PlayerItemHeldEvent;
 import org.bukkit.event.player.PlayerJoinEvent;
 import org.bukkit.event.player.PlayerLoginEvent;
-import org.bukkit.event.player.PlayerPortalEvent;
 import org.bukkit.event.player.PlayerRespawnEvent;
 import org.bukkit.event.player.PlayerTeleportEvent;
 import org.bukkit.event.player.PlayerTeleportEvent.TeleportCause;
@@ -74,7 +74,7 @@ import java.util.regex.Pattern;
 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 +97,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 +116,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 +129,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++;
                 }
@@ -134,7 +137,7 @@ public class WorldGuardPlayerListener implements Listener {
 
             if (removed > 10) {
                 log.info("Halt-Act: " + removed + " entities (>10) auto-removed from "
-                        + player.getWorld().toString());
+                        + player.getWorld());
             }
         }
 
@@ -144,27 +147,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().isEmpty() && wcfg.regionCancelEmptyChatEvents) {
                 event.setCancelled(true);
             }
         }
@@ -173,9 +184,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 +198,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 +225,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 +245,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 +273,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 +290,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 +306,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 +325,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 +346,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")) {
@@ -352,87 +362,58 @@ public class WorldGuardPlayerListener implements Listener {
 
     @EventHandler(priority = EventPriority.LOW, ignoreCancelled = true)
     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 = setFrom.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) {
+                        if (message != null) {
+                            player.sendMessage(message);
                         }
+                        event.setCancelled(true);
+                        return;
                     }
                 }
-            } catch (NoSuchFieldError ignored) {}
-        }
-    }
-
-    @EventHandler(ignoreCancelled = true, priority = EventPriority.HIGH)
-    public void onPlayerPortal(PlayerPortalEvent event) {
-        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());
-        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
-            return;
-        }
-        TravelAgent pta = event.getPortalTravelAgent();
-        if (pta == null) { // possible, but shouldn't create a portal
-            return;
-        }
-        if (pta.findPortal(event.getTo()) != null) {
-            return; // portal exists...it shouldn't make a new one
-        }
-        // HOPEFULLY covered everything the server can throw at us...proceed protection checking
-        // a lot of that is implementation specific though
-
-        // hackily estimate the area that could be effected by this event, since the server refuses to tell us
-        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();
-
-        ProtectedRegion check = new ProtectedCuboidRegion("__portalcheck__", BukkitUtil.toVector(min.getBlock()), BukkitUtil.toVector(max.getBlock()));
-
-        if (wcfg.useRegions && !plugin.getGlobalRegionManager().hasBypass(event.getPlayer(), world)) {
-            RegionManager mgr = plugin.getRegionContainer().get(event.getTo().getWorld());
-            if (mgr == null) return;
-            ApplicableRegionSet set = mgr.getApplicableRegions(check);
-            if (!set.testState(plugin.wrapPlayer(event.getPlayer()), DefaultFlag.BUILD)) {
-                event.getPlayer().sendMessage(ChatColor.RED + "Destination is in a protected area.");
+            } else 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 = setFrom.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) {
+                        if (message != null) {
+                            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;
             }
@@ -443,19 +424,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 +445,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,18 @@
 
 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.block.Block;
+import org.bukkit.block.BlockFace;
 import org.bukkit.event.EventHandler;
 import org.bukkit.event.EventPriority;
 import org.bukkit.event.Listener;
@@ -54,8 +60,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 +76,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 +92,23 @@ 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)) {
+        if (!wcfg.disallowedLightningBlocks.isEmpty()) {
+            final Block target = event.getLightning().getLocation().getBlock();
+            Material targetId = target.getType();
+            if (targetId == Material.AIR) {
+                targetId = target.getRelative(BlockFace.DOWN).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

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

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

@@ -0,0 +1,86 @@
+/*
+ * 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.bukkit.event.player.ProcessPlayerEvent;
+import com.sk89q.worldguard.session.AbstractSessionManager;
+import com.sk89q.worldguard.session.Session;
+import com.sk89q.worldguard.util.profile.Profile;
+import org.bukkit.Bukkit;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+
+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 onPlayerProcess(ProcessPlayerEvent event) {
+        // Pre-load a session
+        LocalPlayer player = WorldGuardPlugin.inst().wrapPlayer(event.getPlayer());
+        get(player).initialize(player);
+        WorldGuard.getInstance().getExecutorService().submit(() ->
+            WorldGuard.getInstance().getProfileCache().put(new Profile(player.getUniqueId(), player.getName())));
+    }
+
+    @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);
+    }
+}