Update WorldGuard for CommandBook 3

.github/FUNDING.yml

@@ -1 +0,0 @@
-github: enginehub

.github/ISSUE_TEMPLATE/bug_report.yml

@@ -1,93 +0,0 @@
-name: Bug report
-description: Report a way in which WorldGuard is not working as intended
-labels: ['type:bug', 'status:pending']
-
-body:
-- type: markdown
-  attributes:
-    value: |
-      Please note that this is only for bugs, help with installation or other types of support should
-      be taken to the Discord Guild instead.
-  
-- type: input
-  attributes:
-    label: WorldEdit Version
-    description: The full version of WorldEdit, can be found by using `/we version`.
-    placeholder: e.g. 7.2.3 or 7.3.0-SNAPSHOT
-  validations:
-    required: true
-
-- type: input
-  attributes:
-    label: WorldGuard Version
-    description: The full version of WorldGuard, can be found by using `/wg version`.
-    placeholder: e.g. 7.0.5 or 7.0.6-SNAPSHOT
-  validations:
-    required: true
-
-- type: input
-  attributes:
-    label: Platform Version
-    description: |
-      The version of the platform you are on, i.e. Spigot or Paper.
-      Please ensure you are running up-to-date software before making a bug report.
-      Old versions, paper forks or hybrids will receive little to no support.
-    placeholder: e.g. git-Spigot-21fe707-e1ebe52, git-Paper-463
-  validations:
-    required: true
-
-- type: checkboxes
-  id: confirmations
-  attributes:
-    label: Confirmations
-    description: Please confirm the following before submitting the bug. Your report will be closed if you are running hybrids or old software.
-    options:
-      - label: I am using the most recent Minecraft release.
-        required: true
-      - label: I am using a version of WorldEdit compatible with my Minecraft version.
-        required: true
-      - label: I am using a version of WorldGuard compatible with my Minecraft version.
-        required: true
-      - label: I am using the latest or recommended version of my platform software.
-        required: true
-      - label: I am NOT using a hybrid server, e.g. a server that combines Bukkit and Forge. Examples include Arclight, Mohist, and Cardboard.
-        required: true
-      - label: I am NOT using a fork of WorldEdit, such as FastAsyncWorldEdit (FAWE) or AsyncWorldEdit (AWE)
-        required: true
-
-- type: textarea
-  attributes:
-    label: Bug Description
-    description: A clear and concise description of what the bug is.
-  validations:
-    required: true
-
-- type: textarea
-  attributes:
-    label: Expected Behavior
-    description: The behavior that you expected, instead of the bugged behavior that occurs.
-  validations:
-    required: true
-
-- type: textarea
-  attributes:
-    label: Reproduction Steps
-    description: Steps to reproduce the behavior.
-    value: |
-      1. ...
-      2. ...
-  validations:
-    required: true
-
-
-- type: input
-  attributes:
-    label: Optional WorldGuard-Report
-    description: Link to WorldGuard Region report for bugs with regions, received with `/wg report -p`
-  validations:
-    required: false
-
-- type: textarea
-  attributes:
-    label: Anything Else?
-    description: Add any additional context you can provide below.

.github/ISSUE_TEMPLATE/config.yml

@@ -1,5 +0,0 @@
-blank_issues_enabled: false
-contact_links:
-  - name: EngineHub Discord
-    url: https://discord.gg/EngineHub
-    about: Please ask and answer questions here.

.github/ISSUE_TEMPLATE/feature_request.yml

@@ -1,35 +0,0 @@
-name: Feature request
-description: Suggest an idea for WorldGuard
-labels: ['type:feature-request', 'status:pending']
-
-body:
-- type: textarea
-  attributes:
-    label: The Problem
-    description: >
-      What is making your WorldGuard experience sub-optimal? This should be something that
-      cannot be easily solved by existing WorldGuard features.
-    placeholder: It's hard to ... ; I'm unable to ...
-  validations:
-    required: true
-
-- type: textarea
-  attributes:
-    label: A Solution
-    description: What is your proposed solution to the above problem?
-  validations:
-    required: true
-
-- type: textarea
-  attributes:
-    label: Alternatives
-    description: |
-      Alternative solutions or workarounds to the problem.
-      You should also describe why these are not preferable to the given solution.
-  validations:
-    required: false
-
-- type: textarea
-  attributes:
-    label: Anything Else?
-    description: Add any additional context you can provide below.

.gitignore

@@ -15,5 +15,3 @@ dependency-reduced-pom.xml
 .gradle/
 **/build/
 out/
-
-scripts/

.travis.yml

@@ -1,7 +1,7 @@
 language: java
 dist: trusty
 jdk:
-  - oraclejdk11
+  - oraclejdk8
 notifications:
   email: false
 before_install: chmod +x gradlew

CHANGELOG.md

@@ -1,130 +1,5 @@
 # Changelog
 
-## 7.0.10
-
-* Add support for MC 1.20.5 and 1.20.6, drop support for other 1.20 versions
-
-## 7.0.9
-* Add support for MC 1.20, drop support for MC 1.19
-* Made entities spawned via the `/summon` command get treated as plugin-spawned entities
-* Add sniffer egg trample protection options
-
-## 7.0.8
-* Add support for MC 1.19
-* Add skulk-growth flag and config option
-* Add copper-fade flag
-* Add data packs to report output
-* Add protection for allay inventory slot
-* Categorize allay item pickups under item-pickup flag
-* Categorize dragon egg interaction (teleporting) as building
-* Ignore most NPC-based actions for Player events
-* Optimize handling of tamed animals where the owner was offline (Paper only)
-* Optimize additional InventoryHolder accesses (Paper only)
-* Fix an exception that occurred when plugins created portals with non-player entities
-* Fix possible error when using Paper's entity origin API
-* Update bstats and squirrelid libs
-
-## 7.0.7
-* Add rock-growth flag for budding amethyst and pointed dripstone.
-* Add /rg migrateheights command. See https://worldguard.enginehub.org/en/latest/regions/commands/#migrate-region-heights
-* Add regions.set-parent-on-claim config (set to a region id for /rg claim to automatically assign the parent region).
-* Add `-i search` and `-s` flags to /rg list, -c to /rg teleport.
-* Fix an error in blacklist logging caused by non-player actions (eg on-dispense)
-* Treat unknown causes as known if using paper-entity-origin config option.
-* Improve lightning strike handling from channeling tridents (PaperMC only).
-* Ignore an error caused by lingering player references of offline players.
-* Add red sand to no-physics-sand.
-* Fix potion splash events being cancelled if no entities were affected.
-
-## 7.0.6
-
-* Add support for 1.17 blocks/items, drop support for 1.16.
-* Add use-dripleaf flag for "toggling" big dripleaf blocks.
-* Fix support for fully negative-height regions.
-* Fix crop-growth config option.
-* Be more rigorous with protecting blocks against dispenser behaviors.
-* Fix handling of lingering splash potion effects.
-* Handle other-explosion flag consistently for block-like entities (armor frames etc.)
-* Allow inheriting values for all flags (previously wasn't used for things like teleport.)
-* Region commands that defaulted to the region the player was standing in no longer check parents.
-* Fix child regions being unlinked when redefining a parent region.
-
-## 7.0.5
-
-* Add a use-anvil flag and exclude it from the use flag (since they can break on use.)
-* Add nonplayer-protection-domains flag which allows merging region borders from the perspective of pistons, saplings, etc.
-* Expand crop-related options (crop-growth, etc) to sweet berry bushes, nether wart, and bamboo.
-* Add a config option (`mobs.block-vehicle-entry`) to prevent non-players from entering vehicles.
-* Add a UUID flag (for developers/API usage).
-* Add map query methods with fallback flag (for developers/API usage).
-* Add `on` and `off` optional arguments for `/rg toggle-bypass` command.
-* Add additional timings info for session handlers.
-* Fix sponge-simulation clearing NBT from blocks. Note that if you are using sponge simulation you should switch to something like CraftBook as the feature will be removed from WorldGuard in a future (major) version.
-* Fix the `/rg` command showing up as unknown client-side to players without bypass perms.
-* Fix error propagation from third-party flag loading causing WG to error.
-* Fix a (harmless) exception that occurred when swapping armor slots to the offhand slot.
-* Fix empty lines being sent on enderpearl/chorus-fruit teleport if the deny messages were empty.
-* Fix an issue with falling blocks when using max-priority-association.
-* Fix performance issues with third-party plugins querying protection for offline players.
-* Fix dispensing shulkers over region boundaries.
-* Fix iron door interaction being denied as if it were a regular door.
-* Fix being able to enter/exit regions with the flag denied by using entity mounting functions in other plugins.
-
-## 7.0.4 (including beta1)
-
-* Add support for MC 1.16. Dropped support for previous versions.
-* Add respawn-anchors flag mirroring the sleep flag (e.g. to prevent using respawn anchors to cause explosions in the overworld)
-* Add nether vines to vine-growth flag.
-* Add config option to disable the bypass permission cache.
-* Fix water-flow flags not checking waterlogged blocks.
-* Add config option to consider non-player causes (e.g. pistons, flowing water) to only be members of the highest priority region. This should be enabled for plots-within-city-like setups to prevent things in plots from modifying the city.
-* Fix items dropping from falling blocks that were suppressed by other plugins.
-* Add config option to block turtle egg trampling.
-* Fix ride flag being checked on striders that didn't have saddles.
-* Add config option to have /rg bypass toggled off on login.
-* Developer changes: Methods taking names in Domains are now explicitly deprecated (was previously just a javadoc comment.); These will eventually be removed: there is no reason to use names over UUIDs. Offline players and NPCs alike have stable UUIDs.
-* Also for developers; The new `com.sk89q.worldguard.protection.util.WorldEditRegionConverter` class has some useful static methods to convert to and from WorldEdit's Region and WorldGuard's ProtectedRegion classes.
-
-
-## 7.0.3
-
-* This is the last release supporting MC 1.14 and 1.15.
-* Decouple chest-access flag from interact flag. IMPORTANT: If you relied on allowing players to access chests via setting
-    the interact flag to allow, you will now need to set the chest-access flag to allow instead (or as well). This does not
-    affect any setups where users were *not* supposed to be able to access chests and other inventories.
-* Add natural-health-regen and natural-hunger-drain flags. Unlike the heal/feed flags, these can not restore or deplete health/hunger.
-* Fix the interact flag allowing breaking of turtle eggs (now tied directly to block-trampling flag).
-* Fix a memory leak that could occur with many many explosives.
-* Add regions.titles-always-use-default-times config option. Set this to true if you use greeting/farewell titles and another plugin
-    makes the titles disappear too quickly.
-* Add protection for cauldrons water level changing.
-* Improve diagnostic hints and information, such as spawn protection warnings, flag colors in region info, etc.
-* Fix waterlogged blocks bypassing water-flow flag.
-* Workaround for a CraftBukkit change that made no-physics-sand/gravel non-functional.
-* Workaround for CraftBukkit throttling move events.
-* Track projectiles shot by dispensers.
-* Allowed setting passthrough allow on global to unprotect it if members/owners are added.
-* Add support for newer forge clients (FML2) in host keys.
-* Allow using WorldEdit's `//world <worldname>` command to select a world for region commands. This removes the need to
-    use `-w <worldname>` in every command when running commands from console.
-* Add a teleport-message flag, shown when using `/rg tp`.
-* Add coral-fade flag, which prevents corals from drying when out of water.
-* Fix spammy deny-message when walking over redstone ore with certain flag setups.
-* Improve handling of interacting with various tools in hand that didn't modify blocks. (eg opening a chest with an axe in hand)
-* Fix allow-all-interact option not being read from per-world configs.
-* Fix misattribution of pets (eg wolves) in PvP.
-* Improve performance of hopper checks when on recent builds of Paper.
-* Add event-handling.break-hoppers-on-denied-move config option to prevent hoppers from being broken (but items still won't be moved).
-* Note to developers using the WorldGuard API: If you specifically relied on flags such as greeting/farewell, deny-message, etc being
-    StringFlags, be warned that this will change in a future version to support JSON text components. Please plan accordingly.
-
-
-## 7.0.2
-* Update to MC 1.15. Still compatible with 1.14, and incompatible with 1.13, as before.
-* Add an informational message when defining a region that overlaps vanilla spawn protection.
-* Protect against pushing a piston with another piston on a region border.
-* Protect against buckets in dispensers on region borders.
-
 ## 7.0.1
 * Add `/rg toggle-bypass` command which temporarily turns off region bypassing until used again.
 * More improvements to `/rg flag` and `/rg flags` commands.

COMPILING.md

@@ -1,39 +0,0 @@
-Compiling
-=========
-
-You can compile WorldGuard as long as you have some version of Java greater than or equal to 21 installed. 
-Gradle will download JDK 21 specifically if needed, but it needs some version of Java to bootstrap from.
-
-The build process uses Gradle, which you do *not* need to download. WorldGuard is a multi-module project with three modules:
-
-* `worldguard-core` contains the WorldGuard API
-* `worldguard-bukkit` is the Bukkit plugin
-* `worldguard-libs` contains library relocations
-
-## To compile...
-
-### On Windows
-
-1. **Shift** + **right click** the folder with WorldGuard's files and click "Open PowerShell window here".
-2. `gradlew build`
-
-### On Linux, BSD, or Mac OS X
-
-1. In your terminal, navigate to the folder with WorldGuard's files (`cd /folder/of/worldguard/files`)
-2. `./gradlew build`
-
-## Then you will find...
-
-You will find:
-
-* The core WorldGuard API in **worldguard-core/build/libs**
-* WorldGuard for Bukkit in **worldguard-bukkit/build/libs**
-
-If you want to use WorldGuard, use the `-dist` version.
-
-(The -dist version includes WorldGuard + necessary libraries.)
-
-## Other commands
-
-* `gradlew idea` will generate an [IntelliJ IDEA](http://www.jetbrains.com/idea/) module for each folder.
-* `gradlew eclipse` will generate an [Eclipse](https://www.eclipse.org/downloads/) project for each folder.

CONTRIBUTING.md

@@ -7,7 +7,9 @@ ask that you make note of the following guidelines.
 * **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 16 for source and compilation.**
+* **Target Java 6 for source and compilation.** Make sure to mark methods with
+  ` @Override` that override methods of parent classes, or that implement
+  methods of interfaces (Java 6+).
 * **Use only spaces for indentation.** Our indents are 4-spaces long, and tabs
   are unacceptable.
 * **Wrap code to a 89 column limit.** We do this to make side by side diffs

README.md

@@ -1,29 +1,27 @@
-<h1>
-    <img src="worldguard-logo.svg" alt="WorldGuard" width="400" /> 
-</h1>
+# ![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
+* Block creeper and wither block damage, falling damage, etc.;
+* Disable fire spread, lava fire spread, ice formation, Endermen picking up blocks, etc.;
+* Blacklist certain items and blocks so they can't be used;
+* Warn moderators when certain items and blocks are used;
+* Protect areas of your world so only certain people can build in them;
+* Set areas where PVP, TNT, mob damage, and other features are disabled;
+* Protect your server from various 'exploits' like magical obsidian creation machines;
+* Disable, or enable, various Minecraft features, like sponges from classic;
+* Add useful commands like an immediate "STOP ALL FIRE SPREAD" command.
+* Enable only features you want! Everything is off by default.
 
 WorldGuard is open source and is available under the GNU Lesser
 General Public License v3.
 
-A Bukkit server implementation (such as [Paper](https://papermc.io)) and the [WorldEdit plugin](https://dev.bukkit.org/projects/worldedit) are required to use WorldGuard. You can get a release copy of WorldGuard from the [BukkitDev site](https://dev.bukkit.org/projects/worldguard).
+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 17 and our build process makes use of
+The project is written for Java 8 and our build process makes use of
 [Gradle](http://gradle.org).
 
 Dependencies are automatically handled by Gradle.
@@ -40,8 +38,9 @@ Submissions must be licensed under the GNU Lesser General Public License v3.
 Links
 -----
 
-* [Homepage](https://enginehub.org/worldguard)
+* [Homepage](http://enginehub.org/worldguard)
 * [Discord](https://discord.gg/enginehub)
-* [Issue tracker](https://github.com/EngineHub/WorldGuard/issues)
-* [Continuous integration](https://builds.enginehub.org) [![Build Status](https://ci.enginehub.org/app/rest/builds/buildType:bt11,branch:master/statusIcon.svg)](http://ci.enginehub.org/viewType.html?buildTypeId=bt11&guest=1)
+* [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.kts

@@ -17,10 +17,10 @@ applyRootArtifactoryConfig()
 if (!project.hasProperty("gitCommitHash")) {
     apply(plugin = "org.ajoberstar.grgit")
     ext["gitCommitHash"] = try {
-        Grgit.open(mapOf("currentDir" to project.rootDir))?.head()?.abbreviatedId
+        (ext["grgit"] as Grgit?)?.head()?.abbreviatedId
     } catch (e: Exception) {
         logger.warn("Error getting commit hash", e)
 
-        "no.git.id"
+        "no_git_id"
     }
 }

buildSrc/build.gradle.kts

@@ -4,26 +4,16 @@ plugins {
 }
 
 repositories {
-    mavenCentral()
+    jcenter()
     gradlePluginPortal()
 }
 
 dependencies {
     implementation(gradleApi())
-    implementation("gradle.plugin.org.cadixdev.gradle:licenser:0.6.1")
-    implementation("org.ajoberstar.grgit:grgit-gradle:5.2.2")
-    implementation("com.github.johnrengelman:shadow:8.1.1")
-    implementation("org.jfrog.buildinfo:build-info-extractor-gradle:5.2.0")
-    constraints {
-        val asmVersion = "[9.7,)"
-        implementation("org.ow2.asm:asm:$asmVersion") {
-            because("Need Java 21 support in shadow")
-        }
-        implementation("org.ow2.asm:asm-commons:$asmVersion") {
-            because("Need Java 21 support in shadow")
-        }
-        implementation("org.vafer:jdependency:[2.10,)") {
-            because("Need Java 21 support in shadow")
-        }
-    }
+    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

@@ -34,7 +34,7 @@ fun Project.applyRootArtifactoryConfig() {
 }
 
 fun Project.applyCommonArtifactoryConfig() {
-    tasks.named<ArtifactoryTask>("artifactoryPublish") {
-        publications("maven")
+    val named = tasks.named<ArtifactoryTask>("artifactoryPublish") {
+        publishConfigs("archives")
     }
-}
+}

buildSrc/src/main/kotlin/CommonConfig.kt

@@ -1,11 +1,5 @@
-import org.cadixdev.gradle.licenser.LicenseExtension
 import org.gradle.api.Project
-import org.gradle.api.plugins.JavaPluginExtension
-import org.gradle.jvm.toolchain.JavaLanguageVersion
-import org.gradle.kotlin.dsl.apply
-import org.gradle.kotlin.dsl.configure
 import org.gradle.kotlin.dsl.repositories
-import org.gradle.kotlin.dsl.the
 
 fun Project.applyCommonConfiguration() {
     group = rootProject.group
@@ -13,26 +7,12 @@ fun Project.applyCommonConfiguration() {
 
     repositories {
         mavenCentral()
-        maven { url = uri("https://maven.enginehub.org/repo/") }
+        maven { url = uri("https://maven.sk89q.com/repo/") }
         maven { url = uri("https://oss.sonatype.org/content/repositories/snapshots/") }
     }
-
     configurations.all {
         resolutionStrategy {
-            cacheChangingModulesFor(5, "MINUTES")
+            cacheChangingModulesFor(5, "minutes")
         }
     }
-
-    plugins.withId("java") {
-        the<JavaPluginExtension>().toolchain {
-            languageVersion.set(JavaLanguageVersion.of(21))
-        }
-    }
-
-    apply(plugin = "org.cadixdev.licenser")
-    configure<LicenseExtension> {
-        header(rootProject.file("HEADER.txt"))
-        include("**/*.java")
-        include("**/*.kt")
-    }
 }

buildSrc/src/main/kotlin/LibsConfig.kt

@@ -1,54 +1,39 @@
 import com.github.jengelman.gradle.plugins.shadow.tasks.ShadowJar
-import org.gradle.api.Plugin
 import org.gradle.api.Project
 import org.gradle.api.artifacts.ModuleDependency
-import org.gradle.api.attributes.Bundling
-import org.gradle.api.attributes.Category
-import org.gradle.api.attributes.DocsType
-import org.gradle.api.attributes.LibraryElements
-import org.gradle.api.attributes.Usage
-import org.gradle.api.attributes.java.TargetJvmVersion
-import org.gradle.api.component.AdhocComponentWithVariants
-import org.gradle.api.component.SoftwareComponentFactory
-import org.gradle.api.publish.PublishingExtension
-import org.gradle.api.publish.maven.MavenPublication
+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.configure
 import org.gradle.kotlin.dsl.get
+import org.gradle.kotlin.dsl.getPlugin
 import org.gradle.kotlin.dsl.invoke
-import org.gradle.kotlin.dsl.named
 import org.gradle.kotlin.dsl.register
-import javax.inject.Inject
 
 fun Project.applyLibrariesConfiguration() {
     applyCommonConfiguration()
     apply(plugin = "java-base")
-    apply(plugin = "maven-publish")
+    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"
 
-    val relocations = mapOf(
-        "org.enginehub.squirrelid" to "com.sk89q.worldguard.util.profile"
-    )
-
     tasks.register<ShadowJar>("jar") {
         configurations = listOf(project.configurations["shade"])
         archiveClassifier.set("")
 
         dependencies {
-            exclude(dependency("com.google.code.findbugs:jsr305"))
+            exclude(dependency("com.google.code.findbugs:jsr305:1.3.9"))
         }
 
-        relocations.forEach { (from, to) ->
-            relocate(from, to)
-        }
+        relocate("com.sk89q.squirrelid", "com.sk89q.worldguard.util.profile")
     }
     val altConfigFiles = { artifactType: String ->
         val deps = configurations["shade"].incoming.dependencies
@@ -73,15 +58,13 @@ fun Project.applyLibrariesConfiguration() {
         from({
             altConfigFiles("sources")
         })
-        relocations.forEach { (from, to) ->
-            val filePattern = Regex("(.*)${from.replace('.', '/')}((?:/|$).*)")
-            val textPattern = Regex.fromLiteral(from)
-            eachFile {
-                filter {
-                    it.replaceFirst(textPattern, to)
-                }
-                path = path.replaceFirst(filePattern, "$1${to.replace('.', '/')}$2")
+        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")
     }
@@ -90,82 +73,24 @@ fun Project.applyLibrariesConfiguration() {
         dependsOn("jar", "sourcesJar")
     }
 
-    project.apply<LibsConfigPluginHack>()
-
-    val libsComponent = project.components["libs"] as AdhocComponentWithVariants
-
-    val apiElements = project.configurations.register("apiElements") {
-        isVisible = false
-        description = "API elements for libs"
-        isCanBeResolved = false
-        isCanBeConsumed = true
-        attributes {
-            attribute(Usage.USAGE_ATTRIBUTE, project.objects.named(Usage.JAVA_API))
-            attribute(Category.CATEGORY_ATTRIBUTE, project.objects.named(Category.LIBRARY))
-            attribute(Bundling.BUNDLING_ATTRIBUTE, project.objects.named(Bundling.SHADOWED))
-            attribute(LibraryElements.LIBRARY_ELEMENTS_ATTRIBUTE, project.objects.named(LibraryElements.JAR))
-            attribute(TargetJvmVersion.TARGET_JVM_VERSION_ATTRIBUTE, 8)
+    artifacts {
+        val jar = tasks.named("jar")
+        add("default", jar) {
+            builtBy(jar)
         }
-        outgoing.artifact(tasks.named("jar"))
-    }
-
-    val runtimeElements = project.configurations.register("runtimeElements") {
-        isVisible = false
-        description = "Runtime elements for libs"
-        isCanBeResolved = false
-        isCanBeConsumed = true
-        attributes {
-            attribute(Usage.USAGE_ATTRIBUTE, project.objects.named(Usage.JAVA_RUNTIME))
-            attribute(Category.CATEGORY_ATTRIBUTE, project.objects.named(Category.LIBRARY))
-            attribute(Bundling.BUNDLING_ATTRIBUTE, project.objects.named(Bundling.SHADOWED))
-            attribute(LibraryElements.LIBRARY_ELEMENTS_ATTRIBUTE, project.objects.named(LibraryElements.JAR))
-            attribute(TargetJvmVersion.TARGET_JVM_VERSION_ATTRIBUTE, 8)
+        val sourcesJar = tasks.named("sourcesJar")
+        add("archives", sourcesJar) {
+            builtBy(sourcesJar)
         }
-        outgoing.artifact(tasks.named("jar"))
     }
 
-    val sourcesElements = project.configurations.register("sourcesElements") {
-        isVisible = false
-        description = "Source elements for libs"
-        isCanBeResolved = false
-        isCanBeConsumed = true
-        attributes {
-            attribute(Usage.USAGE_ATTRIBUTE, project.objects.named(Usage.JAVA_RUNTIME))
-            attribute(Category.CATEGORY_ATTRIBUTE, project.objects.named(Category.DOCUMENTATION))
-            attribute(Bundling.BUNDLING_ATTRIBUTE, project.objects.named(Bundling.SHADOWED))
-            attribute(DocsType.DOCS_TYPE_ATTRIBUTE, project.objects.named(DocsType.SOURCES))
-        }
-        outgoing.artifact(tasks.named("sourcesJar"))
-    }
-
-    libsComponent.addVariantsFromConfiguration(apiElements.get()) {
-        mapToMavenScope("compile")
-    }
-
-    libsComponent.addVariantsFromConfiguration(runtimeElements.get()) {
-        mapToMavenScope("runtime")
-    }
-
-    libsComponent.addVariantsFromConfiguration(sourcesElements.get()) {
-        mapToMavenScope("runtime")
-    }
-
-    configure<PublishingExtension> {
-        publications {
-            register<MavenPublication>("maven") {
-                from(libsComponent)
-            }
+    tasks.register<Upload>("install") {
+        configuration = configurations["archives"]
+        (repositories as HasConvention).convention.getPlugin<MavenRepositoryHandlerConvention>().mavenInstaller {
+            pom.version = project.version.toString()
+            pom.artifactId = project.name
         }
     }
 
     applyCommonArtifactoryConfig()
-}
-
-internal open class LibsConfigPluginHack @Inject constructor(
-        private val softwareComponentFactory: SoftwareComponentFactory
-) : Plugin<Project> {
-    override fun apply(project: Project) {
-        val libsComponents = softwareComponentFactory.adhoc("libs")
-        project.components.add(libsComponents)
-    }
 }

buildSrc/src/main/kotlin/PlatformConfig.kt

@@ -1,95 +1,105 @@
 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.component.AdhocComponentWithVariants
-import org.gradle.api.plugins.JavaPluginExtension
+import org.gradle.api.plugins.JavaPluginConvention
 import org.gradle.api.plugins.quality.CheckstyleExtension
-import org.gradle.api.publish.PublishingExtension
-import org.gradle.api.publish.maven.MavenPublication
+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.StandardJavadocDocletOptions
+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
-import org.gradle.kotlin.dsl.the
 
 fun Project.applyPlatformAndCoreConfiguration() {
     applyCommonConfiguration()
     apply(plugin = "java")
     apply(plugin = "eclipse")
     apply(plugin = "idea")
-    apply(plugin = "maven-publish")
+    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"]}"
+    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 = "10.3"
+        toolVersion = "7.6.1"
     }
 
     tasks.withType<Test>().configureEach {
-        useJUnitPlatform()
+        useJUnit()
     }
 
     dependencies {
-        "compileOnly"("com.google.code.findbugs:jsr305:3.0.2")
-        "testCompileOnly"("com.google.code.findbugs:jsr305:3.0.2")
-        "testImplementation"("org.junit.jupiter:junit-jupiter-api:${Versions.JUNIT}")
-        "testImplementation"("org.junit.jupiter:junit-jupiter-params:${Versions.JUNIT}")
-        "testImplementation"("org.mockito:mockito-core:${Versions.MOCKITO}")
-        "testImplementation"("org.mockito:mockito-junit-jupiter:${Versions.MOCKITO}")
-        "testRuntimeOnly"("org.junit.jupiter:junit-jupiter-engine:${Versions.JUNIT}")
+        "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 StandardJavadocDocletOptions).apply {
-            addStringOption("Xdoclint:none", "-quiet")
-            tags(
-                "apiNote:a:API Note:",
-                "implSpec:a:Implementation Requirements:",
-                "implNote:a:Implementation Note:"
-            )
-        }
+        (options as CoreJavadocOptions).addStringOption("Xdoclint:none", "-quiet")
     }
 
-    the<JavaPluginExtension>().withJavadocJar()
+    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") {
-        the<JavaPluginExtension>().withSourcesJar()
+        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")
     }
 
-    configure<PublishingExtension> {
-        publications {
-            register<MavenPublication>("maven") {
-                from(components["java"])
-                versionMapping {
-                    usage("java-api") {
-                        fromResolutionOf("runtimeClasspath")
-                    }
-                    usage("java-runtime") {
-                        fromResolutionResult()
-                    }
-                }
-            }
-        }
+    applyCommonArtifactoryConfig()
+
+    configure<LicenseExtension> {
+        header = rootProject.file("HEADER.txt")
+        include("**/*.java")
     }
 
-    applyCommonArtifactoryConfig()
 }
 
 fun Project.applyShadowConfiguration() {
-    apply(plugin = "com.github.johnrengelman.shadow")
     tasks.named<ShadowJar>("shadowJar") {
         archiveClassifier.set("dist")
         dependencies {
@@ -100,14 +110,10 @@ fun Project.applyShadowConfiguration() {
             relocate("org.flywaydb", "com.sk89q.worldguard.internal.flywaydb") {
                 include(dependency("org.flywaydb:flyway-core:3.0"))
             }
-            exclude("com.google.code.findbugs:jsr305")
+            relocate("com.sk89q.squirrelid", "com.sk89q.worldguard.util.profile")
         }
         exclude("GradleStart**")
         exclude(".cache")
         exclude("LICENSE*")
     }
-    val javaComponent = components["java"] as AdhocComponentWithVariants
-    javaComponent.withVariantsFromConfiguration(configurations["shadowRuntimeElements"]) {
-        skip()
-    }
 }

buildSrc/src/main/kotlin/Versions.kt

@@ -1,10 +1,7 @@
 object Versions {
-    //    const val PISTON = "0.4.3"
-    //    const val AUTO_VALUE = "1.6.5"
-    const val WORLDEDIT = "7.3.0"
-    const val JUNIT = "5.9.1"
-    const val MOCKITO = "4.9.0"
-    const val SQUIRRELID = "0.3.2"
-    const val GUAVA = "31.1-jre"
-    const val FINDBUGS = "3.0.2"
+//    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/import-control.xml

@@ -27,11 +27,8 @@
     <subpackage name="bukkit">
       <allow pkg="org.bukkit"/>
       <allow pkg="org.bstats.bukkit"/>
-      <allow pkg="org.bstats.charts"/>
       <allow pkg="io.papermc.lib"/>
       <allow pkg="com.destroystokyo.paper"/>
-      <allow pkg="io.papermc.paper"/>
-      <allow pkg="org.spigotmc" />
     </subpackage>
 
   </subpackage>

gradle.properties

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

gradle/wrapper/gradle-wrapper.properties

@@ -1,7 +1,5 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-8.7-bin.zip
-networkTimeout=10000
-validateDistributionUrl=true
+distributionUrl=https\://services.gradle.org/distributions/gradle-5.5.1-all.zip
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists

gradlew

@@ -1,127 +1,78 @@
-#!/bin/sh
-
-#
-# Copyright © 2015-2021 the original authors.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      https://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
+#!/usr/bin/env sh
 
 ##############################################################################
-#
-#   Gradle start up script for POSIX generated by Gradle.
-#
-#   Important for running:
-#
-#   (1) You need a POSIX-compliant shell to run this script. If your /bin/sh is
-#       noncompliant, but you have some other compliant shell such as ksh or
-#       bash, then to run this script, type that shell name before the whole
-#       command line, like:
-#
-#           ksh Gradle
-#
-#       Busybox and similar reduced shells will NOT work, because this script
-#       requires all of these POSIX shell features:
-#         * functions;
-#         * expansions «$var», «${var}», «${var:-default}», «${var+SET}»,
-#           «${var#prefix}», «${var%suffix}», and «$( cmd )»;
-#         * compound commands having a testable exit status, especially «case»;
-#         * various built-in commands including «command», «set», and «ulimit».
-#
-#   Important for patching:
-#
-#   (2) This script targets any POSIX shell, so it avoids extensions provided
-#       by Bash, Ksh, etc; in particular arrays are avoided.
-#
-#       The "traditional" practice of packing multiple parameters into a
-#       space-separated string is a well documented source of bugs and security
-#       problems, so this is (mostly) avoided, by progressively accumulating
-#       options in "$@", and eventually passing that to Java.
-#
-#       Where the inherited environment variables (DEFAULT_JVM_OPTS, JAVA_OPTS,
-#       and GRADLE_OPTS) rely on word-splitting, this is performed explicitly;
-#       see the in-line comments for details.
-#
-#       There are tweaks for specific operating systems such as AIX, CygWin,
-#       Darwin, MinGW, and NonStop.
-#
-#   (3) This script is generated from the Groovy template
-#       https://github.com/gradle/gradle/blob/HEAD/subprojects/plugins/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt
-#       within the Gradle project.
-#
-#       You can find Gradle at https://github.com/gradle/gradle/.
-#
+##
+##  Gradle start up script for UN*X
+##
 ##############################################################################
 
 # Attempt to set APP_HOME
-
 # Resolve links: $0 may be a link
-app_path=$0
-
-# Need this for daisy-chained symlinks.
-while
-    APP_HOME=${app_path%"${app_path##*/}"}  # leaves a trailing /; empty if no leading path
-    [ -h "$app_path" ]
-do
-    ls=$( ls -ld "$app_path" )
-    link=${ls#*' -> '}
-    case $link in             #(
-      /*)   app_path=$link ;; #(
-      *)    app_path=$APP_HOME$link ;;
-    esac
+PRG="$0"
+# Need this for relative symlinks.
+while [ -h "$PRG" ] ; do
+    ls=`ls -ld "$PRG"`
+    link=`expr "$ls" : '.*-> \(.*\)$'`
+    if expr "$link" : '/.*' > /dev/null; then
+        PRG="$link"
+    else
+        PRG=`dirname "$PRG"`"/$link"
+    fi
 done
+SAVED="`pwd`"
+cd "`dirname \"$PRG\"`/" >/dev/null
+APP_HOME="`pwd -P`"
+cd "$SAVED" >/dev/null
 
-# This is normally unused
-# shellcheck disable=SC2034
-APP_BASE_NAME=${0##*/}
-# Discard cd standard output in case $CDPATH is set (https://github.com/gradle/gradle/issues/25036)
-APP_HOME=$( cd "${APP_HOME:-./}" > /dev/null && pwd -P ) || exit
+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
+MAX_FD="maximum"
 
 warn () {
     echo "$*"
-} >&2
+}
 
 die () {
     echo
     echo "$*"
     echo
     exit 1
-} >&2
+}
 
 # OS specific support (must be 'true' or 'false').
 cygwin=false
 msys=false
 darwin=false
 nonstop=false
-case "$( uname )" in                #(
-  CYGWIN* )         cygwin=true  ;; #(
-  Darwin* )         darwin=true  ;; #(
-  MSYS* | MINGW* )  msys=true    ;; #(
-  NONSTOP* )        nonstop=true ;;
+case "`uname`" in
+  CYGWIN* )
+    cygwin=true
+    ;;
+  Darwin* )
+    darwin=true
+    ;;
+  MINGW* )
+    msys=true
+    ;;
+  NONSTOP* )
+    nonstop=true
+    ;;
 esac
 
 CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
 
-
 # Determine the Java command to use to start the JVM.
 if [ -n "$JAVA_HOME" ] ; then
     if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
         # IBM's JDK on AIX uses strange locations for the executables
-        JAVACMD=$JAVA_HOME/jre/sh/java
+        JAVACMD="$JAVA_HOME/jre/sh/java"
     else
-        JAVACMD=$JAVA_HOME/bin/java
+        JAVACMD="$JAVA_HOME/bin/java"
     fi
     if [ ! -x "$JAVACMD" ] ; then
         die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
@@ -130,120 +81,92 @@ Please set the JAVA_HOME variable in your environment to match the
 location of your Java installation."
     fi
 else
-    JAVACMD=java
-    if ! command -v java >/dev/null 2>&1
-    then
-        die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+    JAVACMD="java"
+    which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
 
 Please set the JAVA_HOME variable in your environment to match the
 location of your Java installation."
-    fi
 fi
 
 # Increase the maximum file descriptors if we can.
-if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then
-    case $MAX_FD in #(
-      max*)
-        # In POSIX sh, ulimit -H is undefined. That's why the result is checked to see if it worked.
-        # shellcheck disable=SC2039,SC3045
-        MAX_FD=$( ulimit -H -n ) ||
-            warn "Could not query maximum file descriptor limit"
-    esac
-    case $MAX_FD in  #(
-      '' | soft) :;; #(
-      *)
-        # In POSIX sh, ulimit -n is undefined. That's why the result is checked to see if it worked.
-        # shellcheck disable=SC2039,SC3045
-        ulimit -n "$MAX_FD" ||
-            warn "Could not set maximum file descriptor limit to $MAX_FD"
-    esac
-fi
-
-# Collect all arguments for the java command, stacking in reverse order:
-#   * args from the command line
-#   * the main class name
-#   * -classpath
-#   * -D...appname settings
-#   * --module-path (only if needed)
-#   * DEFAULT_JVM_OPTS, JAVA_OPTS, and GRADLE_OPTS environment variables.
-
-# For Cygwin or MSYS, switch paths to Windows format before running java
-if "$cygwin" || "$msys" ; then
-    APP_HOME=$( cygpath --path --mixed "$APP_HOME" )
-    CLASSPATH=$( cygpath --path --mixed "$CLASSPATH" )
-
-    JAVACMD=$( cygpath --unix "$JAVACMD" )
-
-    # Now convert the arguments - kludge to limit ourselves to /bin/sh
-    for arg do
-        if
-            case $arg in                                #(
-              -*)   false ;;                            # don't mess with options #(
-              /?*)  t=${arg#/} t=/${t%%/*}              # looks like a POSIX filepath
-                    [ -e "$t" ] ;;                      #(
-              *)    false ;;
-            esac
-        then
-            arg=$( cygpath --path --ignore --mixed "$arg" )
+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
+            MAX_FD="$MAX_FD_LIMIT"
         fi
-        # Roll the args list around exactly as many times as the number of
-        # args, so each arg winds up back in the position where it started, but
-        # possibly modified.
-        #
-        # NB: a `for` loop captures its iteration list before it begins, so
-        # changing the positional parameters here affects neither the number of
-        # iterations, nor the values presented in `arg`.
-        shift                   # remove old arg
-        set -- "$@" "$arg"      # push replacement arg
+        ulimit -n $MAX_FD
+        if [ $? -ne 0 ] ; then
+            warn "Could not set maximum file descriptor limit: $MAX_FD"
+        fi
+    else
+        warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT"
+    fi
+fi
+
+# For Darwin, add options to specify how the application appears in the dock
+if $darwin; then
+    GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\""
+fi
+
+# For Cygwin, switch paths to Windows format before running java
+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`
+    SEP=""
+    for dir in $ROOTDIRSRAW ; do
+        ROOTDIRS="$ROOTDIRS$SEP$dir"
+        SEP="|"
     done
+    OURCYGPATTERN="(^($ROOTDIRS))"
+    # Add a user-defined pattern to the cygpath arguments
+    if [ "$GRADLE_CYGPATTERN" != "" ] ; then
+        OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)"
+    fi
+    # Now convert the arguments - kludge to limit ourselves to /bin/sh
+    i=0
+    for arg in "$@" ; do
+        CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -`
+        CHECK2=`echo "$arg"|egrep -c "^-"`                                 ### Determine if an option
+
+        if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then                    ### Added a condition
+            eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"`
+        else
+            eval `echo args$i`="\"$arg\""
+        fi
+        i=$((i+1))
+    done
+    case $i in
+        (0) set -- ;;
+        (1) set -- "$args0" ;;
+        (2) set -- "$args0" "$args1" ;;
+        (3) set -- "$args0" "$args1" "$args2" ;;
+        (4) set -- "$args0" "$args1" "$args2" "$args3" ;;
+        (5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;;
+        (6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;;
+        (7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;;
+        (8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;;
+        (9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;;
+    esac
 fi
 
+# Escape application args
+save () {
+    for i do printf %s\\n "$i" | sed "s/'/'\\\\''/g;1s/^/'/;\$s/\$/' \\\\/" ; done
+    echo " "
+}
+APP_ARGS=$(save "$@")
 
-# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
-DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
+# Collect all arguments for the java command, 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"
 
-# Collect all arguments for the java command:
-#   * DEFAULT_JVM_OPTS, JAVA_OPTS, JAVA_OPTS, and optsEnvironmentVar are not allowed to contain shell fragments,
-#     and any embedded shellness will be escaped.
-#   * For example: A user cannot expect ${Hostname} to be expanded, as it is an environment variable and will be
-#     treated as '${Hostname}' itself on the command line.
-
-set -- \
-        "-Dorg.gradle.appname=$APP_BASE_NAME" \
-        -classpath "$CLASSPATH" \
-        org.gradle.wrapper.GradleWrapperMain \
-        "$@"
-
-# Stop when "xargs" is not available.
-if ! command -v xargs >/dev/null 2>&1
-then
-    die "xargs is not available"
+# 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
 
-# Use "xargs" to parse quoted args.
-#
-# With -n1 it outputs one arg per line, with the quotes and backslashes removed.
-#
-# In Bash we could simply go:
-#
-#   readarray ARGS < <( xargs -n1 <<<"$var" ) &&
-#   set -- "${ARGS[@]}" "$@"
-#
-# but POSIX shell has neither arrays nor command substitution, so instead we
-# post-process each arg (as a line of input to sed) to backslash-escape any
-# character that might be a shell metacharacter, then use eval to reverse
-# that process (while maintaining the separation between arguments), and wrap
-# the whole thing up as a single "set" statement.
-#
-# This will of course break if any of these variables contains a newline or
-# an unmatched quote.
-#
-
-eval "set -- $(
-        printf '%s\n' "$DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS" |
-        xargs -n1 |
-        sed ' s~[^-[:alnum:]+,./:=@_]~\\&~g; ' |
-        tr '\n' ' '
-    )" '"$@"'
-
 exec "$JAVACMD" "$@"

gradlew.bat

@@ -1,20 +1,4 @@
-@rem
-@rem Copyright 2015 the original author or authors.
-@rem
-@rem Licensed under the Apache License, Version 2.0 (the "License");
-@rem you may not use this file except in compliance with the License.
-@rem You may obtain a copy of the License at
-@rem
-@rem      https://www.apache.org/licenses/LICENSE-2.0
-@rem
-@rem Unless required by applicable law or agreed to in writing, software
-@rem distributed under the License is distributed on an "AS IS" BASIS,
-@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-@rem See the License for the specific language governing permissions and
-@rem limitations under the License.
-@rem
-
-@if "%DEBUG%"=="" @echo off
+@if "%DEBUG%" == "" @echo off
 @rem ##########################################################################
 @rem
 @rem  Gradle startup script for Windows
@@ -25,29 +9,25 @@
 if "%OS%"=="Windows_NT" setlocal
 
 set DIRNAME=%~dp0
-if "%DIRNAME%"=="" set DIRNAME=.
-@rem This is normally unused
+if "%DIRNAME%" == "" set DIRNAME=.
 set APP_BASE_NAME=%~n0
 set APP_HOME=%DIRNAME%
 
-@rem Resolve any "." and ".." in APP_HOME to make it shorter.
-for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi
-
 @rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
-set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m"
+set DEFAULT_JVM_OPTS="-Xmx64m"
 
 @rem Find java.exe
 if defined JAVA_HOME goto findJavaFromJavaHome
 
 set JAVA_EXE=java.exe
 %JAVA_EXE% -version >NUL 2>&1
-if %ERRORLEVEL% equ 0 goto execute
+if "%ERRORLEVEL%" == "0" goto init
 
-echo. 1>&2
-echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. 1>&2
-echo. 1>&2
-echo Please set the JAVA_HOME variable in your environment to match the 1>&2
-echo location of your Java installation. 1>&2
+echo.
+echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+echo.
+echo Please set the JAVA_HOME variable in your environment to match the
+echo location of your Java installation.
 
 goto fail
 
@@ -55,36 +35,48 @@ goto fail
 set JAVA_HOME=%JAVA_HOME:"=%
 set JAVA_EXE=%JAVA_HOME%/bin/java.exe
 
-if exist "%JAVA_EXE%" goto execute
+if exist "%JAVA_EXE%" goto init
 
-echo. 1>&2
-echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME% 1>&2
-echo. 1>&2
-echo Please set the JAVA_HOME variable in your environment to match the 1>&2
-echo location of your Java installation. 1>&2
+echo.
+echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
+echo.
+echo Please set the JAVA_HOME variable in your environment to match the
+echo location of your Java installation.
 
 goto fail
 
+:init
+@rem Get command-line arguments, handling Windows variants
+
+if not "%OS%" == "Windows_NT" goto win9xME_args
+
+:win9xME_args
+@rem Slurp the command line arguments.
+set CMD_LINE_ARGS=
+set _SKIP=2
+
+:win9xME_args_slurp
+if "x%~1" == "x" goto execute
+
+set CMD_LINE_ARGS=%*
+
 :execute
 @rem Setup the command line
 
 set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
 
-
 @rem Execute Gradle
-"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %*
+"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %CMD_LINE_ARGS%
 
 :end
 @rem End local scope for the variables with windows NT shell
-if %ERRORLEVEL% equ 0 goto mainEnd
+if "%ERRORLEVEL%"=="0" goto mainEnd
 
 :fail
 rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
 rem the _cmd.exe /c_ return code!
-set EXIT_CODE=%ERRORLEVEL%
-if %EXIT_CODE% equ 0 set EXIT_CODE=1
-if not ""=="%GRADLE_EXIT_CONSOLE%" exit %EXIT_CODE%
-exit /b %EXIT_CODE%
+if  not "" == "%GRADLE_EXIT_CONSOLE%" exit 1
+exit /b 1
 
 :mainEnd
 if "%OS%"=="Windows_NT" endlocal

worldguard-bukkit/build.gradle.kts

@@ -1,74 +1,75 @@
 import com.github.jengelman.gradle.plugins.shadow.tasks.ShadowJar
+import org.gradle.api.internal.HasConvention
 
 plugins {
-    `java-library`
+    id("java-library")
+    id("net.ltgt.apt-eclipse")
+    id("net.ltgt.apt-idea")
 }
 
 applyPlatformAndCoreConfiguration()
 applyShadowConfiguration()
 
 repositories {
+    mavenLocal()
     maven {
         name = "paper"
-        url = uri("https://repo.papermc.io/repository/maven-public/")
+        url = uri("https://papermc.io/repo/repository/maven-public/")
     }
     maven {
-        // TODO: Remove this once paper updated to adventure release
-        name = "adventure-snapshots"
-        url = uri("https://s01.oss.sonatype.org/content/repositories/snapshots/")
+        name = "bstats"
+        url = uri("https://repo.codemc.org/repository/maven-public")
     }
 }
 
-configurations {
-    compileClasspath.get().extendsFrom(create("shadeOnly"))
-}
-
 dependencies {
-    "api"(project(":worldguard-core"))
-    "compileOnly"("io.papermc.paper:paper-api:1.20.6-R0.1-SNAPSHOT")
-    "runtimeOnly"("org.spigotmc:spigot-api:1.20.6-R0.1-SNAPSHOT") {
-        exclude("junit", "junit")
-    }
+    "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.google.guava:guava:${Versions.GUAVA}")
-    "compileOnly"("com.sk89q:commandbook:2.3") { isTransitive = false }
-    "shadeOnly"("io.papermc:paperlib:1.0.8")
-    "shadeOnly"("org.bstats:bstats-bukkit:3.0.1")
+    "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") {
-    val internalVersion = project.ext["internalVersion"]
-    inputs.property("internalVersion", internalVersion)
     filesMatching("plugin.yml") {
-        expand("internalVersion" to internalVersion)
+        expand("internalVersion" to project.ext["internalVersion"])
     }
 }
 
 tasks.named<Jar>("jar") {
-    val projectVersion = project.version
-    inputs.property("projectVersion", projectVersion)
     manifest {
-        attributes("Implementation-Version" to projectVersion)
+        attributes("Implementation-Version" to project.version)
     }
 }
 
 tasks.named<ShadowJar>("shadowJar") {
-    configurations = listOf(project.configurations["shadeOnly"], project.configurations["runtimeClasspath"])
-
     dependencies {
-        include(dependency(":worldguard-core"))
         relocate("org.bstats", "com.sk89q.worldguard.bukkit.bstats") {
-            include(dependency("org.bstats:"))
+            include(dependency("org.bstats:bstats-bukkit:1.5"))
         }
         relocate ("io.papermc.lib", "com.sk89q.worldguard.bukkit.paperlib") {
-            include(dependency("io.papermc:paperlib"))
-        }
-        relocate ("co.aikar.timings.lib", "com.sk89q.worldguard.bukkit.timingslib") {
-            include(dependency("co.aikar:minecraft-timings"))
+            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

@@ -92,10 +92,6 @@ public class BukkitConfigurationManager extends YamlConfigurationManager {
     @Override
     public BukkitWorldConfiguration get(World world) {
         String worldName = world.getName();
-        return get(worldName);
-    }
-
-    public BukkitWorldConfiguration get(String worldName) {
         BukkitWorldConfiguration config = worlds.get(worldName);
         BukkitWorldConfiguration newConfig = null;
 
@@ -103,8 +99,8 @@ public class BukkitConfigurationManager extends YamlConfigurationManager {
             if (newConfig == null) {
                 newConfig = new BukkitWorldConfiguration(plugin, worldName, this.getConfig());
             }
-            worlds.putIfAbsent(worldName, newConfig);
-            config = worlds.get(worldName);
+            worlds.putIfAbsent(world.getName(), newConfig);
+            config = worlds.get(world.getName());
         }
 
         return config;

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

@@ -24,8 +24,6 @@ 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 com.sk89q.worldguard.WorldGuard;
-import com.sk89q.worldguard.util.MessagingUtil;
 import io.papermc.lib.PaperLib;
 import org.bukkit.BanList.Type;
 import org.bukkit.Bukkit;
@@ -174,11 +172,7 @@ public class BukkitPlayer extends com.sk89q.worldedit.bukkit.BukkitPlayer implem
 
     @Override
     public void sendTitle(String title, String subtitle) {
-        if (WorldGuard.getInstance().getPlatform().getGlobalStateManager().get(getWorld()).forceDefaultTitleTimes) {
-            getPlayer().sendTitle(title, subtitle, 10, 70, 20);
-        } else {
-            getPlayer().sendTitle(title, subtitle, -1, -1, -1);
-        }
+        getPlayer().sendTitle(title, subtitle, -1, -1, -1);
     }
 
     @Override
@@ -191,10 +185,7 @@ public class BukkitPlayer extends com.sk89q.worldedit.bukkit.BukkitPlayer implem
         PaperLib.teleportAsync(getPlayer(), BukkitAdapter.adapt(location))
                 .thenApply(success -> {
                     if (success) {
-                        // The success message can be cleared via flag
-                        if (!successMessage.isEmpty()) {
-                            MessagingUtil.sendStringToChat(this, successMessage);
-                        }
+                        print(successMessage);
                     } else {
                         printError(failMessage);
                     }

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

@@ -40,7 +40,7 @@ import com.sk89q.worldguard.chest.ChestProtection;
 import com.sk89q.worldguard.commands.CommandUtils;
 import com.sk89q.worldguard.config.YamlWorldConfiguration;
 import org.bukkit.potion.PotionEffectType;
-import org.yaml.snakeyaml.error.YAMLException;
+import org.yaml.snakeyaml.parser.ParserException;
 
 import java.io.File;
 import java.io.FileNotFoundException;
@@ -105,13 +105,6 @@ public class BukkitWorldConfiguration extends YamlWorldConfiguration {
 
         if (inputs == null || inputs.isEmpty()) {
             parentConfig.setProperty(node, new ArrayList<String>());
-        }
-
-        if (config.getProperty(node) != null) {
-            inputs = config.getStringList(node, null);
-        }
-
-        if (inputs == null || inputs.isEmpty()) {
             return set;
         }
 
@@ -135,13 +128,11 @@ public class BukkitWorldConfiguration extends YamlWorldConfiguration {
             config.load();
         } catch (IOException e) {
             log.log(Level.SEVERE, "Error reading configuration for world " + worldName + ": ", e);
-        } catch (YAMLException e) {
+        } catch (ParserException e) {
             log.severe("Error parsing configuration for world " + worldName + ". ");
             throw e;
         }
 
-        boolean needParentSave = false;
-
         summaryOnStart = getBoolean("summary-on-start", true);
         opPermissions = getBoolean("op-permissions", true);
 
@@ -153,17 +144,13 @@ public class BukkitWorldConfiguration extends YamlWorldConfiguration {
         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);
-        breakDeniedHoppers = getBoolean("event-handling.break-hoppers-on-denied-move", true);
 
         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);
-
-        needParentSave |= removeProperty("protection.disable-obsidian-generators");
-
-        useMaxPriorityAssociation = getBoolean("protection.use-max-priority-association", false);
+        disableObsidianGenerators = getBoolean("protection.disable-obsidian-generators", false);
 
         blockPotions = new HashSet<>();
         for (String potionName : getStringList("gameplay.block-potions", null)) {
@@ -181,11 +168,6 @@ public class BukkitWorldConfiguration extends YamlWorldConfiguration {
         simulateSponge = getBoolean("simulation.sponge.enable", false);
         spongeRadius = Math.max(1, getInt("simulation.sponge.radius", 3)) - 1;
         redstoneSponges = getBoolean("simulation.sponge.redstone", false);
-        if (simulateSponge) {
-            log.warning("Sponge simulation is deprecated for removal in a future version. We recommend using CraftBook's sponge simulation instead.");
-        } else {
-            needParentSave |= removeProperty("simulation");
-        }
 
         pumpkinScuba = getBoolean("default.pumpkin-scuba", false);
         disableHealthRegain = getBoolean("default.disable-health-regain", false);
@@ -226,7 +208,6 @@ public class BukkitWorldConfiguration extends YamlWorldConfiguration {
         blockGroundSlimes = getBoolean("mobs.block-above-ground-slimes", false);
         blockOtherExplosions = getBoolean("mobs.block-other-explosions", false);
         blockZombieDoorDestruction = getBoolean("mobs.block-zombie-door-destruction", false);
-        blockEntityVehicleEntry = getBoolean("mobs.block-vehicle-entry", false);
 
         disableFallDamage = getBoolean("player-damage.disable-fall-damage", false);
         disableLavaDamage = getBoolean("player-damage.disable-lava-damage", false);
@@ -244,21 +225,11 @@ public class BukkitWorldConfiguration extends YamlWorldConfiguration {
         disableDeathMessages = getBoolean("player-damage.disable-death-messages", false);
 
         signChestProtection = getBoolean("chest-protection.enable", false);
-        disableSignChestProtectionCheck = getBoolean("chest-protection.disable-off-check", true);
-        if (signChestProtection) {
-            log.warning("Sign-based chest protection is deprecated for removal in a future version. See https://worldguard.enginehub.org/en/latest/chest-protection/ for details.");
-        } else {
-            needParentSave |= removeProperty("chest-protection");
-        }
+        disableSignChestProtectionCheck = getBoolean("chest-protection.disable-off-check", false);
 
         disableCreatureCropTrampling = getBoolean("crops.disable-creature-trampling", false);
         disablePlayerCropTrampling = getBoolean("crops.disable-player-trampling", false);
 
-        disableCreatureTurtleEggTrampling = getBoolean("turtle-egg.disable-creature-trampling", false);
-        disablePlayerTurtleEggTrampling = getBoolean("turtle-egg.disable-player-trampling", false);
-        disableCreatureSnifferEggTrampling = getBoolean("sniffer-egg.disable-creature-trampling", false);
-        disablePlayerSnifferEggTrampling = getBoolean("sniffer-egg.disable-player-trampling", false);
-
         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);
@@ -278,19 +249,14 @@ public class BukkitWorldConfiguration extends YamlWorldConfiguration {
         disableGrassGrowth = getBoolean("dynamics.disable-grass-growth", false);
         disableMyceliumSpread = getBoolean("dynamics.disable-mycelium-spread", false);
         disableVineGrowth = getBoolean("dynamics.disable-vine-growth", false);
-        disableRockGrowth = getBoolean("dynamics.disable-rock-growth", false);
-        disableSculkGrowth = getBoolean("dynamics.disable-sculk-growth", false);
         disableCropGrowth = getBoolean("dynamics.disable-crop-growth", false);
         disableSoilDehydration = getBoolean("dynamics.disable-soil-dehydration", false);
-        disableCoralBlockFade = getBoolean("dynamics.disable-coral-block-fade", false);
-        disableCopperBlockFade = getBoolean("dynamics.disable-copper-block-fade", false);
         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", true);
-        forceDefaultTitleTimes = config.getBoolean("regions.titles-always-use-default-times", true); // note: technically not region-specific, but we only use it for the title flags
+        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);
@@ -298,7 +264,6 @@ public class BukkitWorldConfiguration extends YamlWorldConfiguration {
         regionWand = convertLegacyItem(getString("regions.wand", ItemTypes.LEATHER.getId()));
         maxClaimVolume = getInt("regions.max-claim-volume", 30000);
         claimOnlyInsideExistingRegions = getBoolean("regions.claim-only-inside-existing-regions", false);
-        setParentOnClaim = getString("regions.set-parent-on-claim", "");
         boundedLocationFlags = getBoolean("regions.location-flags-only-inside-regions", false);
 
         maxRegionCountPerPlayer = getInt("regions.max-region-count-per-player.default", 7);
@@ -420,20 +385,6 @@ public class BukkitWorldConfiguration extends YamlWorldConfiguration {
         config.setHeader(CONFIG_HEADER);
 
         config.save();
-        if (needParentSave) {
-            parentConfig.save();
-        }
-    }
-
-    private boolean removeProperty(String prop) {
-        if (config.getProperty(prop) != null) {
-            config.removeProperty(prop);
-        }
-        if (parentConfig.getProperty(prop) != null) {
-            parentConfig.removeProperty(prop);
-            return true;
-        }
-        return false;
     }
 
     public boolean isChestProtected(Location block, LocalPlayer player) {

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

@@ -31,10 +31,9 @@ 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.PaperPlayerService;
+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.DatapackReport;
 import com.sk89q.worldguard.bukkit.util.report.PerformanceReport;
 import com.sk89q.worldguard.bukkit.util.report.PluginReport;
 import com.sk89q.worldguard.bukkit.util.report.SchedulerReport;
@@ -68,7 +67,7 @@ import java.util.stream.Collectors;
 
 public class BukkitWorldGuardPlatform implements WorldGuardPlatform {
 
-    private BukkitSessionManager sessionManager;
+    private SessionManager sessionManager;
     private BukkitConfigurationManager configuration;
     private BukkitRegionContainer regionContainer;
     private BukkitDebugHandler debugHandler;
@@ -146,7 +145,6 @@ public class BukkitWorldGuardPlatform implements WorldGuardPlatform {
 
     @Override
     public void unload() {
-        sessionManager.shutdown();
         configuration.unload();
         regionContainer.shutdown();
     }
@@ -174,6 +172,7 @@ public class BukkitWorldGuardPlatform implements WorldGuardPlatform {
     @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();
 
@@ -207,7 +206,12 @@ public class BukkitWorldGuardPlatform implements WorldGuardPlatform {
                     }
 
                     // Same type?
-                    if (item2.isSimilar(item)) {
+                    // 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);
@@ -239,7 +243,6 @@ public class BukkitWorldGuardPlatform implements WorldGuardPlatform {
         report.add(new ServicesReport());
         report.add(new WorldReport());
         report.add(new PerformanceReport());
-        if (PaperLib.isPaper()) report.add(new DatapackReport());
     }
 
     @Override
@@ -247,7 +250,7 @@ public class BukkitWorldGuardPlatform implements WorldGuardPlatform {
         List<ProfileService> services = new ArrayList<>();
         if (PaperLib.isPaper()) {
             // Paper has a shared cache
-            services.add(PaperPlayerService.getInstance());
+            services.add(PaperProfileService.getInstance());
         } else {
             services.add(BukkitPlayerService.getInstance());
         }
@@ -266,7 +269,7 @@ public class BukkitWorldGuardPlatform implements WorldGuardPlatform {
                 if (radius > 0) {
                     BlockVector3 spawnLoc = BukkitAdapter.asBlockVector(bWorld.getSpawnLocation());
                     return new ProtectedCuboidRegion("__spawn_protection__",
-                            spawnLoc.subtract(radius, 0, radius).withY(world.getMinimumPoint().y()),
+                            spawnLoc.subtract(radius, 0, radius).withY(world.getMinimumPoint().getY()),
                             spawnLoc.add(radius, 0, radius).withY(world.getMaxY()));
                 }
             }

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

@@ -20,6 +20,7 @@
 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;
@@ -59,9 +60,8 @@ 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.ClassSourceValidator;
-import com.sk89q.worldguard.bukkit.util.Entities;
 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;
@@ -72,12 +72,10 @@ 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.bstats.charts.DrilldownPie;
-import org.bstats.charts.SimplePie;
-import org.bstats.charts.SingleLineChart;
 import org.bukkit.Bukkit;
 import org.bukkit.ChatColor;
 import org.bukkit.OfflinePlayer;
@@ -95,8 +93,9 @@ import java.io.IOException;
 import java.io.InputStream;
 import java.util.HashMap;
 import java.util.Map;
-import java.util.logging.Level;
+import java.util.jar.JarFile;
 import java.util.logging.Logger;
+import java.util.zip.ZipEntry;
 
 /**
  * The main class for WorldGuard as a Bukkit plugin.
@@ -108,8 +107,6 @@ public class WorldGuardPlugin extends JavaPlugin {
     private final CommandsManager<Actor> commands;
     private PlayerMoveListener playerMoveListener;
 
-    private static final int BSTATS_PLUGIN_ID = 3283;
-
     /**
      * Construct objects. Actual loading occurs when the plugin is enabled, so
      * this merely instantiates the objects.
@@ -137,10 +134,6 @@ public class WorldGuardPlugin extends JavaPlugin {
      */
     @Override
     public void onEnable() {
-        // Catch bad things being done by naughty plugins that include WorldGuard's classes
-        ClassSourceValidator verifier = new ClassSourceValidator(this);
-        verifier.reportMismatches(ImmutableList.of(WorldGuard.class, ProtectedRegion.class, Flag.class));
-
         configureLogger();
 
         getDataFolder().mkdirs(); // Need to create the plugins/WorldGuard folder
@@ -154,14 +147,21 @@ public class WorldGuardPlugin extends JavaPlugin {
         // 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);
 
-        if (!platform.getGlobalStateManager().hasCommandBookGodMode()) {
-            reg.register(GeneralCommands.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);
 
@@ -214,20 +214,20 @@ public class WorldGuardPlugin extends JavaPlugin {
         ((SimpleFlagRegistry) WorldGuard.getInstance().getFlagRegistry()).setInitialized(true);
 
         // Enable metrics
-        final Metrics metrics = new Metrics(this, BSTATS_PLUGIN_ID); // bStats plugin id
-        if (platform.getGlobalStateManager().extraStats) {
+        final Metrics metrics = new Metrics(this);
+        if (metrics.isEnabled() && platform.getGlobalStateManager().extraStats) {
             setupCustomCharts(metrics);
         }
     }
 
     private void setupCustomCharts(Metrics metrics) {
-        metrics.addCustomChart(new SingleLineChart("region_count", () ->
+        metrics.addCustomChart(new Metrics.SingleLineChart("region_count", () ->
                 platform.getRegionContainer().getLoaded().stream().mapToInt(RegionManager::size).sum()));
-        metrics.addCustomChart(new SimplePie("region_driver", () -> {
+        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 DrilldownPie("blacklist", () -> {
+        metrics.addCustomChart(new Metrics.DrilldownPie("blacklist", () -> {
             int empty = 0;
             Map<String, Integer> blacklistMap = new HashMap<>();
             Map<String, Integer> whitelistMap = new HashMap<>();
@@ -250,14 +250,14 @@ public class WorldGuardPlugin extends JavaPlugin {
             blacklistCounts.put("whitelist", whitelistMap);
             return blacklistCounts;
         }));
-        metrics.addCustomChart(new SimplePie("chest_protection", () ->
+        metrics.addCustomChart(new Metrics.SimplePie("chest_protection", () ->
                 "" + platform.getGlobalStateManager().getWorldConfigs().stream().anyMatch(cfg -> cfg.signChestProtection)));
-        metrics.addCustomChart(new SimplePie("build_permissions", () ->
+        metrics.addCustomChart(new Metrics.SimplePie("build_permissions", () ->
                 "" + platform.getGlobalStateManager().getWorldConfigs().stream().anyMatch(cfg -> cfg.buildPermissions)));
 
-        metrics.addCustomChart(new SimplePie("custom_flags", () ->
+        metrics.addCustomChart(new Metrics.SimplePie("custom_flags", () ->
                 "" + (WorldGuard.getInstance().getFlagRegistry().size() > Flags.INBUILT_FLAGS.size())));
-        metrics.addCustomChart(new SimplePie("custom_handlers", () ->
+        metrics.addCustomChart(new Metrics.SimplePie("custom_handlers", () ->
                 "" + (WorldGuard.getInstance().getPlatform().getSessionManager().customHandlersRegistered())));
     }
 
@@ -387,8 +387,6 @@ public class WorldGuardPlugin extends JavaPlugin {
         Plugin worldEdit = getServer().getPluginManager().getPlugin("WorldEdit");
         if (worldEdit == null) {
             throw new CommandException("WorldEdit does not appear to be installed.");
-        } else if (!worldEdit.isEnabled()) {
-            throw new CommandException("WorldEdit does not appear to be enabled.");
         }
 
         if (worldEdit instanceof WorldEditPlugin) {
@@ -420,9 +418,8 @@ public class WorldGuardPlugin extends JavaPlugin {
     }
 
     public Actor wrapCommandSender(CommandSender sender) {
-        if (sender instanceof Player player) {
-            if (Entities.isNPC(player)) return null;
-            return wrapPlayer(player);
+        if (sender instanceof Player) {
+            return wrapPlayer((Player) sender);
         }
 
         try {
@@ -455,13 +452,6 @@ public class WorldGuardPlugin extends JavaPlugin {
         return new BukkitOfflinePlayer(this, player);
     }
 
-    /**
-     * Internal method. Do not use as API.
-     */
-    public BukkitConfigurationManager getConfigManager() {
-        return platform.getGlobalStateManager();
-    }
-
     /**
      * Return a protection query helper object that can be used by another
      * plugin to test whether WorldGuard permits an action at a particular
@@ -498,25 +488,44 @@ public class WorldGuardPlugin extends JavaPlugin {
             return;
         }
 
-        try (InputStream stream = getResource("defaults/" + defaultName)){
-            if (stream == null) throw new FileNotFoundException();
-            copyDefaultConfig(stream, actual, defaultName);
+        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) {
-            getLogger().severe("Unable to read default configuration: " + defaultName);
+            WorldGuard.logger.severe("Unable to read default configuration: " + defaultName);
         }
 
-    }
+        if (input != null) {
+            FileOutputStream output = null;
 
-    private void copyDefaultConfig(InputStream input, File actual, String name) {
-        try (FileOutputStream output = new FileOutputStream(actual)) {
-            byte[] buf = new byte[8192];
-            int length;
-            while ((length = input.read(buf)) > 0) {
-                output.write(buf, 0, length);
+            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) {
+                }
             }
-            getLogger().info("Default configuration file written: " + name);
-        } catch (IOException e) {
-            getLogger().log(Level.WARNING, "Failed to write default config file", e);
         }
     }
 

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

@@ -21,29 +21,21 @@ package com.sk89q.worldguard.bukkit.cause;
 
 import com.google.common.base.Joiner;
 import com.google.common.collect.Sets;
-import com.sk89q.worldguard.bukkit.BukkitWorldConfiguration;
-import com.sk89q.worldguard.bukkit.WorldGuardPlugin;
 import com.sk89q.worldguard.bukkit.internal.WGMetadata;
-import com.sk89q.worldguard.bukkit.util.Entities;
 import io.papermc.lib.PaperLib;
 import org.bukkit.Bukkit;
-import org.bukkit.OfflinePlayer;
 import org.bukkit.block.Block;
-import org.bukkit.entity.AnimalTamer;
 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.LightningStrike;
 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 org.bukkit.projectiles.BlockProjectileSource;
-import org.bukkit.projectiles.ProjectileSource;
 
 import javax.annotation.Nullable;
 import java.util.ArrayList;
@@ -96,39 +88,26 @@ public final class Cause {
     }
 
     /**
-     * Return whether a cause is known. This method will return false if
-     * the list of causes is empty or the root cause is really not known
-     * (e.g. primed TNT).
+     * Return whether a cause is known. This method will return true if
+     * the list of causes is empty or the list of causes only contains
+     * objects that really are not root causes (i.e primed TNT).
      *
      * @return true if known
      */
     public boolean isKnown() {
-        Object object = getRootCause();
-
-        if (object == null) {
+        if (causes.isEmpty()) {
             return false;
         }
 
-        if (object instanceof Tameable tameable && tameable.isTamed()) {
-            // if they're tamed but also the root cause, the owner is offline
-            // otherwise the owner will be the root cause (and known)
-            return false;
-        }
-
-        if (object instanceof TNTPrimed || object instanceof Vehicle) {
-            if (!PaperLib.isPaper()) {
-                return false;
-            }
-
-            Entity entity = (Entity) object;
-            BukkitWorldConfiguration config = WorldGuardPlugin.inst().getConfigManager().get(entity.getWorld().getName());
-
-            if (!config.usePaperEntityOrigin || entity.getOrigin() == null) {
-                return false;
+        boolean found = false;
+        for (Object object : causes) {
+            if (!(object instanceof TNTPrimed) && !(object instanceof Vehicle)) {
+                found = true;
+                break;
             }
         }
 
-        return true;
+        return found;
     }
 
     @Nullable
@@ -143,8 +122,8 @@ public final class Cause {
     @Nullable
     public Player getFirstPlayer() {
         for (Object object : causes) {
-            if (object instanceof Player p && !Entities.isNPC(p)) {
-                return p;
+            if (object instanceof Player) {
+                return (Player) object;
             }
         }
 
@@ -154,8 +133,8 @@ public final class Cause {
     @Nullable
     public Entity getFirstEntity() {
         for (Object object : causes) {
-            if (object instanceof Entity e) {
-                return e;
+            if (object instanceof Entity) {
+                return (Entity) object;
             }
         }
 
@@ -165,8 +144,8 @@ public final class Cause {
     @Nullable
     public Entity getFirstNonPlayerEntity() {
         for (Object object : causes) {
-            if (object instanceof Entity e && (!(object instanceof Player) || Entities.isNPC(e))) {
-                return e;
+            if (object instanceof Entity && !(object instanceof Player)) {
+                return (Entity) object;
             }
         }
 
@@ -176,8 +155,8 @@ public final class Cause {
     @Nullable
     public Block getFirstBlock() {
         for (Object object : causes) {
-            if (object instanceof Block b) {
-                return b;
+            if (object instanceof Block) {
+                return (Block) object;
             }
         }
 
@@ -257,15 +236,6 @@ public final class Cause {
         WGMetadata.put(target, CAUSE_KEY, parent);
     }
 
-    /**
-     * Remove a parent cause from a {@code Metadatable} object.
-     *
-     * @param target the target
-     */
-    public static void untrackParentCause(Metadatable target) {
-        WGMetadata.remove(target, CAUSE_KEY);
-    }
-
     /**
      * Builds causes.
      */
@@ -279,22 +249,19 @@ public final class Cause {
         }
 
         private void addAll(@Nullable Object... element) {
-            if (element == null) {
-                return;
-            }
-            for (Object o : element) {
-                if (o == null || seen.contains(o)) {
-                    continue;
-                }
+            if (element != null) {
+                for (Object o : element) {
+                    if (o == null || seen.contains(o)) {
+                        continue;
+                    }
 
-                seen.add(o);
+                    seen.add(o);
 
-                if (o instanceof TNTPrimed) {
-                    addAll(((TNTPrimed) o).getSource());
-                } else if (o instanceof Projectile) {
-                    ProjectileSource shooter = ((Projectile) o).getShooter();
-                    addAll(shooter);
-                    if (shooter == null && o instanceof Firework && PaperLib.isPaper()) {
+                    if (o instanceof TNTPrimed) {
+                        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);
@@ -302,53 +269,32 @@ public final class Cause {
                                 addAll(spawningEntity);
                             }
                         }
+                    } else if (o instanceof Vehicle) {
+                        ((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());
+                    } else if (o instanceof Tameable) {
+                        indirect = true;
+                        addAll(((Tameable) o).getOwner());
                     }
-                } else if (o instanceof Vehicle) {
-                    ((Vehicle) o).getPassengers().forEach(this::addAll);
-                } else if (o instanceof AreaEffectCloud) {
-                    indirect = true;
-                    addAll(((AreaEffectCloud) o).getSource());
-                } else if (o instanceof Tameable tameable) {
-                    indirect = true;
-                    if (PaperLib.isPaper()) {
-                        UUID ownerId = tameable.getOwnerUniqueId();
-                        if (ownerId != null) {
-                            Player owner = Bukkit.getPlayer(ownerId);
-                            if (owner != null) {
-                                addAll(owner);
-                            }
-                        }
-                    } else {
-                        // this will cause offline player loads if the player is offline
-                        // too bad for spigot users
-                        AnimalTamer owner = tameable.getOwner();
-                        if (owner instanceof OfflinePlayer player) {
-                            addAll(player.getPlayer()); // player object if online, else null
+
+                    // Add manually tracked parent causes
+                    Object source = o;
+                    int index = causes.size();
+                    while (source instanceof Metadatable && !(source instanceof Block)) {
+                        source = WGMetadata.getIfPresent((Metadatable) source, CAUSE_KEY, Object.class);
+                        if (source != null) {
+                            causes.add(index, source);
+                            seen.add(source);
                         }
                     }
-                } else if (o instanceof Creature && ((Creature) o).getTarget() != null) {
-                    indirect = true;
-                    addAll(((Creature) o).getTarget());
-                } else if (o instanceof BlockProjectileSource) {
-                    addAll(((BlockProjectileSource) o).getBlock());
-                } else if (o instanceof LightningStrike && PaperLib.isPaper() &&
-                        ((LightningStrike) o).getCausingEntity() != null) {
-                    indirect = true;
-                    addAll(((LightningStrike) o).getCausingEntity());
-                }
 
-                // Add manually tracked parent causes
-                Object source = o;
-                int index = causes.size();
-                while (source instanceof Metadatable && !(source instanceof Block)) {
-                    source = WGMetadata.getIfPresent((Metadatable) source, CAUSE_KEY, Object.class);
-                    if (source != null) {
-                        causes.add(index, source);
-                        seen.add(source);
-                    }
+                    causes.add(o);
                 }
-
-                causes.add(o);
             }
         }
 

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

@@ -75,13 +75,4 @@ public final class WGMetadata {
         return null;
     }
 
-    /**
-     * Removes metadata from the target.
-     *
-     * @param target the target
-     * @param key the key
-     */
-    public static void remove(Metadatable target, String key) {
-        target.removeMetadata(key, WorldGuardPlugin.inst());
-    }
 }

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

@@ -22,17 +22,16 @@ 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.BukkitConfigurationManager;
-import com.sk89q.worldguard.bukkit.BukkitPlayer;
 import com.sk89q.worldguard.bukkit.BukkitWorldConfiguration;
 import com.sk89q.worldguard.bukkit.WorldGuardPlugin;
 import com.sk89q.worldguard.bukkit.cause.Cause;
-import com.sk89q.worldguard.bukkit.util.Entities;
+import com.sk89q.worldguard.config.ConfigurationManager;
 import com.sk89q.worldguard.config.WorldConfiguration;
 import com.sk89q.worldguard.domains.Association;
-import com.sk89q.worldguard.protection.association.DelayedRegionOverlapAssociation;
+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;
@@ -73,8 +72,8 @@ class AbstractListener implements Listener {
      *
      * @return the plugin
      */
-    protected static WorldGuardPlugin getPlugin() {
-        return WorldGuardPlugin.inst();
+    protected WorldGuardPlugin getPlugin() {
+        return plugin;
     }
 
     /**
@@ -82,8 +81,8 @@ class AbstractListener implements Listener {
      *
      * @return the configuration
      */
-    protected static BukkitConfigurationManager getConfig() {
-        return getPlugin().getConfigManager();
+    protected static ConfigurationManager getConfig() {
+        return WorldGuard.getInstance().getPlatform().getGlobalStateManager();
     }
 
     /**
@@ -92,22 +91,18 @@ class AbstractListener implements Listener {
      * @param world The world to get the configuration for.
      * @return The configuration for {@code world}
      */
-    protected static BukkitWorldConfiguration getWorldConfig(String world) {
+    protected static WorldConfiguration getWorldConfig(World world) {
         return getConfig().get(world);
     }
 
-    protected static BukkitWorldConfiguration getWorldConfig(org.bukkit.World world) {
-        return getWorldConfig(world.getName());
-    }
-
     /**
      * 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 BukkitWorldConfiguration getWorldConfig(LocalPlayer player) {
-        return getWorldConfig(((BukkitPlayer) player).getPlayer().getWorld());
+    protected static WorldConfiguration getWorldConfig(LocalPlayer player) {
+        return getWorldConfig((World) player.getExtent());
     }
 
     /**
@@ -116,7 +111,7 @@ class AbstractListener implements Listener {
      * @param world the world
      * @return true if region support is enabled
      */
-    protected static boolean isRegionSupportEnabled(org.bukkit.World world) {
+    protected static boolean isRegionSupportEnabled(World world) {
         return getWorldConfig(world).useRegions;
     }
 
@@ -125,30 +120,27 @@ class AbstractListener implements Listener {
 
         if (!cause.isKnown()) {
             return Associables.constant(Association.NON_MEMBER);
-        } else if (rootCause instanceof Player player && !Entities.isNPC(player)) {
-            return getPlugin().wrapPlayer(player);
-        } else if (rootCause instanceof OfflinePlayer offlinePlayer) {
-            return getPlugin().wrapOfflinePlayer(offlinePlayer);
-        } else if (rootCause instanceof Entity entity) {
+        } 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();
-            BukkitWorldConfiguration config = getWorldConfig(entity.getWorld());
+            final Entity entity = (Entity) rootCause;
             Location loc;
-            if (PaperLib.isPaper()  && config.usePaperEntityOrigin) {
+            if (PaperLib.isPaper()
+                    && ((BukkitWorldConfiguration) getWorldConfig(BukkitAdapter.adapt(entity.getWorld()))).usePaperEntityOrigin) {
                 loc = entity.getOrigin();
-                // Origin world may be null, and thus a Location with a null world created, which cannot be adapted to a WorldEdit location
-                if (loc == null || loc.getWorld() == null) {
+                if (loc == null) {
                     loc = entity.getLocation();
                 }
             } else {
                 loc = entity.getLocation();
             }
-            return new DelayedRegionOverlapAssociation(query, BukkitAdapter.adapt(loc),
-                    config.useMaxPriorityAssociation);
-        } else if (rootCause instanceof Block block) {
+            return new DelayedRegionOverlapAssociation(query, BukkitAdapter.adapt(loc));
+        } else if (rootCause instanceof Block) {
             RegionQuery query = WorldGuard.getInstance().getPlatform().getRegionContainer().createQuery();
-            Location loc = block.getLocation();
-            return new DelayedRegionOverlapAssociation(query, BukkitAdapter.adapt(loc),
-                    getWorldConfig(loc.getWorld()).useMaxPriorityAssociation);
+            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

@@ -31,7 +31,6 @@ 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.BukkitWorldConfiguration;
 import com.sk89q.worldguard.bukkit.WorldGuardPlugin;
 import com.sk89q.worldguard.bukkit.event.block.BreakBlockEvent;
 import com.sk89q.worldguard.bukkit.event.block.PlaceBlockEvent;
@@ -50,7 +49,6 @@ 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.ClickType;
 import org.bukkit.event.inventory.InventoryAction;
 import org.bukkit.event.inventory.InventoryClickEvent;
 import org.bukkit.event.inventory.InventoryCreativeEvent;
@@ -60,7 +58,6 @@ import org.bukkit.event.player.PlayerDropItemEvent;
 import org.bukkit.event.player.PlayerItemHeldEvent;
 import org.bukkit.inventory.Inventory;
 import org.bukkit.inventory.ItemStack;
-import org.bukkit.inventory.PlayerInventory;
 
 import static com.sk89q.worldguard.bukkit.BukkitUtil.createTarget;
 
@@ -80,19 +77,20 @@ public class BlacklistListener extends AbstractListener {
 
     @EventHandler(ignoreCancelled = true)
     public void onBreakBlock(final BreakBlockEvent event) {
-        final WorldConfiguration wcfg = getWorldConfig(event.getWorld());
-
-        // Blacklist guard
-        if (wcfg.getBlacklist() == null) {
-            return;
-        }
-        Player player = event.getCause().getFirstPlayer();
+        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),
@@ -110,12 +108,6 @@ public class BlacklistListener extends AbstractListener {
 
     @EventHandler(ignoreCancelled = true)
     public void onPlaceBlock(final PlaceBlockEvent event) {
-        final WorldConfiguration wcfg = getWorldConfig(event.getWorld());
-
-        // Blacklist guard
-        if (wcfg.getBlacklist() == null) {
-            return;
-        }
         Player player = event.getCause().getFirstPlayer();
 
         if (player == null) {
@@ -123,18 +115,19 @@ public class BlacklistListener extends AbstractListener {
         }
 
         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) {
-        final WorldConfiguration wcfg = getWorldConfig(event.getWorld());
-
-        // Blacklist guard
-        if (wcfg.getBlacklist() == null) {
-            return;
-        }
         Player player = event.getCause().getFirstPlayer();
 
         if (player == null) {
@@ -142,25 +135,33 @@ public class BlacklistListener extends AbstractListener {
         }
 
         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) {
-        final WorldConfiguration wcfg = getWorldConfig(event.getWorld());
-
-        // Blacklist guard
-        if (wcfg.getBlacklist() == null) {
-            return;
-        }
         Player player = event.getCause().getFirstPlayer();
 
         if (player == null) {
             return;
         }
 
-        final LocalPlayer localPlayer = getPlugin().wrapPlayer(player);
+        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(
@@ -172,20 +173,21 @@ public class BlacklistListener extends AbstractListener {
 
     @EventHandler(ignoreCancelled = true)
     public void onDestroyEntity(DestroyEntityEvent event) {
-        final WorldConfiguration wcfg = getWorldConfig(event.getWorld());
-
-        // Blacklist guard
-        if (wcfg.getBlacklist() == null) {
-            return;
-        }
         Player player = event.getCause().getFirstPlayer();
 
         if (player == null) {
             return;
         }
 
-        final LocalPlayer localPlayer = getPlugin().wrapPlayer(player);
+        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(
@@ -208,20 +210,21 @@ public class BlacklistListener extends AbstractListener {
 
     @EventHandler(ignoreCancelled = true)
     public void onUseItem(UseItemEvent event) {
-        final WorldConfiguration wcfg = getWorldConfig(event.getWorld());
-
-        // Blacklist guard
-        if (wcfg.getBlacklist() == null) {
-            return;
-        }
         Player player = event.getCause().getFirstPlayer();
 
         if (player == null) {
             return;
         }
 
-        final LocalPlayer localPlayer = getPlugin().wrapPlayer(player);
+        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);
@@ -236,7 +239,8 @@ public class BlacklistListener extends AbstractListener {
 
     @EventHandler(ignoreCancelled = true)
     public void onPlayerDropItem(PlayerDropItemEvent event) {
-        WorldConfiguration wcfg = getWorldConfig(event.getPlayer().getWorld());
+        ConfigurationManager cfg = WorldGuard.getInstance().getPlatform().getGlobalStateManager();
+        WorldConfiguration wcfg = cfg.get(BukkitAdapter.adapt(event.getPlayer().getWorld()));
 
         if (wcfg.getBlacklist() != null) {
             Item ci = event.getItemDrop();
@@ -251,7 +255,8 @@ public class BlacklistListener extends AbstractListener {
 
     @EventHandler(ignoreCancelled = true)
     public void onBlockDispense(BlockDispenseEvent event) {
-        BukkitWorldConfiguration wcfg = getWorldConfig(event.getBlock().getWorld());
+        ConfigurationManager cfg = WorldGuard.getInstance().getPlatform().getGlobalStateManager();
+        WorldConfiguration wcfg = cfg.get(BukkitAdapter.adapt(event.getBlock().getWorld()));
 
         if (wcfg.getBlacklist() != null) {
             if (!wcfg.getBlacklist().check(new BlockDispenseBlacklistEvent(null, BukkitAdapter.asBlockVector(event.getBlock().getLocation()),
@@ -270,7 +275,8 @@ public class BlacklistListener extends AbstractListener {
 
         if (item != null && inventory.getHolder() != null) {
             Player player = (Player) entity;
-            WorldConfiguration wcfg = getWorldConfig(player.getWorld());
+            ConfigurationManager cfg = WorldGuard.getInstance().getPlatform().getGlobalStateManager();
+            WorldConfiguration wcfg = cfg.get(BukkitAdapter.adapt(entity.getWorld()));
             LocalPlayer localPlayer = getPlugin().wrapPlayer(player);
 
             if (wcfg.getBlacklist() != null && !wcfg.getBlacklist().check(
@@ -324,16 +330,12 @@ public class BlacklistListener extends AbstractListener {
                         return cursor;
                     }
                 case HOTBAR_SWAP:
-                    if (event.getClick() == ClickType.SWAP_OFFHAND) {
-                        return clickedInventory == null ? null : ((PlayerInventory) clickedInventory).getItemInOffHand();
-                    }
                     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.getView().getTopInventory().getType() == InventoryType.CRAFTING)
+                && event.getView().getTopInventory().getType() == InventoryType.PLAYER
                 && event.getAction() == InventoryAction.MOVE_TO_OTHER_INVENTORY) {
             return event.getCurrentItem();
         }
@@ -347,7 +349,8 @@ public class BlacklistListener extends AbstractListener {
 
         if (item.getType() != Material.AIR && entity instanceof Player) {
             Player player = (Player) entity;
-            WorldConfiguration wcfg = getWorldConfig(player.getWorld());
+            ConfigurationManager cfg = WorldGuard.getInstance().getPlatform().getGlobalStateManager();
+            WorldConfiguration wcfg = cfg.get(BukkitAdapter.adapt(entity.getWorld()));
             LocalPlayer localPlayer = getPlugin().wrapPlayer(player);
 
             if (wcfg.getBlacklist() != null && !wcfg.getBlacklist().check(
@@ -364,7 +367,8 @@ public class BlacklistListener extends AbstractListener {
         ItemStack item = inventory.getItem(event.getNewSlot());
 
         if (item != null) {
-            WorldConfiguration wcfg = getWorldConfig(player.getWorld());
+            ConfigurationManager cfg = WorldGuard.getInstance().getPlatform().getGlobalStateManager();
+            WorldConfiguration wcfg = cfg.get(BukkitAdapter.adapt(player.getWorld()));
             LocalPlayer localPlayer = getPlugin().wrapPlayer(player);
 
             if (wcfg.getBlacklist() != null && !wcfg.getBlacklist().check(
@@ -380,7 +384,8 @@ public class BlacklistListener extends AbstractListener {
         Player player = ((Player) event.getTargetEntity());
         ItemStack stack = event.getItem();
 
-        WorldConfiguration wcfg = getWorldConfig(player.getWorld());
+        ConfigurationManager cfg = WorldGuard.getInstance().getPlatform().getGlobalStateManager();
+        WorldConfiguration wcfg = cfg.get(BukkitAdapter.adapt(player.getWorld()));
         LocalPlayer localPlayer = getPlugin().wrapPlayer(player);
         if (wcfg.getBlacklist() != null && !wcfg.getBlacklist().check(
                 new ItemEquipBlacklistEvent(localPlayer, BukkitAdapter.asBlockVector(player.getLocation()), createTarget(stack)), false, true)) {

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

@@ -19,11 +19,14 @@
 
 package com.sk89q.worldguard.bukkit.listener;
 
+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;
@@ -35,10 +38,6 @@ import org.bukkit.inventory.ItemStack;
 import org.bukkit.inventory.meta.PotionMeta;
 import org.bukkit.potion.PotionEffect;
 import org.bukkit.potion.PotionEffectType;
-import org.bukkit.potion.PotionType;
-
-import java.util.ArrayList;
-import java.util.List;
 
 /**
  * Handles blocked potions.
@@ -54,56 +53,51 @@ public class BlockedPotionsListener extends AbstractListener {
         super(plugin);
     }
 
-    private PotionEffectType getBlockedEffectByArrow(Arrow arrow, BukkitWorldConfiguration wcfg) {
-        List<PotionEffect> effects = new ArrayList<>();
-        PotionType potionType = arrow.getBasePotionType();
-        if (potionType != null) {
-            effects.addAll(potionType.getPotionEffects());
-        }
-        effects.addAll(arrow.getCustomEffects());
-        for (PotionEffect potionEffect : effects) {
-            if (wcfg.blockPotions.contains(potionEffect.getType())) {
-                return potionEffect.getType();
-            }
-        }
-        return null;
-    }
-
-
     @EventHandler
     public void onProjectile(DamageEntityEvent event) {
-        if (!(event.getOriginalEvent() instanceof EntityDamageByEntityEvent originalEvent)) {
-            return;
-        }
-        if (!Entities.isPotionArrow(originalEvent.getDamager())) {
-            return;
-        }
-
-        BukkitWorldConfiguration wcfg = getWorldConfig(event.getWorld());
-        PotionEffectType blockedEffect = null;
-        if (originalEvent.getDamager() instanceof SpectralArrow) {
-            if (wcfg.blockPotions.contains(PotionEffectType.GLOWING)) {
-                blockedEffect = PotionEffectType.GLOWING;
-            }
-        } else if (originalEvent.getDamager() instanceof Arrow arrow) {
-            blockedEffect = getBlockedEffectByArrow(arrow, wcfg);
-        }
-        if (blockedEffect != null) {
-            Player player = event.getCause().getFirstPlayer();
-            if (player != null) {
-                if (getPlugin().hasPermission(player, "worldguard.override.potions")) {
-                    return;
+        if (event.getOriginalEvent() instanceof EntityDamageByEntityEvent) {
+            EntityDamageByEntityEvent originalEvent = (EntityDamageByEntityEvent) event.getOriginalEvent();
+            if (Entities.isPotionArrow(originalEvent.getDamager())) { // should take care of backcompat
+                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 Arrow) {
+                    Arrow tippedArrow = (Arrow) originalEvent.getDamager();
+                    PotionEffectType baseEffect = tippedArrow.getBasePotionData().getType().getEffectType();
+                    if (wcfg.blockPotions.contains(baseEffect)) {
+                        blockedEffect = baseEffect;
+                    } else {
+                        for (PotionEffect potionEffect : tippedArrow.getCustomEffects()) {
+                            if (wcfg.blockPotions.contains(potionEffect.getType())) {
+                                blockedEffect = potionEffect.getType();
+                                break;
+                            }
+                        }
+                    }
+                }
+                if (blockedEffect != null) {
+                    Player player = event.getCause().getFirstPlayer();
+                    if (player != null) {
+                        if (getPlugin().hasPermission(player, "worldguard.override.potions")) {
+                            return;
+                        }
+                        player.sendMessage(ChatColor.RED + "Sorry, arrows with "
+                                + blockedEffect.getName() + " are presently disabled.");
+                    }
+                    event.setCancelled(true);
                 }
-                player.sendMessage(ChatColor.RED + "Sorry, arrows with "
-                        + blockedEffect.getName() + " are presently disabled.");
             }
-            event.setCancelled(true);
         }
     }
 
     @EventHandler
     public void onItemInteract(UseItemEvent event) {
-        BukkitWorldConfiguration wcfg = getWorldConfig(event.getWorld());
+        ConfigurationManager cfg = WorldGuard.getInstance().getPlatform().getGlobalStateManager();
+        BukkitWorldConfiguration wcfg = (BukkitWorldConfiguration) cfg.get(BukkitAdapter.adapt(event.getWorld()));
         ItemStack item = event.getItemStack();
 
         if (item.getType() != Material.POTION
@@ -115,20 +109,25 @@ public class BlockedPotionsListener extends AbstractListener {
         if (!wcfg.blockPotions.isEmpty()) {
             PotionEffectType blockedEffect = null;
 
-            if (!(item.getItemMeta() instanceof PotionMeta meta)) {
-                return;
+            PotionMeta meta;
+            if (item.getItemMeta() instanceof PotionMeta) {
+                meta = ((PotionMeta) item.getItemMeta());
+            } else {
+                return; // ok...?
             }
 
             // Find the first blocked effect
-            List<PotionEffect> effects = new ArrayList<>();
-            if (meta.getBasePotionType() != null) {
-                effects.addAll(meta.getBasePotionType().getPotionEffects());
+            PotionEffectType baseEffect = meta.getBasePotionData().getType().getEffectType();
+            if (wcfg.blockPotions.contains(baseEffect)) {
+                blockedEffect = baseEffect;
             }
-            effects.addAll(meta.getCustomEffects());
-            for (PotionEffect potionEffect : effects) {
-                if (wcfg.blockPotions.contains(potionEffect.getType())) {
-                    blockedEffect = potionEffect.getType();
-                    break;
+
+            if (blockedEffect == null && meta.hasCustomEffects()) {
+                for (PotionEffect effect : meta.getCustomEffects()) {
+                    if (wcfg.blockPotions.contains(effect.getType())) {
+                        blockedEffect = effect.getType();
+                        break;
+                    }
                 }
             }
 

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

@@ -59,7 +59,7 @@ public class ChestProtectionListener extends AbstractListener {
         final Player player = event.getCause().getFirstPlayer();
 
         if (player != null) {
-            final BukkitWorldConfiguration wcfg = getWorldConfig(event.getWorld());
+            final BukkitWorldConfiguration wcfg = (BukkitWorldConfiguration) getWorldConfig(WorldGuardPlugin.inst().wrapPlayer(player));
 
             // Early guard
             if (!wcfg.signChestProtection) {
@@ -82,7 +82,7 @@ public class ChestProtectionListener extends AbstractListener {
     public void onBreakBlock(final BreakBlockEvent event) {
         final Player player = event.getCause().getFirstPlayer();
 
-        final BukkitWorldConfiguration wcfg = getWorldConfig(event.getWorld());
+        final BukkitWorldConfiguration wcfg = (BukkitWorldConfiguration) getWorldConfig(BukkitAdapter.adapt(event.getWorld()));
 
         // Early guard
         if (!wcfg.signChestProtection) {
@@ -108,7 +108,7 @@ public class ChestProtectionListener extends AbstractListener {
     public void onUseBlock(final UseBlockEvent event) {
         final Player player = event.getCause().getFirstPlayer();
 
-        final BukkitWorldConfiguration wcfg = getWorldConfig(event.getWorld());
+        final BukkitWorldConfiguration wcfg = (BukkitWorldConfiguration) getWorldConfig(BukkitAdapter.adapt(event.getWorld()));
 
         // Early guard
         if (!wcfg.signChestProtection) {
@@ -133,7 +133,7 @@ public class ChestProtectionListener extends AbstractListener {
     @EventHandler(ignoreCancelled = true)
     public void onSignChange(SignChangeEvent event) {
         Player player = event.getPlayer();
-        final BukkitWorldConfiguration wcfg = getWorldConfig(event.getBlock().getWorld());
+        BukkitWorldConfiguration wcfg = (BukkitWorldConfiguration) getWorldConfig(WorldGuardPlugin.inst().wrapPlayer(player));
 
         if (wcfg.signChestProtection) {
             if ("[Lock]".equalsIgnoreCase(event.getLine(0))) {

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

@@ -21,7 +21,9 @@ package com.sk89q.worldguard.bukkit.listener;
 
 import static com.sk89q.worldguard.bukkit.cause.Cause.create;
 
-import com.destroystokyo.paper.event.entity.EntityZapEvent;
+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;
@@ -46,14 +48,11 @@ import com.sk89q.worldguard.bukkit.util.Events;
 import com.sk89q.worldguard.bukkit.util.Materials;
 import com.sk89q.worldguard.config.WorldConfiguration;
 import com.sk89q.worldguard.protection.flags.Flags;
-import io.papermc.lib.PaperLib;
-import io.papermc.paper.event.player.PlayerOpenSignEvent;
 import org.bukkit.Bukkit;
 import org.bukkit.Effect;
 import org.bukkit.GameMode;
 import org.bukkit.Location;
 import org.bukkit.Material;
-import org.bukkit.Tag;
 import org.bukkit.World;
 import org.bukkit.block.Block;
 import org.bukkit.block.BlockFace;
@@ -62,7 +61,6 @@ import org.bukkit.block.Chest;
 import org.bukkit.block.DoubleChest;
 import org.bukkit.block.Hopper;
 import org.bukkit.block.PistonMoveReaction;
-import org.bukkit.block.data.BlockData;
 import org.bukkit.block.data.Waterlogged;
 import org.bukkit.block.data.type.Dispenser;
 import org.bukkit.entity.AreaEffectCloud;
@@ -74,17 +72,14 @@ import org.bukkit.entity.Firework;
 import org.bukkit.entity.Item;
 import org.bukkit.entity.ItemFrame;
 import org.bukkit.entity.LivingEntity;
-import org.bukkit.entity.Mob;
 import org.bukkit.entity.Painting;
 import org.bukkit.entity.Player;
-import org.bukkit.entity.Tameable;
 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.Action;
 import org.bukkit.event.block.BlockBreakEvent;
 import org.bukkit.event.block.BlockBurnEvent;
@@ -99,7 +94,6 @@ 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.CauldronLevelChangeEvent;
 import org.bukkit.event.block.EntityBlockFormEvent;
 import org.bukkit.event.block.SignChangeEvent;
 import org.bukkit.event.entity.AreaEffectCloudApplyEvent;
@@ -114,7 +108,6 @@ 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.EntityPickupItemEvent;
 import org.bukkit.event.entity.EntityTameEvent;
 import org.bukkit.event.entity.EntityUnleashEvent;
 import org.bukkit.event.entity.ExpBottleEvent;
@@ -144,8 +137,6 @@ import org.bukkit.event.world.StructureGrowEvent;
 import org.bukkit.inventory.EquipmentSlot;
 import org.bukkit.inventory.InventoryHolder;
 import org.bukkit.inventory.ItemStack;
-import org.bukkit.plugin.PluginManager;
-import org.bukkit.potion.PotionEffect;
 import org.bukkit.projectiles.ProjectileSource;
 import org.bukkit.util.Vector;
 
@@ -172,17 +163,6 @@ public class EventAbstractionListener extends AbstractListener {
         super(plugin);
     }
 
-    @Override
-    public void registerEvents() {
-        super.registerEvents();
-
-        if (PaperLib.isPaper()) {
-            PluginManager pm = getPlugin().getServer().getPluginManager();
-            pm.registerEvents(new EventAbstractionListener.PaperListener(), getPlugin());
-        }
-    }
-
-
     //-------------------------------------------------------------------------
     // Block break / place
     //-------------------------------------------------------------------------
@@ -248,7 +228,7 @@ public class EventAbstractionListener extends AbstractListener {
         boolean allowed = false;
 
         for (Block source : adjacent) {
-            if (Materials.isFire(source.getType())) {
+            if (source.getType() == Material.FIRE) {
                 found++;
                 if (Events.fireAndTestCancel(new BreakBlockEvent(event, create(source), target))) {
                     source.setType(Material.AIR);
@@ -277,42 +257,6 @@ public class EventAbstractionListener extends AbstractListener {
         }
     }
 
-    private void handleFallingBlock(EntityChangeBlockEvent event, boolean dropItem) {
-        Entity entity = event.getEntity();
-        Block block = event.getBlock();
-
-        if (entity instanceof FallingBlock) {
-            try {
-                if (dropItem) {
-                    FallingBlock fallingBlock = (FallingBlock) entity;
-                    if (!fallingBlock.getDropItem()) return;
-                    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))) {
-                        item.remove();
-                    }
-                }
-            } finally {
-                Cause.untrackParentCause(entity);
-            }
-        }
-    }
-
-    private void setDelegateEventMaterialOptions(DelegateEvent event, Material fromType, Material toType) {
-        if (fromType == Material.FARMLAND && toType == Material.DIRT) {
-            event.setSilent(true);
-            event.getRelevantFlags().add(Flags.TRAMPLE_BLOCKS);
-        } else if (Tag.REDSTONE_ORES.isTagged(fromType)) {
-            event.setSilent(true);
-        } else if (fromType == Material.BIG_DRIPLEAF && toType == Material.BIG_DRIPLEAF) {
-            event.setSilent(true);
-            event.getRelevantFlags().add(Flags.USE_DRIPLEAF);
-        }
-    }
-
     @EventHandler(ignoreCancelled = true)
     public void onEntityChangeBlock(EntityChangeBlockEvent event) {
         Block block = event.getBlock();
@@ -323,44 +267,54 @@ public class EventAbstractionListener extends AbstractListener {
 
         // Fire two events: one as BREAK and one as PLACE
         if (toType != Material.AIR && fromType != Material.AIR) {
+            boolean trample = fromType == Material.FARMLAND && toType == Material.DIRT;
             BreakBlockEvent breakDelagate = new BreakBlockEvent(event, cause, block);
-            setDelegateEventMaterialOptions(breakDelagate, fromType, toType);
-            boolean denied;
-            if (!(denied = Events.fireToCancel(event, breakDelagate))) {
+            if (trample) {
+                breakDelagate.getRelevantFlags().add(Flags.TRAMPLE_BLOCKS);
+            }
+            if (!Events.fireToCancel(event, breakDelagate)) {
                 PlaceBlockEvent placeDelegate = new PlaceBlockEvent(event, cause, block.getLocation(), toType);
-                setDelegateEventMaterialOptions(placeDelegate, fromType, toType);
-                denied = Events.fireToCancel(event, placeDelegate);
-            }
-            if (denied && entity instanceof Player) {
-                playDenyEffect((Player) entity, block.getLocation());
+                if (trample) {
+                    placeDelegate.getRelevantFlags().add(Flags.TRAMPLE_BLOCKS);
+                }
+                Events.fireToCancel(event, placeDelegate);
             }
+        } else {
+            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);
 
-            handleFallingBlock(event, denied);
-        } else 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);
-
-                // Switch around the event
-                Events.fireToCancel(event, new SpawnEntityEvent(event, create(block), entity));
+                    // Switch around the event
+                    Events.fireToCancel(event, new SpawnEntityEvent(event, create(block), entity));
+                } else {
+                    entityBreakBlockDebounce.debounce(
+                            block, event.getEntity(), event, new BreakBlockEvent(event, cause, block));
+                }
             } else {
-                entityBreakBlockDebounce.debounce(
-                        block, event.getEntity(), event, new BreakBlockEvent(event, cause, block));
-            }
-        } else { // toType != Material.AIR && fromType == Material.AIR
-            boolean denied = Events.fireToCancel(event, new PlaceBlockEvent(event, cause, block.getLocation(), toType));
-            handleFallingBlock(event, denied);
-        }
+                boolean wasCancelled = event.isCancelled();
 
+                Events.fireToCancel(event, new PlaceBlockEvent(event, cause, block.getLocation(), toType));
+
+                if (event.isCancelled() && !wasCancelled && entity instanceof FallingBlock) {
+                    FallingBlock fallingBlock = (FallingBlock) entity;
+                    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))) {
+                        item.remove();
+                    }
+                }
+            }
+        }
     }
 
     @EventHandler(ignoreCancelled = true)
     public void onEntityExplode(EntityExplodeEvent event) {
         Entity entity = event.getEntity();
         Events.fireBulkEventToCancel(event, new BreakBlockEvent(event, create(entity), event.getLocation().getWorld(), event.blockList(), Material.AIR));
-        if (entity instanceof Creeper) {
-            Cause.untrackParentCause(entity);
-        }
     }
 
     @EventHandler(ignoreCancelled = true)
@@ -378,7 +332,6 @@ public class EventAbstractionListener extends AbstractListener {
                 Events.fireBulkEventToCancel(event, new BreakBlockEvent(event, cause, event.getBlock().getWorld(), blocks, Material.AIR));
                 if (originalSize != blocks.size()) {
                     event.setCancelled(true);
-                    return;
                 }
                 for (Block b : blocks) {
                     Location loc = b.getRelative(direction).getLocation();
@@ -398,14 +351,8 @@ public class EventAbstractionListener extends AbstractListener {
     public void onBlockPistonExtend(BlockPistonExtendEvent event) {
         EventDebounce.Entry entry = pistonExtendDebounce.getIfNotPresent(new BlockPistonExtendKey(event), event);
         if (entry != null) {
-            Cause cause = create(event.getBlock());
             List<Block> blocks = new ArrayList<>(event.getBlocks());
             int originalLength = blocks.size();
-            Events.fireBulkEventToCancel(event, new BreakBlockEvent(event, cause, event.getBlock().getWorld(), blocks, Material.AIR));
-            if (originalLength != blocks.size()) {
-                event.setCancelled(true);
-                return;
-            }
             BlockFace dir = event.getDirection();
             for (int i = 0; i < blocks.size(); i++) {
                 Block existing = blocks.get(i);
@@ -415,7 +362,7 @@ public class EventAbstractionListener extends AbstractListener {
                     blocks.set(i, existing.getRelative(dir));
                 }
             }
-            Events.fireBulkEventToCancel(event, new PlaceBlockEvent(event, cause, event.getBlock().getWorld(), blocks, Material.STONE));
+            Events.fireBulkEventToCancel(event, new PlaceBlockEvent(event, create(event.getBlock()), event.getBlock().getWorld(), blocks, Material.STONE));
             if (blocks.size() != originalLength) {
                 event.setCancelled(true);
             }
@@ -448,43 +395,23 @@ public class EventAbstractionListener extends AbstractListener {
         @Nullable ItemStack item = event.getItem();
         Block clicked = event.getClickedBlock();
         Block placed;
+        boolean silent = false;
         boolean modifiesWorld;
         Cause cause = create(player);
 
         switch (event.getAction()) {
             case PHYSICAL:
                 if (event.useInteractedBlock() != Result.DENY) {
-                    if (clicked.getType() == Material.FARMLAND ||
-                            clicked.getType() == Material.TURTLE_EGG ||
-                            clicked.getType() == Material.SNIFFER_EGG) {
-                        BreakBlockEvent breakDelagate = new BreakBlockEvent(event, cause, clicked);
-                        breakDelagate.setSilent(true);
-                        breakDelagate.getRelevantFlags().add(Flags.TRAMPLE_BLOCKS);
-                        boolean denied;
-                        if (!(denied = Events.fireToCancel(event, breakDelagate))) {
-                            PlaceBlockEvent placeDelegate = new PlaceBlockEvent(event, cause, clicked.getLocation(),
-                                    clicked.getType() == Material.FARMLAND ? Material.DIRT : clicked.getType());
-                            placeDelegate.setSilent(true);
-                            placeDelegate.getRelevantFlags().add(Flags.TRAMPLE_BLOCKS);
-                            denied = Events.fireToCancel(event, placeDelegate);
-                        }
-                        if (denied) {
-                            playDenyEffect(player, clicked.getLocation());
-                        }
-                        return;
-                    }
                     DelegateEvent firedEvent = new UseBlockEvent(event, cause, clicked).setAllowed(hasInteractBypass(clicked));
-                    if (Tag.REDSTONE_ORES.isTagged(clicked.getType())) {
-                        firedEvent.setSilent(true);
+                    if (clicked.getType() == Material.REDSTONE_ORE) {
+                        silent = true;
                     }
-                    if (clicked.getType() == Material.BIG_DRIPLEAF) {
-                        firedEvent.getRelevantFlags().add(Flags.USE_DRIPLEAF);
-                        firedEvent.setSilent(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);
-                    if (event.useInteractedBlock() == Result.DENY && !firedEvent.isSilent()) {
-                        playDenyEffect(player, clicked.getLocation().add(0, 1, 0));
-                    }
                 }
                 break;
 
@@ -526,7 +453,7 @@ public class EventAbstractionListener extends AbstractListener {
                     }
 
                     // Special handling of putting out fires
-                    if (event.getAction() == Action.LEFT_CLICK_BLOCK && Materials.isFire(placed.getType())) {
+                    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;
@@ -550,7 +477,7 @@ public class EventAbstractionListener extends AbstractListener {
                 // 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.setUseInteractedBlock(Result.DENY);
                     }
@@ -576,7 +503,6 @@ public class EventAbstractionListener extends AbstractListener {
 
     @EventHandler(ignoreCancelled = true)
     public void onBlockFertilize(BlockFertilizeEvent event) {
-        if (event.getBlocks().isEmpty()) return; 
         Cause cause = create(event.getPlayer(), event.getBlock());
         Events.fireToCancel(event, new PlaceBlockEvent(event, cause, event.getBlock().getWorld(), event.getBlocks()));
     }
@@ -602,7 +528,9 @@ public class EventAbstractionListener extends AbstractListener {
 
     @EventHandler(ignoreCancelled = true)
     public void onSignChange(SignChangeEvent event) {
-        if (Events.fireToCancel(event, new PlaceBlockEvent(event, create(event.getPlayer()), event.getBlock()))) {
+        Events.fireToCancel(event, new UseBlockEvent(event, create(event.getPlayer()), event.getBlock()));
+
+        if (event.isCancelled()) {
             playDenyEffect(event.getPlayer(), event.getBlock().getLocation().add(0.5, 0.5, 0.5));
         }
     }
@@ -669,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
@@ -715,7 +643,7 @@ public class EventAbstractionListener extends AbstractListener {
             case DISPENSE_EGG:
             case EGG:
             case SPAWNER_EGG:
-                if (getWorldConfig(event.getEntity().getWorld()).strictEntitySpawn) {
+                if (getWorldConfig(BukkitAdapter.adapt(event.getEntity().getWorld())).strictEntitySpawn) {
                     Events.fireToCancel(event, new SpawnEntityEvent(event, Cause.unknown(), event.getEntity()));
                 }
                 break;
@@ -776,7 +704,7 @@ public class EventAbstractionListener extends AbstractListener {
                 event.setCancelled(true);
             }
         } else if (event.getState() == PlayerFishEvent.State.CAUGHT_FISH) {
-            if (event.getExpToDrop() > 0 && Events.fireAndTestCancel(new SpawnEntityEvent(event, create(event.getPlayer(), event.getHook()), event.getHook().getLocation(), EntityType.EXPERIENCE_ORB))) {
+            if (Events.fireAndTestCancel(new SpawnEntityEvent(event, create(event.getPlayer(), event.getHook()), event.getHook().getLocation(), EntityType.EXPERIENCE_ORB))) {
                 event.setExpToDrop(0);
             }
         } else if (event.getState() == PlayerFishEvent.State.CAUGHT_ENTITY) {
@@ -865,11 +793,7 @@ public class EventAbstractionListener extends AbstractListener {
             } else if (damager instanceof Creeper) {
                 eventToFire.getRelevantFlags().add(Flags.CREEPER_EXPLOSION);
             }
-            if (Events.fireToCancel(event, eventToFire)) {
-                if (damager instanceof Tameable && damager instanceof Mob) {
-                    ((Mob) damager).setTarget(null);
-                }
-            }
+            Events.fireToCancel(event, eventToFire);
 
             // Item use event with the item in hand
             // Older blacklist handler code used this, although it suffers from
@@ -920,12 +844,6 @@ public class EventAbstractionListener extends AbstractListener {
         pickupDebounce.debounce(event.getPlayer(), item, event, new DestroyEntityEvent(event, create(event.getPlayer()), event.getItem()));
     }
 
-    @EventHandler(ignoreCancelled = true)
-    public void onEntityPickupItem(EntityPickupItemEvent event) {
-        Item item = event.getItem();
-        pickupDebounce.debounce(event.getEntity(), item, event, new DestroyEntityEvent(event, create(event.getEntity()), event.getItem()));
-    }
-
     @EventHandler(ignoreCancelled = true)
     public void onPlayerDropItem(PlayerDropItemEvent event) {
         Events.fireToCancel(event, new SpawnEntityEvent(event, create(event.getPlayer()), event.getItemDrop()));
@@ -956,23 +874,21 @@ public class EventAbstractionListener extends AbstractListener {
 
     @EventHandler(ignoreCancelled = true)
     public void onInventoryMoveItem(InventoryMoveItemEvent event) {
-        InventoryHolder causeHolder = PaperLib.getHolder(event.getInitiator(), false).getHolder();
+        final InventoryHolder causeHolder = event.getInitiator().getHolder();
 
-        WorldConfiguration wcfg = null;
         if (causeHolder instanceof Hopper
-                && (wcfg = getWorldConfig((((Hopper) causeHolder).getWorld()))).ignoreHopperMoveEvents) {
+                && getWorldConfig(BukkitAdapter.adapt((((Hopper) causeHolder).getWorld()))).ignoreHopperMoveEvents) {
             return;
         } else if (causeHolder instanceof HopperMinecart
-                && (wcfg = getWorldConfig((((HopperMinecart) causeHolder).getWorld()))).ignoreHopperMoveEvents) {
+                && getWorldConfig(BukkitAdapter.adapt((((HopperMinecart) causeHolder).getWorld()))).ignoreHopperMoveEvents) {
             return;
         }
 
         Entry entry;
 
         if ((entry = moveItemDebounce.tryDebounce(event)) != null) {
-            InventoryHolder sourceHolder = PaperLib.getHolder(event.getSource(), false).getHolder();
-            InventoryHolder targetHolder = PaperLib.getHolder(event.getDestination(), false).getHolder();
-
+            InventoryHolder sourceHolder = event.getSource().getHolder();
+            InventoryHolder targetHolder = event.getDestination().getHolder();
             Cause cause;
 
             if (causeHolder instanceof Entity) {
@@ -989,7 +905,7 @@ public class EventAbstractionListener extends AbstractListener {
 
             handleInventoryHolderUse(event, cause, targetHolder);
 
-            if (event.isCancelled() && causeHolder instanceof Hopper && wcfg.breakDeniedHoppers) {
+            if (event.isCancelled() && causeHolder instanceof Hopper) {
                 Bukkit.getScheduler().scheduleSyncDelayedTask(getPlugin(),
                         () -> ((Hopper) causeHolder).getBlock().breakNaturally());
             } else {
@@ -1028,7 +944,7 @@ public class EventAbstractionListener extends AbstractListener {
                 }
             }
 
-            if (affectedSize > 0 && blocked == affectedSize) { // server does weird things with this if the event is modified, so use cached number
+            if (blocked == affectedSize) { // server does weird things with this if the event is modified, so use cached number
                 event.setCancelled(true);
             }
         }
@@ -1036,32 +952,18 @@ public class EventAbstractionListener extends AbstractListener {
 
     @EventHandler(ignoreCancelled = true)
     public void onBlockDispense(BlockDispenseEvent event) {
+        Cause cause = create(event.getBlock());
         Block dispenserBlock = event.getBlock();
+        ItemStack item = event.getItem();
+
+        Events.fireToCancel(event, new UseItemEvent(event, cause, dispenserBlock.getWorld(), item));
 
         // Simulate right click event as players have it
-        if (dispenserBlock.getType() == Material.DISPENSER) {
-            Cause cause = create(event.getBlock());
-            ItemStack item = event.getItem();
-            if (Events.fireToCancel(event, new UseItemEvent(event, cause, dispenserBlock.getWorld(), item))) {
-                return;
-            }
-
-            BlockData blockData = dispenserBlock.getBlockData();
-            Dispenser dispenser = (Dispenser) blockData; // if this ClassCastExceptions it's a bukkit bug
+        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, placed);
-
-            // handle special dispenser behavior
-            if (Materials.isShulkerBox(item.getType())) {
-                if (Events.fireToCancel(event, new PlaceBlockEvent(event, cause, placed.getLocation(), item.getType()))) {
-                    playDenyEffect(placed.getLocation());
-                }
-            } else if (isItemAppliedToBlock(item, placed)) {
-                if (Events.fireToCancel(event, new PlaceBlockEvent(event, cause, placed.getLocation(), placed.getType()))) {
-                    playDenyEffect(placed.getLocation());
-                }
-            }
         }
     }
 
@@ -1084,16 +986,7 @@ public class EventAbstractionListener extends AbstractListener {
 
     @EventHandler(ignoreCancelled = true)
     public void onLingeringApply(AreaEffectCloudApplyEvent event) {
-        AreaEffectCloud entity = event.getEntity();
-        List<PotionEffect> effects = new ArrayList<>();
-        List<PotionEffect> baseEffectTypes = entity.getBasePotionType() == null ? null : entity.getBasePotionType().getPotionEffects();
-        if (baseEffectTypes != null) {
-            effects.addAll(baseEffectTypes);
-        }
-        if (entity.hasCustomEffects()) {
-            effects.addAll(entity.getCustomEffects());
-        }
-        if (!Materials.hasDamageEffect(effects)) {
+        if (!Materials.hasDamageEffect(event.getEntity().getCustomEffects())) {
             return;
         }
         Cause cause = create(event.getEntity());
@@ -1117,17 +1010,10 @@ public class EventAbstractionListener extends AbstractListener {
     @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);
     }
 
-    @EventHandler(ignoreCancelled = true)
-    public void onCauldronLevelChange(CauldronLevelChangeEvent event) {
-        if (event.getEntity() == null) return;
-        interactDebounce.debounce(event.getBlock(), event.getEntity(), event,
-                new UseBlockEvent(event, create(event.getEntity()),
-                        event.getBlock()).setAllowed(hasInteractBypass(event.getBlock())));
-    }
-
     /**
      * Handle the right click of a block while an item is held.
      *
@@ -1173,17 +1059,14 @@ public class EventAbstractionListener extends AbstractListener {
 
         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.END_CRYSTAL));
+            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) {
-            EntityType possibleEntityType = Materials.getEntitySpawnEgg(item.getType());
-            if (possibleEntityType != null) {
-                Events.fireToCancel(event, new SpawnEntityEvent(event, cause, placed.getLocation().add(0.5, 0, 0.5), possibleEntityType));
-                return;
-            }
+        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 water/lava placement
@@ -1199,7 +1082,8 @@ public class EventAbstractionListener extends AbstractListener {
             return;
         }
 
-        if (holder instanceof Entity entity) {
+        if (holder instanceof Entity) {
+            Entity entity = (Entity) holder;
             Material mat = Materials.getRelatedMaterial((entity).getType());
             UseEntityEvent useEntityEvent = new UseEntityEvent(originalEvent, cause, entity);
             if (mat != null && hasInteractBypass((entity).getWorld(), mat)) {
@@ -1207,7 +1091,8 @@ public class EventAbstractionListener extends AbstractListener {
             }
             Events.fireToCancel(originalEvent, useEntityEvent);
         } else {
-            if (holder instanceof BlockState block && block.isPlaced()) {
+            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);
@@ -1227,15 +1112,15 @@ public class EventAbstractionListener extends AbstractListener {
     }
 
     private static boolean hasInteractBypass(Block block) {
-        return getWorldConfig(block.getWorld()).allowAllInteract.test(block);
+        return ((BukkitWorldConfiguration) getWorldConfig(BukkitAdapter.adapt(block.getWorld()))).allowAllInteract.test(block);
     }
 
     private static boolean hasInteractBypass(World world, Material material) {
-        return getWorldConfig(world).allowAllInteract.test(material);
+        return ((BukkitWorldConfiguration) getWorldConfig(BukkitAdapter.adapt(world))).allowAllInteract.test(material);
     }
 
     private static boolean hasInteractBypass(World world, ItemStack item) {
-        return getWorldConfig(world).allowAllInteract.test(item);
+        return ((BukkitWorldConfiguration) getWorldConfig(BukkitAdapter.adapt(world))).allowAllInteract.test(item);
     }
 
     private static boolean isBlockModifiedOnClick(Block block, boolean rightClick) {
@@ -1250,29 +1135,15 @@ public class EventAbstractionListener extends AbstractListener {
 
     private static void playDenyEffect(Player player, Location location) {
         //player.playSound(location, Sound.SUCCESSFUL_HIT, 0.2f, 0.4f);
-        if (getConfig().particleEffects) {
+        if (WorldGuard.getInstance().getPlatform().getGlobalStateManager().particleEffects) {
             player.playEffect(location, Effect.SMOKE, BlockFace.UP);
         }
     }
 
     private static void playDenyEffect(Location location) {
-        if (getConfig().particleEffects) {
+        if (WorldGuard.getInstance().getPlatform().getGlobalStateManager().particleEffects) {
             location.getWorld().playEffect(location, Effect.SMOKE, BlockFace.UP);
         }
     }
 
-    private class PaperListener implements Listener {
-        @EventHandler(ignoreCancelled = true)
-        public void onEntityTransform(EntityZapEvent event) {
-            Events.fireToCancel(event, new DamageEntityEvent(event, create(event.getBolt()), event.getEntity()));
-        }
-
-        @EventHandler(ignoreCancelled = true)
-        public void onSignOpen(PlayerOpenSignEvent event) {
-            if (event.getCause() == PlayerOpenSignEvent.Cause.INTERACT) {
-                // other cases are handled by other events
-                Events.fireToCancel(event, new UseBlockEvent(event, create(event.getPlayer()), event.getSign().getBlock()));
-            }
-        }
-    }
 }

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

@@ -19,10 +19,11 @@
 
 package com.sk89q.worldguard.bukkit.listener;
 
+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.util.Entities;
 import org.bukkit.entity.Entity;
 import org.bukkit.entity.LivingEntity;
 import org.bukkit.entity.Player;
@@ -58,11 +59,14 @@ public class InvincibilityListener extends AbstractListener {
     @EventHandler(ignoreCancelled = true)
     public void onEntityDamage(EntityDamageEvent event) {
         Entity victim = event.getEntity();
-        if (Entities.isNPC(victim)) return;
 
-        if (victim instanceof Player player) {
+        if (victim instanceof Player) {
+            Player player = (Player) victim;
             LocalPlayer localPlayer = WorldGuardPlugin.inst().wrapPlayer(player);
 
+            BukkitWorldConfiguration worldConfig =
+                    (BukkitWorldConfiguration) WorldGuard.getInstance().getPlatform().getGlobalStateManager().get((World) localPlayer.getExtent());
+
             if (isInvincible(localPlayer)) {
                 player.setFireTicks(0);
                 event.setCancelled(true);
@@ -75,7 +79,7 @@ public class InvincibilityListener extends AbstractListener {
                         attacker = (Entity) ((Projectile) attacker).getShooter();
                     }
 
-                    if (getWorldConfig(player.getWorld()).regionInvinciblityRemovesMobs
+                    if (worldConfig.regionInvinciblityRemovesMobs
                             && attacker instanceof LivingEntity && !(attacker instanceof Player)
                             && !(attacker instanceof Tameable && ((Tameable) attacker).isTamed())) {
                         attacker.remove();
@@ -88,9 +92,9 @@ public class InvincibilityListener extends AbstractListener {
     @EventHandler(ignoreCancelled = true)
     public void onEntityCombust(EntityCombustEvent event) {
         Entity entity = event.getEntity();
-        if (Entities.isNPC(entity)) return;
 
-        if (entity instanceof Player player) {
+        if (entity instanceof Player) {
+            Player player = (Player) entity;
             LocalPlayer localPlayer = WorldGuardPlugin.inst().wrapPlayer(player);
 
             if (isInvincible(localPlayer)) {
@@ -101,9 +105,8 @@ public class InvincibilityListener extends AbstractListener {
 
     @EventHandler(ignoreCancelled = true)
     public void onFoodLevelChange(FoodLevelChangeEvent event) {
-        if (Entities.isNPC(event.getEntity())) return;
-
-        if (event.getEntity() instanceof Player player) {
+        if (event.getEntity() instanceof Player) {
+            Player player = (Player) event.getEntity();
             LocalPlayer localPlayer = WorldGuardPlugin.inst().wrapPlayer(player);
 
             if (event.getFoodLevel() < player.getFoodLevel() && isInvincible(localPlayer)) {

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

@@ -27,37 +27,37 @@ import com.sk89q.worldguard.session.MoveType;
 import com.sk89q.worldguard.session.Session;
 import org.bukkit.Bukkit;
 import org.bukkit.Location;
-import org.bukkit.entity.AbstractHorse;
 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;
 import org.bukkit.event.EventPriority;
-import org.bukkit.event.entity.EntityMountEvent;
+import org.bukkit.event.Listener;
 import org.bukkit.event.player.PlayerMoveEvent;
-import org.bukkit.event.player.PlayerQuitEvent;
 import org.bukkit.event.player.PlayerRespawnEvent;
 import org.bukkit.event.vehicle.VehicleEnterEvent;
 import org.bukkit.plugin.PluginManager;
 import org.bukkit.util.Vector;
 
-public class PlayerMoveListener extends AbstractListener {
+public class PlayerMoveListener implements Listener {
+
+    private final WorldGuardPlugin plugin;
 
     public PlayerMoveListener(WorldGuardPlugin plugin) {
-        super(plugin);
+        this.plugin = plugin;
     }
 
-    @Override
     public void registerEvents() {
         if (WorldGuard.getInstance().getPlatform().getGlobalStateManager().usePlayerMove) {
-            PluginManager pm = getPlugin().getServer().getPluginManager();
-            pm.registerEvents(this, getPlugin());
+            PluginManager pm = plugin.getServer().getPluginManager();
+            pm.registerEvents(this, plugin);
         }
     }
 
-    @EventHandler(priority = EventPriority.MONITOR)
+    @EventHandler
     public void onPlayerRespawn(PlayerRespawnEvent event) {
-        LocalPlayer player = getPlugin().wrapPlayer(event.getPlayer());
+        LocalPlayer player = plugin.wrapPlayer(event.getPlayer());
 
         Session session = WorldGuard.getInstance().getPlatform().getSessionManager().get(player);
         session.testMoveTo(player, BukkitAdapter.adapt(event.getRespawnLocation()), MoveType.RESPAWN, true);
@@ -67,7 +67,7 @@ public class PlayerMoveListener extends AbstractListener {
     public void onVehicleEnter(VehicleEnterEvent event) {
         Entity entity = event.getEntered();
         if (entity instanceof Player) {
-            LocalPlayer player = getPlugin().wrapPlayer((Player) entity);
+            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);
@@ -77,16 +77,8 @@ public class PlayerMoveListener extends AbstractListener {
 
     @EventHandler(priority = EventPriority.HIGH)
     public void onPlayerMove(PlayerMoveEvent event) {
-        Location from = event.getFrom();
-        Location to = event.getTo();
-        if (from.getBlockX() == to.getBlockX()
-                && from.getBlockY() == to.getBlockY()
-                && from.getBlockZ() == to.getBlockZ()) {
-            return;
-        }
-
         final Player player = event.getPlayer();
-        LocalPlayer localPlayer = getPlugin().wrapPlayer(player);
+        LocalPlayer localPlayer = plugin.wrapPlayer(player);
 
         Session session = WorldGuard.getInstance().getPlatform().getSessionManager().get(localPlayer);
         MoveType moveType = MoveType.MOVE;
@@ -94,18 +86,18 @@ public class PlayerMoveListener extends AbstractListener {
             moveType = MoveType.GLIDE;
         } else if (event.getPlayer().isSwimming()) {
             moveType = MoveType.SWIM;
-        } else if (event.getPlayer().getVehicle() != null && event.getPlayer().getVehicle() instanceof AbstractHorse) {
+        } 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(to), moveType);
+        com.sk89q.worldedit.util.Location weLocation = session.testMoveTo(localPlayer, BukkitAdapter.adapt(event.getTo()), moveType);
 
         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);
-            override.setPitch(to.getPitch());
-            override.setYaw(to.getYaw());
+            override.setPitch(event.getTo().getPitch());
+            override.setYaw(event.getTo().getYaw());
 
             event.setTo(override.clone());
 
@@ -127,35 +119,9 @@ public class PlayerMoveListener extends AbstractListener {
 
                 player.teleport(override.clone().add(0, 1, 0));
 
-                Bukkit.getScheduler().runTaskLater(getPlugin(), () -> player.teleport(override.clone().add(0, 1, 0)), 1);
+                Bukkit.getScheduler().runTaskLater(plugin, () -> player.teleport(override.clone().add(0, 1, 0)), 1);
             }
         }
     }
 
-    @EventHandler
-    public void onPlayerQuit(PlayerQuitEvent event) {
-        final Player player = event.getPlayer();
-        LocalPlayer localPlayer = getPlugin().wrapPlayer(player);
-
-        Session session = WorldGuard.getInstance().getPlatform().getSessionManager().get(localPlayer);
-        com.sk89q.worldedit.util.Location loc = session.testMoveTo(localPlayer,
-            BukkitAdapter.adapt(event.getPlayer().getLocation()), MoveType.OTHER_CANCELLABLE); // white lie
-        if (loc != null) {
-            player.teleport(BukkitAdapter.adapt(loc));
-        }
-
-        session.uninitialize(localPlayer);
-    }
-
-    @EventHandler
-    public void onEntityMount(EntityMountEvent event) {
-        Entity entity = event.getEntity();
-        if (entity instanceof Player) {
-            LocalPlayer player = getPlugin().wrapPlayer((Player) entity);
-            Session session = WorldGuard.getInstance().getPlatform().getSessionManager().get(player);
-            if (null != session.testMoveTo(player, BukkitAdapter.adapt(event.getMount().getLocation()), MoveType.EMBARK, true)) {
-                event.setCancelled(true);
-            }
-        }
-    }
 }

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

@@ -25,7 +25,6 @@ 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;
@@ -58,7 +57,8 @@ 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 = WorldGuard.getInstance().getPlatform().getRegionContainer().createQuery();
 
@@ -69,7 +69,7 @@ public class RegionFlagsListener extends AbstractListener {
             }
         }
 
-        if (event.getCause().find(EntityType.SNOW_GOLEM) != null) {
+        if (event.getCause().find(EntityType.SNOWMAN) != null) {
             event.filter(testState(query, Flags.SNOWMAN_TRAILS), false);
         }
 
@@ -80,9 +80,10 @@ public class RegionFlagsListener extends AbstractListener {
 
     @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());
+        WorldConfiguration config = getWorldConfig(weWorld);
         RegionQuery query = WorldGuard.getInstance().getPlatform().getRegionContainer().createQuery();
 
         Block block;
@@ -100,7 +101,7 @@ public class RegionFlagsListener extends AbstractListener {
             event.filter(testState(query, Flags.ENDERDRAGON_BLOCK_DAMAGE), config.explosionFlagCancellation);
         }
 
-        if (event.getCause().find(EntityType.END_CRYSTAL) != null) { // EnderCrystal
+        if (event.getCause().find(EntityType.ENDER_CRYSTAL) != null) { // EnderCrystal
             event.filter(testState(query, Flags.OTHER_EXPLOSION), config.explosionFlagCancellation);
         }
 
@@ -117,26 +118,26 @@ public class RegionFlagsListener extends AbstractListener {
     public void onEntityDamage(EntityDamageEvent event) {
         Entity entity = event.getEntity();
         World world = entity.getWorld();
-        if (!isRegionSupportEnabled(world)) return; // Region support disabled
-
-        if (Entities.isNPC(entity)) return;
-        if (!(entity instanceof Player player)) return;
 
+        if (!isRegionSupportEnabled(BukkitAdapter.adapt(world))) return; // Region support disabled
         RegionQuery query = WorldGuard.getInstance().getPlatform().getRegionContainer().createQuery();
 
-        if (event.getCause() == DamageCause.FALL) {
-            LocalPlayer localPlayer = WorldGuardPlugin.inst().wrapPlayer(player);
+        if (entity instanceof Player && event.getCause() == DamageCause.FALL) {
+            LocalPlayer localPlayer = WorldGuardPlugin.inst().wrapPlayer((Player) entity);
             if (!query.testState(BukkitAdapter.adapt(entity.getLocation()), localPlayer, Flags.FALL_DAMAGE)) {
                 event.setCancelled(true);
                 return;
             }
-        } else if (event.getCause() == DamageCause.FLY_INTO_WALL) {
-            LocalPlayer localPlayer = WorldGuardPlugin.inst().wrapPlayer(player);
-            if (!query.testState(BukkitAdapter.adapt(entity.getLocation()), localPlayer, Flags.FALL_DAMAGE)) {
-                event.setCancelled(true);
-                return;
+        } else {
+            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;
+                }
             }
         }
+
     }
 
     /**

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

@@ -41,6 +41,7 @@ import com.sk89q.worldguard.bukkit.util.InteropUtils;
 import com.sk89q.worldguard.bukkit.util.Materials;
 import com.sk89q.worldguard.commands.CommandUtils;
 import com.sk89q.worldguard.config.WorldConfiguration;
+import com.sk89q.worldguard.internal.permission.RegionPermissionModel;
 import com.sk89q.worldguard.protection.association.RegionAssociable;
 import com.sk89q.worldguard.protection.flags.Flags;
 import com.sk89q.worldguard.protection.flags.StateFlag;
@@ -58,10 +59,8 @@ 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;
 import org.bukkit.event.Event.Result;
 import org.bukkit.event.EventHandler;
-import org.bukkit.event.player.PlayerTakeLecternBookEvent;
 import org.bukkit.event.vehicle.VehicleExitEvent;
 
 import java.util.ArrayList;
@@ -136,14 +135,15 @@ public class RegionProtectionListener extends AbstractListener {
 
         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;
             }
 
-            LocalPlayer localPlayer = WorldGuardPlugin.inst().wrapPlayer(player);
-            return !pvp && WorldGuard.getInstance().getPlatform().getSessionManager().hasBypass(localPlayer, localPlayer.getWorld());
+            return !pvp && WorldGuard.getInstance().getPlatform().getSessionManager().hasBypass(localPlayer, localWorld);
         } else {
             return false;
         }
@@ -152,7 +152,7 @@ public class RegionProtectionListener extends AbstractListener {
     @EventHandler(ignoreCancelled = true)
     public void onPlaceBlock(final PlaceBlockEvent event) {
         if (event.getResult() == Result.ALLOW) return; // Don't care about events that have been pre-allowed
-        if (!isRegionSupportEnabled(event.getWorld())) return; // Region support disabled
+        if (!isRegionSupportEnabled(BukkitAdapter.adapt(event.getWorld()))) return; // Region support disabled
         if (isWhitelisted(event.getCause(), event.getWorld(), false)) return; // Whitelisted cause
 
         final Material type = event.getEffectiveMaterial();
@@ -162,7 +162,7 @@ public class RegionProtectionListener extends AbstractListener {
         // 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;
         }
 
@@ -171,9 +171,9 @@ public class RegionProtectionListener extends AbstractListener {
             String what;
 
             /* Flint and steel, fire charge, etc. */
-            if (Materials.isFire(type)) {
+            if (type == Material.FIRE) {
                 Block block = event.getCause().getFirstBlock();
-                boolean fire = block != null && Materials.isFire(block.getType());
+                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);
@@ -205,7 +205,7 @@ public class RegionProtectionListener extends AbstractListener {
     @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 = WorldGuard.getInstance().getPlatform().getRegionContainer().createQuery();
@@ -218,7 +218,7 @@ public class RegionProtectionListener extends AbstractListener {
                 String what;
 
                 /* TNT */
-                if (event.getCause().find(EntityType.TNT, EntityType.TNT_MINECART) != null) {
+                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";
 
@@ -241,7 +241,7 @@ 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();
@@ -259,29 +259,14 @@ public class RegionProtectionListener extends AbstractListener {
 
             /* Inventory */
             } else if (Materials.isInventoryBlock(type)) {
-                canUse = query.testBuild(BukkitAdapter.adapt(target), associable, combine(event, Flags.CHEST_ACCESS));
+                canUse = query.testBuild(BukkitAdapter.adapt(target), associable, combine(event, Flags.INTERACT, Flags.CHEST_ACCESS));
                 what = "open that";
 
-            /* Inventory for blocks with the possibility to be only use, e.g. lectern */
-            } else if (handleAsInventoryUsage(event.getOriginalEvent())) {
-                canUse = query.testBuild(BukkitAdapter.adapt(target), associable, combine(event, Flags.CHEST_ACCESS));
-                what = "take that";
-
-            /* Anvils */
-            } else if (Materials.isAnvil(type)) {
-                canUse = query.testBuild(BukkitAdapter.adapt(target), associable, combine(event, Flags.USE_ANVIL));
-                what = "use that";
-
             /* Beds */
             } else if (Materials.isBed(type)) {
                 canUse = query.testBuild(BukkitAdapter.adapt(target), associable, combine(event, Flags.INTERACT, Flags.SLEEP));
                 what = "sleep";
 
-            /* Respawn Anchors */
-            } else if(type == Material.RESPAWN_ANCHOR) {
-                canUse = query.testBuild(BukkitAdapter.adapt(target), associable, combine(event, Flags.INTERACT, Flags.RESPAWN_ANCHORS));
-                what = "use anchors";
-
             /* TNT */
             } else if (type == Material.TNT) {
                 canUse = query.testBuild(BukkitAdapter.adapt(target), associable, combine(event, Flags.INTERACT, Flags.TNT));
@@ -310,7 +295,7 @@ public class RegionProtectionListener extends AbstractListener {
     @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();
@@ -344,7 +329,12 @@ public class RegionProtectionListener extends AbstractListener {
         /* Everything else */
         } else {
             canSpawn = query.testBuild(BukkitAdapter.adapt(target), associable, combine(event));
-            what = "place things";
+
+            if (event.getEntity() instanceof Item) {
+                what = "drop items";
+            } else {
+                what = "place things";
+            }
         }
 
         if (!canSpawn) {
@@ -356,7 +346,7 @@ 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();
@@ -392,7 +382,7 @@ 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();
@@ -411,8 +401,7 @@ public class RegionProtectionListener extends AbstractListener {
             what = "use that";
         /* Paintings, item frames, etc. */
         } else if (Entities.isConsideredBuildingIfUsed(entity)) {
-            if ((type == EntityType.ITEM_FRAME || type == EntityType.GLOW_ITEM_FRAME)
-                    && event.getCause().getFirstPlayer() != null
+            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";
@@ -443,7 +432,7 @@ 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
 
         com.sk89q.worldedit.util.Location target = BukkitAdapter.adapt(event.getTarget());
@@ -519,10 +508,11 @@ public class RegionProtectionListener extends AbstractListener {
     @EventHandler(ignoreCancelled = true)
     public void onVehicleExit(VehicleExitEvent event) {
         Entity vehicle = event.getVehicle();
-        if (!isRegionSupportEnabled(vehicle.getWorld())) return; // Region support disabled
+        if (!isRegionSupportEnabled(BukkitAdapter.adapt(vehicle.getWorld()))) return; // Region support disabled
         Entity exited = event.getExited();
 
-        if (vehicle instanceof Tameable && exited instanceof Player player && !Entities.isNPC(player)) {
+        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 = WorldGuard.getInstance().getPlatform().getRegionContainer().createQuery();
@@ -541,6 +531,10 @@ public class RegionProtectionListener extends AbstractListener {
         }
     }
 
+    private boolean isWhitelistedEntity(Entity entity) {
+        return Entities.isNonPlayerCreature(entity);
+    }
+
     /**
      * Combine the flags from a delegate event with an array of flags.
      *
@@ -559,14 +553,4 @@ public class RegionProtectionListener extends AbstractListener {
         return flags;
     }
 
-    /**
-     * Check if that event should be handled as inventory usage, e.g. if a player takes a book from a lectern
-     *
-     * @param event the event to handle
-     * @return whether it should be handled as inventory usage
-     */
-    private static boolean handleAsInventoryUsage(Event event) {
-        return event instanceof PlayerTakeLecternBookEvent;
-    }
-
 }

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

@@ -31,16 +31,14 @@ 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.Location;
 import org.bukkit.Material;
 import org.bukkit.World;
 import org.bukkit.block.Block;
-import org.bukkit.block.data.Waterlogged;
 import org.bukkit.entity.Player;
 import org.bukkit.entity.Snowman;
-import org.bukkit.event.Cancellable;
 import org.bukkit.event.EventHandler;
 import org.bukkit.event.EventPriority;
+import org.bukkit.event.Listener;
 import org.bukkit.event.block.BlockBreakEvent;
 import org.bukkit.event.block.BlockBurnEvent;
 import org.bukkit.event.block.BlockExplodeEvent;
@@ -62,9 +60,12 @@ import org.bukkit.inventory.meta.ItemMeta;
 
 /**
  * The listener for block events.
+ *
+ * @author sk89q
  */
-public class WorldGuardBlockListener extends AbstractListener {
+public class WorldGuardBlockListener implements Listener {
 
+    private WorldGuardPlugin plugin;
 
     /**
      * Construct the object.
@@ -72,7 +73,34 @@ public class WorldGuardBlockListener extends AbstractListener {
      * @param plugin The plugin instance
      */
     public WorldGuardBlockListener(WorldGuardPlugin plugin) {
-        super(plugin);
+        this.plugin = plugin;
+    }
+
+    /**
+     * Register events.
+     */
+    public void registerEvents() {
+        plugin.getServer().getPluginManager().registerEvents(this, plugin);
+    }
+
+    /**
+     * Get the world configuration given a world.
+     *
+     * @param world The world to get the configuration for.
+     * @return The configuration for {@code world}
+     */
+    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 BukkitWorldConfiguration} for the player's world
+     */
+    private WorldConfiguration getWorldConfig(Player player) {
+        return getWorldConfig(player.getWorld());
     }
 
     /*
@@ -81,7 +109,7 @@ public class WorldGuardBlockListener extends AbstractListener {
     @EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
     public void onBlockBreak(BlockBreakEvent event) {
         Player player = event.getPlayer();
-        WorldConfiguration wcfg = getWorldConfig(player.getWorld());
+        WorldConfiguration wcfg = getWorldConfig(player);
 
         if (!wcfg.itemDurability) {
             ItemStack held = player.getInventory().getItemInMainHand();
@@ -103,20 +131,18 @@ public class WorldGuardBlockListener extends AbstractListener {
         Block blockFrom = event.getBlock();
         Block blockTo = event.getToBlock();
 
-        ConfigurationManager cfg = getConfig();
+        boolean isWater = blockFrom.getType() == Material.WATER;
+        boolean isLava = blockFrom.getType() == Material.LAVA;
+        boolean isAir = blockFrom.getType() == Material.AIR;
+
+        ConfigurationManager cfg = WorldGuard.getInstance().getPlatform().getGlobalStateManager();
+        WorldConfiguration wcfg = getWorldConfig(event.getBlock().getWorld());
 
         if (cfg.activityHaltToggle) {
             event.setCancelled(true);
             return;
         }
 
-        Material fromType = blockFrom.getType();
-        boolean isWater = Materials.isWater(fromType);
-        boolean isLava = fromType == Material.LAVA;
-        boolean isAir = fromType == Material.AIR;
-
-        WorldConfiguration wcfg = getWorldConfig(world);
-
         if (wcfg.simulateSponge && isWater) {
             int ox = blockTo.getX();
             int oy = blockTo.getY();
@@ -168,7 +194,7 @@ public class WorldGuardBlockListener extends AbstractListener {
             }
         }
 
-        if (wcfg.highFreqFlags && (isWater || blockFrom.getBlockData() instanceof Waterlogged)
+        if (wcfg.highFreqFlags && isWater
                 && WorldGuard.getInstance().getPlatform().getRegionContainer().createQuery().queryState(BukkitAdapter.adapt(blockFrom.getLocation()), (RegionAssociable) null, Flags.WATER_FLOW) == StateFlag.State.DENY) {
             event.setCancelled(true);
             return;
@@ -179,6 +205,13 @@ public class WorldGuardBlockListener extends AbstractListener {
             event.setCancelled(true);
             return;
         }
+
+        if (wcfg.disableObsidianGenerators && (isAir || isLava)
+                && (blockTo.getType() == Material.REDSTONE_WIRE
+                    || blockTo.getType() == Material.TRIPWIRE)) {
+            blockTo.setType(Material.AIR);
+            return;
+        }
     }
 
     /*
@@ -190,14 +223,13 @@ public class WorldGuardBlockListener extends AbstractListener {
         Block block = event.getBlock();
         World world = block.getWorld();
 
-        ConfigurationManager cfg = getConfig();
+        ConfigurationManager cfg = WorldGuard.getInstance().getPlatform().getGlobalStateManager();
+        WorldConfiguration wcfg = getWorldConfig(world);
 
         if (cfg.activityHaltToggle) {
             event.setCancelled(true);
             return;
         }
-
-        WorldConfiguration wcfg = getWorldConfig(world);
         boolean isFireSpread = cause == IgniteCause.SPREAD;
 
         if (wcfg.preventLightningFire && cause == IgniteCause.LIGHTNING) {
@@ -217,7 +249,7 @@ public class WorldGuardBlockListener extends AbstractListener {
 
         if (wcfg.blockLighter && (cause == IgniteCause.FLINT_AND_STEEL || cause == IgniteCause.FIREBALL)
                 && event.getPlayer() != null
-                && !getPlugin().hasPermission(event.getPlayer(), "worldguard.override.lighter")) {
+                && !plugin.hasPermission(event.getPlayer(), "worldguard.override.lighter")) {
             event.setCancelled(true);
             return;
         }
@@ -278,15 +310,14 @@ public class WorldGuardBlockListener extends AbstractListener {
      */
     @EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
     public void onBlockBurn(BlockBurnEvent event) {
-        ConfigurationManager cfg = getConfig();
+        ConfigurationManager cfg = WorldGuard.getInstance().getPlatform().getGlobalStateManager();
+        BukkitWorldConfiguration wcfg = (BukkitWorldConfiguration) getWorldConfig(event.getBlock().getWorld());
 
         if (cfg.activityHaltToggle) {
             event.setCancelled(true);
             return;
         }
 
-        BukkitWorldConfiguration wcfg = getWorldConfig(event.getBlock().getWorld());
-
         if (wcfg.disableFireSpread) {
             event.setCancelled(true);
             return;
@@ -295,7 +326,7 @@ public class WorldGuardBlockListener extends AbstractListener {
         if (wcfg.fireSpreadDisableToggle) {
             Block block = event.getBlock();
             event.setCancelled(true);
-            checkAndDestroyFireAround(block.getWorld(), block.getX(), block.getY(), block.getZ());
+            checkAndDestroyAround(block.getWorld(), block.getX(), block.getY(), block.getZ(), Material.FIRE);
             return;
         }
 
@@ -304,7 +335,7 @@ public class WorldGuardBlockListener extends AbstractListener {
 
             if (wcfg.disableFireSpreadBlocks.contains(BukkitAdapter.asBlockType(block.getType()).getId())) {
                 event.setCancelled(true);
-                checkAndDestroyFireAround(block.getWorld(), block.getX(), block.getY(), block.getZ());
+                checkAndDestroyAround(block.getWorld(), block.getX(), block.getY(), block.getZ(), Material.FIRE);
                 return;
             }
         }
@@ -323,24 +354,24 @@ public class WorldGuardBlockListener extends AbstractListener {
                     WorldGuard.getInstance().getPlatform().getRegionContainer().createQuery().getApplicableRegions(BukkitAdapter.adapt(block.getLocation()));
 
             if (!set.testState(null, Flags.FIRE_SPREAD)) {
-                checkAndDestroyFireAround(block.getWorld(), x, y, z);
+                checkAndDestroyAround(block.getWorld(), x, y, z, Material.FIRE);
                 event.setCancelled(true);
             }
 
         }
     }
 
-    private void checkAndDestroyFireAround(World world, int x, int y, int z) {
-        checkAndDestroyFire(world, x, y, z + 1);
-        checkAndDestroyFire(world, x, y, z - 1);
-        checkAndDestroyFire(world, x, y + 1, z);
-        checkAndDestroyFire(world, x, y - 1, z);
-        checkAndDestroyFire(world, x + 1, y, z);
-        checkAndDestroyFire(world, x - 1, y, z);
+    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);
+        checkAndDestroy(world, x, y - 1, z, required);
+        checkAndDestroy(world, x + 1, y, z, required);
+        checkAndDestroy(world, x - 1, y, z, required);
     }
 
-    private void checkAndDestroyFire(World world, int x, int y, int z) {
-        if (Materials.isFire(world.getBlockAt(x, y, z).getType())) {
+    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);
         }
     }
@@ -350,22 +381,22 @@ public class WorldGuardBlockListener extends AbstractListener {
      */
     @EventHandler(ignoreCancelled = true)
     public void onBlockPhysics(BlockPhysicsEvent event) {
-        ConfigurationManager cfg = getConfig();
+        ConfigurationManager cfg = WorldGuard.getInstance().getPlatform().getGlobalStateManager();
+        WorldConfiguration wcfg = getWorldConfig(event.getBlock().getWorld());
 
         if (cfg.activityHaltToggle) {
             event.setCancelled(true);
             return;
         }
 
-        WorldConfiguration wcfg = getWorldConfig(event.getBlock().getWorld());
-        final Material id = event.getBlock().getType();
+        Material id = event.getBlock().getType();
 
         if (id == Material.GRAVEL && wcfg.noPhysicsGravel) {
             event.setCancelled(true);
             return;
         }
 
-        if ((id == Material.SAND || id == Material.RED_SAND) && wcfg.noPhysicsSand) {
+        if (id == Material.SAND && wcfg.noPhysicsSand) {
             event.setCancelled(true);
             return;
         }
@@ -375,7 +406,7 @@ public class WorldGuardBlockListener extends AbstractListener {
             return;
         }
 
-        if (id == Material.LADDER && wcfg.ropeLadders) {
+        if (wcfg.ropeLadders && event.getBlock().getType() == Material.LADDER) {
             if (event.getBlock().getRelative(0, 1, 0).getType() == Material.LADDER) {
                 event.setCancelled(true);
                 return;
@@ -442,15 +473,14 @@ public class WorldGuardBlockListener extends AbstractListener {
 
     @EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
     public void onLeavesDecay(LeavesDecayEvent event) {
-        ConfigurationManager cfg = getConfig();
+        ConfigurationManager cfg = WorldGuard.getInstance().getPlatform().getGlobalStateManager();
+        WorldConfiguration wcfg = getWorldConfig(event.getBlock().getWorld());
 
         if (cfg.activityHaltToggle) {
             event.setCancelled(true);
             return;
         }
 
-        WorldConfiguration wcfg = getWorldConfig(event.getBlock().getWorld());
-
         if (wcfg.disableLeafDecay) {
             event.setCancelled(true);
             return;
@@ -468,15 +498,14 @@ public class WorldGuardBlockListener extends AbstractListener {
      */
     @EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
     public void onBlockForm(BlockFormEvent event) {
-        ConfigurationManager cfg = getConfig();
+        ConfigurationManager cfg = WorldGuard.getInstance().getPlatform().getGlobalStateManager();
+        WorldConfiguration wcfg = getWorldConfig(event.getBlock().getWorld());
 
         if (cfg.activityHaltToggle) {
             event.setCancelled(true);
             return;
         }
 
-        WorldConfiguration wcfg = getWorldConfig(event.getBlock().getWorld());
-
         Material type = event.getNewState().getType();
 
         if (event instanceof EntityBlockFormEvent) {
@@ -520,18 +549,6 @@ public class WorldGuardBlockListener extends AbstractListener {
                 return;
             }
         }
-
-        if (Materials.isUnwaxedCopper(event.getBlock().getType())) {
-            if (wcfg.disableCopperBlockFade) {
-                event.setCancelled(true);
-                return;
-            }
-            if (wcfg.useRegions && !StateFlag.test(WorldGuard.getInstance().getPlatform().getRegionContainer().createQuery()
-                    .queryState(BukkitAdapter.adapt(event.getBlock().getLocation()), (RegionAssociable) null, Flags.COPPER_FADE))) {
-                event.setCancelled(true);
-                return;
-            }
-        }
     }
 
     /*
@@ -539,14 +556,14 @@ public class WorldGuardBlockListener extends AbstractListener {
      */
     @EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
     public void onBlockSpread(BlockSpreadEvent event) {
-        ConfigurationManager cfg = getConfig();
+        ConfigurationManager cfg = WorldGuard.getInstance().getPlatform().getGlobalStateManager();
+        WorldConfiguration wcfg = getWorldConfig(event.getBlock().getWorld());
 
         if (cfg.activityHaltToggle) {
             event.setCancelled(true);
             return;
         }
 
-        WorldConfiguration wcfg = getWorldConfig(event.getBlock().getWorld());
         Material newType = event.getNewState().getType(); // craftbukkit randomly gives AIR as event.getSource even if that block is not air
 
         if (Materials.isMushroom(newType)) {
@@ -586,7 +603,7 @@ public class WorldGuardBlockListener extends AbstractListener {
             }
         }
 
-        if (Materials.isVine(newType)) {
+        if (newType == Material.VINE || newType == Material.KELP) {
             if (wcfg.disableVineGrowth) {
                 event.setCancelled(true);
                 return;
@@ -598,54 +615,21 @@ public class WorldGuardBlockListener extends AbstractListener {
                 return;
             }
         }
-
-        if (Materials.isAmethystGrowth(newType) || newType == Material.POINTED_DRIPSTONE) {
-            if (wcfg.disableRockGrowth) {
-                event.setCancelled(true);
-                return;
-            }
-
-            if (wcfg.useRegions && !StateFlag.test(WorldGuard.getInstance().getPlatform().getRegionContainer().createQuery()
-                    .queryState(BukkitAdapter.adapt(event.getBlock().getLocation()), (RegionAssociable) null, Flags.ROCK_GROWTH))) {
-                event.setCancelled(true);
-                return;
-            }
-        }
-
-        if (Materials.isSculkGrowth(newType)) {
-            if (wcfg.disableSculkGrowth) {
-                event.setCancelled(true);
-                return;
-            }
-
-            if (wcfg.useRegions && !StateFlag.test(WorldGuard.getInstance().getPlatform().getRegionContainer().createQuery()
-                    .queryState(BukkitAdapter.adapt(event.getBlock().getLocation()), (RegionAssociable) null, Flags.SCULK_GROWTH))) {
-                event.setCancelled(true);
-                return;
-            }
-        }
-
-        handleGrow(event, event.getBlock().getLocation(), newType);
     }
 
     @EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
     public void onBlockGrow(BlockGrowEvent event) {
-        Location loc = event.getBlock().getLocation();
+        WorldConfiguration wcfg = getWorldConfig(event.getBlock().getWorld());
         final Material type = event.getNewState().getType();
 
-        handleGrow(event, loc, type);
-    }
-
-    private void handleGrow(Cancellable event, Location loc, Material type) {
-        WorldConfiguration wcfg = getWorldConfig(loc.getWorld());
         if (Materials.isCrop(type)) {
             if (wcfg.disableCropGrowth) {
-                event.setCancelled(true);
+                event.setCancelled(false);
                 return;
             }
 
             if (wcfg.useRegions && !StateFlag.test(WorldGuard.getInstance().getPlatform().getRegionContainer().createQuery()
-                .queryState(BukkitAdapter.adapt(loc), (RegionAssociable) null, Flags.CROP_GROWTH))) {
+                .queryState(BukkitAdapter.adapt(event.getBlock().getLocation()), (RegionAssociable) null, Flags.CROP_GROWTH))) {
                 event.setCancelled(true);
                 return;
             }
@@ -698,22 +682,12 @@ public class WorldGuardBlockListener extends AbstractListener {
                 event.setCancelled(true);
                 return;
             }
-        } else if (Materials.isCoral(event.getBlock().getType())) {
-            if (wcfg.disableCoralBlockFade) {
-                event.setCancelled(true);
-                return;
-            }
-            if (wcfg.useRegions && !StateFlag.test(WorldGuard.getInstance().getPlatform().getRegionContainer().createQuery()
-                    .queryState(BukkitAdapter.adapt(event.getBlock().getLocation()), (RegionAssociable) null, Flags.CORAL_FADE))) {
-                event.setCancelled(true);
-                return;
-            }
         }
     }
 
     @EventHandler(ignoreCancelled = true)
     public void onBlockExplode(BlockExplodeEvent event) {
-        ConfigurationManager cfg = getConfig();
+        ConfigurationManager cfg = WorldGuard.getInstance().getPlatform().getGlobalStateManager();
 
         if (cfg.activityHaltToggle) {
             event.setCancelled(true);

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

@@ -19,7 +19,7 @@
 
 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;

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

@@ -25,17 +25,13 @@ 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.bukkit.util.Entities;
-import com.sk89q.worldguard.bukkit.util.InteropUtils;
 import com.sk89q.worldguard.config.ConfigurationManager;
 import com.sk89q.worldguard.config.WorldConfiguration;
 import com.sk89q.worldguard.protection.ApplicableRegionSet;
-import com.sk89q.worldguard.protection.FailedLoadRegionSet;
 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.flags.StateFlag.State;
 import com.sk89q.worldguard.protection.managers.RegionManager;
 import com.sk89q.worldguard.protection.regions.ProtectedCuboidRegion;
 import com.sk89q.worldguard.protection.regions.RegionQuery;
@@ -51,9 +47,7 @@ import org.bukkit.entity.EnderDragon;
 import org.bukkit.entity.Enderman;
 import org.bukkit.entity.Entity;
 import org.bukkit.entity.EntityType;
-import org.bukkit.entity.FallingBlock;
 import org.bukkit.entity.Fireball;
-import org.bukkit.entity.HumanEntity;
 import org.bukkit.entity.ItemFrame;
 import org.bukkit.entity.LivingEntity;
 import org.bukkit.entity.Player;
@@ -66,6 +60,7 @@ 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.CreatureSpawnEvent;
 import org.bukkit.event.entity.CreatureSpawnEvent.SpawnReason;
 import org.bukkit.event.entity.CreeperPowerEvent;
@@ -79,13 +74,10 @@ 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.EntityRegainHealthEvent.RegainReason;
 import org.bukkit.event.entity.EntityTransformEvent;
 import org.bukkit.event.entity.ExplosionPrimeEvent;
-import org.bukkit.event.entity.FoodLevelChangeEvent;
 import org.bukkit.event.entity.PigZapEvent;
 import org.bukkit.event.entity.PlayerDeathEvent;
-import org.bukkit.event.vehicle.VehicleEnterEvent;
 import org.bukkit.event.world.PortalCreateEvent;
 import org.bukkit.inventory.ItemStack;
 import org.bukkit.projectiles.ProjectileSource;
@@ -94,8 +86,12 @@ import java.util.Set;
 
 /**
  * Listener for entity related events.
+ *
+ * @author sk89q
  */
-public class WorldGuardEntityListener extends AbstractListener {
+public class WorldGuardEntityListener implements Listener {
+
+    private WorldGuardPlugin plugin;
 
     /**
      * Construct the object;
@@ -103,32 +99,36 @@ public class WorldGuardEntityListener extends AbstractListener {
      * @param plugin The plugin instance
      */
     public WorldGuardEntityListener(WorldGuardPlugin plugin) {
-        super(plugin);
+        this.plugin = plugin;
+    }
+
+    /**
+     * Register events.
+     */
+    public void registerEvents() {
+        plugin.getServer().getPluginManager().registerEvents(this, plugin);
     }
 
     @EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
     public void onEntityInteract(EntityInteractEvent event) {
+        Entity entity = event.getEntity();
         Block block = event.getBlock();
 
-        WorldConfiguration wcfg = getWorldConfig(block.getWorld());
+        ConfigurationManager cfg = WorldGuard.getInstance().getPlatform().getGlobalStateManager();
+        WorldConfiguration wcfg = cfg.get(BukkitAdapter.adapt(entity.getWorld()));
 
-        if (block.getType() == Material.FARMLAND && wcfg.disableCreatureCropTrampling) {
-            event.setCancelled(true);
-            return;
-        }
-        if (block.getType() == Material.TURTLE_EGG && wcfg.disableCreatureTurtleEggTrampling) {
-            event.setCancelled(true);
-            return;
-        }
-        if (block.getType() == Material.SNIFFER_EGG && wcfg.disableCreatureSnifferEggTrampling) {
-            event.setCancelled(true);
-            return;
+        if (block.getType() == Material.FARMLAND) {
+            if (/* entity instanceof Creature && // catch for any entity (not thrown for players) */
+                wcfg.disableCreatureCropTrampling) {
+                event.setCancelled(true);
+            }
         }
     }
 
     @EventHandler(priority = EventPriority.HIGH)
     public void onEntityDeath(EntityDeathEvent event) {
-        WorldConfiguration wcfg = getWorldConfig(event.getEntity().getWorld());
+        WorldConfiguration wcfg =
+                WorldGuard.getInstance().getPlatform().getGlobalStateManager().get(BukkitAdapter.adapt(event.getEntity().getWorld()));
 
         if (event instanceof PlayerDeathEvent && wcfg.disableDeathMessages) {
             ((PlayerDeathEvent) event).setDeathMessage("");
@@ -139,14 +139,16 @@ public class WorldGuardEntityListener extends AbstractListener {
         Entity defender = event.getEntity();
         DamageCause type = event.getCause();
 
-        WorldConfiguration wcfg = getWorldConfig(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)) {
                 event.setCancelled(true);
                 return;
             }
-        } else if (defender instanceof Player player && !Entities.isNPC(defender)) {
+        } else if (defender instanceof Player) {
+            Player player = (Player) defender;
             LocalPlayer localPlayer = WorldGuardPlugin.inst().wrapPlayer(player);
 
             if (wcfg.disableLavaDamage && type == DamageCause.LAVA) {
@@ -188,7 +190,7 @@ public class WorldGuardEntityListener extends AbstractListener {
             // handled anywhere else
             if (type == DamageCause.BLOCK_EXPLOSION
                     && (wcfg.blockOtherExplosions
-                            || ((wcfg.explosionFlagCancellation || Entities.isConsideredBuildingIfUsed(defender))
+                            || (wcfg.explosionFlagCancellation
                                 && !StateFlag.test(WorldGuard.getInstance().getPlatform().getRegionContainer().createQuery()
                     .queryState(BukkitAdapter.adapt(defender.getLocation()), (RegionAssociable) null, Flags.OTHER_EXPLOSION))))) {
                 event.setCancelled(true);
@@ -208,7 +210,8 @@ public class WorldGuardEntityListener extends AbstractListener {
         Entity attacker = event.getDamager();
         Entity defender = event.getEntity();
 
-        WorldConfiguration wcfg = getWorldConfig(defender.getWorld());
+        WorldConfiguration wcfg =
+                WorldGuard.getInstance().getPlatform().getGlobalStateManager().get(BukkitAdapter.adapt(defender.getWorld()));
 
         if (defender instanceof ItemFrame) {
             if (checkItemFrameProtection(attacker, (ItemFrame) defender)) {
@@ -234,8 +237,9 @@ public class WorldGuardEntityListener extends AbstractListener {
             }
         }
 
-        if (defender instanceof Player player && !Entities.isNPC(defender)) {
-            LocalPlayer localPlayer = getPlugin().wrapPlayer(player);
+        if (defender instanceof Player) {
+            Player player = (Player) defender;
+            LocalPlayer localPlayer = plugin.wrapPlayer(player);
 
             if (wcfg.disableLightningDamage && event.getCause() == DamageCause.LIGHTNING) {
                 event.setCancelled(true);
@@ -294,9 +298,11 @@ public class WorldGuardEntityListener extends AbstractListener {
             return;
         }
 
-        WorldConfiguration wcfg = getWorldConfig(defender.getWorld());
-        if (defender instanceof Player player && !Entities.isNPC(defender)) {
-            LocalPlayer localPlayer = getPlugin().wrapPlayer(player);
+        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);
 
 
             // Check Mob
@@ -361,14 +367,16 @@ public class WorldGuardEntityListener extends AbstractListener {
         Entity defender = event.getEntity();
         DamageCause type = event.getCause();
 
-        WorldConfiguration wcfg = getWorldConfig(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) {
                 event.setCancelled(true);
                 return;
             }
-        } else if (defender instanceof Player player && !Entities.isNPC(defender)) {
+        } else if (defender instanceof Player) {
+            Player player = (Player) defender;
             LocalPlayer localPlayer = WorldGuardPlugin.inst().wrapPlayer(player);
 
             if (type == DamageCause.WITHER) {
@@ -381,14 +389,14 @@ public class WorldGuardEntityListener extends AbstractListener {
                 if (wcfg.useRegions) {
                     ApplicableRegionSet set = WorldGuard.getInstance().getPlatform().getRegionContainer().createQuery().getApplicableRegions(localPlayer.getLocation());
 
-                    if (!set.testState(getPlugin().wrapPlayer(player), Flags.MOB_DAMAGE)) {
+                    if (!set.testState(plugin.wrapPlayer(player), Flags.MOB_DAMAGE)) {
                         event.setCancelled(true);
                         return;
                     }
                 }
             }
 
-            if (type == DamageCause.DROWNING && getConfig().hasAmphibiousMode(localPlayer)) {
+            if (type == DamageCause.DROWNING && cfg.hasAmphibiousMode(localPlayer)) {
                 player.setRemainingAir(player.getMaximumAir());
                 event.setCancelled(true);
                 return;
@@ -440,7 +448,10 @@ public class WorldGuardEntityListener extends AbstractListener {
      */
     @EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
     public void onEntityExplode(EntityExplodeEvent event) {
-        ConfigurationManager cfg = getConfig();
+        ConfigurationManager cfg = WorldGuard.getInstance().getPlatform().getGlobalStateManager();
+        Location l = event.getLocation();
+        World world = l.getWorld();
+        BukkitWorldConfiguration wcfg = (BukkitWorldConfiguration) cfg.get(BukkitAdapter.adapt(world));
         Entity ent = event.getEntity();
 
         if (cfg.activityHaltToggle) {
@@ -449,7 +460,6 @@ public class WorldGuardEntityListener extends AbstractListener {
             return;
         }
 
-        BukkitWorldConfiguration wcfg = getWorldConfig(event.getLocation().getWorld());
         if (ent instanceof Creeper) {
             if (wcfg.blockCreeperExplosions) {
                 event.setCancelled(true);
@@ -556,7 +566,8 @@ public class WorldGuardEntityListener extends AbstractListener {
      */
     @EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
     public void onExplosionPrime(ExplosionPrimeEvent event) {
-        ConfigurationManager cfg = getConfig();
+        ConfigurationManager cfg = WorldGuard.getInstance().getPlatform().getGlobalStateManager();
+        WorldConfiguration wcfg = cfg.get(BukkitAdapter.adapt(event.getEntity().getWorld()));
         Entity ent = event.getEntity();
 
         if (cfg.activityHaltToggle) {
@@ -565,7 +576,6 @@ public class WorldGuardEntityListener extends AbstractListener {
             return;
         }
 
-        BukkitWorldConfiguration wcfg = getWorldConfig(ent.getWorld());
         if (event.getEntityType() == EntityType.WITHER) {
             if (wcfg.blockWitherExplosions) {
                 event.setCancelled(true);
@@ -586,8 +596,8 @@ public class WorldGuardEntityListener extends AbstractListener {
                 event.setCancelled(true);
                 return;
             }
-        } else if (event.getEntityType() == EntityType.TNT
-                || event.getEntityType() == EntityType.TNT_MINECART) {
+        } else if (event.getEntityType() == EntityType.PRIMED_TNT
+                || event.getEntityType() == EntityType.MINECART_TNT) {
             if (wcfg.blockTNTExplosions) {
                 event.setCancelled(true);
                 return;
@@ -597,17 +607,17 @@ public class WorldGuardEntityListener extends AbstractListener {
 
     @EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
     public void onCreatureSpawn(CreatureSpawnEvent event) {
-        ConfigurationManager cfg = getConfig();
+        ConfigurationManager cfg = WorldGuard.getInstance().getPlatform().getGlobalStateManager();
 
         if (cfg.activityHaltToggle) {
             event.setCancelled(true);
             return;
         }
 
-        WorldConfiguration wcfg = getWorldConfig(event.getEntity().getWorld());
+        WorldConfiguration wcfg = cfg.get(BukkitAdapter.adapt(event.getEntity().getWorld()));
 
         // allow spawning of creatures from plugins
-        if (!wcfg.blockPluginSpawning && Entities.isPluginSpawning(event.getSpawnReason())) {
+        if (!wcfg.blockPluginSpawning && event.getSpawnReason() == CreatureSpawnEvent.SpawnReason.CUSTOM) {
             return;
         }
 
@@ -659,48 +669,37 @@ public class WorldGuardEntityListener extends AbstractListener {
 
     @EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
     public void onCreatePortal(PortalCreateEvent event) {
-        WorldConfiguration wcfg = getWorldConfig(event.getWorld());
+        ConfigurationManager cfg = WorldGuard.getInstance().getPlatform().getGlobalStateManager();
+        final com.sk89q.worldedit.world.World world = BukkitAdapter.adapt(event.getWorld());
+        WorldConfiguration wcfg = cfg.get(world);
 
-        if (wcfg.useRegions && wcfg.regionNetherPortalProtection
+        if (wcfg.regionNetherPortalProtection
                 && event.getReason() == PortalCreateEvent.CreateReason.NETHER_PAIR
                 && !event.getBlocks().isEmpty()) {
-            final com.sk89q.worldedit.world.World world = BukkitAdapter.adapt(event.getWorld());
-            final Cause cause = Cause.create(event.getEntity());
-            LocalPlayer localPlayer = null;
-            if (cause.getRootCause() instanceof Player player) {
-                if (wcfg.fakePlayerBuildOverride && InteropUtils.isFakePlayer(player)) {
-                    return;
-                }
-                localPlayer = getPlugin().wrapPlayer(player);
-                if (WorldGuard.getInstance().getPlatform().getSessionManager().hasBypass(localPlayer, world)) {
-                    return;
-                }
-            }
             final RegionManager regionManager = WorldGuard.getInstance().getPlatform().getRegionContainer()
                     .get(world);
-            ApplicableRegionSet regions;
-            if (regionManager == null) {
-                regions = FailedLoadRegionSet.getInstance();
-            } else {
-                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);
+            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;
                 }
-                ProtectedCuboidRegion target = new ProtectedCuboidRegion("__portal_check", true, min, max);
-                regions = regionManager.getApplicableRegions(target);
             }
-            final RegionAssociable associable = createRegionAssociable(cause);
-            final State buildState = StateFlag.denyToNone(regions.queryState(associable, Flags.BUILD));
-            if (!StateFlag.test(buildState, regions.queryState(associable, Flags.BLOCK_BREAK))
-                    || !StateFlag.test(buildState, regions.queryState(associable, Flags.BLOCK_PLACE))) {
-                if (localPlayer != null && !cause.isIndirect()) {
+            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
-                    String message = regions.queryValue(localPlayer, Flags.DENY_MESSAGE);
-                    RegionProtectionListener.formatAndSendDenyMessage("create portals", localPlayer, message);
+                    associable.print("Destination is an a protected area.");
                 }
                 event.setCancelled(true);
             }
@@ -715,8 +714,9 @@ public class WorldGuardEntityListener extends AbstractListener {
 
     @EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
     public void onEntityTransform(EntityTransformEvent event) {
+        ConfigurationManager cfg = WorldGuard.getInstance().getPlatform().getGlobalStateManager();
         final Entity entity = event.getEntity();
-        WorldConfiguration wcfg = getWorldConfig(entity.getWorld());
+        WorldConfiguration wcfg = cfg.get(BukkitAdapter.adapt(entity.getWorld()));
 
         final EntityType type = entity.getType();
         if (wcfg.disableVillagerZap && type == EntityType.VILLAGER
@@ -727,8 +727,9 @@ public class WorldGuardEntityListener extends AbstractListener {
 
     @EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
     public void onPigZap(PigZapEvent event) {
+        ConfigurationManager cfg = WorldGuard.getInstance().getPlatform().getGlobalStateManager();
         final Entity entity = event.getEntity();
-        WorldConfiguration wcfg = getWorldConfig(entity.getWorld());
+        WorldConfiguration wcfg = cfg.get(BukkitAdapter.adapt(entity.getWorld()));
 
         if (wcfg.disablePigZap) {
             event.setCancelled(true);
@@ -737,8 +738,8 @@ public class WorldGuardEntityListener extends AbstractListener {
 
     @EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
     public void onCreeperPower(CreeperPowerEvent event) {
-        final Entity entity = event.getEntity();
-        WorldConfiguration wcfg = getWorldConfig(entity.getWorld());
+        ConfigurationManager cfg = WorldGuard.getInstance().getPlatform().getGlobalStateManager();
+        WorldConfiguration wcfg = cfg.get(BukkitAdapter.adapt(event.getEntity().getWorld()));
 
         if (wcfg.disableCreeperPower) {
             event.setCancelled(true);
@@ -747,44 +748,17 @@ public class WorldGuardEntityListener extends AbstractListener {
 
     @EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
     public void onEntityRegainHealth(EntityRegainHealthEvent event) {
-        RegainReason regainReason = event.getRegainReason();
-        if (regainReason != RegainReason.REGEN && regainReason != RegainReason.SATIATED) {
-            return;
-        }
 
         Entity ent = event.getEntity();
+        World world = ent.getWorld();
 
-        WorldConfiguration wcfg = getWorldConfig(ent.getWorld());
+        ConfigurationManager cfg = WorldGuard.getInstance().getPlatform().getGlobalStateManager();
+        WorldConfiguration wcfg = cfg.get(BukkitAdapter.adapt(world));
 
         if (wcfg.disableHealthRegain) {
             event.setCancelled(true);
             return;
         }
-        if (wcfg.useRegions && ent instanceof Player player && !Entities.isNPC(ent)
-                && !WorldGuard.getInstance().getPlatform().getRegionContainer().createQuery().testState(
-                        BukkitAdapter.adapt(ent.getLocation()),
-                        WorldGuardPlugin.inst().wrapPlayer(player),
-                        Flags.HEALTH_REGEN)) {
-            event.setCancelled(true);
-        }
-    }
-
-    @EventHandler(ignoreCancelled = true)
-    public void onFoodChange(FoodLevelChangeEvent event) {
-        if (event.getItem() != null) return;
-        HumanEntity ent = event.getEntity();
-        if (Entities.isNPC(ent)) return;
-        if (!(ent instanceof Player bukkitPlayer)) return;
-        if (event.getFoodLevel() > ent.getFoodLevel()) return;
-
-        LocalPlayer player = WorldGuardPlugin.inst().wrapPlayer(bukkitPlayer);
-        WorldConfiguration wcfg = getWorldConfig(ent.getWorld());
-
-        if (wcfg.useRegions
-                && !WorldGuard.getInstance().getPlatform().getRegionContainer().createQuery().testState(
-                        player.getLocation(), player, Flags.HUNGER_DRAIN)) {
-            event.setCancelled(true);
-        }
     }
 
     /**
@@ -795,21 +769,12 @@ public class WorldGuardEntityListener extends AbstractListener {
     @EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
     public void onEntityChangeBlock(EntityChangeBlockEvent event) {
         Entity ent = event.getEntity();
+        Block block = event.getBlock();
+        Location location = block.getLocation();
 
-        WorldConfiguration wcfg = getWorldConfig(ent.getWorld());
-        if (ent instanceof FallingBlock) {
-            Material id = event.getBlock().getType();
-
-            if (id == Material.GRAVEL && wcfg.noPhysicsGravel) {
-                event.setCancelled(true);
-                return;
-            }
-
-            if ((id == Material.SAND || id == Material.RED_SAND) && wcfg.noPhysicsSand) {
-                event.setCancelled(true);
-                return;
-            }
-        } else if (ent instanceof Enderman) {
+        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;
@@ -820,7 +785,6 @@ public class WorldGuardEntityListener extends AbstractListener {
                 return;
             }
             if (wcfg.useRegions) {
-                Location location = event.getBlock().getLocation();
                 if (!StateFlag.test(WorldGuard.getInstance().getPlatform().getRegionContainer().createQuery().queryState(BukkitAdapter.adapt(location), (RegionAssociable) null, Flags.WITHER_DAMAGE))) {
                     event.setCancelled(true);
                     return;
@@ -834,15 +798,6 @@ public class WorldGuardEntityListener extends AbstractListener {
         }
     }
 
-    @EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
-    public void onVehicleEnter(VehicleEnterEvent event) {
-        BukkitWorldConfiguration wcfg = getWorldConfig(event.getEntered().getWorld());
-
-        if (wcfg.blockEntityVehicleEntry && !(event.getEntered() instanceof Player)) {
-            event.setCancelled(true);
-        }
-    }
-
     /**
      * Checks regions and config settings to protect items from being knocked
      * out of item frames.
@@ -851,8 +806,9 @@ public class WorldGuardEntityListener extends AbstractListener {
      * @return true if the event should be cancelled
      */
     private boolean checkItemFrameProtection(Entity attacker, ItemFrame defender) {
-        World world = defender.getWorld();
-        WorldConfiguration wcfg = getWorldConfig(world);
+        World world = attacker.getWorld();
+        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
             if (!(attacker instanceof Player)) {

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

@@ -22,6 +22,7 @@ package com.sk89q.worldguard.bukkit.listener;
 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.protection.association.RegionAssociable;
 import com.sk89q.worldguard.protection.flags.Flags;
@@ -37,6 +38,7 @@ import org.bukkit.entity.Player;
 import org.bukkit.entity.Projectile;
 import org.bukkit.event.EventHandler;
 import org.bukkit.event.EventPriority;
+import org.bukkit.event.Listener;
 import org.bukkit.event.hanging.HangingBreakByEntityEvent;
 import org.bukkit.event.hanging.HangingBreakEvent;
 import org.bukkit.event.hanging.HangingBreakEvent.RemoveCause;
@@ -44,18 +46,35 @@ import org.bukkit.projectiles.ProjectileSource;
 
 /**
  * Listener for painting related events.
+ *
+ * @author BangL <henno.rickowski@gmail.com>
  */
-public class WorldGuardHangingListener extends AbstractListener {
+public class WorldGuardHangingListener implements Listener {
 
+    private WorldGuardPlugin plugin;
+
+    /**
+     * Construct the object;
+     *
+     * @param plugin The plugin instance
+     */
     public WorldGuardHangingListener(WorldGuardPlugin plugin) {
-        super(plugin);
+        this.plugin = plugin;
+    }
+
+    /**
+     * Register events.
+     */
+    public void registerEvents() {
+        plugin.getServer().getPluginManager().registerEvents(this, plugin);
     }
 
     @EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
     public void onHangingBreak(HangingBreakEvent event) {
         Hanging hanging = event.getEntity();
         World world = hanging.getWorld();
-        WorldConfiguration wcfg = getWorldConfig(world);
+        ConfigurationManager cfg = WorldGuard.getInstance().getPlatform().getGlobalStateManager();
+        WorldConfiguration wcfg = cfg.get(BukkitAdapter.adapt(world));
 
         if (event instanceof HangingBreakByEntityEvent) {
             HangingBreakByEntityEvent entityEvent = (HangingBreakByEntityEvent) event;

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

@@ -38,7 +38,6 @@ 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 com.sk89q.worldguard.util.profile.Profile;
 import org.bukkit.ChatColor;
 import org.bukkit.Material;
 import org.bukkit.World;
@@ -48,6 +47,7 @@ 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;
 import org.bukkit.event.block.Action;
 import org.bukkit.event.player.AsyncPlayerChatEvent;
 import org.bukkit.event.player.PlayerCommandPreprocessEvent;
@@ -60,31 +60,45 @@ import org.bukkit.event.player.PlayerRespawnEvent;
 import org.bukkit.event.player.PlayerTeleportEvent;
 import org.bukkit.event.player.PlayerTeleportEvent.TeleportCause;
 import org.bukkit.inventory.ItemStack;
+import org.bukkit.plugin.PluginManager;
 
+import javax.annotation.Nullable;
 import java.util.Iterator;
 import java.util.Set;
 import java.util.logging.Logger;
 import java.util.regex.Pattern;
-import javax.annotation.Nullable;
 
 /**
  * Handles all events thrown in relation to a player.
  */
-public class WorldGuardPlayerListener extends AbstractListener {
+public class WorldGuardPlayerListener implements Listener {
 
     private static final Logger log = Logger.getLogger(WorldGuardPlayerListener.class.getCanonicalName());
     private static final Pattern opPattern = Pattern.compile("^/(?:minecraft:)?(?:bukkit:)?(?:de)?op(?:\\s.*)?$", Pattern.CASE_INSENSITIVE);
+    private WorldGuardPlugin plugin;
 
+    /**
+     * Construct the object;
+     *
+     * @param plugin
+     */
     public WorldGuardPlayerListener(WorldGuardPlugin plugin) {
-        super(plugin);
+        this.plugin = plugin;
     }
 
+    /**
+     * Register events.
+     */
+    public void registerEvents() {
+        PluginManager pm = plugin.getServer().getPluginManager();
+        pm.registerEvents(this, plugin);
+    }
 
     @EventHandler
     public void onPlayerGameModeChange(PlayerGameModeChangeEvent event) {
         Player player = event.getPlayer();
-        LocalPlayer localPlayer = getPlugin().wrapPlayer(player);
-        WorldConfiguration wcfg = getWorldConfig(player.getWorld());
+        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);
@@ -102,10 +116,11 @@ public class WorldGuardPlayerListener extends AbstractListener {
     @EventHandler
     public void onPlayerJoin(PlayerJoinEvent event) {
         Player player = event.getPlayer();
+        LocalPlayer localPlayer = plugin.wrapPlayer(player);
         World world = player.getWorld();
 
-        ConfigurationManager cfg = getConfig();
-        WorldConfiguration wcfg = getWorldConfig(world);
+        ConfigurationManager cfg = WorldGuard.getInstance().getPlatform().getGlobalStateManager();
+        WorldConfiguration wcfg = cfg.get(localPlayer.getWorld());
 
         if (cfg.activityHaltToggle) {
             player.sendMessage(ChatColor.YELLOW
@@ -132,15 +147,14 @@ public class WorldGuardPlayerListener extends AbstractListener {
         }
 
         Events.fire(new ProcessPlayerEvent(player));
-        WorldGuard.getInstance().getExecutorService().submit(() ->
-            WorldGuard.getInstance().getProfileCache().put(new Profile(player.getUniqueId(), player.getName())));
     }
 
     @EventHandler(ignoreCancelled = true)
     public void onPlayerChat(AsyncPlayerChatEvent event) {
         Player player = event.getPlayer();
-        LocalPlayer localPlayer = getPlugin().wrapPlayer(player);
-        WorldConfiguration wcfg = getWorldConfig(player.getWorld());
+        LocalPlayer localPlayer = plugin.wrapPlayer(player);
+        WorldConfiguration wcfg =
+                WorldGuard.getInstance().getPlatform().getGlobalStateManager().get(localPlayer.getWorld());
         if (wcfg.useRegions) {
             RegionQuery query = WorldGuard.getInstance().getPlatform().getRegionContainer().createQuery();
             ApplicableRegionSet chatFrom = query.getApplicableRegions(localPlayer.getLocation());
@@ -155,7 +169,7 @@ public class WorldGuardPlayerListener extends AbstractListener {
             boolean anyRemoved = false;
             for (Iterator<Player> i = event.getRecipients().iterator(); i.hasNext();) {
                 Player rPlayer = i.next();
-                LocalPlayer rLocal = getPlugin().wrapPlayer(rPlayer);
+                LocalPlayer rLocal = plugin.wrapPlayer(rPlayer);
                 if (!query.testState(rLocal.getLocation(), rLocal, Flags.RECEIVE_CHAT)) {
                     i.remove();
                     anyRemoved = true;
@@ -170,7 +184,7 @@ public class WorldGuardPlayerListener extends AbstractListener {
     @EventHandler(ignoreCancelled = true)
     public void onPlayerLogin(PlayerLoginEvent event) {
         Player player = event.getPlayer();
-        ConfigurationManager cfg = getConfig();
+        ConfigurationManager cfg = WorldGuard.getInstance().getPlatform().getGlobalStateManager();
 
         String hostKey = cfg.hostKeys.get(player.getUniqueId().toString());
         if (hostKey == null) {
@@ -185,8 +199,7 @@ public class WorldGuardPlayerListener extends AbstractListener {
             }
 
             if (!hostname.equals(hostKey)
-                    && !(cfg.hostKeysAllowFMLClients &&
-                            (hostname.equals(hostKey + "\u0000FML\u0000") || hostname.equals(hostKey + "\u0000FML2\u0000")))) {
+                    && !(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: " +
@@ -212,11 +225,11 @@ public class WorldGuardPlayerListener extends AbstractListener {
             handlePhysicalInteract(event);
         }
 
-        ConfigurationManager cfg = getConfig();
-        WorldConfiguration wcfg = getWorldConfig(world);
+        ConfigurationManager cfg = WorldGuard.getInstance().getPlatform().getGlobalStateManager();
+        WorldConfiguration wcfg = cfg.get(BukkitAdapter.adapt(world));
 
         if (wcfg.removeInfiniteStacks
-                && !getPlugin().hasPermission(player, "worldguard.override.infinite-stack")) {
+                && !plugin.hasPermission(player, "worldguard.override.infinite-stack")) {
             int slot = player.getInventory().getHeldItemSlot();
             ItemStack heldItem = player.getInventory().getItem(slot);
             if (heldItem != null && heldItem.getAmount() < 0) {
@@ -242,12 +255,13 @@ public class WorldGuardPlayerListener extends AbstractListener {
         Player player = event.getPlayer();
         @Nullable ItemStack item = event.getItem();
 
-        WorldConfiguration wcfg = getWorldConfig(world);
+        ConfigurationManager cfg = WorldGuard.getInstance().getPlatform().getGlobalStateManager();
+        WorldConfiguration wcfg = cfg.get(BukkitAdapter.adapt(world));
 
         // Infinite stack removal
         if (Materials.isInventoryBlock(type)
                 && wcfg.removeInfiniteStacks
-                && !getPlugin().hasPermission(player, "worldguard.override.infinite-stack")) {
+                && !plugin.hasPermission(player, "worldguard.override.infinite-stack")) {
             for (int slot = 0; slot < 40; slot++) {
                 ItemStack heldItem = player.getInventory().getItem(slot);
                 if (heldItem != null && heldItem.getAmount() < 0) {
@@ -258,11 +272,13 @@ public class WorldGuardPlayerListener extends AbstractListener {
         }
 
         if (wcfg.useRegions) {
-            LocalPlayer localPlayer = getPlugin().wrapPlayer(player);
+            //Block placedIn = block.getRelative(event.getBlockFace());
+            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.getType().getKey().toString().equals(wcfg.regionWand) && getPlugin().hasPermission(player, "worldguard.region.wand")) {
-                ApplicableRegionSet set = WorldGuard.getInstance().getPlatform().getRegionContainer().createQuery()
-                        .getApplicableRegions(BukkitAdapter.adapt(block.getLocation()), RegionQuery.QueryOption.SORT);
+            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.testState(localPlayer, Flags.BUILD) ? "Yes" : "No"));
 
@@ -294,20 +310,13 @@ public class WorldGuardPlayerListener extends AbstractListener {
 
         Player player = event.getPlayer();
         Block block = event.getClickedBlock(); //not actually clicked but whatever
-        Material type = block.getType();
+        //int type = block.getTypeId();
         World world = player.getWorld();
 
-        WorldConfiguration wcfg = getWorldConfig(world);
+        ConfigurationManager cfg = WorldGuard.getInstance().getPlatform().getGlobalStateManager();
+        WorldConfiguration wcfg = cfg.get(BukkitAdapter.adapt(world));
 
-        if (type == Material.FARMLAND && wcfg.disablePlayerCropTrampling) {
-            event.setCancelled(true);
-            return;
-        }
-        if (type == Material.TURTLE_EGG && wcfg.disablePlayerTurtleEggTrampling) {
-            event.setCancelled(true);
-            return;
-        }
-        if (type == Material.SNIFFER_EGG && wcfg.disablePlayerSnifferEggTrampling) {
+        if (block.getType() == Material.FARMLAND && wcfg.disablePlayerCropTrampling) {
             event.setCancelled(true);
             return;
         }
@@ -316,11 +325,12 @@ public class WorldGuardPlayerListener extends AbstractListener {
     @EventHandler(priority = EventPriority.HIGHEST)
     public void onPlayerRespawn(PlayerRespawnEvent event) {
         Player player = event.getPlayer();
-        if (com.sk89q.worldguard.bukkit.util.Entities.isNPC(player)) return;
-        WorldConfiguration wcfg = getWorldConfig(player.getWorld());
+        LocalPlayer localPlayer = plugin.wrapPlayer(player);
+
+        ConfigurationManager cfg = WorldGuard.getInstance().getPlatform().getGlobalStateManager();
+        WorldConfiguration wcfg = cfg.get(localPlayer.getWorld());
 
         if (wcfg.useRegions) {
-            LocalPlayer localPlayer = getPlugin().wrapPlayer(player);
             ApplicableRegionSet set =
                     WorldGuard.getInstance().getPlatform().getRegionContainer().createQuery().getApplicableRegions(localPlayer.getLocation());
 
@@ -335,10 +345,12 @@ public class WorldGuardPlayerListener extends AbstractListener {
     @EventHandler(priority = EventPriority.HIGH)
     public void onItemHeldChange(PlayerItemHeldEvent event) {
         Player player = event.getPlayer();
-        WorldConfiguration wcfg = getWorldConfig(player.getWorld());
+
+        ConfigurationManager cfg = WorldGuard.getInstance().getPlatform().getGlobalStateManager();
+        WorldConfiguration wcfg = cfg.get(BukkitAdapter.adapt(player.getWorld()));
 
         if (wcfg.removeInfiniteStacks
-                && !getPlugin().hasPermission(player, "worldguard.override.infinite-stack")) {
+                && !plugin.hasPermission(player, "worldguard.override.infinite-stack")) {
             int newSlot = event.getNewSlot();
             ItemStack heldItem = player.getInventory().getItem(newSlot);
             if (heldItem != null && heldItem.getAmount() < 0) {
@@ -351,15 +363,15 @@ public class WorldGuardPlayerListener extends AbstractListener {
     @EventHandler(priority = EventPriority.LOW, ignoreCancelled = true)
     public void onPlayerTeleport(PlayerTeleportEvent event) {
         Player player = event.getPlayer();
-        if (com.sk89q.worldguard.bukkit.util.Entities.isNPC(player)) return;
-        LocalPlayer localPlayer = getPlugin().wrapPlayer(player);
-        ConfigurationManager cfg = getConfig();
-        WorldConfiguration wcfg = getWorldConfig(player.getWorld());
+        LocalPlayer localPlayer = plugin.wrapPlayer(player);
+        ConfigurationManager cfg = WorldGuard.getInstance().getPlatform().getGlobalStateManager();
+        WorldConfiguration wcfg = cfg.get(localPlayer.getWorld());
 
         if (wcfg.useRegions && cfg.usePlayerTeleports) {
-            RegionQuery query = WorldGuard.getInstance().getPlatform().getRegionContainer().createQuery();
-            ApplicableRegionSet set = query.getApplicableRegions(BukkitAdapter.adapt(event.getTo()));
-            ApplicableRegionSet setFrom = query.getApplicableRegions(BukkitAdapter.adapt(event.getFrom()));
+            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 (!WorldGuard.getInstance().getPlatform().getSessionManager().hasBypass(localPlayer, localPlayer.getWorld())) {
@@ -373,7 +385,7 @@ public class WorldGuardPlayerListener extends AbstractListener {
                         message = set.queryValue(localPlayer, Flags.ENTRY_DENY_MESSAGE);
                     }
                     if (cancel) {
-                        if (message != null && !message.isEmpty()) {
+                        if (message != null) {
                             player.sendMessage(message);
                         }
                         event.setCancelled(true);
@@ -392,7 +404,7 @@ public class WorldGuardPlayerListener extends AbstractListener {
                         message = set.queryValue(localPlayer, Flags.ENTRY_DENY_MESSAGE);
                     }
                     if (cancel) {
-                        if (message != null && !message.isEmpty()) {
+                        if (message != null) {
                             player.sendMessage(message);
                         }
                         event.setCancelled(true);
@@ -411,9 +423,9 @@ public class WorldGuardPlayerListener extends AbstractListener {
     @EventHandler(priority = EventPriority.LOWEST, ignoreCancelled = true)
     public void onPlayerCommandPreprocess(PlayerCommandPreprocessEvent event) {
         Player player = event.getPlayer();
-        LocalPlayer localPlayer = getPlugin().wrapPlayer(player);
-        ConfigurationManager cfg = getConfig();
-        WorldConfiguration wcfg = getWorldConfig(player.getWorld());
+        LocalPlayer localPlayer = plugin.wrapPlayer(player);
+        ConfigurationManager cfg = WorldGuard.getInstance().getPlatform().getGlobalStateManager();
+        WorldConfiguration wcfg = cfg.get(localPlayer.getWorld());
 
         if (wcfg.useRegions && !WorldGuard.getInstance().getPlatform().getSessionManager().hasBypass(localPlayer, localPlayer.getWorld())) {
             ApplicableRegionSet set =

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

@@ -19,28 +19,42 @@
 
 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;
 import org.bukkit.event.server.PluginDisableEvent;
 import org.bukkit.event.server.PluginEnableEvent;
+import org.bukkit.plugin.PluginManager;
 
-public class WorldGuardServerListener extends AbstractListener {
+/**
+ * @author zml2008
+ */
+public class WorldGuardServerListener implements Listener {
+
+    private final WorldGuardPlugin plugin;
 
     public WorldGuardServerListener(WorldGuardPlugin plugin) {
-        super(plugin);
+        this.plugin = plugin;
+    }
+
+    public void registerEvents() {
+        PluginManager pm = plugin.getServer().getPluginManager();
+        pm.registerEvents(this, plugin);
     }
 
     @EventHandler
     public void onPluginEnable(PluginEnableEvent event) {
         if (event.getPlugin().getDescription().getName().equalsIgnoreCase("CommandBook")) {
-            getConfig().updateCommandBookGodMode();
+            ((BukkitConfigurationManager) WorldGuard.getInstance().getPlatform().getGlobalStateManager()).updateCommandBookGodMode();
         }
     }
 
     @EventHandler
     public void onPluginDisable(PluginDisableEvent event) {
         if (event.getPlugin().getDescription().getName().equalsIgnoreCase("CommandBook")) {
-            getConfig().updateCommandBookGodMode();
+            ((BukkitConfigurationManager) WorldGuard.getInstance().getPlatform().getGlobalStateManager()).updateCommandBookGodMode();
         }
     }
 }

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

@@ -24,7 +24,7 @@ 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.Entities;
+import com.sk89q.worldguard.config.ConfigurationManager;
 import com.sk89q.worldguard.config.WorldConfiguration;
 import com.sk89q.worldguard.session.MoveType;
 import com.sk89q.worldguard.util.Locations;
@@ -32,16 +32,31 @@ import org.bukkit.World;
 import org.bukkit.entity.Player;
 import org.bukkit.entity.Vehicle;
 import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
 import org.bukkit.event.vehicle.VehicleMoveEvent;
 import org.bukkit.util.Vector;
 
 import java.util.List;
 import java.util.stream.Collectors;
 
-public class WorldGuardVehicleListener extends AbstractListener {
+public class WorldGuardVehicleListener implements Listener {
 
+    private WorldGuardPlugin plugin;
+
+    /**
+     * Construct the object;
+     *
+     * @param plugin
+     */
     public WorldGuardVehicleListener(WorldGuardPlugin plugin) {
-        super(plugin);
+        this.plugin = plugin;
+    }
+
+    /**
+     * Register events.
+     */
+    public void registerEvents() {
+        plugin.getServer().getPluginManager().registerEvents(this, plugin);
     }
 
     @EventHandler
@@ -54,14 +69,14 @@ public class WorldGuardVehicleListener extends AbstractListener {
             return;
         }
         World world = vehicle.getWorld();
-        WorldConfiguration wcfg = getWorldConfig(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(BukkitAdapter.adapt(event.getFrom()), BukkitAdapter.adapt(event.getTo()))) {
                 for (Player player : playerPassengers) {
-                    if (Entities.isNPC(player)) continue;
-                    LocalPlayer localPlayer = getPlugin().wrapPlayer(player);
+                    LocalPlayer localPlayer = plugin.wrapPlayer(player);
                     Location lastValid;
                     if ((lastValid = WorldGuard.getInstance().getPlatform().getSessionManager().get(localPlayer)
                             .testMoveTo(localPlayer, BukkitAdapter.adapt(event.getTo()), MoveType.RIDE)) != null) {

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

@@ -22,6 +22,7 @@ package com.sk89q.worldguard.bukkit.listener;
 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.protection.association.RegionAssociable;
 import com.sk89q.worldguard.protection.flags.Flags;
@@ -32,19 +33,35 @@ 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;
 import org.bukkit.event.weather.LightningStrikeEvent;
 import org.bukkit.event.weather.ThunderChangeEvent;
 import org.bukkit.event.weather.WeatherChangeEvent;
 
-public class WorldGuardWeatherListener extends AbstractListener {
+public class WorldGuardWeatherListener implements Listener {
 
+    /**
+     * Plugin.
+     */
+    private WorldGuardPlugin plugin;
+
+    /**
+     * Construct the object;
+     *
+     * @param plugin The plugin instance
+     */
     public WorldGuardWeatherListener(WorldGuardPlugin plugin) {
-        super(plugin);
+        this.plugin = plugin;
+    }
+
+    public void registerEvents() {
+        plugin.getServer().getPluginManager().registerEvents(this, plugin);
     }
 
     @EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
     public void onWeatherChange(WeatherChangeEvent event) {
-        WorldConfiguration wcfg = getWorldConfig(event.getWorld());
+        ConfigurationManager cfg = WorldGuard.getInstance().getPlatform().getGlobalStateManager();
+        WorldConfiguration wcfg = cfg.get(BukkitAdapter.adapt(event.getWorld()));
 
         if (event.toWeatherState()) {
             if (wcfg.disableWeather) {
@@ -59,7 +76,8 @@ public class WorldGuardWeatherListener extends AbstractListener {
 
     @EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
     public void onThunderChange(ThunderChangeEvent event) {
-        WorldConfiguration wcfg = getWorldConfig(event.getWorld());
+        ConfigurationManager cfg = WorldGuard.getInstance().getPlatform().getGlobalStateManager();
+        WorldConfiguration wcfg = cfg.get(BukkitAdapter.adapt(event.getWorld()));
 
         if (event.toThunderState()) {
             if (wcfg.disableThunder) {
@@ -74,7 +92,8 @@ public class WorldGuardWeatherListener extends AbstractListener {
 
     @EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
     public void onLightningStrike(LightningStrikeEvent event) {
-        WorldConfiguration wcfg = getWorldConfig(event.getWorld());
+        ConfigurationManager cfg = WorldGuard.getInstance().getPlatform().getGlobalStateManager();
+        WorldConfiguration wcfg = cfg.get(BukkitAdapter.adapt(event.getWorld()));
 
         if (!wcfg.disallowedLightningBlocks.isEmpty()) {
             final Block target = event.getLightning().getLocation().getBlock();

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

@@ -34,17 +34,30 @@ import org.bukkit.event.world.WorldLoadEvent;
 
 import java.util.logging.Logger;
 
-public class WorldGuardWorldListener extends AbstractListener {
+public class WorldGuardWorldListener implements Listener {
 
     private static final Logger log = Logger.getLogger(WorldGuardWorldListener.class.getCanonicalName());
+    private WorldGuardPlugin plugin;
 
+    /**
+     * Construct the object;
+     *
+     * @param plugin The plugin instance
+     */
     public WorldGuardWorldListener(WorldGuardPlugin plugin) {
-        super(plugin);
+        this.plugin = plugin;
+    }
+
+    /**
+     * Register events.
+     */
+    public void registerEvents() {
+        plugin.getServer().getPluginManager().registerEvents(this, plugin);
     }
 
     @EventHandler
     public void onChunkLoad(ChunkLoadEvent event) {
-        ConfigurationManager cfg = getConfig();
+        ConfigurationManager cfg = WorldGuard.getInstance().getPlatform().getGlobalStateManager();
 
         if (cfg.activityHaltToggle) {
             int removed = 0;
@@ -76,7 +89,8 @@ public class WorldGuardWorldListener extends AbstractListener {
      * @param world The specified world
      */
     public void initWorld(World world) {
-        WorldConfiguration wcfg = getWorldConfig(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,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.entity.SpawnEntityEvent;
 import com.sk89q.worldguard.config.WorldConfiguration;
@@ -41,7 +42,7 @@ public class WorldRulesListener extends AbstractListener {
     @EventHandler(priority = EventPriority.LOWEST, ignoreCancelled = true)
     public void onSpawnEntity(final SpawnEntityEvent event) {
         if (event.getEffectiveType() == EntityType.EXPERIENCE_ORB) {
-            WorldConfiguration config = getWorldConfig(event.getWorld());
+            WorldConfiguration config = getWorldConfig(BukkitAdapter.adapt(event.getWorld()));
 
             if (config.disableExpDrops) {
                 event.setCancelled(true);
@@ -52,7 +53,7 @@ public class WorldRulesListener extends AbstractListener {
     @EventHandler(priority = EventPriority.LOWEST, ignoreCancelled = true)
     public void onPotionEffect(EntityPotionEffectEvent event) {
         if (event.getCause() == EntityPotionEffectEvent.Cause.CONDUIT) {
-            WorldConfiguration config = getWorldConfig(event.getEntity().getWorld());
+            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/legacy/InventoryMoveItemEventDebounce.java

@@ -20,7 +20,6 @@
 package com.sk89q.worldguard.bukkit.listener.debounce.legacy;
 
 import com.sk89q.worldguard.bukkit.listener.debounce.legacy.InventoryMoveItemEventDebounce.Key;
-import io.papermc.lib.PaperLib;
 import org.bukkit.Material;
 import org.bukkit.block.Block;
 import org.bukkit.block.BlockState;
@@ -45,18 +44,18 @@ public class InventoryMoveItemEventDebounce extends AbstractEventDebounce<Key> {
         private final Object target;
 
         public Key(InventoryMoveItemEvent event) {
-            cause = transform(PaperLib.getHolder(event.getInitiator(), false).getHolder());
-            source = transform(PaperLib.getHolder(event.getSource(), false).getHolder());
-            target = transform(PaperLib.getHolder(event.getDestination(), false).getHolder());
+            cause = transform(event.getInitiator().getHolder());
+            source = transform(event.getSource().getHolder());
+            target = transform(event.getDestination().getHolder());
         }
 
         private Object transform(InventoryHolder holder) {
-            if (holder instanceof BlockState blockState) {
-                return new BlockMaterialKey(blockState);
-            } else if (holder instanceof DoubleChest doubleChest) {
-                InventoryHolder left = PaperLib.isPaper() ? doubleChest.getLeftSide(false) : doubleChest.getLeftSide();
-                if (left instanceof Chest chest) {
-                    return new BlockMaterialKey(chest);
+            if (holder instanceof BlockState) {
+                return new BlockMaterialKey(((BlockState) holder).getBlock());
+            } else if (holder instanceof DoubleChest) {
+                InventoryHolder left = ((DoubleChest) holder).getLeftSide();
+                if (left instanceof Chest) {
+                    return new BlockMaterialKey(((Chest) left).getBlock());
                 } else {
                     return holder;
                 }
@@ -95,8 +94,8 @@ public class InventoryMoveItemEventDebounce extends AbstractEventDebounce<Key> {
         private final Block block;
         private final Material material;
 
-        private BlockMaterialKey(BlockState block) {
-            this.block = block.getBlock();
+        private BlockMaterialKey(Block block) {
+            this.block = block;
             material = block.getType();
         }
 

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

@@ -25,9 +25,9 @@ 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.bukkit.util.Entities;
 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;
@@ -62,6 +62,8 @@ public class BukkitSessionManager extends AbstractSessionManager implements Runn
         // 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
@@ -74,22 +76,11 @@ public class BukkitSessionManager extends AbstractSessionManager implements Runn
 
     @Override
     public boolean hasBypass(LocalPlayer player, World world) {
-        if (player instanceof BukkitPlayer bukkitPlayer) {
-            if (Entities.isNPC(bukkitPlayer.getPlayer())
-                    && WorldGuard.getInstance().getPlatform().getGlobalStateManager().get(world).fakePlayerBuildOverride) {
+        if (player instanceof BukkitPlayer) {
+            if (((BukkitPlayer) player).getPlayer().hasMetadata("NPC")
+                    && WorldGuard.getInstance().getPlatform().getGlobalStateManager().get(world).fakePlayerBuildOverride)
                 return true;
-            }
-            if (!((BukkitPlayer) player).getPlayer().isOnline()) {
-                return false;
-            }
         }
         return super.hasBypass(player, world);
     }
-
-    public void shutdown() {
-        for (Player player : Bukkit.getServer().getOnlinePlayers()) {
-            LocalPlayer localPlayer = WorldGuardPlugin.inst().wrapPlayer(player);
-            get(localPlayer).uninitialize(localPlayer);
-        }
-    }
 }

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

@@ -1,167 +0,0 @@
-/*
- * WorldGuard, a suite of tools for Minecraft
- * Copyright (C) sk89q <http://www.sk89q.com>
- * Copyright (C) WorldGuard team and contributors
- *
- * This program is free software: you can redistribute it and/or modify it
- * under the terms of the GNU Lesser General Public License as published by the
- * Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License
- * for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-package com.sk89q.worldguard.bukkit.util;
-
-import com.google.common.base.Strings;
-import com.google.common.collect.ImmutableMap;
-import org.bukkit.Bukkit;
-import org.bukkit.plugin.Plugin;
-import org.bukkit.plugin.java.PluginClassLoader;
-
-import javax.annotation.Nullable;
-import java.lang.reflect.InvocationTargetException;
-import java.lang.reflect.Method;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Locale;
-import java.util.Map;
-
-import static com.google.common.base.Preconditions.checkNotNull;
-
-/**
- * Validates that certain specified classes came from the same source as
- * a plugin.
- * This is copied from the same class in WorldEdit because unfortunately
- * trying to use WorldEdit's means we're susceptible to getting a bad version
- * of this class if another plugin shades it....which is exactly what we're
- * trying to detect and report.
- */
-public class ClassSourceValidator {
-
-    private static final String SEPARATOR_LINE = Strings.repeat("*", 46);
-    private static final Method loadClass;
-    private static Class<?> pluginClassLoaderClass;
-
-    static {
-        Method tmp;
-        try {
-            pluginClassLoaderClass = Class.forName("org.bukkit.plugin.java.PluginClassLoader", false,
-                    Bukkit.class.getClassLoader());
-            tmp = pluginClassLoaderClass.getDeclaredMethod("loadClass0",
-                    String.class, boolean.class, boolean.class, boolean.class);
-            tmp.setAccessible(true);
-        } catch (NoSuchMethodException | ClassNotFoundException e) {
-            tmp = null;
-        }
-        loadClass = tmp;
-    }
-
-    private final Plugin plugin;
-    @Nullable
-    private final ClassLoader expectedClassLoader;
-
-    /**
-     * Create a new instance.
-     *
-     * @param plugin The plugin
-     */
-    public ClassSourceValidator(Plugin plugin) {
-        checkNotNull(plugin, "plugin");
-        this.plugin = plugin;
-        this.expectedClassLoader = plugin.getClass().getClassLoader();
-    }
-
-    /**
-     * Return a map of classes that been loaded from a different source.
-     *
-     * @param classes A list of classes to check
-     * @return The results
-     */
-    public Map<Class<?>, Plugin> findMismatches(List<Class<?>> classes) {
-        checkNotNull(classes, "classes");
-
-        if (expectedClassLoader == null || loadClass == null) {
-            return ImmutableMap.of();
-        }
-
-        Map<Class<?>, Plugin> mismatches = new HashMap<>();
-
-        for (Plugin target : Bukkit.getPluginManager().getPlugins()) {
-            if (target == plugin) {
-                continue;
-            }
-            ClassLoader targetLoader = target.getClass().getClassLoader();
-            if (!(pluginClassLoaderClass.isAssignableFrom(targetLoader.getClass()))) {
-                continue;
-            }
-            for (Class<?> testClass : classes) {
-                Class<?> targetClass;
-                try {
-                    targetClass = (Class<?>) loadClass.invoke(targetLoader, testClass.getName(), false, false, false);
-                } catch (IllegalAccessException | InvocationTargetException ignored) {
-                    continue;
-                }
-                if (targetClass.getClassLoader() != expectedClassLoader) {
-                    mismatches.putIfAbsent(testClass, targetClass.getClassLoader() == targetLoader ? target : null);
-                }
-            }
-        }
-
-        return mismatches;
-    }
-
-    /**
-     * Reports classes that have come from a different source.
-     *
-     * <p>The warning is emitted to the log.</p>
-     *
-     * @param classes The list of classes to check
-     */
-    public void reportMismatches(List<Class<?>> classes) {
-        if (Boolean.getBoolean("enginehub.disable.class.source.validation")) {
-            return;
-        }
-        Map<Class<?>, Plugin> mismatches = findMismatches(classes);
-
-        if (mismatches.isEmpty()) {
-            return;
-        }
-        StringBuilder builder = new StringBuilder("\n");
-
-        builder.append(SEPARATOR_LINE).append("\n");
-        builder.append("** /!\\    SEVERE WARNING    /!\\\n");
-        builder.append("** \n");
-        builder.append("** A plugin developer has included a portion of \n");
-        builder.append("** ").append(plugin.getName()).append(" into their own plugin, so rather than using\n");
-        builder.append("** the version of ").append(plugin.getName()).append(" that you downloaded, you\n");
-        builder.append("** will be using a broken mix of old ").append(plugin.getName()).append(" (that came\n");
-        builder.append("** with the plugin) and your downloaded version. THIS MAY\n");
-        builder.append("** SEVERELY BREAK ").append(plugin.getName().toUpperCase(Locale.ROOT)).append(" AND ALL OF ITS FEATURES.\n");
-        builder.append("**\n");
-        builder.append("** This may have happened because the developer is using\n");
-        builder.append("** the ").append(plugin.getName()).append(" API and thinks that including\n");
-        builder.append("** ").append(plugin.getName()).append(" is necessary. However, it is not!\n");
-        builder.append("**\n");
-        builder.append("** Here are some files that have been overridden:\n");
-        builder.append("** \n");
-        for (Map.Entry<Class<?>, Plugin> entry : mismatches.entrySet()) {
-            Plugin badPlugin = entry.getValue();
-            String url = badPlugin == null
-                    ? "(unknown)"
-                    : badPlugin.getName() + " (" + badPlugin.getClass().getProtectionDomain().getCodeSource().getLocation() + ")";
-            builder.append("** '").append(entry.getKey().getSimpleName()).append("' came from '").append(url).append("'\n");
-        }
-        builder.append("**\n");
-        builder.append("** Please report this to the plugins' developers.\n");
-        builder.append(SEPARATOR_LINE).append("\n");
-
-        plugin.getLogger().severe(builder.toString());
-    }
-}

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

@@ -19,7 +19,6 @@
 
 package com.sk89q.worldguard.bukkit.util;
 
-import org.bukkit.entity.Allay;
 import org.bukkit.entity.Ambient;
 import org.bukkit.entity.ArmorStand;
 import org.bukkit.entity.Arrow;
@@ -34,17 +33,16 @@ import org.bukkit.entity.LivingEntity;
 import org.bukkit.entity.Minecart;
 import org.bukkit.entity.Monster;
 import org.bukkit.entity.NPC;
+import org.bukkit.entity.Pig;
 import org.bukkit.entity.Player;
 import org.bukkit.entity.Projectile;
 import org.bukkit.entity.Shulker;
 import org.bukkit.entity.Slime;
 import org.bukkit.entity.SpectralArrow;
-import org.bukkit.entity.Steerable;
 import org.bukkit.entity.TNTPrimed;
 import org.bukkit.entity.Tameable;
 import org.bukkit.entity.Vehicle;
 import org.bukkit.entity.minecart.ExplosiveMinecart;
-import org.bukkit.event.entity.CreatureSpawnEvent;
 import org.bukkit.inventory.InventoryHolder;
 import org.bukkit.projectiles.ProjectileSource;
 
@@ -93,7 +91,7 @@ public final class Entities {
      * @return true if the entity can be ridden
      */
     public static boolean isRiddenOnUse(Entity entity) {
-        return entity instanceof Steerable ? ((Steerable) entity).hasSaddle() : entity instanceof Vehicle;
+        return entity instanceof Pig ? ((Pig) entity).hasSaddle() : entity instanceof Vehicle;
     }
 
     /**
@@ -103,20 +101,8 @@ public final class Entities {
      * @return true if the type is a vehicle type
      */
     public static boolean isVehicle(EntityType type) {
-        return isBoat(type) || isMinecart(type);
-    }
-
-    /**
-     * Test whether the given entity type is a Boat type.
-     *
-     * @param type the type
-     * @return true if the type is a Boat type
-     */
-    public static boolean isBoat(EntityType type) {
-        return switch(type) {
-            case BOAT, CHEST_BOAT -> true;
-            default -> false;
-        };
+        return type == EntityType.BOAT
+                || isMinecart(type);
     }
 
     /**
@@ -126,11 +112,13 @@ public final class Entities {
      * @return true if the type is a Minecart type
      */
     public static boolean isMinecart(EntityType type) {
-        return switch(type) {
-            case MINECART, CHEST_MINECART, COMMAND_BLOCK_MINECART, FURNACE_MINECART,
-                 HOPPER_MINECART, SPAWNER_MINECART, TNT_MINECART -> true;
-            default -> false;
-        };
+        return type == EntityType.MINECART
+                || type == EntityType.MINECART_CHEST
+                || type == EntityType.MINECART_COMMAND
+                || type == EntityType.MINECART_FURNACE
+                || type == EntityType.MINECART_HOPPER
+                || type == EntityType.MINECART_MOB_SPAWNER
+                || type == EntityType.MINECART_TNT;
     }
 
     /**
@@ -220,7 +208,6 @@ public final class Entities {
         return entity instanceof Hanging
                 || entity instanceof ArmorStand
                 || entity instanceof EnderCrystal
-                || entity instanceof Allay
                 || entity instanceof Minecart && entity instanceof InventoryHolder;
     }
 
@@ -231,18 +218,4 @@ public final class Entities {
     public static boolean isAoECloud(EntityType type) {
         return type == EntityType.AREA_EFFECT_CLOUD;
     }
-
-    /**
-     * Check whether the spawn reason should be considered as a "plugin spawning".
-     * This is true for custom creations or the summon command.
-     *
-     * @param spawnReason the reason
-     * @return true if considerd plugin spawning
-     */
-    public static boolean isPluginSpawning(CreatureSpawnEvent.SpawnReason spawnReason) {
-        return switch (spawnReason) {
-            case CUSTOM, COMMAND -> true;
-            default -> false;
-        };
-    }
 }

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

@@ -70,7 +70,7 @@ public final class InteropUtils {
         UUID uuid = player.getUniqueId();
         String name = player.getName();
 
-        if (Entities.isNPC(player)) {
+        if (player.hasMetadata("NPC")) {
             return true;
         }
 

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

@@ -0,0 +1,127 @@
+/*
+ * WorldGuard, a suite of tools for Minecraft
+ * Copyright (C) sk89q <http://www.sk89q.com>
+ * Copyright (C) WorldGuard team and contributors
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published by the
+ * Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License
+ * for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package com.sk89q.worldguard.bukkit.util.logging;
+
+import com.google.common.base.Strings;
+import com.google.common.collect.Maps;
+import org.bukkit.plugin.Plugin;
+
+import javax.annotation.Nullable;
+import java.security.CodeSource;
+import java.util.List;
+import java.util.Map;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+
+/**
+ * Validates that certain specified classes came from the same source as
+ * a plugin.
+ */
+public class ClassSourceValidator {
+
+    private static final Logger log = Logger.getLogger(ClassSourceValidator.class.getCanonicalName());
+    private static final String separatorLine = Strings.repeat("*", 46);
+
+    private final Plugin plugin;
+    @Nullable
+    private final CodeSource expectedCodeSource;
+
+    /**
+     * Create a new instance.
+     *
+     * @param plugin The plugin
+     */
+    public ClassSourceValidator(Plugin plugin) {
+        checkNotNull(plugin, "plugin");
+        this.plugin = plugin;
+        this.expectedCodeSource = plugin.getClass().getProtectionDomain().getCodeSource();
+    }
+
+    /**
+     * Return a map of classes that been loaded from a different source.
+     *
+     * @param classes A list of classes to check
+     * @return The results
+     */
+    public Map<Class<?>, CodeSource> findMismatches(List<Class<?>> classes) {
+        checkNotNull(classes, "classes");
+
+        Map<Class<?>, CodeSource> mismatches = Maps.newHashMap();
+
+        if (expectedCodeSource != null) {
+            for (Class<?> testClass : classes) {
+                CodeSource testSource = testClass.getProtectionDomain().getCodeSource();
+                if (!expectedCodeSource.equals(testSource)) {
+                    mismatches.put(testClass, testSource);
+                }
+            }
+        }
+
+        return mismatches;
+    }
+
+    /**
+     * Reports classes that have come from a different source.
+     *
+     * <p>The warning is emitted to the log.</p>
+     *
+     * @param classes The list of classes to check
+     */
+    public void reportMismatches(List<Class<?>> classes) {
+        if (Boolean.getBoolean("worldguard.disable.class.validation")) {
+            return;
+        }
+        Map<Class<?>, CodeSource> mismatches = findMismatches(classes);
+
+        if (!mismatches.isEmpty()) {
+            StringBuilder builder = new StringBuilder("\n");
+
+            builder.append(separatorLine).append("\n");
+            builder.append("** /!\\    SEVERE WARNING    /!\\\n");
+            builder.append("** \n");
+            builder.append("** A plugin developer has copied and pasted a portion of \n");
+            builder.append("** ").append(plugin.getName()).append(" into their own plugin, so rather than using\n");
+            builder.append("** the version of ").append(plugin.getName()).append(" that you downloaded, you\n");
+            builder.append("** will be using a broken mix of old ").append(plugin.getName()).append(" (that came\n");
+            builder.append("** with the plugin) and your downloaded version. THIS MAY\n");
+            builder.append("** SEVERELY BREAK ").append(plugin.getName().toUpperCase()).append(" AND ALL OF ITS FEATURES.\n");
+            builder.append("**\n");
+            builder.append("** This may have happened because the developer is using\n");
+            builder.append("** the ").append(plugin.getName()).append(" API and thinks that including\n");
+            builder.append("** ").append(plugin.getName()).append(" is necessary. However, it is not!\n");
+            builder.append("**\n");
+            builder.append("** Here are some files that have been overridden:\n");
+            builder.append("** \n");
+            for (Map.Entry<Class<?>, CodeSource> entry : mismatches.entrySet()) {
+                CodeSource codeSource = entry.getValue();
+                String url = codeSource != null ? codeSource.getLocation().toExternalForm() : "(unknown)";
+                builder.append("** '").append(entry.getKey().getSimpleName()).append("' came from '").append(url).append("'\n");
+            }
+            builder.append("**\n");
+            builder.append("** Please report this to the plugins' developers.\n");
+            builder.append(separatorLine).append("\n");
+
+            log.log(Level.SEVERE, builder.toString());
+        }
+    }
+
+}

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

@@ -1,48 +0,0 @@
-/*
- * WorldGuard, a suite of tools for Minecraft
- * Copyright (C) sk89q <http://www.sk89q.com>
- * Copyright (C) WorldGuard team and contributors
- *
- * This program is free software: you can redistribute it and/or modify it
- * under the terms of the GNU Lesser General Public License as published by the
- * Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License
- * for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-package com.sk89q.worldguard.bukkit.util.report;
-
-import com.sk89q.worldedit.util.report.DataReport;
-import io.papermc.paper.datapack.Datapack;
-import org.bukkit.Bukkit;
-
-import java.util.Collection;
-
-/**
- * A report for current datapacks with some information. Only available on Paper
- */
-public class DatapackReport extends DataReport {
-    public DatapackReport() {
-        super("DataPacks");
-
-        Collection<Datapack> packs = Bukkit.getDatapackManager().getPacks();
-
-        append("Datapack Count", packs.size());
-        append("Datapack Enabled Count", Bukkit.getDatapackManager().getEnabledPacks().size());
-
-        for (Datapack pack : packs) {
-            DataReport report = new DataReport("DataPack: " + pack.getName());
-            report.append("Enabled?", pack.isEnabled());
-            report.append("Name", pack.getName());
-            report.append("Compatibility", pack.getCompatibility().name());
-            append(report.getTitle(), report);
-        }
-    }
-}

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

@@ -20,7 +20,6 @@
 package com.sk89q.worldguard.bukkit.util.report;
 
 import com.sk89q.worldedit.util.report.DataReport;
-import io.papermc.lib.PaperLib;
 import org.bukkit.Bukkit;
 import org.bukkit.Server;
 
@@ -34,17 +33,8 @@ public class ServerReport extends DataReport {
         append("Bukkit Version", server.getBukkitVersion());
         append("Implementation", server.getName() + " " + server.getVersion());
         append("Player Count", "%d/%d", Bukkit.getOnlinePlayers().size(), server.getMaxPlayers());
-        append("Server Class Source", server.getClass().getProtectionDomain().getCodeSource().getLocation());
 
-        DataReport onlineMode = new DataReport("Online Mode");
-        onlineMode.append("enabled?", server.getOnlineMode());
-        if (PaperLib.isSpigot()) {
-            onlineMode.append("BungeeCord support?", Bukkit.spigot().getConfig().getBoolean("settings.bungeecord", false));
-        }
-        if (PaperLib.isPaper()) {
-            onlineMode.append("Velocity support?", Bukkit.spigot().getPaperConfig().getBoolean("proxies.velocity.enabled", false));
-        }
-        append(onlineMode.getTitle(), onlineMode);
+        append("Server Class Source", server.getClass().getProtectionDomain().getCodeSource().getLocation());
 
         DataReport spawning = new DataReport("Spawning");
         spawning.append("Ambient Spawn Limit", server.getAmbientSpawnLimit());

worldguard-bukkit/src/main/java/com/sk89q/worldguard/util/profile/resolver/PaperProfileService.java

@@ -19,19 +19,14 @@
 
 package com.sk89q.worldguard.util.profile.resolver;
 
+import com.destroystokyo.paper.profile.PlayerProfile;
 import com.sk89q.worldguard.util.profile.Profile;
 import io.papermc.lib.PaperLib;
+import org.bukkit.Bukkit;
 
 import javax.annotation.Nullable;
-import java.io.IOException;
-import java.util.UUID;
 
-/**
- * @deprecated Use {@link com.sk89q.worldguard.util.profile.resolver.PaperPlayerService} instead
- */
-@Deprecated(forRemoval = true)
 public final class PaperProfileService extends SingleRequestService {
-    private static final PaperPlayerService SUPER = PaperPlayerService.getInstance();
     private static final PaperProfileService INSTANCE = new PaperProfileService();
 
     private PaperProfileService() {
@@ -42,19 +37,18 @@ public final class PaperProfileService extends SingleRequestService {
 
     @Override
     public int getIdealRequestLimit() {
-        return SUPER.getIdealRequestLimit();
+        return Integer.MAX_VALUE;
     }
 
     @Override
     @Nullable
-    public Profile findByName(String name) throws IOException, InterruptedException {
-        return SUPER.findByName(name);
-    }
-
-    @Nullable
-    @Override
-    public Profile findByUuid(UUID uuid) throws IOException, InterruptedException {
-        return SUPER.findByUuid(uuid);
+    public Profile findByName(String name) {
+        PlayerProfile profile = Bukkit.createProfile(name);
+        if (profile.completeFromCache()) {
+            //noinspection ConstantConditions - completeFromCache guarantees non-null on success
+            return new Profile(profile.getId(), profile.getName());
+        }
+        return null;
     }
 
     public static PaperProfileService getInstance() {

worldguard-bukkit/src/main/resources/plugin.yml

@@ -3,4 +3,4 @@ main: com.sk89q.worldguard.bukkit.WorldGuardPlugin
 version: "${internalVersion}"
 depend: [WorldEdit]
 softdepend: [CommandBook]
-api-version: "1.20"
+api-version: 1.13

worldguard-core/build.gradle.kts

@@ -1,20 +1,31 @@
 plugins {
-    `java-library`
+    id("java-library")
+    id("net.ltgt.apt-eclipse")
+    id("net.ltgt.apt-idea")
 }
 
 applyPlatformAndCoreConfiguration()
 
 dependencies {
-    "api"(project(":worldguard-libs:core"))
-    "api"("com.sk89q.worldedit:worldedit-core:${Versions.WORLDEDIT}")
+    "compile"(project(":worldguard-libs:core"))
+    "compile"("com.sk89q.worldedit:worldedit-core:${Versions.WORLDEDIT}")
     "implementation"("org.flywaydb:flyway-core:3.0")
-    "implementation"("org.yaml:snakeyaml:2.0")
-    "implementation"("com.google.guava:guava:${Versions.GUAVA}")
 
-    "compileOnly"("com.google.code.findbugs:jsr305:${Versions.FINDBUGS}")
-    "testImplementation"("org.hamcrest:hamcrest-library:2.2")
+    "compileOnly"("com.google.code.findbugs:jsr305:1.3.9")
+    "testImplementation"("org.hamcrest:hamcrest-library:1.2.1")
 }
 
 tasks.withType<JavaCompile>().configureEach {
     dependsOn(":worldguard-libs:build")
+}
+
+sourceSets {
+    main {
+        java {
+            srcDir("src/main/java")
+        }
+        resources {
+            srcDir("src/main/resources")
+        }
+    }
 }

worldguard-core/src/main/java/com/sk89q/worldguard/WorldGuard.java

@@ -93,12 +93,11 @@ public final class WorldGuard {
 
     /**
      * The WorldGuard Platform.
-     * The Platform is only available after WorldGuard is enabled.
      *
      * @return The platform
      */
     public WorldGuardPlatform getPlatform() {
-        checkNotNull(platform, "WorldGuard is not enabled, unable to access the platform.");
+        checkNotNull(platform);
         return platform;
     }
 

worldguard-core/src/main/java/com/sk89q/worldguard/blacklist/logger/DatabaseHandler.java

@@ -95,9 +95,9 @@ public class DatabaseHandler implements LoggerHandler {
             stmt.setString(1, eventType.name());
             stmt.setString(2, worldName);
             stmt.setString(3, player != null ? player.getName() : "");
-            stmt.setInt(4, pos.x());
-            stmt.setInt(5, pos.y());
-            stmt.setInt(6, pos.z());
+            stmt.setInt(4, pos.getBlockX());
+            stmt.setInt(5, pos.getBlockY());
+            stmt.setInt(6, pos.getBlockZ());
             stmt.setString(7, item);
             stmt.setInt(8, (int)(System.currentTimeMillis() / 1000));
             stmt.setString(9, comment);

worldguard-core/src/main/java/com/sk89q/worldguard/blacklist/logger/FileHandler.java

@@ -24,7 +24,6 @@ import com.sk89q.worldguard.LocalPlayer;
 import com.sk89q.worldguard.blacklist.event.BlacklistEvent;
 import com.sk89q.worldguard.blacklist.target.Target;
 
-import javax.annotation.Nullable;
 import java.io.BufferedWriter;
 import java.io.File;
 import java.io.FileWriter;
@@ -88,13 +87,13 @@ public class FileHandler implements LoggerHandler {
      * Build the path.
      *
      * @param playerName The name of the player
-     * @return The path for the logfile, null when no applicable path could be found
+     * @return The path for the logfile
      */
-    private @Nullable String buildPath(@Nullable String playerName) {
+    private String buildPath(String playerName) {
         GregorianCalendar calendar = new GregorianCalendar();
 
         Matcher m = pattern.matcher(pathPattern);
-        StringBuilder buffer = new StringBuilder();
+        StringBuffer buffer = new StringBuffer();
 
         // Pattern replacements
         while (m.find()) {
@@ -104,13 +103,12 @@ public class FileHandler implements LoggerHandler {
             if (group.matches("%%")) {
                 rep = "%";
             } else if (group.matches("%u")) {
-                if (playerName == null) return null; // Unable to create a path for non player logging events
                 rep = playerName.toLowerCase().replaceAll("[^A-Za-z0-9_]", "_");
                 if (rep.length() > 32) { // Actual max length is 16
                     rep = rep.substring(0, 32);
                 }
 
-            } else if (group.matches("%w")) {
+            }else if (group.matches("%w")) {
                 rep = worldName.toLowerCase().replaceAll("[^A-Za-z0-9_]", "_");
                 if (rep.length() > 32) { // Actual max length is 16
                     rep = rep.substring(0, 32);
@@ -150,12 +148,11 @@ public class FileHandler implements LoggerHandler {
      * @param message The message to log
      * @param comment The comment associated with the logged event
      */
-    private void log(@Nullable LocalPlayer player, String message, String comment) {
-        String path = buildPath(player != null ? player.getName() : null);
-        if (path == null) return;
+    private void log(LocalPlayer player, String message, String comment) {
+        String path = buildPath(player.getName());
         try {
             String date = dateFormat.format(new Date());
-            String line = "[" + date + "] " + (player != null ? player.getName() : "Unknown Source") + ": " + message
+            String line = "[" + date + "] " + player.getName() + ": " + message
                     + (comment != null ? " (" + comment + ")" : "") + "\r\n";
 
             LogFileWriter writer = writers.get(path);
@@ -193,7 +190,7 @@ public class FileHandler implements LoggerHandler {
                         writers.entrySet().iterator();
 
                 // Remove some entries
-                while (it.hasNext()) {
+                for (; it.hasNext(); ) {
                     Map.Entry<String,LogFileWriter> entry = it.next();
                     try {
                         entry.getValue().getWriter().close();
@@ -221,7 +218,7 @@ public class FileHandler implements LoggerHandler {
      * @return The position's coordinates in human-readable form
      */
     private String getCoordinates(BlockVector3 pos) {
-        return "@" + pos.x() + "," + pos.y() + "," + pos.z();
+        return "@" + pos.getBlockX() + "," + pos.getBlockY() + "," + pos.getBlockZ();
     }
 
     private void logEvent(BlacklistEvent event, String text, Target target, BlockVector3 pos, String comment) {

worldguard-core/src/main/java/com/sk89q/worldguard/commands/WorldGuardCommands.java

@@ -226,7 +226,7 @@ public class WorldGuardCommands {
             }
         }, MoreExecutors.directExecutor());
 
-        Futures.addCallback(sampler.getFuture(), new FutureCallback<>() {
+        Futures.addCallback(sampler.getFuture(), new FutureCallback<Sampler>() {
             @Override
             public void onSuccess(Sampler result) {
                 String output = result.toString();
@@ -247,7 +247,7 @@ public class WorldGuardCommands {
             @Override
             public void onFailure(Throwable throwable) {
             }
-        }, MoreExecutors.directExecutor());
+        });
     }
 
     @Command(aliases = {"stopprofile"}, usage = "",desc = "Stop a running profile", min = 0, max = 0)

worldguard-core/src/main/java/com/sk89q/worldguard/commands/region/FlagHelperBox.java

@@ -46,7 +46,6 @@ import com.sk89q.worldguard.protection.flags.RegistryFlag;
 import com.sk89q.worldguard.protection.flags.SetFlag;
 import com.sk89q.worldguard.protection.flags.StateFlag;
 import com.sk89q.worldguard.protection.flags.StringFlag;
-import com.sk89q.worldguard.protection.flags.registry.UnknownFlag;
 import com.sk89q.worldguard.protection.regions.ProtectedRegion;
 
 import javax.annotation.Nullable;
@@ -76,7 +75,7 @@ class FlagHelperBox extends PaginationBox {
             .collect(Collectors.toList());
     private static final int SIZE = FLAGS.size() == Flags.INBUILT_FLAGS.size() ? FLAGS.size() : FLAGS.size() + 1;
     private static final int PAD_PX_SIZE = 180;
-    static final Set<Flag<?>> DANGER_ZONE = ImmutableSet.of(Flags.BUILD, Flags.PASSTHROUGH, Flags.BLOCK_PLACE, Flags.BLOCK_BREAK);
+    private static final Set<Flag<?>> DANGER_ZONE = ImmutableSet.of(Flags.BUILD, Flags.PASSTHROUGH, Flags.BLOCK_PLACE, Flags.BLOCK_BREAK);
 
     private final World world;
     private final ProtectedRegion region;
@@ -109,7 +108,7 @@ class FlagHelperBox extends PaginationBox {
     private Component createLine(Flag<?> flag, boolean thirdParty) {
         final TextComponent.Builder builder = TextComponent.builder("");
 
-        appendFlagName(builder, flag, flag instanceof UnknownFlag ? TextColor.GRAY : thirdParty ? TextColor.LIGHT_PURPLE : TextColor.GOLD);
+        appendFlagName(builder, flag, thirdParty ? TextColor.LIGHT_PURPLE : TextColor.GOLD);
         appendFlagValue(builder, flag);
         return builder.build();
     }
@@ -200,7 +199,7 @@ class FlagHelperBox extends PaginationBox {
             if (maySet) {
                 if (isExplicitSet) {
                     hoverTexts.add(TextComponent.of("Click to unset", TextColor.GOLD));
-                } else if (DANGER_ZONE.contains(flag) && !(ProtectedRegion.GLOBAL_REGION.equals(region.getId()) && flag == Flags.PASSTHROUGH)) {
+                } else if (DANGER_ZONE.contains(flag)) {
                     hoverTexts.add(TextComponent.of("Setting this flag may have unintended consequences.", TextColor.RED)
                             .append(TextComponent.newline())
                             .append(TextComponent.of("Please read the documentation and set this flag manually if you really intend to.")
@@ -256,7 +255,7 @@ class FlagHelperBox extends PaginationBox {
 
         boolean isExplicitSet = currVal != null && !inherited;
 
-        boolean maySet = !(flag instanceof UnknownFlag) && perms.maySetFlag(region, flag);
+        boolean maySet = perms.maySetFlag(region, flag);
 
         TextColor col = isExplicitSet ? TextColor.WHITE : inherited ? TextColor.GRAY : TextColor.DARK_GRAY;
         Set<TextDecoration> styles = currVal == defVal ? ImmutableSet.of(TextDecoration.UNDERLINED) : Collections.emptySet();
@@ -360,9 +359,11 @@ class FlagHelperBox extends PaginationBox {
         if (currVal == null) {
             currVal = getInheritedValue(region, flag);
         }
+        @SuppressWarnings("unchecked")
+        List<V> values = currVal == null ? Collections.emptyList() : (List<V>) flag.marshal(currVal);
         String display = (currVal == null ? "" : currVal.size() + "x ") + subName;
         final String stringValue = currVal == null ? ""
-                : currVal.stream().map(String::valueOf).collect(Collectors.joining(","));
+                : values.stream().map(String::valueOf).collect(Collectors.joining(","));
         TextComponent hoverComp = TextComponent.of("");
         if (currVal != null) {
             hoverComp = hoverComp.append(TextComponent.of("Current values:"))
@@ -378,7 +379,7 @@ class FlagHelperBox extends PaginationBox {
         if (currVal == null) {
             currVal = getInheritedValue(region, flag);
         }
-        String display = currVal == null ? regName : currVal.id();
+        String display = currVal == null ? regName : currVal.getId();
         appendValueText(builder, flag, display, null);
     }
 

worldguard-core/src/main/java/com/sk89q/worldguard/commands/region/RegionCommands.java

@@ -21,17 +21,16 @@ package com.sk89q.worldguard.commands.region;
 
 import static com.google.common.base.Preconditions.checkNotNull;
 
-import com.google.common.base.Strings;
 import com.google.common.collect.Sets;
 import com.sk89q.minecraft.util.commands.Command;
 import com.sk89q.minecraft.util.commands.CommandContext;
 import com.sk89q.minecraft.util.commands.CommandException;
+import com.sk89q.minecraft.util.commands.CommandPermissions;
 import com.sk89q.minecraft.util.commands.CommandPermissionsException;
 import com.sk89q.worldedit.WorldEdit;
 import com.sk89q.worldedit.command.util.AsyncCommandBuilder;
 import com.sk89q.worldedit.extension.platform.Actor;
 import com.sk89q.worldedit.extension.platform.Capability;
-import com.sk89q.worldedit.regions.Region;
 import com.sk89q.worldedit.util.Location;
 import com.sk89q.worldedit.util.formatting.component.ErrorFormat;
 import com.sk89q.worldedit.util.formatting.component.LabelFormat;
@@ -43,9 +42,9 @@ import com.sk89q.worldedit.util.formatting.text.event.HoverEvent;
 import com.sk89q.worldedit.util.formatting.text.format.TextColor;
 import com.sk89q.worldedit.util.formatting.text.format.TextDecoration;
 import com.sk89q.worldedit.world.World;
-import com.sk89q.worldedit.world.gamemode.GameModes;
 import com.sk89q.worldguard.LocalPlayer;
 import com.sk89q.worldguard.WorldGuard;
+import com.sk89q.worldguard.commands.CommandUtils;
 import com.sk89q.worldguard.commands.task.RegionAdder;
 import com.sk89q.worldguard.commands.task.RegionLister;
 import com.sk89q.worldguard.commands.task.RegionManagerLoader;
@@ -55,7 +54,6 @@ import com.sk89q.worldguard.config.ConfigurationManager;
 import com.sk89q.worldguard.config.WorldConfiguration;
 import com.sk89q.worldguard.internal.permission.RegionPermissionModel;
 import com.sk89q.worldguard.protection.ApplicableRegionSet;
-import com.sk89q.worldguard.protection.FlagValueCalculator;
 import com.sk89q.worldguard.protection.flags.Flag;
 import com.sk89q.worldguard.protection.flags.FlagContext;
 import com.sk89q.worldguard.protection.flags.Flags;
@@ -68,7 +66,6 @@ import com.sk89q.worldguard.protection.managers.RemovalStrategy;
 import com.sk89q.worldguard.protection.managers.migration.DriverMigration;
 import com.sk89q.worldguard.protection.managers.migration.MigrationException;
 import com.sk89q.worldguard.protection.managers.migration.UUIDMigration;
-import com.sk89q.worldguard.protection.managers.migration.WorldHeightMigration;
 import com.sk89q.worldguard.protection.managers.storage.DriverType;
 import com.sk89q.worldguard.protection.managers.storage.RegionDriver;
 import com.sk89q.worldguard.protection.regions.GlobalProtectedRegion;
@@ -77,7 +74,6 @@ import com.sk89q.worldguard.protection.regions.ProtectedRegion;
 import com.sk89q.worldguard.protection.regions.ProtectedRegion.CircularInheritanceException;
 import com.sk89q.worldguard.protection.regions.RegionContainer;
 import com.sk89q.worldguard.protection.util.DomainInputResolver.UserLocatorPolicy;
-import com.sk89q.worldguard.protection.util.WorldEditRegionConverter;
 import com.sk89q.worldguard.session.Session;
 import com.sk89q.worldguard.util.Enums;
 import com.sk89q.worldguard.util.logging.LoggerToChatHandler;
@@ -133,21 +129,22 @@ public final class RegionCommands extends RegionCommandsBase {
      * @throws CommandException any error
      */
     @Command(aliases = {"define", "def", "d", "create"},
-             usage = "[-w <world>] <id> [<owner1> [<owner2> [<owners...>]]]",
-             flags = "ngw:",
+             usage = "<id> [<owner1> [<owner2> [<owners...>]]]",
+             flags = "ng",
              desc = "Defines a region",
              min = 1)
     public void define(CommandContext args, Actor sender) throws CommandException {
         warnAboutSaveFailures(sender);
+        LocalPlayer player = worldGuard.checkPlayer(sender);
 
         // Check permissions
-        if (!getPermissionModel(sender).mayDefine()) {
+        if (!getPermissionModel(player).mayDefine()) {
             throw new CommandPermissionsException();
         }
 
         String id = checkRegionId(args.getString(0), false);
 
-        World world = checkWorld(args, sender, 'w');
+        World world = player.getWorld();
         RegionManager manager = checkRegionManager(world);
 
         checkRegionDoesNotExist(manager, id, true);
@@ -157,7 +154,7 @@ public final class RegionCommands extends RegionCommandsBase {
         if (args.hasFlag('g')) {
             region = new GlobalProtectedRegion(id);
         } else {
-            region = checkRegionFromSelection(sender, id);
+            region = checkRegionFromSelection(player, id);
         }
 
         RegionAdder task = new RegionAdder(manager, region);
@@ -185,22 +182,24 @@ public final class RegionCommands extends RegionCommandsBase {
      * @throws CommandException any error
      */
     @Command(aliases = {"redefine", "update", "move"},
-             usage = "[-w <world>] <id>",
+             usage = "<id>",
              desc = "Re-defines the shape of a region",
-             flags = "gw:",
+             flags = "g",
              min = 1, max = 1)
     public void redefine(CommandContext args, Actor sender) throws CommandException {
         warnAboutSaveFailures(sender);
 
+        LocalPlayer player = worldGuard.checkPlayer(sender);
+
         String id = checkRegionId(args.getString(0), false);
 
-        World world = checkWorld(args, sender, 'w');
+        World world = player.getWorld();
         RegionManager manager = checkRegionManager(world);
 
         ProtectedRegion existing = checkExistingRegion(manager, id, false);
 
         // Check permissions
-        if (!getPermissionModel(sender).mayRedefine(existing)) {
+        if (!getPermissionModel(player).mayRedefine(existing)) {
             throw new CommandPermissionsException();
         }
 
@@ -209,7 +208,7 @@ public final class RegionCommands extends RegionCommandsBase {
         if (args.hasFlag('g')) {
             region = new GlobalProtectedRegion(id);
         } else {
-            region = checkRegionFromSelection(sender, id);
+            region = checkRegionFromSelection(player, id);
         }
 
         region.copyFrom(existing);
@@ -222,9 +221,9 @@ public final class RegionCommands extends RegionCommandsBase {
                 .sendMessageAfterDelay("(Please wait... " + description + ")")
                 .onSuccess((Component) null,
                         t -> {
-                            sender.print(String.format("Region '%s' has been updated with a new area.", region.getId()));
-                            warnAboutDimensions(sender, region);
-                            informNewUser(sender, manager, region);
+                            player.print(String.format("Region '%s' has been updated with a new area.", region.getId()));
+                            warnAboutDimensions(player, region);
+                            informNewUser(player, manager, region);
                             checkSpawnOverlap(sender, world, region);
                         })
                 .onFailure(String.format("Failed to update the region '%s'", region.getId()), worldGuard.getExceptionConverter())
@@ -285,7 +284,7 @@ public final class RegionCommands extends RegionCommandsBase {
             }
         }
 
-        // We have to check whether this region violates the space of any other region
+        // We have to check whether this region violates the space of any other reion
         ApplicableRegionSet regions = manager.getApplicableRegions(region);
 
         // Check if this region overlaps any other region
@@ -318,21 +317,17 @@ public final class RegionCommands extends RegionCommandsBase {
             }
         }
 
-        // Inherit from a template region
-        if (!Strings.isNullOrEmpty(wcfg.setParentOnClaim)) {
-            ProtectedRegion templateRegion = manager.getRegion(wcfg.setParentOnClaim);
-            if (templateRegion != null) {
-                try {
-                    region.setParent(templateRegion);
-                } catch (CircularInheritanceException e) {
-                    throw new CommandException(e.getMessage());
-                }
-            }
-        }
+        RegionAdder task = new RegionAdder(manager, region);
+        task.setLocatorPolicy(UserLocatorPolicy.UUID_ONLY);
+        task.setOwnersInput(new String[]{player.getName()});
 
-        region.getOwners().addPlayer(player);
-        manager.addRegion(region);
-        player.print(TextComponent.of(String.format("A new region has been claimed named '%s'.", id)));
+        final String description = String.format("Claiming region '%s'", id);
+        AsyncCommandBuilder.wrap(task, sender)
+                .registerWithSupervisor(WorldGuard.getInstance().getSupervisor(), description)
+                .sendMessageAfterDelay("(Please wait... " + description + ")")
+                .onSuccess(TextComponent.of(String.format("A new region has been claimed named '%s'.", id)), null)
+                .onFailure("Failed to claim region", WorldGuard.getInstance().getExceptionConverter())
+                .buildAndExec(WorldGuard.getInstance().getExecutorService());
     }
 
     /**
@@ -343,34 +338,28 @@ public final class RegionCommands extends RegionCommandsBase {
      * @throws CommandException any error
      */
     @Command(aliases = {"select", "sel", "s"},
-             usage = "[-w <world>] [id]",
+             usage = "[id]",
              desc = "Load a region as a WorldEdit selection",
-             min = 0, max = 1,
-             flags = "w:")
+             min = 0, max = 1)
     public void select(CommandContext args, Actor sender) throws CommandException {
-        World world = checkWorld(args, sender, 'w');
-        RegionManager manager = checkRegionManager(world);
+        LocalPlayer player = worldGuard.checkPlayer(sender);
+        RegionManager manager = checkRegionManager(player.getWorld());
         ProtectedRegion existing;
 
         // If no arguments were given, get the region that the player is inside
         if (args.argsLength() == 0) {
-            LocalPlayer player = worldGuard.checkPlayer(sender);
-            if (!player.getWorld().equals(world)) { // confusing to get current location regions in another world
-                throw new CommandException("Please specify a region name."); // just don't allow that
-            }
-            world = player.getWorld();
-            existing = checkRegionStandingIn(manager, player, "/rg select -w \"" + world.getName() + "\" %id%");
+            existing = checkRegionStandingIn(manager, player, "/rg select %id%");
         } else {
             existing = checkExistingRegion(manager, args.getString(0), false);
         }
 
         // Check permissions
-        if (!getPermissionModel(sender).maySelect(existing)) {
+        if (!getPermissionModel(player).maySelect(existing)) {
             throw new CommandPermissionsException();
         }
 
         // Select
-        setPlayerSelection(sender, existing, world);
+        setPlayerSelection(player, existing);
     }
 
     /**
@@ -418,7 +407,7 @@ public final class RegionCommands extends RegionCommandsBase {
                 throw new CommandPermissionsException();
             }
 
-            setPlayerSelection(worldGuard.checkPlayer(sender), existing, world);
+            setPlayerSelection(worldGuard.checkPlayer(sender), existing);
         }
 
         // Print region information
@@ -428,10 +417,7 @@ public final class RegionCommands extends RegionCommandsBase {
         AsyncCommandBuilder.wrap(printout, sender)
                 .registerWithSupervisor(WorldGuard.getInstance().getSupervisor(), "Fetching region info")
                 .sendMessageAfterDelay("(Please wait... fetching region information...)")
-                .onSuccess((Component) null, component -> {
-                    sender.print(component);
-                    checkSpawnOverlap(sender, world, existing);
-                })
+                .onSuccess((Component) null, sender::print)
                 .onFailure("Failed to fetch region information", WorldGuard.getInstance().getExceptionConverter())
                 .buildAndExec(WorldGuard.getInstance().getExecutorService());
     }
@@ -444,9 +430,9 @@ public final class RegionCommands extends RegionCommandsBase {
      * @throws CommandException any error
      */
     @Command(aliases = {"list"},
-             usage = "[-w world] [-p owner [-n]] [-s] [-i filter] [page]",
+             usage = "[page]",
              desc = "Get a list of regions",
-             flags = "np:w:i:s",
+             flags = "np:w:",
              max = 1)
     public void list(CommandContext args, Actor sender) throws CommandException {
         warnAboutSaveFailures(sender);
@@ -483,16 +469,6 @@ public final class RegionCommands extends RegionCommandsBase {
             task.filterOwnedByName(ownedBy, args.hasFlag('n'));
         }
 
-        if (args.hasFlag('s')) {
-            ProtectedRegion existing = checkRegionFromSelection(sender, "tmp");
-            task.filterByIntersecting(existing);
-        }
-
-        // -i string is in region id
-        if (args.hasFlag('i')) {
-            task.filterIdByMatch(args.getFlag('i'));
-        }
-
         AsyncCommandBuilder.wrap(task, sender)
                 .registerWithSupervisor(WorldGuard.getInstance().getSupervisor(), "Getting region list")
                 .sendMessageAfterDelay("(Please wait... fetching region list...)")
@@ -646,7 +622,6 @@ public final class RegionCommands extends RegionCommandsBase {
             printout.appendFlagsList(false);
             printout.append(SubtleFormat.wrap(")"));
             printout.send(sender);
-            checkSpawnOverlap(sender, world, existing);
         }
     }
 
@@ -663,7 +638,7 @@ public final class RegionCommands extends RegionCommandsBase {
         ProtectedRegion region;
         if (args.argsLength() == 0) { // Get region from where the player is
             if (!(sender instanceof LocalPlayer)) {
-                throw new CommandException("Please specify the region with /region flags -w world_name region_name.");
+                throw new CommandException("Please specify the region with /region info -w world_name region_name.");
             }
 
             region = checkRegionStandingIn(manager, (LocalPlayer) sender, true,
@@ -687,12 +662,7 @@ public final class RegionCommands extends RegionCommandsBase {
         if (!sender.isPlayer()) {
             flagHelperBox.tryMonoSpacing();
         }
-        AsyncCommandBuilder.wrap(() -> {
-                    if (checkSpawnOverlap(sender, world, region)) {
-                        flagHelperBox.setComponentsPerPage(15);
-                    }
-                    return flagHelperBox.create(page);
-                }, sender)
+        AsyncCommandBuilder.wrap(() -> flagHelperBox.create(page), sender)
                 .onSuccess((Component) null, sender::print)
                 .onFailure("Failed to get region flags", WorldGuard.getInstance().getExceptionConverter())
                 .buildAndExec(WorldGuard.getInstance().getExecutorService());
@@ -728,7 +698,6 @@ public final class RegionCommands extends RegionCommandsBase {
         existing.setPriority(priority);
 
         sender.print("Priority of '" + existing.getId() + "' set to " + priority + " (higher numbers override).");
-        checkSpawnOverlap(sender, world, existing);
     }
 
     /**
@@ -1087,62 +1056,6 @@ public final class RegionCommands extends RegionCommandsBase {
         }
     }
 
-
-    /**
-     * Migrate regions that went from 0-255 to new world heights.
-     *
-     * @param args the arguments
-     * @param sender the sender
-     * @throws CommandException any error
-     */
-    @Command(aliases = {"migrateheights"},
-            usage = "[world]", max = 1,
-            flags = "yw:",
-            desc = "Migrate regions from old height limits to new height limits")
-    public void migrateHeights(CommandContext args, Actor sender) throws CommandException {
-        // Check permissions
-        if (!getPermissionModel(sender).mayMigrateRegionHeights()) {
-            throw new CommandPermissionsException();
-        }
-
-        if (!args.hasFlag('y')) {
-            throw new CommandException("This command is potentially dangerous.\n" +
-                    "Please ensure you have made a backup of your data, and then re-enter the command with -y tacked on at the end to proceed.");
-        }
-
-        World world = null;
-        try {
-            world = checkWorld(args, sender, 'w');
-        } catch (CommandException ignored) {
-        }
-
-        LoggerToChatHandler handler = null;
-        Logger minecraftLogger = null;
-
-        if (sender instanceof LocalPlayer) {
-            handler = new LoggerToChatHandler(sender);
-            handler.setLevel(Level.ALL);
-            minecraftLogger = Logger.getLogger("com.sk89q.worldguard");
-            minecraftLogger.addHandler(handler);
-        }
-
-        try {
-            RegionContainer container = WorldGuard.getInstance().getPlatform().getRegionContainer();
-            RegionDriver driver = container.getDriver();
-            WorldHeightMigration migration = new WorldHeightMigration(driver, WorldGuard.getInstance().getFlagRegistry(), world);
-            container.migrate(migration);
-            sender.print("Migration complete!");
-        } catch (MigrationException e) {
-            log.log(Level.WARNING, "Failed to migrate", e);
-            throw new CommandException("Error encountered while migrating: " + e.getMessage());
-        } finally {
-            if (minecraftLogger != null) {
-                minecraftLogger.removeHandler(handler);
-            }
-        }
-    }
-
-
     /**
      * Teleport to a region
      * 
@@ -1151,8 +1064,8 @@ public final class RegionCommands extends RegionCommandsBase {
      * @throws CommandException any error
      */
     @Command(aliases = {"teleport", "tp"},
-             usage = "[-w world] [-c|s] <id>",
-             flags = "csw:",
+             usage = "<id>",
+             flags = "sw:",
              desc = "Teleports you to the location associated with the region.",
              min = 1, max = 1)
     public void teleport(CommandContext args, Actor sender) throws CommandException {
@@ -1171,70 +1084,32 @@ public final class RegionCommands extends RegionCommandsBase {
 
         // -s for spawn location
         if (args.hasFlag('s')) {
-            teleportLocation = FlagValueCalculator.getEffectiveFlagOf(existing, Flags.SPAWN_LOC, player);
+            teleportLocation = existing.getFlag(Flags.SPAWN_LOC);
             
             if (teleportLocation == null) {
                 throw new CommandException(
                         "The region has no spawn point associated.");
             }
-        } else if (args.hasFlag('c')) {
-            // Check permissions
-            if (!getPermissionModel(player).mayTeleportToCenter(existing)) {
-                throw new CommandPermissionsException();
-            }
-            Region region = WorldEditRegionConverter.convertToRegion(existing);
-            if (region == null || region.getCenter() == null) {
-                throw new CommandException("The region has no center point.");
-            }
-            if (player.getGameMode() == GameModes.SPECTATOR) {
-                teleportLocation = new Location(world, region.getCenter(), 0, 0);
-            } else {
-                // TODO: Add some method to create a safe teleport location.
-                // The method AbstractPlayerActor$findFreePoisition(Location loc) is no good way for this.
-                // It doesn't return the found location and it can't be checked if the location is inside the region.
-                throw new CommandException("Center teleport is only available in Spectator gamemode.");
-            }
         } else {
-            teleportLocation = FlagValueCalculator.getEffectiveFlagOf(existing, Flags.TELE_LOC, player);
+            teleportLocation = existing.getFlag(Flags.TELE_LOC);
             
             if (teleportLocation == null) {
                 throw new CommandException("The region has no teleport point associated.");
             }
         }
 
-        String message = FlagValueCalculator.getEffectiveFlagOf(existing, Flags.TELE_MESSAGE, player);
-
-        // If the flag isn't set, use the default message
-        // If message.isEmpty(), no message is sent by LocalPlayer#teleport(...)
-        if (message == null) {
-            message = Flags.TELE_MESSAGE.getDefault();
-        }
-
         player.teleport(teleportLocation,
-                message.replace("%id%", existing.getId()),
+                "Teleported you to the region '" + existing.getId() + "'.",
                 "Unable to teleport to region '" + existing.getId() + "'.");
     }
 
     @Command(aliases = {"toggle-bypass", "bypass"},
-             usage = "[on|off]",
              desc = "Toggle region bypassing, effectively ignoring bypass permissions.")
+    @CommandPermissions({"worldguard.region.toggle-bypass"})
     public void toggleBypass(CommandContext args, Actor sender) throws CommandException {
         LocalPlayer player = worldGuard.checkPlayer(sender);
-        if (!player.hasPermission("worldguard.region.toggle-bypass")) {
-            throw new CommandPermissionsException();
-        }
         Session session = WorldGuard.getInstance().getPlatform().getSessionManager().get(player);
-        boolean shouldEnableBypass;
-        if (args.argsLength() > 0) {
-            String arg1 = args.getString(0);
-            if (!arg1.equalsIgnoreCase("on") && !arg1.equalsIgnoreCase("off")) {
-                throw new CommandException("Allowed optional arguments are: on, off");
-            }
-            shouldEnableBypass = arg1.equalsIgnoreCase("on");
-        } else {
-            shouldEnableBypass = session.hasBypassDisabled();
-        }
-        if (shouldEnableBypass) {
+        if (session.hasBypassDisabled()) {
             session.setBypassDisabled(false);
             player.print("You are now bypassing region protection (as long as you have permission).");
         } else {

worldguard-core/src/main/java/com/sk89q/worldguard/commands/region/RegionCommandsBase.java

@@ -31,7 +31,6 @@ import com.sk89q.worldedit.math.BlockVector3;
 import com.sk89q.worldedit.regions.CuboidRegion;
 import com.sk89q.worldedit.regions.Polygonal2DRegion;
 import com.sk89q.worldedit.regions.Region;
-import com.sk89q.worldedit.regions.RegionSelector;
 import com.sk89q.worldedit.regions.selector.CuboidRegionSelector;
 import com.sk89q.worldedit.regions.selector.Polygonal2DRegionSelector;
 import com.sk89q.worldedit.util.formatting.component.ErrorFormat;
@@ -55,8 +54,6 @@ import com.sk89q.worldguard.protection.regions.ProtectedCuboidRegion;
 import com.sk89q.worldguard.protection.regions.ProtectedPolygonalRegion;
 import com.sk89q.worldguard.protection.regions.ProtectedRegion;
 import com.sk89q.worldguard.protection.regions.RegionContainer;
-import com.sk89q.worldguard.protection.regions.RegionQuery.QueryOption;
-import com.sk89q.worldguard.protection.util.WorldEditRegionConverter;
 
 import java.util.Set;
 import java.util.stream.Collectors;
@@ -87,25 +84,9 @@ class RegionCommandsBase {
      * @throws CommandException on error
      */
     protected static World checkWorld(CommandContext args, Actor sender, char flag) throws CommandException {
-        return checkWorld(args, sender, flag, true);
-    }
-
-    protected static World checkWorld(CommandContext args, Actor sender, char flag, boolean allowWorldEditOverride) throws CommandException {
         if (args.hasFlag(flag)) {
             return WorldGuard.getInstance().getPlatform().getMatcher().matchWorld(sender, args.getFlag(flag));
         } else {
-            if (allowWorldEditOverride) {
-                try {
-                    World override = WorldEdit.getInstance().getSessionManager().get(sender).getWorldOverride();
-                    if (override != null) {
-                        if (sender instanceof LocalPlayer && !override.equals(((LocalPlayer) sender).getWorld())) {
-                            sender.printDebug(TextComponent.of("Using //world override for region command: " + override.getName()));
-                        }
-                        return override;
-                    }
-                } catch (NoSuchMethodError ignored) {
-                }
-            }
             if (sender instanceof LocalPlayer) {
                 return ((LocalPlayer) sender).getWorld();
             } else {
@@ -201,7 +182,7 @@ class RegionCommandsBase {
      * @throws CommandException thrown if no region was found
      */
     protected static ProtectedRegion checkRegionStandingIn(RegionManager regionManager, LocalPlayer player, boolean allowGlobal, String rgCmd) throws CommandException {
-        ApplicableRegionSet set = regionManager.getApplicableRegions(player.getLocation().toVector().toBlockPoint(), QueryOption.SORT);
+        ApplicableRegionSet set = regionManager.getApplicableRegions(player.getLocation().toVector().toBlockPoint());
 
         if (set.size() == 0) {
             if (allowGlobal) {
@@ -211,7 +192,7 @@ class RegionCommandsBase {
                 return global;
             }
             throw new CommandException(
-                    "You're not standing in a region. " +
+                    "You're not standing in a region." +
                             "Specify an ID if you want to select a specific region.");
         } else if (set.size() > 1) {
             boolean first = true;
@@ -231,31 +212,28 @@ class RegionCommandsBase {
                 builder.append(regionComp);
             }
             player.print(builder.build());
-            throw new CommandException("You're standing in several regions (please pick one).");
+            throw new CommandException("Several regions affect your current location (please pick one).");
         }
 
         return set.iterator().next();
     }
 
     /**
-     * Get a WorldEdit selection for an actor, or emit an exception if there is none
+     * Get a WorldEdit selection for a player, or emit an exception if there is none
      * available.
      *
-     * @param actor the actor
+     * @param player the player
      * @return the selection
      * @throws CommandException thrown on an error
      */
-    protected static Region checkSelection(Actor actor) throws CommandException {
-        LocalSession localSession = WorldEdit.getInstance().getSessionManager().get(actor);
+    protected static Region checkSelection(LocalPlayer player) throws CommandException {
         try {
-            if (localSession == null || localSession.getSelectionWorld() == null) {
-                throw new IncompleteRegionException();
-            }
-            return localSession.getRegionSelector(localSession.getSelectionWorld()).getRegion();
+            return WorldEdit.getInstance().getSessionManager().get(player).getRegionSelector(player.getWorld()).getRegion();
         } catch (IncompleteRegionException e) {
-            throw new CommandException("Please select an area first. " +
-                    "Use WorldEdit to make a selection! " +
-                    "(see: https://worldedit.enginehub.org/en/latest/usage/regions/selections/).");
+            throw new CommandException(
+                    "Please select an area first. " +
+                            "Use WorldEdit to make a selection! " +
+                            "(see: https://worldedit.enginehub.org/en/latest/usage/regions/selections/).");
         }
     }
 
@@ -295,21 +273,21 @@ class RegionCommandsBase {
     }
 
     /**
-     * Create a {@link ProtectedRegion} from the actor's selection.
+     * Create a {@link ProtectedRegion} from the player's selection.
      *
-     * @param actor the actor
+     * @param player the player
      * @param id the ID of the new region
      * @return a new region
      * @throws CommandException thrown on an error
      */
-    protected static ProtectedRegion checkRegionFromSelection(Actor actor, String id) throws CommandException {
-        Region selection = checkSelection(actor);
+    protected static ProtectedRegion checkRegionFromSelection(LocalPlayer player, String id) throws CommandException {
+        Region selection = checkSelection(player);
 
         // Detect the type of region from WorldEdit
         if (selection instanceof Polygonal2DRegion) {
             Polygonal2DRegion polySel = (Polygonal2DRegion) selection;
-            int minY = polySel.getMinimumPoint().y();
-            int maxY = polySel.getMaximumPoint().y();
+            int minY = polySel.getMinimumPoint().getBlockY();
+            int maxY = polySel.getMaximumPoint().getBlockY();
             return new ProtectedPolygonalRegion(id, polySel.getPoints(), minY, maxY);
         } else if (selection instanceof CuboidRegion) {
             BlockVector3 min = selection.getMinimumPoint();
@@ -345,10 +323,7 @@ class RegionCommandsBase {
      * @param region the region
      */
     protected static void warnAboutDimensions(Actor sender, ProtectedRegion region) {
-        if (region instanceof GlobalProtectedRegion) {
-            return;
-        }
-        int height = region.getMaximumPoint().y() - region.getMinimumPoint().y();
+        int height = region.getMaximumPoint().getBlockY() - region.getMinimumPoint().getBlockY();
         if (height <= 2) {
             sender.printDebug("(Warning: The height of the region was " + (height + 1) + " block(s).)");
         }
@@ -376,38 +351,56 @@ class RegionCommandsBase {
      * @param world the world the region is in
      * @param region the region
      */
-    protected static boolean checkSpawnOverlap(Actor sender, World world, ProtectedRegion region) {
+    protected static void checkSpawnOverlap(Actor sender, World world, ProtectedRegion region) {
         ProtectedRegion spawn = WorldGuard.getInstance().getPlatform().getSpawnProtection(world);
         if (spawn != null) {
             if (!spawn.getIntersectingRegions(ImmutableList.of(region)).isEmpty()) {
                 sender.print(ErrorFormat.wrap("Warning!")
                         .append(TextComponent.of(" This region overlaps vanilla's spawn protection. WorldGuard cannot " +
-                                "override this, and only server operators will be able to interact with this area.", TextColor.WHITE)));
-                return true;
+                                "override this, and only server operators will be able to interact with this area.")));
             }
         }
-        return false;
     }
 
     /**
-     * Set an actor's selection to a given region.
+     * Set a player's selection to a given region.
      *
-     * @param actor the actor
+     * @param player the player
      * @param region the region
      * @throws CommandException thrown on a command error
      */
-    protected static void setPlayerSelection(Actor actor, ProtectedRegion region, World world) throws CommandException {
-        LocalSession session = WorldEdit.getInstance().getSessionManager().get(actor);
+    protected static void setPlayerSelection(LocalPlayer player, ProtectedRegion region) throws CommandException {
+        LocalSession session = WorldEdit.getInstance().getSessionManager().get(player);
+
+        // Set selection
+        if (region instanceof ProtectedCuboidRegion) {
+            ProtectedCuboidRegion cuboid = (ProtectedCuboidRegion) region;
+            BlockVector3 pt1 = cuboid.getMinimumPoint();
+            BlockVector3 pt2 = cuboid.getMaximumPoint();
+
+            CuboidRegionSelector selector = new CuboidRegionSelector(player.getWorld(), pt1, pt2);
+            session.setRegionSelector(player.getWorld(), selector);
+            selector.explainRegionAdjust(player, session);
+            player.print("Region selected as a cuboid.");
+
+        } else if (region instanceof ProtectedPolygonalRegion) {
+            ProtectedPolygonalRegion poly2d = (ProtectedPolygonalRegion) region;
+            Polygonal2DRegionSelector selector = new Polygonal2DRegionSelector(
+                    player.getWorld(), poly2d.getPoints(),
+                    poly2d.getMinimumPoint().getBlockY(),
+                    poly2d.getMaximumPoint().getBlockY());
+            session.setRegionSelector(player.getWorld(), selector);
+            selector.explainRegionAdjust(player, session);
+            player.print("Region selected as a polygon.");
+
+        } else if (region instanceof GlobalProtectedRegion) {
+            throw new CommandException(
+                    "Can't select global regions! " +
+                            "That would cover the entire world.");
 
-        RegionSelector selector = WorldEditRegionConverter.convertToSelector(region);
-        if (selector != null) {
-            selector.setWorld(world);
-            session.setRegionSelector(world, selector);
-            selector.explainRegionAdjust(actor, session);
-            actor.print("Region selected as " + region.getType().getName());
         } else {
-            throw new CommandException("Can't select that region! " +
-                    "The region type '" + region.getType().getName() + "' can't be selected.");
+            throw new CommandException("Unknown region type: " +
+                    region.getClass().getCanonicalName());
         }
     }
 

worldguard-core/src/main/java/com/sk89q/worldguard/commands/region/RegionPrintoutBuilder.java

@@ -19,7 +19,6 @@
 
 package com.sk89q.worldguard.commands.region;
 
-import com.sk89q.worldguard.protection.flags.registry.UnknownFlag;
 import com.sk89q.worldguard.util.profile.cache.ProfileCache;
 import com.sk89q.worldedit.extension.platform.Actor;
 import com.sk89q.worldedit.math.BlockVector3;
@@ -36,8 +35,6 @@ import com.sk89q.worldedit.util.formatting.text.format.TextColor;
 import com.sk89q.worldguard.WorldGuard;
 import com.sk89q.worldguard.domains.DefaultDomain;
 import com.sk89q.worldguard.internal.permission.RegionPermissionModel;
-import com.sk89q.worldguard.protection.FlagValueCalculator;
-import com.sk89q.worldguard.protection.association.RegionAssociable;
 import com.sk89q.worldguard.protection.flags.Flag;
 import com.sk89q.worldguard.protection.flags.Flags;
 import com.sk89q.worldguard.protection.flags.RegionGroupFlag;
@@ -146,22 +143,8 @@ public class RegionPrintoutBuilder implements Callable<TextComponent> {
                 flagString = flag.getName() + " -g " + group + ": ";
             }
 
-            TextColor flagColor = TextColor.WHITE;
-            if (useColors) {
-                // passthrough is ok on global
-                if (FlagHelperBox.DANGER_ZONE.contains(flag)
-                        && !(region.getId().equals(ProtectedRegion.GLOBAL_REGION) && flag == Flags.PASSTHROUGH)) {
-                    flagColor = TextColor.DARK_RED;
-                } else if (Flags.INBUILT_FLAGS.contains(flag.getName())) {
-                    flagColor = TextColor.GOLD;
-                } else if (flag instanceof UnknownFlag) {
-                    flagColor = TextColor.GRAY;
-                } else {
-                    flagColor = TextColor.LIGHT_PURPLE;
-                }
-            }
-            TextComponent flagText = TextComponent.of(flagString, flagColor)
-                    .append(TextComponent.of(String.valueOf(val), useColors ? TextColor.YELLOW : TextColor.WHITE));
+            TextComponent flagText = TextComponent.of(flagString, useColors ? TextColor.GOLD : TextColor.WHITE)
+                    .append(TextComponent.of(String.valueOf(val), useColors? TextColor.YELLOW : TextColor.WHITE));
             if (perms != null && perms.maySetFlag(region, flag)) {
                 flagText = flagText.hoverEvent(HoverEvent.of(HoverEvent.Action.SHOW_TEXT, TextComponent.of("Click to set flag")))
                         .clickEvent(ClickEvent.of(ClickEvent.Action.SUGGEST_COMMAND,
@@ -317,22 +300,16 @@ public class RegionPrintoutBuilder implements Callable<TextComponent> {
                     .clickEvent(ClickEvent.of(ClickEvent.Action.RUN_COMMAND, "/rg select " + region.getId()));
         }
         builder.append(bound);
-        final Location teleFlag = FlagValueCalculator.getEffectiveFlagOf(region, Flags.TELE_LOC, perms != null && perms.getSender() instanceof RegionAssociable ? (RegionAssociable) perms.getSender() : null);
+        final Location teleFlag = region.getFlag(Flags.TELE_LOC);
         if (teleFlag != null && perms != null && perms.mayTeleportTo(region)) {
             builder.append(TextComponent.space().append(TextComponent.of("[Teleport]", TextColor.GRAY)
                     .hoverEvent(HoverEvent.of(HoverEvent.Action.SHOW_TEXT,
                             TextComponent.of("Click to teleport").append(TextComponent.newline()).append(
-                                    TextComponent.of(teleFlag.getBlockX() + ", "
+                                    TextComponent.of(teleFlag.getBlockY() + ", "
                                             + teleFlag.getBlockY() + ", "
                                             + teleFlag.getBlockZ()))))
                     .clickEvent(ClickEvent.of(ClickEvent.Action.RUN_COMMAND,
                             "/rg tp -w \"" + world + "\" " + region.getId()))));
-        } else if (perms != null && perms.mayTeleportToCenter(region) && region.isPhysicalArea()) {
-            builder.append(TextComponent.space().append(TextComponent.of("[Center Teleport]", TextColor.GRAY)
-                    .hoverEvent(HoverEvent.of(HoverEvent.Action.SHOW_TEXT,
-                            TextComponent.of("Click to teleport to the center of the region")))
-                    .clickEvent(ClickEvent.of(ClickEvent.Action.RUN_COMMAND,
-                            "/rg tp -c -w \"" + world + "\" " + region.getId()))));
         }
 
         newline();

worldguard-core/src/main/java/com/sk89q/worldguard/commands/task/RegionLister.java

@@ -24,7 +24,6 @@ import static com.google.common.base.Preconditions.checkNotNull;
 import com.sk89q.minecraft.util.commands.CommandException;
 import com.sk89q.worldguard.util.profile.Profile;
 import com.sk89q.worldedit.extension.platform.Actor;
-import com.sk89q.worldedit.util.Location;
 import com.sk89q.worldedit.util.formatting.component.PaginationBox;
 import com.sk89q.worldedit.util.formatting.text.Component;
 import com.sk89q.worldedit.util.formatting.text.TextComponent;
@@ -34,15 +33,12 @@ import com.sk89q.worldedit.util.formatting.text.format.TextColor;
 import com.sk89q.worldguard.WorldGuard;
 import com.sk89q.worldguard.domains.DefaultDomain;
 import com.sk89q.worldguard.internal.permission.RegionPermissionModel;
-import com.sk89q.worldguard.protection.FlagValueCalculator;
-import com.sk89q.worldguard.protection.association.RegionAssociable;
 import com.sk89q.worldguard.protection.flags.Flags;
 import com.sk89q.worldguard.protection.managers.RegionManager;
 import com.sk89q.worldguard.protection.regions.ProtectedRegion;
 
 import java.io.IOException;
 import java.util.ArrayList;
-import java.util.Collection;
 import java.util.Collections;
 import java.util.List;
 import java.util.Map;
@@ -59,8 +55,6 @@ public class RegionLister implements Callable<Integer> {
     private final RegionManager manager;
     private final String world;
     private OwnerMatcher ownerMatcher;
-    private String idFilter;
-    private ProtectedRegion filterByIntersecting;
     private int page;
     private String playerName;
     private boolean nameOnly;
@@ -83,10 +77,6 @@ public class RegionLister implements Callable<Integer> {
         this.page = page;
     }
 
-    public void filterByIntersecting(ProtectedRegion region) {
-        this.filterByIntersecting = region;
-    }
-
     public void filterOwnedByName(String name, boolean nameOnly) {
         this.playerName = name;
         this.nameOnly = nameOnly;
@@ -151,29 +141,20 @@ public class RegionLister implements Callable<Integer> {
         };
     }
 
-    public void filterIdByMatch(String idFilter) {
-        this.idFilter = idFilter;
-    }
-
     @Override
     public Integer call() throws Exception {
         Map<String, ProtectedRegion> regions = manager.getRegions();
-        Collection<ProtectedRegion> iterableRegions = regions.values();
-
-        if (filterByIntersecting != null) {
-            iterableRegions = filterByIntersecting.getIntersectingRegions(iterableRegions);
-        }
 
         // Build a list of regions to show
         List<RegionListEntry> entries = new ArrayList<>();
 
-        for (ProtectedRegion rg : iterableRegions) {
-            if (rg.getId().equals("__global__")) {
+        for (Map.Entry<String, ProtectedRegion> rg : regions.entrySet()) {
+            if (rg.getKey().equals("__global__")) {
                 continue;
             }
-            final RegionListEntry entry = new RegionListEntry(rg);
-
-            if (entry.matches(idFilter) && entry.matches(ownerMatcher)) {
+            final ProtectedRegion region = rg.getValue();
+            final RegionListEntry entry = new RegionListEntry(region);
+            if (entry.matches(ownerMatcher)) {
                 entries.add(entry);
             }
         }
@@ -184,7 +165,7 @@ public class RegionLister implements Callable<Integer> {
         // insert global on top
         if (regions.containsKey("__global__")) {
             final RegionListEntry entry = new RegionListEntry(regions.get("__global__"));
-            if (entry.matches(idFilter) && entry.matches(ownerMatcher)) {
+            if (entry.matches(ownerMatcher)) {
                 entries.add(0, entry);
             }
         }
@@ -198,8 +179,6 @@ public class RegionLister implements Callable<Integer> {
         String cmd = "/rg list -w \"" + world + "\""
                 + (playerName != null ? " -p " + playerName : "")
                 + (nameOnly ? " -n" : "")
-                + (filterByIntersecting != null ? " -s" : "")
-                + (idFilter != null ? " -i " + idFilter : "")
                 + " %page%";
         PaginationBox box = new RegionListBox(title, cmd, perms, entries, world);
         sender.print(box.create(page));
@@ -228,10 +207,6 @@ public class RegionLister implements Callable<Integer> {
                     || (isMember = matcher.isContainedWithin(region.getMembers()));
         }
 
-        public boolean matches(String idMatcher) {
-            return idMatcher == null || region.getId().contains(idMatcher);
-        }
-
         public ProtectedRegion getRegion() {
             return region;
         }
@@ -286,18 +261,11 @@ public class RegionLister implements Callable<Integer> {
                         .clickEvent(ClickEvent.of(ClickEvent.Action.RUN_COMMAND,
                                 "/rg info -w \"" + world + "\" " + entry.region.getId()))));
             }
-            final Location teleFlag = FlagValueCalculator.getEffectiveFlagOf(entry.region, Flags.TELE_LOC, perms != null && perms.getSender() instanceof RegionAssociable ? (RegionAssociable) perms.getSender() : null);
-            if (perms != null && teleFlag != null && perms.mayTeleportTo(entry.region)) {
+            if (perms != null && entry.region.getFlag(Flags.TELE_LOC) != null && perms.mayTeleportTo(entry.region)) {
                 builder.append(TextComponent.space().append(TextComponent.of("[TP]", TextColor.GRAY)
                         .hoverEvent(HoverEvent.of(HoverEvent.Action.SHOW_TEXT, TextComponent.of("Click to teleport")))
                         .clickEvent(ClickEvent.of(ClickEvent.Action.RUN_COMMAND,
                                 "/rg tp -w \"" + world + "\" " + entry.region.getId()))));
-            } else if (perms != null && perms.mayTeleportToCenter(entry.getRegion()) && entry.getRegion().isPhysicalArea()) {
-                builder.append(TextComponent.space().append(TextComponent.of("[TP-Center]", TextColor.GRAY)
-                        .hoverEvent(HoverEvent.of(HoverEvent.Action.SHOW_TEXT,
-                                TextComponent.of("Click to teleport to the center")))
-                        .clickEvent(ClickEvent.of(ClickEvent.Action.RUN_COMMAND,
-                                "/rg tp -c -w \"" + world + "\" " + entry.region.getId()))));
             }
             return builder.build();
         }

worldguard-core/src/main/java/com/sk89q/worldguard/config/ConfigurationManager.java

@@ -76,9 +76,6 @@ public abstract class ConfigurationManager {
     public boolean migrateRegionsToUuid;
     public boolean keepUnresolvedNames;
     public boolean particleEffects;
-    public boolean disablePermissionCache;
-    public boolean disableDefaultBypass;
-    public boolean announceBypassStatus;
 
     @Unreported public Map<String, String> hostKeys = new HashMap<>();
     public boolean hostKeysAllowFMLClients;

worldguard-core/src/main/java/com/sk89q/worldguard/config/WorldConfiguration.java

@@ -105,7 +105,6 @@ public abstract class WorldConfiguration {
     public boolean blockEntityPaintingDestroy;
     public boolean blockEntityItemFrameDestroy;
     public boolean blockEntityArmorStandDestroy;
-    public boolean blockEntityVehicleEntry;
     public boolean blockPluginSpawning;
     public boolean blockGroundSlimes;
     public boolean blockZombieDoorDestruction;
@@ -129,7 +128,6 @@ public abstract class WorldConfiguration {
     public boolean allowTamedSpawns;
     public int maxClaimVolume;
     public boolean claimOnlyInsideExistingRegions;
-    public String setParentOnClaim;
     public int maxRegionCountPerPlayer;
     public boolean antiWolfDumbness;
     public boolean signChestProtection;
@@ -137,10 +135,6 @@ public abstract class WorldConfiguration {
     public boolean removeInfiniteStacks;
     public boolean disableCreatureCropTrampling;
     public boolean disablePlayerCropTrampling;
-    public boolean disableCreatureTurtleEggTrampling;
-    public boolean disablePlayerTurtleEggTrampling;
-    public boolean disableCreatureSnifferEggTrampling;
-    public boolean disablePlayerSnifferEggTrampling;
     public boolean preventLightningFire;
     public Set<String> disallowedLightningBlocks;
     public boolean disableThunder;
@@ -160,26 +154,20 @@ public abstract class WorldConfiguration {
     public boolean disableGrassGrowth;
     public boolean disableMyceliumSpread;
     public boolean disableVineGrowth;
-    public boolean disableRockGrowth;
-    public boolean disableSculkGrowth;
     public boolean disableCropGrowth;
     public boolean disableEndermanGriefing;
     public boolean disableSnowmanTrails;
     public boolean disableSoilDehydration;
-    public boolean disableCoralBlockFade;
-    public boolean disableCopperBlockFade;
     public Set<String> allowedSnowFallOver;
     public boolean regionInvinciblityRemovesMobs;
     public boolean regionCancelEmptyChatEvents;
     public boolean regionNetherPortalProtection;
-    public boolean forceDefaultTitleTimes;
     public boolean fakePlayerBuildOverride;
     public boolean explosionFlagCancellation;
     public boolean disableDeathMessages;
+    public boolean disableObsidianGenerators;
     public boolean strictEntitySpawn;
     public boolean ignoreHopperMoveEvents;
-    public boolean breakDeniedHoppers;
-    public boolean useMaxPriorityAssociation;
     protected Map<String, Integer> maxRegionCounts;
 
     /**

worldguard-core/src/main/java/com/sk89q/worldguard/config/YamlConfigurationManager.java

@@ -56,9 +56,6 @@ public abstract class YamlConfigurationManager extends ConfigurationManager {
         migrateRegionsToUuid = config.getBoolean("regions.uuid-migration.perform-on-next-start", true);
         keepUnresolvedNames = config.getBoolean("regions.uuid-migration.keep-names-that-lack-uuids", true);
         useRegionsCreatureSpawnEvent = config.getBoolean("regions.use-creature-spawn-event", true);
-        disableDefaultBypass = config.getBoolean("regions.disable-bypass-by-default", false);
-        announceBypassStatus = config.getBoolean("regions.announce-bypass-status", false);
-
         useGodPermission = config.getBoolean("auto-invincible", config.getBoolean("auto-invincible-permission", false));
         useGodGroup = config.getBoolean("auto-invincible-group", false);
         useAmphibiousGroup = config.getBoolean("auto-no-drowning-group", false);
@@ -66,7 +63,6 @@ public abstract class YamlConfigurationManager extends ConfigurationManager {
         usePlayerMove = config.getBoolean("use-player-move-event", true);
         usePlayerTeleports = config.getBoolean("use-player-teleports", true);
         particleEffects = config.getBoolean("use-particle-effects", true);
-        disablePermissionCache = config.getBoolean("disable-permission-cache", false);
 
         deopOnJoin = config.getBoolean("security.deop-everyone-on-join", false);
         blockInGameOp = config.getBoolean("security.block-in-game-op-command", false);
@@ -93,12 +89,6 @@ public abstract class YamlConfigurationManager extends ConfigurationManager {
         String sqlUsername = config.getString("regions.sql.username", "worldguard");
         String sqlPassword = config.getString("regions.sql.password", "worldguard");
         String sqlTablePrefix = config.getString("regions.sql.table-prefix", "");
-        if (!useSqlDatabase) {
-            config.removeProperty("regions.sql");
-        } else {
-            log.warning("SQL support for WorldGuard region storage is deprecated for removal in a future version. Please migrate to YAML storage.");
-            log.warning("For details, see https://worldguard.enginehub.org/en/latest/regions/storage/");
-        }
 
         DataSourceConfig dataSourceConfig = new DataSourceConfig(sqlDsn, sqlUsername, sqlPassword, sqlTablePrefix);
         SQLDriver sqlDriver = new SQLDriver(dataSourceConfig);

worldguard-core/src/main/java/com/sk89q/worldguard/domains/DefaultDomain.java

@@ -311,7 +311,7 @@ public class DefaultDomain implements Domain, ChangeTracked {
     public String toGroupsString() {
         StringBuilder str = new StringBuilder();
         for (Iterator<String> it = groupDomain.getGroups().iterator(); it.hasNext(); ) {
-            str.append("g:");
+            str.append("*");
             str.append(it.next());
             if (it.hasNext()) {
                 str.append(", ");
@@ -373,8 +373,7 @@ public class DefaultDomain implements Domain, ChangeTracked {
     private Component toGroupsComponent() {
         final TextComponent.Builder builder = TextComponent.builder("");
         for (Iterator<String> it = groupDomain.getGroups().iterator(); it.hasNext(); ) {
-            builder.append(TextComponent.of("g:", TextColor.GRAY))
-                    .append(TextComponent.of(it.next(), TextColor.GOLD));
+            builder.append(TextComponent.of(it.next(), TextColor.GOLD));
             if (it.hasNext()) {
                 builder.append(TextComponent.of(", "));
             }
@@ -409,18 +408,15 @@ public class DefaultDomain implements Domain, ChangeTracked {
         final TextComponent.Builder builder = TextComponent.builder("");
         final Iterator<TextComponent> profiles = profileMap.keySet().stream().sorted().map(name -> {
             final UUID uuid = profileMap.get(name);
+            final TextComponent component = TextComponent.of(name, TextColor.YELLOW)
+                    .hoverEvent(HoverEvent.of(HoverEvent.Action.SHOW_TEXT, uuid == null
+                            ? TextComponent.of("Name only", TextColor.GRAY)
+                            : TextComponent.of("Last known name of uuid: ", TextColor.GRAY)
+                            .append(TextComponent.of(uuid.toString(), TextColor.WHITE))));
             if (uuid == null) {
-                return TextComponent.of(name, TextColor.YELLOW)
-                        .hoverEvent(HoverEvent.of(HoverEvent.Action.SHOW_TEXT, TextComponent.of("Name only", TextColor.GRAY)
-                            .append(TextComponent.newline()).append(TextComponent.of("Click to copy"))))
-                        .clickEvent(ClickEvent.of(ClickEvent.Action.COPY_TO_CLIPBOARD, name));
-            } else {
-                return TextComponent.of(name, TextColor.YELLOW)
-                        .hoverEvent(HoverEvent.of(HoverEvent.Action.SHOW_TEXT, TextComponent.of("Last known name of uuid: ", TextColor.GRAY)
-                            .append(TextComponent.of(uuid.toString(), TextColor.WHITE))
-                            .append(TextComponent.newline()).append(TextComponent.of("Click to copy"))))
-                        .clickEvent(ClickEvent.of(ClickEvent.Action.COPY_TO_CLIPBOARD, uuid.toString()));
+                return component;
             }
+            return component.clickEvent(ClickEvent.of(ClickEvent.Action.SUGGEST_COMMAND, uuid.toString()));
         }).iterator();
         while (profiles.hasNext()) {
             builder.append(profiles.next());
@@ -431,11 +427,9 @@ public class DefaultDomain implements Domain, ChangeTracked {
 
         if (!uuids.isEmpty()) {
             builder.append(TextComponent.of(uuids.size() + " unknown uuid" + (uuids.size() == 1 ? "" : "s"), TextColor.GRAY)
-                    .hoverEvent(HoverEvent.of(HoverEvent.Action.SHOW_TEXT, TextComponent.of("Unable to resolve the name for:", TextColor.GRAY)
-                        .append(TextComponent.newline())
-                        .append(TextComponent.of(String.join("\n", uuids), TextColor.WHITE))
-                        .append(TextComponent.newline().append(TextComponent.of("Click to copy")))))
-                    .clickEvent(ClickEvent.of(ClickEvent.Action.COPY_TO_CLIPBOARD, String.join(",", uuids))));
+                    .hoverEvent(HoverEvent.of(HoverEvent.Action.SHOW_TEXT, TextComponent.of(String.join("\n", uuids))
+                        .append(TextComponent.newline().append(TextComponent.of("Click to select")))))
+                    .clickEvent(ClickEvent.of(ClickEvent.Action.SUGGEST_COMMAND, String.join(",", uuids))));
         }
 
 

worldguard-core/src/main/java/com/sk89q/worldguard/domains/PlayerDomain.java

@@ -73,9 +73,7 @@ public class PlayerDomain implements Domain, ChangeTracked {
      * Add the given player to the domain, identified by the player's name.
      *
      * @param name the name of the player
-     * @deprecated names are deprecated in favor of UUIDs in MC 1.7+
      */
-    @Deprecated
     public void addPlayer(String name) {
         checkNotNull(name);
         if (!name.trim().isEmpty()) {
@@ -113,9 +111,7 @@ public class PlayerDomain implements Domain, ChangeTracked {
      * Remove the given player from the domain, identified by the player's name.
      *
      * @param name the name of the player
-     * @deprecated names are deprecated in favor of UUIDs in MC 1.7+
      */
-    @Deprecated
     public void removePlayer(String name) {
         checkNotNull(name);
         setDirty(true);
@@ -149,16 +145,14 @@ public class PlayerDomain implements Domain, ChangeTracked {
     @Override
     public boolean contains(LocalPlayer player) {
         checkNotNull(player);
-        return contains(player.getUniqueId()) || (!names.isEmpty() && contains(player.getName()));
+        return contains(player.getName().trim().toLowerCase()) || contains(player.getUniqueId());
     }
 
     /**
      * Get the set of player names.
      *
      * @return the set of player names
-     * @deprecated names are deprecated in favor of UUIDs in MC 1.7+
      */
-    @Deprecated
     public Set<String> getPlayers() {
         return Collections.unmodifiableSet(names);
     }

worldguard-core/src/main/java/com/sk89q/worldguard/internal/permission/RegionPermissionModel.java

@@ -63,11 +63,7 @@ public class RegionPermissionModel extends AbstractPermissionModel {
     public boolean mayMigrateRegionNames() {
         return hasPluginPermission("region.migrateuuid");
     }
-
-    public boolean mayMigrateRegionHeights() {
-        return hasPluginPermission("region.migrateheights");
-    }
-
+    
     public boolean mayDefine() {
         return hasPluginPermission("region.define");
     }
@@ -110,10 +106,6 @@ public class RegionPermissionModel extends AbstractPermissionModel {
         return hasPatternPermission("teleport", region);
     }
 
-    public boolean mayTeleportToCenter(ProtectedRegion region) {
-        return hasPatternPermission("teleportcenter", region);
-    }
-
     public boolean mayOverrideLocationFlagBounds(ProtectedRegion region) {
         return hasPatternPermission("locationoverride", region);
     }
@@ -133,7 +125,7 @@ public class RegionPermissionModel extends AbstractPermissionModel {
             return mayList();
         }
     }
-
+    
     public boolean maySetFlag(ProtectedRegion region) {
         return hasPatternPermission("flag.regions", region);
     }
@@ -203,4 +195,5 @@ public class RegionPermissionModel extends AbstractPermissionModel {
 
         return hasPluginPermission(effectivePerm);
     }
+
 }

worldguard-core/src/main/java/com/sk89q/worldguard/protection/ApplicableRegionSet.java

@@ -23,8 +23,6 @@ import com.sk89q.worldguard.LocalPlayer;
 import com.sk89q.worldguard.protection.association.RegionAssociable;
 import com.sk89q.worldguard.protection.flags.Flags;
 import com.sk89q.worldguard.protection.flags.Flag;
-import com.sk89q.worldguard.protection.flags.MapFlag;
-import com.sk89q.worldguard.protection.flags.RegionGroup;
 import com.sk89q.worldguard.protection.flags.StateFlag;
 import com.sk89q.worldguard.protection.flags.StateFlag.State;
 import com.sk89q.worldguard.protection.managers.RegionManager;
@@ -121,50 +119,6 @@ public interface ApplicableRegionSet extends Iterable<ProtectedRegion> {
     @Nullable
     <V> V queryValue(@Nullable RegionAssociable subject, Flag<V> flag);
 
-    /**
-     * Get the effective value for a key in a {@link MapFlag}. If there are multiple values
-     * (for example, if there are multiple regions with the same priority
-     * but with different farewell messages set, there would be multiple
-     * completing values), then the selected (or "winning") value will be undefined.
-     *
-     * <p>A subject can be provided that is used to determine whether the value
-     * of a flag on a particular region should be used. For example, if a
-     * flag's region group is set to {@link RegionGroup#MEMBERS} and the given
-     * subject is not a member, then the region would be skipped when
-     * querying that flag. If {@code null} is provided for the subject, then
-     * only flags that use {@link RegionGroup#ALL},
-     * {@link RegionGroup#NON_MEMBERS}, etc. will apply.</p>
-     *
-     * @param subject an optional subject, which would be used to determine the region group to apply
-     * @param flag the flag of type {@link MapFlag}
-     * @param key the key for the map flag
-     * @return a value, which could be {@code null}
-     */
-    @Nullable
-    <V, K> V queryMapValue(@Nullable RegionAssociable subject, MapFlag<K, V> flag, K key);
-
-    /**
-     * Get the effective value for a key in a {@link MapFlag}. If there are multiple values
-     * (for example, if there are multiple regions with the same priority
-     * but with different farewell messages set, there would be multiple
-     * completing values), then the selected (or "winning") value will be undefined.
-     *
-     * <p>A subject can be provided that is used to determine whether the value
-     * of a flag on a particular region should be used. For example, if a
-     * flag's region group is set to {@link RegionGroup#MEMBERS} and the given
-     * subject is not a member, then the region would be skipped when
-     * querying that flag. If {@code null} is provided for the subject, then
-     * only flags that use {@link RegionGroup#ALL},
-     * {@link RegionGroup#NON_MEMBERS}, etc. will apply.</p>
-     *
-     * @param subject an optional subject, which would be used to determine the region group to apply
-     * @param flag the flag of type {@link MapFlag}
-     * @param key the key for the map flag
-     * @return a value, which could be {@code null}
-     */
-    @Nullable
-    <V, K> V queryMapValue(@Nullable RegionAssociable subject, MapFlag<K, V> flag, K key, @Nullable Flag<V> fallback);
-
     /**
      * Get the effective values for a flag, returning a collection of all
      * values. It is up to the caller to determine which value, if any,

worldguard-core/src/main/java/com/sk89q/worldguard/protection/DelayedRegionOverlapAssociation.java

@@ -21,8 +21,16 @@ package com.sk89q.worldguard.protection;
 
 import com.sk89q.worldedit.util.Location;
 import com.sk89q.worldguard.protection.regions.RegionQuery;
+import com.sk89q.worldguard.domains.Association;
+import com.sk89q.worldguard.protection.ApplicableRegionSet;
+import com.sk89q.worldguard.protection.association.RegionAssociable;
+import com.sk89q.worldguard.protection.regions.ProtectedRegion;
 
+import javax.annotation.Nullable;
 import java.util.List;
+import java.util.Set;
+
+import static com.google.common.base.Preconditions.checkNotNull;
 
 /**
  * Determines that the association to a region is {@code OWNER} if the input
@@ -30,18 +38,41 @@ import java.util.List;
  *
  * <p>This class only performs a spatial query if its
  * {@link #getAssociation(List)} method is called.</p>
- *
- * @deprecated Use {@link com.sk89q.worldguard.protection.association.DelayedRegionOverlapAssociation} instead. This class is mis-packaged.
  */
-@Deprecated
-public class DelayedRegionOverlapAssociation extends com.sk89q.worldguard.protection.association.DelayedRegionOverlapAssociation {
+public class DelayedRegionOverlapAssociation implements RegionAssociable {
+
+    private final RegionQuery query;
+    private final Location location;
+    @Nullable
+    private Set<ProtectedRegion> source;
+
     /**
      * Create a new instance.
+     *
      * @param query the query
      * @param location the location
      */
     public DelayedRegionOverlapAssociation(RegionQuery query, Location location) {
-        super(query, location, false);
+        checkNotNull(query);
+        checkNotNull(location);
+        this.query = query;
+        this.location = location;
+    }
+
+    @Override
+    public Association getAssociation(List<ProtectedRegion> regions) {
+        if (source == null) {
+            ApplicableRegionSet result = query.getApplicableRegions(location);
+            source = result.getRegions();
+        }
+
+        for (ProtectedRegion region : regions) {
+            if ((region.getId().equals(ProtectedRegion.GLOBAL_REGION) && source.isEmpty()) || source.contains(region)) {
+                return Association.OWNER;
+            }
+        }
+
+        return Association.NON_MEMBER;
     }
 
 }

worldguard-core/src/main/java/com/sk89q/worldguard/protection/FailedLoadRegionSet.java

@@ -24,7 +24,6 @@ import com.sk89q.worldguard.LocalPlayer;
 import com.sk89q.worldguard.protection.association.RegionAssociable;
 import com.sk89q.worldguard.protection.flags.Flags;
 import com.sk89q.worldguard.protection.flags.Flag;
-import com.sk89q.worldguard.protection.flags.MapFlag;
 import com.sk89q.worldguard.protection.flags.StateFlag.State;
 import com.sk89q.worldguard.protection.regions.ProtectedRegion;
 
@@ -32,7 +31,6 @@ import javax.annotation.Nullable;
 import java.util.Collection;
 import java.util.Collections;
 import java.util.Iterator;
-import java.util.Map;
 import java.util.Set;
 
 /**
@@ -67,19 +65,6 @@ public class FailedLoadRegionSet extends AbstractRegionSet {
         return flag.getDefault();
     }
 
-    @Nullable
-    @Override
-    public <V, K> V queryMapValue(@Nullable RegionAssociable subject, MapFlag<K, V> flag, K key) {
-        return queryMapValue(subject, flag, key, null);
-    }
-
-    @Nullable
-    @Override
-    public <V, K> V queryMapValue(@Nullable RegionAssociable subject, MapFlag<K, V> flag, K key, @Nullable Flag<V> fallback) {
-        Map<K, V> defaultVal = flag.getDefault();
-        return defaultVal != null ? defaultVal.get(key) : fallback != null ? fallback.getDefault() : null;
-    }
-
     @SuppressWarnings("unchecked")
     @Override
     public <V> Collection<V> queryAllValues(@Nullable RegionAssociable subject, Flag<V> flag) {

worldguard-core/src/main/java/com/sk89q/worldguard/protection/FlagValueCalculator.java

@@ -26,7 +26,6 @@ import com.sk89q.worldguard.domains.Association;
 import com.sk89q.worldguard.protection.association.RegionAssociable;
 import com.sk89q.worldguard.protection.flags.Flags;
 import com.sk89q.worldguard.protection.flags.Flag;
-import com.sk89q.worldguard.protection.flags.MapFlag;
 import com.sk89q.worldguard.protection.flags.RegionGroup;
 import com.sk89q.worldguard.protection.flags.StateFlag;
 import com.sk89q.worldguard.protection.flags.StateFlag.State;
@@ -90,14 +89,13 @@ public class FlagValueCalculator {
     /**
      * Return the membership status of the given subject, indicating
      * whether there are no (counted) regions in the list of regions,
-     * whether the subject is a member of all (counted) regions, or
-     * whether the subject is not a member of all (counted) regions.
+     * whether the subject is a member of all regions, or whether
+     * the region is not a member of all regions.
      *
      * <p>A region is "counted" if it doesn't have the
-     * {@link Flags#PASSTHROUGH} flag set to {@code ALLOW} and if
-     * there isn't another "counted" region with a higher priority.
-     * (The explicit purpose of the PASSTHROUGH flag is to have the
-     * region be skipped over in this check.)</p>
+     * {@link Flags#PASSTHROUGH} flag set to {@code ALLOW}. (The
+     * explicit purpose of the PASSTHROUGH flag is to have the region
+     * be skipped over in this check.)</p>
      *
      * <p>This method is mostly for internal use. It's not particularly
      * useful.</p>
@@ -114,13 +112,11 @@ public class FlagValueCalculator {
         Set<ProtectedRegion> ignoredRegions = Sets.newHashSet();
 
         for (ProtectedRegion region : getApplicable()) {
-            int priority = getPriority(region);
-
             // Don't consider lower priorities below minimumPriority
             // (which starts at Integer.MIN_VALUE). A region that "counts"
             // (has the flag set OR has members) will raise minimumPriority
             // to its own priority.
-            if (priority < minimumPriority) {
+            if (getPriority(region) < minimumPriority) {
                 break;
             }
 
@@ -133,7 +129,7 @@ public class FlagValueCalculator {
                 continue;
             }
 
-            minimumPriority = priority;
+            minimumPriority = getPriority(region);
 
             boolean member = RegionGroup.MEMBERS.contains(subject.getAssociation(Collections.singletonList(region)));
 
@@ -228,117 +224,6 @@ public class FlagValueCalculator {
         return flag.chooseValue(values);
     }
 
-    /**
-     * Get the effective value for a key in a {@link MapFlag}. If there are multiple values
-     * (for example, if there are multiple regions with the same priority
-     * but with different farewell messages set, there would be multiple
-     * completing values), then the selected (or "winning") value will be undefined.
-     *
-     * <p>A subject can be provided that is used to determine whether the value
-     * of a flag on a particular region should be used. For example, if a
-     * flag's region group is set to {@link RegionGroup#MEMBERS} and the given
-     * subject is not a member, then the region would be skipped when
-     * querying that flag. If {@code null} is provided for the subject, then
-     * only flags that use {@link RegionGroup#ALL},
-     * {@link RegionGroup#NON_MEMBERS}, etc. will apply.</p>
-     *
-     * @param subject an optional subject, which would be used to determine the region group to apply
-     * @param flag the flag of type {@link MapFlag}
-     * @param key the key for the map flag
-     * @return a value, which could be {@code null}
-     */
-    @Nullable
-    public <V, K> V queryMapValue(@Nullable RegionAssociable subject, MapFlag<K, V> flag, K key, Flag<V> fallback) {
-        checkNotNull(flag);
-        checkNotNull(key);
-
-        Map<ProtectedRegion, V> consideredValues = new HashMap<>();
-        Map<ProtectedRegion, V> fallbackValues = new HashMap<>();
-        int minimumPriority = Integer.MIN_VALUE;
-        Set<ProtectedRegion> ignoredParents = new HashSet<>();
-
-        for(ProtectedRegion region : getApplicable()) {
-            int priority = getPriority(region);
-
-            if (priority < minimumPriority) {
-                break;
-            }
-
-            if (ignoredParents.contains(region)) {
-                continue;
-            }
-
-            V effectiveValue = getEffectiveMapValue(region, flag, key, subject);
-
-            if (effectiveValue != null) {
-                minimumPriority = priority;
-                consideredValues.put(region, effectiveValue);
-            } else if (fallback != null) {
-                effectiveValue = getEffectiveFlag(region, fallback, subject);
-                if (effectiveValue != null) {
-                    minimumPriority = priority;
-                    fallbackValues.put(region, effectiveValue);
-                }
-            }
-
-            addParents(ignoredParents, region);
-        }
-
-
-        if (consideredValues.isEmpty()) {
-            if (fallback != null && !fallbackValues.isEmpty()) {
-                return fallback.chooseValue(fallbackValues.values());
-            }
-            V defaultValue = flag.getValueFlag().getDefault();
-            return defaultValue != null ? defaultValue : fallback != null ? fallback.getDefault() : null;
-        }
-
-        return flag.getValueFlag().chooseValue(consideredValues.values());
-    }
-
-    @Nullable
-    public <V, K> V getEffectiveMapValue(ProtectedRegion region, MapFlag<K, V> mapFlag, K key, RegionAssociable subject) {
-        return getEffectiveMapValueOf(region, mapFlag, key, subject);
-    }
-
-    @Nullable
-    public static <V, K> V getEffectiveMapValueOf(ProtectedRegion region, MapFlag<K, V> mapFlag, K key, RegionAssociable subject) {
-        List<ProtectedRegion> seen = new ArrayList<>();
-        ProtectedRegion current = region;
-
-        while (current != null) {
-            seen.add(current);
-
-            Map<K, V> mapValue = current.getFlag(mapFlag);
-
-            if (mapValue != null && mapValue.containsKey(key)) {
-                boolean use = true;
-
-                if (mapFlag.getRegionGroupFlag() != null) {
-                    RegionGroup group = current.getFlag(mapFlag.getRegionGroupFlag());
-                    if (group == null) {
-                        group = mapFlag.getRegionGroupFlag().getDefault();
-                    }
-
-                    if (group == null) {
-                        use = false;
-                    } else if (subject == null) {
-                        use = group.contains(Association.NON_MEMBER);
-                    } else if (!group.contains(subject.getAssociation(seen))) {
-                        use = false;
-                    }
-                }
-
-                if (use) {
-                    return mapValue.get(key);
-                }
-            }
-
-            current = current.getParent();
-        }
-        return null;
-    }
-
     /**
      * Get the effective values for a flag, returning a collection of all
      * values. It is up to the caller to determine which value, if any,
@@ -398,9 +283,7 @@ public class FlagValueCalculator {
         Set<ProtectedRegion> ignoredParents = new HashSet<>();
 
         for (ProtectedRegion region : getApplicable()) {
-            int priority = getPriority(region);
-
-            if (priority < minimumPriority) {
+            if (getPriority(region) < minimumPriority) {
                 break;
             }
 
@@ -409,6 +292,7 @@ public class FlagValueCalculator {
             }
 
             V value = getEffectiveFlag(region, flag, subject);
+            int priority = getPriority(region);
 
             if (value != null) {
                 minimumPriority = priority;
@@ -426,7 +310,7 @@ public class FlagValueCalculator {
             // PASSTHROUGH is not set to ALLOW
             if (priority != minimumPriority && flag.implicitlySetWithMembership()
                     && getEffectiveFlag(region, Flags.PASSTHROUGH, subject) != State.ALLOW) {
-                minimumPriority = priority;
+                minimumPriority = getPriority(region);
             }
         }
 
@@ -455,11 +339,7 @@ public class FlagValueCalculator {
      * @return the priority
      */
     public int getPriority(final ProtectedRegion region) {
-        return getPriorityOf(region);
-    }
-
-    public static int getPriorityOf(final ProtectedRegion region) {
-        if (region.getId().equals(ProtectedRegion.GLOBAL_REGION)) {
+        if (region == globalRegion) {
             return Integer.MIN_VALUE;
         } else {
             return region.getPriority();
@@ -475,20 +355,13 @@ public class FlagValueCalculator {
      * @param subject an subject object
      * @return the value
      */
-    @Nullable
-    public <V> V getEffectiveFlag(final ProtectedRegion region, Flag<V> flag, @Nullable RegionAssociable subject) {
-        return getEffectiveFlagOf(region, flag, subject);
-    }
-
     @SuppressWarnings("unchecked")
-    @Nullable
-    public static <V> V getEffectiveFlagOf(final ProtectedRegion region, Flag<V> flag, @Nullable RegionAssociable subject) {
-        if (region.getId().equals(ProtectedRegion.GLOBAL_REGION)) {
+    public <V> V getEffectiveFlag(final ProtectedRegion region, Flag<V> flag, @Nullable RegionAssociable subject) {
+        if (region == globalRegion) {
             if (flag == Flags.PASSTHROUGH) {
                 // Has members/owners -> the global region acts like
                 // a regular region without PASSTHROUGH
-                State passthrough = region.getFlag(Flags.PASSTHROUGH);
-                if (passthrough == State.DENY || passthrough != State.ALLOW && region.hasMembersOrOwners()) {
+                if (region.hasMembersOrOwners() || region.getFlag(Flags.PASSTHROUGH) == State.DENY) {
                     return null;
                 } else {
                     return (V) State.ALLOW;

worldguard-core/src/main/java/com/sk89q/worldguard/protection/PermissiveRegionSet.java

@@ -24,7 +24,6 @@ import com.sk89q.worldguard.LocalPlayer;
 import com.sk89q.worldguard.protection.association.RegionAssociable;
 import com.sk89q.worldguard.protection.flags.Flags;
 import com.sk89q.worldguard.protection.flags.Flag;
-import com.sk89q.worldguard.protection.flags.MapFlag;
 import com.sk89q.worldguard.protection.flags.StateFlag.State;
 import com.sk89q.worldguard.protection.regions.ProtectedRegion;
 
@@ -32,7 +31,6 @@ import javax.annotation.Nullable;
 import java.util.Collection;
 import java.util.Collections;
 import java.util.Iterator;
-import java.util.Map;
 import java.util.Set;
 
 /**
@@ -61,19 +59,6 @@ public class PermissiveRegionSet extends AbstractRegionSet {
         return flag.getDefault();
     }
 
-    @Nullable
-    @Override
-    public <V, K> V queryMapValue(@Nullable RegionAssociable subject, MapFlag<K, V> flag, K key) {
-        return queryMapValue(subject, flag, key, null);
-    }
-
-    @Nullable
-    @Override
-    public <V, K> V queryMapValue(@Nullable RegionAssociable subject, MapFlag<K, V> flag, K key, @Nullable Flag<V> fallback) {
-        Map<K, V> defaultVal = flag.getDefault();
-        return defaultVal != null ? defaultVal.get(key) : fallback != null ? fallback.getDefault() : null;
-    }
-
     @SuppressWarnings("unchecked")
     @Override
     public <V> Collection<V> queryAllValues(@Nullable RegionAssociable subject, Flag<V> flag) {

worldguard-core/src/main/java/com/sk89q/worldguard/protection/RegionResultSet.java

@@ -19,22 +19,16 @@
 
 package com.sk89q.worldguard.protection;
 
-import com.google.common.collect.ImmutableSet;
 import com.sk89q.worldguard.LocalPlayer;
 import com.sk89q.worldguard.protection.association.RegionAssociable;
 import com.sk89q.worldguard.protection.flags.Flag;
-import com.sk89q.worldguard.protection.flags.MapFlag;
 import com.sk89q.worldguard.protection.flags.StateFlag;
 import com.sk89q.worldguard.protection.flags.StateFlag.State;
 import com.sk89q.worldguard.protection.regions.ProtectedRegion;
 import com.sk89q.worldguard.protection.util.NormativeOrders;
 
 import javax.annotation.Nullable;
-import java.util.Collection;
-import java.util.Collections;
-import java.util.Iterator;
-import java.util.List;
-import java.util.Set;
+import java.util.*;
 
 import static com.google.common.base.Preconditions.checkNotNull;
 
@@ -69,7 +63,7 @@ public class RegionResultSet extends AbstractRegionSet {
      */
     public RegionResultSet(Set<ProtectedRegion> applicable, @Nullable ProtectedRegion globalRegion) {
         this(NormativeOrders.fromSet(applicable), globalRegion, true);
-        this.regionSet = ImmutableSet.copyOf(applicable);
+        this.regionSet = applicable;
     }
 
     /**
@@ -88,7 +82,7 @@ public class RegionResultSet extends AbstractRegionSet {
         if (!sorted) {
             NormativeOrders.sort(applicable);
         }
-        this.applicable = Collections.unmodifiableList(applicable);
+        this.applicable = applicable;
         this.flagValueCalculator = new FlagValueCalculator(applicable, globalRegion);
     }
 
@@ -114,18 +108,6 @@ public class RegionResultSet extends AbstractRegionSet {
         return flagValueCalculator.queryAllValues(subject, flag);
     }
 
-    @Override
-    @Nullable
-    public <V, K> V queryMapValue(@Nullable RegionAssociable subject, MapFlag<K, V> flag, K key) {
-        return flagValueCalculator.queryMapValue(subject, flag, key, null);
-    }
-
-    @Override
-    @Nullable
-    public <V, K> V queryMapValue(@Nullable RegionAssociable subject, MapFlag<K, V> flag, K key, Flag<V> fallback) {
-        return flagValueCalculator.queryMapValue(subject, flag, key, fallback);
-    }
-
     @Override
     public boolean isOwnerOfAll(LocalPlayer player) {
         checkNotNull(player);
@@ -162,7 +144,7 @@ public class RegionResultSet extends AbstractRegionSet {
         if (regionSet != null) {
             return regionSet;
         }
-        regionSet = ImmutableSet.copyOf(applicable);
+        regionSet = Collections.unmodifiableSet(new HashSet<>(applicable));
         return regionSet;
     }
 

worldguard-core/src/main/java/com/sk89q/worldguard/protection/association/AbstractRegionOverlapAssociation.java

@@ -1,127 +0,0 @@
-/*
- * WorldGuard, a suite of tools for Minecraft
- * Copyright (C) sk89q <http://www.sk89q.com>
- * Copyright (C) WorldGuard team and contributors
- *
- * This program is free software: you can redistribute it and/or modify it
- * under the terms of the GNU Lesser General Public License as published by the
- * Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License
- * for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-package com.sk89q.worldguard.protection.association;
-
-import static com.google.common.base.Preconditions.checkNotNull;
-
-import com.sk89q.worldguard.domains.Association;
-import com.sk89q.worldguard.protection.FlagValueCalculator;
-import com.sk89q.worldguard.protection.flags.Flags;
-import com.sk89q.worldguard.protection.regions.ProtectedRegion;
-
-import javax.annotation.Nullable;
-import java.util.Collection;
-import java.util.Collections;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Set;
-
-public abstract class AbstractRegionOverlapAssociation implements RegionAssociable {
-
-    @Nullable
-    protected Set<ProtectedRegion> source;
-    private boolean useMaxPriorityAssociation;
-    private int maxPriority;
-    private Set<ProtectedRegion> maxPriorityRegions;
-
-    protected AbstractRegionOverlapAssociation(@Nullable Set<ProtectedRegion> source, boolean useMaxPriorityAssociation) {
-        this.source = source;
-        this.useMaxPriorityAssociation = useMaxPriorityAssociation;
-    }
-
-    protected void calcMaxPriority() {
-        checkNotNull(source);
-        int best = 0;
-        Set<ProtectedRegion> bestRegions = new HashSet<>();
-        for (ProtectedRegion region : source) {
-            int priority = region.getPriority();
-            if (priority > best) {
-                best = priority;
-                bestRegions.clear();
-                bestRegions.add(region);
-            } else if (priority == best) {
-                bestRegions.add(region);
-            }
-        }
-        this.maxPriority = best;
-        this.maxPriorityRegions = bestRegions;
-    }
-
-    private boolean checkNonplayerProtectionDomains(Iterable<? extends ProtectedRegion> source, Collection<?> domains) {
-        if (source == null || domains == null || domains.isEmpty()) {
-            return false;
-        }
-
-        for (ProtectedRegion region : source) {
-            // Potential endless recurrence? No, because there is no region group flag.
-            Set<String> regionDomains = FlagValueCalculator.getEffectiveFlagOf(region, Flags.NONPLAYER_PROTECTION_DOMAINS, this);
-
-            if (regionDomains == null || regionDomains.isEmpty()) {
-                continue;
-            }
-
-            if (!Collections.disjoint(regionDomains, domains)) {
-                return true;
-            }
-        }
-
-        return false;
-    }
-
-    @Override
-    public Association getAssociation(List<ProtectedRegion> regions) {
-        checkNotNull(source);
-        for (ProtectedRegion region : regions) {
-            while (region != null) {
-                if ((region.getId().equals(ProtectedRegion.GLOBAL_REGION) && source.isEmpty())) {
-                    return Association.OWNER;
-                }
-
-                if (source.contains(region)) {
-                    if (useMaxPriorityAssociation) {
-                        int priority = region.getPriority();
-                        if (priority == maxPriority) {
-                            return Association.OWNER;
-                        }
-                    } else {
-                        return Association.OWNER;
-                    }
-                }
-
-                Set<ProtectedRegion> source;
-
-                if (useMaxPriorityAssociation) {
-                    source = maxPriorityRegions;
-                } else {
-                    source = this.source;
-                }
-
-                // Potential endless recurrence? No, because there is no region group flag.
-                if (checkNonplayerProtectionDomains(source, FlagValueCalculator.getEffectiveFlagOf(region, Flags.NONPLAYER_PROTECTION_DOMAINS, this))) {
-                    return Association.OWNER;
-                }
-
-                region = region.getParent();
-            }
-        }
-
-        return Association.NON_MEMBER;
-    }
-}

worldguard-core/src/main/java/com/sk89q/worldguard/protection/association/DelayedRegionOverlapAssociation.java

@@ -1,79 +0,0 @@
-/*
- * WorldGuard, a suite of tools for Minecraft
- * Copyright (C) sk89q <http://www.sk89q.com>
- * Copyright (C) WorldGuard team and contributors
- *
- * This program is free software: you can redistribute it and/or modify it
- * under the terms of the GNU Lesser General Public License as published by the
- * Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License
- * for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-package com.sk89q.worldguard.protection.association;
-
-import static com.google.common.base.Preconditions.checkNotNull;
-
-import com.sk89q.worldedit.util.Location;
-import com.sk89q.worldguard.domains.Association;
-import com.sk89q.worldguard.protection.ApplicableRegionSet;
-import com.sk89q.worldguard.protection.regions.ProtectedRegion;
-import com.sk89q.worldguard.protection.regions.RegionQuery;
-import com.sk89q.worldguard.protection.regions.RegionQuery.QueryOption;
-
-import java.util.List;
-
-/**
- * Determines that the association to a region is {@code OWNER} if the input
- * region is in a set of source regions.
- *
- * <p>This class only performs a spatial query if its
- * {@link #getAssociation(List)} method is called.</p>
- */
-public class DelayedRegionOverlapAssociation extends AbstractRegionOverlapAssociation {
-
-    private final RegionQuery query;
-    private final Location location;
-
-    /**
-     * Create a new instance.
-     * @param query the query
-     * @param location the location
-     */
-    public DelayedRegionOverlapAssociation(RegionQuery query, Location location) {
-        this(query, location, false);
-    }
-
-    /**
-     * Create a new instance.
-     * @param query the query
-     * @param location the location
-     * @param useMaxPriorityAssociation whether to use the max priority from regions to determine association
-     */
-    public DelayedRegionOverlapAssociation(RegionQuery query, Location location, boolean useMaxPriorityAssociation) {
-        super(null, useMaxPriorityAssociation);
-        checkNotNull(query);
-        checkNotNull(location);
-        this.query = query;
-        this.location = location;
-    }
-
-    @Override
-    public Association getAssociation(List<ProtectedRegion> regions) {
-        if (source == null) {
-            ApplicableRegionSet result = query.getApplicableRegions(location, QueryOption.NONE);
-            source = result.getRegions();
-            calcMaxPriority();
-        }
-
-        return super.getAssociation(regions);
-    }
-
-}

worldguard-core/src/main/java/com/sk89q/worldguard/protection/association/RegionOverlapAssociation.java

@@ -19,35 +19,41 @@
 
 package com.sk89q.worldguard.protection.association;
 
+import com.sk89q.worldguard.domains.Association;
 import com.sk89q.worldguard.protection.regions.ProtectedRegion;
 
-import javax.annotation.Nonnull;
+import java.util.List;
 import java.util.Set;
 
+import static com.google.common.base.Preconditions.checkNotNull;
+
 /**
  * Determines that the association to a region is {@code OWNER} if the input
  * region is in a set of source regions.
  */
-public class RegionOverlapAssociation extends AbstractRegionOverlapAssociation {
+public class RegionOverlapAssociation implements RegionAssociable {
+
+    private final Set<ProtectedRegion> source;
 
     /**
      * Create a new instance.
      *
      * @param source set of regions that input regions must be contained within
      */
-    public RegionOverlapAssociation(@Nonnull Set<ProtectedRegion> source) {
-        this(source, false);
+    public RegionOverlapAssociation(Set<ProtectedRegion> source) {
+        checkNotNull(source);
+        this.source = source;
     }
 
-    /**
-     * Create a new instance.
-     *
-     * @param source set of regions that input regions must be contained within
-     * @param useMaxPriorityAssociation whether to use the max priority from regions to determine association
-     */
-    public RegionOverlapAssociation(@Nonnull Set<ProtectedRegion> source, boolean useMaxPriorityAssociation) {
-        super(source, useMaxPriorityAssociation);
-        calcMaxPriority();
+    @Override
+    public Association getAssociation(List<ProtectedRegion> regions) {
+        for (ProtectedRegion region : regions) {
+            if ((region.getId().equals(ProtectedRegion.GLOBAL_REGION) && source.isEmpty()) || source.contains(region)) {
+                return Association.OWNER;
+            }
+        }
+
+        return Association.NON_MEMBER;
     }
 
 }

worldguard-core/src/main/java/com/sk89q/worldguard/protection/flags/EntityTypeFlag.java

@@ -26,9 +26,7 @@ import javax.annotation.Nullable;
 
 /**
  * Stores an entity type.
- * @deprecated replaced by {@link RegistryFlag<EntityType>}, will be removed in WorldGuard 8
  */
-@Deprecated
 public class EntityTypeFlag extends Flag<EntityType> {
 
     protected EntityTypeFlag(String name, @Nullable RegionGroup defaultGroup) {
@@ -57,6 +55,6 @@ public class EntityTypeFlag extends Flag<EntityType> {
 
     @Override
     public Object marshal(EntityType o) {
-        return o.id();
+        return o.getId();
     }
 }

worldguard-core/src/main/java/com/sk89q/worldguard/protection/flags/FlagUtil.java

@@ -48,7 +48,7 @@ public final class FlagUtil {
         for (Entry<Flag<?>, Object> entry : values.entrySet()) {
             try {
                 rawValues.put(entry.getKey().getName(), marshal(entry.getKey(), entry.getValue()));
-            } catch (Throwable e) {
+            } catch (Exception e) {
                 log.log(Level.WARNING, "Failed to marshal flag value for " + entry.getKey() + "; value is " + entry.getValue(), e);
             }
         }

worldguard-core/src/main/java/com/sk89q/worldguard/protection/flags/Flags.java

@@ -46,7 +46,6 @@ public final class Flags {
 
     // Overrides membership check
     public static final StateFlag PASSTHROUGH = register(new StateFlag("passthrough", false));
-    public static final SetFlag<String> NONPLAYER_PROTECTION_DOMAINS = register(new SetFlag<>("nonplayer-protection-domains", null, new StringFlag(null)));
 
     // This flag is unlike the others. It forces the checking of region membership
     public static final StateFlag BUILD = register(new BuildFlag("build", true));
@@ -61,7 +60,6 @@ public final class Flags {
     public static final StateFlag DAMAGE_ANIMALS = register(new StateFlag("damage-animals", false));
     public static final StateFlag PVP = register(new StateFlag("pvp", false));
     public static final StateFlag SLEEP = register(new StateFlag("sleep", false));
-    public static final StateFlag RESPAWN_ANCHORS = register(new StateFlag("respawn-anchors", false));
     public static final StateFlag TNT = register(new StateFlag("tnt", false));
     public static final StateFlag CHEST_ACCESS = register(new StateFlag("chest-access", false));
     public static final StateFlag PLACE_VEHICLE = register(new StateFlag("vehicle-place", false));
@@ -72,8 +70,6 @@ public final class Flags {
     public static final StateFlag ITEM_FRAME_ROTATE = register(new StateFlag("item-frame-rotation", false));
     public static final StateFlag TRAMPLE_BLOCKS = register(new StateFlag("block-trampling", false));
     public static final StateFlag FIREWORK_DAMAGE = register(new StateFlag("firework-damage", false));
-    public static final StateFlag USE_ANVIL = register(new StateFlag("use-anvil", false));
-    public static final StateFlag USE_DRIPLEAF = register(new StateFlag("use-dripleaf", false));
 
     // These flags are similar to the ones above (used in tandem with BUILD),
     // but their defaults are set to TRUE because it is more user friendly.
@@ -120,12 +116,8 @@ public final class Flags {
     public static final StateFlag GRASS_SPREAD = register(new StateFlag("grass-growth", true));
     public static final StateFlag MYCELIUM_SPREAD = register(new StateFlag("mycelium-spread", true));
     public static final StateFlag VINE_GROWTH = register(new StateFlag("vine-growth", true));
-    public static final StateFlag ROCK_GROWTH = register(new StateFlag("rock-growth", true));
-    public static final StateFlag SCULK_GROWTH = register (new StateFlag("sculk-growth", true));
     public static final StateFlag CROP_GROWTH = register(new StateFlag("crop-growth", true));
     public static final StateFlag SOIL_DRY = register(new StateFlag("soil-dry", true));
-    public static final StateFlag CORAL_FADE = register(new StateFlag("coral-fade", true));
-    public static final StateFlag COPPER_FADE = register(new StateFlag("copper-fade", true));
     public static final StateFlag WATER_FLOW = register(new StateFlag("water-flow", true));
     public static final StateFlag LAVA_FLOW = register(new StateFlag("lava-flow", true));
 
@@ -139,23 +131,12 @@ public final class Flags {
     public static final SetFlag<String> ALLOWED_CMDS = register(new SetFlag<>("allowed-cmds", new CommandStringFlag(null)));
 
     // locations
-    public static final LocationFlag TELE_LOC = register(new LocationFlag("teleport"));
+    public static final LocationFlag TELE_LOC = register(new LocationFlag("teleport", RegionGroup.MEMBERS));
     public static final LocationFlag SPAWN_LOC = register(new LocationFlag("spawn", RegionGroup.MEMBERS));
 
-    /**
-     * @deprecated The type of this flag will change from a StringFlag to a ComponentFlag to support JSON text
-     *              in a future release. If you depend on the type of this flag, take proper precaution for future breakage.
-     */
-    @Deprecated
-    public static final StringFlag TELE_MESSAGE = register(new StringFlag("teleport-message",
-            LegacyComponentSerializer.INSTANCE.serialize(TextComponent.of("").append(TextComponent.of(
-                    "Teleported you to the region '%id%'.", TextColor.LIGHT_PURPLE)))));
-
     // idk?
     public static final StateFlag INVINCIBILITY = register(new StateFlag("invincible", false));
     public static final StateFlag FALL_DAMAGE = register(new StateFlag("fall-damage", true));
-    public static final StateFlag HEALTH_REGEN = register(new StateFlag("natural-health-regen", true));
-    public static final StateFlag HUNGER_DRAIN = register(new StateFlag("natural-hunger-drain", true));
 
     // session and movement based flags
     public static final StateFlag ENTRY = register(new StateFlag("entry", true, RegionGroup.NON_MEMBERS));
@@ -166,29 +147,9 @@ public final class Flags {
     public static final StateFlag ENDERPEARL = register(new StateFlag("enderpearl", true));
     public static final StateFlag CHORUS_TELEPORT = register(new StateFlag("chorus-fruit-teleport", true));
 
-    /**
-     * @deprecated The type of this flag will change from a StringFlag to a ComponentFlag to support JSON text
-     *              in a future release. If you depend on the type of this flag, take proper precaution for future breakage.
-     */
-    @Deprecated
     public static final StringFlag GREET_MESSAGE = register(new StringFlag("greeting"));
-    /**
-     * @deprecated The type of this flag will change from a StringFlag to a ComponentFlag to support JSON text
-     *              in a future release. If you depend on the type of this flag, take proper precaution for future breakage.
-     */
-    @Deprecated
     public static final StringFlag FAREWELL_MESSAGE = register(new StringFlag("farewell"));
-    /**
-     * @deprecated The type of this flag will change from a StringFlag to a ComponentFlag to support JSON text
-     *              in a future release. If you depend on the type of this flag, take proper precaution for future breakage.
-     */
-    @Deprecated
     public static final StringFlag GREET_TITLE = register(new StringFlag("greeting-title"));
-    /**
-     * @deprecated The type of this flag will change from a StringFlag to a ComponentFlag to support JSON text
-     *              in a future release. If you depend on the type of this flag, take proper precaution for future breakage.
-     */
-    @Deprecated
     public static final StringFlag FAREWELL_TITLE = register(new StringFlag("farewell-title"));
 
     public static final BooleanFlag NOTIFY_ENTER = register(new BooleanFlag("notify-enter"));
@@ -212,29 +173,14 @@ public final class Flags {
     public static final IntegerFlag MAX_FOOD = register(new IntegerFlag("feed-max-hunger"), f -> f.setSuggestedValues(VITALS_MAXS));
 
     // deny messages
-    /**
-     * @deprecated The type of this flag will change from a StringFlag to a ComponentFlag to support JSON text
-     *              in a future release. If you depend on the type of this flag, take proper precaution for future breakage.
-     */
-    @Deprecated
     public static final StringFlag DENY_MESSAGE = register(new StringFlag("deny-message",
             LegacyComponentSerializer.INSTANCE.serialize(TextComponent.of("").append(TextComponent.of("Hey!",
                     TextColor.RED, Sets.newHashSet(TextDecoration.BOLD)))
                     .append(TextComponent.of(" Sorry, but you can't %what% here.", TextColor.GRAY)))));
-    /**
-     * @deprecated The type of this flag will change from a StringFlag to a ComponentFlag to support JSON text
-     *              in a future release. If you depend on the type of this flag, take proper precaution for future breakage.
-     */
-    @Deprecated
     public static final StringFlag ENTRY_DENY_MESSAGE = register(new StringFlag("entry-deny-message",
             LegacyComponentSerializer.INSTANCE.serialize(TextComponent.of("").append(TextComponent.of("Hey!",
                     TextColor.RED, Sets.newHashSet(TextDecoration.BOLD)))
                     .append(TextComponent.of(" You are not permitted to enter this area.", TextColor.GRAY)))));
-    /**
-     * @deprecated The type of this flag will change from a StringFlag to a ComponentFlag to support JSON text
-     *              in a future release. If you depend on the type of this flag, take proper precaution for future breakage.
-     */
-    @Deprecated
     public static final StringFlag EXIT_DENY_MESSAGE = register(new StringFlag("exit-deny-message",
             LegacyComponentSerializer.INSTANCE.serialize(TextComponent.of("").append(TextComponent.of("Hey!",
                     TextColor.RED, Sets.newHashSet(TextDecoration.BOLD)))

worldguard-core/src/main/java/com/sk89q/worldguard/protection/flags/GameModeTypeFlag.java

@@ -24,11 +24,6 @@ import com.sk89q.worldedit.world.gamemode.GameModes;
 
 import javax.annotation.Nullable;
 
-/**
- * Stores an gamemode type.
- * @deprecated replaced by {@link RegistryFlag<GameMode>}, will be removed in WorldGuard 8
- */
-@Deprecated
 public class GameModeTypeFlag extends Flag<GameMode> {
 
     protected GameModeTypeFlag(String name, @Nullable RegionGroup defaultGroup) {
@@ -57,6 +52,6 @@ public class GameModeTypeFlag extends Flag<GameMode> {
 
     @Override
     public Object marshal(GameMode o) {
-        return o.id();
+        return o.getId();
     }
 }

worldguard-core/src/main/java/com/sk89q/worldguard/protection/flags/LocationFlag.java

@@ -137,9 +137,9 @@ public class LocationFlag extends Flag<Location> {
                 return null;
             }
         }
-        vec.put("x", position.x());
-        vec.put("y", position.y());
-        vec.put("z", position.z());
+        vec.put("x", position.getX());
+        vec.put("y", position.getY());
+        vec.put("z", position.getZ());
         vec.put("yaw", o.getYaw());
         vec.put("pitch", o.getPitch());
         return vec;

worldguard-core/src/main/java/com/sk89q/worldguard/protection/flags/MapFlag.java

@@ -25,8 +25,6 @@ import javax.annotation.Nullable;
 import java.util.Map;
 import java.util.Map.Entry;
 
-import static java.util.Objects.requireNonNull;
-
 /**
  * Stores a key value map of typed {@link Flag}s.
  */
@@ -37,16 +35,12 @@ public class MapFlag<K, V> extends Flag<Map<K, V>> {
 
     public MapFlag(final String name, final Flag<K> keyFlag, final Flag<V> valueFlag) {
         super(name);
-        requireNonNull(keyFlag, "keyFlag cannot be null.");
-        requireNonNull(valueFlag, "valueFlag cannot be null.");
         this.keyFlag = keyFlag;
         this.valueFlag = valueFlag;
     }
 
     public MapFlag(final String name, @Nullable final RegionGroup defaultGroup, final Flag<K> keyFlag, final Flag<V> valueFlag) {
         super(name, defaultGroup);
-        requireNonNull(keyFlag, "keyFlag cannot be null.");
-        requireNonNull(valueFlag, "valueFlag cannot be null.");
         this.keyFlag = keyFlag;
         this.valueFlag = valueFlag;
     }

worldguard-core/src/main/java/com/sk89q/worldguard/protection/flags/NumberFlag.java

@@ -21,8 +21,6 @@ package com.sk89q.worldguard.protection.flags;
 
 import static com.google.common.base.Preconditions.checkNotNull;
 
-import com.google.common.annotations.Beta;
-
 /**
  * Stores an Number.
  */
@@ -39,20 +37,10 @@ public abstract class NumberFlag<T extends Number> extends Flag<T> {
         super(name);
     }
 
-    /**
-     * Not recommended for public use. Will likely be moved when migrating to piston for commands.
-     * @param values suggested values
-     */
-    @Beta
     public void setSuggestedValues(Number[] values) {
         this.suggestions = checkNotNull(values);
     }
 
-    /**
-     * Not recommended for public use. Will likely be moved when migrating to piston for commands.
-     * @return suggested values
-     */
-    @Beta
     public Number[] getSuggestedValues() {
         return suggestions;
     }

worldguard-core/src/main/java/com/sk89q/worldguard/protection/flags/RegistryFlag.java

@@ -26,20 +26,16 @@ import javax.annotation.Nullable;
 import java.util.Locale;
 import java.util.Optional;
 
-import static java.util.Objects.requireNonNull;
-
 public class RegistryFlag<T extends Keyed> extends Flag<T> {
     private final Registry<T> registry;
 
     public RegistryFlag(String name, Registry<T> registry) {
         super(name);
-        requireNonNull(registry, "registry cannot be null.");
         this.registry = registry;
     }
 
     public RegistryFlag(String name, @Nullable RegionGroup defaultGroup, Registry<T> registry) {
         super(name, defaultGroup);
-        requireNonNull(registry, "registry cannot be null.");
         this.registry = registry;
     }
 
@@ -61,6 +57,6 @@ public class RegistryFlag<T extends Keyed> extends Flag<T> {
 
     @Override
     public Object marshal(T o) {
-        return o.id();
+        return o.getId();
     }
 }

worldguard-core/src/main/java/com/sk89q/worldguard/protection/flags/SetFlag.java

@@ -27,8 +27,6 @@ import java.util.HashSet;
 import java.util.List;
 import java.util.Set;
 
-import static java.util.Objects.requireNonNull;
-
 /**
  * Stores a set of types.
  */
@@ -38,13 +36,11 @@ public class SetFlag<T> extends Flag<Set<T>> {
 
     public SetFlag(String name, RegionGroup defaultGroup, Flag<T> subFlag) {
         super(name, defaultGroup);
-        requireNonNull(subFlag, "SubFlag cannot be null.");
         this.subFlag = subFlag;
     }
 
     public SetFlag(String name, Flag<T> subFlag) {
         super(name);
-        requireNonNull(subFlag, "SubFlag cannot be null.");
         this.subFlag = subFlag;
     }
 

worldguard-core/src/main/java/com/sk89q/worldguard/protection/flags/UUIDFlag.java

@@ -1,64 +0,0 @@
-/*
- * WorldGuard, a suite of tools for Minecraft
- * Copyright (C) sk89q <http://www.sk89q.com>
- * Copyright (C) WorldGuard team and contributors
- *
- * This program is free software: you can redistribute it and/or modify it
- * under the terms of the GNU Lesser General Public License as published by the
- * Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License
- * for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-package com.sk89q.worldguard.protection.flags;
-
-import javax.annotation.Nullable;
-import java.util.UUID;
-
-public class UUIDFlag extends Flag<UUID> {
-
-    public UUIDFlag(String name, @Nullable RegionGroup defaultGroup) {
-        super(name, defaultGroup);
-    }
-
-    public UUIDFlag(String name) {
-        super(name);
-    }
-
-    @Override
-    public UUID parseInput(FlagContext context) throws InvalidFlagFormat {
-        String input = context.getUserInput();
-        if ("self".equalsIgnoreCase(input)) {
-            return context.getSender().getUniqueId();
-        }
-        try {
-            return UUID.fromString(input);
-        } catch (IllegalArgumentException e) {
-            throw new InvalidFlagFormat("Not a valid uuid: " + input);
-        }
-    }
-
-    @Override
-    public UUID unmarshal(@Nullable Object o) {
-        if (!(o instanceof String)) {
-            return null;
-        }
-        try {
-            return UUID.fromString((String)o);
-        } catch (IllegalArgumentException e) {
-            return null;
-        }
-    }
-
-    @Override
-    public Object marshal(UUID o) {
-        return o.toString();
-    }
-}

worldguard-core/src/main/java/com/sk89q/worldguard/protection/flags/VectorFlag.java

@@ -82,9 +82,9 @@ public class VectorFlag extends Flag<Vector3> {
     @Override
     public Object marshal(Vector3 o) {
         Map<String, Object> vec = new HashMap<>();
-        vec.put("x", o.x());
-        vec.put("y", o.y());
-        vec.put("z", o.z());
+        vec.put("x", o.getX());
+        vec.put("y", o.getY());
+        vec.put("z", o.getZ());
         return vec;
     }
 

worldguard-core/src/main/java/com/sk89q/worldguard/protection/flags/WeatherTypeFlag.java

@@ -24,11 +24,6 @@ import com.sk89q.worldedit.world.weather.WeatherTypes;
 
 import javax.annotation.Nullable;
 
-/**
- * Stores an weather type.
- * @deprecated replaced by {@link RegistryFlag<WeatherType>}, will be removed in WorldGuard 8
- */
-@Deprecated
 public class WeatherTypeFlag extends Flag<WeatherType> {
 
     protected WeatherTypeFlag(String name, @Nullable RegionGroup defaultGroup) {
@@ -57,6 +52,6 @@ public class WeatherTypeFlag extends Flag<WeatherType> {
 
     @Override
     public Object marshal(WeatherType o) {
-        return o.id();
+        return o.getId();
     }
 }

worldguard-core/src/main/java/com/sk89q/worldguard/protection/flags/registry/SimpleFlagRegistry.java

@@ -144,7 +144,7 @@ public class SimpleFlagRegistry implements FlagRegistry {
                     } else {
                         log.warning("Failed to parse flag '" + flag.getName() + "' with value '" + entry.getValue() + "'");
                     }
-                } catch (Throwable e) {
+                } catch (Exception e) {
                     log.log(Level.WARNING, "Failed to unmarshal flag value for " + flag, e);
                 }
             }