Release 7.0.8

Not tested cuz I don't know how to enable camels, but in theory this should work for that.

.github/ISSUE_TEMPLATE/bug_report.md

@@ -1,34 +0,0 @@
----
-name: Bug report
-about: Report a way in which WorldGuard is not working as intended
-title: ''
-labels: type:bug, status:pending
-assignees: ''
-
----
-
-**Versions**
-<!-- Please include the full version of WorldEdit, WorldGuard and the platform (Bukkit/Spigot/Paper) you are running, e.g. output from `/we version`, `/wg version` `/version` commands. Please ensure you are running up to date software before making a bug report. Old versions will receive little to no support. -->
-WorldEdit version:
-
-WorldGuard version:
-
-Platform version:
-
-
-**Describe the bug**
-<!-- A clear and concise description of what the bug is. -->
-
-**To Reproduce**
-<!-- Steps to reproduce the behavior: -->
-1. ...
-2. ...
-
-**Expected behavior**
-<!-- A clear and concise description of what you expected to happen. -->
-
-**Screenshots**
-<!-- If applicable, add screenshots to help explain your problem. Screenshots of `/rg info` for any applicable regions (or simply the link from `/wg report -p`) are good to include. -->
-
-**Additional context**
-<!-- Add any other context about the problem here. -->

.github/ISSUE_TEMPLATE/bug_report.yml

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

.github/ISSUE_TEMPLATE/feature_request.md

@@ -1,20 +0,0 @@
----
-name: Feature request
-about: Suggest an idea for WorldGuard
-title: ''
-labels: type:feature-request, status:pending
-assignees: ''
-
----
-
-**Is your feature request related to a problem? Please describe.**
-<!-- A clear and concise description of what the problem is. Ex. I'm always frustrated when [...] -->
-
-**Describe the solution you'd like**
-<!-- A clear and concise description of what you want to happen. -->
-
-**Describe alternatives you've considered**
-<!-- A clear and concise description of any alternative solutions or features you've considered. -->
-
-**Additional context**
-<!-- Add any other context or screenshots about the feature request here. -->

.github/ISSUE_TEMPLATE/feature_request.yml

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

.travis.yml

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

CHANGELOG.md

@@ -1,8 +1,49 @@
 # Changelog
 
+## 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).

COMPILING.md

@@ -0,0 +1,42 @@
+Compiling
+=========
+
+You can compile WorldGuard as long as you have some version of Java greater than or equal to 17 installed. Gradle will download JDK 17 specifically if needed,
+but it needs some version of Java to bootstrap from.
+
+Note that if you have JRE 17 installed, Gradle will currently attempt to use that to compile, which will not work. It is easiest to uninstall JRE 16 and
+replace it with JDK 17.
+
+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,9 +7,7 @@ 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 8 for source and compilation.** Make sure to mark methods with
-  ` @Override` that override methods of parent classes, or that implement
-  methods of interfaces.
+* **Target Java 16 for source and compilation.**
 * **Use only spaces for indentation.** Our indents are 4-spaces long, and tabs
   are unacceptable.
 * **Wrap code to a 89 column limit.** We do this to make side by side diffs

README.md

@@ -23,7 +23,7 @@ A Bukkit server implementation (such as [Paper](https://papermc.io)) and the [Wo
 Compiling
 ---------
 
-The project is written for Java 8 and our build process makes use of
+The project is written for Java 16 and our build process makes use of
 [Gradle](http://gradle.org).
 
 Dependencies are automatically handled by Gradle.

build.gradle.kts

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

buildSrc/build.gradle.kts

@@ -4,16 +4,14 @@ plugins {
 }
 
 repositories {
-    jcenter()
+    mavenCentral()
     gradlePluginPortal()
 }
 
 dependencies {
     implementation(gradleApi())
-    implementation("gradle.plugin.net.minecrell:licenser:0.4.1")
-    implementation("org.ajoberstar.grgit:grgit-gradle:3.1.1")
-    implementation("com.github.jengelman.gradle.plugins:shadow:5.1.0")
-    implementation("net.ltgt.apt-eclipse:net.ltgt.apt-eclipse.gradle.plugin:0.21")
-    implementation("net.ltgt.apt-idea:net.ltgt.apt-idea.gradle.plugin:0.21")
-    implementation("org.jfrog.buildinfo:build-info-extractor-gradle:4.9.7")
+    implementation("gradle.plugin.org.cadixdev.gradle:licenser:0.6.1")
+    implementation("org.ajoberstar.grgit:grgit-gradle:4.1.1")
+    implementation("gradle.plugin.com.github.johnrengelman:shadow:7.1.2")
+    implementation("org.jfrog.buildinfo:build-info-extractor-gradle:4.27.1")
 }

buildSrc/src/main/kotlin/ArtifactoryConfig.kt

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

buildSrc/src/main/kotlin/CommonConfig.kt

@@ -1,5 +1,11 @@
+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
@@ -10,9 +16,23 @@ fun Project.applyCommonConfiguration() {
         maven { url = uri("https://maven.enginehub.org/repo/") }
         maven { url = uri("https://oss.sonatype.org/content/repositories/snapshots/") }
     }
+
     configurations.all {
         resolutionStrategy {
             cacheChangingModulesFor(5, "MINUTES")
         }
     }
+
+    plugins.withId("java") {
+        the<JavaPluginExtension>().toolchain {
+            languageVersion.set(JavaLanguageVersion.of(17))
+        }
+    }
+
+    apply(plugin = "org.cadixdev.licenser")
+    configure<LicenseExtension> {
+        header(rootProject.file("HEADER.txt"))
+        include("**/*.java")
+        include("**/*.kt")
+    }
 }

buildSrc/src/main/kotlin/LibsConfig.kt

@@ -1,39 +1,54 @@
 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.internal.HasConvention
-import org.gradle.api.plugins.MavenRepositoryHandlerConvention
-import org.gradle.api.tasks.Upload
+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.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")
+    apply(plugin = "maven-publish")
     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:1.3.9"))
+            exclude(dependency("com.google.code.findbugs:jsr305"))
         }
 
-        relocate("com.sk89q.squirrelid", "com.sk89q.worldguard.util.profile")
+        relocations.forEach { (from, to) ->
+            relocate(from, to)
+        }
     }
     val altConfigFiles = { artifactType: String ->
         val deps = configurations["shade"].incoming.dependencies
@@ -58,13 +73,15 @@ fun Project.applyLibrariesConfiguration() {
         from({
             altConfigFiles("sources")
         })
-        val filePattern = Regex("(.*)com/sk89q/squirrelid((?:/|$).*)")
-        val textPattern = Regex("com\\.sk89q\\.squirrelid")
-        eachFile {
-            filter {
-                it.replaceFirst(textPattern, "com.sk89q.worldguard.util.profile")
+        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")
             }
-            path = path.replaceFirst(filePattern, "$1com/sk89q/worldguard/util/profile$2")
         }
         archiveClassifier.set("sources")
     }
@@ -73,24 +90,82 @@ fun Project.applyLibrariesConfiguration() {
         dependsOn("jar", "sourcesJar")
     }
 
-    artifacts {
-        val jar = tasks.named("jar")
-        add("default", jar) {
-            builtBy(jar)
-        }
-        val sourcesJar = tasks.named("sourcesJar")
-        add("archives", sourcesJar) {
-            builtBy(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)
         }
+        outgoing.artifact(tasks.named("jar"))
     }
 
-    tasks.register<Upload>("install") {
-        configuration = configurations["archives"]
-        (repositories as HasConvention).convention.getPlugin<MavenRepositoryHandlerConvention>().mavenInstaller {
-            pom.version = project.version.toString()
-            pom.artifactId = project.name
+    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)
+        }
+        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)
+            }
         }
     }
 
     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,105 +1,95 @@
 import com.github.jengelman.gradle.plugins.shadow.tasks.ShadowJar
-import net.minecrell.gradle.licenser.LicenseExtension
-import org.gradle.api.JavaVersion
 import org.gradle.api.Project
-import org.gradle.api.plugins.JavaPluginConvention
+import org.gradle.api.component.AdhocComponentWithVariants
+import org.gradle.api.plugins.JavaPluginExtension
 import org.gradle.api.plugins.quality.CheckstyleExtension
-import org.gradle.api.tasks.bundling.Jar
+import org.gradle.api.publish.PublishingExtension
+import org.gradle.api.publish.maven.MavenPublication
 import org.gradle.api.tasks.javadoc.Javadoc
 import org.gradle.api.tasks.testing.Test
-import org.gradle.external.javadoc.CoreJavadocOptions
+import org.gradle.external.javadoc.StandardJavadocDocletOptions
 import org.gradle.kotlin.dsl.apply
 import org.gradle.kotlin.dsl.configure
 import org.gradle.kotlin.dsl.dependencies
 import org.gradle.kotlin.dsl.get
-import org.gradle.kotlin.dsl.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")
+    apply(plugin = "maven-publish")
     apply(plugin = "checkstyle")
-    apply(plugin = "com.github.johnrengelman.shadow")
     apply(plugin = "com.jfrog.artifactory")
-    apply(plugin = "net.minecrell.licenser")
 
     ext["internalVersion"] = "$version+${rootProject.ext["gitCommitHash"]}"
 
-    configure<JavaPluginConvention> {
-        sourceCompatibility = JavaVersion.VERSION_1_8
-        targetCompatibility = JavaVersion.VERSION_1_8
-    }
-
     configure<CheckstyleExtension> {
         configFile = rootProject.file("config/checkstyle/checkstyle.xml")
-        toolVersion = "7.6.1"
+        toolVersion = "10.3"
     }
 
     tasks.withType<Test>().configureEach {
-        useJUnit()
+        useJUnitPlatform()
     }
 
     dependencies {
-        "testCompile"("junit:junit:${Versions.JUNIT}")
-        // TODO switch to jupiter - doesn't support abstract test classes so tests need rewriting
-        //"testImplementation"("org.junit.jupiter:junit-jupiter-api:${Versions.JUNIT}")
-        //"testRuntime"("org.junit.jupiter:junit-jupiter-engine:${Versions.JUNIT}")
+        "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}")
     }
 
     // Java 8 turns on doclint which we fail
     tasks.withType<Javadoc>().configureEach {
-        (options as CoreJavadocOptions).addStringOption("Xdoclint:none", "-quiet")
+        (options as StandardJavadocDocletOptions).apply {
+            addStringOption("Xdoclint:none", "-quiet")
+            tags(
+                "apiNote:a:API Note:",
+                "implSpec:a:Implementation Requirements:",
+                "implNote:a:Implementation Note:"
+            )
+        }
     }
 
-    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"))
-    }
+    the<JavaPluginExtension>().withJavadocJar()
 
     if (name == "worldguard-core" || name == "worldguard-bukkit") {
-        tasks.register<Jar>("sourcesJar") {
-            dependsOn("classes")
-            archiveClassifier.set("sources")
-            from(sourceSets["main"].allSource)
-        }
-
-        artifacts {
-            add("archives", tasks.named("sourcesJar"))
-        }
-        tasks.named("assemble").configure {
-            dependsOn("sourcesJar")
-        }
+        the<JavaPluginExtension>().withSourcesJar()
     }
 
     tasks.named("check").configure {
         dependsOn("checkstyleMain", "checkstyleTest")
     }
 
-    applyCommonArtifactoryConfig()
-
-    configure<LicenseExtension> {
-        header = rootProject.file("HEADER.txt")
-        include("**/*.java")
+    configure<PublishingExtension> {
+        publications {
+            register<MavenPublication>("maven") {
+                from(components["java"])
+                versionMapping {
+                    usage("java-api") {
+                        fromResolutionOf("runtimeClasspath")
+                    }
+                    usage("java-runtime") {
+                        fromResolutionResult()
+                    }
+                }
+            }
+        }
     }
 
+    applyCommonArtifactoryConfig()
 }
 
 fun Project.applyShadowConfiguration() {
+    apply(plugin = "com.github.johnrengelman.shadow")
     tasks.named<ShadowJar>("shadowJar") {
         archiveClassifier.set("dist")
         dependencies {
@@ -110,10 +100,14 @@ fun Project.applyShadowConfiguration() {
             relocate("org.flywaydb", "com.sk89q.worldguard.internal.flywaydb") {
                 include(dependency("org.flywaydb:flyway-core:3.0"))
             }
-            relocate("com.sk89q.squirrelid", "com.sk89q.worldguard.util.profile")
+            exclude("com.google.code.findbugs:jsr305")
         }
         exclude("GradleStart**")
         exclude(".cache")
         exclude("LICENSE*")
     }
+    val javaComponent = components["java"] as AdhocComponentWithVariants
+    javaComponent.withVariantsFromConfiguration(configurations["shadowRuntimeElements"]) {
+        skip()
+    }
 }

buildSrc/src/main/kotlin/Versions.kt

@@ -1,8 +1,10 @@
 object Versions {
-//    const val PISTON = "0.4.3"
-//    const val AUTO_VALUE = "1.6.5"
-    const val WORLDEDIT = "7.2.0-SNAPSHOT"
-    const val JUNIT = "4.11"
-    const val SQUIRRELID = "0.2.0"
-    const val GUAVA = "21.0"
+    //    const val PISTON = "0.4.3"
+    //    const val AUTO_VALUE = "1.6.5"
+    const val WORLDEDIT = "7.2.12"
+    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"
 }

config/checkstyle/import-control.xml

@@ -27,9 +27,10 @@
     <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="co.aikar.timings.lib" />
+      <allow pkg="io.papermc.paper"/>
       <allow pkg="org.spigotmc" />
     </subpackage>
 

gradle.properties

@@ -1,2 +1,2 @@
 group=com.sk89q.worldguard
-version=7.0.5
+version=7.0.8

gradle/wrapper/gradle-wrapper.properties

@@ -1,5 +1,6 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-6.5.1-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.0.2-bin.zip
+networkTimeout=10000
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists

gradlew

@@ -1,7 +1,7 @@
-#!/usr/bin/env sh
+#!/bin/sh
 
 #
-# Copyright 2015 the original author or authors.
+# 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.
@@ -17,78 +17,113 @@
 #
 
 ##############################################################################
-##
-##  Gradle start up script for UN*X
-##
+#
+#   Gradle start up script for POSIX generated by Gradle.
+#
+#   Important for running:
+#
+#   (1) You need a POSIX-compliant shell to run this script. If your /bin/sh is
+#       noncompliant, but you have some other compliant shell such as ksh or
+#       bash, then to run this script, type that shell name before the whole
+#       command line, like:
+#
+#           ksh Gradle
+#
+#       Busybox and similar reduced shells will NOT work, because this script
+#       requires all of these POSIX shell features:
+#         * functions;
+#         * expansions «$var», «${var}», «${var:-default}», «${var+SET}»,
+#           «${var#prefix}», «${var%suffix}», and «$( cmd )»;
+#         * compound commands having a testable exit status, especially «case»;
+#         * various built-in commands including «command», «set», and «ulimit».
+#
+#   Important for patching:
+#
+#   (2) This script targets any POSIX shell, so it avoids extensions provided
+#       by Bash, Ksh, etc; in particular arrays are avoided.
+#
+#       The "traditional" practice of packing multiple parameters into a
+#       space-separated string is a well documented source of bugs and security
+#       problems, so this is (mostly) avoided, by progressively accumulating
+#       options in "$@", and eventually passing that to Java.
+#
+#       Where the inherited environment variables (DEFAULT_JVM_OPTS, JAVA_OPTS,
+#       and GRADLE_OPTS) rely on word-splitting, this is performed explicitly;
+#       see the in-line comments for details.
+#
+#       There are tweaks for specific operating systems such as AIX, CygWin,
+#       Darwin, MinGW, and NonStop.
+#
+#   (3) This script is generated from the Groovy template
+#       https://github.com/gradle/gradle/blob/HEAD/subprojects/plugins/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt
+#       within the Gradle project.
+#
+#       You can find Gradle at https://github.com/gradle/gradle/.
+#
 ##############################################################################
 
 # Attempt to set APP_HOME
-# Resolve links: $0 may be a link
-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
 
-APP_NAME="Gradle"
-APP_BASE_NAME=`basename "$0"`
+# Resolve links: $0 may be a link
+app_path=$0
+
+# Need this for daisy-chained symlinks.
+while
+    APP_HOME=${app_path%"${app_path##*/}"}  # leaves a trailing /; empty if no leading path
+    [ -h "$app_path" ]
+do
+    ls=$( ls -ld "$app_path" )
+    link=${ls#*' -> '}
+    case $link in             #(
+      /*)   app_path=$link ;; #(
+      *)    app_path=$APP_HOME$link ;;
+    esac
+done
+
+# This is normally unused
+# shellcheck disable=SC2034
+APP_BASE_NAME=${0##*/}
+APP_HOME=$( cd "${APP_HOME:-./}" && pwd -P ) || exit
 
 # 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"'
 
 # 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
-    ;;
-  MINGW* )
-    msys=true
-    ;;
-  NONSTOP* )
-    nonstop=true
-    ;;
+case "$( uname )" in                #(
+  CYGWIN* )         cygwin=true  ;; #(
+  Darwin* )         darwin=true  ;; #(
+  MSYS* | MINGW* )  msys=true    ;; #(
+  NONSTOP* )        nonstop=true ;;
 esac
 
 CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
 
+
 # Determine the Java command to use to start the JVM.
 if [ -n "$JAVA_HOME" ] ; then
     if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
         # IBM's JDK on AIX uses strange locations for the executables
-        JAVACMD="$JAVA_HOME/jre/sh/java"
+        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
@@ -97,7 +132,7 @@ Please set the JAVA_HOME variable in your environment to match the
 location of your Java installation."
     fi
 else
-    JAVACMD="java"
+    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
@@ -105,84 +140,105 @@ location of your Java installation."
 fi
 
 # Increase the maximum file descriptors if we can.
-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
-        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" ;;
+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=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=SC3045
+        ulimit -n "$MAX_FD" ||
+            warn "Could not set maximum file descriptor limit to $MAX_FD"
     esac
 fi
 
-# Escape application args
-save () {
-    for i do printf %s\\n "$i" | sed "s/'/'\\\\''/g;1s/^/'/;\$s/\$/' \\\\/" ; done
-    echo " "
-}
-APP_ARGS=$(save "$@")
+# 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.
 
-# 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"
+# 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" )
 
-# 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")"
+    JAVACMD=$( cygpath --unix "$JAVACMD" )
+
+    # Now convert the arguments - kludge to limit ourselves to /bin/sh
+    for arg do
+        if
+            case $arg in                                #(
+              -*)   false ;;                            # don't mess with options #(
+              /?*)  t=${arg#/} t=/${t%%/*}              # looks like a POSIX filepath
+                    [ -e "$t" ] ;;                      #(
+              *)    false ;;
+            esac
+        then
+            arg=$( cygpath --path --ignore --mixed "$arg" )
+        fi
+        # Roll the args list around exactly as many times as the number of
+        # args, so each arg winds up back in the position where it started, but
+        # possibly modified.
+        #
+        # NB: a `for` loop captures its iteration list before it begins, so
+        # changing the positional parameters here affects neither the number of
+        # iterations, nor the values presented in `arg`.
+        shift                   # remove old arg
+        set -- "$@" "$arg"      # push replacement arg
+    done
 fi
 
+# Collect all arguments for the java command;
+#   * $DEFAULT_JVM_OPTS, $JAVA_OPTS, and $GRADLE_OPTS can contain fragments of
+#     shell script including quotes and variable substitutions, so put them in
+#     double quotes to make sure that they get re-expanded; and
+#   * put everything else in single quotes, so that it's not re-expanded.
+
+set -- \
+        "-Dorg.gradle.appname=$APP_BASE_NAME" \
+        -classpath "$CLASSPATH" \
+        org.gradle.wrapper.GradleWrapperMain \
+        "$@"
+
+# Stop when "xargs" is not available.
+if ! command -v xargs >/dev/null 2>&1
+then
+    die "xargs is not available"
+fi
+
+# Use "xargs" to parse quoted args.
+#
+# With -n1 it outputs one arg per line, with the quotes and backslashes removed.
+#
+# In Bash we could simply go:
+#
+#   readarray ARGS < <( xargs -n1 <<<"$var" ) &&
+#   set -- "${ARGS[@]}" "$@"
+#
+# but POSIX shell has neither arrays nor command substitution, so instead we
+# post-process each arg (as a line of input to sed) to backslash-escape any
+# character that might be a shell metacharacter, then use eval to reverse
+# that process (while maintaining the separation between arguments), and wrap
+# the whole thing up as a single "set" statement.
+#
+# This will of course break if any of these variables contains a newline or
+# an unmatched quote.
+#
+
+eval "set -- $(
+        printf '%s\n' "$DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS" |
+        xargs -n1 |
+        sed ' s~[^-[:alnum:]+,./:=@_]~\\&~g; ' |
+        tr '\n' ' '
+    )" '"$@"'
+
 exec "$JAVACMD" "$@"

gradlew.bat

@@ -14,7 +14,7 @@
 @rem limitations under the License.
 @rem
 
-@if "%DEBUG%" == "" @echo off
+@if "%DEBUG%"=="" @echo off
 @rem ##########################################################################
 @rem
 @rem  Gradle startup script for Windows
@@ -25,10 +25,14 @@
 if "%OS%"=="Windows_NT" setlocal
 
 set DIRNAME=%~dp0
-if "%DIRNAME%" == "" set DIRNAME=.
+if "%DIRNAME%"=="" set DIRNAME=.
+@rem This is normally unused
 set APP_BASE_NAME=%~n0
 set APP_HOME=%DIRNAME%
 
+@rem Resolve any "." and ".." in APP_HOME to make it shorter.
+for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi
+
 @rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
 set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m"
 
@@ -37,7 +41,7 @@ if defined JAVA_HOME goto findJavaFromJavaHome
 
 set JAVA_EXE=java.exe
 %JAVA_EXE% -version >NUL 2>&1
-if "%ERRORLEVEL%" == "0" goto init
+if %ERRORLEVEL% equ 0 goto execute
 
 echo.
 echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
@@ -51,7 +55,7 @@ goto fail
 set JAVA_HOME=%JAVA_HOME:"=%
 set JAVA_EXE=%JAVA_HOME%/bin/java.exe
 
-if exist "%JAVA_EXE%" goto init
+if exist "%JAVA_EXE%" goto execute
 
 echo.
 echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
@@ -61,38 +65,26 @@ 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 %CMD_LINE_ARGS%
+"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %*
 
 :end
 @rem End local scope for the variables with windows NT shell
-if "%ERRORLEVEL%"=="0" goto mainEnd
+if %ERRORLEVEL% equ 0 goto mainEnd
 
 :fail
 rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
 rem the _cmd.exe /c_ return code!
-if  not "" == "%GRADLE_EXIT_CONSOLE%" exit 1
-exit /b 1
+set EXIT_CODE=%ERRORLEVEL%
+if %EXIT_CODE% equ 0 set EXIT_CODE=1
+if not ""=="%GRADLE_EXIT_CONSOLE%" exit %EXIT_CODE%
+exit /b %EXIT_CODE%
 
 :mainEnd
 if "%OS%"=="Windows_NT" endlocal

worldguard-bukkit/build.gradle.kts

@@ -1,10 +1,7 @@
 import com.github.jengelman.gradle.plugins.shadow.tasks.ShadowJar
-import org.gradle.api.internal.HasConvention
 
 plugins {
-    id("java-library")
-    id("net.ltgt.apt-eclipse")
-    id("net.ltgt.apt-idea")
+    `java-library`
 }
 
 applyPlatformAndCoreConfiguration()
@@ -13,47 +10,25 @@ applyShadowConfiguration()
 repositories {
     maven {
         name = "paper"
-        url = uri("https://papermc.io/repo/repository/maven-public/")
-    }
-    maven {
-        name = "bstats"
-        url = uri("https://repo.codemc.org/repository/maven-public")
-    }
-    maven {
-        name = "aikar-timings"
-        url = uri("http://repo.aikar.co/nexus/content/groups/aikar/")
+        url = uri("https://repo.papermc.io/repository/maven-public/")
     }
 }
 
 configurations {
-    compileClasspath.extendsFrom(create("shade"))
+    compileClasspath.get().extendsFrom(create("shadeOnly"))
 }
 
 dependencies {
-    "compile"(project(":worldguard-core"))
-    //"compile"(project(":worldguard-libs:bukkit"))
-    "api"("com.destroystokyo.paper:paper-api:1.16.2-R0.1-SNAPSHOT")
-    "shade"("io.papermc:paperlib:1.0.4")
+    "api"(project(":worldguard-core"))
+    "compileOnly"("io.papermc.paper:paper-api:1.19.3-R0.1-SNAPSHOT")
+    "runtimeOnly"("org.spigotmc:spigot-api:1.19.3-R0.1-SNAPSHOT") {
+        exclude("junit", "junit")
+    }
     "api"("com.sk89q.worldedit:worldedit-bukkit:${Versions.WORLDEDIT}") { isTransitive = false }
     "implementation"("com.google.guava:guava:${Versions.GUAVA}")
-    "implementation"("com.sk89q:commandbook:2.3") { isTransitive = false }
-    "shade"("org.bstats:bstats-bukkit:1.7")
-    "shade"("co.aikar:minecraft-timings:1.0.4")
-}
-
-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.spigotmc")
-                setProperty("artifactId", "spigot-api")
-            }
-        }
-    }
+    "compileOnly"("com.sk89q:commandbook:2.3") { isTransitive = false }
+    "shadeOnly"("io.papermc:paperlib:1.0.8")
+    "shadeOnly"("org.bstats:bstats-bukkit:3.0.1")
 }
 
 tasks.named<Copy>("processResources") {
@@ -73,11 +48,12 @@ tasks.named<Jar>("jar") {
 }
 
 tasks.named<ShadowJar>("shadowJar") {
-    configurations = listOf(project.configurations["shade"], project.configurations["runtimeClasspath"])
+    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:bstats-bukkit"))
+            include(dependency("org.bstats:"))
         }
         relocate ("io.papermc.lib", "com.sk89q.worldguard.bukkit.paperlib") {
             include(dependency("io.papermc:paperlib"))

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

@@ -37,7 +37,6 @@ public class BukkitConfigurationManager extends YamlConfigurationManager {
 
     private boolean hasCommandBookGodMode;
     boolean extraStats;
-    boolean timedSessionHandlers;
 
     /**
      * Construct the object.
@@ -57,7 +56,6 @@ public class BukkitConfigurationManager extends YamlConfigurationManager {
     public void load() {
         super.load();
         this.extraStats = getConfig().getBoolean("custom-metrics-charts", true);
-        this.timedSessionHandlers = getConfig().getBoolean("extra-timings.session-handlers", true);
     }
 
     @Override
@@ -94,6 +92,10 @@ 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;
 
@@ -101,8 +103,8 @@ public class BukkitConfigurationManager extends YamlConfigurationManager {
             if (newConfig == null) {
                 newConfig = new BukkitWorldConfiguration(plugin, worldName, this.getConfig());
             }
-            worlds.putIfAbsent(world.getName(), newConfig);
-            config = worlds.get(world.getName());
+            worlds.putIfAbsent(worldName, newConfig);
+            config = worlds.get(worldName);
         }
 
         return config;

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

@@ -140,6 +140,8 @@ public class BukkitWorldConfiguration extends YamlWorldConfiguration {
             throw e;
         }
 
+        boolean needParentSave = false;
+
         summaryOnStart = getBoolean("summary-on-start", true);
         opPermissions = getBoolean("op-permissions", true);
 
@@ -158,7 +160,8 @@ public class BukkitWorldConfiguration extends YamlWorldConfiguration {
         itemDurability = getBoolean("protection.item-durability", true);
         removeInfiniteStacks = getBoolean("protection.remove-infinite-stacks", false);
         disableExpDrops = getBoolean("protection.disable-xp-orb-drops", false);
-        disableObsidianGenerators = getBoolean("protection.disable-obsidian-generators", false);
+
+        needParentSave |= removeProperty("protection.disable-obsidian-generators");
 
         useMaxPriorityAssociation = getBoolean("protection.use-max-priority-association", false);
 
@@ -178,6 +181,11 @@ 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);
@@ -236,7 +244,12 @@ 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", 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");
+        }
 
         disableCreatureCropTrampling = getBoolean("crops.disable-creature-trampling", false);
         disablePlayerCropTrampling = getBoolean("crops.disable-player-trampling", false);
@@ -263,9 +276,12 @@ 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);
@@ -280,6 +296,7 @@ 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);
@@ -401,6 +418,20 @@ 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,9 +31,10 @@ import com.sk89q.worldguard.LocalPlayer;
 import com.sk89q.worldguard.WorldGuard;
 import com.sk89q.worldguard.protection.regions.ProtectedCuboidRegion;
 import com.sk89q.worldguard.protection.regions.ProtectedRegion;
-import com.sk89q.worldguard.util.profile.resolver.PaperProfileService;
+import com.sk89q.worldguard.util.profile.resolver.PaperPlayerService;
 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;
@@ -138,7 +139,6 @@ public class BukkitWorldGuardPlatform implements WorldGuardPlatform {
         sessionManager = new BukkitSessionManager();
         configuration = new BukkitConfigurationManager(WorldGuardPlugin.inst());
         configuration.load();
-        sessionManager.setUsingTimings(configuration.timedSessionHandlers);
         regionContainer = new BukkitRegionContainer(WorldGuardPlugin.inst());
         regionContainer.initialize();
         debugHandler = new BukkitDebugHandler(WorldGuardPlugin.inst());
@@ -146,6 +146,7 @@ public class BukkitWorldGuardPlatform implements WorldGuardPlatform {
 
     @Override
     public void unload() {
+        sessionManager.shutdown();
         configuration.unload();
         regionContainer.shutdown();
     }
@@ -173,7 +174,6 @@ 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,12 +207,7 @@ public class BukkitWorldGuardPlatform implements WorldGuardPlatform {
                     }
 
                     // Same type?
-                    // Blocks store their color in the damage value
-                    if (item2.getType() == item.getType() &&
-                            (ignoreDamaged || item.getDurability() == item2.getDurability()) &&
-                            ((item.getItemMeta() == null && item2.getItemMeta() == null)
-                                    || (item.getItemMeta() != null &&
-                                    item.getItemMeta().equals(item2.getItemMeta())))) {
+                    if (item2.isSimilar(item)) {
                         // This stack won't fit in the parent stack
                         if (item2.getAmount() > needed) {
                             item.setAmount(max);
@@ -244,6 +239,7 @@ 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
@@ -251,7 +247,7 @@ public class BukkitWorldGuardPlatform implements WorldGuardPlatform {
         List<ProfileService> services = new ArrayList<>();
         if (PaperLib.isPaper()) {
             // Paper has a shared cache
-            services.add(PaperProfileService.getInstance());
+            services.add(PaperPlayerService.getInstance());
         } else {
             services.add(BukkitPlayerService.getInstance());
         }

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

@@ -59,8 +59,9 @@ 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;
@@ -71,10 +72,12 @@ 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;
@@ -105,6 +108,8 @@ 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.
@@ -132,6 +137,10 @@ 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
@@ -145,21 +154,14 @@ 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);
 
-        getServer().getScheduler().scheduleSyncDelayedTask(this, () -> {
-            if (!platform.getGlobalStateManager().hasCommandBookGodMode()) {
-                reg.register(GeneralCommands.class);
-            }
-        }, 0L);
+        if (!platform.getGlobalStateManager().hasCommandBookGodMode()) {
+            reg.register(GeneralCommands.class);
+        }
 
         getServer().getScheduler().scheduleSyncRepeatingTask(this, sessionManager, BukkitSessionManager.RUN_DELAY, BukkitSessionManager.RUN_DELAY);
 
@@ -212,20 +214,20 @@ public class WorldGuardPlugin extends JavaPlugin {
         ((SimpleFlagRegistry) WorldGuard.getInstance().getFlagRegistry()).setInitialized(true);
 
         // Enable metrics
-        final Metrics metrics = new Metrics(this, 3283); // bStats plugin id
-        if (metrics.isEnabled() && platform.getGlobalStateManager().extraStats) {
+        final Metrics metrics = new Metrics(this, BSTATS_PLUGIN_ID); // bStats plugin id
+        if (platform.getGlobalStateManager().extraStats) {
             setupCustomCharts(metrics);
         }
     }
 
     private void setupCustomCharts(Metrics metrics) {
-        metrics.addCustomChart(new Metrics.SingleLineChart("region_count", () ->
+        metrics.addCustomChart(new SingleLineChart("region_count", () ->
                 platform.getRegionContainer().getLoaded().stream().mapToInt(RegionManager::size).sum()));
-        metrics.addCustomChart(new Metrics.SimplePie("region_driver", () -> {
+        metrics.addCustomChart(new SimplePie("region_driver", () -> {
             RegionDriver driver = platform.getGlobalStateManager().selectedRegionStoreDriver;
             return driver instanceof DirectoryYamlDriver ? "yaml" : driver instanceof SQLDriver ? "sql" : "unknown";
         }));
-        metrics.addCustomChart(new Metrics.DrilldownPie("blacklist", () -> {
+        metrics.addCustomChart(new DrilldownPie("blacklist", () -> {
             int empty = 0;
             Map<String, Integer> blacklistMap = new HashMap<>();
             Map<String, Integer> whitelistMap = new HashMap<>();
@@ -248,14 +250,14 @@ public class WorldGuardPlugin extends JavaPlugin {
             blacklistCounts.put("whitelist", whitelistMap);
             return blacklistCounts;
         }));
-        metrics.addCustomChart(new Metrics.SimplePie("chest_protection", () ->
+        metrics.addCustomChart(new SimplePie("chest_protection", () ->
                 "" + platform.getGlobalStateManager().getWorldConfigs().stream().anyMatch(cfg -> cfg.signChestProtection)));
-        metrics.addCustomChart(new Metrics.SimplePie("build_permissions", () ->
+        metrics.addCustomChart(new SimplePie("build_permissions", () ->
                 "" + platform.getGlobalStateManager().getWorldConfigs().stream().anyMatch(cfg -> cfg.buildPermissions)));
 
-        metrics.addCustomChart(new Metrics.SimplePie("custom_flags", () ->
+        metrics.addCustomChart(new SimplePie("custom_flags", () ->
                 "" + (WorldGuard.getInstance().getFlagRegistry().size() > Flags.INBUILT_FLAGS.size())));
-        metrics.addCustomChart(new Metrics.SimplePie("custom_handlers", () ->
+        metrics.addCustomChart(new SimplePie("custom_handlers", () ->
                 "" + (WorldGuard.getInstance().getPlatform().getSessionManager().customHandlersRegistered())));
     }
 
@@ -418,8 +420,9 @@ public class WorldGuardPlugin extends JavaPlugin {
     }
 
     public Actor wrapCommandSender(CommandSender sender) {
-        if (sender instanceof Player) {
-            return wrapPlayer((Player) sender);
+        if (sender instanceof Player player) {
+            if (Entities.isNPC(player)) return null;
+            return wrapPlayer(player);
         }
 
         try {
@@ -452,6 +455,13 @@ 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

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

@@ -21,15 +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;
@@ -98,7 +104,31 @@ public final class Cause {
      */
     public boolean isKnown() {
         Object object = getRootCause();
-        return !(object == null || object instanceof TNTPrimed || object instanceof Vehicle);
+
+        if (object == null) {
+            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;
+            }
+        }
+
+        return true;
     }
 
     @Nullable
@@ -113,8 +143,8 @@ public final class Cause {
     @Nullable
     public Player getFirstPlayer() {
         for (Object object : causes) {
-            if (object instanceof Player) {
-                return (Player) object;
+            if (object instanceof Player p && !Entities.isNPC(p)) {
+                return p;
             }
         }
 
@@ -124,8 +154,8 @@ public final class Cause {
     @Nullable
     public Entity getFirstEntity() {
         for (Object object : causes) {
-            if (object instanceof Entity) {
-                return (Entity) object;
+            if (object instanceof Entity e) {
+                return e;
             }
         }
 
@@ -135,8 +165,8 @@ public final class Cause {
     @Nullable
     public Entity getFirstNonPlayerEntity() {
         for (Object object : causes) {
-            if (object instanceof Entity && !(object instanceof Player)) {
-                return (Entity) object;
+            if (object instanceof Entity e && (!(object instanceof Player) || Entities.isNPC(e))) {
+                return e;
             }
         }
 
@@ -146,8 +176,8 @@ public final class Cause {
     @Nullable
     public Block getFirstBlock() {
         for (Object object : causes) {
-            if (object instanceof Block) {
-                return (Block) object;
+            if (object instanceof Block b) {
+                return b;
             }
         }
 
@@ -249,56 +279,76 @@ public final class Cause {
         }
 
         private void addAll(@Nullable Object... element) {
-            if (element != null) {
-                for (Object o : element) {
-                    if (o == null || seen.contains(o)) {
-                        continue;
-                    }
+            if (element == null) {
+                return;
+            }
+            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()) {
-                            UUID spawningUUID = ((Firework) o).getSpawningEntity();
-                            if (spawningUUID != null) {
-                                Entity spawningEntity = Bukkit.getEntity(spawningUUID);
-                                if (spawningEntity != null) {
-                                    addAll(spawningEntity);
-                                }
+                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()) {
+                        UUID spawningUUID = ((Firework) o).getSpawningEntity();
+                        if (spawningUUID != null) {
+                            Entity spawningEntity = Bukkit.getEntity(spawningUUID);
+                            if (spawningEntity != null) {
+                                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 Tameable) {
-                        indirect = true;
-                        addAll(((Tameable) o).getOwner());
-                    } else if (o instanceof Creature && ((Creature) o).getTarget() != null) {
-                        indirect = true;
-                        addAll(((Creature) o).getTarget());
-                    } else if (o instanceof BlockProjectileSource) {
-                        addAll(((BlockProjectileSource) o).getBlock());
                     }
-
-                    // 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 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
                         }
                     }
-
-                    causes.add(o);
+                } 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);
             }
         }
 

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

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

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

@@ -31,6 +31,7 @@ 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;
@@ -79,20 +80,19 @@ public class BlacklistListener extends AbstractListener {
 
     @EventHandler(ignoreCancelled = true)
     public void onBreakBlock(final BreakBlockEvent event) {
-        final Player player = event.getCause().getFirstPlayer();
+        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);
-        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,6 +110,12 @@ 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) {
@@ -117,19 +123,18 @@ 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) {
@@ -137,33 +142,25 @@ 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;
         }
 
-        LocalPlayer localPlayer = getPlugin().wrapPlayer(player);
-        WorldConfiguration wcfg = getWorldConfig(localPlayer);
-
-        // Blacklist guard
-        if (wcfg.getBlacklist() == null) {
-            return;
-        }
-
+        final LocalPlayer localPlayer = getPlugin().wrapPlayer(player);
         Material material = Materials.getRelatedMaterial(event.getEffectiveType());
         if (material != null) {
             if (!wcfg.getBlacklist().check(new ItemUseBlacklistEvent(
@@ -175,21 +172,20 @@ 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;
         }
 
-        LocalPlayer localPlayer = getPlugin().wrapPlayer(player);
+        final 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(
@@ -212,21 +208,20 @@ 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;
         }
 
-        LocalPlayer localPlayer = getPlugin().wrapPlayer(player);
+        final 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);
@@ -241,8 +236,7 @@ public class BlacklistListener extends AbstractListener {
 
     @EventHandler(ignoreCancelled = true)
     public void onPlayerDropItem(PlayerDropItemEvent event) {
-        ConfigurationManager cfg = WorldGuard.getInstance().getPlatform().getGlobalStateManager();
-        WorldConfiguration wcfg = cfg.get(BukkitAdapter.adapt(event.getPlayer().getWorld()));
+        WorldConfiguration wcfg = getWorldConfig(event.getPlayer().getWorld());
 
         if (wcfg.getBlacklist() != null) {
             Item ci = event.getItemDrop();
@@ -257,8 +251,7 @@ public class BlacklistListener extends AbstractListener {
 
     @EventHandler(ignoreCancelled = true)
     public void onBlockDispense(BlockDispenseEvent event) {
-        ConfigurationManager cfg = WorldGuard.getInstance().getPlatform().getGlobalStateManager();
-        WorldConfiguration wcfg = cfg.get(BukkitAdapter.adapt(event.getBlock().getWorld()));
+        BukkitWorldConfiguration wcfg = getWorldConfig(event.getBlock().getWorld());
 
         if (wcfg.getBlacklist() != null) {
             if (!wcfg.getBlacklist().check(new BlockDispenseBlacklistEvent(null, BukkitAdapter.asBlockVector(event.getBlock().getLocation()),
@@ -277,8 +270,7 @@ public class BlacklistListener extends AbstractListener {
 
         if (item != null && inventory.getHolder() != null) {
             Player player = (Player) entity;
-            ConfigurationManager cfg = WorldGuard.getInstance().getPlatform().getGlobalStateManager();
-            WorldConfiguration wcfg = cfg.get(BukkitAdapter.adapt(entity.getWorld()));
+            WorldConfiguration wcfg = getWorldConfig(player.getWorld());
             LocalPlayer localPlayer = getPlugin().wrapPlayer(player);
 
             if (wcfg.getBlacklist() != null && !wcfg.getBlacklist().check(
@@ -340,7 +332,8 @@ public class BlacklistListener extends AbstractListener {
                     break;
             }
         } else if (clickedInventory != null && clickedInventory.getType() == InventoryType.PLAYER
-                && event.getView().getTopInventory().getType() == InventoryType.PLAYER
+                && (event.getView().getTopInventory().getType() == InventoryType.PLAYER
+                    || event.getView().getTopInventory().getType() == InventoryType.CRAFTING)
                 && event.getAction() == InventoryAction.MOVE_TO_OTHER_INVENTORY) {
             return event.getCurrentItem();
         }
@@ -354,8 +347,7 @@ public class BlacklistListener extends AbstractListener {
 
         if (item.getType() != Material.AIR && entity instanceof Player) {
             Player player = (Player) entity;
-            ConfigurationManager cfg = WorldGuard.getInstance().getPlatform().getGlobalStateManager();
-            WorldConfiguration wcfg = cfg.get(BukkitAdapter.adapt(entity.getWorld()));
+            WorldConfiguration wcfg = getWorldConfig(player.getWorld());
             LocalPlayer localPlayer = getPlugin().wrapPlayer(player);
 
             if (wcfg.getBlacklist() != null && !wcfg.getBlacklist().check(
@@ -372,8 +364,7 @@ public class BlacklistListener extends AbstractListener {
         ItemStack item = inventory.getItem(event.getNewSlot());
 
         if (item != null) {
-            ConfigurationManager cfg = WorldGuard.getInstance().getPlatform().getGlobalStateManager();
-            WorldConfiguration wcfg = cfg.get(BukkitAdapter.adapt(player.getWorld()));
+            WorldConfiguration wcfg = getWorldConfig(player.getWorld());
             LocalPlayer localPlayer = getPlugin().wrapPlayer(player);
 
             if (wcfg.getBlacklist() != null && !wcfg.getBlacklist().check(
@@ -389,8 +380,7 @@ public class BlacklistListener extends AbstractListener {
         Player player = ((Player) event.getTargetEntity());
         ItemStack stack = event.getItem();
 
-        ConfigurationManager cfg = WorldGuard.getInstance().getPlatform().getGlobalStateManager();
-        WorldConfiguration wcfg = cfg.get(BukkitAdapter.adapt(player.getWorld()));
+        WorldConfiguration wcfg = getWorldConfig(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,14 +19,11 @@
 
 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;
@@ -58,8 +55,7 @@ public class BlockedPotionsListener extends AbstractListener {
         if (event.getOriginalEvent() instanceof EntityDamageByEntityEvent) {
             EntityDamageByEntityEvent originalEvent = (EntityDamageByEntityEvent) event.getOriginalEvent();
             if (Entities.isPotionArrow(originalEvent.getDamager())) { // should take care of backcompat
-                ConfigurationManager cfg = WorldGuard.getInstance().getPlatform().getGlobalStateManager();
-                BukkitWorldConfiguration wcfg = (BukkitWorldConfiguration) cfg.get(BukkitAdapter.adapt(event.getWorld()));
+                BukkitWorldConfiguration wcfg = getWorldConfig(event.getWorld());
                 PotionEffectType blockedEffect = null;
                 if (originalEvent.getDamager() instanceof SpectralArrow) {
                     if (wcfg.blockPotions.contains(PotionEffectType.GLOWING)) {
@@ -96,8 +92,7 @@ public class BlockedPotionsListener extends AbstractListener {
 
     @EventHandler
     public void onItemInteract(UseItemEvent event) {
-        ConfigurationManager cfg = WorldGuard.getInstance().getPlatform().getGlobalStateManager();
-        BukkitWorldConfiguration wcfg = (BukkitWorldConfiguration) cfg.get(BukkitAdapter.adapt(event.getWorld()));
+        BukkitWorldConfiguration wcfg = getWorldConfig(event.getWorld());
         ItemStack item = event.getItemStack();
 
         if (item.getType() != Material.POTION

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

@@ -19,7 +19,6 @@
 
 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;
@@ -52,7 +51,7 @@ public class BuildPermissionListener extends AbstractListener {
     }
 
     private void tellErrorMessage(CommandSender sender, World world) {
-        String message = getWorldConfig(BukkitAdapter.adapt(world)).buildPermissionDenyMessage;
+        String message = getWorldConfig(world).buildPermissionDenyMessage;
         if (!message.isEmpty()) {
             sender.sendMessage(message);
         }
@@ -60,7 +59,7 @@ public class BuildPermissionListener extends AbstractListener {
 
     @EventHandler(ignoreCancelled = true)
     public void onPlaceBlock(final PlaceBlockEvent event) {
-        if (!getWorldConfig(BukkitAdapter.adapt(event.getWorld())).buildPermissions) return;
+        if (!getWorldConfig(event.getWorld()).buildPermissions) return;
 
         Object rootCause = event.getCause().getRootCause();
 
@@ -78,7 +77,7 @@ public class BuildPermissionListener extends AbstractListener {
 
     @EventHandler(ignoreCancelled = true)
     public void onBreakBlock(final BreakBlockEvent event) {
-        if (!getWorldConfig(BukkitAdapter.adapt(event.getWorld())).buildPermissions) return;
+        if (!getWorldConfig(event.getWorld()).buildPermissions) return;
 
         Object rootCause = event.getCause().getRootCause();
 
@@ -96,7 +95,7 @@ public class BuildPermissionListener extends AbstractListener {
 
     @EventHandler(ignoreCancelled = true)
     public void onUseBlock(final UseBlockEvent event) {
-        if (!getWorldConfig(BukkitAdapter.adapt(event.getWorld())).buildPermissions) return;
+        if (!getWorldConfig(event.getWorld()).buildPermissions) return;
 
         Object rootCause = event.getCause().getRootCause();
 
@@ -114,7 +113,7 @@ public class BuildPermissionListener extends AbstractListener {
 
     @EventHandler(ignoreCancelled = true)
     public void onSpawnEntity(SpawnEntityEvent event) {
-        if (!getWorldConfig(BukkitAdapter.adapt(event.getWorld())).buildPermissions) return;
+        if (!getWorldConfig(event.getWorld()).buildPermissions) return;
 
         Object rootCause = event.getCause().getRootCause();
 
@@ -132,7 +131,7 @@ public class BuildPermissionListener extends AbstractListener {
 
     @EventHandler(ignoreCancelled = true)
     public void onDestroyEntity(DestroyEntityEvent event) {
-        if (!getWorldConfig(BukkitAdapter.adapt(event.getWorld())).buildPermissions) return;
+        if (!getWorldConfig(event.getWorld()).buildPermissions) return;
 
         Object rootCause = event.getCause().getRootCause();
 
@@ -150,7 +149,7 @@ public class BuildPermissionListener extends AbstractListener {
 
     @EventHandler(ignoreCancelled = true)
     public void onUseEntity(UseEntityEvent event) {
-        if (!getWorldConfig(BukkitAdapter.adapt(event.getWorld())).buildPermissions) return;
+        if (!getWorldConfig(event.getWorld()).buildPermissions) return;
 
         Object rootCause = event.getCause().getRootCause();
 
@@ -168,7 +167,7 @@ public class BuildPermissionListener extends AbstractListener {
 
     @EventHandler(ignoreCancelled = true)
     public void onDamageEntity(DamageEntityEvent event) {
-        if (!getWorldConfig(BukkitAdapter.adapt(event.getWorld())).buildPermissions) return;
+        if (!getWorldConfig(event.getWorld()).buildPermissions) return;
 
         Object rootCause = event.getCause().getRootCause();
 
@@ -186,7 +185,7 @@ public class BuildPermissionListener extends AbstractListener {
 
     @EventHandler(ignoreCancelled = true)
     public void onUseItem(UseItemEvent event) {
-        if (!getWorldConfig(BukkitAdapter.adapt(event.getWorld())).buildPermissions) return;
+        if (!getWorldConfig(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 = (BukkitWorldConfiguration) getWorldConfig(WorldGuardPlugin.inst().wrapPlayer(player));
+            final BukkitWorldConfiguration wcfg = getWorldConfig(event.getWorld());
 
             // 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 = (BukkitWorldConfiguration) getWorldConfig(BukkitAdapter.adapt(event.getWorld()));
+        final BukkitWorldConfiguration wcfg = getWorldConfig(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 = (BukkitWorldConfiguration) getWorldConfig(BukkitAdapter.adapt(event.getWorld()));
+        final BukkitWorldConfiguration wcfg = getWorldConfig(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();
-        BukkitWorldConfiguration wcfg = (BukkitWorldConfiguration) getWorldConfig(WorldGuardPlugin.inst().wrapPlayer(player));
+        final BukkitWorldConfiguration wcfg = getWorldConfig(event.getBlock().getWorld());
 
         if (wcfg.signChestProtection) {
             if ("[Lock]".equalsIgnoreCase(event.getLine(0))) {

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

@@ -21,9 +21,7 @@ package com.sk89q.worldguard.bukkit.listener;
 
 import static com.sk89q.worldguard.bukkit.cause.Cause.create;
 
-import com.sk89q.worldedit.bukkit.BukkitAdapter;
-import com.sk89q.worldguard.WorldGuard;
-import com.sk89q.worldguard.bukkit.BukkitWorldConfiguration;
+import com.destroystokyo.paper.event.entity.EntityZapEvent;
 import com.sk89q.worldguard.bukkit.WorldGuardPlugin;
 import com.sk89q.worldguard.bukkit.cause.Cause;
 import com.sk89q.worldguard.bukkit.event.DelegateEvent;
@@ -48,11 +46,13 @@ 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 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;
@@ -83,6 +83,7 @@ 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;
@@ -112,6 +113,7 @@ 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;
@@ -139,9 +141,11 @@ import org.bukkit.event.vehicle.VehicleDamageEvent;
 import org.bukkit.event.vehicle.VehicleDestroyEvent;
 import org.bukkit.event.world.StructureGrowEvent;
 import org.bukkit.inventory.EquipmentSlot;
-import org.bukkit.inventory.Inventory;
 import org.bukkit.inventory.InventoryHolder;
 import org.bukkit.inventory.ItemStack;
+import org.bukkit.plugin.PluginManager;
+import org.bukkit.potion.PotionEffect;
+import org.bukkit.potion.PotionEffectType;
 import org.bukkit.projectiles.ProjectileSource;
 import org.bukkit.util.Vector;
 
@@ -159,17 +163,6 @@ public class EventAbstractionListener extends AbstractListener {
     private final EventDebounce<BlockPistonRetractKey> pistonRetractDebounce = EventDebounce.create(5000);
     private final EventDebounce<BlockPistonExtendKey> pistonExtendDebounce = EventDebounce.create(5000);
 
-    private static final boolean HAS_SNAPSHOT_INVHOLDER;
-    static {
-        boolean temp;
-        try {
-            Inventory.class.getMethod("getHolder", boolean.class);
-            temp = true;
-        } catch (NoSuchMethodException e) {
-            temp = false;
-        }
-        HAS_SNAPSHOT_INVHOLDER = temp;
-    }
     /**
      * Construct the listener.
      *
@@ -179,6 +172,17 @@ 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
     //-------------------------------------------------------------------------
@@ -297,6 +301,18 @@ public class EventAbstractionListener extends AbstractListener {
         }
     }
 
+    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();
@@ -307,23 +323,12 @@ 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);
-            if (trample) {
-                breakDelagate.setSilent(true);
-                breakDelagate.getRelevantFlags().add(Flags.TRAMPLE_BLOCKS);
-            } else if (fromType == Material.REDSTONE_ORE) {
-                breakDelagate.setSilent(true);
-            }
+            setDelegateEventMaterialOptions(breakDelagate, fromType, toType);
             boolean denied;
             if (!(denied = Events.fireToCancel(event, breakDelagate))) {
                 PlaceBlockEvent placeDelegate = new PlaceBlockEvent(event, cause, block.getLocation(), toType);
-                if (trample) {
-                    placeDelegate.setSilent(true);
-                    placeDelegate.getRelevantFlags().add(Flags.TRAMPLE_BLOCKS);
-                } else if (fromType == Material.REDSTONE_ORE) {
-                    placeDelegate.setSilent(true);
-                }
+                setDelegateEventMaterialOptions(placeDelegate, fromType, toType);
                 denied = Events.fireToCancel(event, placeDelegate);
             }
             if (denied && entity instanceof Player) {
@@ -467,7 +472,11 @@ public class EventAbstractionListener extends AbstractListener {
                         return;
                     }
                     DelegateEvent firedEvent = new UseBlockEvent(event, cause, clicked).setAllowed(hasInteractBypass(clicked));
-                    if (clicked.getType() == Material.REDSTONE_ORE) {
+                    if (Tag.REDSTONE_ORES.isTagged(clicked.getType())) {
+                        firedEvent.setSilent(true);
+                    }
+                    if (clicked.getType() == Material.BIG_DRIPLEAF) {
+                        firedEvent.getRelevantFlags().add(Flags.USE_DRIPLEAF);
                         firedEvent.setSilent(true);
                     }
                     interactDebounce.debounce(clicked, event.getPlayer(), event, firedEvent);
@@ -539,7 +548,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 && ((BukkitWorldConfiguration) getWorldConfig(BukkitAdapter.adapt(player.getWorld()))).blockUseAtFeet.test(item)) {
+                if (item != null && getWorldConfig(player.getWorld()).blockUseAtFeet.test(item)) {
                     if (Events.fireAndTestCancel(new UseBlockEvent(event, cause, player.getLocation().getBlock()))) {
                         event.setUseInteractedBlock(Result.DENY);
                     }
@@ -660,7 +669,7 @@ public class EventAbstractionListener extends AbstractListener {
 
     @EventHandler(ignoreCancelled = true)
     public void onBlockFromTo(BlockFromToEvent event) {
-        WorldConfiguration config = getWorldConfig(BukkitAdapter.adapt(event.getBlock().getWorld()));
+        WorldConfiguration config = getWorldConfig(event.getBlock().getWorld());
 
         // This only applies to regions but nothing else cares about high
         // frequency events at the moment
@@ -706,7 +715,7 @@ public class EventAbstractionListener extends AbstractListener {
             case DISPENSE_EGG:
             case EGG:
             case SPAWNER_EGG:
-                if (getWorldConfig(BukkitAdapter.adapt(event.getEntity().getWorld())).strictEntitySpawn) {
+                if (getWorldConfig(event.getEntity().getWorld()).strictEntitySpawn) {
                     Events.fireToCancel(event, new SpawnEntityEvent(event, Cause.unknown(), event.getEntity()));
                 }
                 break;
@@ -911,6 +920,12 @@ 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()));
@@ -941,34 +956,22 @@ public class EventAbstractionListener extends AbstractListener {
 
     @EventHandler(ignoreCancelled = true)
     public void onInventoryMoveItem(InventoryMoveItemEvent event) {
-        InventoryHolder causeHolder;
-        if (HAS_SNAPSHOT_INVHOLDER) {
-            causeHolder = event.getInitiator().getHolder(false);
-        } else {
-            causeHolder = event.getInitiator().getHolder();
-        }
+        InventoryHolder causeHolder = PaperLib.getHolder(event.getInitiator(), false).getHolder();
 
         WorldConfiguration wcfg = null;
         if (causeHolder instanceof Hopper
-                && (wcfg = getWorldConfig(BukkitAdapter.adapt((((Hopper) causeHolder).getWorld())))).ignoreHopperMoveEvents) {
+                && (wcfg = getWorldConfig((((Hopper) causeHolder).getWorld()))).ignoreHopperMoveEvents) {
             return;
         } else if (causeHolder instanceof HopperMinecart
-                && (wcfg = getWorldConfig(BukkitAdapter.adapt((((HopperMinecart) causeHolder).getWorld())))).ignoreHopperMoveEvents) {
+                && (wcfg = getWorldConfig((((HopperMinecart) causeHolder).getWorld()))).ignoreHopperMoveEvents) {
             return;
         }
 
         Entry entry;
 
         if ((entry = moveItemDebounce.tryDebounce(event)) != null) {
-            InventoryHolder sourceHolder;
-            InventoryHolder targetHolder;
-            if (HAS_SNAPSHOT_INVHOLDER) {
-                sourceHolder = event.getSource().getHolder(false);
-                targetHolder = event.getDestination().getHolder(false);
-            } else {
-                sourceHolder = event.getSource().getHolder();
-                targetHolder = event.getDestination().getHolder();
-            }
+            InventoryHolder sourceHolder = PaperLib.getHolder(event.getSource(), false).getHolder();
+            InventoryHolder targetHolder = PaperLib.getHolder(event.getDestination(), false).getHolder();
 
             Cause cause;
 
@@ -1025,7 +1028,7 @@ public class EventAbstractionListener extends AbstractListener {
                 }
             }
 
-            if (blocked == affectedSize) { // server does weird things with this if the event is modified, so use cached number
+            if (affectedSize > 0 && blocked == affectedSize) { // server does weird things with this if the event is modified, so use cached number
                 event.setCancelled(true);
             }
         }
@@ -1050,9 +1053,14 @@ public class EventAbstractionListener extends AbstractListener {
             handleBlockRightClick(event, cause, item, clicked, placed);
 
             // handle special dispenser behavior
-            if (item != null && Materials.isShulkerBox(item.getType())) {
-                Events.fireToCancel(event, new PlaceBlockEvent(event, cause, placed.getLocation(), item.getType()));
-                return;
+            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());
+                }
             }
         }
     }
@@ -1076,7 +1084,16 @@ public class EventAbstractionListener extends AbstractListener {
 
     @EventHandler(ignoreCancelled = true)
     public void onLingeringApply(AreaEffectCloudApplyEvent event) {
-        if (!Materials.hasDamageEffect(event.getEntity().getCustomEffects())) {
+        AreaEffectCloud entity = event.getEntity();
+        List<PotionEffect> effects = new ArrayList<>();
+        PotionEffectType baseEffectType = entity.getBasePotionData().getType().getEffectType();
+        if (baseEffectType != null) {
+            effects.add(new PotionEffect(baseEffectType, 0, 0));
+        }
+        if (entity.hasCustomEffects()) {
+            effects.addAll(entity.getCustomEffects());
+        }
+        if (!Materials.hasDamageEffect(effects)) {
             return;
         }
         Cause cause = create(event.getEntity());
@@ -1161,9 +1178,12 @@ public class EventAbstractionListener extends AbstractListener {
         }
 
         // Handle created spawn eggs
-        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;
+        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;
+            }
         }
 
         // handle water/lava placement
@@ -1179,8 +1199,7 @@ public class EventAbstractionListener extends AbstractListener {
             return;
         }
 
-        if (holder instanceof Entity) {
-            Entity entity = (Entity) holder;
+        if (holder instanceof Entity entity) {
             Material mat = Materials.getRelatedMaterial((entity).getType());
             UseEntityEvent useEntityEvent = new UseEntityEvent(originalEvent, cause, entity);
             if (mat != null && hasInteractBypass((entity).getWorld(), mat)) {
@@ -1188,8 +1207,7 @@ public class EventAbstractionListener extends AbstractListener {
             }
             Events.fireToCancel(originalEvent, useEntityEvent);
         } else {
-            if (holder instanceof BlockState) {
-                final BlockState block = (BlockState) holder;
+            if (holder instanceof BlockState block && block.isPlaced()) {
                 final UseBlockEvent useBlockEvent = new UseBlockEvent(originalEvent, cause, block.getBlock());
                 if (hasInteractBypass(block.getWorld(), block.getType())) {
                     useBlockEvent.setAllowed(true);
@@ -1209,15 +1227,15 @@ public class EventAbstractionListener extends AbstractListener {
     }
 
     private static boolean hasInteractBypass(Block block) {
-        return ((BukkitWorldConfiguration) getWorldConfig(BukkitAdapter.adapt(block.getWorld()))).allowAllInteract.test(block);
+        return getWorldConfig(block.getWorld()).allowAllInteract.test(block);
     }
 
     private static boolean hasInteractBypass(World world, Material material) {
-        return ((BukkitWorldConfiguration) getWorldConfig(BukkitAdapter.adapt(world))).allowAllInteract.test(material);
+        return getWorldConfig(world).allowAllInteract.test(material);
     }
 
     private static boolean hasInteractBypass(World world, ItemStack item) {
-        return ((BukkitWorldConfiguration) getWorldConfig(BukkitAdapter.adapt(world))).allowAllInteract.test(item);
+        return getWorldConfig(world).allowAllInteract.test(item);
     }
 
     private static boolean isBlockModifiedOnClick(Block block, boolean rightClick) {
@@ -1232,15 +1250,21 @@ public class EventAbstractionListener extends AbstractListener {
 
     private static void playDenyEffect(Player player, Location location) {
         //player.playSound(location, Sound.SUCCESSFUL_HIT, 0.2f, 0.4f);
-        if (WorldGuard.getInstance().getPlatform().getGlobalStateManager().particleEffects) {
+        if (getConfig().particleEffects) {
             player.playEffect(location, Effect.SMOKE, BlockFace.UP);
         }
     }
 
     private static void playDenyEffect(Location location) {
-        if (WorldGuard.getInstance().getPlatform().getGlobalStateManager().particleEffects) {
+        if (getConfig().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()));
+        }
+    }
 }

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

@@ -19,11 +19,10 @@
 
 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;
@@ -59,14 +58,11 @@ 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 player = (Player) victim;
+        if (victim instanceof Player player) {
             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);
@@ -79,7 +75,7 @@ public class InvincibilityListener extends AbstractListener {
                         attacker = (Entity) ((Projectile) attacker).getShooter();
                     }
 
-                    if (worldConfig.regionInvinciblityRemovesMobs
+                    if (getWorldConfig(player.getWorld()).regionInvinciblityRemovesMobs
                             && attacker instanceof LivingEntity && !(attacker instanceof Player)
                             && !(attacker instanceof Tameable && ((Tameable) attacker).isTamed())) {
                         attacker.remove();
@@ -92,9 +88,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 player = (Player) entity;
+        if (entity instanceof Player player) {
             LocalPlayer localPlayer = WorldGuardPlugin.inst().wrapPlayer(player);
 
             if (isInvincible(localPlayer)) {
@@ -105,8 +101,9 @@ public class InvincibilityListener extends AbstractListener {
 
     @EventHandler(ignoreCancelled = true)
     public void onFoodLevelChange(FoodLevelChangeEvent event) {
-        if (event.getEntity() instanceof Player) {
-            Player player = (Player) event.getEntity();
+        if (Entities.isNPC(event.getEntity())) return;
+
+        if (event.getEntity() instanceof Player player) {
             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

@@ -28,8 +28,8 @@ import com.sk89q.worldguard.session.Session;
 import io.papermc.lib.PaperLib;
 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;
@@ -43,27 +43,26 @@ import org.bukkit.plugin.PluginManager;
 import org.bukkit.util.Vector;
 import org.spigotmc.event.entity.EntityMountEvent;
 
-public class PlayerMoveListener implements Listener {
-
-    private final WorldGuardPlugin plugin;
+public class PlayerMoveListener extends AbstractListener {
 
     public PlayerMoveListener(WorldGuardPlugin plugin) {
-        this.plugin = plugin;
+        super(plugin);
     }
 
+    @Override
     public void registerEvents() {
         if (WorldGuard.getInstance().getPlatform().getGlobalStateManager().usePlayerMove) {
-            PluginManager pm = plugin.getServer().getPluginManager();
-            pm.registerEvents(this, plugin);
+            PluginManager pm = getPlugin().getServer().getPluginManager();
+            pm.registerEvents(this, getPlugin());
             if (PaperLib.isSpigot()) {
-                pm.registerEvents(new EntityMountListener(), plugin);
+                pm.registerEvents(new EntityMountListener(), getPlugin());
             }
         }
     }
 
     @EventHandler
     public void onPlayerRespawn(PlayerRespawnEvent event) {
-        LocalPlayer player = plugin.wrapPlayer(event.getPlayer());
+        LocalPlayer player = getPlugin().wrapPlayer(event.getPlayer());
 
         Session session = WorldGuard.getInstance().getPlatform().getSessionManager().get(player);
         session.testMoveTo(player, BukkitAdapter.adapt(event.getRespawnLocation()), MoveType.RESPAWN, true);
@@ -73,7 +72,7 @@ public class PlayerMoveListener implements Listener {
     public void onVehicleEnter(VehicleEnterEvent event) {
         Entity entity = event.getEntered();
         if (entity instanceof Player) {
-            LocalPlayer player = plugin.wrapPlayer((Player) entity);
+            LocalPlayer player = getPlugin().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);
@@ -92,7 +91,7 @@ public class PlayerMoveListener implements Listener {
         }
 
         final Player player = event.getPlayer();
-        LocalPlayer localPlayer = plugin.wrapPlayer(player);
+        LocalPlayer localPlayer = getPlugin().wrapPlayer(player);
 
         Session session = WorldGuard.getInstance().getPlatform().getSessionManager().get(localPlayer);
         MoveType moveType = MoveType.MOVE;
@@ -100,7 +99,7 @@ public class PlayerMoveListener implements Listener {
             moveType = MoveType.GLIDE;
         } else if (event.getPlayer().isSwimming()) {
             moveType = MoveType.SWIM;
-        } else if (event.getPlayer().getVehicle() != null && event.getPlayer().getVehicle() instanceof Horse) {
+        } else if (event.getPlayer().getVehicle() != null && event.getPlayer().getVehicle() instanceof AbstractHorse) {
             moveType = MoveType.RIDE;
         }
         com.sk89q.worldedit.util.Location weLocation = session.testMoveTo(localPlayer, BukkitAdapter.adapt(to), moveType);
@@ -133,7 +132,7 @@ public class PlayerMoveListener implements Listener {
 
                 player.teleport(override.clone().add(0, 1, 0));
 
-                Bukkit.getScheduler().runTaskLater(plugin, () -> player.teleport(override.clone().add(0, 1, 0)), 1);
+                Bukkit.getScheduler().runTaskLater(getPlugin(), () -> player.teleport(override.clone().add(0, 1, 0)), 1);
             }
         }
     }
@@ -141,7 +140,7 @@ public class PlayerMoveListener implements Listener {
     @EventHandler
     public void onPlayerQuit(PlayerQuitEvent event) {
         final Player player = event.getPlayer();
-        LocalPlayer localPlayer = plugin.wrapPlayer(player);
+        LocalPlayer localPlayer = getPlugin().wrapPlayer(player);
 
         Session session = WorldGuard.getInstance().getPlatform().getSessionManager().get(localPlayer);
         com.sk89q.worldedit.util.Location loc = session.testMoveTo(localPlayer,
@@ -149,6 +148,8 @@ public class PlayerMoveListener implements Listener {
         if (loc != null) {
             player.teleport(BukkitAdapter.adapt(loc));
         }
+
+        session.uninitialize(localPlayer);
     }
 
     private class EntityMountListener implements Listener {
@@ -156,7 +157,7 @@ public class PlayerMoveListener implements Listener {
         public void onEntityMount(EntityMountEvent event) {
             Entity entity = event.getEntity();
             if (entity instanceof Player) {
-                LocalPlayer player = plugin.wrapPlayer((Player) entity);
+                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,6 +25,7 @@ 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;
@@ -57,8 +58,7 @@ public class RegionFlagsListener extends AbstractListener {
 
     @EventHandler(priority = EventPriority.LOW, ignoreCancelled = true)
     public void onPlaceBlock(final PlaceBlockEvent event) {
-        com.sk89q.worldedit.world.World weWorld = BukkitAdapter.adapt(event.getWorld());
-        if (!isRegionSupportEnabled(weWorld)) return; // Region support disabled
+        if (!isRegionSupportEnabled(event.getWorld())) return; // Region support disabled
 
         RegionQuery query = WorldGuard.getInstance().getPlatform().getRegionContainer().createQuery();
 
@@ -80,10 +80,9 @@ public class RegionFlagsListener extends AbstractListener {
 
     @EventHandler(priority = EventPriority.LOW, ignoreCancelled = true)
     public void onBreakBlock(final BreakBlockEvent event) {
-        com.sk89q.worldedit.world.World weWorld = BukkitAdapter.adapt(event.getWorld());
-        if (!isRegionSupportEnabled(weWorld)) return; // Region support disabled
+        if (!isRegionSupportEnabled(event.getWorld())) return; // Region support disabled
 
-        WorldConfiguration config = getWorldConfig(weWorld);
+        WorldConfiguration config = getWorldConfig(event.getWorld());
         RegionQuery query = WorldGuard.getInstance().getPlatform().getRegionContainer().createQuery();
 
         Block block;
@@ -118,26 +117,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 (entity instanceof Player && event.getCause() == DamageCause.FALL) {
-            LocalPlayer localPlayer = WorldGuardPlugin.inst().wrapPlayer((Player) entity);
+        if (event.getCause() == DamageCause.FALL) {
+            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;
-                }
+        } 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;
             }
         }
-
     }
 
     /**

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

@@ -136,15 +136,14 @@ public class RegionProtectionListener extends AbstractListener {
 
         if (rootCause instanceof Player) {
             Player player = (Player) rootCause;
-            LocalPlayer localPlayer = WorldGuardPlugin.inst().wrapPlayer(player);
-            com.sk89q.worldedit.world.World localWorld = BukkitAdapter.adapt(world);
-            WorldConfiguration config = getWorldConfig(localWorld);
+            WorldConfiguration config = getWorldConfig(world);
 
             if (config.fakePlayerBuildOverride && InteropUtils.isFakePlayer(player)) {
                 return true;
             }
 
-            return !pvp && WorldGuard.getInstance().getPlatform().getSessionManager().hasBypass(localPlayer, localWorld);
+            LocalPlayer localPlayer = WorldGuardPlugin.inst().wrapPlayer(player);
+            return !pvp && WorldGuard.getInstance().getPlatform().getSessionManager().hasBypass(localPlayer, localPlayer.getWorld());
         } else {
             return false;
         }
@@ -153,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(BukkitAdapter.adapt(event.getWorld()))) return; // Region support disabled
+        if (!isRegionSupportEnabled(event.getWorld())) return; // Region support disabled
         if (isWhitelisted(event.getCause(), event.getWorld(), false)) return; // Whitelisted cause
 
         final Material type = event.getEffectiveMaterial();
@@ -163,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(BukkitAdapter.adapt(event.getWorld())).checkLiquidFlow) {
+                && !getWorldConfig(event.getWorld()).checkLiquidFlow) {
             return;
         }
 
@@ -206,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(BukkitAdapter.adapt(event.getWorld()))) return; // Region support disabled
+        if (!isRegionSupportEnabled(event.getWorld())) return; // Region support disabled
         if (isWhitelisted(event.getCause(), event.getWorld(), false)) return; // Whitelisted cause
 
         final RegionQuery query = WorldGuard.getInstance().getPlatform().getRegionContainer().createQuery();
@@ -242,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(BukkitAdapter.adapt(event.getWorld()))) return; // Region support disabled
+        if (!isRegionSupportEnabled(event.getWorld())) return; // Region support disabled
         if (isWhitelisted(event.getCause(), event.getWorld(), false)) return; // Whitelisted cause
 
         final Material type = event.getEffectiveMaterial();
@@ -311,7 +310,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(BukkitAdapter.adapt(event.getWorld()))) return; // Region support disabled
+        if (!isRegionSupportEnabled(event.getWorld())) return; // Region support disabled
         if (isWhitelisted(event.getCause(), event.getWorld(), false)) return; // Whitelisted cause
 
         Location target = event.getTarget();
@@ -357,7 +356,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(BukkitAdapter.adapt(event.getWorld()))) return; // Region support disabled
+        if (!isRegionSupportEnabled(event.getWorld())) return; // Region support disabled
         if (isWhitelisted(event.getCause(), event.getWorld(), false)) return; // Whitelisted cause
 
         Location target = event.getTarget();
@@ -393,7 +392,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(BukkitAdapter.adapt(event.getWorld()))) return; // Region support disabled
+        if (!isRegionSupportEnabled(event.getWorld())) return; // Region support disabled
         if (isWhitelisted(event.getCause(), event.getWorld(), false)) return; // Whitelisted cause
 
         Location target = event.getTarget();
@@ -412,7 +411,8 @@ public class RegionProtectionListener extends AbstractListener {
             what = "use that";
         /* Paintings, item frames, etc. */
         } else if (Entities.isConsideredBuildingIfUsed(entity)) {
-            if (type == EntityType.ITEM_FRAME && event.getCause().getFirstPlayer() != null
+            if ((type == EntityType.ITEM_FRAME || type == EntityType.GLOW_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 +443,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(BukkitAdapter.adapt(event.getWorld()))) return; // Region support disabled
+        if (!isRegionSupportEnabled(event.getWorld())) return; // Region support disabled
         // Whitelist check is below
 
         com.sk89q.worldedit.util.Location target = BukkitAdapter.adapt(event.getTarget());
@@ -519,11 +519,10 @@ public class RegionProtectionListener extends AbstractListener {
     @EventHandler(ignoreCancelled = true)
     public void onVehicleExit(VehicleExitEvent event) {
         Entity vehicle = event.getVehicle();
-        if (!isRegionSupportEnabled(BukkitAdapter.adapt(vehicle.getWorld()))) return; // Region support disabled
+        if (!isRegionSupportEnabled(vehicle.getWorld())) return; // Region support disabled
         Entity exited = event.getExited();
 
-        if (vehicle instanceof Tameable && exited instanceof Player) {
-            Player player = (Player) exited;
+        if (vehicle instanceof Tameable && exited instanceof Player player && !Entities.isNPC(player)) {
             LocalPlayer localPlayer = WorldGuardPlugin.inst().wrapPlayer(player);
             if (!isWhitelisted(Cause.create(player), vehicle.getWorld(), false)) {
                 RegionQuery query = WorldGuard.getInstance().getPlatform().getRegionContainer().createQuery();
@@ -542,10 +541,6 @@ 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.
      *

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

@@ -41,7 +41,6 @@ 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;
@@ -63,12 +62,9 @@ import org.bukkit.inventory.meta.ItemMeta;
 
 /**
  * The listener for block events.
- *
- * @author sk89q
  */
-public class WorldGuardBlockListener implements Listener {
+public class WorldGuardBlockListener extends AbstractListener {
 
-    private WorldGuardPlugin plugin;
 
     /**
      * Construct the object.
@@ -76,34 +72,7 @@ public class WorldGuardBlockListener implements Listener {
      * @param plugin The plugin instance
      */
     public WorldGuardBlockListener(WorldGuardPlugin plugin) {
-        this.plugin = plugin;
-    }
-
-    /**
-     * Register events.
-     */
-    public void registerEvents() {
-        plugin.getServer().getPluginManager().registerEvents(this, plugin);
-    }
-
-    /**
-     * Get the world configuration given a world.
-     *
-     * @param world The world to get the configuration for.
-     * @return The configuration for {@code world}
-     */
-    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());
+        super(plugin);
     }
 
     /*
@@ -112,7 +81,7 @@ public class WorldGuardBlockListener implements Listener {
     @EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
     public void onBlockBreak(BlockBreakEvent event) {
         Player player = event.getPlayer();
-        WorldConfiguration wcfg = getWorldConfig(player);
+        WorldConfiguration wcfg = getWorldConfig(player.getWorld());
 
         if (!wcfg.itemDurability) {
             ItemStack held = player.getInventory().getItemInMainHand();
@@ -134,19 +103,20 @@ public class WorldGuardBlockListener implements Listener {
         Block blockFrom = event.getBlock();
         Block blockTo = event.getToBlock();
 
-        Material fromType = blockFrom.getType();
-        boolean isWater = Materials.isWater(fromType);
-        boolean isLava = fromType == Material.LAVA;
-        boolean isAir = fromType == Material.AIR;
-
-        ConfigurationManager cfg = WorldGuard.getInstance().getPlatform().getGlobalStateManager();
-        WorldConfiguration wcfg = getWorldConfig(event.getBlock().getWorld());
+        ConfigurationManager cfg = getConfig();
 
         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();
@@ -220,13 +190,14 @@ public class WorldGuardBlockListener implements Listener {
         Block block = event.getBlock();
         World world = block.getWorld();
 
-        ConfigurationManager cfg = WorldGuard.getInstance().getPlatform().getGlobalStateManager();
-        WorldConfiguration wcfg = getWorldConfig(world);
+        ConfigurationManager cfg = getConfig();
 
         if (cfg.activityHaltToggle) {
             event.setCancelled(true);
             return;
         }
+
+        WorldConfiguration wcfg = getWorldConfig(world);
         boolean isFireSpread = cause == IgniteCause.SPREAD;
 
         if (wcfg.preventLightningFire && cause == IgniteCause.LIGHTNING) {
@@ -246,7 +217,7 @@ public class WorldGuardBlockListener implements Listener {
 
         if (wcfg.blockLighter && (cause == IgniteCause.FLINT_AND_STEEL || cause == IgniteCause.FIREBALL)
                 && event.getPlayer() != null
-                && !plugin.hasPermission(event.getPlayer(), "worldguard.override.lighter")) {
+                && !getPlugin().hasPermission(event.getPlayer(), "worldguard.override.lighter")) {
             event.setCancelled(true);
             return;
         }
@@ -307,14 +278,15 @@ public class WorldGuardBlockListener implements Listener {
      */
     @EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
     public void onBlockBurn(BlockBurnEvent event) {
-        ConfigurationManager cfg = WorldGuard.getInstance().getPlatform().getGlobalStateManager();
-        BukkitWorldConfiguration wcfg = (BukkitWorldConfiguration) getWorldConfig(event.getBlock().getWorld());
+        ConfigurationManager cfg = getConfig();
 
         if (cfg.activityHaltToggle) {
             event.setCancelled(true);
             return;
         }
 
+        BukkitWorldConfiguration wcfg = getWorldConfig(event.getBlock().getWorld());
+
         if (wcfg.disableFireSpread) {
             event.setCancelled(true);
             return;
@@ -378,22 +350,22 @@ public class WorldGuardBlockListener implements Listener {
      */
     @EventHandler(ignoreCancelled = true)
     public void onBlockPhysics(BlockPhysicsEvent event) {
-        ConfigurationManager cfg = WorldGuard.getInstance().getPlatform().getGlobalStateManager();
-        WorldConfiguration wcfg = getWorldConfig(event.getBlock().getWorld());
+        ConfigurationManager cfg = getConfig();
 
         if (cfg.activityHaltToggle) {
             event.setCancelled(true);
             return;
         }
 
-        Material id = event.getBlock().getType();
+        WorldConfiguration wcfg = getWorldConfig(event.getBlock().getWorld());
+        final Material id = event.getBlock().getType();
 
         if (id == Material.GRAVEL && wcfg.noPhysicsGravel) {
             event.setCancelled(true);
             return;
         }
 
-        if (id == Material.SAND && wcfg.noPhysicsSand) {
+        if ((id == Material.SAND || id == Material.RED_SAND) && wcfg.noPhysicsSand) {
             event.setCancelled(true);
             return;
         }
@@ -403,7 +375,7 @@ public class WorldGuardBlockListener implements Listener {
             return;
         }
 
-        if (wcfg.ropeLadders && event.getBlock().getType() == Material.LADDER) {
+        if (id == Material.LADDER && wcfg.ropeLadders) {
             if (event.getBlock().getRelative(0, 1, 0).getType() == Material.LADDER) {
                 event.setCancelled(true);
                 return;
@@ -470,14 +442,15 @@ public class WorldGuardBlockListener implements Listener {
 
     @EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
     public void onLeavesDecay(LeavesDecayEvent event) {
-        ConfigurationManager cfg = WorldGuard.getInstance().getPlatform().getGlobalStateManager();
-        WorldConfiguration wcfg = getWorldConfig(event.getBlock().getWorld());
+        ConfigurationManager cfg = getConfig();
 
         if (cfg.activityHaltToggle) {
             event.setCancelled(true);
             return;
         }
 
+        WorldConfiguration wcfg = getWorldConfig(event.getBlock().getWorld());
+
         if (wcfg.disableLeafDecay) {
             event.setCancelled(true);
             return;
@@ -495,14 +468,16 @@ public class WorldGuardBlockListener implements Listener {
      */
     @EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
     public void onBlockForm(BlockFormEvent event) {
-        ConfigurationManager cfg = WorldGuard.getInstance().getPlatform().getGlobalStateManager();
-        WorldConfiguration wcfg = getWorldConfig(event.getBlock().getWorld());
+        ConfigurationManager cfg = getConfig();
+
 
         if (cfg.activityHaltToggle) {
             event.setCancelled(true);
             return;
         }
 
+        WorldConfiguration wcfg = getWorldConfig(event.getBlock().getWorld());
+
         Material type = event.getNewState().getType();
 
         if (event instanceof EntityBlockFormEvent) {
@@ -553,14 +528,14 @@ public class WorldGuardBlockListener implements Listener {
      */
     @EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
     public void onBlockSpread(BlockSpreadEvent event) {
-        ConfigurationManager cfg = WorldGuard.getInstance().getPlatform().getGlobalStateManager();
-        WorldConfiguration wcfg = getWorldConfig(event.getBlock().getWorld());
+        ConfigurationManager cfg = getConfig();
 
         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)) {
@@ -613,6 +588,32 @@ public class WorldGuardBlockListener implements Listener {
             }
         }
 
+        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);
     }
 
@@ -628,7 +629,7 @@ public class WorldGuardBlockListener implements Listener {
         WorldConfiguration wcfg = getWorldConfig(loc.getWorld());
         if (Materials.isCrop(type)) {
             if (wcfg.disableCropGrowth) {
-                event.setCancelled(false);
+                event.setCancelled(true);
                 return;
             }
 
@@ -696,12 +697,22 @@ public class WorldGuardBlockListener implements Listener {
                 event.setCancelled(true);
                 return;
             }
+        } else 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;
+            }
         }
     }
 
     @EventHandler(ignoreCancelled = true)
     public void onBlockExplode(BlockExplodeEvent event) {
-        ConfigurationManager cfg = WorldGuard.getInstance().getPlatform().getGlobalStateManager();
+        ConfigurationManager cfg = getConfig();
 
         if (cfg.activityHaltToggle) {
             event.setCancelled(true);

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

@@ -25,13 +25,17 @@ 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;
@@ -62,7 +66,6 @@ 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;
@@ -91,12 +94,8 @@ import java.util.Set;
 
 /**
  * Listener for entity related events.
- *
- * @author sk89q
  */
-public class WorldGuardEntityListener implements Listener {
-
-    private WorldGuardPlugin plugin;
+public class WorldGuardEntityListener extends AbstractListener {
 
     /**
      * Construct the object;
@@ -104,23 +103,14 @@ public class WorldGuardEntityListener implements Listener {
      * @param plugin The plugin instance
      */
     public WorldGuardEntityListener(WorldGuardPlugin plugin) {
-        this.plugin = plugin;
-    }
-
-    /**
-     * Register events.
-     */
-    public void registerEvents() {
-        plugin.getServer().getPluginManager().registerEvents(this, plugin);
+        super(plugin);
     }
 
     @EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
     public void onEntityInteract(EntityInteractEvent event) {
-        Entity entity = event.getEntity();
         Block block = event.getBlock();
 
-        ConfigurationManager cfg = WorldGuard.getInstance().getPlatform().getGlobalStateManager();
-        WorldConfiguration wcfg = cfg.get(BukkitAdapter.adapt(entity.getWorld()));
+        WorldConfiguration wcfg = getWorldConfig(block.getWorld());
 
         if (block.getType() == Material.FARMLAND && wcfg.disableCreatureCropTrampling) {
             event.setCancelled(true);
@@ -134,8 +124,7 @@ public class WorldGuardEntityListener implements Listener {
 
     @EventHandler(priority = EventPriority.HIGH)
     public void onEntityDeath(EntityDeathEvent event) {
-        WorldConfiguration wcfg =
-                WorldGuard.getInstance().getPlatform().getGlobalStateManager().get(BukkitAdapter.adapt(event.getEntity().getWorld()));
+        WorldConfiguration wcfg = getWorldConfig(event.getEntity().getWorld());
 
         if (event instanceof PlayerDeathEvent && wcfg.disableDeathMessages) {
             ((PlayerDeathEvent) event).setDeathMessage("");
@@ -146,16 +135,14 @@ public class WorldGuardEntityListener implements Listener {
         Entity defender = event.getEntity();
         DamageCause type = event.getCause();
 
-        ConfigurationManager cfg = WorldGuard.getInstance().getPlatform().getGlobalStateManager();
-        WorldConfiguration wcfg = cfg.get(BukkitAdapter.adapt(defender.getWorld()));
+        WorldConfiguration wcfg = getWorldConfig(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 player = (Player) defender;
+        } else if (defender instanceof Player player && !Entities.isNPC(defender)) {
             LocalPlayer localPlayer = WorldGuardPlugin.inst().wrapPlayer(player);
 
             if (wcfg.disableLavaDamage && type == DamageCause.LAVA) {
@@ -197,7 +184,7 @@ public class WorldGuardEntityListener implements Listener {
             // handled anywhere else
             if (type == DamageCause.BLOCK_EXPLOSION
                     && (wcfg.blockOtherExplosions
-                            || (wcfg.explosionFlagCancellation
+                            || ((wcfg.explosionFlagCancellation || Entities.isConsideredBuildingIfUsed(defender))
                                 && !StateFlag.test(WorldGuard.getInstance().getPlatform().getRegionContainer().createQuery()
                     .queryState(BukkitAdapter.adapt(defender.getLocation()), (RegionAssociable) null, Flags.OTHER_EXPLOSION))))) {
                 event.setCancelled(true);
@@ -217,8 +204,7 @@ public class WorldGuardEntityListener implements Listener {
         Entity attacker = event.getDamager();
         Entity defender = event.getEntity();
 
-        WorldConfiguration wcfg =
-                WorldGuard.getInstance().getPlatform().getGlobalStateManager().get(BukkitAdapter.adapt(defender.getWorld()));
+        WorldConfiguration wcfg = getWorldConfig(defender.getWorld());
 
         if (defender instanceof ItemFrame) {
             if (checkItemFrameProtection(attacker, (ItemFrame) defender)) {
@@ -244,9 +230,8 @@ public class WorldGuardEntityListener implements Listener {
             }
         }
 
-        if (defender instanceof Player) {
-            Player player = (Player) defender;
-            LocalPlayer localPlayer = plugin.wrapPlayer(player);
+        if (defender instanceof Player player && !Entities.isNPC(defender)) {
+            LocalPlayer localPlayer = getPlugin().wrapPlayer(player);
 
             if (wcfg.disableLightningDamage && event.getCause() == DamageCause.LIGHTNING) {
                 event.setCancelled(true);
@@ -305,11 +290,9 @@ public class WorldGuardEntityListener implements Listener {
             return;
         }
 
-        ConfigurationManager cfg = WorldGuard.getInstance().getPlatform().getGlobalStateManager();
-        WorldConfiguration wcfg = cfg.get(BukkitAdapter.adapt(defender.getWorld()));
-        if (defender instanceof Player) {
-            Player player = (Player) defender;
-            LocalPlayer localPlayer = plugin.wrapPlayer(player);
+        WorldConfiguration wcfg = getWorldConfig(defender.getWorld());
+        if (defender instanceof Player player && !Entities.isNPC(defender)) {
+            LocalPlayer localPlayer = getPlugin().wrapPlayer(player);
 
 
             // Check Mob
@@ -374,16 +357,14 @@ public class WorldGuardEntityListener implements Listener {
         Entity defender = event.getEntity();
         DamageCause type = event.getCause();
 
-        ConfigurationManager cfg = WorldGuard.getInstance().getPlatform().getGlobalStateManager();
-        WorldConfiguration wcfg = cfg.get(BukkitAdapter.adapt(defender.getWorld()));
+        WorldConfiguration wcfg = getWorldConfig(defender.getWorld());
 
         if (defender instanceof Wolf && ((Wolf) defender).isTamed()) {
             if (wcfg.antiWolfDumbness) {
                 event.setCancelled(true);
                 return;
             }
-        } else if (defender instanceof Player) {
-            Player player = (Player) defender;
+        } else if (defender instanceof Player player && !Entities.isNPC(defender)) {
             LocalPlayer localPlayer = WorldGuardPlugin.inst().wrapPlayer(player);
 
             if (type == DamageCause.WITHER) {
@@ -396,14 +377,14 @@ public class WorldGuardEntityListener implements Listener {
                 if (wcfg.useRegions) {
                     ApplicableRegionSet set = WorldGuard.getInstance().getPlatform().getRegionContainer().createQuery().getApplicableRegions(localPlayer.getLocation());
 
-                    if (!set.testState(plugin.wrapPlayer(player), Flags.MOB_DAMAGE)) {
+                    if (!set.testState(getPlugin().wrapPlayer(player), Flags.MOB_DAMAGE)) {
                         event.setCancelled(true);
                         return;
                     }
                 }
             }
 
-            if (type == DamageCause.DROWNING && cfg.hasAmphibiousMode(localPlayer)) {
+            if (type == DamageCause.DROWNING && getConfig().hasAmphibiousMode(localPlayer)) {
                 player.setRemainingAir(player.getMaximumAir());
                 event.setCancelled(true);
                 return;
@@ -455,10 +436,7 @@ public class WorldGuardEntityListener implements Listener {
      */
     @EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
     public void onEntityExplode(EntityExplodeEvent event) {
-        ConfigurationManager cfg = WorldGuard.getInstance().getPlatform().getGlobalStateManager();
-        Location l = event.getLocation();
-        World world = l.getWorld();
-        BukkitWorldConfiguration wcfg = (BukkitWorldConfiguration) cfg.get(BukkitAdapter.adapt(world));
+        ConfigurationManager cfg = getConfig();
         Entity ent = event.getEntity();
 
         if (cfg.activityHaltToggle) {
@@ -467,6 +445,7 @@ public class WorldGuardEntityListener implements Listener {
             return;
         }
 
+        BukkitWorldConfiguration wcfg = getWorldConfig(event.getLocation().getWorld());
         if (ent instanceof Creeper) {
             if (wcfg.blockCreeperExplosions) {
                 event.setCancelled(true);
@@ -573,8 +552,7 @@ public class WorldGuardEntityListener implements Listener {
      */
     @EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
     public void onExplosionPrime(ExplosionPrimeEvent event) {
-        ConfigurationManager cfg = WorldGuard.getInstance().getPlatform().getGlobalStateManager();
-        WorldConfiguration wcfg = cfg.get(BukkitAdapter.adapt(event.getEntity().getWorld()));
+        ConfigurationManager cfg = getConfig();
         Entity ent = event.getEntity();
 
         if (cfg.activityHaltToggle) {
@@ -583,6 +561,7 @@ public class WorldGuardEntityListener implements Listener {
             return;
         }
 
+        BukkitWorldConfiguration wcfg = getWorldConfig(ent.getWorld());
         if (event.getEntityType() == EntityType.WITHER) {
             if (wcfg.blockWitherExplosions) {
                 event.setCancelled(true);
@@ -614,14 +593,14 @@ public class WorldGuardEntityListener implements Listener {
 
     @EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
     public void onCreatureSpawn(CreatureSpawnEvent event) {
-        ConfigurationManager cfg = WorldGuard.getInstance().getPlatform().getGlobalStateManager();
+        ConfigurationManager cfg = getConfig();
 
         if (cfg.activityHaltToggle) {
             event.setCancelled(true);
             return;
         }
 
-        WorldConfiguration wcfg = cfg.get(BukkitAdapter.adapt(event.getEntity().getWorld()));
+        WorldConfiguration wcfg = getWorldConfig(event.getEntity().getWorld());
 
         // allow spawning of creatures from plugins
         if (!wcfg.blockPluginSpawning && event.getSpawnReason() == CreatureSpawnEvent.SpawnReason.CUSTOM) {
@@ -676,37 +655,48 @@ public class WorldGuardEntityListener implements Listener {
 
     @EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
     public void onCreatePortal(PortalCreateEvent event) {
-        ConfigurationManager cfg = WorldGuard.getInstance().getPlatform().getGlobalStateManager();
-        final com.sk89q.worldedit.world.World world = BukkitAdapter.adapt(event.getWorld());
-        WorldConfiguration wcfg = cfg.get(world);
+        WorldConfiguration wcfg = getWorldConfig(event.getWorld());
 
-        if (wcfg.regionNetherPortalProtection
+        if (wcfg.useRegions && wcfg.regionNetherPortalProtection
                 && event.getReason() == PortalCreateEvent.CreateReason.NETHER_PAIR
                 && !event.getBlocks().isEmpty()) {
-            final RegionManager regionManager = WorldGuard.getInstance().getPlatform().getRegionContainer()
-                    .get(world);
-            if (regionManager == null) return;
-            LocalPlayer associable = null;
-            if (event.getEntity() instanceof Player) {
-                associable = plugin.wrapPlayer(((Player) event.getEntity()));
-                if (WorldGuard.getInstance().getPlatform().getSessionManager().hasBypass(associable, world)) {
+            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;
                 }
             }
-            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);
+            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);
+                }
+                ProtectedCuboidRegion target = new ProtectedCuboidRegion("__portal_check", true, min, max);
+                regions = regionManager.getApplicableRegions(target);
             }
-            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) {
+            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()) {
                     // NB there is no way to cancel the teleport without PTA (since PlayerPortal doesn't have block info)
                     // removing PTA was a mistake
-                    associable.print("Destination is an a protected area.");
+                    String message = regions.queryValue(localPlayer, Flags.DENY_MESSAGE);
+                    RegionProtectionListener.formatAndSendDenyMessage("create portals", localPlayer, message);
                 }
                 event.setCancelled(true);
             }
@@ -721,9 +711,8 @@ public class WorldGuardEntityListener implements Listener {
 
     @EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
     public void onEntityTransform(EntityTransformEvent event) {
-        ConfigurationManager cfg = WorldGuard.getInstance().getPlatform().getGlobalStateManager();
         final Entity entity = event.getEntity();
-        WorldConfiguration wcfg = cfg.get(BukkitAdapter.adapt(entity.getWorld()));
+        WorldConfiguration wcfg = getWorldConfig(entity.getWorld());
 
         final EntityType type = entity.getType();
         if (wcfg.disableVillagerZap && type == EntityType.VILLAGER
@@ -734,9 +723,8 @@ public class WorldGuardEntityListener implements Listener {
 
     @EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
     public void onPigZap(PigZapEvent event) {
-        ConfigurationManager cfg = WorldGuard.getInstance().getPlatform().getGlobalStateManager();
         final Entity entity = event.getEntity();
-        WorldConfiguration wcfg = cfg.get(BukkitAdapter.adapt(entity.getWorld()));
+        WorldConfiguration wcfg = getWorldConfig(entity.getWorld());
 
         if (wcfg.disablePigZap) {
             event.setCancelled(true);
@@ -745,8 +733,8 @@ public class WorldGuardEntityListener implements Listener {
 
     @EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
     public void onCreeperPower(CreeperPowerEvent event) {
-        ConfigurationManager cfg = WorldGuard.getInstance().getPlatform().getGlobalStateManager();
-        WorldConfiguration wcfg = cfg.get(BukkitAdapter.adapt(event.getEntity().getWorld()));
+        final Entity entity = event.getEntity();
+        WorldConfiguration wcfg = getWorldConfig(entity.getWorld());
 
         if (wcfg.disableCreeperPower) {
             event.setCancelled(true);
@@ -761,19 +749,17 @@ public class WorldGuardEntityListener implements Listener {
         }
 
         Entity ent = event.getEntity();
-        World world = ent.getWorld();
 
-        ConfigurationManager cfg = WorldGuard.getInstance().getPlatform().getGlobalStateManager();
-        WorldConfiguration wcfg = cfg.get(BukkitAdapter.adapt(world));
+        WorldConfiguration wcfg = getWorldConfig(ent.getWorld());
 
         if (wcfg.disableHealthRegain) {
             event.setCancelled(true);
             return;
         }
-        if (wcfg.useRegions && ent instanceof Player
+        if (wcfg.useRegions && ent instanceof Player player && !Entities.isNPC(ent)
                 && !WorldGuard.getInstance().getPlatform().getRegionContainer().createQuery().testState(
                         BukkitAdapter.adapt(ent.getLocation()),
-                        WorldGuardPlugin.inst().wrapPlayer((Player) ent),
+                        WorldGuardPlugin.inst().wrapPlayer(player),
                         Flags.HEALTH_REGEN)) {
             event.setCancelled(true);
         }
@@ -783,12 +769,12 @@ public class WorldGuardEntityListener implements Listener {
     public void onFoodChange(FoodLevelChangeEvent event) {
         if (event.getItem() != null) return;
         HumanEntity ent = event.getEntity();
-        if (!(ent instanceof Player)) return;
-        LocalPlayer player = WorldGuardPlugin.inst().wrapPlayer((Player) ent);
-        if (event.getFoodLevel() > player.getFoodLevel()) return;
+        if (Entities.isNPC(ent)) return;
+        if (!(ent instanceof Player bukkitPlayer)) return;
+        if (event.getFoodLevel() > ent.getFoodLevel()) return;
 
-        ConfigurationManager cfg = WorldGuard.getInstance().getPlatform().getGlobalStateManager();
-        WorldConfiguration wcfg = cfg.get(player.getWorld());
+        LocalPlayer player = WorldGuardPlugin.inst().wrapPlayer(bukkitPlayer);
+        WorldConfiguration wcfg = getWorldConfig(ent.getWorld());
 
         if (wcfg.useRegions
                 && !WorldGuard.getInstance().getPlatform().getRegionContainer().createQuery().testState(
@@ -805,11 +791,8 @@ public class WorldGuardEntityListener implements Listener {
     @EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
     public void onEntityChangeBlock(EntityChangeBlockEvent event) {
         Entity ent = event.getEntity();
-        Block block = event.getBlock();
-        Location location = block.getLocation();
 
-        ConfigurationManager cfg = WorldGuard.getInstance().getPlatform().getGlobalStateManager();
-        WorldConfiguration wcfg = cfg.get(BukkitAdapter.adapt(ent.getWorld()));
+        WorldConfiguration wcfg = getWorldConfig(ent.getWorld());
         if (ent instanceof FallingBlock) {
             Material id = event.getBlock().getType();
 
@@ -818,7 +801,7 @@ public class WorldGuardEntityListener implements Listener {
                 return;
             }
 
-            if (id == Material.SAND && wcfg.noPhysicsSand) {
+            if ((id == Material.SAND || id == Material.RED_SAND) && wcfg.noPhysicsSand) {
                 event.setCancelled(true);
                 return;
             }
@@ -833,6 +816,7 @@ public class WorldGuardEntityListener implements Listener {
                 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;
@@ -848,8 +832,7 @@ public class WorldGuardEntityListener implements Listener {
 
     @EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
     public void onVehicleEnter(VehicleEnterEvent event) {
-        ConfigurationManager cfg = WorldGuard.getInstance().getPlatform().getGlobalStateManager();
-        WorldConfiguration wcfg = cfg.get(BukkitAdapter.adapt(event.getEntered().getWorld()));
+        BukkitWorldConfiguration wcfg = getWorldConfig(event.getEntered().getWorld());
 
         if (wcfg.blockEntityVehicleEntry && !(event.getEntered() instanceof Player)) {
             event.setCancelled(true);
@@ -864,9 +847,8 @@ public class WorldGuardEntityListener implements Listener {
      * @return true if the event should be cancelled
      */
     private boolean checkItemFrameProtection(Entity attacker, ItemFrame defender) {
-        World world = attacker.getWorld();
-        ConfigurationManager cfg = WorldGuard.getInstance().getPlatform().getGlobalStateManager();
-        WorldConfiguration wcfg = cfg.get(BukkitAdapter.adapt(world));
+        World world = defender.getWorld();
+        WorldConfiguration wcfg = getWorldConfig(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,7 +22,6 @@ 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;
@@ -38,7 +37,6 @@ 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;
@@ -46,35 +44,18 @@ import org.bukkit.projectiles.ProjectileSource;
 
 /**
  * Listener for painting related events.
- *
- * @author BangL <henno.rickowski@gmail.com>
  */
-public class WorldGuardHangingListener implements Listener {
+public class WorldGuardHangingListener extends AbstractListener {
 
-    private WorldGuardPlugin plugin;
-
-    /**
-     * Construct the object;
-     *
-     * @param plugin The plugin instance
-     */
     public WorldGuardHangingListener(WorldGuardPlugin plugin) {
-        this.plugin = plugin;
-    }
-
-    /**
-     * Register events.
-     */
-    public void registerEvents() {
-        plugin.getServer().getPluginManager().registerEvents(this, plugin);
+        super(plugin);
     }
 
     @EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
     public void onHangingBreak(HangingBreakEvent event) {
         Hanging hanging = event.getEntity();
         World world = hanging.getWorld();
-        ConfigurationManager cfg = WorldGuard.getInstance().getPlatform().getGlobalStateManager();
-        WorldConfiguration wcfg = cfg.get(BukkitAdapter.adapt(world));
+        WorldConfiguration wcfg = getWorldConfig(world);
 
         if (event instanceof HangingBreakByEntityEvent) {
             HangingBreakByEntityEvent entityEvent = (HangingBreakByEntityEvent) event;

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

@@ -48,7 +48,6 @@ 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;
@@ -61,45 +60,31 @@ 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 implements Listener {
+public class WorldGuardPlayerListener extends AbstractListener {
 
     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) {
-        this.plugin = plugin;
+        super(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 = plugin.wrapPlayer(player);
-        WorldConfiguration wcfg = WorldGuard.getInstance().getPlatform().getGlobalStateManager().get(localPlayer.getWorld());
+        LocalPlayer localPlayer = getPlugin().wrapPlayer(player);
+        WorldConfiguration wcfg = getWorldConfig(player.getWorld());
         Session session = WorldGuard.getInstance().getPlatform().getSessionManager().getIfPresent(localPlayer);
         if (session != null) {
             GameModeFlag handler = session.getHandler(GameModeFlag.class);
@@ -117,11 +102,10 @@ public class WorldGuardPlayerListener implements Listener {
     @EventHandler
     public void onPlayerJoin(PlayerJoinEvent event) {
         Player player = event.getPlayer();
-        LocalPlayer localPlayer = plugin.wrapPlayer(player);
         World world = player.getWorld();
 
-        ConfigurationManager cfg = WorldGuard.getInstance().getPlatform().getGlobalStateManager();
-        WorldConfiguration wcfg = cfg.get(localPlayer.getWorld());
+        ConfigurationManager cfg = getConfig();
+        WorldConfiguration wcfg = getWorldConfig(world);
 
         if (cfg.activityHaltToggle) {
             player.sendMessage(ChatColor.YELLOW
@@ -155,9 +139,8 @@ public class WorldGuardPlayerListener implements Listener {
     @EventHandler(ignoreCancelled = true)
     public void onPlayerChat(AsyncPlayerChatEvent event) {
         Player player = event.getPlayer();
-        LocalPlayer localPlayer = plugin.wrapPlayer(player);
-        WorldConfiguration wcfg =
-                WorldGuard.getInstance().getPlatform().getGlobalStateManager().get(localPlayer.getWorld());
+        LocalPlayer localPlayer = getPlugin().wrapPlayer(player);
+        WorldConfiguration wcfg = getWorldConfig(player.getWorld());
         if (wcfg.useRegions) {
             RegionQuery query = WorldGuard.getInstance().getPlatform().getRegionContainer().createQuery();
             ApplicableRegionSet chatFrom = query.getApplicableRegions(localPlayer.getLocation());
@@ -172,7 +155,7 @@ public class WorldGuardPlayerListener implements Listener {
             boolean anyRemoved = false;
             for (Iterator<Player> i = event.getRecipients().iterator(); i.hasNext();) {
                 Player rPlayer = i.next();
-                LocalPlayer rLocal = plugin.wrapPlayer(rPlayer);
+                LocalPlayer rLocal = getPlugin().wrapPlayer(rPlayer);
                 if (!query.testState(rLocal.getLocation(), rLocal, Flags.RECEIVE_CHAT)) {
                     i.remove();
                     anyRemoved = true;
@@ -187,7 +170,7 @@ public class WorldGuardPlayerListener implements Listener {
     @EventHandler(ignoreCancelled = true)
     public void onPlayerLogin(PlayerLoginEvent event) {
         Player player = event.getPlayer();
-        ConfigurationManager cfg = WorldGuard.getInstance().getPlatform().getGlobalStateManager();
+        ConfigurationManager cfg = getConfig();
 
         String hostKey = cfg.hostKeys.get(player.getUniqueId().toString());
         if (hostKey == null) {
@@ -229,11 +212,11 @@ public class WorldGuardPlayerListener implements Listener {
             handlePhysicalInteract(event);
         }
 
-        ConfigurationManager cfg = WorldGuard.getInstance().getPlatform().getGlobalStateManager();
-        WorldConfiguration wcfg = cfg.get(BukkitAdapter.adapt(world));
+        ConfigurationManager cfg = getConfig();
+        WorldConfiguration wcfg = getWorldConfig(world);
 
         if (wcfg.removeInfiniteStacks
-                && !plugin.hasPermission(player, "worldguard.override.infinite-stack")) {
+                && !getPlugin().hasPermission(player, "worldguard.override.infinite-stack")) {
             int slot = player.getInventory().getHeldItemSlot();
             ItemStack heldItem = player.getInventory().getItem(slot);
             if (heldItem != null && heldItem.getAmount() < 0) {
@@ -259,13 +242,12 @@ public class WorldGuardPlayerListener implements Listener {
         Player player = event.getPlayer();
         @Nullable ItemStack item = event.getItem();
 
-        ConfigurationManager cfg = WorldGuard.getInstance().getPlatform().getGlobalStateManager();
-        WorldConfiguration wcfg = cfg.get(BukkitAdapter.adapt(world));
+        WorldConfiguration wcfg = getWorldConfig(world);
 
         // Infinite stack removal
         if (Materials.isInventoryBlock(type)
                 && wcfg.removeInfiniteStacks
-                && !plugin.hasPermission(player, "worldguard.override.infinite-stack")) {
+                && !getPlugin().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) {
@@ -276,13 +258,11 @@ public class WorldGuardPlayerListener implements Listener {
         }
 
         if (wcfg.useRegions) {
-            //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);
+            LocalPlayer localPlayer = getPlugin().wrapPlayer(player);
 
-            if (item != null && item.getType().getKey().toString().equals(wcfg.regionWand) && plugin.hasPermission(player, "worldguard.region.wand")) {
+            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 (set.size() > 0) {
                     player.sendMessage(ChatColor.YELLOW + "Can you build? " + (set.testState(localPlayer, Flags.BUILD) ? "Yes" : "No"));
 
@@ -317,8 +297,7 @@ public class WorldGuardPlayerListener implements Listener {
         Material type = block.getType();
         World world = player.getWorld();
 
-        ConfigurationManager cfg = WorldGuard.getInstance().getPlatform().getGlobalStateManager();
-        WorldConfiguration wcfg = cfg.get(BukkitAdapter.adapt(world));
+        WorldConfiguration wcfg = getWorldConfig(world);
 
         if (type == Material.FARMLAND && wcfg.disablePlayerCropTrampling) {
             event.setCancelled(true);
@@ -333,12 +312,11 @@ public class WorldGuardPlayerListener implements Listener {
     @EventHandler(priority = EventPriority.HIGHEST)
     public void onPlayerRespawn(PlayerRespawnEvent event) {
         Player player = event.getPlayer();
-        LocalPlayer localPlayer = plugin.wrapPlayer(player);
-
-        ConfigurationManager cfg = WorldGuard.getInstance().getPlatform().getGlobalStateManager();
-        WorldConfiguration wcfg = cfg.get(localPlayer.getWorld());
+        if (com.sk89q.worldguard.bukkit.util.Entities.isNPC(player)) return;
+        WorldConfiguration wcfg = getWorldConfig(player.getWorld());
 
         if (wcfg.useRegions) {
+            LocalPlayer localPlayer = getPlugin().wrapPlayer(player);
             ApplicableRegionSet set =
                     WorldGuard.getInstance().getPlatform().getRegionContainer().createQuery().getApplicableRegions(localPlayer.getLocation());
 
@@ -353,12 +331,10 @@ public class WorldGuardPlayerListener implements Listener {
     @EventHandler(priority = EventPriority.HIGH)
     public void onItemHeldChange(PlayerItemHeldEvent event) {
         Player player = event.getPlayer();
-
-        ConfigurationManager cfg = WorldGuard.getInstance().getPlatform().getGlobalStateManager();
-        WorldConfiguration wcfg = cfg.get(BukkitAdapter.adapt(player.getWorld()));
+        WorldConfiguration wcfg = getWorldConfig(player.getWorld());
 
         if (wcfg.removeInfiniteStacks
-                && !plugin.hasPermission(player, "worldguard.override.infinite-stack")) {
+                && !getPlugin().hasPermission(player, "worldguard.override.infinite-stack")) {
             int newSlot = event.getNewSlot();
             ItemStack heldItem = player.getInventory().getItem(newSlot);
             if (heldItem != null && heldItem.getAmount() < 0) {
@@ -371,15 +347,15 @@ public class WorldGuardPlayerListener implements Listener {
     @EventHandler(priority = EventPriority.LOW, ignoreCancelled = true)
     public void onPlayerTeleport(PlayerTeleportEvent event) {
         Player player = event.getPlayer();
-        LocalPlayer localPlayer = plugin.wrapPlayer(player);
-        ConfigurationManager cfg = WorldGuard.getInstance().getPlatform().getGlobalStateManager();
-        WorldConfiguration wcfg = cfg.get(localPlayer.getWorld());
+        if (com.sk89q.worldguard.bukkit.util.Entities.isNPC(player)) return;
+        LocalPlayer localPlayer = getPlugin().wrapPlayer(player);
+        ConfigurationManager cfg = getConfig();
+        WorldConfiguration wcfg = getWorldConfig(player.getWorld());
 
         if (wcfg.useRegions && cfg.usePlayerTeleports) {
-            ApplicableRegionSet set =
-                    WorldGuard.getInstance().getPlatform().getRegionContainer().createQuery().getApplicableRegions(BukkitAdapter.adapt(event.getTo()));
-            ApplicableRegionSet setFrom =
-                    WorldGuard.getInstance().getPlatform().getRegionContainer().createQuery().getApplicableRegions(BukkitAdapter.adapt(event.getFrom()));
+            RegionQuery query = WorldGuard.getInstance().getPlatform().getRegionContainer().createQuery();
+            ApplicableRegionSet set = query.getApplicableRegions(BukkitAdapter.adapt(event.getTo()));
+            ApplicableRegionSet setFrom = query.getApplicableRegions(BukkitAdapter.adapt(event.getFrom()));
 
             if (event.getCause() == TeleportCause.ENDER_PEARL) {
                 if (!WorldGuard.getInstance().getPlatform().getSessionManager().hasBypass(localPlayer, localPlayer.getWorld())) {
@@ -431,9 +407,9 @@ public class WorldGuardPlayerListener implements Listener {
     @EventHandler(priority = EventPriority.LOWEST, ignoreCancelled = true)
     public void onPlayerCommandPreprocess(PlayerCommandPreprocessEvent event) {
         Player player = event.getPlayer();
-        LocalPlayer localPlayer = plugin.wrapPlayer(player);
-        ConfigurationManager cfg = WorldGuard.getInstance().getPlatform().getGlobalStateManager();
-        WorldConfiguration wcfg = cfg.get(localPlayer.getWorld());
+        LocalPlayer localPlayer = getPlugin().wrapPlayer(player);
+        ConfigurationManager cfg = getConfig();
+        WorldConfiguration wcfg = getWorldConfig(player.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,42 +19,28 @@
 
 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;
 
-/**
- * @author zml2008
- */
-public class WorldGuardServerListener implements Listener {
-
-    private final WorldGuardPlugin plugin;
+public class WorldGuardServerListener extends AbstractListener {
 
     public WorldGuardServerListener(WorldGuardPlugin plugin) {
-        this.plugin = plugin;
-    }
-
-    public void registerEvents() {
-        PluginManager pm = plugin.getServer().getPluginManager();
-        pm.registerEvents(this, plugin);
+        super(plugin);
     }
 
     @EventHandler
     public void onPluginEnable(PluginEnableEvent event) {
         if (event.getPlugin().getDescription().getName().equalsIgnoreCase("CommandBook")) {
-            ((BukkitConfigurationManager) WorldGuard.getInstance().getPlatform().getGlobalStateManager()).updateCommandBookGodMode();
+            getConfig().updateCommandBookGodMode();
         }
     }
 
     @EventHandler
     public void onPluginDisable(PluginDisableEvent event) {
         if (event.getPlugin().getDescription().getName().equalsIgnoreCase("CommandBook")) {
-            ((BukkitConfigurationManager) WorldGuard.getInstance().getPlatform().getGlobalStateManager()).updateCommandBookGodMode();
+            getConfig().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.config.ConfigurationManager;
+import com.sk89q.worldguard.bukkit.util.Entities;
 import com.sk89q.worldguard.config.WorldConfiguration;
 import com.sk89q.worldguard.session.MoveType;
 import com.sk89q.worldguard.util.Locations;
@@ -32,31 +32,16 @@ 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 implements Listener {
+public class WorldGuardVehicleListener extends AbstractListener {
 
-    private WorldGuardPlugin plugin;
-
-    /**
-     * Construct the object;
-     *
-     * @param plugin
-     */
     public WorldGuardVehicleListener(WorldGuardPlugin plugin) {
-        this.plugin = plugin;
-    }
-
-    /**
-     * Register events.
-     */
-    public void registerEvents() {
-        plugin.getServer().getPluginManager().registerEvents(this, plugin);
+        super(plugin);
     }
 
     @EventHandler
@@ -69,14 +54,14 @@ public class WorldGuardVehicleListener implements Listener {
             return;
         }
         World world = vehicle.getWorld();
-        ConfigurationManager cfg = WorldGuard.getInstance().getPlatform().getGlobalStateManager();
-        WorldConfiguration wcfg = cfg.get(BukkitAdapter.adapt(world));
+        WorldConfiguration wcfg = getWorldConfig(world);
 
         if (wcfg.useRegions) {
             // Did we move a block?
             if (Locations.isDifferentBlock(BukkitAdapter.adapt(event.getFrom()), BukkitAdapter.adapt(event.getTo()))) {
                 for (Player player : playerPassengers) {
-                    LocalPlayer localPlayer = plugin.wrapPlayer(player);
+                    if (Entities.isNPC(player)) continue;
+                    LocalPlayer localPlayer = getPlugin().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,7 +22,6 @@ 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;
@@ -33,35 +32,19 @@ 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 implements Listener {
+public class WorldGuardWeatherListener extends AbstractListener {
 
-    /**
-     * Plugin.
-     */
-    private WorldGuardPlugin plugin;
-
-    /**
-     * Construct the object;
-     *
-     * @param plugin The plugin instance
-     */
     public WorldGuardWeatherListener(WorldGuardPlugin plugin) {
-        this.plugin = plugin;
-    }
-
-    public void registerEvents() {
-        plugin.getServer().getPluginManager().registerEvents(this, plugin);
+        super(plugin);
     }
 
     @EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
     public void onWeatherChange(WeatherChangeEvent event) {
-        ConfigurationManager cfg = WorldGuard.getInstance().getPlatform().getGlobalStateManager();
-        WorldConfiguration wcfg = cfg.get(BukkitAdapter.adapt(event.getWorld()));
+        WorldConfiguration wcfg = getWorldConfig(event.getWorld());
 
         if (event.toWeatherState()) {
             if (wcfg.disableWeather) {
@@ -76,8 +59,7 @@ public class WorldGuardWeatherListener implements Listener {
 
     @EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
     public void onThunderChange(ThunderChangeEvent event) {
-        ConfigurationManager cfg = WorldGuard.getInstance().getPlatform().getGlobalStateManager();
-        WorldConfiguration wcfg = cfg.get(BukkitAdapter.adapt(event.getWorld()));
+        WorldConfiguration wcfg = getWorldConfig(event.getWorld());
 
         if (event.toThunderState()) {
             if (wcfg.disableThunder) {
@@ -92,8 +74,7 @@ public class WorldGuardWeatherListener implements Listener {
 
     @EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
     public void onLightningStrike(LightningStrikeEvent event) {
-        ConfigurationManager cfg = WorldGuard.getInstance().getPlatform().getGlobalStateManager();
-        WorldConfiguration wcfg = cfg.get(BukkitAdapter.adapt(event.getWorld()));
+        WorldConfiguration wcfg = getWorldConfig(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,30 +34,17 @@ import org.bukkit.event.world.WorldLoadEvent;
 
 import java.util.logging.Logger;
 
-public class WorldGuardWorldListener implements Listener {
+public class WorldGuardWorldListener extends AbstractListener {
 
     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) {
-        this.plugin = plugin;
-    }
-
-    /**
-     * Register events.
-     */
-    public void registerEvents() {
-        plugin.getServer().getPluginManager().registerEvents(this, plugin);
+        super(plugin);
     }
 
     @EventHandler
     public void onChunkLoad(ChunkLoadEvent event) {
-        ConfigurationManager cfg = WorldGuard.getInstance().getPlatform().getGlobalStateManager();
+        ConfigurationManager cfg = getConfig();
 
         if (cfg.activityHaltToggle) {
             int removed = 0;
@@ -89,8 +76,7 @@ public class WorldGuardWorldListener implements Listener {
      * @param world The specified world
      */
     public void initWorld(World world) {
-        ConfigurationManager cfg = WorldGuard.getInstance().getPlatform().getGlobalStateManager();
-        WorldConfiguration wcfg = cfg.get(BukkitAdapter.adapt(world));
+        WorldConfiguration wcfg = getWorldConfig(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,7 +19,6 @@
 
 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;
@@ -42,7 +41,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(BukkitAdapter.adapt(event.getWorld()));
+            WorldConfiguration config = getWorldConfig(event.getWorld());
 
             if (config.disableExpDrops) {
                 event.setCancelled(true);
@@ -53,7 +52,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(BukkitAdapter.adapt(event.getEntity().getWorld()));
+            WorldConfiguration config = getWorldConfig(event.getEntity().getWorld());
 
             if (config.disableConduitEffects) {
                 event.setCancelled(true);

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

@@ -20,6 +20,7 @@
 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;
@@ -44,18 +45,18 @@ public class InventoryMoveItemEventDebounce extends AbstractEventDebounce<Key> {
         private final Object target;
 
         public Key(InventoryMoveItemEvent event) {
-            cause = transform(event.getInitiator().getHolder());
-            source = transform(event.getSource().getHolder());
-            target = transform(event.getDestination().getHolder());
+            cause = transform(PaperLib.getHolder(event.getInitiator(), false).getHolder());
+            source = transform(PaperLib.getHolder(event.getSource(), false).getHolder());
+            target = transform(PaperLib.getHolder(event.getDestination(), false).getHolder());
         }
 
         private Object transform(InventoryHolder holder) {
-            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());
+            if (holder instanceof BlockState blockState) {
+                return new BlockMaterialKey(blockState);
+            } else if (holder instanceof DoubleChest doubleChest) {
+                InventoryHolder left = doubleChest.getLeftSide();
+                if (left instanceof Chest chest) {
+                    return new BlockMaterialKey(chest);
                 } else {
                     return holder;
                 }
@@ -94,8 +95,8 @@ public class InventoryMoveItemEventDebounce extends AbstractEventDebounce<Key> {
         private final Block block;
         private final Material material;
 
-        private BlockMaterialKey(Block block) {
-            this.block = block;
+        private BlockMaterialKey(BlockState block) {
+            this.block = block.getBlock();
             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.session.handler.Handler;
 import org.bukkit.Bukkit;
 import org.bukkit.entity.Player;
 import org.bukkit.event.EventHandler;
@@ -41,13 +41,6 @@ import java.util.Collection;
  */
 public class BukkitSessionManager extends AbstractSessionManager implements Runnable, Listener {
 
-    private boolean useTimings;
-
-    @Override
-    protected Handler.Factory<? extends Handler> wrapForRegistration(Handler.Factory<? extends Handler> factory) {
-        return useTimings ? new TimedHandlerFactory(factory) : factory;
-    }
-
     /**
      * Re-initialize handlers and clear "last position," "last state," etc.
      * information for all players.
@@ -81,19 +74,22 @@ public class BukkitSessionManager extends AbstractSessionManager implements Runn
 
     @Override
     public boolean hasBypass(LocalPlayer player, World world) {
-        if (player instanceof BukkitPlayer) {
-            if (((BukkitPlayer) player).getPlayer().hasMetadata("NPC")
-                && WorldGuard.getInstance().getPlatform().getGlobalStateManager().get(world).fakePlayerBuildOverride)
+        if (player instanceof BukkitPlayer bukkitPlayer) {
+            if (Entities.isNPC(bukkitPlayer.getPlayer())
+                    && WorldGuard.getInstance().getPlatform().getGlobalStateManager().get(world).fakePlayerBuildOverride) {
                 return true;
+            }
+            if (!((BukkitPlayer) player).getPlayer().isOnline()) {
+                return false;
+            }
         }
         return super.hasBypass(player, world);
     }
 
-    public boolean isUsingTimings() {
-        return useTimings;
-    }
-
-    public void setUsingTimings(boolean useTimings) {
-        this.useTimings = useTimings;
+    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/session/TimedHandlerFactory.java

@@ -1,132 +0,0 @@
-/*
- * WorldGuard, a suite of tools for Minecraft
- * Copyright (C) sk89q <http://www.sk89q.com>
- * Copyright (C) WorldGuard team and contributors
- *
- * This program is free software: you can redistribute it and/or modify it
- * under the terms of the GNU Lesser General Public License as published by the
- * Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License
- * for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-package com.sk89q.worldguard.bukkit.session;
-
-import co.aikar.timings.lib.MCTiming;
-import co.aikar.timings.lib.TimingManager;
-import com.sk89q.worldedit.util.Location;
-import com.sk89q.worldguard.LocalPlayer;
-import com.sk89q.worldguard.bukkit.WorldGuardPlugin;
-import com.sk89q.worldguard.protection.ApplicableRegionSet;
-import com.sk89q.worldguard.protection.flags.StateFlag;
-import com.sk89q.worldguard.protection.regions.ProtectedRegion;
-import com.sk89q.worldguard.session.MoveType;
-import com.sk89q.worldguard.session.Session;
-import com.sk89q.worldguard.session.handler.Handler;
-import org.bukkit.Bukkit;
-import org.bukkit.plugin.Plugin;
-
-
-import javax.annotation.Nullable;
-import java.security.CodeSource;
-import java.util.HashMap;
-import java.util.Map;
-import java.util.Objects;
-import java.util.Set;
-
-class TimedHandlerFactory extends Handler.Factory<Handler> {
-
-    private static final TimingManager TIMINGS = TimingManager.of(WorldGuardPlugin.inst());
-    private static final MCTiming UNKNOWN_SOURCE = TIMINGS.of("Third-Party Session Handlers");
-    private static final Map<CodeSource, TimingManager> PLUGIN_SOURCES = new HashMap<>();
-
-    private final Handler.Factory<?> factory;
-    private final MCTiming timing;
-
-    TimedHandlerFactory(Handler.Factory<?> factory) {
-        this.factory = factory;
-        this.timing = makeTiming();
-    }
-
-    private MCTiming makeTiming() {
-        CodeSource codeSource = factory.getClass().getProtectionDomain().getCodeSource();
-        TimingManager owner = PLUGIN_SOURCES.computeIfAbsent(codeSource, source -> {
-            for (Plugin plugin : Bukkit.getPluginManager().getPlugins()) {
-                CodeSource pluginSource = plugin.getClass().getProtectionDomain().getCodeSource();
-                if (Objects.equals(pluginSource, source)) {
-                    return TimingManager.of(plugin);
-                }
-            }
-            return null;
-        });
-        String handlerName = factory.getClass().getEnclosingClass().getSimpleName();
-        return owner == null
-            ? TIMINGS.of(handlerName, UNKNOWN_SOURCE)
-            : owner.of(handlerName, owner.of("Session Handlers"));
-    }
-
-    @Override
-    public Handler create(Session session) {
-        return new TimedHandler(factory.create(session), session, timing);
-    }
-
-    static class TimedHandler extends Handler {
-        private final Handler handler;
-        private final MCTiming timing;
-
-        TimedHandler(Handler innerHandler, Session session, MCTiming timing) {
-            super(session);
-            this.handler = innerHandler;
-            this.timing = timing;
-        }
-
-        @Override
-        public void initialize(LocalPlayer player, Location current, ApplicableRegionSet set) {
-            try (MCTiming ignored = timing.startTiming()) {
-                handler.initialize(player, current, set);
-            }
-        }
-
-        @Override
-        public boolean testMoveTo(LocalPlayer player, Location from, Location to, ApplicableRegionSet toSet, MoveType moveType) {
-            try (MCTiming ignored = timing.startTiming()) {
-                return handler.testMoveTo(player, from, to, toSet, moveType);
-            }
-        }
-
-        @Override
-        public boolean onCrossBoundary(LocalPlayer player, Location from, Location to, ApplicableRegionSet toSet, Set<ProtectedRegion> entered, Set<ProtectedRegion> exited, MoveType moveType) {
-            try (MCTiming ignored = timing.startTiming()) {
-                return handler.onCrossBoundary(player, from, to, toSet, entered, exited, moveType);
-            }
-        }
-
-        @Override
-        public void tick(LocalPlayer player, ApplicableRegionSet set) {
-            try (MCTiming ignored = timing.startTiming()) {
-                handler.tick(player, set);
-            }
-        }
-
-        @Nullable
-        @Override
-        public StateFlag.State getInvincibility(LocalPlayer player) {
-            try (MCTiming ignored = timing.startTiming()) {
-                return handler.getInvincibility(player);
-            }
-        }
-
-        @Override
-        public Handler getWrappedHandler() {
-            return handler;
-        }
-    }
-
-}

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

@@ -0,0 +1,167 @@
+/*
+ * 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,6 +19,7 @@
 
 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;
@@ -101,8 +102,20 @@ public final class Entities {
      * @return true if the type is a vehicle type
      */
     public static boolean isVehicle(EntityType type) {
-        return type == EntityType.BOAT
-                || isMinecart(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;
+        };
     }
 
     /**
@@ -112,13 +125,11 @@ public final class Entities {
      * @return true if the type is a Minecart type
      */
     public static boolean isMinecart(EntityType type) {
-        return type == EntityType.MINECART
-                || type == EntityType.MINECART_CHEST
-                || type == EntityType.MINECART_COMMAND
-                || type == EntityType.MINECART_FURNACE
-                || type == EntityType.MINECART_HOPPER
-                || type == EntityType.MINECART_MOB_SPAWNER
-                || type == EntityType.MINECART_TNT;
+        return switch(type) {
+            case MINECART, MINECART_CHEST, MINECART_COMMAND, MINECART_FURNACE,
+                    MINECART_HOPPER, MINECART_MOB_SPAWNER, MINECART_TNT -> true;
+            default -> false;
+        };
     }
 
     /**
@@ -208,6 +219,7 @@ public final class Entities {
         return entity instanceof Hanging
                 || entity instanceof ArmorStand
                 || entity instanceof EnderCrystal
+                || entity instanceof Allay
                 || entity instanceof Minecart && entity instanceof InventoryHolder;
     }
 

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 (player.hasMetadata("NPC")) {
+        if (Entities.isNPC(player)) {
             return true;
         }
 

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

@@ -52,6 +52,11 @@ public final class Materials {
     private static final Map<Material, Integer> MATERIAL_FLAGS = new EnumMap<>(Material.class);
     private static final Set<PotionEffectType> DAMAGE_EFFECTS = new HashSet<>();
 
+    private static void putMaterialTag(Tag<Material> tag, Integer value) {
+        tag.getValues().forEach(mat -> MATERIAL_FLAGS.put(mat, value));
+    }
+    private static Tag<Material> SIGNS_TAG;
+
     static {
         ENTITY_ITEMS.put(EntityType.PAINTING, Material.PAINTING);
         ENTITY_ITEMS.put(EntityType.ARROW, Material.ARROW);
@@ -60,6 +65,7 @@ public final class Materials {
         ENTITY_ITEMS.put(EntityType.ENDER_PEARL, Material.ENDER_PEARL);
         ENTITY_ITEMS.put(EntityType.THROWN_EXP_BOTTLE, Material.EXPERIENCE_BOTTLE);
         ENTITY_ITEMS.put(EntityType.ITEM_FRAME, Material.ITEM_FRAME);
+        ENTITY_ITEMS.put(EntityType.GLOW_ITEM_FRAME, Material.GLOW_ITEM_FRAME);
         ENTITY_ITEMS.put(EntityType.PRIMED_TNT, Material.TNT);
         ENTITY_ITEMS.put(EntityType.FIREWORK, Material.FIREWORK_ROCKET);
         ENTITY_ITEMS.put(EntityType.MINECART_COMMAND, Material.COMMAND_BLOCK_MINECART);
@@ -84,12 +90,8 @@ public final class Materials {
         MATERIAL_FLAGS.put(Material.LAVA, 0);
         MATERIAL_FLAGS.put(Material.SAND, 0);
         MATERIAL_FLAGS.put(Material.GRAVEL, 0);
-        MATERIAL_FLAGS.put(Material.GOLD_ORE, 0);
-        MATERIAL_FLAGS.put(Material.IRON_ORE, 0);
-        MATERIAL_FLAGS.put(Material.COAL_ORE, 0);
         MATERIAL_FLAGS.put(Material.SPONGE, 0);
         MATERIAL_FLAGS.put(Material.GLASS, 0);
-        MATERIAL_FLAGS.put(Material.LAPIS_ORE, 0);
         MATERIAL_FLAGS.put(Material.LAPIS_BLOCK, 0);
         MATERIAL_FLAGS.put(Material.DISPENSER, MODIFIED_ON_RIGHT);
         MATERIAL_FLAGS.put(Material.SANDSTONE, 0);
@@ -113,7 +115,7 @@ public final class Materials {
         MATERIAL_FLAGS.put(Material.IRON_BLOCK, 0);
         MATERIAL_FLAGS.put(Material.BRICK, 0);
         MATERIAL_FLAGS.put(Material.TNT, MODIFIED_ON_RIGHT);
-        MATERIAL_FLAGS.put(Material.BOOKSHELF, 0);
+        MATERIAL_FLAGS.put(Material.BOOKSHELF, MODIFIED_ON_RIGHT);
         MATERIAL_FLAGS.put(Material.MOSSY_COBBLESTONE, 0);
         MATERIAL_FLAGS.put(Material.OBSIDIAN, 0);
         MATERIAL_FLAGS.put(Material.TORCH, 0);
@@ -121,7 +123,6 @@ public final class Materials {
         MATERIAL_FLAGS.put(Material.SPAWNER, MODIFIED_ON_RIGHT);
         MATERIAL_FLAGS.put(Material.CHEST, MODIFIED_ON_RIGHT);
         MATERIAL_FLAGS.put(Material.REDSTONE_WIRE, MODIFIED_ON_RIGHT);
-        MATERIAL_FLAGS.put(Material.DIAMOND_ORE, 0);
         MATERIAL_FLAGS.put(Material.DIAMOND_BLOCK, 0);
         MATERIAL_FLAGS.put(Material.CRAFTING_TABLE, 0);
         MATERIAL_FLAGS.put(Material.WHEAT, 0);
@@ -132,7 +133,6 @@ public final class Materials {
         MATERIAL_FLAGS.put(Material.COBBLESTONE_STAIRS, 0);
         MATERIAL_FLAGS.put(Material.LEVER, MODIFIED_ON_RIGHT);
         MATERIAL_FLAGS.put(Material.STONE_PRESSURE_PLATE, 0);
-        MATERIAL_FLAGS.put(Material.REDSTONE_ORE, 0);
         MATERIAL_FLAGS.put(Material.REDSTONE_WALL_TORCH, 0);
         MATERIAL_FLAGS.put(Material.REDSTONE_TORCH, 0);
         MATERIAL_FLAGS.put(Material.SNOW, 0);
@@ -181,7 +181,6 @@ public final class Materials {
         MATERIAL_FLAGS.put(Material.NETHER_BRICK_STAIRS, 0);
         MATERIAL_FLAGS.put(Material.ENCHANTING_TABLE, MODIFIED_ON_RIGHT);
         MATERIAL_FLAGS.put(Material.BREWING_STAND, MODIFIED_ON_RIGHT);
-        MATERIAL_FLAGS.put(Material.CAULDRON, MODIFIED_ON_RIGHT);
         MATERIAL_FLAGS.put(Material.END_PORTAL, 0);
         MATERIAL_FLAGS.put(Material.END_PORTAL_FRAME, 0);
         MATERIAL_FLAGS.put(Material.END_STONE, 0);
@@ -189,7 +188,6 @@ public final class Materials {
         MATERIAL_FLAGS.put(Material.REDSTONE_LAMP, 0);
         MATERIAL_FLAGS.put(Material.COCOA, 0);
         MATERIAL_FLAGS.put(Material.SANDSTONE_STAIRS, 0);
-        MATERIAL_FLAGS.put(Material.EMERALD_ORE, 0);
         MATERIAL_FLAGS.put(Material.ENDER_CHEST, 0);
         MATERIAL_FLAGS.put(Material.TRIPWIRE_HOOK, 0);
         MATERIAL_FLAGS.put(Material.TRIPWIRE, 0);
@@ -235,7 +233,7 @@ public final class Materials {
         MATERIAL_FLAGS.put(Material.ACACIA_DOOR, MODIFIED_ON_RIGHT);
         MATERIAL_FLAGS.put(Material.DARK_OAK_DOOR, MODIFIED_ON_RIGHT);
 
-        MATERIAL_FLAGS.put(Material.GRASS_PATH, 0);
+        MATERIAL_FLAGS.put(Material.DIRT_PATH, 0);
         MATERIAL_FLAGS.put(Material.CHORUS_PLANT, 0);
         MATERIAL_FLAGS.put(Material.CHORUS_FLOWER, 0);
         MATERIAL_FLAGS.put(Material.BEETROOTS, 0);
@@ -697,7 +695,6 @@ public final class Materials {
         MATERIAL_FLAGS.put(Material.NETHERITE_SHOVEL, 0);
         MATERIAL_FLAGS.put(Material.NETHERITE_SWORD, 0);
 
-        MATERIAL_FLAGS.put(Material.NETHER_GOLD_ORE, 0);
         MATERIAL_FLAGS.put(Material.NETHER_SPROUTS, 0);
         MATERIAL_FLAGS.put(Material.PIGLIN_BANNER_PATTERN, 0);
         MATERIAL_FLAGS.put(Material.POLISHED_BASALT, 0);
@@ -726,80 +723,152 @@ public final class Materials {
         MATERIAL_FLAGS.put(Material.WEEPING_VINES, 0);
         MATERIAL_FLAGS.put(Material.WEEPING_VINES_PLANT, 0);
 
+        // 1.17
+        MATERIAL_FLAGS.put(Material.DEEPSLATE, 0);
+        MATERIAL_FLAGS.put(Material.COBBLED_DEEPSLATE, 0);
+        MATERIAL_FLAGS.put(Material.POLISHED_DEEPSLATE, 0);
+        MATERIAL_FLAGS.put(Material.CALCITE, 0);
+        MATERIAL_FLAGS.put(Material.TUFF, 0);
+        MATERIAL_FLAGS.put(Material.DRIPSTONE_BLOCK, 0);
+        MATERIAL_FLAGS.put(Material.ROOTED_DIRT, 0);
+
+        MATERIAL_FLAGS.put(Material.RAW_IRON_BLOCK, 0);
+        MATERIAL_FLAGS.put(Material.RAW_COPPER_BLOCK, 0);
+        MATERIAL_FLAGS.put(Material.RAW_GOLD_BLOCK, 0);
+        MATERIAL_FLAGS.put(Material.AMETHYST_BLOCK, 0);
+        MATERIAL_FLAGS.put(Material.BUDDING_AMETHYST, 0);
+
+        MATERIAL_FLAGS.put(Material.EXPOSED_COPPER, 0);
+        MATERIAL_FLAGS.put(Material.WEATHERED_COPPER, 0);
+        MATERIAL_FLAGS.put(Material.OXIDIZED_COPPER, 0);
+        MATERIAL_FLAGS.put(Material.CUT_COPPER, 0);
+        MATERIAL_FLAGS.put(Material.EXPOSED_CUT_COPPER, 0);
+        MATERIAL_FLAGS.put(Material.WEATHERED_CUT_COPPER, 0);
+        MATERIAL_FLAGS.put(Material.OXIDIZED_CUT_COPPER, 0);
+        MATERIAL_FLAGS.put(Material.WAXED_COPPER_BLOCK, 0);
+        MATERIAL_FLAGS.put(Material.WAXED_EXPOSED_COPPER, 0);
+        MATERIAL_FLAGS.put(Material.WAXED_WEATHERED_COPPER, 0);
+        MATERIAL_FLAGS.put(Material.WAXED_OXIDIZED_COPPER, 0);
+        MATERIAL_FLAGS.put(Material.AZALEA, 0);
+        MATERIAL_FLAGS.put(Material.FLOWERING_AZALEA, 0);
+
+        MATERIAL_FLAGS.put(Material.COPPER_BLOCK, 0);
+        MATERIAL_FLAGS.put(Material.WAXED_CUT_COPPER, 0);
+        MATERIAL_FLAGS.put(Material.WAXED_EXPOSED_CUT_COPPER, 0);
+        MATERIAL_FLAGS.put(Material.WAXED_WEATHERED_CUT_COPPER, 0);
+        MATERIAL_FLAGS.put(Material.WAXED_OXIDIZED_CUT_COPPER, 0);
+        MATERIAL_FLAGS.put(Material.TINTED_GLASS, 0);
+        MATERIAL_FLAGS.put(Material.SPORE_BLOSSOM, 0);
+        MATERIAL_FLAGS.put(Material.MOSS_CARPET, 0);
+        MATERIAL_FLAGS.put(Material.BIG_DRIPLEAF, 0);
+        MATERIAL_FLAGS.put(Material.BIG_DRIPLEAF_STEM, 0);
+        MATERIAL_FLAGS.put(Material.SMALL_DRIPLEAF, 0);
+        MATERIAL_FLAGS.put(Material.SMOOTH_BASALT, 0);
+        MATERIAL_FLAGS.put(Material.INFESTED_DEEPSLATE, 0);
+        MATERIAL_FLAGS.put(Material.DEEPSLATE_BRICKS, 0);
+        MATERIAL_FLAGS.put(Material.CRACKED_DEEPSLATE_BRICKS, 0);
+        MATERIAL_FLAGS.put(Material.DEEPSLATE_TILES, 0);
+        MATERIAL_FLAGS.put(Material.CRACKED_DEEPSLATE_TILES, 0);
+        MATERIAL_FLAGS.put(Material.CHISELED_DEEPSLATE, 0);
+        MATERIAL_FLAGS.put(Material.GLOW_LICHEN, 0);
+        MATERIAL_FLAGS.put(Material.LIGHT, MODIFIED_ON_RIGHT);
+        MATERIAL_FLAGS.put(Material.LIGHTNING_ROD, 0);
+        MATERIAL_FLAGS.put(Material.SCULK_SENSOR, 0);
+        MATERIAL_FLAGS.put(Material.AMETHYST_SHARD, 0);
+        MATERIAL_FLAGS.put(Material.RAW_IRON, 0);
+        MATERIAL_FLAGS.put(Material.RAW_COPPER, 0);
+        MATERIAL_FLAGS.put(Material.COPPER_INGOT, 0);
+        MATERIAL_FLAGS.put(Material.RAW_GOLD, 0);
+        MATERIAL_FLAGS.put(Material.POWDER_SNOW_BUCKET, 0);
+        MATERIAL_FLAGS.put(Material.AXOLOTL_BUCKET, 0);
+        MATERIAL_FLAGS.put(Material.BUNDLE, 0);
+        MATERIAL_FLAGS.put(Material.SPYGLASS, 0);
+        MATERIAL_FLAGS.put(Material.GLOW_INK_SAC, 0);
+        MATERIAL_FLAGS.put(Material.GLOW_ITEM_FRAME, 0);
+        MATERIAL_FLAGS.put(Material.GLOW_BERRIES, 0);
+
+        MATERIAL_FLAGS.put(Material.SMALL_AMETHYST_BUD, 0);
+        MATERIAL_FLAGS.put(Material.MEDIUM_AMETHYST_BUD, 0);
+        MATERIAL_FLAGS.put(Material.LARGE_AMETHYST_BUD, 0);
+        MATERIAL_FLAGS.put(Material.AMETHYST_CLUSTER, 0);
+        MATERIAL_FLAGS.put(Material.POWDER_SNOW, 0);
+
+        MATERIAL_FLAGS.put(Material.CAVE_VINES, MODIFIED_ON_RIGHT);
+        MATERIAL_FLAGS.put(Material.CAVE_VINES_PLANT, MODIFIED_ON_RIGHT);
+        MATERIAL_FLAGS.put(Material.MOSS_BLOCK, 0);
+        MATERIAL_FLAGS.put(Material.HANGING_ROOTS, 0);
+        MATERIAL_FLAGS.put(Material.POINTED_DRIPSTONE, 0);
+
+        // 1.19
+        MATERIAL_FLAGS.put(Material.MUD, 0);
+        MATERIAL_FLAGS.put(Material.MANGROVE_ROOTS, 0);
+        MATERIAL_FLAGS.put(Material.MUDDY_MANGROVE_ROOTS, 0);
+        MATERIAL_FLAGS.put(Material.PACKED_MUD, 0);
+        MATERIAL_FLAGS.put(Material.MUD_BRICKS, 0);
+        MATERIAL_FLAGS.put(Material.SCULK, 0);
+        MATERIAL_FLAGS.put(Material.SCULK_VEIN, 0);
+        MATERIAL_FLAGS.put(Material.SCULK_CATALYST, 0);
+        MATERIAL_FLAGS.put(Material.SCULK_SHRIEKER, 0);
+        MATERIAL_FLAGS.put(Material.TADPOLE_BUCKET, 0);
+        MATERIAL_FLAGS.put(Material.RECOVERY_COMPASS, 0);
+        MATERIAL_FLAGS.put(Material.DISC_FRAGMENT_5, 0);
+        MATERIAL_FLAGS.put(Material.GOAT_HORN, 0);
+        MATERIAL_FLAGS.put(Material.OCHRE_FROGLIGHT, 0);
+        MATERIAL_FLAGS.put(Material.VERDANT_FROGLIGHT, 0);
+        MATERIAL_FLAGS.put(Material.PEARLESCENT_FROGLIGHT, 0);
+        MATERIAL_FLAGS.put(Material.FROGSPAWN, 0);
+        MATERIAL_FLAGS.put(Material.ECHO_SHARD, 0);
+        MATERIAL_FLAGS.put(Material.REINFORCED_DEEPSLATE, 0);
+
+        // 1.19.3: Try to register those things
+        try {
+            SIGNS_TAG = Tag.ALL_SIGNS;
+
+            MATERIAL_FLAGS.put(Material.BAMBOO_MOSAIC, 0);
+            MATERIAL_FLAGS.put(Material.BAMBOO_BLOCK, 0);
+            MATERIAL_FLAGS.put(Material.STRIPPED_BAMBOO_BLOCK, 0);
+        } catch (NoSuchFieldError ignored) {
+            SIGNS_TAG = Tag.SIGNS;
+        }
 
         // Generated via tag
-        for (Material woodenDoor : Tag.WOODEN_DOORS.getValues()) {
-            MATERIAL_FLAGS.put(woodenDoor, MODIFIED_ON_RIGHT);
-        }
-        for (Material woodenTrapdoor : Tag.WOODEN_TRAPDOORS.getValues()) {
-            MATERIAL_FLAGS.put(woodenTrapdoor, MODIFIED_ON_RIGHT);
-        }
-        for (Material shulkerBox : Tag.SHULKER_BOXES.getValues()) {
-            MATERIAL_FLAGS.put(shulkerBox, MODIFIED_ON_RIGHT);
-        }
-        for (Material boat : Tag.ITEMS_BOATS.getValues()) {
-            MATERIAL_FLAGS.put(boat, 0);
-        }
-        for (Material banner : Tag.BANNERS.getValues()) {
-            MATERIAL_FLAGS.put(banner, 0);
-        }
-        for (Material slab : Tag.SLABS.getValues()) {
-            MATERIAL_FLAGS.put(slab, 0);
-        }
-        for (Material plank : Tag.PLANKS.getValues()) {
-            MATERIAL_FLAGS.put(plank, 0);
-        }
-        for (Material carpet : Tag.CARPETS.getValues()) {
-            MATERIAL_FLAGS.put(carpet, 0);
-        }
-        for (Material sapling : Tag.SAPLINGS.getValues()) {
-            MATERIAL_FLAGS.put(sapling, 0);
-        }
-        for (Material log : Tag.LOGS.getValues()) {
-            MATERIAL_FLAGS.put(log, 0);
-        }
-        for (Material leaves : Tag.LEAVES.getValues()) {
-            MATERIAL_FLAGS.put(leaves, 0);
-        }
-        for (Material stair : Tag.STAIRS.getValues()) {
-            MATERIAL_FLAGS.put(stair, 0);
-        }
-        for (Material wool : Tag.WOOL.getValues()) {
-           MATERIAL_FLAGS.put(wool, 0);
-        }
-        for (Material plate : Tag.WOODEN_PRESSURE_PLATES.getValues()) {
-            MATERIAL_FLAGS.put(plate, 0);
-        }
-        for (Material button : Tag.BUTTONS.getValues()) {
-            MATERIAL_FLAGS.put(button, MODIFIED_ON_RIGHT);
-        }
-        for (Material pot : Tag.FLOWER_POTS.getValues()) {
-            MATERIAL_FLAGS.put(pot, MODIFIED_ON_RIGHT);
-        }
-        for (Material wall : Tag.WALLS.getValues()) {
-            MATERIAL_FLAGS.put(wall, 0);
-        }
-        for (Material sign : Tag.SIGNS.getValues()) {
-            MATERIAL_FLAGS.put(sign, 0);
-        }
-        for (Material flower : Tag.SMALL_FLOWERS.getValues()) {
-            MATERIAL_FLAGS.put(flower, 0);
-        }
-        for (Material bed : Tag.BEDS.getValues()) {
-            MATERIAL_FLAGS.put(bed, MODIFIED_ON_RIGHT);
-        }
-        for (Material musicDisc : Tag.ITEMS_MUSIC_DISCS.getValues()) {
-            MATERIAL_FLAGS.put(musicDisc, 0);
-        }
-        for (Material bannerPat : Tag.ITEMS_BANNERS.getValues()) {
-            MATERIAL_FLAGS.put(bannerPat, 0);
-        }
-        for (Material fenceGate : Tag.FENCE_GATES.getValues()) {
-            MATERIAL_FLAGS.put(fenceGate, MODIFIED_ON_RIGHT);
-        }
-        for (Material fence : Tag.FENCES.getValues()) {
-            MATERIAL_FLAGS.put(fence, 0);
-        }
+        putMaterialTag(Tag.WOODEN_DOORS, MODIFIED_ON_RIGHT);
+        putMaterialTag(Tag.WOODEN_TRAPDOORS, MODIFIED_ON_RIGHT);
+        putMaterialTag(Tag.SHULKER_BOXES, MODIFIED_ON_RIGHT);
+        putMaterialTag(Tag.ITEMS_BOATS, 0);
+        putMaterialTag(Tag.BANNERS, 0);
+        putMaterialTag(Tag.SLABS, 0);
+        putMaterialTag(Tag.PLANKS, 0);
+        putMaterialTag(Tag.WOOL_CARPETS, 0);
+        putMaterialTag(Tag.SAPLINGS, 0);
+        putMaterialTag(Tag.LOGS, 0);
+        putMaterialTag(Tag.LEAVES, 0);
+        putMaterialTag(Tag.STAIRS, 0);
+        putMaterialTag(Tag.WOOL, 0);
+        putMaterialTag(Tag.WOODEN_PRESSURE_PLATES, 0);
+        putMaterialTag(Tag.BUTTONS, MODIFIED_ON_RIGHT);
+        putMaterialTag(Tag.FLOWER_POTS, MODIFIED_ON_RIGHT);
+        putMaterialTag(Tag.WALLS, 0);
+        putMaterialTag(SIGNS_TAG, 0);
+        putMaterialTag(Tag.SMALL_FLOWERS, 0);
+        putMaterialTag(Tag.BEDS, MODIFIED_ON_RIGHT);
+        putMaterialTag(Tag.ITEMS_MUSIC_DISCS, 0);
+        putMaterialTag(Tag.ITEMS_BANNERS, 0);
+        putMaterialTag(Tag.FENCE_GATES, MODIFIED_ON_RIGHT);
+        putMaterialTag(Tag.FENCES, 0);
+
+        putMaterialTag(Tag.COAL_ORES, 0);
+        putMaterialTag(Tag.IRON_ORES, 0);
+        putMaterialTag(Tag.GOLD_ORES, 0);
+        putMaterialTag(Tag.DIAMOND_ORES, 0);
+        putMaterialTag(Tag.REDSTONE_ORES, 0);
+        putMaterialTag(Tag.COPPER_ORES, 0);
+        putMaterialTag(Tag.EMERALD_ORES, 0);
+        putMaterialTag(Tag.LAPIS_ORES, 0);
+        putMaterialTag(Tag.CANDLES, MODIFIED_ON_RIGHT);
+        putMaterialTag(Tag.CANDLE_CAKES, MODIFIED_ON_RIGHT);
+        putMaterialTag(Tag.CAULDRONS, MODIFIED_ON_RIGHT);
+
         Stream.concat(Stream.concat(
                 Tag.CORAL_BLOCKS.getValues().stream(),
                 Tag.CORALS.getValues().stream()),
@@ -856,6 +925,7 @@ public final class Materials {
 //        DAMAGE_EFFECTS.add(PotionEffectType.DOLPHINS_GRACE);
         DAMAGE_EFFECTS.add(PotionEffectType.BAD_OMEN);
 //        DAMAGE_EFFECTS.add(PotionEffectType.HERO_OF_THE_VILLAGE);
+        DAMAGE_EFFECTS.add(PotionEffectType.DARKNESS);
     }
 
     private Materials() {
@@ -1043,211 +1113,94 @@ public final class Materials {
                 || material == Material.BARREL
                 || material == Material.BLAST_FURNACE
                 || material == Material.SMOKER
+                || Tag.ITEMS_CHEST_BOATS.isTagged(material)
                 || Tag.SHULKER_BOXES.isTagged(material);
     }
 
     public static boolean isSpawnEgg(Material material) {
-        switch (material) {
-            case SPIDER_SPAWN_EGG:
-            case BAT_SPAWN_EGG:
-            case BEE_SPAWN_EGG:
-            case BLAZE_SPAWN_EGG:
-            case CAT_SPAWN_EGG:
-            case CAVE_SPIDER_SPAWN_EGG:
-            case CHICKEN_SPAWN_EGG:
-            case COD_SPAWN_EGG:
-            case COW_SPAWN_EGG:
-            case CREEPER_SPAWN_EGG:
-            case DOLPHIN_SPAWN_EGG:
-            case DONKEY_SPAWN_EGG:
-            case DROWNED_SPAWN_EGG:
-            case ELDER_GUARDIAN_SPAWN_EGG:
-            case ENDERMAN_SPAWN_EGG:
-            case ENDERMITE_SPAWN_EGG:
-            case EVOKER_SPAWN_EGG:
-            case FOX_SPAWN_EGG:
-            case GHAST_SPAWN_EGG:
-            case GUARDIAN_SPAWN_EGG:
-            case HOGLIN_SPAWN_EGG:
-            case HORSE_SPAWN_EGG:
-            case HUSK_SPAWN_EGG:
-            case LLAMA_SPAWN_EGG:
-            case MAGMA_CUBE_SPAWN_EGG:
-            case MOOSHROOM_SPAWN_EGG:
-            case MULE_SPAWN_EGG:
-            case OCELOT_SPAWN_EGG:
-            case PANDA_SPAWN_EGG:
-            case PARROT_SPAWN_EGG:
-            case PHANTOM_SPAWN_EGG:
-            case PIGLIN_BRUTE_SPAWN_EGG:
-            case PIGLIN_SPAWN_EGG:
-            case PIG_SPAWN_EGG:
-            case PILLAGER_SPAWN_EGG:
-            case POLAR_BEAR_SPAWN_EGG:
-            case PUFFERFISH_SPAWN_EGG:
-            case RABBIT_SPAWN_EGG:
-            case RAVAGER_SPAWN_EGG:
-            case SALMON_SPAWN_EGG:
-            case SHEEP_SPAWN_EGG:
-            case SHULKER_SPAWN_EGG:
-            case SILVERFISH_SPAWN_EGG:
-            case SKELETON_HORSE_SPAWN_EGG:
-            case SKELETON_SPAWN_EGG:
-            case SLIME_SPAWN_EGG:
-            case SQUID_SPAWN_EGG:
-            case STRAY_SPAWN_EGG:
-            case STRIDER_SPAWN_EGG:
-            case TRADER_LLAMA_SPAWN_EGG:
-            case TROPICAL_FISH_SPAWN_EGG:
-            case TURTLE_SPAWN_EGG:
-            case VEX_SPAWN_EGG:
-            case VILLAGER_SPAWN_EGG:
-            case VINDICATOR_SPAWN_EGG:
-            case WANDERING_TRADER_SPAWN_EGG:
-            case WITCH_SPAWN_EGG:
-            case WITHER_SKELETON_SPAWN_EGG:
-            case WOLF_SPAWN_EGG:
-            case ZOGLIN_SPAWN_EGG:
-            case ZOMBIE_HORSE_SPAWN_EGG:
-            case ZOMBIFIED_PIGLIN_SPAWN_EGG:
-            case ZOMBIE_SPAWN_EGG:
-            case ZOMBIE_VILLAGER_SPAWN_EGG:
-                return true;
-            default:
-                return false;
-        }
+        return getEntitySpawnEgg(material) != null;
     }
 
     public static EntityType getEntitySpawnEgg(Material material) {
-        switch (material) {
-            case SPIDER_SPAWN_EGG:
-                return EntityType.SPIDER;
-            case BAT_SPAWN_EGG:
-                return EntityType.BAT;
-            case BEE_SPAWN_EGG:
-                return EntityType.BEE;
-            case BLAZE_SPAWN_EGG:
-                return EntityType.BLAZE;
-            case CAT_SPAWN_EGG:
-                return EntityType.CAT;
-            case CAVE_SPIDER_SPAWN_EGG:
-                return EntityType.CAVE_SPIDER;
-            case CHICKEN_SPAWN_EGG:
-                return EntityType.CHICKEN;
-            case COD_SPAWN_EGG:
-                return EntityType.COD;
-            case COW_SPAWN_EGG:
-                return EntityType.COW;
-            case CREEPER_SPAWN_EGG:
-                return EntityType.CREEPER;
-            case DOLPHIN_SPAWN_EGG:
-                return EntityType.DOLPHIN;
-            case DONKEY_SPAWN_EGG:
-                return EntityType.DONKEY;
-            case DROWNED_SPAWN_EGG:
-                return EntityType.DROWNED;
-            case ELDER_GUARDIAN_SPAWN_EGG:
-                return EntityType.ELDER_GUARDIAN;
-            case ENDERMAN_SPAWN_EGG:
-                return EntityType.ENDERMAN;
-            case ENDERMITE_SPAWN_EGG:
-                return EntityType.ENDERMITE;
-            case EVOKER_SPAWN_EGG:
-                return EntityType.EVOKER;
-            case FOX_SPAWN_EGG:
-                return EntityType.FOX;
-            case GHAST_SPAWN_EGG:
-                return EntityType.GHAST;
-            case GUARDIAN_SPAWN_EGG:
-                return EntityType.GUARDIAN;
-            case HOGLIN_SPAWN_EGG:
-                return EntityType.HOGLIN;
-            case HORSE_SPAWN_EGG:
-                return EntityType.HORSE;
-            case HUSK_SPAWN_EGG:
-                return EntityType.HUSK;
-            case LLAMA_SPAWN_EGG:
-                return EntityType.LLAMA;
-            case MAGMA_CUBE_SPAWN_EGG:
-                return EntityType.MAGMA_CUBE;
-            case MOOSHROOM_SPAWN_EGG:
-                return EntityType.MUSHROOM_COW;
-            case MULE_SPAWN_EGG:
-                return EntityType.MULE;
-            case OCELOT_SPAWN_EGG:
-                return EntityType.OCELOT;
-            case PANDA_SPAWN_EGG:
-                return EntityType.PANDA;
-            case PARROT_SPAWN_EGG:
-                return EntityType.PARROT;
-            case PHANTOM_SPAWN_EGG:
-                return EntityType.PHANTOM;
-            case PIGLIN_BRUTE_SPAWN_EGG:
-                return EntityType.PIGLIN_BRUTE;
-            case PIGLIN_SPAWN_EGG:
-                return EntityType.PIGLIN;
-            case PILLAGER_SPAWN_EGG:
-                return EntityType.PILLAGER;
-            case POLAR_BEAR_SPAWN_EGG:
-                return EntityType.POLAR_BEAR;
-            case PUFFERFISH_SPAWN_EGG:
-                return EntityType.PUFFERFISH;
-            case RABBIT_SPAWN_EGG:
-                return EntityType.RABBIT;
-            case RAVAGER_SPAWN_EGG:
-                return EntityType.RAVAGER;
-            case SALMON_SPAWN_EGG:
-                return EntityType.SALMON;
-            case SHEEP_SPAWN_EGG:
-                return EntityType.SHEEP;
-            case SHULKER_SPAWN_EGG:
-                return EntityType.SHULKER;
-            case SILVERFISH_SPAWN_EGG:
-                return EntityType.SILVERFISH;
-            case SKELETON_HORSE_SPAWN_EGG:
-                return EntityType.SKELETON_HORSE;
-            case SKELETON_SPAWN_EGG:
-                return EntityType.SKELETON;
-            case SLIME_SPAWN_EGG:
-                return EntityType.SLIME;
-            case SQUID_SPAWN_EGG:
-                return EntityType.SQUID;
-            case STRAY_SPAWN_EGG:
-                return EntityType.STRAY;
-            case STRIDER_SPAWN_EGG:
-                return EntityType.STRIDER;
-            case TRADER_LLAMA_SPAWN_EGG:
-                return EntityType.TRADER_LLAMA;
-            case TROPICAL_FISH_SPAWN_EGG:
-                return EntityType.TROPICAL_FISH;
-            case TURTLE_SPAWN_EGG:
-                return EntityType.TURTLE;
-            case VEX_SPAWN_EGG:
-                return EntityType.VEX;
-            case VILLAGER_SPAWN_EGG:
-                return EntityType.VILLAGER;
-            case VINDICATOR_SPAWN_EGG:
-                return EntityType.VINDICATOR;
-            case WANDERING_TRADER_SPAWN_EGG:
-                return EntityType.WANDERING_TRADER;
-            case WITCH_SPAWN_EGG:
-                return EntityType.WITCH;
-            case WITHER_SKELETON_SPAWN_EGG:
-                return EntityType.WITHER_SKELETON;
-            case WOLF_SPAWN_EGG:
-                return EntityType.WOLF;
-            case ZOMBIE_HORSE_SPAWN_EGG:
-                return EntityType.ZOMBIE_HORSE;
-            case ZOMBIFIED_PIGLIN_SPAWN_EGG:
-                return EntityType.ZOMBIFIED_PIGLIN;
-            case ZOMBIE_SPAWN_EGG:
-                return EntityType.ZOMBIE;
-            case ZOMBIE_VILLAGER_SPAWN_EGG:
-                return EntityType.ZOMBIE_VILLAGER;
-            case PIG_SPAWN_EGG:
-            default: // Uhh
-                return EntityType.PIG;
-        }
+        return switch (material) {
+            case ALLAY_SPAWN_EGG -> EntityType.ALLAY;
+            case AXOLOTL_SPAWN_EGG -> EntityType.AXOLOTL;
+            case SPIDER_SPAWN_EGG -> EntityType.SPIDER;
+            case BAT_SPAWN_EGG -> EntityType.BAT;
+            case BEE_SPAWN_EGG -> EntityType.BEE;
+            case BLAZE_SPAWN_EGG -> EntityType.BLAZE;
+            case CAT_SPAWN_EGG -> EntityType.CAT;
+            case CAMEL_SPAWN_EGG -> EntityType.CAMEL;
+            case CAVE_SPIDER_SPAWN_EGG -> EntityType.CAVE_SPIDER;
+            case CHICKEN_SPAWN_EGG -> EntityType.CHICKEN;
+            case COD_SPAWN_EGG -> EntityType.COD;
+            case COW_SPAWN_EGG -> EntityType.COW;
+            case CREEPER_SPAWN_EGG -> EntityType.CREEPER;
+            case DOLPHIN_SPAWN_EGG -> EntityType.DOLPHIN;
+            case DONKEY_SPAWN_EGG -> EntityType.DONKEY;
+            case DROWNED_SPAWN_EGG -> EntityType.DROWNED;
+            case ELDER_GUARDIAN_SPAWN_EGG -> EntityType.ELDER_GUARDIAN;
+            case ENDER_DRAGON_SPAWN_EGG -> EntityType.ENDER_DRAGON;
+            case ENDERMAN_SPAWN_EGG -> EntityType.ENDERMAN;
+            case ENDERMITE_SPAWN_EGG -> EntityType.ENDERMITE;
+            case EVOKER_SPAWN_EGG -> EntityType.EVOKER;
+            case FOX_SPAWN_EGG -> EntityType.FOX;
+            case FROG_SPAWN_EGG -> EntityType.FROG;
+            case GHAST_SPAWN_EGG -> EntityType.GHAST;
+            case GLOW_SQUID_SPAWN_EGG -> EntityType.GLOW_SQUID;
+            case GOAT_SPAWN_EGG -> EntityType.GOAT;
+            case GUARDIAN_SPAWN_EGG -> EntityType.GUARDIAN;
+            case HOGLIN_SPAWN_EGG -> EntityType.HOGLIN;
+            case HORSE_SPAWN_EGG -> EntityType.HORSE;
+            case HUSK_SPAWN_EGG -> EntityType.HUSK;
+            case IRON_GOLEM_SPAWN_EGG -> EntityType.IRON_GOLEM;
+            case LLAMA_SPAWN_EGG -> EntityType.LLAMA;
+            case MAGMA_CUBE_SPAWN_EGG -> EntityType.MAGMA_CUBE;
+            case MOOSHROOM_SPAWN_EGG -> EntityType.MUSHROOM_COW;
+            case MULE_SPAWN_EGG -> EntityType.MULE;
+            case OCELOT_SPAWN_EGG -> EntityType.OCELOT;
+            case PANDA_SPAWN_EGG -> EntityType.PANDA;
+            case PARROT_SPAWN_EGG -> EntityType.PARROT;
+            case PHANTOM_SPAWN_EGG -> EntityType.PHANTOM;
+            case PIGLIN_BRUTE_SPAWN_EGG -> EntityType.PIGLIN_BRUTE;
+            case PIGLIN_SPAWN_EGG -> EntityType.PIGLIN;
+            case PILLAGER_SPAWN_EGG -> EntityType.PILLAGER;
+            case POLAR_BEAR_SPAWN_EGG -> EntityType.POLAR_BEAR;
+            case PUFFERFISH_SPAWN_EGG -> EntityType.PUFFERFISH;
+            case RABBIT_SPAWN_EGG -> EntityType.RABBIT;
+            case RAVAGER_SPAWN_EGG -> EntityType.RAVAGER;
+            case SALMON_SPAWN_EGG -> EntityType.SALMON;
+            case SHEEP_SPAWN_EGG -> EntityType.SHEEP;
+            case SHULKER_SPAWN_EGG -> EntityType.SHULKER;
+            case SILVERFISH_SPAWN_EGG -> EntityType.SILVERFISH;
+            case SKELETON_HORSE_SPAWN_EGG -> EntityType.SKELETON_HORSE;
+            case SKELETON_SPAWN_EGG -> EntityType.SKELETON;
+            case SLIME_SPAWN_EGG -> EntityType.SLIME;
+            case SNOW_GOLEM_SPAWN_EGG -> EntityType.SNOWMAN;
+            case SQUID_SPAWN_EGG -> EntityType.SQUID;
+            case STRAY_SPAWN_EGG -> EntityType.STRAY;
+            case STRIDER_SPAWN_EGG -> EntityType.STRIDER;
+            case TADPOLE_SPAWN_EGG -> EntityType.TADPOLE;
+            case TRADER_LLAMA_SPAWN_EGG -> EntityType.TRADER_LLAMA;
+            case TROPICAL_FISH_SPAWN_EGG -> EntityType.TROPICAL_FISH;
+            case TURTLE_SPAWN_EGG -> EntityType.TURTLE;
+            case VEX_SPAWN_EGG -> EntityType.VEX;
+            case VILLAGER_SPAWN_EGG -> EntityType.VILLAGER;
+            case VINDICATOR_SPAWN_EGG -> EntityType.VINDICATOR;
+            case WANDERING_TRADER_SPAWN_EGG -> EntityType.WANDERING_TRADER;
+            case WARDEN_SPAWN_EGG -> EntityType.WARDEN;
+            case WITCH_SPAWN_EGG -> EntityType.WITCH;
+            case WITHER_SPAWN_EGG -> EntityType.WITHER;
+            case WITHER_SKELETON_SPAWN_EGG -> EntityType.WITHER_SKELETON;
+            case WOLF_SPAWN_EGG -> EntityType.WOLF;
+            case ZOGLIN_SPAWN_EGG -> EntityType.ZOGLIN;
+            case ZOMBIE_HORSE_SPAWN_EGG -> EntityType.ZOMBIE_HORSE;
+            case ZOMBIFIED_PIGLIN_SPAWN_EGG -> EntityType.ZOMBIFIED_PIGLIN;
+            case ZOMBIE_SPAWN_EGG -> EntityType.ZOMBIE;
+            case ZOMBIE_VILLAGER_SPAWN_EGG -> EntityType.ZOMBIE_VILLAGER;
+            case PIG_SPAWN_EGG -> EntityType.PIG;
+            default -> null;
+        };
     }
 
     public static boolean isBed(Material material) {
@@ -1271,20 +1224,14 @@ public final class Materials {
      * @return true if the material is a crop
      */
     public static boolean isCrop(Material type) {
-        return type == Material.WHEAT
-                || type == Material.CARROTS
-                || type == Material.POTATOES
-                || type == Material.BEETROOTS
-                || type == Material.MELON_STEM
-                || type == Material.PUMPKIN_STEM
-                || type == Material.PUMPKIN
-                || type == Material.MELON
-                || type == Material.CACTUS
-                || type == Material.SUGAR_CANE
-                || type == Material.BAMBOO
-                || type == Material.BAMBOO_SAPLING
-                || type == Material.SWEET_BERRY_BUSH
-                || type == Material.NETHER_WART;
+        if (Tag.CROPS.isTagged(type)) return true;
+        // yea, that's not all, there are some more
+        return switch (type) {
+            case PUMPKIN, MELON, CACTUS, SUGAR_CANE, BAMBOO, BAMBOO_SAPLING,
+                    SWEET_BERRY_BUSH, NETHER_WART, CAVE_VINES, CAVE_VINES_PLANT ->
+                    true;
+            default -> false;
+        };
     }
 
     /**
@@ -1296,7 +1243,8 @@ public final class Materials {
         return newType == Material.VINE ||
                 newType == Material.KELP ||
                 newType == Material.TWISTING_VINES ||
-                newType == Material.WEEPING_VINES;
+                newType == Material.WEEPING_VINES ||
+                Tag.CAVE_VINES.isTagged(newType);
 
     }
 
@@ -1318,18 +1266,11 @@ public final class Materials {
                 || Tag.PRESSURE_PLATES.isTagged(material)) {
             return true;
         }
-        switch (material) {
-            case LEVER:
-            case LECTERN:
-            case ENCHANTING_TABLE:
-            case BELL:
-            case LOOM:
-            case CARTOGRAPHY_TABLE:
-            case STONECUTTER:
-            case GRINDSTONE:
-                return true;
-            default: return false;
-        }
+        return switch (material) {
+            case LEVER, LECTERN, ENCHANTING_TABLE, BELL, LOOM,
+                    CARTOGRAPHY_TABLE, STONECUTTER, GRINDSTONE -> true;
+            default -> false;
+        };
     }
 
     /**
@@ -1375,7 +1316,11 @@ public final class Materials {
     public static boolean isConsideredBuildingIfUsed(Material type) {
         return type == Material.REPEATER
             || type == Material.COMPARATOR
-            || Tag.FLOWER_POTS.isTagged(type);
+            || type == Material.CAKE
+            || type == Material.DRAGON_EGG
+            || Tag.FLOWER_POTS.isTagged(type)
+            || Tag.CANDLES.isTagged(type)
+            || Tag.CANDLE_CAKES.isTagged(type);
     }
 
     /**
@@ -1405,37 +1350,17 @@ public final class Materials {
      * @return true if equippable armor
      */
     public static boolean isArmor(Material type) {
-        switch (type) {
-            case LEATHER_HELMET:
-            case LEATHER_CHESTPLATE:
-            case LEATHER_LEGGINGS:
-            case LEATHER_BOOTS:
-            case CHAINMAIL_HELMET:
-            case CHAINMAIL_CHESTPLATE:
-            case CHAINMAIL_LEGGINGS:
-            case CHAINMAIL_BOOTS:
-            case IRON_HELMET:
-            case IRON_CHESTPLATE:
-            case IRON_LEGGINGS:
-            case IRON_BOOTS:
-            case DIAMOND_HELMET:
-            case DIAMOND_CHESTPLATE:
-            case DIAMOND_LEGGINGS:
-            case DIAMOND_BOOTS:
-            case GOLDEN_HELMET:
-            case GOLDEN_CHESTPLATE:
-            case GOLDEN_LEGGINGS:
-            case GOLDEN_BOOTS:
-            case NETHERITE_HELMET:
-            case NETHERITE_CHESTPLATE:
-            case NETHERITE_LEGGINGS:
-            case NETHERITE_BOOTS:
-            case TURTLE_HELMET:
-            case ELYTRA:
-                return true;
-            default:
-                return false;
-        }
+        return switch (type) {
+            case LEATHER_HELMET, LEATHER_CHESTPLATE, LEATHER_LEGGINGS, LEATHER_BOOTS,
+                    CHAINMAIL_HELMET, CHAINMAIL_CHESTPLATE, CHAINMAIL_LEGGINGS, CHAINMAIL_BOOTS,
+                    IRON_HELMET, IRON_CHESTPLATE, IRON_LEGGINGS, IRON_BOOTS,
+                    DIAMOND_HELMET, DIAMOND_CHESTPLATE, DIAMOND_LEGGINGS, DIAMOND_BOOTS,
+                    GOLDEN_HELMET, GOLDEN_CHESTPLATE, GOLDEN_LEGGINGS, GOLDEN_BOOTS,
+                    NETHERITE_HELMET, NETHERITE_CHESTPLATE, NETHERITE_LEGGINGS, NETHERITE_BOOTS,
+                    TURTLE_HELMET, ELYTRA ->
+                    true;
+            default -> false;
+        };
     }
 
     /**
@@ -1456,61 +1381,40 @@ public final class Materials {
             case GOLDEN_HOE:
             case DIAMOND_HOE:
             case NETHERITE_HOE:
-                switch (targetMaterial) {
-                    case GRASS_BLOCK:
-                    case DIRT:
-                    case GRASS_PATH:
-                    // case COARSE_DIRT: // already handled by the server...
-                        return true;
-                }
-                return false;
+                return switch (targetMaterial) {
+                    case GRASS_BLOCK, DIRT, DIRT_PATH, ROOTED_DIRT ->
+                            true;
+                    default -> false;
+                };
             case WOODEN_AXE:
             case STONE_AXE:
             case IRON_AXE:
             case GOLDEN_AXE:
             case DIAMOND_AXE:
             case NETHERITE_AXE:
-                switch (targetMaterial) {
-                    case OAK_LOG:
-                    case DARK_OAK_LOG:
-                    case ACACIA_LOG:
-                    case BIRCH_LOG:
-                    case SPRUCE_LOG:
-                    case JUNGLE_LOG:
-                    case OAK_WOOD:
-                    case DARK_OAK_WOOD:
-                    case ACACIA_WOOD:
-                    case BIRCH_WOOD:
-                    case SPRUCE_WOOD:
-                    case JUNGLE_WOOD:
-                    case CRIMSON_STEM:
-                    case WARPED_STEM:
-                    case CRIMSON_HYPHAE:
-                    case WARPED_HYPHAE:
-                        return true;
-                }
-                return false;
+                if (isWaxedCopper(targetMaterial)) return true;
+                if (Tag.LOGS.isTagged(targetMaterial)) return true;
+                return switch (targetMaterial) {
+                    case OAK_WOOD, DARK_OAK_WOOD, ACACIA_WOOD, BIRCH_WOOD, SPRUCE_WOOD, PUMPKIN, BAMBOO_BLOCK,
+                            JUNGLE_WOOD, CRIMSON_STEM, WARPED_STEM, CRIMSON_HYPHAE, WARPED_HYPHAE ->
+                            true;
+                    default -> false;
+                };
             case WOODEN_SHOVEL:
             case STONE_SHOVEL:
             case IRON_SHOVEL:
             case GOLDEN_SHOVEL:
             case DIAMOND_SHOVEL:
             case NETHERITE_SHOVEL:
-                switch (targetMaterial) {
-                    case GRASS_BLOCK:
-                    case CAMPFIRE:
-                    case SOUL_CAMPFIRE:
-                        return true;
-                }
-                return false;
+                return switch (targetMaterial) {
+                    case GRASS_BLOCK, CAMPFIRE, SOUL_CAMPFIRE -> true;
+                    default -> false;
+                };
             case SHEARS:
-                switch (targetMaterial) {
-                    case PUMPKIN:
-                    case BEE_NEST:
-                    case BEEHIVE:
-                        return true;
-                }
-                return false;
+                return switch (targetMaterial) {
+                    case PUMPKIN, BEE_NEST, BEEHIVE -> true;
+                    default -> false;
+                };
             case BLACK_DYE:
             case BLUE_DYE:
             case BROWN_DYE:
@@ -1527,7 +1431,11 @@ public final class Materials {
             case RED_DYE:
             case WHITE_DYE:
             case YELLOW_DYE:
-                return Tag.SIGNS.isTagged(targetMaterial);
+            case GLOW_INK_SAC:
+            case INK_SAC:
+                return SIGNS_TAG.isTagged(targetMaterial);
+            case HONEYCOMB:
+                return isUnwaxedCopper(targetMaterial);
             default:
                 return false;
         }
@@ -1536,4 +1444,39 @@ public final class Materials {
     public static boolean isFire(Material type) {
         return type == Material.FIRE || type == Material.SOUL_FIRE;
     }
+    
+    public static boolean isWaxedCopper(Material type) {
+        return switch (type) {
+            case WAXED_COPPER_BLOCK, WAXED_EXPOSED_COPPER, WAXED_WEATHERED_COPPER, WAXED_OXIDIZED_COPPER,
+                    WAXED_CUT_COPPER, WAXED_EXPOSED_CUT_COPPER, WAXED_WEATHERED_CUT_COPPER,
+                    WAXED_OXIDIZED_CUT_COPPER, WAXED_CUT_COPPER_STAIRS, WAXED_EXPOSED_CUT_COPPER_STAIRS,
+                    WAXED_WEATHERED_CUT_COPPER_STAIRS, WAXED_OXIDIZED_CUT_COPPER_STAIRS, WAXED_CUT_COPPER_SLAB,
+                    WAXED_EXPOSED_CUT_COPPER_SLAB, WAXED_WEATHERED_CUT_COPPER_SLAB, WAXED_OXIDIZED_CUT_COPPER_SLAB ->
+                    true;
+            default -> false;
+        };
+    }
+    
+    public static boolean isUnwaxedCopper(Material type) {
+        return switch (type) {
+            case COPPER_BLOCK, EXPOSED_COPPER, WEATHERED_COPPER, OXIDIZED_COPPER, CUT_COPPER,
+                    EXPOSED_CUT_COPPER, WEATHERED_CUT_COPPER, OXIDIZED_CUT_COPPER, CUT_COPPER_STAIRS,
+                    EXPOSED_CUT_COPPER_STAIRS, WEATHERED_CUT_COPPER_STAIRS, OXIDIZED_CUT_COPPER_STAIRS,
+                    CUT_COPPER_SLAB, EXPOSED_CUT_COPPER_SLAB, WEATHERED_CUT_COPPER_SLAB, OXIDIZED_CUT_COPPER_SLAB ->
+                    true;
+            default -> false;
+        };
+    }
+
+    public static boolean isAmethystGrowth(Material mat) {
+        return mat == Material.BUDDING_AMETHYST
+                || mat == Material.AMETHYST_CLUSTER
+                || mat == Material.LARGE_AMETHYST_BUD
+                || mat == Material.MEDIUM_AMETHYST_BUD
+                || mat == Material.SMALL_AMETHYST_BUD;
+    }
+
+    public static boolean isSculkGrowth(Material mat) {
+        return mat == Material.SCULK || mat == Material.SCULK_VEIN;
+    }
 }

worldguard-bukkit/src/main/java/com/sk89q/worldguard/bukkit/util/logging/ClassSourceValidator.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.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

@@ -0,0 +1,48 @@
+/*
+ * 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,6 +20,7 @@
 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;
 
@@ -33,9 +34,18 @@ 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);
+
         DataReport spawning = new DataReport("Spawning");
         spawning.append("Ambient Spawn Limit", server.getAmbientSpawnLimit());
         spawning.append("Animal Spawn Limit", server.getAnimalSpawnLimit());

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

@@ -19,14 +19,19 @@
 
 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() {
@@ -37,18 +42,19 @@ public final class PaperProfileService extends SingleRequestService {
 
     @Override
     public int getIdealRequestLimit() {
-        return Integer.MAX_VALUE;
+        return SUPER.getIdealRequestLimit();
     }
 
     @Override
     @Nullable
-    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 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 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.16
+api-version: 1.19

worldguard-core/build.gradle.kts

@@ -1,7 +1,5 @@
 plugins {
-    id("java-library")
-    id("net.ltgt.apt-eclipse")
-    id("net.ltgt.apt-idea")
+    `java-library`
 }
 
 applyPlatformAndCoreConfiguration()
@@ -10,24 +8,13 @@ dependencies {
     "api"(project(":worldguard-libs:core"))
     "api"("com.sk89q.worldedit:worldedit-core:${Versions.WORLDEDIT}")
     "implementation"("org.flywaydb:flyway-core:3.0")
-    "implementation"("org.yaml:snakeyaml:1.9")
+    "implementation"("org.yaml:snakeyaml:1.33")
     "implementation"("com.google.guava:guava:${Versions.GUAVA}")
 
-    "compileOnly"("com.google.code.findbugs:jsr305:1.3.9")
-    "testImplementation"("org.hamcrest:hamcrest-library:1.2.1")
+    "compileOnly"("com.google.code.findbugs:jsr305:${Versions.FINDBUGS}")
+    "testImplementation"("org.hamcrest:hamcrest-library:2.2")
 }
 
 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,11 +93,12 @@ public final class WorldGuard {
 
     /**
      * The WorldGuard Platform.
+     * The Platform is only available after WorldGuard is enabled.
      *
      * @return The platform
      */
     public WorldGuardPlatform getPlatform() {
-        checkNotNull(platform);
+        checkNotNull(platform, "WorldGuard is not enabled, unable to access the platform.");
         return platform;
     }
 

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

@@ -24,6 +24,7 @@ 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;
@@ -87,13 +88,13 @@ public class FileHandler implements LoggerHandler {
      * Build the path.
      *
      * @param playerName The name of the player
-     * @return The path for the logfile
+     * @return The path for the logfile, null when no applicable path could be found
      */
-    private String buildPath(String playerName) {
+    private @Nullable String buildPath(@Nullable String playerName) {
         GregorianCalendar calendar = new GregorianCalendar();
 
         Matcher m = pattern.matcher(pathPattern);
-        StringBuffer buffer = new StringBuffer();
+        StringBuilder buffer = new StringBuilder();
 
         // Pattern replacements
         while (m.find()) {
@@ -103,12 +104,13 @@ 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);
@@ -148,11 +150,12 @@ public class FileHandler implements LoggerHandler {
      * @param message The message to log
      * @param comment The comment associated with the logged event
      */
-    private void log(LocalPlayer player, String message, String comment) {
-        String path = buildPath(player.getName());
+    private void log(@Nullable LocalPlayer player, String message, String comment) {
+        String path = buildPath(player != null ? player.getName() : null);
+        if (path == null) return;
         try {
             String date = dateFormat.format(new Date());
-            String line = "[" + date + "] " + player.getName() + ": " + message
+            String line = "[" + date + "] " + (player != null ? player.getName() : "Unknown Source") + ": " + message
                     + (comment != null ? " (" + comment + ")" : "") + "\r\n";
 
             LogFileWriter writer = writers.get(path);
@@ -190,7 +193,7 @@ public class FileHandler implements LoggerHandler {
                         writers.entrySet().iterator();
 
                 // Remove some entries
-                for (; it.hasNext(); ) {
+                while (it.hasNext()) {
                     Map.Entry<String,LogFileWriter> entry = it.next();
                     try {
                         entry.getValue().getWriter().close();

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<Sampler>() {
+        Futures.addCallback(sampler.getFuture(), new FutureCallback<>() {
             @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/RegionCommands.java

@@ -21,6 +21,7 @@ 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;
@@ -30,6 +31,7 @@ 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;
@@ -41,6 +43,7 @@ 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.task.RegionAdder;
@@ -52,6 +55,7 @@ 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;
@@ -64,6 +68,7 @@ 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;
@@ -72,6 +77,7 @@ 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;
@@ -279,7 +285,7 @@ public final class RegionCommands extends RegionCommandsBase {
             }
         }
 
-        // We have to check whether this region violates the space of any other reion
+        // We have to check whether this region violates the space of any other region
         ApplicableRegionSet regions = manager.getApplicableRegions(region);
 
         // Check if this region overlaps any other region
@@ -312,17 +318,21 @@ public final class RegionCommands extends RegionCommandsBase {
             }
         }
 
-        RegionAdder task = new RegionAdder(manager, region);
-        task.setLocatorPolicy(UserLocatorPolicy.UUID_ONLY);
-        task.setOwnersInput(new String[]{player.getName()});
+        // 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());
+                }
+            }
+        }
 
-        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());
+        region.getOwners().addPlayer(player);
+        manager.addRegion(region);
+        player.print(TextComponent.of(String.format("A new region has been claimed named '%s'.", id)));
     }
 
     /**
@@ -434,9 +444,9 @@ public final class RegionCommands extends RegionCommandsBase {
      * @throws CommandException any error
      */
     @Command(aliases = {"list"},
-             usage = "[page]",
+             usage = "[-w world] [-p owner [-n]] [-s] [-i filter] [page]",
              desc = "Get a list of regions",
-             flags = "np:w:",
+             flags = "np:w:i:s",
              max = 1)
     public void list(CommandContext args, Actor sender) throws CommandException {
         warnAboutSaveFailures(sender);
@@ -473,6 +483,16 @@ 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...)")
@@ -1067,6 +1087,62 @@ 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
      * 
@@ -1075,8 +1151,8 @@ public final class RegionCommands extends RegionCommandsBase {
      * @throws CommandException any error
      */
     @Command(aliases = {"teleport", "tp"},
-             usage = "<id>",
-             flags = "sw:",
+             usage = "[-w world] [-c|s] <id>",
+             flags = "csw:",
              desc = "Teleports you to the location associated with the region.",
              min = 1, max = 1)
     public void teleport(CommandContext args, Actor sender) throws CommandException {
@@ -1095,21 +1171,38 @@ public final class RegionCommands extends RegionCommandsBase {
 
         // -s for spawn location
         if (args.hasFlag('s')) {
-            teleportLocation = existing.getFlag(Flags.SPAWN_LOC);
+            teleportLocation = FlagValueCalculator.getEffectiveFlagOf(existing, Flags.SPAWN_LOC, player);
             
             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 = existing.getFlag(Flags.TELE_LOC);
+            teleportLocation = FlagValueCalculator.getEffectiveFlagOf(existing, Flags.TELE_LOC, player);
             
             if (teleportLocation == null) {
                 throw new CommandException("The region has no teleport point associated.");
             }
         }
 
-        String message = existing.getFlag(Flags.TELE_MESSAGE);
+        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(...)

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

@@ -55,6 +55,7 @@ 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;
@@ -200,7 +201,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());
+        ApplicableRegionSet set = regionManager.getApplicableRegions(player.getLocation().toVector().toBlockPoint(), QueryOption.SORT);
 
         if (set.size() == 0) {
             if (allowGlobal) {
@@ -210,7 +211,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;
@@ -230,7 +231,7 @@ class RegionCommandsBase {
                 builder.append(regionComp);
             }
             player.print(builder.build());
-            throw new CommandException("Several regions affect your current location (please pick one).");
+            throw new CommandException("You're standing in several regions (please pick one).");
         }
 
         return set.iterator().next();

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

@@ -36,6 +36,8 @@ 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;
@@ -315,7 +317,7 @@ public class RegionPrintoutBuilder implements Callable<TextComponent> {
                     .clickEvent(ClickEvent.of(ClickEvent.Action.RUN_COMMAND, "/rg select " + region.getId()));
         }
         builder.append(bound);
-        final Location teleFlag = region.getFlag(Flags.TELE_LOC);
+        final Location teleFlag = FlagValueCalculator.getEffectiveFlagOf(region, Flags.TELE_LOC, perms != null && perms.getSender() instanceof RegionAssociable ? (RegionAssociable) perms.getSender() : null);
         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,
@@ -325,6 +327,12 @@ public class RegionPrintoutBuilder implements Callable<TextComponent> {
                                             + 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,6 +24,7 @@ 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;
@@ -33,12 +34,15 @@ 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;
@@ -55,6 +59,8 @@ 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;
@@ -77,6 +83,10 @@ 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;
@@ -141,20 +151,29 @@ 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 (Map.Entry<String, ProtectedRegion> rg : regions.entrySet()) {
-            if (rg.getKey().equals("__global__")) {
+        for (ProtectedRegion rg : iterableRegions) {
+            if (rg.getId().equals("__global__")) {
                 continue;
             }
-            final ProtectedRegion region = rg.getValue();
-            final RegionListEntry entry = new RegionListEntry(region);
-            if (entry.matches(ownerMatcher)) {
+            final RegionListEntry entry = new RegionListEntry(rg);
+
+            if (entry.matches(idFilter) && entry.matches(ownerMatcher)) {
                 entries.add(entry);
             }
         }
@@ -165,7 +184,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(ownerMatcher)) {
+            if (entry.matches(idFilter) && entry.matches(ownerMatcher)) {
                 entries.add(0, entry);
             }
         }
@@ -179,6 +198,8 @@ 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));
@@ -207,6 +228,10 @@ 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;
         }
@@ -261,11 +286,18 @@ public class RegionLister implements Callable<Integer> {
                         .clickEvent(ClickEvent.of(ClickEvent.Action.RUN_COMMAND,
                                 "/rg info -w \"" + world + "\" " + entry.region.getId()))));
             }
-            if (perms != null && entry.region.getFlag(Flags.TELE_LOC) != null && perms.mayTeleportTo(entry.region)) {
+            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)) {
                 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/WorldConfiguration.java

@@ -129,6 +129,7 @@ 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;
@@ -157,11 +158,14 @@ 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;
@@ -170,7 +174,6 @@ public abstract class WorldConfiguration {
     public boolean fakePlayerBuildOverride;
     public boolean explosionFlagCancellation;
     public boolean disableDeathMessages;
-    public boolean disableObsidianGenerators;
     public boolean strictEntitySpawn;
     public boolean ignoreHopperMoveEvents;
     public boolean breakDeniedHoppers;

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

@@ -93,6 +93,12 @@ 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

@@ -409,15 +409,18 @@ 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 component;
+                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.clickEvent(ClickEvent.of(ClickEvent.Action.SUGGEST_COMMAND, uuid.toString()));
         }).iterator();
         while (profiles.hasNext()) {
             builder.append(profiles.next());
@@ -428,9 +431,11 @@ 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(String.join("\n", uuids))
-                        .append(TextComponent.newline().append(TextComponent.of("Click to select")))))
-                    .clickEvent(ClickEvent.of(ClickEvent.Action.SUGGEST_COMMAND, String.join(",", uuids))));
+                    .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))));
         }
 
 

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

@@ -63,7 +63,11 @@ 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");
     }
@@ -106,6 +110,10 @@ 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);
     }
@@ -125,7 +133,7 @@ public class RegionPermissionModel extends AbstractPermissionModel {
             return mayList();
         }
     }
-    
+
     public boolean maySetFlag(ProtectedRegion region) {
         return hasPatternPermission("flag.regions", region);
     }
@@ -195,5 +203,4 @@ public class RegionPermissionModel extends AbstractPermissionModel {
 
         return hasPluginPermission(effectivePerm);
     }
-
 }

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

@@ -297,7 +297,12 @@ public class FlagValueCalculator {
     }
 
     @Nullable
-    private <V, K> V getEffectiveMapValue(ProtectedRegion region, MapFlag<K, V> mapFlag, K key, RegionAssociable subject) {
+    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;
 
@@ -450,7 +455,11 @@ public class FlagValueCalculator {
      * @return the priority
      */
     public int getPriority(final ProtectedRegion region) {
-        if (region == globalRegion) {
+        return getPriorityOf(region);
+    }
+
+    public static int getPriorityOf(final ProtectedRegion region) {
+        if (region.getId().equals(ProtectedRegion.GLOBAL_REGION)) {
             return Integer.MIN_VALUE;
         } else {
             return region.getPriority();
@@ -466,9 +475,15 @@ public class FlagValueCalculator {
      * @param subject an subject object
      * @return the value
      */
-    @SuppressWarnings("unchecked")
+    @Nullable
     public <V> V getEffectiveFlag(final ProtectedRegion region, Flag<V> flag, @Nullable RegionAssociable subject) {
-        if (region == globalRegion) {
+        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)) {
             if (flag == Flags.PASSTHROUGH) {
                 // Has members/owners -> the global region acts like
                 // a regular region without PASSTHROUGH

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

@@ -19,6 +19,7 @@
 
 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;
@@ -29,7 +30,11 @@ import com.sk89q.worldguard.protection.regions.ProtectedRegion;
 import com.sk89q.worldguard.protection.util.NormativeOrders;
 
 import javax.annotation.Nullable;
-import java.util.*;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Set;
 
 import static com.google.common.base.Preconditions.checkNotNull;
 
@@ -64,7 +69,7 @@ public class RegionResultSet extends AbstractRegionSet {
      */
     public RegionResultSet(Set<ProtectedRegion> applicable, @Nullable ProtectedRegion globalRegion) {
         this(NormativeOrders.fromSet(applicable), globalRegion, true);
-        this.regionSet = applicable;
+        this.regionSet = ImmutableSet.copyOf(applicable);
     }
 
     /**
@@ -83,7 +88,7 @@ public class RegionResultSet extends AbstractRegionSet {
         if (!sorted) {
             NormativeOrders.sort(applicable);
         }
-        this.applicable = applicable;
+        this.applicable = Collections.unmodifiableList(applicable);
         this.flagValueCalculator = new FlagValueCalculator(applicable, globalRegion);
     }
 
@@ -157,7 +162,7 @@ public class RegionResultSet extends AbstractRegionSet {
         if (regionSet != null) {
             return regionSet;
         }
-        regionSet = Collections.unmodifiableSet(new HashSet<>(applicable));
+        regionSet = ImmutableSet.copyOf(applicable);
         return regionSet;
     }
 

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

@@ -22,6 +22,7 @@ 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;
 
@@ -69,7 +70,8 @@ public abstract class AbstractRegionOverlapAssociation implements RegionAssociab
         }
 
         for (ProtectedRegion region : source) {
-            Set<String> regionDomains = region.getFlag(Flags.NONPLAYER_PROTECTION_DOMAINS);
+            // 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;
@@ -87,31 +89,36 @@ public abstract class AbstractRegionOverlapAssociation implements RegionAssociab
     public Association getAssociation(List<ProtectedRegion> regions) {
         checkNotNull(source);
         for (ProtectedRegion region : regions) {
-            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 {
+            while (region != null) {
+                if ((region.getId().equals(ProtectedRegion.GLOBAL_REGION) && source.isEmpty())) {
                     return Association.OWNER;
                 }
-            }
 
-            Set<ProtectedRegion> source;
+                if (source.contains(region)) {
+                    if (useMaxPriorityAssociation) {
+                        int priority = region.getPriority();
+                        if (priority == maxPriority) {
+                            return Association.OWNER;
+                        }
+                    } else {
+                        return Association.OWNER;
+                    }
+                }
 
-            if (useMaxPriorityAssociation) {
-                source = maxPriorityRegions;
-            } else {
-                source = this.source;
-            }
+                Set<ProtectedRegion> source;
 
-            if (checkNonplayerProtectionDomains(source, region.getFlag(Flags.NONPLAYER_PROTECTION_DOMAINS))) {
-                return Association.OWNER;
+                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();
             }
         }
 

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

@@ -26,6 +26,7 @@ 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;
 
@@ -67,7 +68,7 @@ public class DelayedRegionOverlapAssociation extends AbstractRegionOverlapAssoci
     @Override
     public Association getAssociation(List<ProtectedRegion> regions) {
         if (source == null) {
-            ApplicableRegionSet result = query.getApplicableRegions(location);
+            ApplicableRegionSet result = query.getApplicableRegions(location, QueryOption.NONE);
             source = result.getRegions();
             calcMaxPriority();
         }

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

@@ -46,7 +46,7 @@ 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", new StringFlag(null)));
+    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));
@@ -73,6 +73,7 @@ public final class Flags {
     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.
@@ -119,9 +120,12 @@ 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));
 

worldguard-core/src/main/java/com/sk89q/worldguard/protection/managers/RegionManager.java

@@ -34,7 +34,7 @@ import com.sk89q.worldguard.protection.managers.storage.DifferenceSaveException;
 import com.sk89q.worldguard.protection.managers.storage.RegionDatabase;
 import com.sk89q.worldguard.protection.managers.storage.StorageException;
 import com.sk89q.worldguard.protection.regions.ProtectedRegion;
-import com.sk89q.worldguard.protection.util.RegionCollectionConsumer;
+import com.sk89q.worldguard.protection.regions.RegionQuery.QueryOption;
 import com.sk89q.worldguard.util.Normal;
 
 import javax.annotation.Nullable;
@@ -293,32 +293,60 @@ public final class RegionManager {
     }
 
     /**
-     * Query for effective flags and owners for the given positive.
+     * Query for effective flags and members for the given position.
+     *
+     * <p>{@link QueryOption#COMPUTE_PARENTS} is used.</p>
      *
      * @param position the position
      * @return the query object
      */
     public ApplicableRegionSet getApplicableRegions(BlockVector3 position) {
-        checkNotNull(position);
-
-        Set<ProtectedRegion> regions = Sets.newHashSet();
-        index.applyContaining(position, new RegionCollectionConsumer(regions, true));
-        return new RegionResultSet(regions, index.get("__global__"));
+        return getApplicableRegions(position, QueryOption.COMPUTE_PARENTS);
     }
 
     /**
-     * Query for effective flags and owners for the area represented
+     * Return a region set for the given position.
+     *
+     * @param position the position
+     * @param option the option
+     * @return a region set
+     */
+    public ApplicableRegionSet getApplicableRegions(BlockVector3 position, QueryOption option) {
+        checkNotNull(position);
+        checkNotNull(option);
+
+        Set<ProtectedRegion> regions = Sets.newHashSet();
+        index.applyContaining(position, option.createIndexConsumer(regions));
+        return new RegionResultSet(option.constructResult(regions), index.get("__global__"), true);
+    }
+
+    /**
+     * Query for effective flags and members for the area represented
      * by the given region.
      *
+     * <p>{@link QueryOption#COMPUTE_PARENTS} is used.</p>
+     *
      * @param region the region
      * @return the query object
      */
     public ApplicableRegionSet getApplicableRegions(ProtectedRegion region) {
+        return getApplicableRegions(region, QueryOption.COMPUTE_PARENTS);
+    }
+
+    /**
+     * Return a region set for the area represented by the given region.
+     *
+     * @param region the region
+     * @param option the option
+     * @return a region set
+     */
+    public ApplicableRegionSet getApplicableRegions(ProtectedRegion region, QueryOption option) {
         checkNotNull(region);
+        checkNotNull(option);
 
         Set<ProtectedRegion> regions = Sets.newHashSet();
-        index.applyIntersecting(region, new RegionCollectionConsumer(regions, true));
-        return new RegionResultSet(regions, index.get("__global__"));
+        index.applyIntersecting(region, option.createIndexConsumer(regions));
+        return new RegionResultSet(option.constructResult(regions), index.get("__global__"), true);
     }
 
     /**

worldguard-core/src/main/java/com/sk89q/worldguard/protection/managers/index/ChunkHashTable.java

@@ -316,7 +316,7 @@ public class ChunkHashTable implements ConcurrentRegionIndex {
                     List<ProtectedRegion> regions = new ArrayList<>();
                     ProtectedRegion chunkRegion = new ProtectedCuboidRegion(
                             "_",
-                            position.multiply(16).toBlockVector3(0),
+                            position.multiply(16).toBlockVector3(Integer.MIN_VALUE),
                             position.add(1, 1).multiply(16).toBlockVector3(Integer.MAX_VALUE));
                     index.applyIntersecting(chunkRegion, new RegionCollectionConsumer(regions, false));
                     Collections.sort(regions);

worldguard-core/src/main/java/com/sk89q/worldguard/protection/managers/index/HashMapIndex.java

@@ -24,9 +24,11 @@ import static com.sk89q.worldguard.util.Normal.normalize;
 
 import com.sk89q.worldedit.math.BlockVector2;
 import com.sk89q.worldedit.math.BlockVector3;
+import com.sk89q.worldguard.WorldGuard;
 import com.sk89q.worldguard.protection.managers.RegionDifference;
 import com.sk89q.worldguard.protection.managers.RemovalStrategy;
 import com.sk89q.worldguard.protection.regions.ProtectedRegion;
+import com.sk89q.worldguard.protection.regions.ProtectedRegion.CircularInheritanceException;
 
 import javax.annotation.Nullable;
 import java.util.Collection;
@@ -38,6 +40,7 @@ import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.ConcurrentMap;
 import java.util.function.Function;
 import java.util.function.Predicate;
+import java.util.logging.Level;
 
 /**
  * An index that stores regions in a hash map, which allows for fast lookup
@@ -74,9 +77,13 @@ public class HashMapIndex extends AbstractRegionIndex implements ConcurrentRegio
 
             ProtectedRegion existing = regions.get(normalId);
 
-            // Casing / form of ID has changed
-            if (existing != null && !existing.getId().equals(region.getId())) {
-                removed.add(existing);
+            if (existing != null) {
+                removeAndReplaceParents(existing.getId(), RemovalStrategy.UNSET_PARENT_IN_CHILDREN, region, false);
+
+                // Casing / form of ID has not changed
+                if (existing.getId().equals(region.getId())) {
+                    removed.remove(existing);
+                }
             }
 
             regions.put(normalId, region);
@@ -134,6 +141,10 @@ public class HashMapIndex extends AbstractRegionIndex implements ConcurrentRegio
 
     @Override
     public Set<ProtectedRegion> remove(String id, RemovalStrategy strategy) {
+        return removeAndReplaceParents(id, strategy, null, true);
+    }
+
+    private Set<ProtectedRegion> removeAndReplaceParents(String id, RemovalStrategy strategy, @Nullable ProtectedRegion replacement, boolean rebuildIndex) {
         checkNotNull(id);
         checkNotNull(strategy);
 
@@ -161,7 +172,12 @@ public class HashMapIndex extends AbstractRegionIndex implements ConcurrentRegio
                                     it.remove();
                                     break;
                                 case UNSET_PARENT_IN_CHILDREN:
-                                    current.clearParent();
+                                    try {
+                                        current.setParent(replacement);
+                                    } catch (CircularInheritanceException e) {
+                                        WorldGuard.logger.log(Level.WARNING, "Failed to replace parent '" + parent.getId() + "' of child '" + current.getId() + "' with replacement '" + replacement.getId() + "'", e);
+                                        current.clearParent();
+                                    }
                             }
                         }
                     }
@@ -174,7 +190,9 @@ public class HashMapIndex extends AbstractRegionIndex implements ConcurrentRegio
 
             this.removed.addAll(removedSet);
 
-            rebuildIndex();
+            if (rebuildIndex) {
+                rebuildIndex();
+            }
         }
 
         return removedSet;

worldguard-core/src/main/java/com/sk89q/worldguard/protection/managers/migration/AbstractMigration.java

@@ -72,7 +72,7 @@ abstract class AbstractMigration implements Migration {
      * @param store the region store
      * @throws MigrationException on migration error
      */
-    protected abstract void migrate(RegionDatabase store)throws MigrationException;
+    protected abstract void migrate(RegionDatabase store) throws MigrationException;
 
     /**
      * Called after migration has successfully completed.

worldguard-core/src/main/java/com/sk89q/worldguard/protection/managers/migration/WorldHeightMigration.java

@@ -0,0 +1,114 @@
+/*
+ * 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.managers.migration;
+
+import com.sk89q.worldedit.world.World;
+import com.sk89q.worldguard.WorldGuard;
+import com.sk89q.worldguard.protection.flags.registry.FlagRegistry;
+import com.sk89q.worldguard.protection.managers.storage.RegionDatabase;
+import com.sk89q.worldguard.protection.managers.storage.RegionDriver;
+import com.sk89q.worldguard.protection.managers.storage.StorageException;
+import com.sk89q.worldguard.protection.regions.ProtectedRegion;
+
+import javax.annotation.Nullable;
+import java.lang.reflect.Field;
+import java.util.Set;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+public class WorldHeightMigration extends AbstractMigration {
+    private static final Logger log = Logger.getLogger(WorldHeightMigration.class.getCanonicalName());
+
+    private static final Field minField;
+    private static final Field maxField;
+    static {
+        try {
+            minField = ProtectedRegion.class.getDeclaredField("min");
+            minField.setAccessible(true);
+            maxField = ProtectedRegion.class.getDeclaredField("max");
+            maxField.setAccessible(true);
+        } catch (NoSuchFieldException e) {
+            throw new ExceptionInInitializerError(new MigrationException("Migrator broke.", e));
+        }
+    }
+
+    private final FlagRegistry flagRegistry;
+    private final World world;
+    private int changed = 0;
+
+    public WorldHeightMigration(RegionDriver driver, FlagRegistry flagRegistry, @Nullable World world) {
+        super(driver);
+        this.flagRegistry = flagRegistry;
+        this.world = world;
+    }
+
+    @Override
+    protected void migrate(RegionDatabase store) throws MigrationException {
+        if (world != null && !store.getName().equals(world.getName())) return;
+
+        log.log(Level.INFO, "Migrating regions in '" + store.getName() + "' to new height limits...");
+
+        Set<ProtectedRegion> regions;
+
+        try {
+            regions = store.loadAll(flagRegistry);
+        } catch (StorageException e) {
+            throw new MigrationException("Failed to load region data for the world '" + store.getName() + "'", e);
+        }
+
+        int min = -64;
+        int max = 319;
+        World world = WorldGuard.getInstance().getPlatform().getMatcher().getWorldByName(store.getName());
+        if (world != null) {
+            min = world.getMinY();
+            max = world.getMaxY();
+            // in theory someone could run a data pack that keeps their world height
+            // at the old defaults...? either way if this is the case there are no changes to make.
+            if (min == 0 && max == 255) return;
+        }
+        for (ProtectedRegion region : regions) {
+            if (region.getMinimumPoint().getBlockY() <= 0
+                    && region.getMaximumPoint().getBlockY() >= 255) {
+                expand(region, min, max);
+                changed++;
+            }
+        }
+        try {
+            store.saveAll(regions);
+        } catch (StorageException e) {
+            throw new MigrationException("Failed to save region data after migration of the world '" + store.getName() + "'", e);
+        }
+    }
+
+    private static void expand(ProtectedRegion region, int min, int max) throws MigrationException {
+        try {
+            minField.set(region, region.getMinimumPoint().withY(min));
+            maxField.set(region, region.getMaximumPoint().withY(max));
+            region.setDirty(true);
+        } catch (IllegalAccessException e) {
+            throw new MigrationException("Migrator broke.", e);
+        }
+    }
+
+    @Override
+    protected void postMigration() {
+        log.log(Level.INFO, "A total of " + changed + " top-to-bottom regions were vertically expanded.");
+    }
+}

worldguard-core/src/main/java/com/sk89q/worldguard/protection/regions/QueryCache.java

@@ -24,7 +24,9 @@ import com.sk89q.worldedit.world.World;
 import com.sk89q.worldguard.protection.ApplicableRegionSet;
 import com.sk89q.worldguard.protection.RegionResultSet;
 import com.sk89q.worldguard.protection.managers.RegionManager;
+import com.sk89q.worldguard.protection.regions.RegionQuery.QueryOption;
 
+import java.util.Map;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.ConcurrentMap;
 
@@ -38,7 +40,7 @@ import static com.google.common.base.Preconditions.checkNotNull;
  */
 public class QueryCache {
 
-    private final ConcurrentMap<CacheKey, ApplicableRegionSet> cache = new ConcurrentHashMap<>(16, 0.75f, 2);
+    private final ConcurrentMap<CacheKey, Map<QueryOption, ApplicableRegionSet>> cache = new ConcurrentHashMap<>(16, 0.75f, 2);
 
     /**
      * Get from the cache a {@code ApplicableRegionSet} if an entry exists;
@@ -46,20 +48,16 @@ public class QueryCache {
      *
      * @param manager the region manager
      * @param location the location
+     * @param option the option
      * @return a result
      */
-    public ApplicableRegionSet queryContains(RegionManager manager, Location location) {
+    public ApplicableRegionSet queryContains(RegionManager manager, Location location, QueryOption option) {
         checkNotNull(manager);
         checkNotNull(location);
+        checkNotNull(option);
 
         CacheKey key = new CacheKey(location);
-        ApplicableRegionSet result = cache.get(key);
-        if (result == null) {
-            result = manager.getApplicableRegions(location.toVector().toBlockPoint());
-            cache.put(key, result);
-        }
-
-        return result;
+        return cache.compute(key, (k, v) -> option.createCache(manager, location, v)).get(option);
     }
 
     /**

worldguard-core/src/main/java/com/sk89q/worldguard/protection/regions/RegionQuery.java

@@ -21,6 +21,7 @@ package com.sk89q.worldguard.protection.regions;
 
 import static com.google.common.base.Preconditions.checkNotNull;
 
+import com.google.common.collect.ImmutableList;
 import com.sk89q.worldedit.util.Location;
 import com.sk89q.worldedit.world.World;
 import com.sk89q.worldguard.LocalPlayer;
@@ -39,8 +40,16 @@ 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;
+import com.sk89q.worldguard.protection.managers.index.RegionIndex;
+import com.sk89q.worldguard.protection.util.NormativeOrders;
+import com.sk89q.worldguard.protection.util.RegionCollectionConsumer;
 
 import java.util.Collection;
+import java.util.EnumMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
 
 import javax.annotation.Nullable;
 
@@ -74,17 +83,37 @@ public class RegionQuery {
     /**
      * Query for regions containing the given location.
      *
-     * <p>An instance of {@link RegionResultSet} will always be returned,
+     * <p>{@link QueryOption#COMPUTE_PARENTS} is used.</p>
+     *
+     * <p>An instance of {@link ApplicableRegionSet} will always be returned,
      * even if regions are disabled or region data failed to load. An
-     * appropriate "virtual" set will be returned in such a case
-     * (for example, if regions are disabled, the returned set
-     * would permit all activities).</p>
+     * appropriate "virtual" set will be returned in such a case (for example,
+     * if regions are disabled, the returned set would permit all
+     * activities).</p>
      *
      * @param location the location
      * @return a region set
      */
     public ApplicableRegionSet getApplicableRegions(Location location) {
+        return getApplicableRegions(location, QueryOption.COMPUTE_PARENTS);
+    }
+
+    /**
+     * Query for regions containing the given location.
+     *
+     * <p>An instance of {@link ApplicableRegionSet} will always be returned,
+     * even if regions are disabled or region data failed to load. An
+     * appropriate "virtual" set will be returned in such a case (for example,
+     * if regions are disabled, the returned set would permit all
+     * activities).</p>
+     *
+     * @param location the location
+     * @param option the option
+     * @return a region set
+     */
+    public ApplicableRegionSet getApplicableRegions(Location location, QueryOption option) {
         checkNotNull(location);
+        checkNotNull(option);
 
         World world = (World) location.getExtent();
         WorldConfiguration worldConfig = config.get(world);
@@ -95,7 +124,7 @@ public class RegionQuery {
 
         RegionManager manager = WorldGuard.getInstance().getPlatform().getRegionContainer().get((World) location.getExtent());
         if (manager != null) {
-            return cache.queryContains(manager, location);
+            return cache.queryContains(manager, location, option);
         } else {
             return FailedLoadRegionSet.getInstance();
         }
@@ -465,4 +494,150 @@ public class RegionQuery {
         return getApplicableRegions(location).queryAllValues(associable, flag);
     }
 
+    /**
+     * Options for constructing a region set via
+     * {@link #getApplicableRegions(Location, QueryOption)} for example.
+     */
+    public enum QueryOption {
+        /**
+         * Constructs a region set that does not include parent regions and
+         * may be left unsorted (but a cached, sorted set of the same regions
+         * may be returned).
+         */
+        NONE(false) {
+            @Override
+            public List<ProtectedRegion> constructResult(Set<ProtectedRegion> applicable) {
+                return ImmutableList.copyOf(applicable);
+            }
+
+            @Override
+            Map<QueryOption, ApplicableRegionSet> createCache(RegionManager manager, Location location, Map<QueryOption, ApplicableRegionSet> cache) {
+                if (cache == null) {
+                    cache = new EnumMap<>(QueryOption.class);
+                    cache.put(QueryOption.NONE, manager.getApplicableRegions(location.toVector().toBlockPoint(), QueryOption.NONE));
+                }
+
+                // If c != null, we can assume that Option.NONE is present.
+                return cache;
+            }
+        },
+
+        /**
+         * Constructs a region set that does not include parent regions and is
+         * sorted by {@link NormativeOrders}.
+         */
+        SORT(false) {
+            @Override
+            Map<QueryOption, ApplicableRegionSet> createCache(RegionManager manager, Location location, Map<QueryOption, ApplicableRegionSet> cache) {
+                if (cache == null) {
+                    Map<QueryOption, ApplicableRegionSet> newCache = new EnumMap<>(QueryOption.class);
+                    ApplicableRegionSet result = manager.getApplicableRegions(location.toVector().toBlockPoint(), QueryOption.SORT);
+                    newCache.put(QueryOption.NONE, result);
+                    newCache.put(QueryOption.SORT, result);
+                    return newCache;
+                } else {
+                    // If c != null, we can assume that Option.NONE is present.
+                    cache.computeIfAbsent(QueryOption.SORT, k -> new RegionResultSet(cache.get(QueryOption.NONE).getRegions(), manager.getRegion("__global__")));
+                    return cache;
+                }
+            }
+        },
+
+        /**
+         * Constructs a region set that includes parent regions and is sorted by
+         * {@link NormativeOrders}.
+         */
+        COMPUTE_PARENTS(true) {
+            @Override
+            Map<QueryOption, ApplicableRegionSet> createCache(RegionManager manager, Location location, Map<QueryOption, ApplicableRegionSet> cache) {
+                if (cache == null) {
+                    Map<QueryOption, ApplicableRegionSet> newCache = new EnumMap<>(QueryOption.class);
+                    ApplicableRegionSet noParResult = manager.getApplicableRegions(location.toVector().toBlockPoint(), QueryOption.NONE);
+                    Set<ProtectedRegion> noParRegions = noParResult.getRegions();
+                    Set<ProtectedRegion> regions = new HashSet<>();
+                    noParRegions.forEach(new RegionCollectionConsumer(regions, true)::apply);
+                    ApplicableRegionSet result = new RegionResultSet(regions, manager.getRegion("__global__"));
+
+                    if (regions.size() == noParRegions.size()) {
+                        newCache.put(QueryOption.NONE, result);
+                        newCache.put(QueryOption.SORT, result);
+                    } else {
+                        newCache.put(QueryOption.NONE, noParResult);
+                    }
+
+                    newCache.put(QueryOption.COMPUTE_PARENTS, result);
+                    return newCache;
+                }
+
+                cache.computeIfAbsent(QueryOption.COMPUTE_PARENTS, k -> {
+                    Set<ProtectedRegion> regions = new HashSet<>();
+                    ApplicableRegionSet result = cache.get(QueryOption.SORT);
+                    boolean sorted = true;
+
+                    if (result == null) {
+                        // If c != null, we can assume that Option.NONE is present.
+                        result = cache.get(QueryOption.NONE);
+                        sorted = false;
+                    }
+
+                    Set<ProtectedRegion> noParRegions = result.getRegions();
+                    noParRegions.forEach(new RegionCollectionConsumer(regions, true)::apply);
+
+                    if (sorted && regions.size() == noParRegions.size()) {
+                        return result;
+                    }
+
+                    result = new RegionResultSet(regions, manager.getRegion("__global__"));
+
+                    if (regions.size() == noParRegions.size()) {
+                        cache.put(QueryOption.SORT, result);
+                    }
+
+                    return result;
+                });
+                return cache;
+            }
+        };
+
+        private final boolean collectParents;
+
+        QueryOption(boolean collectParents) {
+            this.collectParents = collectParents;
+        }
+
+        /**
+         * Create a {@link RegionCollectionConsumer} with the given collection
+         * used for the {@link RegionIndex}. Internal API.
+         *
+         * @param collection the collection
+         * @return a region collection consumer
+         */
+        public RegionCollectionConsumer createIndexConsumer(Collection<? super ProtectedRegion> collection) {
+            return new RegionCollectionConsumer(collection, collectParents);
+        }
+
+        /**
+         * Convert the set of regions to a list. Sort and add parents if
+         * necessary. Internal API.
+         *
+         * @param applicable the set of regions
+         * @return a list of regions
+         */
+        public List<ProtectedRegion> constructResult(Set<ProtectedRegion> applicable) {
+            return NormativeOrders.fromSet(applicable);
+        }
+
+        /**
+         * Create (if null) or update the given cache map with at least an entry
+         * for this option if necessary and return it.
+         *
+         * @param manager the manager
+         * @param location the location
+         * @param cache the cache map
+         * @return a cache map
+         */
+        abstract Map<QueryOption, ApplicableRegionSet> createCache(RegionManager manager, Location location, Map<QueryOption, ApplicableRegionSet> cache);
+
+    }
+
 }

worldguard-core/src/main/java/com/sk89q/worldguard/protection/util/RegionCollectionConsumer.java

@@ -35,7 +35,7 @@ import static com.google.common.base.Preconditions.checkNotNull;
  */
 public class RegionCollectionConsumer implements Predicate<ProtectedRegion> {
 
-    private final Collection<ProtectedRegion> collection;
+    private final Collection<? super ProtectedRegion> collection;
     private final boolean addParents;
 
     /**
@@ -44,7 +44,7 @@ public class RegionCollectionConsumer implements Predicate<ProtectedRegion> {
      * @param collection the collection to add regions to
      * @param addParents true to also add the parents to the collection
      */
-    public RegionCollectionConsumer(Collection<ProtectedRegion> collection, boolean addParents) {
+    public RegionCollectionConsumer(Collection<? super ProtectedRegion> collection, boolean addParents) {
         checkNotNull(collection);
 
         this.collection = collection;

worldguard-core/src/main/java/com/sk89q/worldguard/session/AbstractSessionManager.java

@@ -44,10 +44,8 @@ import com.sk89q.worldguard.session.handler.WeatherLockFlag;
 import javax.annotation.Nullable;
 import java.lang.ref.WeakReference;
 import java.util.Arrays;
-import java.util.HashMap;
 import java.util.LinkedList;
 import java.util.List;
-import java.util.Map;
 import java.util.UUID;
 import java.util.concurrent.TimeUnit;
 import java.util.function.BiPredicate;
@@ -75,8 +73,6 @@ public abstract class AbstractSessionManager implements SessionManager {
                     createSession(key.playerRef.get())));
 
     private boolean hasCustom = false;
-    // <original handler, wrapped handler>
-    private Map<Handler.Factory<? extends Handler>, Handler.Factory<? extends Handler>> wrappedHandlers = new HashMap<>();
     private List<Handler.Factory<? extends Handler>> handlers = new LinkedList<>();
 
     private static final List<Handler.Factory<? extends Handler>> defaultHandlers = new LinkedList<>();
@@ -110,27 +106,20 @@ public abstract class AbstractSessionManager implements SessionManager {
         return hasCustom;
     }
 
-    protected Handler.Factory<? extends Handler> wrapForRegistration(Handler.Factory<? extends Handler> factory) {
-        return factory;
-    }
-
     @Override
     public boolean registerHandler(Handler.Factory<? extends Handler> factory, @Nullable Handler.Factory<? extends Handler> after) {
         if (factory == null) return false;
         WorldGuard.logger.log(Level.INFO, "Registering session handler "
                 + factory.getClass().getEnclosingClass().getName());
         hasCustom = true;
-        Handler.Factory<? extends Handler> wrappedFactory = wrapForRegistration(factory);
         if (after == null) {
-            handlers.add(wrappedFactory);
+            handlers.add(factory);
         } else {
-            Handler.Factory<? extends Handler> wrappedAfter = wrappedHandlers.get(after);
-            int index = handlers.indexOf(wrappedAfter != null ? wrappedAfter : after);
+            int index = handlers.indexOf(after);
             if (index == -1) return false;
 
-            handlers.add(index, factory); // shifts "after" right one, and everything after "after" right one
+            handlers.add(index + 1, factory); // shifts "after" right one, and everything after "after" right one
         }
-        wrappedHandlers.put(factory, wrappedFactory);
         return true;
     }
 
@@ -142,7 +131,6 @@ public abstract class AbstractSessionManager implements SessionManager {
         } else {
             WorldGuard.logger.log(Level.INFO, "Unregistering session handler "
                     + factory.getClass().getEnclosingClass().getName());
-            factory = wrappedHandlers.remove(factory);
         }
         return handlers.remove(factory);
     }

worldguard-core/src/main/java/com/sk89q/worldguard/session/Session.java

@@ -34,10 +34,10 @@ import com.sk89q.worldguard.protection.regions.RegionQuery;
 import com.sk89q.worldguard.session.handler.Handler;
 import com.sk89q.worldguard.util.Locations;
 
+import javax.annotation.Nullable;
 import java.util.HashMap;
 import java.util.Set;
 import java.util.concurrent.atomic.AtomicBoolean;
-import javax.annotation.Nullable;
 
 import static com.google.common.base.Preconditions.checkNotNull;
 
@@ -69,7 +69,7 @@ public class Session {
      * @param handler A new handler
      */
     public void register(Handler handler) {
-        handlers.put(handler.getWrappedHandler().getClass(), handler);
+        handlers.put(handler.getClass(), handler);
     }
 
     /**
@@ -91,7 +91,7 @@ public class Session {
     @Nullable
     @SuppressWarnings("unchecked")
     public <T extends Handler> T getHandler(Class<T> type) {
-        return (T) handlers.get(type).getWrappedHandler();
+        return (T) handlers.get(type);
     }
 
     /**
@@ -120,6 +120,21 @@ public class Session {
         }
     }
 
+    /**
+     * Uninitialize the session.
+     *
+     * @param player The player
+     */
+    public void uninitialize(LocalPlayer player) {
+        RegionQuery query = WorldGuard.getInstance().getPlatform().getRegionContainer().createQuery();
+        Location location = player.getLocation();
+        ApplicableRegionSet set = query.getApplicableRegions(location);
+
+        for (Handler handler : handlers.values()) {
+            handler.uninitialize(player, location, set);
+        }
+    }
+
     /**
      * Tick the session.
      *

worldguard-core/src/main/java/com/sk89q/worldguard/session/handler/FlagValueChangeHandler.java

@@ -45,6 +45,12 @@ public abstract class FlagValueChangeHandler<T> extends Handler {
         onInitialValue(player, set, lastValue);
     }
 
+    @Override
+    public final void uninitialize(LocalPlayer player, Location current, ApplicableRegionSet set) {
+        onClearValue(player, set);
+        lastValue = null;
+    }
+
     @Override
     public boolean onCrossBoundary(LocalPlayer player, Location from, Location to, ApplicableRegionSet toSet, Set<ProtectedRegion> entered, Set<ProtectedRegion> exited, MoveType moveType) {
         if (entered.isEmpty() && exited.isEmpty()
@@ -74,4 +80,10 @@ public abstract class FlagValueChangeHandler<T> extends Handler {
 
     protected abstract boolean onAbsentValue(LocalPlayer player, Location from, Location to, ApplicableRegionSet toSet, T lastValue, MoveType moveType);
 
+    protected void onClearValue(LocalPlayer player, ApplicableRegionSet set) {
+        if (lastValue != null) {
+            Location current = player.getLocation();
+            onAbsentValue(player, current, current, set, lastValue, MoveType.OTHER_NON_CANCELLABLE);
+        }
+    }
 }

worldguard-core/src/main/java/com/sk89q/worldguard/session/handler/Handler.java

@@ -74,6 +74,16 @@ public abstract class Handler {
     public void initialize(LocalPlayer player, Location current, ApplicableRegionSet set) {
     }
 
+    /**
+     * Called when the session should clear its caches.
+     *
+     * @param player The player
+     * @param current The player's current location
+     * @param set The regions for the current location
+     */
+    public void uninitialize(LocalPlayer player, Location current, ApplicableRegionSet set) {
+    }
+
     /**
      * Called when {@link Session#testMoveTo(LocalPlayer, Location, MoveType)} is called.
      *
@@ -138,11 +148,4 @@ public abstract class Handler {
         return null;
     }
 
-    /**
-     * Get the handler wrapped by this handler object, if applicable, or just return this if no handler is wrapped.
-     * @return any wrapped handler, or this handler itself
-     */
-    public Handler getWrappedHandler() {
-        return this;
-    }
 }

worldguard-core/src/main/java/com/sk89q/worldguard/session/handler/NotifyExitFlag.java

@@ -59,4 +59,8 @@ public class NotifyExitFlag extends FlagValueChangeHandler<Boolean> {
         WorldGuard.getInstance().getPlatform().broadcastNotification(new Notify(player.getName(), " left NOTIFY region").create());
         return true;
     }
+
+    @Override
+    protected void onClearValue(LocalPlayer player, ApplicableRegionSet set) {
+    }
 }

worldguard-core/src/test/java/com/sk89q/worldguard/TestPlayer.java

@@ -30,7 +30,6 @@ import com.sk89q.worldedit.util.Location;
 import com.sk89q.worldedit.util.formatting.text.Component;
 import com.sk89q.worldedit.world.World;
 import com.sk89q.worldedit.world.weather.WeatherType;
-import org.junit.Ignore;
 
 import java.util.HashSet;
 import java.util.Locale;
@@ -39,7 +38,7 @@ import java.util.UUID;
 
 import javax.annotation.Nullable;
 
-@Ignore
+
 public class TestPlayer extends AbstractPlayerActor implements LocalPlayer {
 
     private final UUID uuid = UUID.randomUUID();
@@ -250,6 +249,7 @@ public class TestPlayer extends AbstractPlayerActor implements LocalPlayer {
     }
 
     @Override
+    @Deprecated
     public void setPosition(Vector3 pos, float pitch, float yaw) {
 
     }

worldguard-core/src/test/java/com/sk89q/worldguard/domains/DefaultDomainTest.java

@@ -20,13 +20,14 @@
 package com.sk89q.worldguard.domains;
 
 import com.sk89q.worldguard.TestPlayer;
-import junit.framework.TestCase;
+import org.junit.jupiter.api.Test;
 
-import static org.hamcrest.Matchers.is;
-import static org.junit.Assert.assertThat;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
-public class DefaultDomainTest extends TestCase {
+public class DefaultDomainTest {
 
+    @Test
     public void testContains() throws Exception {
         TestPlayer player1 = new TestPlayer("test1");
         TestPlayer player2 = new TestPlayer("test2");
@@ -40,81 +41,76 @@ public class DefaultDomainTest extends TestCase {
 
         domain = new DefaultDomain();
         domain.addGroup("group1");
-        assertThat(domain.contains(player1), is(false));
-        assertThat(domain.contains(player2), is(true));
-        assertThat(domain.contains(player3), is(true));
+        assertFalse(domain.contains(player1));
+        assertTrue(domain.contains(player2));
+        assertTrue(domain.contains(player3));
 
         domain = new DefaultDomain();
         domain.addGroup("group1");
         domain.addGroup("group2");
-        assertThat(domain.contains(player1), is(false));
-        assertThat(domain.contains(player2), is(true));
-        assertThat(domain.contains(player3), is(true));
+        assertFalse(domain.contains(player1));
+        assertTrue(domain.contains(player2));
+        assertTrue(domain.contains(player3));
 
         domain = new DefaultDomain();
         domain.addGroup("group1");
         domain.addGroup("group3");
-        assertThat(domain.contains(player1), is(false));
-        assertThat(domain.contains(player2), is(true));
-        assertThat(domain.contains(player3), is(true));
+        assertFalse(domain.contains(player1));
+        assertTrue(domain.contains(player2));
+        assertTrue(domain.contains(player3));
 
         domain = new DefaultDomain();
         domain.addGroup("group3");
-        assertThat(domain.contains(player1), is(false));
-        assertThat(domain.contains(player2), is(false));
-        assertThat(domain.contains(player3), is(true));
+        assertFalse(domain.contains(player1));
+        assertFalse(domain.contains(player2));
+        assertTrue(domain.contains(player3));
 
         domain = new DefaultDomain();
         domain.addPlayer(player1.getName());
-        assertThat(domain.contains(player1), is(true));
-        assertThat(domain.contains(player2), is(false));
-        assertThat(domain.contains(player3), is(false));
+        assertTrue(domain.contains(player1));
+        assertFalse(domain.contains(player2));
+        assertFalse(domain.contains(player3));
 
         domain = new DefaultDomain();
         domain.addGroup("group3");
         domain.addPlayer(player1.getName());
-        assertThat(domain.contains(player1), is(true));
-        assertThat(domain.contains(player2), is(false));
-        assertThat(domain.contains(player3), is(true));
+        assertTrue(domain.contains(player1));
+        assertFalse(domain.contains(player2));
+        assertTrue(domain.contains(player3));
 
         domain = new DefaultDomain();
         domain.addGroup("group3");
         domain.addPlayer(player1.getUniqueId());
-        assertThat(domain.contains(player1), is(true));
-        assertThat(domain.contains(player2), is(false));
-        assertThat(domain.contains(player3), is(true));
+        assertTrue(domain.contains(player1));
+        assertFalse(domain.contains(player2));
+        assertTrue(domain.contains(player3));
 
         domain = new DefaultDomain();
         domain.addGroup("group3");
         domain.addPlayer(player1.getName());
         domain.addPlayer(player1.getUniqueId());
-        assertThat(domain.contains(player1), is(true));
-        assertThat(domain.contains(player2), is(false));
-        assertThat(domain.contains(player3), is(true));
+        assertTrue(domain.contains(player1));
+        assertFalse(domain.contains(player2));
+        assertTrue(domain.contains(player3));
 
         domain = new DefaultDomain();
         domain.addGroup("group3");
         domain.addPlayer(player1);
-        assertThat(domain.contains(player1), is(true));
-        assertThat(domain.contains(player2), is(false));
-        assertThat(domain.contains(player3), is(true));
+        assertTrue(domain.contains(player1));
+        assertFalse(domain.contains(player2));
+        assertTrue(domain.contains(player3));
 
         domain = new DefaultDomain();
         domain.addPlayer(player1);
-        assertThat(domain.contains(player1), is(true));
-        assertThat(domain.contains(player2), is(false));
-        assertThat(domain.contains(player3), is(false));
+        assertTrue(domain.contains(player1));
+        assertFalse(domain.contains(player2));
+        assertFalse(domain.contains(player3));
 
         domain = new DefaultDomain();
         domain.addPlayer(player2);
         domain.addPlayer(player3);
-        assertThat(domain.contains(player1), is(false));
-        assertThat(domain.contains(player2), is(true));
-        assertThat(domain.contains(player3), is(true));
+        assertFalse(domain.contains(player1));
+        assertTrue(domain.contains(player2));
+        assertTrue(domain.contains(player3));
     }
-
-    public void testSize() throws Exception {
-
-    }
-
 }

worldguard-core/src/test/java/com/sk89q/worldguard/protection/ApplicableRegionSetTest.java

@@ -25,13 +25,15 @@ import com.sk89q.worldguard.protection.flags.StateFlag;
 import com.sk89q.worldguard.protection.flags.StringFlag;
 import com.sk89q.worldguard.protection.regions.ProtectedRegion;
 import com.sk89q.worldguard.util.command.CommandFilter;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import java.util.HashSet;
 import java.util.Set;
 
-import static org.hamcrest.CoreMatchers.is;
-import static org.junit.Assert.*;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
 public class ApplicableRegionSetTest {
 
@@ -42,7 +44,7 @@ public class ApplicableRegionSetTest {
         LocalPlayer player = mock.createPlayer();
 
         ApplicableRegionSet set = mock.getApplicableSet();
-        assertThat(set.testState(player, Flags.BUILD), is(true));
+        assertTrue(set.testState(player, Flags.BUILD));
     }
 
     @Test
@@ -54,7 +56,7 @@ public class ApplicableRegionSetTest {
         ProtectedRegion global = mock.global();
 
         ApplicableRegionSet set = mock.getApplicableSet();
-        assertThat(set.testState(player, Flags.BUILD), is(true));
+        assertTrue(set.testState(player, Flags.BUILD));
     }
 
     @Test
@@ -68,8 +70,8 @@ public class ApplicableRegionSetTest {
         region.getMembers().addPlayer(member);
 
         ApplicableRegionSet set = mock.getApplicableSet();
-        assertThat(set.testState(member, Flags.BUILD), is(true));
-        assertThat(set.testState(nonMember, Flags.BUILD), is(false));
+        assertTrue(set.testState(member, Flags.BUILD));
+        assertFalse(set.testState(nonMember, Flags.BUILD));
     }
 
     @Test
@@ -80,15 +82,15 @@ public class ApplicableRegionSetTest {
 
         ApplicableRegionSet set = mock.getApplicableSet();
 
-        assertThat(set.testState(player, Flags.MOB_DAMAGE), is(true));
-        assertThat(set.testState(player, Flags.ENTRY), is(true));
-        assertThat(set.testState(player, Flags.EXIT), is(true));
-        assertThat(set.testState(player, Flags.LEAF_DECAY), is(true));
-        assertThat(set.testState(player, Flags.RECEIVE_CHAT), is(true));
-        assertThat(set.testState(player, Flags.SEND_CHAT), is(true));
-        assertThat(set.testState(player, Flags.INVINCIBILITY), is(false));
+        assertTrue(set.testState(player, Flags.MOB_DAMAGE));
+        assertTrue(set.testState(player, Flags.ENTRY));
+        assertTrue(set.testState(player, Flags.EXIT));
+        assertTrue(set.testState(player, Flags.LEAF_DECAY));
+        assertTrue(set.testState(player, Flags.RECEIVE_CHAT));
+        assertTrue(set.testState(player, Flags.SEND_CHAT));
+        assertFalse(set.testState(player, Flags.INVINCIBILITY));
 
-        assertThat(set.testState(player, Flags.BUILD), is(true));
+        assertTrue(set.testState(player, Flags.BUILD));
     }
 
     @Test
@@ -101,15 +103,15 @@ public class ApplicableRegionSetTest {
 
         ApplicableRegionSet set = mock.getApplicableSet();
 
-        assertThat(set.testState(player, Flags.MOB_DAMAGE), is(true));
-        assertThat(set.testState(player, Flags.ENTRY), is(true));
-        assertThat(set.testState(player, Flags.EXIT), is(true));
-        assertThat(set.testState(player, Flags.LEAF_DECAY), is(true));
-        assertThat(set.testState(player, Flags.RECEIVE_CHAT), is(true));
-        assertThat(set.testState(player, Flags.SEND_CHAT), is(true));
-        assertThat(set.testState(player, Flags.INVINCIBILITY), is(false));
+        assertTrue(set.testState(player, Flags.MOB_DAMAGE));
+        assertTrue(set.testState(player, Flags.ENTRY));
+        assertTrue(set.testState(player, Flags.EXIT));
+        assertTrue(set.testState(player, Flags.LEAF_DECAY));
+        assertTrue(set.testState(player, Flags.RECEIVE_CHAT));
+        assertTrue(set.testState(player, Flags.SEND_CHAT));
+        assertFalse(set.testState(player, Flags.INVINCIBILITY));
 
-        assertThat(set.testState(player, Flags.BUILD), is(true));
+        assertTrue(set.testState(player, Flags.BUILD));
     }
 
     @Test
@@ -124,25 +126,25 @@ public class ApplicableRegionSetTest {
 
         ApplicableRegionSet set = mock.getApplicableSet();
 
-        assertThat(set.testState(member, Flags.MOB_DAMAGE), is(true));
-        assertThat(set.testState(member, Flags.ENTRY), is(true));
-        assertThat(set.testState(member, Flags.EXIT), is(true));
-        assertThat(set.testState(member, Flags.LEAF_DECAY), is(true));
-        assertThat(set.testState(member, Flags.RECEIVE_CHAT), is(true));
-        assertThat(set.testState(member, Flags.SEND_CHAT), is(true));
-        assertThat(set.testState(member, Flags.INVINCIBILITY), is(false));
+        assertTrue(set.testState(member, Flags.MOB_DAMAGE));
+        assertTrue(set.testState(member, Flags.ENTRY));
+        assertTrue(set.testState(member, Flags.EXIT));
+        assertTrue(set.testState(member, Flags.LEAF_DECAY));
+        assertTrue(set.testState(member, Flags.RECEIVE_CHAT));
+        assertTrue(set.testState(member, Flags.SEND_CHAT));
+        assertFalse(set.testState(member, Flags.INVINCIBILITY));
 
-        assertThat(set.testState(member, Flags.BUILD), is(true));
+        assertTrue(set.testState(member, Flags.BUILD));
 
-        assertThat(set.testState(nonMember, Flags.MOB_DAMAGE), is(true));
-        assertThat(set.testState(nonMember, Flags.ENTRY), is(true));
-        assertThat(set.testState(nonMember, Flags.EXIT), is(true));
-        assertThat(set.testState(nonMember, Flags.LEAF_DECAY), is(true));
-        assertThat(set.testState(nonMember, Flags.RECEIVE_CHAT), is(true));
-        assertThat(set.testState(nonMember, Flags.SEND_CHAT), is(true));
-        assertThat(set.testState(nonMember, Flags.INVINCIBILITY), is(false));
+        assertTrue(set.testState(nonMember, Flags.MOB_DAMAGE));
+        assertTrue(set.testState(nonMember, Flags.ENTRY));
+        assertTrue(set.testState(nonMember, Flags.EXIT));
+        assertTrue(set.testState(nonMember, Flags.LEAF_DECAY));
+        assertTrue(set.testState(nonMember, Flags.RECEIVE_CHAT));
+        assertTrue(set.testState(nonMember, Flags.SEND_CHAT));
+        assertFalse(set.testState(nonMember, Flags.INVINCIBILITY));
 
-        assertThat(set.testState(nonMember, Flags.BUILD), is(false));
+        assertFalse(set.testState(nonMember, Flags.BUILD));
     }
 
     @Test
@@ -623,19 +625,19 @@ public class ApplicableRegionSetTest {
         test = new CommandFilter(
                 set.queryValue(nonMember, Flags.ALLOWED_CMDS),
                 set.queryValue(nonMember, Flags.BLOCKED_CMDS));
-        assertThat(test.apply("/permit"), is(true));
-        assertThat(test.apply("/strange"), is(true));
-        assertThat(test.apply("/other"), is(false));
-        assertThat(test.apply("/deny"), is(false));
+        assertTrue(test.apply("/permit"));
+        assertTrue(test.apply("/strange"));
+        assertFalse(test.apply("/other"));
+        assertFalse(test.apply("/deny"));
 
         set = mock.getApplicableSetInWilderness();
         test = new CommandFilter(
                 set.queryValue(nonMember, Flags.ALLOWED_CMDS),
                 set.queryValue(nonMember, Flags.BLOCKED_CMDS));
-        assertThat(test.apply("/permit"), is(true));
-        assertThat(test.apply("/strange"), is(false));
-        assertThat(test.apply("/other"), is(true));
-        assertThat(test.apply("/deny"), is(false));
+        assertTrue(test.apply("/permit"));
+        assertFalse(test.apply("/strange"));
+        assertTrue(test.apply("/other"));
+        assertFalse(test.apply("/deny"));
     }
 
     @Test

worldguard-core/src/test/java/com/sk89q/worldguard/protection/FlagValueCalculatorMapFlagTest.java

@@ -24,13 +24,12 @@ import com.sk89q.worldguard.protection.flags.MapFlag;
 import com.sk89q.worldguard.protection.flags.StateFlag;
 import com.sk89q.worldguard.protection.flags.StringFlag;
 import com.sk89q.worldguard.protection.regions.ProtectedRegion;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import java.util.HashMap;
 import java.util.Map;
 
-import static org.hamcrest.MatcherAssert.assertThat;
-import static org.hamcrest.Matchers.equalTo;
+import static org.junit.jupiter.api.Assertions.assertEquals;
 
 @SuppressWarnings({"UnusedDeclaration"})
 public class FlagValueCalculatorMapFlagTest {
@@ -48,18 +47,18 @@ public class FlagValueCalculatorMapFlagTest {
         global.setFlag(mapFlag, map);
 
         ApplicableRegionSet applicableSet = mock.getApplicableSet();
-        assertThat(applicableSet.queryMapValue(null, mapFlag, "allow", Flags.BUILD),
-                equalTo(StateFlag.State.ALLOW));
-        assertThat(applicableSet.queryMapValue(null, mapFlag, "deny", Flags.BUILD),
-                equalTo(StateFlag.State.DENY));
-        assertThat(applicableSet.queryMapValue(null, mapFlag, "undefined", Flags.BUILD),
-                equalTo(StateFlag.State.DENY));
-        assertThat(applicableSet.queryMapValue(null, mapFlag, "allow", null),
-                equalTo(StateFlag.State.ALLOW));
-        assertThat(applicableSet.queryMapValue(null, mapFlag, "deny", null),
-                equalTo(StateFlag.State.DENY));
-        assertThat(applicableSet.queryMapValue(null, mapFlag, "undefined", null),
-                equalTo(StateFlag.State.ALLOW));
+        assertEquals(applicableSet.queryMapValue(null, mapFlag, "allow", Flags.BUILD),
+                StateFlag.State.ALLOW);
+        assertEquals(applicableSet.queryMapValue(null, mapFlag, "deny", Flags.BUILD),
+                StateFlag.State.DENY);
+        assertEquals(applicableSet.queryMapValue(null, mapFlag, "undefined", Flags.BUILD),
+                StateFlag.State.DENY);
+        assertEquals(applicableSet.queryMapValue(null, mapFlag, "allow", null),
+                StateFlag.State.ALLOW);
+        assertEquals(applicableSet.queryMapValue(null, mapFlag, "deny", null),
+                StateFlag.State.DENY);
+        assertEquals(applicableSet.queryMapValue(null, mapFlag, "undefined", null),
+                StateFlag.State.ALLOW);
     }
 
     @Test
@@ -86,12 +85,12 @@ public class FlagValueCalculatorMapFlagTest {
         region2.setFlag(mapFlag, map2);
 
         ApplicableRegionSet applicableSet = mock.getApplicableSet();
-        assertThat(applicableSet.queryMapValue(null, mapFlag, "should-deny", null),
-                equalTo(StateFlag.State.DENY));
-        assertThat(applicableSet.queryMapValue(null, mapFlag, "should-allow", null),
-                equalTo(StateFlag.State.ALLOW));
-        assertThat(applicableSet.queryMapValue(null, mapFlag, "should-allow2", null),
-                equalTo(StateFlag.State.ALLOW));
+        assertEquals(applicableSet.queryMapValue(null, mapFlag, "should-deny", null),
+                StateFlag.State.DENY);
+        assertEquals(applicableSet.queryMapValue(null, mapFlag, "should-allow", null),
+                StateFlag.State.ALLOW);
+        assertEquals(applicableSet.queryMapValue(null, mapFlag, "should-allow2", null),
+                StateFlag.State.ALLOW);
     }
 
 
@@ -116,9 +115,9 @@ public class FlagValueCalculatorMapFlagTest {
         child.setFlag(mapFlag, childMap);
 
         ApplicableRegionSet applicableSet = mock.getApplicableSet();
-        assertThat(applicableSet.queryMapValue(null, mapFlag, "useChildValue", null),
-                equalTo(StateFlag.State.DENY));
-        assertThat(applicableSet.queryMapValue(null, mapFlag, "useParentValue", null),
-                equalTo(StateFlag.State.ALLOW));
+        assertEquals(applicableSet.queryMapValue(null, mapFlag, "useChildValue", null),
+                StateFlag.State.DENY);
+        assertEquals(applicableSet.queryMapValue(null, mapFlag, "useParentValue", null),
+                StateFlag.State.ALLOW);
     }
 }

worldguard-core/src/test/java/com/sk89q/worldguard/protection/FlagValueCalculatorTest.java

@@ -28,12 +28,14 @@ import com.sk89q.worldguard.protection.flags.StateFlag.State;
 import com.sk89q.worldguard.protection.flags.StringFlag;
 import com.sk89q.worldguard.protection.regions.ProtectedRegion;
 import org.hamcrest.Matchers;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
+
+import java.util.List;
+import java.util.Set;
 
 import static com.google.common.collect.ImmutableSet.copyOf;
 import static com.google.common.collect.ImmutableSet.of;
-import static org.hamcrest.MatcherAssert.assertThat;
-import static org.hamcrest.Matchers.*;
+import static org.junit.jupiter.api.Assertions.*;
 
 @SuppressWarnings({"UnusedAssignment", "UnusedDeclaration"})
 public class FlagValueCalculatorTest {
@@ -45,7 +47,7 @@ public class FlagValueCalculatorTest {
         LocalPlayer player = mock.createPlayer();
 
         FlagValueCalculator result = mock.getFlagCalculator();
-        assertThat(result.getMembership(player), is(Result.NO_REGIONS));
+        assertEquals(result.getMembership(player), Result.NO_REGIONS);
     }
 
     @Test
@@ -57,7 +59,7 @@ public class FlagValueCalculatorTest {
         ProtectedRegion global = mock.global();
 
         FlagValueCalculator result = mock.getFlagCalculator();
-        assertThat(result.getMembership(player), is(Result.NO_REGIONS));
+        assertEquals(result.getMembership(player), Result.NO_REGIONS);
     }
 
     @Test
@@ -69,7 +71,7 @@ public class FlagValueCalculatorTest {
         LocalPlayer player = mock.createPlayer();
 
         FlagValueCalculator result = mock.getFlagCalculator();
-        assertThat(result.getMembership(player), is(Result.NO_REGIONS));
+        assertEquals(result.getMembership(player), Result.NO_REGIONS);
     }
 
     @Test
@@ -83,7 +85,7 @@ public class FlagValueCalculatorTest {
         LocalPlayer player = mock.createPlayer();
 
         FlagValueCalculator result = mock.getFlagCalculator();
-        assertThat(result.getMembership(player), is(Result.FAIL));
+        assertEquals(result.getMembership(player), Result.FAIL);
     }
 
     @Test
@@ -99,7 +101,7 @@ public class FlagValueCalculatorTest {
         LocalPlayer player = mock.createPlayer();
 
         FlagValueCalculator result = mock.getFlagCalculator();
-        assertThat(result.getMembership(player), is(Result.NO_REGIONS));
+        assertEquals(result.getMembership(player), Result.NO_REGIONS);
     }
 
     @Test
@@ -114,7 +116,7 @@ public class FlagValueCalculatorTest {
         LocalPlayer player = mock.createPlayer();
 
         FlagValueCalculator result = mock.getFlagCalculator();
-        assertThat(result.getMembership(player), is(Result.FAIL));
+        assertEquals(result.getMembership(player), Result.FAIL);
     }
 
     @Test
@@ -130,7 +132,7 @@ public class FlagValueCalculatorTest {
         region.getMembers().addPlayer(player);
 
         FlagValueCalculator result = mock.getFlagCalculator();
-        assertThat(result.getMembership(player), is(Result.SUCCESS));
+        assertEquals(result.getMembership(player), Result.SUCCESS);
     }
 
     @Test
@@ -148,13 +150,13 @@ public class FlagValueCalculatorTest {
         region = mock.add(0);
 
         FlagValueCalculator result = mock.getFlagCalculator();
-        assertThat(result.getMembership(player), is(Result.FAIL));
+        assertEquals(result.getMembership(player), Result.FAIL);
 
         // Add another player (should still fail)
         region.getMembers().addPlayer(mock.createPlayer());
 
         result = mock.getFlagCalculator();
-        assertThat(result.getMembership(player), is(Result.FAIL));
+        assertEquals(result.getMembership(player), Result.FAIL);
     }
 
     @Test
@@ -172,7 +174,7 @@ public class FlagValueCalculatorTest {
         region = mock.add(10);
 
         FlagValueCalculator result = mock.getFlagCalculator();
-        assertThat(result.getMembership(player), is(Result.FAIL));
+        assertEquals(result.getMembership(player), Result.FAIL);
     }
 
     @Test
@@ -190,7 +192,7 @@ public class FlagValueCalculatorTest {
         region = mock.add(0);
 
         FlagValueCalculator result = mock.getFlagCalculator();
-        assertThat(result.getMembership(player), is(Result.SUCCESS));
+        assertEquals(result.getMembership(player), Result.SUCCESS);
     }
 
     @Test
@@ -209,7 +211,7 @@ public class FlagValueCalculatorTest {
         region.getMembers().addPlayer(player);
 
         FlagValueCalculator result = mock.getFlagCalculator();
-        assertThat(result.getMembership(player), is(Result.SUCCESS));
+        assertEquals(result.getMembership(player), Result.SUCCESS);
     }
 
     @Test
@@ -228,7 +230,7 @@ public class FlagValueCalculatorTest {
         parent.getMembers().addPlayer(player);
 
         FlagValueCalculator result = mock.getFlagCalculator();
-        assertThat(result.getMembership(player), is(Result.SUCCESS));
+        assertEquals(result.getMembership(player), Result.SUCCESS);
     }
 
     @Test
@@ -249,7 +251,7 @@ public class FlagValueCalculatorTest {
         parent.getMembers().addPlayer(player);
 
         FlagValueCalculator result = mock.getFlagCalculator();
-        assertThat(result.getMembership(player), is(Result.FAIL));
+        assertEquals(result.getMembership(player), Result.FAIL);
     }
 
     @Test
@@ -271,7 +273,7 @@ public class FlagValueCalculatorTest {
         parent.getMembers().addPlayer(player);
 
         FlagValueCalculator result = mock.getFlagCalculator();
-        assertThat(result.getMembership(player), is(Result.SUCCESS));
+        assertEquals(result.getMembership(player), Result.SUCCESS);
     }
 
     // ========================================================================
@@ -285,8 +287,8 @@ public class FlagValueCalculatorTest {
         StateFlag flag2 = new StateFlag("test2", true);
 
         FlagValueCalculator result = mock.getFlagCalculator();
-        assertThat(result.queryState(null, flag1), is((State) null));
-        assertThat(result.queryState(null, flag2), is(State.ALLOW));
+        assertNull(result.queryState(null, flag1));
+        assertEquals(result.queryState(null, flag2), State.ALLOW);
     }
 
     // ========================================================================
@@ -303,8 +305,8 @@ public class FlagValueCalculatorTest {
         region.setFlag(flag2, State.DENY);
 
         FlagValueCalculator result = mock.getFlagCalculator();
-        assertThat(result.queryValue(null, flag1), is((State) null));
-        assertThat(result.queryValue(null, flag2), is(State.DENY));
+        assertNull(result.queryValue(null, flag1));
+        assertEquals(result.queryValue(null, flag2), State.DENY);
     }
 
     @Test
@@ -321,8 +323,8 @@ public class FlagValueCalculatorTest {
         region.setFlag(flag2, State.ALLOW);
 
         FlagValueCalculator result = mock.getFlagCalculator();
-        assertThat(result.queryValue(null, flag1), is((State) null));
-        assertThat(result.queryValue(null, flag2), is(State.DENY));
+        assertNull(result.queryValue(null, flag1));
+        assertEquals(result.queryValue(null, flag2), State.DENY);
     }
 
     @Test
@@ -338,8 +340,8 @@ public class FlagValueCalculatorTest {
         region.setFlag(flag2, State.ALLOW);
 
         FlagValueCalculator result = mock.getFlagCalculator();
-        assertThat(result.queryValue(null, flag1), is((State) null));
-        assertThat(result.queryValue(null, flag2), is(State.ALLOW));
+        assertNull(result.queryValue(null, flag1));
+        assertEquals(result.queryValue(null, flag2), State.ALLOW);
     }
 
     @Test
@@ -358,9 +360,9 @@ public class FlagValueCalculatorTest {
         region.setFlag(flag2, State.DENY);
 
         FlagValueCalculator result = mock.getFlagCalculator();
-        assertThat(result.queryValue(null, flag1), is(State.DENY));
-        assertThat(result.queryValue(null, flag2), is(State.DENY));
-        assertThat(result.queryValue(null, flag3), is((State) null));
+        assertEquals(result.queryValue(null, flag1), State.DENY);
+        assertEquals(result.queryValue(null, flag2), State.DENY);
+        assertNull(result.queryValue(null, flag3));
     }
 
     @Test
@@ -381,8 +383,8 @@ public class FlagValueCalculatorTest {
         region.setParent(parent);
 
         FlagValueCalculator result = mock.getFlagCalculator();
-        assertThat(result.queryValue(nonMember, flag1), is(State.DENY));
-        assertThat(result.queryValue(member, flag1), is((State) null));
+        assertEquals(result.queryValue(nonMember, flag1), State.DENY);
+        assertNull(result.queryValue(member, flag1));
     }
 
     @Test
@@ -405,9 +407,9 @@ public class FlagValueCalculatorTest {
         region.setParent(parent);
 
         FlagValueCalculator result = mock.getFlagCalculator();
-        assertThat(result.queryValue(nonMember, flag1), is(State.DENY));
-        assertThat(result.queryValue(memberOne, flag1), is((State) null));
-        assertThat(result.queryValue(memberTwo, flag1), is(State.DENY));
+        assertEquals(result.queryValue(nonMember, flag1), State.DENY);
+        assertNull(result.queryValue(memberOne, flag1));
+        assertEquals(result.queryValue(memberTwo, flag1), State.DENY);
     }
 
     @Test
@@ -427,8 +429,8 @@ public class FlagValueCalculatorTest {
         region.getMembers().addPlayer(member);
 
         FlagValueCalculator result = mock.getFlagCalculator();
-        assertThat(result.queryValue(nonMember, flag1), is(State.DENY));
-        assertThat(result.queryValue(member, flag1), is(State.DENY));
+        assertEquals(result.queryValue(nonMember, flag1), State.DENY);
+        assertEquals(result.queryValue(member, flag1), State.DENY);
     }
 
     @Test
@@ -450,8 +452,8 @@ public class FlagValueCalculatorTest {
         region.getMembers().addPlayer(member);
 
         FlagValueCalculator result = mock.getFlagCalculator();
-        assertThat(result.queryValue(nonMember, flag1), is(State.DENY));
-        assertThat(result.queryValue(member, flag1), is(State.ALLOW));
+        assertEquals(result.queryValue(nonMember, flag1), State.DENY);
+        assertEquals(result.queryValue(member, flag1), State.ALLOW);
     }
 
     @Test
@@ -469,9 +471,9 @@ public class FlagValueCalculatorTest {
         region.setFlag(stringFlag1, "test2");
 
         FlagValueCalculator result = mock.getFlagCalculator();
-        assertThat(result.queryValue(null, stringFlag1), isOneOf("test1", "test2"));
-        assertThat(result.queryValue(null, stringFlag2), is((String) null));
-        assertThat(result.queryValue(null, flag1), is((State) null));
+        assertTrue(List.of("test1", "test2").contains(result.queryValue(null, stringFlag1)));
+        assertNull(result.queryValue(null, stringFlag2));
+        assertNull(result.queryValue(null, flag1));
     }
 
     @Test
@@ -483,7 +485,7 @@ public class FlagValueCalculatorTest {
         ProtectedRegion global = mock.global();
 
         FlagValueCalculator result = mock.getFlagCalculator();
-        assertThat(result.queryValue(null, flag), is(State.ALLOW));
+        assertEquals(result.queryValue(null, flag), State.ALLOW);
     }
 
     @Test
@@ -496,7 +498,7 @@ public class FlagValueCalculatorTest {
         global.setFlag(flag, State.ALLOW);
 
         FlagValueCalculator result = mock.getFlagCalculator();
-        assertThat(result.queryValue(null, flag), is(State.ALLOW));
+        assertEquals(result.queryValue(null, flag), State.ALLOW);
     }
 
     @Test
@@ -509,7 +511,7 @@ public class FlagValueCalculatorTest {
         global.setFlag(flag, State.DENY);
 
         FlagValueCalculator result = mock.getFlagCalculator();
-        assertThat(result.queryValue(null, flag), is(State.DENY));
+        assertEquals(result.queryValue(null, flag), State.DENY);
     }
 
     @Test
@@ -521,7 +523,7 @@ public class FlagValueCalculatorTest {
         ProtectedRegion global = mock.global();
 
         FlagValueCalculator result = mock.getFlagCalculator();
-        assertThat(result.queryValue(null, flag), is((String) null));
+        assertNull(result.queryValue(null, flag));
     }
 
     @Test
@@ -534,7 +536,7 @@ public class FlagValueCalculatorTest {
         global.setFlag(flag, "hello");
 
         FlagValueCalculator result = mock.getFlagCalculator();
-        assertThat(result.queryValue(null, flag), is("hello"));
+        assertEquals(result.queryValue(null, flag), "hello");
     }
 
     @Test
@@ -549,7 +551,7 @@ public class FlagValueCalculatorTest {
         ProtectedRegion region = mock.add(0);
 
         FlagValueCalculator result = mock.getFlagCalculator();
-        assertThat(result.queryValue(null, flag), is("hello"));
+        assertEquals(result.queryValue(null, flag), "hello");
     }
 
     @Test
@@ -565,7 +567,7 @@ public class FlagValueCalculatorTest {
         region.setFlag(flag, "beep");
 
         FlagValueCalculator result = mock.getFlagCalculator();
-        assertThat(result.queryValue(null, flag), is("beep"));
+        assertEquals(result.queryValue(null, flag), "beep");
     }
 
     @Test
@@ -591,9 +593,9 @@ public class FlagValueCalculatorTest {
         region.getMembers().addPlayer(member);
 
         FlagValueCalculator result = mock.getFlagCalculator();
-        assertThat(result.queryValue(null, flag), is("ello there"));
-        assertThat(result.queryValue(nonMember, flag), is("ello there"));
-        assertThat(result.queryValue(member, flag), is("beep beep"));
+        assertEquals(result.queryValue(null, flag), "ello there");
+        assertEquals(result.queryValue(nonMember, flag), "ello there");
+        assertEquals(result.queryValue(member, flag), "beep beep");
     }
 
     @Test
@@ -603,7 +605,7 @@ public class FlagValueCalculatorTest {
         LocalPlayer nonMember = mock.createPlayer();
 
         FlagValueCalculator result = mock.getFlagCalculator();
-        assertThat(result.queryValue(nonMember, Flags.BUILD), is(State.ALLOW));
+        assertEquals(result.queryValue(nonMember, Flags.BUILD), State.ALLOW);
     }
 
     @Test
@@ -615,7 +617,7 @@ public class FlagValueCalculatorTest {
         ProtectedRegion global = mock.global();
 
         FlagValueCalculator result = mock.getFlagCalculator();
-        assertThat(result.queryValue(nonMember, Flags.BUILD), is(State.ALLOW));
+        assertEquals(result.queryValue(nonMember, Flags.BUILD), State.ALLOW);
     }
 
     @Test
@@ -628,7 +630,7 @@ public class FlagValueCalculatorTest {
         global.setFlag(Flags.BUILD, State.DENY);
 
         FlagValueCalculator result = mock.getFlagCalculator();
-        assertThat(result.queryValue(nonMember, Flags.BUILD), is(State.DENY));
+        assertEquals(result.queryValue(nonMember, Flags.BUILD), State.DENY);
     }
 
     @Test
@@ -641,7 +643,7 @@ public class FlagValueCalculatorTest {
         global.setFlag(Flags.BUILD, State.ALLOW);
 
         FlagValueCalculator result = mock.getFlagCalculator();
-        assertThat(result.queryValue(nonMember, Flags.BUILD), is(State.ALLOW));
+        assertEquals(result.queryValue(nonMember, Flags.BUILD), State.ALLOW);
     }
 
     @Test
@@ -655,8 +657,8 @@ public class FlagValueCalculatorTest {
         global.getMembers().addPlayer(member);
 
         FlagValueCalculator result = mock.getFlagCalculator();
-        assertThat(result.queryValue(member, Flags.BUILD), is(State.ALLOW));
-        assertThat(result.queryValue(nonMember, Flags.BUILD), is((State) null));
+        assertEquals(result.queryValue(member, Flags.BUILD), State.ALLOW);
+        assertNull(result.queryValue(nonMember, Flags.BUILD));
     }
 
     @Test
@@ -671,8 +673,8 @@ public class FlagValueCalculatorTest {
         global.setFlag(Flags.BUILD, State.DENY);
 
         FlagValueCalculator result = mock.getFlagCalculator();
-        assertThat(result.queryValue(member, Flags.BUILD), is(State.DENY));
-        assertThat(result.queryValue(nonMember, Flags.BUILD), is(State.DENY));
+        assertEquals(result.queryValue(member, Flags.BUILD), State.DENY);
+        assertEquals(result.queryValue(nonMember, Flags.BUILD), State.DENY);
     }
 
     @Test
@@ -689,8 +691,8 @@ public class FlagValueCalculatorTest {
         // Cannot set ALLOW on BUILD
 
         FlagValueCalculator result = mock.getFlagCalculator();
-        assertThat(result.queryValue(member, Flags.BUILD), is(State.ALLOW));
-        assertThat(result.queryValue(nonMember, Flags.BUILD), is((State) null));
+        assertEquals(result.queryValue(member, Flags.BUILD), State.ALLOW);
+        assertNull(result.queryValue(nonMember, Flags.BUILD));
     }
 
     @Test
@@ -704,8 +706,8 @@ public class FlagValueCalculatorTest {
         region.getMembers().addPlayer(member);
 
         FlagValueCalculator result = mock.getFlagCalculator();
-        assertThat(result.queryValue(nonMember, Flags.BUILD), is((State) null));
-        assertThat(result.queryValue(member, Flags.BUILD), is(State.ALLOW));
+        assertNull(result.queryValue(nonMember, Flags.BUILD)); 
+        assertEquals(result.queryValue(member, Flags.BUILD), State.ALLOW);
     }
 
     @Test
@@ -724,9 +726,9 @@ public class FlagValueCalculatorTest {
         region.getMembers().addPlayer(memberBoth);
 
         FlagValueCalculator result = mock.getFlagCalculator();
-        assertThat(result.queryValue(nonMember, Flags.BUILD), is((State) null));
-        assertThat(result.queryValue(memberOne, Flags.BUILD), is((State) null));
-        assertThat(result.queryValue(memberBoth, Flags.BUILD), is(State.ALLOW));
+        assertNull(result.queryValue(nonMember, Flags.BUILD));
+        assertNull(result.queryValue(memberOne, Flags.BUILD));
+        assertEquals(result.queryValue(memberBoth, Flags.BUILD), State.ALLOW);
     }
 
     @Test
@@ -746,9 +748,9 @@ public class FlagValueCalculatorTest {
         region.getMembers().addPlayer(memberBoth);
 
         FlagValueCalculator result = mock.getFlagCalculator();
-        assertThat(result.queryValue(nonMember, Flags.BUILD), is((State) null));
-        assertThat(result.queryValue(memberOne, Flags.BUILD), is(State.ALLOW));
-        assertThat(result.queryValue(memberBoth, Flags.BUILD), is(State.ALLOW));
+        assertNull(result.queryValue(nonMember, Flags.BUILD));
+        assertEquals(result.queryValue(memberOne, Flags.BUILD), State.ALLOW);
+        assertEquals(result.queryValue(memberBoth, Flags.BUILD), State.ALLOW);
     }
 
     @Test
@@ -768,9 +770,9 @@ public class FlagValueCalculatorTest {
         region.setParent(parent);
 
         FlagValueCalculator result = mock.getFlagCalculator();
-        assertThat(result.queryValue(nonMember, Flags.BUILD), is((State) null));
-        assertThat(result.queryValue(memberOne, Flags.BUILD), is(State.ALLOW));
-        assertThat(result.queryValue(memberBoth, Flags.BUILD), is(State.ALLOW));
+        assertNull(result.queryValue(nonMember, Flags.BUILD));
+        assertEquals(result.queryValue(memberOne, Flags.BUILD), State.ALLOW);
+        assertEquals(result.queryValue(memberBoth, Flags.BUILD), State.ALLOW);
     }
 
     @Test
@@ -790,9 +792,9 @@ public class FlagValueCalculatorTest {
         region.setParent(parent);
 
         FlagValueCalculator result = mock.getFlagCalculator();
-        assertThat(result.queryValue(nonMember, Flags.BUILD), is((State) null));
-        assertThat(result.queryValue(memberOne, Flags.BUILD), is(State.ALLOW));
-        assertThat(result.queryValue(memberBoth, Flags.BUILD), is(State.ALLOW));
+        assertNull(result.queryValue(nonMember, Flags.BUILD));
+        assertEquals(result.queryValue(memberOne, Flags.BUILD), State.ALLOW);
+        assertEquals(result.queryValue(memberBoth, Flags.BUILD), State.ALLOW);
     }
 
     @Test
@@ -814,9 +816,9 @@ public class FlagValueCalculatorTest {
         ProtectedRegion priority = mock.add(10);
 
         FlagValueCalculator result = mock.getFlagCalculator();
-        assertThat(result.queryValue(nonMember, Flags.BUILD), is((State) null));
-        assertThat(result.queryValue(memberOne, Flags.BUILD), is((State) null));
-        assertThat(result.queryValue(memberBoth, Flags.BUILD), is((State) null));
+        assertNull(result.queryValue(nonMember, Flags.BUILD));
+        assertNull(result.queryValue(memberOne, Flags.BUILD));
+        assertNull(result.queryValue(memberBoth, Flags.BUILD));
     }
 
     @Test
@@ -839,9 +841,9 @@ public class FlagValueCalculatorTest {
         priority.setFlag(Flags.PASSTHROUGH, State.ALLOW);
 
         FlagValueCalculator result = mock.getFlagCalculator();
-        assertThat(result.queryValue(nonMember, Flags.BUILD), is((State) null));
-        assertThat(result.queryValue(memberOne, Flags.BUILD), is(State.ALLOW));
-        assertThat(result.queryValue(memberBoth, Flags.BUILD), is(State.ALLOW));
+        assertNull(result.queryValue(nonMember, Flags.BUILD));
+        assertEquals(result.queryValue(memberOne, Flags.BUILD), State.ALLOW);
+        assertEquals(result.queryValue(memberBoth, Flags.BUILD), State.ALLOW);
     }
 
     @Test
@@ -862,9 +864,9 @@ public class FlagValueCalculatorTest {
         region.getMembers().addPlayer(memberBoth);
 
         FlagValueCalculator result = mock.getFlagCalculator();
-        assertThat(result.queryValue(nonMember, Flags.BUILD), is((State) null));
-        assertThat(result.queryValue(memberOne, Flags.BUILD), is((State) null));
-        assertThat(result.queryValue(memberBoth, Flags.BUILD), is(State.ALLOW));
+        assertNull(result.queryValue(nonMember, Flags.BUILD));
+        assertNull(result.queryValue(memberOne, Flags.BUILD));
+        assertEquals(result.queryValue(memberBoth, Flags.BUILD), State.ALLOW);
     }
 
     @Test
@@ -887,9 +889,9 @@ public class FlagValueCalculatorTest {
         region.setFlag(Flags.BUILD, State.ALLOW);
 
         FlagValueCalculator result = mock.getFlagCalculator();
-        assertThat(result.queryValue(nonMember, Flags.BUILD), is(State.ALLOW));
-        assertThat(result.queryValue(memberOne, Flags.BUILD), is(State.ALLOW));
-        assertThat(result.queryValue(memberBoth, Flags.BUILD), is(State.ALLOW));
+        assertEquals(result.queryValue(nonMember, Flags.BUILD), State.ALLOW);
+        assertEquals(result.queryValue(memberOne, Flags.BUILD), State.ALLOW);
+        assertEquals(result.queryValue(memberBoth, Flags.BUILD), State.ALLOW);
     }
 
     @Test
@@ -913,9 +915,9 @@ public class FlagValueCalculatorTest {
         region.setFlag(Flags.BUILD, State.ALLOW);
 
         FlagValueCalculator result = mock.getFlagCalculator();
-        assertThat(result.queryValue(nonMember, Flags.BUILD), is(State.DENY));
-        assertThat(result.queryValue(memberOne, Flags.BUILD), is(State.DENY));
-        assertThat(result.queryValue(memberBoth, Flags.BUILD), is(State.DENY));
+        assertEquals(result.queryValue(nonMember, Flags.BUILD), State.DENY);
+        assertEquals(result.queryValue(memberOne, Flags.BUILD), State.DENY);
+        assertEquals(result.queryValue(memberBoth, Flags.BUILD), State.DENY);
     }
 
     @Test
@@ -939,9 +941,9 @@ public class FlagValueCalculatorTest {
         // Disable setting ALLOW for safety reasons
 
         FlagValueCalculator result = mock.getFlagCalculator();
-        assertThat(result.queryValue(nonMember, Flags.BUILD), is((State) null));
-        assertThat(result.queryValue(memberOne, Flags.BUILD), is((State) null));
-        assertThat(result.queryValue(memberBoth, Flags.BUILD), is(State.ALLOW));
+        assertNull(result.queryValue(nonMember, Flags.BUILD));
+        assertNull(result.queryValue(memberOne, Flags.BUILD));
+        assertEquals(result.queryValue(memberBoth, Flags.BUILD), State.ALLOW);
     }
 
     @Test
@@ -964,10 +966,10 @@ public class FlagValueCalculatorTest {
         region.getMembers().addPlayer(memberBoth);
 
         FlagValueCalculator result = mock.getFlagCalculator();
-        assertThat(result.queryValue(globalMember, Flags.BUILD), is((State) null));
-        assertThat(result.queryValue(nonMember, Flags.BUILD), is((State) null));
-        assertThat(result.queryValue(memberOne, Flags.BUILD), is((State) null));
-        assertThat(result.queryValue(memberBoth, Flags.BUILD), is(State.ALLOW));
+        assertNull(result.queryValue(globalMember, Flags.BUILD));
+        assertNull(result.queryValue(nonMember, Flags.BUILD));
+        assertNull(result.queryValue(memberOne, Flags.BUILD));
+        assertEquals(result.queryValue(memberBoth, Flags.BUILD), State.ALLOW);
     }
 
     @Test
@@ -992,10 +994,10 @@ public class FlagValueCalculatorTest {
 
         FlagValueCalculator result = mock.getFlagCalculator();
         // Inconsistent due to legacy reasons
-        assertThat(result.queryValue(globalMember, Flags.BUILD), is((State) null));
-        assertThat(result.queryValue(nonMember, Flags.BUILD), is((State) null));
-        assertThat(result.queryValue(memberOne, Flags.BUILD), is((State) null));
-        assertThat(result.queryValue(memberBoth, Flags.BUILD), is(State.ALLOW));
+        assertNull(result.queryValue(globalMember, Flags.BUILD));
+        assertNull(result.queryValue(nonMember, Flags.BUILD));
+        assertNull(result.queryValue(memberOne, Flags.BUILD));
+        assertEquals(result.queryValue(memberBoth, Flags.BUILD), State.ALLOW);
     }
 
     @Test
@@ -1019,10 +1021,10 @@ public class FlagValueCalculatorTest {
         region.getMembers().addPlayer(memberBoth);
 
         FlagValueCalculator result = mock.getFlagCalculator();
-        assertThat(result.queryValue(globalMember, Flags.BUILD), is((State) null));
-        assertThat(result.queryValue(nonMember, Flags.BUILD), is((State) null));
-        assertThat(result.queryValue(memberOne, Flags.BUILD), is((State) null));
-        assertThat(result.queryValue(memberBoth, Flags.BUILD), is(State.ALLOW));
+        assertNull(result.queryValue(globalMember, Flags.BUILD));
+        assertNull(result.queryValue(nonMember, Flags.BUILD));
+        assertNull(result.queryValue(memberOne, Flags.BUILD));
+        assertEquals(result.queryValue(memberBoth, Flags.BUILD), State.ALLOW);
     }
 
     // ========================================================================
@@ -1046,8 +1048,8 @@ public class FlagValueCalculatorTest {
         region.setFlag(stringFlag1, "test2");
 
         FlagValueCalculator result = mock.getFlagCalculator();
-        assertThat(copyOf(result.queryAllValues(null, stringFlag1)), equalTo(of("test1", "test2")));
-        assertThat(result.queryAllValues(null, stringFlag2), is(Matchers.<String>empty()));
+        assertEquals(copyOf(result.queryAllValues(null, stringFlag1)), Set.of("test1", "test2"));
+        assertTrue(result.queryAllValues(null, stringFlag2).isEmpty());
     }
 
     @Test
@@ -1068,8 +1070,8 @@ public class FlagValueCalculatorTest {
         region.setFlag(stringFlag1, "test");
 
         FlagValueCalculator result = mock.getFlagCalculator();
-        assertThat(copyOf(result.queryAllValues(null, stringFlag1)), equalTo(of("test", "test")));
-        assertThat(result.queryAllValues(null, stringFlag2), is(Matchers.<String>empty()));
+        assertEquals(copyOf(result.queryAllValues(null, stringFlag1)), Set.of("test"));
+        assertTrue(result.queryAllValues(null, stringFlag2).isEmpty());
     }
 
     @Test
@@ -1090,8 +1092,8 @@ public class FlagValueCalculatorTest {
         region.setFlag(stringFlag1, "test2");
 
         FlagValueCalculator result = mock.getFlagCalculator();
-        assertThat(copyOf(result.queryAllValues(null, stringFlag1)), equalTo(of("test1")));
-        assertThat(result.queryAllValues(null, stringFlag2), is(Matchers.<String>empty()));
+        assertEquals(copyOf(result.queryAllValues(null, stringFlag1)), Set.of("test1"));
+        assertTrue(result.queryAllValues(null, stringFlag2).isEmpty());
     }
 
     @Test
@@ -1115,8 +1117,8 @@ public class FlagValueCalculatorTest {
         region.setFlag(stringFlag1, "test2");
 
         FlagValueCalculator result = mock.getFlagCalculator();
-        assertThat(copyOf(result.queryAllValues(null, stringFlag1)), equalTo(of("test1", "test3")));
-        assertThat(result.queryAllValues(null, stringFlag2), is(Matchers.<String>empty()));
+        assertEquals(copyOf(result.queryAllValues(null, stringFlag1)), Set.of("test1", "test3"));
+        assertTrue(result.queryAllValues(null, stringFlag2).isEmpty());
     }
 
     @Test
@@ -1141,8 +1143,8 @@ public class FlagValueCalculatorTest {
         region.setFlag(stringFlag1, "test2");
 
         FlagValueCalculator result = mock.getFlagCalculator();
-        assertThat(copyOf(result.queryAllValues(null, stringFlag1)), equalTo(of("test1")));
-        assertThat(result.queryAllValues(null, stringFlag2), is(Matchers.<String>empty()));
+        assertEquals(copyOf(result.queryAllValues(null, stringFlag1)), Set.of("test1"));
+        assertTrue(result.queryAllValues(null, stringFlag2).isEmpty());
     }
 
     @Test
@@ -1167,8 +1169,8 @@ public class FlagValueCalculatorTest {
         region.setFlag(stringFlag1, "test2");
 
         FlagValueCalculator result = mock.getFlagCalculator();
-        assertThat(copyOf(result.queryAllValues(null, stringFlag1)), equalTo(of("test3")));
-        assertThat(result.queryAllValues(null, stringFlag2), is(Matchers.<String>empty()));
+        assertEquals(copyOf(result.queryAllValues(null, stringFlag1)), Set.of("test3"));
+        assertTrue(result.queryAllValues(null, stringFlag2).isEmpty());
     }
 
     @Test
@@ -1193,8 +1195,8 @@ public class FlagValueCalculatorTest {
         region.setFlag(stringFlag1, "test2");
 
         FlagValueCalculator result = mock.getFlagCalculator();
-        assertThat(copyOf(result.queryAllValues(null, stringFlag1)), equalTo(of("test1")));
-        assertThat(result.queryAllValues(null, stringFlag2), is(Matchers.<String>empty()));
+        assertEquals(copyOf(result.queryAllValues(null, stringFlag1)), Set.of("test1"));
+        assertTrue(result.queryAllValues(null, stringFlag2).isEmpty());
     }
 
     @Test
@@ -1219,8 +1221,8 @@ public class FlagValueCalculatorTest {
         region.setFlag(stringFlag1, "test2");
 
         FlagValueCalculator result = mock.getFlagCalculator();
-        assertThat(copyOf(result.queryAllValues(null, stringFlag1)), equalTo(of("test2")));
-        assertThat(result.queryAllValues(null, stringFlag2), is(Matchers.<String>empty()));
+        assertEquals(copyOf(result.queryAllValues(null, stringFlag1)), Set.of("test2"));
+        assertTrue(result.queryAllValues(null, stringFlag2).isEmpty());
     }
 
     @Test
@@ -1248,8 +1250,8 @@ public class FlagValueCalculatorTest {
         region.setParent(parent2);
 
         FlagValueCalculator result = mock.getFlagCalculator();
-        assertThat(copyOf(result.queryAllValues(null, stringFlag1)), equalTo(of("test2", "test3")));
-        assertThat(result.queryAllValues(null, stringFlag2), is(Matchers.<String>empty()));
+        assertEquals(copyOf(result.queryAllValues(null, stringFlag1)), Set.of("test2", "test3"));
+        assertTrue(result.queryAllValues(null, stringFlag2).isEmpty());
     }
 
     @Test
@@ -1277,8 +1279,8 @@ public class FlagValueCalculatorTest {
         region = mock.add(30);
 
         FlagValueCalculator result = mock.getFlagCalculator();
-        assertThat(copyOf(result.queryAllValues(null, stringFlag1)), equalTo(of("test2")));
-        assertThat(result.queryAllValues(null, stringFlag2), is(Matchers.<String>empty()));
+        assertEquals(copyOf(result.queryAllValues(null, stringFlag1)), Set.of("test2"));
+        assertTrue(result.queryAllValues(null, stringFlag2).isEmpty());
     }
 
     @Test
@@ -1306,8 +1308,8 @@ public class FlagValueCalculatorTest {
         region = mock.add(30);
 
         FlagValueCalculator result = mock.getFlagCalculator();
-        assertThat(copyOf(result.queryAllValues(null, stringFlag1)), equalTo(of("test1")));
-        assertThat(result.queryAllValues(null, stringFlag2), is(Matchers.<String>empty()));
+        assertEquals(copyOf(result.queryAllValues(null, stringFlag1)), Set.of("test1"));
+        assertTrue(result.queryAllValues(null, stringFlag2).isEmpty());
     }
 
     // ========================================================================
@@ -1320,7 +1322,7 @@ public class FlagValueCalculatorTest {
         ProtectedRegion region = mock.add(30);
 
         FlagValueCalculator result = mock.getFlagCalculator();
-        assertThat(result.getPriority(region), is(30));
+        assertEquals(result.getPriority(region), 30);
     }
 
     @Test
@@ -1330,7 +1332,7 @@ public class FlagValueCalculatorTest {
         ProtectedRegion region = mock.global();
 
         FlagValueCalculator result = mock.getFlagCalculator();
-        assertThat(result.getPriority(region), is(Integer.MIN_VALUE));
+        assertEquals(result.getPriority(region), Integer.MIN_VALUE);
     }
 
     // ========================================================================
@@ -1352,8 +1354,8 @@ public class FlagValueCalculatorTest {
         region.setFlag(stringFlag1.getRegionGroupFlag(), RegionGroup.ALL);
 
         FlagValueCalculator result = mock.getFlagCalculator();
-        assertThat(result.getEffectiveFlag(region, stringFlag1, null), equalTo("test1"));
-        assertThat(result.getEffectiveFlag(region, stringFlag2, null), equalTo(null));
+        assertEquals(result.getEffectiveFlag(region, stringFlag1, null), "test1");
+        assertNull(result.getEffectiveFlag(region, stringFlag2, null));
     }
 
     @Test
@@ -1374,8 +1376,8 @@ public class FlagValueCalculatorTest {
         LocalPlayer player = mock.createPlayer();
 
         FlagValueCalculator result = mock.getFlagCalculator();
-        assertThat(result.getEffectiveFlag(region, stringFlag1, player), equalTo("test1"));
-        assertThat(result.getEffectiveFlag(region, stringFlag2, null), equalTo(null));
+        assertEquals(result.getEffectiveFlag(region, stringFlag1, player), "test1");
+        assertNull(result.getEffectiveFlag(region, stringFlag2, null));
     }
 
     @Test
@@ -1394,8 +1396,8 @@ public class FlagValueCalculatorTest {
         region.setFlag(stringFlag1.getRegionGroupFlag(), RegionGroup.ALL);
 
         FlagValueCalculator result = mock.getFlagCalculator();
-        assertThat(result.getEffectiveFlag(region, stringFlag1, null), equalTo("test1"));
-        assertThat(result.getEffectiveFlag(region, stringFlag2, null), equalTo(null));
+        assertEquals(result.getEffectiveFlag(region, stringFlag1, null), "test1");
+        assertNull(result.getEffectiveFlag(region, stringFlag2, null));
     }
 
     @Test
@@ -1416,8 +1418,8 @@ public class FlagValueCalculatorTest {
         LocalPlayer player = mock.createPlayer();
 
         FlagValueCalculator result = mock.getFlagCalculator();
-        assertThat(result.getEffectiveFlag(region, stringFlag1, player), equalTo("test1"));
-        assertThat(result.getEffectiveFlag(region, stringFlag2, null), equalTo(null));
+        assertEquals(result.getEffectiveFlag(region, stringFlag1, player), "test1");
+        assertNull(result.getEffectiveFlag(region, stringFlag2, null));
     }
 
     @Test
@@ -1436,8 +1438,8 @@ public class FlagValueCalculatorTest {
         region.setFlag(stringFlag1.getRegionGroupFlag(), RegionGroup.NON_MEMBERS);
 
         FlagValueCalculator result = mock.getFlagCalculator();
-        assertThat(result.getEffectiveFlag(region, stringFlag1, null), equalTo("test1"));
-        assertThat(result.getEffectiveFlag(region, stringFlag2, null), equalTo(null));
+        assertEquals(result.getEffectiveFlag(region, stringFlag1, null), "test1");
+        assertNull(result.getEffectiveFlag(region, stringFlag2, null));
     }
 
     @Test
@@ -1458,8 +1460,8 @@ public class FlagValueCalculatorTest {
         LocalPlayer player = mock.createPlayer();
 
         FlagValueCalculator result = mock.getFlagCalculator();
-        assertThat(result.getEffectiveFlag(region, stringFlag1, player), equalTo("test1"));
-        assertThat(result.getEffectiveFlag(region, stringFlag2, null), equalTo(null));
+        assertEquals(result.getEffectiveFlag(region, stringFlag1, player), "test1");
+        assertNull(result.getEffectiveFlag(region, stringFlag2, null));
     }
 
     @Test
@@ -1480,8 +1482,8 @@ public class FlagValueCalculatorTest {
         LocalPlayer player = mock.createPlayer();
 
         FlagValueCalculator result = mock.getFlagCalculator();
-        assertThat(result.getEffectiveFlag(region, stringFlag1, player), equalTo(null));
-        assertThat(result.getEffectiveFlag(region, stringFlag2, null), equalTo(null));
+        assertNull(result.getEffectiveFlag(region, stringFlag1, player));
+        assertNull(result.getEffectiveFlag(region, stringFlag2, null));
     }
 
     @Test
@@ -1500,8 +1502,8 @@ public class FlagValueCalculatorTest {
         region.setFlag(stringFlag1.getRegionGroupFlag(), RegionGroup.MEMBERS);
 
         FlagValueCalculator result = mock.getFlagCalculator();
-        assertThat(result.getEffectiveFlag(region, stringFlag1, null), equalTo(null));
-        assertThat(result.getEffectiveFlag(region, stringFlag2, null), equalTo(null));
+        assertNull(result.getEffectiveFlag(region, stringFlag1, null));
+        assertNull(result.getEffectiveFlag(region, stringFlag2, null));
     }
 
     @Test
@@ -1523,8 +1525,8 @@ public class FlagValueCalculatorTest {
         region.getMembers().addPlayer(player);
 
         FlagValueCalculator result = mock.getFlagCalculator();
-        assertThat(result.getEffectiveFlag(region, stringFlag1, player), equalTo("test1"));
-        assertThat(result.getEffectiveFlag(region, stringFlag2, null), equalTo(null));
+        assertEquals(result.getEffectiveFlag(region, stringFlag1, player), "test1");
+        assertNull(result.getEffectiveFlag(region, stringFlag2, null));
     }
 
     @Test
@@ -1546,8 +1548,8 @@ public class FlagValueCalculatorTest {
         region.getOwners().addPlayer(player);
 
         FlagValueCalculator result = mock.getFlagCalculator();
-        assertThat(result.getEffectiveFlag(region, stringFlag1, player), equalTo("test1"));
-        assertThat(result.getEffectiveFlag(region, stringFlag2, null), equalTo(null));
+        assertEquals(result.getEffectiveFlag(region, stringFlag1, player), "test1");
+        assertNull(result.getEffectiveFlag(region, stringFlag2, null));
     }
 
     @Test
@@ -1569,8 +1571,8 @@ public class FlagValueCalculatorTest {
         region.getOwners().addPlayer(player);
 
         FlagValueCalculator result = mock.getFlagCalculator();
-        assertThat(result.getEffectiveFlag(region, stringFlag1, player), equalTo("test1"));
-        assertThat(result.getEffectiveFlag(region, stringFlag2, null), equalTo(null));
+        assertEquals(result.getEffectiveFlag(region, stringFlag1, player), "test1");
+        assertNull(result.getEffectiveFlag(region, stringFlag2, null));
     }
 
     @Test
@@ -1592,8 +1594,8 @@ public class FlagValueCalculatorTest {
         region.getMembers().addPlayer(player);
 
         FlagValueCalculator result = mock.getFlagCalculator();
-        assertThat(result.getEffectiveFlag(region, stringFlag1, player), equalTo(null));
-        assertThat(result.getEffectiveFlag(region, stringFlag2, null), equalTo(null));
+        assertNull(result.getEffectiveFlag(region, stringFlag1, player));
+        assertNull(result.getEffectiveFlag(region, stringFlag2, null));
     }
 
     @Test
@@ -1615,8 +1617,8 @@ public class FlagValueCalculatorTest {
         region.getOwners().addPlayer(player);
 
         FlagValueCalculator result = mock.getFlagCalculator();
-        assertThat(result.getEffectiveFlag(region, stringFlag1, player), equalTo(null));
-        assertThat(result.getEffectiveFlag(region, stringFlag2, null), equalTo(null));
+        assertNull(result.getEffectiveFlag(region, stringFlag1, player));
+        assertNull(result.getEffectiveFlag(region, stringFlag2, null));
     }
 
     @Test
@@ -1638,8 +1640,8 @@ public class FlagValueCalculatorTest {
         region.getOwners().addPlayer(player);
 
         FlagValueCalculator result = mock.getFlagCalculator();
-        assertThat(result.getEffectiveFlag(region, stringFlag1, player), equalTo(null));
-        assertThat(result.getEffectiveFlag(region, stringFlag2, null), equalTo(null));
+        assertNull(result.getEffectiveFlag(region, stringFlag1, player));
+        assertNull(result.getEffectiveFlag(region, stringFlag2, null));
     }
 
     @Test
@@ -1661,8 +1663,8 @@ public class FlagValueCalculatorTest {
         region.getMembers().addPlayer(player);
 
         FlagValueCalculator result = mock.getFlagCalculator();
-        assertThat(result.getEffectiveFlag(region, stringFlag1, player), equalTo("test1"));
-        assertThat(result.getEffectiveFlag(region, stringFlag2, null), equalTo(null));
+        assertEquals(result.getEffectiveFlag(region, stringFlag1, player), "test1");
+        assertNull(result.getEffectiveFlag(region, stringFlag2, null));
     }
 
     @Test
@@ -1683,8 +1685,8 @@ public class FlagValueCalculatorTest {
         LocalPlayer player = mock.createPlayer();
 
         FlagValueCalculator result = mock.getFlagCalculator();
-        assertThat(result.getEffectiveFlag(region, stringFlag1, player), equalTo("test1"));
-        assertThat(result.getEffectiveFlag(region, stringFlag2, null), equalTo(null));
+        assertEquals(result.getEffectiveFlag(region, stringFlag1, player), "test1");
+        assertNull(result.getEffectiveFlag(region, stringFlag2, null));
     }
 
     @Test
@@ -1709,8 +1711,8 @@ public class FlagValueCalculatorTest {
         region.setParent(parent2);
 
         FlagValueCalculator result = mock.getFlagCalculator();
-        assertThat(result.getEffectiveFlag(region, stringFlag1, null), equalTo("test1"));
-        assertThat(result.getEffectiveFlag(region, stringFlag2, null), equalTo(null));
+        assertEquals(result.getEffectiveFlag(region, stringFlag1, null), "test1");
+        assertNull(result.getEffectiveFlag(region, stringFlag2, null));
     }
 
     @Test
@@ -1737,8 +1739,8 @@ public class FlagValueCalculatorTest {
         region.setParent(parent2);
 
         FlagValueCalculator result = mock.getFlagCalculator();
-        assertThat(result.getEffectiveFlag(region, stringFlag1, null), equalTo("test2"));
-        assertThat(result.getEffectiveFlag(region, stringFlag2, null), equalTo(null));
+        assertEquals(result.getEffectiveFlag(region, stringFlag1, null), "test2");
+        assertNull(result.getEffectiveFlag(region, stringFlag2, null));
     }
 
     @Test
@@ -1765,8 +1767,8 @@ public class FlagValueCalculatorTest {
         parent1.setFlag(stringFlag1.getRegionGroupFlag(), RegionGroup.ALL);
 
         FlagValueCalculator result = mock.getFlagCalculator();
-        assertThat(result.getEffectiveFlag(region, stringFlag1, null), equalTo("test3"));
-        assertThat(result.getEffectiveFlag(region, stringFlag2, null), equalTo(null));
+        assertEquals(result.getEffectiveFlag(region, stringFlag1, null), "test3");
+        assertNull(result.getEffectiveFlag(region, stringFlag2, null));
     }
 
     @Test
@@ -1798,10 +1800,10 @@ public class FlagValueCalculatorTest {
         LocalPlayer player2 = mock.createPlayer();
 
         FlagValueCalculator result = mock.getFlagCalculator();
-        assertThat(result.getEffectiveFlag(region, stringFlag1, player1), equalTo("members"));
-        assertThat(result.getEffectiveFlag(region, stringFlag1, player2), equalTo("everyone"));
-        assertThat(result.getEffectiveFlag(region, stringFlag1, null), equalTo("everyone"));
-        assertThat(result.getEffectiveFlag(region, stringFlag2, null), equalTo(null));
+        assertEquals(result.getEffectiveFlag(region, stringFlag1, player1), "members");
+        assertEquals(result.getEffectiveFlag(region, stringFlag1, player2), "everyone");
+        assertEquals(result.getEffectiveFlag(region, stringFlag1, null), "everyone");
+        assertNull(result.getEffectiveFlag(region, stringFlag2, null));
     }
 
     @Test
@@ -1833,10 +1835,10 @@ public class FlagValueCalculatorTest {
         LocalPlayer player2 = mock.createPlayer();
 
         FlagValueCalculator result = mock.getFlagCalculator();
-        assertThat(result.getEffectiveFlag(region, stringFlag1, player1), equalTo("members"));
-        assertThat(result.getEffectiveFlag(region, stringFlag1, player2), equalTo("everyone"));
-        assertThat(result.getEffectiveFlag(region, stringFlag1, null), equalTo("everyone"));
-        assertThat(result.getEffectiveFlag(region, stringFlag2, null), equalTo(null));
+        assertEquals(result.getEffectiveFlag(region, stringFlag1, player1), "members");
+        assertEquals(result.getEffectiveFlag(region, stringFlag1, player2), "everyone");
+        assertEquals(result.getEffectiveFlag(region, stringFlag1, null), "everyone");
+        assertNull(result.getEffectiveFlag(region, stringFlag2, null));
     }
 
     @Test
@@ -1864,10 +1866,10 @@ public class FlagValueCalculatorTest {
         LocalPlayer player2 = mock.createPlayer();
 
         FlagValueCalculator result = mock.getFlagCalculator();
-        assertThat(result.getEffectiveFlag(region, stringFlag1, player1), equalTo("members"));
-        assertThat(result.getEffectiveFlag(region, stringFlag1, player2), equalTo("everyone"));
-        assertThat(result.getEffectiveFlag(region, stringFlag1, null), equalTo("everyone"));
-        assertThat(result.getEffectiveFlag(region, stringFlag2, null), equalTo(null));
+        assertEquals(result.getEffectiveFlag(region, stringFlag1, player1), "members");
+        assertEquals(result.getEffectiveFlag(region, stringFlag1, player2), "everyone");
+        assertEquals(result.getEffectiveFlag(region, stringFlag1, null), "everyone");
+        assertNull(result.getEffectiveFlag(region, stringFlag2, null));
     }
 
     @Test
@@ -1895,10 +1897,10 @@ public class FlagValueCalculatorTest {
         LocalPlayer player2 = mock.createPlayer();
 
         FlagValueCalculator result = mock.getFlagCalculator();
-        assertThat(result.getEffectiveFlag(region, stringFlag1, player1), equalTo("members"));
-        assertThat(result.getEffectiveFlag(region, stringFlag1, player2), equalTo("everyone"));
-        assertThat(result.getEffectiveFlag(region, stringFlag1, null), equalTo("everyone"));
-        assertThat(result.getEffectiveFlag(region, stringFlag2, null), equalTo(null));
+        assertEquals(result.getEffectiveFlag(region, stringFlag1, player1), "members");
+        assertEquals(result.getEffectiveFlag(region, stringFlag1, player2), "everyone");
+        assertEquals(result.getEffectiveFlag(region, stringFlag1, null), "everyone");
+        assertNull(result.getEffectiveFlag(region, stringFlag2, null));
     }
 
     @Test
@@ -1926,10 +1928,10 @@ public class FlagValueCalculatorTest {
         LocalPlayer player2 = mock.createPlayer();
 
         FlagValueCalculator result = mock.getFlagCalculator();
-        assertThat(result.getEffectiveFlag(region, stringFlag1, player1), equalTo("members"));
-        assertThat(result.getEffectiveFlag(region, stringFlag1, player2), equalTo("everyone"));
-        assertThat(result.getEffectiveFlag(region, stringFlag1, null), equalTo("everyone"));
-        assertThat(result.getEffectiveFlag(region, stringFlag2, null), equalTo(null));
+        assertEquals(result.getEffectiveFlag(region, stringFlag1, player1), "members");
+        assertEquals(result.getEffectiveFlag(region, stringFlag1, player2), "everyone");
+        assertEquals(result.getEffectiveFlag(region, stringFlag1, null), "everyone");
+        assertNull(result.getEffectiveFlag(region, stringFlag2, null));
     }
 
     @Test
@@ -1939,7 +1941,7 @@ public class FlagValueCalculatorTest {
         ProtectedRegion global = mock.global();
 
         FlagValueCalculator result = mock.getFlagCalculator();
-        assertThat(result.getEffectiveFlag(global, Flags.BUILD, null), equalTo(null));
+        assertNull(result.getEffectiveFlag(global, Flags.BUILD, null));
     }
 
     @Test
@@ -1951,7 +1953,7 @@ public class FlagValueCalculatorTest {
 
         FlagValueCalculator result = mock.getFlagCalculator();
         // Cannot let users override BUILD on GLOBAL
-        assertThat(result.getEffectiveFlag(global, Flags.BUILD, null), equalTo(State.DENY));
+        assertEquals(result.getEffectiveFlag(global, Flags.BUILD, null), State.DENY);
     }
 
     @Test
@@ -1963,6 +1965,6 @@ public class FlagValueCalculatorTest {
 
         FlagValueCalculator result = mock.getFlagCalculator();
         // Cannot let users override BUILD on GLOBAL
-        assertThat(result.getEffectiveFlag(global, Flags.BUILD, null), equalTo(null));
+        assertNull(result.getEffectiveFlag(global, Flags.BUILD, null));
     }
 }

worldguard-core/src/test/java/com/sk89q/worldguard/protection/HashMapIndexRemovalTest.java

@@ -29,14 +29,14 @@ import com.sk89q.worldguard.protection.managers.storage.MemoryRegionDatabase;
 import com.sk89q.worldguard.protection.regions.ProtectedCuboidRegion;
 import com.sk89q.worldguard.protection.regions.ProtectedRegion;
 import com.sk89q.worldguard.protection.regions.ProtectedRegion.CircularInheritanceException;
-import org.junit.Before;
-import org.junit.Test;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
 
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertNull;
-import static org.junit.Assert.assertTrue;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
 public class HashMapIndexRemovalTest {
     private static final String ORPHAN_ID = "orphan";
@@ -52,7 +52,7 @@ public class HashMapIndexRemovalTest {
         return new RegionManager(new MemoryRegionDatabase(), new HashMapIndex.Factory(), getFlagRegistry());
     }
 
-    @Before
+    @BeforeEach
     public void setUp() {
         manager = createRegionManager();
 

worldguard-core/src/test/java/com/sk89q/worldguard/protection/RegionEntryExitTest.java

@@ -19,8 +19,6 @@
 
 package com.sk89q.worldguard.protection;
 
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
 
 import com.sk89q.worldedit.math.BlockVector3;
 import com.sk89q.worldguard.TestPlayer;
@@ -34,8 +32,11 @@ import com.sk89q.worldguard.protection.managers.RegionManager;
 import com.sk89q.worldguard.protection.regions.GlobalProtectedRegion;
 import com.sk89q.worldguard.protection.regions.ProtectedCuboidRegion;
 import com.sk89q.worldguard.protection.regions.ProtectedRegion;
-import org.junit.Before;
-import org.junit.Test;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
 public abstract class RegionEntryExitTest {
 
@@ -60,7 +61,7 @@ public abstract class RegionEntryExitTest {
 
     protected abstract RegionManager createRegionManager() throws Exception;
 
-    @Before
+    @BeforeEach
     public void setUp() throws Exception {
         setUpGlobalRegion();
 
@@ -129,8 +130,8 @@ public abstract class RegionEntryExitTest {
 //        System.out.println("flag " + appl.getFlag(Flags.ENTRY));
 //        System.out.println("grp  " + appl.getFlag(Flags.ENTRY.getRegionGroupFlag()));
 //        System.out.println("===");
-        assertTrue("Allowed Entry", appl.testState(vipPlayer, Flags.ENTRY));
-        assertFalse("Forbidden Entry", appl.testState(builderPlayer, Flags.ENTRY));
+        assertTrue(appl.testState(vipPlayer, Flags.ENTRY), "Allowed Entry");
+        assertFalse(appl.testState(builderPlayer, Flags.ENTRY), "Forbidden Entry");
     }
 
     @Test
@@ -144,8 +145,8 @@ public abstract class RegionEntryExitTest {
 //        System.out.println("flag " + appl.getFlag(Flags.EXIT));
 //        System.out.println("grp  " + appl.getFlag(Flags.EXIT.getRegionGroupFlag()));
 //        System.out.println("===");
-        assertTrue("Allowed Exit", appl.testState(builderPlayer, Flags.EXIT));
-        assertFalse("Forbidden Exit", appl.testState(vipPlayer, Flags.EXIT));
+        assertTrue(appl.testState(builderPlayer, Flags.EXIT), "Allowed Exit");
+        assertFalse(appl.testState(vipPlayer, Flags.EXIT), "Forbidden Exit");
     }
 
 }

worldguard-core/src/test/java/com/sk89q/worldguard/protection/RegionOverlapTest.java

@@ -19,9 +19,6 @@
 
 package com.sk89q.worldguard.protection;
 
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
-
 import com.sk89q.worldedit.math.BlockVector2;
 import com.sk89q.worldedit.math.BlockVector3;
 import com.sk89q.worldguard.TestPlayer;
@@ -36,16 +33,20 @@ import com.sk89q.worldguard.protection.regions.GlobalProtectedRegion;
 import com.sk89q.worldguard.protection.regions.ProtectedCuboidRegion;
 import com.sk89q.worldguard.protection.regions.ProtectedPolygonalRegion;
 import com.sk89q.worldguard.protection.regions.ProtectedRegion;
-import org.junit.Before;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.Parameterized;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.TestInstance;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.ValueSource;
 
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.HashSet;
 
-@RunWith(Parameterized.class)
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+@TestInstance(TestInstance.Lifecycle.PER_CLASS)
 public abstract class RegionOverlapTest {
     static String COURTYARD_ID = "courtyard";
     static String FOUNTAIN_ID = "fountain";
@@ -64,13 +65,13 @@ public abstract class RegionOverlapTest {
     TestPlayer player1;
     TestPlayer player2;
 
-    @Parameterized.Parameters(name = "{index}: useMaxPrio = {0}")
+   /* @Parameterized.Parameters(name = "{index}: useMaxPrio = {0}")
     public static Iterable<Object[]> params() {
         return Arrays.asList(new Object[][]{{true}, {false}});
-    }
+    }*/
 
-    @Parameterized.Parameter
-    public boolean useMaxPriorityAssociation;
+
+    // public boolean useMaxPriorityAssociation;
 
     protected FlagRegistry getFlagRegistry() {
         return WorldGuard.getInstance().getFlagRegistry();
@@ -78,7 +79,7 @@ public abstract class RegionOverlapTest {
     
     protected abstract RegionManager createRegionManager() throws Exception;
 
-    @Before
+    @BeforeAll
     public void setUp() throws Exception {
         setUpGlobalRegion();
         
@@ -194,8 +195,9 @@ public abstract class RegionOverlapTest {
         assertTrue(appl.testState(player2, Flags.BUILD));
     }
 
-    @Test
-    public void testNonPlayerBuildAccessInOneRegion() {
+    @ParameterizedTest(name = "useMaxPriorityAssociation={0}")
+    @ValueSource(booleans = { false, true })
+    public void testNonPlayerBuildAccessInOneRegion(boolean useMaxPriorityAssociation) {
         ApplicableRegionSet appl;
 
         HashSet<ProtectedRegion> source = new HashSet<>();
@@ -210,11 +212,12 @@ public abstract class RegionOverlapTest {
         assertTrue(appl.testState(assoc, Flags.BUILD));
         // Inside fountain
         appl = manager.getApplicableRegions(inFountain);
-        assertFalse(appl.testState(assoc, Flags.BUILD));
+        assertTrue(appl.testState(assoc, Flags.BUILD));
     }
 
-    @Test
-    public void testNonPlayerBuildAccessInBothRegions() {
+    @ParameterizedTest(name = "useMaxPriorityAssociation={0}")
+    @ValueSource(booleans = { false, true })
+    public void testNonPlayerBuildAccessInBothRegions(boolean useMaxPriorityAssociation) {
         ApplicableRegionSet appl;
 
         HashSet<ProtectedRegion> source = new HashSet<>();
@@ -233,8 +236,9 @@ public abstract class RegionOverlapTest {
         assertTrue(appl.testState(assoc, Flags.BUILD));
     }
 
-    @Test
-    public void testNonPlayerBuildAccessInNoRegions() {
+    @ParameterizedTest(name = "useMaxPriorityAssociation={0}")
+    @ValueSource(booleans = { false, true })
+    public void testNonPlayerBuildAccessInNoRegions(boolean useMaxPriorityAssociation) {
         ApplicableRegionSet appl;
 
         HashSet<ProtectedRegion> source = new HashSet<>();

worldguard-core/src/test/java/com/sk89q/worldguard/protection/RegionPriorityTest.java

@@ -19,8 +19,6 @@
 
 package com.sk89q.worldguard.protection;
 
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
 
 import com.sk89q.worldedit.math.BlockVector2;
 import com.sk89q.worldedit.math.BlockVector3;
@@ -35,11 +33,16 @@ import com.sk89q.worldguard.protection.regions.GlobalProtectedRegion;
 import com.sk89q.worldguard.protection.regions.ProtectedCuboidRegion;
 import com.sk89q.worldguard.protection.regions.ProtectedPolygonalRegion;
 import com.sk89q.worldguard.protection.regions.ProtectedRegion;
-import org.junit.Before;
-import org.junit.Test;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.TestInstance;
 
 import java.util.ArrayList;
 
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+@TestInstance(TestInstance.Lifecycle.PER_CLASS)
 public abstract class RegionPriorityTest {
     static String COURTYARD_ID = "courtyard";
     static String FOUNTAIN_ID = "fountain";
@@ -63,7 +66,7 @@ public abstract class RegionPriorityTest {
     
     protected abstract RegionManager createRegionManager() throws Exception;
 
-    @Before
+    @BeforeAll
     public void setUp() throws Exception {
         setUpGlobalRegion();
         

worldguard-core/src/test/java/com/sk89q/worldguard/protection/regions/RegionIntersectTest.java

@@ -19,17 +19,18 @@
 
 package com.sk89q.worldguard.protection.regions;
 
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertTrue;
 
 import com.sk89q.worldedit.math.BlockVector2;
 import com.sk89q.worldedit.math.BlockVector3;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
 
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
 public class RegionIntersectTest {
 
     @Test
@@ -96,7 +97,7 @@ public class RegionIntersectTest {
             e.printStackTrace();
         }
 
-        assertEquals("Check for '" + region2.getId() + "' region failed.", expected, actual);
+        assertEquals(expected, actual, "Check for '" + region2.getId() + "' region failed.");
     }
 
     private static final BlockVector2[] polygon = {
@@ -117,8 +118,8 @@ public class RegionIntersectTest {
 
             final ProtectedPolygonalRegion polygonalRegion = new ProtectedPolygonalRegion("polygonalRegion", Arrays.asList(rotatedPolygon), -3, 3);
 
-            assertTrue(String.format("%s does not intersect (cuboid.intersectsEdges(polygonal)", Arrays.asList(rotatedPolygon)), cuboidRegion.intersectsEdges(polygonalRegion));
-            assertTrue(String.format("%s does not intersect (polygonal.intersectsEdges(cuboid)", Arrays.asList(rotatedPolygon)), polygonalRegion.intersectsEdges(cuboidRegion));
+            assertTrue(cuboidRegion.intersectsEdges(polygonalRegion), String.format("%s does not intersect (cuboid.intersectsEdges(polygonal)", Arrays.asList(rotatedPolygon)));
+            assertTrue(polygonalRegion.intersectsEdges(cuboidRegion), String.format("%s does not intersect (polygonal.intersectsEdges(cuboid)", Arrays.asList(rotatedPolygon)));
         }
     }
 }

worldguard-core/src/test/java/com/sk89q/worldguard/util/CommandFilterTest.java

@@ -21,15 +21,15 @@ package com.sk89q.worldguard.util;
 
 import com.sk89q.worldguard.util.command.CommandFilter;
 import com.sk89q.worldguard.util.command.CommandFilter.Builder;
-import junit.framework.TestCase;
+import org.junit.jupiter.api.Test;
 
-import static org.hamcrest.CoreMatchers.is;
-import static org.junit.Assert.assertThat;
+import static org.junit.jupiter.api.Assertions.assertEquals;
 
-public class CommandFilterTest extends TestCase {
+public class CommandFilterTest {
 
     private static final String[] COMMAND_SEPARATORS = new String[] {" ", "  ", "\t", " \t", "\n", "\r\n"};
 
+    @Test
     public void testApply() throws Exception {
         CommandFilter filter;
 
@@ -187,9 +187,9 @@ public class CommandFilterTest extends TestCase {
 
     private void assertSubcommands(CommandFilter filter, final String root, boolean expected) {
         for (String separator : COMMAND_SEPARATORS) {
-            assertThat(filter.apply(root.replaceAll(" ", separator)), is(expected));
-            assertThat(filter.apply((root + " _subcmd").replaceAll(" ", separator)), is(expected));
-            assertThat(filter.apply((root + " _subcmd _another").replaceAll(" ", separator)), is(expected));
+            assertEquals(filter.apply(root.replaceAll(" ", separator)), expected);
+            assertEquals(filter.apply((root + " _subcmd").replaceAll(" ", separator)), expected);
+            assertEquals(filter.apply((root + " _subcmd _another").replaceAll(" ", separator)), expected);
         }
     }