Update pom

- Players with "player weather" will no longer have their weather reset on plots that do not set the PlotWeather flag

.github/CODEOWNERS

@@ -0,0 +1 @@
+* @IntellectualSites/plotsquared-team

.github/FUNDING.yml

@@ -0,0 +1,12 @@
+# These are supported funding model platforms
+
+github: [NotMyFault, dordsor21, SirYwell]
+patreon: IntellectualSites # Replace with a single Patreon username
+open_collective: IntellectualSites
+ko_fi: # Replace with a single Ko-fi username
+tidelift: # Replace with a single Tidelift platform-name/package-name e.g., npm/babel
+community_bridge: # Replace with a single Community Bridge project-name e.g., cloud-foundry
+liberapay: # Replace with a single Liberapay username
+issuehunt: # Replace with a single IssueHunt username
+otechie: # Replace with a single Otechie username
+custom: https://www.paypal.me/AlexanderBrandes # Replace with up to 4 custom sponsorship URLs e.g., ['link1', 'link2']

.github/ISSUE_TEMPLATE/bug_report.yml

@@ -0,0 +1,102 @@
+name: Bug report
+description: Create a report to help us improve
+labels: 'Requires Testing'
+
+body:
+  - type: markdown
+    attributes:
+      value: |
+        Thanks for taking the time to fill out this bug report for PlotSquared! Fill out the following form to your best ability to help us fix the problem.
+        Only use this if you're absolutely sure that you found a bug and can reproduce it. For anything else, use: [our Discord server](https://discord.gg/intellectualsites) or [the wiki](https://github.com/IntellectualSites/PlotSquared/wiki).
+
+  - type: dropdown
+    attributes:
+      label: Server Implementation
+      description: Which server Implementation are you using? If your server implementation is not listed, it is not supported. Switch to a supported version first.
+      multiple: false
+      options:
+        - Paper
+        - Spigot
+        - Tuinity
+        - Purpur
+    validations:
+      required: true
+
+  - type: dropdown
+    attributes:
+      label: Server Version
+      description: Which server version version you using? If your server version is not listed, it is not supported. Update to a supported version first.
+      multiple: false
+      options:
+        - '1.16.5'
+        - '1.15.2'
+        - '1.14.4'
+        - '1.13.2'
+    validations:
+      required: true
+
+  - type: textarea
+    attributes:
+      label: Describe the bug
+      description: A clear and concise description of what the bug is.
+    validations:
+      required: true
+
+  - type: textarea
+    attributes:
+      label: To Reproduce
+      description: Steps to reproduce this behaviour
+      placeholder: |
+        1. Go to '...'
+        2. Click on '...'
+        3. Scroll down to '...'
+        4. See error
+    validations:
+      required: true
+
+  - type: textarea
+    attributes:
+      label: Expected behaviour
+      description: A clear and concise description of what you expected to happen.
+    validations:
+      required: true
+
+  - type: textarea
+    attributes:
+      label: Screenshots / Videos
+      description: If applicable, add screenshots to help explain your problem.
+
+  - type: input
+    attributes:
+      label: Error log (if applicable)
+      description: If you are reporting a console error, upload any relevant log excerpts to either https://paste.gg/ or https://gist.github.com, save and the paste the link in this box.
+
+  - type: input
+    attributes:
+      label: Plot Debugpaste
+      description: Run `/plot debugpaste` in your console or ingame and provide the output link here.
+    validations:
+      required: true
+
+  - type: input
+    attributes:
+      label: PlotSquared Version
+      description: What version of PlotSquared are you running? (`/version PlotSquared`)
+      placeholder: "For example: PlotSquared version 5.13.11-Premium"
+    validations:
+      required: true
+
+  - type: checkboxes
+    attributes:
+      label: Checklist
+      description: Make sure you have followed each of the steps outlined here.
+      options:
+        - label: I have included a Plot debugpaste.
+          required: true
+        - label: I am using the newest build from https://www.spigotmc.org/resources/77506/ and the issue still persists.
+          required: true
+
+  - type: textarea
+    attributes:
+      label: Anything else?
+      description: You can provide additional context below.

.github/ISSUE_TEMPLATE/config.yml

@@ -0,0 +1,8 @@
+blank_issues_enabled: false
+contact_links:
+  - name: IntellectualSites Discord
+    url: https://discord.gg/intellectualsites
+    about: Our support Discord, please ask questions and seek support here.
+  - name: PlotSquared Wiki
+    url: https://github.com/IntellectualSites/PlotSquared/wiki
+    about: Take a look at the wiki page for instructions how to setup PlotSquared and use its commands.

.github/ISSUE_TEMPLATE/feature_request.yml

@@ -0,0 +1,29 @@
+name: Feature request
+description: Suggest an idea for this project
+labels: 'Enhancement'
+
+body:
+  - type: markdown
+    attributes:
+      value: |
+        Thanks for taking the time to fill out this feature request for PlotSquared! Fill out the following form to your best ability to help us understand your feature request and greately improve the change of it getting added.
+        For anything else than a feature request, use: [our Discord server](https://discord.gg/intellectualsites) or [the wiki](https://github.com/IntellectualSites/PlotSquared/wiki).
+
+  - type: textarea
+    attributes:
+      label: What feature do you want to see added?
+      description: A clear and concise description of your feature request.
+    validations:
+      required: true
+
+  - type: textarea
+    attributes:
+      label: Are there any alternatives?
+      description: List any alternatives you might have tried
+    validations:
+      required: true
+
+  - type: textarea
+    attributes:
+      label: Anything else?
+      description: You can provide additional context below.

.github/PULL_REQUEST_TEMPLATE.md

@@ -0,0 +1,17 @@
+## Overview
+<!--  Please describe which issue this Pull Request targets
+
+If there is no issue, please create one so we can look into it before approving your PR.
+You can do so here: https://github.com/IntellectualSites/PlotSquared/issues
+-->
+
+**Fixes {Link to issue}**
+
+## Description
+
+## Checklist
+<!-- Make sure you have completed the following steps (put an "X" between of brackets): -->
+- [] I included all information required in the sections above
+- [] I tested my changes and approved their functionality
+- [] I ensured my changes do not break other parts of the code
+- [] I read and followed the [contribution guidelines](https://github.com/IntellectualSites/PlotSquared/blob/v5/CONTRIBUTING.md)

.github/stale.yml

@@ -0,0 +1,18 @@
+daysUntilStale: 60
+daysUntilClose: 7
+only: issues
+exemptLabels:
+  - "Bug"
+  - "Enhancement"
+  - "Approved"
+  - "Priority"
+  - "Under investigation"
+staleLabel: "resolution: stale"
+markComment: >
+  This issue has been automatically marked as stale because it has not had
+  recent activity. It will be closed if no further activity occurs. If the issue is still present and can be reproduced, please let the team know.
+  Thank you for your contributions.
+closeComment: >
+  This issue has been automatically closed because it has not had activity in
+  a long time. If the issue still applies to the most recent supported
+  version, please reply to this issue and the team will reopen it.

.github/workflows/build.yml

@@ -0,0 +1,20 @@
+name: "build"
+
+on: ["pull_request", "push"]
+ 
+jobs:
+  build:
+    strategy:
+      matrix:
+        java: ["1.8", "11"]
+        os: ["ubuntu-18.04"]
+    runs-on: "${{ matrix.os }}"
+    steps:
+    - name: "Checkout Repository"
+      uses: "actions/checkout@v2.3.4"
+    - name: "Setup JDK ${{ matrix.java }}"
+      uses: "actions/setup-java@v1.4.3"
+      with:
+          java-version: "${{ matrix.java }}"
+    - name: "Clean Build"
+      run: "./gradlew clean build"

.github/workflows/validate-gradle-wrapper.yml

@@ -0,0 +1,12 @@
+name: "validate gradle wrapper"
+
+on: ["pull_request", "push"]
+
+jobs:
+  build:
+    runs-on: "ubuntu-18.04"
+    steps:
+      - name: "Checkout Repository"
+        uses: "actions/checkout@v2.3.4"
+      - name: "Validate Gradle Wrapper"
+        uses: "gradle/wrapper-validation-action@v1.0.3"

.gitignore

@@ -1,134 +1,145 @@
-### Ignore script files
-*.sh
-*.bat
-
-### Maven template
-target/
-pom.xml.tag
-pom.xml.releaseBackup
-pom.xml.versionsBackup
-pom.xml.next
-release.properties
-dependency-reduced-pom.xml
-buildNumber.properties
-.mvn/timing.properties
-
-
-### JetBrains template
-# Covers JetBrains IDEs: IntelliJ, RubyMine, PhpStorm, AppCode, PyCharm, CLion
-
-*.iml
-
-## Directory-based project format:
-.idea/
-# if you remove the above rule, at least ignore the following:
-
-# User-specific stuff:
-# .idea/workspace.xml
-# .idea/tasks.xml
-# .idea/dictionaries
-
-# Sensitive or high-churn files:
-# .idea/dataSources.ids
-# .idea/dataSources.xml
-# .idea/sqlDataSources.xml
-# .idea/dynamic.xml
-# .idea/uiDesigner.xml
-
-# Gradle:
-# .idea/gradle.xml
-# .idea/libraries
-
-# Mongo Explorer plugin:
-# .idea/mongoSettings.xml
-
-## File-based project format:
-*.ipr
-*.iws
-
-## Plugin-specific files:
-
-# IntelliJ
-/out/
-
-# mpeltonen/sbt-idea plugin
-.idea_modules/
-
-# JIRA plugin
-atlassian-ide-plugin.xml
-
-# Crashlytics plugin (for Android Studio and IntelliJ)
-com_crashlytics_export_strings.xml
-crashlytics.properties
-crashlytics-build.properties
-
-
-### NetBeans template
-nbproject/private/
-build/
-nbbuild/
-dist/
-nbdist/
-nbactions.xml
-nb-configuration.xml
-.nb-gradle/
-
-
-### Eclipse template
-*.pydevproject
-.metadata
-.gradle
-bin/
-tmp/
-*.tmp
-*.bak
-*.swp
-*~.nib
-local.properties
-.settings/
-.loadpath
-
-# Eclipse Core
-.project
-
-# External tool builders
-.externalToolBuilders/
-
-# Locally stored "Eclipse launch configurations"
-*.launch
-
-# CDT-specific
-.cproject
-
-# JDT-specific (Eclipse Java Development Tools)
-.classpath
-
-# Java annotation processor (APT)
-.factorypath
-
-# PDT-specific
-.buildpath
-
-# sbteclipse plugin
-.target
-
-# TeXlipse plugin
-.texlipse
-
-
-### Java template
-*.class
-
-# Mobile Tools for Java (J2ME)
-.mtj.tmp/
-
-# Package Files #
-*.jar
-*.war
-*.ear
-*.zip
-
-# virtual machine crash logs, see http://www.java.com/en/download/help/error_hotspot.xml
-hs_err_pid*
-
-
+### Others ###
+*.cmd
+*.sh
+*.prefs
+Sponge/build
+Core/build
+Bukkit/build
+Nukkit/build
+buildSrc/
+
+### Maven ###
+/mvn
+/target/lib
+/target/maven-archiver
+/target/classes
+/target/maven-status
+pom.xml.tag
+pom.xml.releaseBackup
+pom.xml.versionsBackup
+pom.xml.next
+release.properties
+dependency-reduced-pom.xml
+buildNumber.properties
+.mvn/timing.properties
+out/
+
+
+### Java ###
+*.class
+
+# Mobile Tools for Java (J2ME)
+.mtj.tmp/
+
+# Package Files #
+*.war
+*.ear
+
+# virtual machine crash logs, see http://www.java.com/en/download/help/error_hotspot.xml
+hs_err_pid*
+
+
+### Intellij ###
+# Covers JetBrains IDEs: IntelliJ, RubyMine, PhpStorm, AppCode, PyCharm, CLion, Android Studio and Webstorm
+
+*.iml
+
+## Directory-based project format:
+.idea/
+# if you remove the above rule, at least ignore the following:
+
+# User-specific stuff:
+# .idea/workspace.xml
+# .idea/tasks.xml
+# .idea/dictionaries
+# .idea/shelf
+
+# Sensitive or high-churn files:
+# .idea/dataSources.ids
+# .idea/dataSources.xml
+# .idea/sqlDataSources.xml
+# .idea/dynamic.xml
+# .idea/uiDesigner.xml
+
+# Gradle:
+# .idea/gradle.xml
+# .idea/libraries
+.gradle
+
+# Mongo Explorer plugin:
+# .idea/mongoSettings.xml
+
+## File-based project format:
+*.ipr
+*.iws
+
+## Plugin-specific files:
+
+# IntelliJ
+/out/
+
+# mpeltonen/sbt-idea plugin
+.idea_modules/
+
+# JIRA plugin
+atlassian-ide-plugin.xml
+
+# Crashlytics plugin (for Android Studio and IntelliJ)
+com_crashlytics_export_strings.xml
+crashlytics.properties
+crashlytics-build.properties
+fabric.properties
+
+
+### Eclipse ###
+*.pydevproject
+.metadata
+bin/
+tmp/
+*.tmp
+*.bak
+*.swp
+*~.nib
+local.properties
+.settings/
+.loadpath
+
+# Eclipse Core
+.project
+
+# External tool builders
+.externalToolBuilders/
+
+# Locally stored "Eclipse launch configurations"
+*.launch
+
+# CDT-specific
+.cproject
+
+# JDT-specific (Eclipse Java Development Tools)
+.classpath
+
+# Java annotation processor (APT)
+.factorypath
+
+# PDT-specific
+.buildpath
+
+# sbteclipse plugin
+.target
+
+# TeXlipse plugin
+.texlipse
+
+# STS (Spring Tool Suite)
+.springBeans
+/target/
+Nukkit/build/classes/
+Nukkit/build/dependency-cache/
+checkstyle.xml
+classes/
+p2error.txt
+*.bat
+Nukkit/build/resources/main/plugin.yml
+docs/
+build/

Bukkit/build.gradle

@@ -0,0 +1,125 @@
+plugins {
+    id "com.github.johnrengelman.shadow"
+}
+repositories {
+    maven { url = "https://hub.spigotmc.org/nexus/content/repositories/snapshots/" }
+    maven { url = "https://oss.sonatype.org/content/repositories/snapshots/" }
+    maven { url = "https://jitpack.io" }
+    maven { url = "https://repo.codemc.org/repository/maven-public" }
+    maven { url = "https://repo.extendedclip.com/content/repositories/placeholderapi/" }
+    maven {
+        name = "papermc"
+        url = "https://papermc.io/repo/repository/maven-public/"
+    }
+    maven { url = "https://ci.ender.zone/plugin/repository/everything/" }
+    maven { url = "https://mvn.intellectualsites.com/content/repositories/releases" }
+    maven { url = "https://mvn.intellectualsites.com/content/repositories/thirdparty"}
+    maven { url = "https://mvn.intellectualsites.com/content/repositories/snapshots" }
+    maven { url = "http://repo.mvdw-software.be/content/groups/public/" }
+    mavenLocal()
+}
+
+
+dependencies {
+    implementation(project(":PlotSquared-Core"))
+    compile("org.bstats:bstats-bukkit:1.7")
+    compile(project(":PlotSquared-Core"))
+    compile("com.destroystokyo.paper:paper-api:1.16.4-R0.1-SNAPSHOT")
+    implementation("org.spigotmc:spigot-api:1.16.4-R0.1-SNAPSHOT")
+    compile(group: "com.sk89q.worldedit", name: "worldedit-bukkit", version: "7.2.0") {
+        exclude(module: "bukkit")
+    }
+    compile("io.papermc:paperlib:1.0.5")
+    implementation("net.kyori:text-adapter-bukkit:3.0.3")
+    compile("com.github.MilkBowl:VaultAPI:1.7") {
+        exclude(module: "bukkit")
+    }
+    implementation("me.clip:placeholderapi:2.10.6")
+    implementation("net.luckperms:api:5.1")
+    implementation("net.ess3:EssentialsX:2.18.0") {
+        exclude(group: "io.papermc", module: "paperlib")
+    }
+    compile("se.hyperver.hyperverse:Core:0.6.0-SNAPSHOT"){ transitive = false }
+    compile('com.sk89q:squirrelid:1.0.0-SNAPSHOT'){ transitive = false }
+    compile('be.maximvdw:MVdWPlaceholderAPI:3.1.1'){ transitive = false }
+    implementation("org.incendo.serverlib:ServerLib:2.2.0")
+}
+
+sourceCompatibility = 1.8
+targetCompatibility = 1.8
+
+processResources {
+    from("src/main/resources") {
+        include("plugin.yml")
+        expand(
+                name: project.parent.name,
+                version: project.parent.version
+        )
+    }
+}
+
+//noinspection GroovyAssignabilityCheck
+jar.archiveFileName = "PlotSquared-Bukkit-${project.parent.version}.jar"
+jar.destinationDirectory = file("../mvn/com/plotsquared/PlotSquared-Bukkit/" + project.parent.version)
+task createPom {
+    doLast {
+        pom {
+            project {
+                groupId = rootProject.group
+                artifactId = "PlotSquared-Bukkit"
+                version = rootProject.version
+            }
+        }.writeTo("../mvn/com/plotsquared/PlotSquared-Bukkit/${project.parent.version}/PlotSquared-Bukkit-${project.parent.version}.pom")
+        pom {
+            project {
+                groupId = rootProject.group
+                artifactId = "PlotSquared-Bukkit"
+                version = "latest"
+            }
+        }.writeTo("../mvn/com/plotsquared/PlotSquared-Bukkit/latest/PlotSquared-Bukkit-latest.pom")
+         .writeTo("pom.xml")
+    }
+}
+
+task copyFiles {
+    doLast {
+        copy {
+            from("../mvn/com/plotsquared/PlotSquared-Bukkit/${project.parent.version}/")
+            into("../mvn/com/plotsquared/PlotSquared-Bukkit/latest/")
+            include("PlotSquared-Bukkit*.jar")
+            rename("PlotSquared-Bukkit-${project.parent.version}.jar", "PlotSquared-Bukkit-latest.jar")
+        }
+    }
+}
+
+
+shadowJar {
+    dependencies {
+        include(dependency(":PlotSquared-Core"))
+        include(dependency("io.papermc:paperlib:1.0.5"))
+        include(dependency("net.kyori:text-adapter-bukkit:3.0.3"))
+        include(dependency("org.bstats:bstats-bukkit:1.7"))
+        include(dependency("org.khelekore:prtree:1.7.0-SNAPSHOT"))
+        include(dependency("com.sk89q:squirrelid:1.0.0-SNAPSHOT"))
+        include(dependency("com.intellectualsites.paster:Paster:1.0.2-SNAPSHOT"))
+        include(dependency("org.incendo.serverlib:ServerLib:2.2.0"))
+    }
+    relocate('net.kyori.text', 'com.plotsquared.formatting.text')
+    relocate("io.papermc.lib", "com.plotsquared.bukkit.paperlib")
+    relocate("org.bstats", "com.plotsquared.metrics")
+    relocate('com.sk89q.squirrelid', 'com.plotsquared.squirrelid')
+    relocate('org.khelekore.prtree', 'com.plotsquared.prtree')
+    relocate('com.intellectualsites.paster', 'com.plotsquared.core.paster')
+    relocate('org.incendo.serverlib', 'com.plotsquared.bukkit')
+    archiveFileName = "${project.name}-${parent.version}.jar"
+    destinationDirectory = file "../target"
+}
+
+shadowJar.doLast {
+    task ->
+        ant.checksum file: task.archivePath
+}
+
+build.dependsOn(shadowJar)
+build.finalizedBy(copyFiles)
+copyFiles.dependsOn(createPom)

Bukkit/pom.xml

@@ -0,0 +1,198 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd" xmlns="http://maven.apache.org/POM/4.0.0"
+    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
+  <modelVersion>4.0.0</modelVersion>
+  <groupId>com.plotsquared</groupId>
+  <artifactId>PlotSquared-Bukkit</artifactId>
+  <version>latest</version>
+  <dependencies>
+    <dependency>
+      <groupId>org.json</groupId>
+      <artifactId>json</artifactId>
+      <version>20200518</version>
+      <scope>compile</scope>
+    </dependency>
+    <dependency>
+      <groupId>org.bstats</groupId>
+      <artifactId>bstats-bukkit</artifactId>
+      <version>1.7</version>
+      <scope>compile</scope>
+    </dependency>
+    <dependency>
+      <groupId>com.plotsquared</groupId>
+      <artifactId>PlotSquared-Core</artifactId>
+      <version>5.13.13</version>
+      <scope>compile</scope>
+    </dependency>
+    <dependency>
+      <groupId>com.destroystokyo.paper</groupId>
+      <artifactId>paper-api</artifactId>
+      <version>1.16.4-R0.1-SNAPSHOT</version>
+      <scope>compile</scope>
+    </dependency>
+    <dependency>
+      <groupId>com.sk89q.worldedit</groupId>
+      <artifactId>worldedit-bukkit</artifactId>
+      <version>7.2.0</version>
+      <scope>compile</scope>
+      <exclusions>
+        <exclusion>
+          <artifactId>bukkit</artifactId>
+          <groupId>*</groupId>
+        </exclusion>
+      </exclusions>
+    </dependency>
+    <dependency>
+      <groupId>io.papermc</groupId>
+      <artifactId>paperlib</artifactId>
+      <version>1.0.5</version>
+      <scope>compile</scope>
+    </dependency>
+    <dependency>
+      <groupId>com.github.MilkBowl</groupId>
+      <artifactId>VaultAPI</artifactId>
+      <version>1.7</version>
+      <scope>compile</scope>
+      <exclusions>
+        <exclusion>
+          <artifactId>bukkit</artifactId>
+          <groupId>*</groupId>
+        </exclusion>
+      </exclusions>
+    </dependency>
+    <dependency>
+      <groupId>se.hyperver.hyperverse</groupId>
+      <artifactId>Core</artifactId>
+      <version>0.6.0-SNAPSHOT</version>
+      <scope>compile</scope>
+      <exclusions>
+        <exclusion>
+          <artifactId>*</artifactId>
+          <groupId>*</groupId>
+        </exclusion>
+      </exclusions>
+    </dependency>
+    <dependency>
+      <groupId>com.sk89q</groupId>
+      <artifactId>squirrelid</artifactId>
+      <version>1.0.0-SNAPSHOT</version>
+      <scope>compile</scope>
+      <exclusions>
+        <exclusion>
+          <artifactId>*</artifactId>
+          <groupId>*</groupId>
+        </exclusion>
+      </exclusions>
+    </dependency>
+    <dependency>
+      <groupId>be.maximvdw</groupId>
+      <artifactId>MVdWPlaceholderAPI</artifactId>
+      <version>3.1.1</version>
+      <scope>compile</scope>
+      <exclusions>
+        <exclusion>
+          <artifactId>*</artifactId>
+          <groupId>*</groupId>
+        </exclusion>
+      </exclusions>
+    </dependency>
+    <dependency>
+      <groupId>com.sk89q.worldedit</groupId>
+      <artifactId>worldedit-core</artifactId>
+      <version>7.2.0</version>
+      <scope>runtime</scope>
+      <exclusions>
+        <exclusion>
+          <artifactId>dummypermscompat</artifactId>
+          <groupId>*</groupId>
+        </exclusion>
+        <exclusion>
+          <artifactId>bukkit-classloader-check</artifactId>
+          <groupId>*</groupId>
+        </exclusion>
+        <exclusion>
+          <artifactId>mockito-core</artifactId>
+          <groupId>*</groupId>
+        </exclusion>
+      </exclusions>
+    </dependency>
+    <dependency>
+      <groupId>net.kyori</groupId>
+      <artifactId>text-api</artifactId>
+      <version>3.0.2</version>
+      <scope>runtime</scope>
+    </dependency>
+    <dependency>
+      <groupId>net.kyori</groupId>
+      <artifactId>text-serializer-gson</artifactId>
+      <version>3.0.2</version>
+      <scope>runtime</scope>
+    </dependency>
+    <dependency>
+      <groupId>net.kyori</groupId>
+      <artifactId>text-serializer-legacy</artifactId>
+      <version>3.0.2</version>
+      <scope>runtime</scope>
+    </dependency>
+    <dependency>
+      <groupId>net.kyori</groupId>
+      <artifactId>text-serializer-plain</artifactId>
+      <version>3.0.2</version>
+      <scope>runtime</scope>
+    </dependency>
+    <dependency>
+      <groupId>com.google.guava</groupId>
+      <artifactId>guava</artifactId>
+      <version>21.0</version>
+      <scope>runtime</scope>
+    </dependency>
+    <dependency>
+      <groupId>org.spigotmc</groupId>
+      <artifactId>spigot-api</artifactId>
+      <version>1.16.4-R0.1-SNAPSHOT</version>
+      <scope>runtime</scope>
+    </dependency>
+    <dependency>
+      <groupId>net.kyori</groupId>
+      <artifactId>text-adapter-bukkit</artifactId>
+      <version>3.0.3</version>
+      <scope>runtime</scope>
+    </dependency>
+    <dependency>
+      <groupId>me.clip</groupId>
+      <artifactId>placeholderapi</artifactId>
+      <version>2.10.6</version>
+      <scope>runtime</scope>
+    </dependency>
+    <dependency>
+      <groupId>net.luckperms</groupId>
+      <artifactId>api</artifactId>
+      <version>5.1</version>
+      <scope>runtime</scope>
+    </dependency>
+    <dependency>
+      <groupId>net.ess3</groupId>
+      <artifactId>EssentialsX</artifactId>
+      <version>2.18.0</version>
+      <scope>runtime</scope>
+      <exclusions>
+        <exclusion>
+          <artifactId>paperlib</artifactId>
+          <groupId>io.papermc</groupId>
+        </exclusion>
+      </exclusions>
+    </dependency>
+    <dependency>
+      <groupId>org.incendo.serverlib</groupId>
+      <artifactId>ServerLib</artifactId>
+      <version>2.2.0</version>
+      <scope>runtime</scope>
+    </dependency>
+    <dependency>
+      <groupId>junit</groupId>
+      <artifactId>junit</artifactId>
+      <version>4.13</version>
+      <scope>test</scope>
+    </dependency>
+  </dependencies>
+</project>

Bukkit/src/main/java/com/plotsquared/bukkit/BukkitCommand.java

@@ -0,0 +1,83 @@
+/*
+ *       _____  _       _    _____                                _
+ *      |  __ \| |     | |  / ____|                              | |
+ *      | |__) | | ___ | |_| (___   __ _ _   _  __ _ _ __ ___  __| |
+ *      |  ___/| |/ _ \| __|\___ \ / _` | | | |/ _` | '__/ _ \/ _` |
+ *      | |    | | (_) | |_ ____) | (_| | |_| | (_| | | |  __/ (_| |
+ *      |_|    |_|\___/ \__|_____/ \__, |\__,_|\__,_|_|  \___|\__,_|
+ *                                    | |
+ *                                    |_|
+ *            PlotSquared plot management system for Minecraft
+ *                  Copyright (C) 2021 IntellectualSites
+ *
+ *     This program is free software: you can redistribute it and/or modify
+ *     it under the terms of the GNU 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 General Public License for more details.
+ *
+ *     You should have received a copy of the GNU General Public License
+ *     along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package com.plotsquared.bukkit;
+
+import com.plotsquared.bukkit.util.BukkitUtil;
+import com.plotsquared.core.command.MainCommand;
+import com.plotsquared.core.player.ConsolePlayer;
+import com.plotsquared.core.player.PlotPlayer;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandExecutor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.command.ConsoleCommandSender;
+import org.bukkit.command.ProxiedCommandSender;
+import org.bukkit.command.RemoteConsoleCommandSender;
+import org.bukkit.command.TabCompleter;
+import org.bukkit.entity.Player;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.List;
+
+public class BukkitCommand implements CommandExecutor, TabCompleter {
+
+    @Override
+    public boolean onCommand(CommandSender commandSender, Command command, String commandLabel,
+        String[] args) {
+        if (commandSender instanceof Player) {
+            return MainCommand.onCommand(BukkitUtil.getPlayer((Player) commandSender), args);
+        }
+        if (commandSender instanceof ConsoleCommandSender
+            || commandSender instanceof ProxiedCommandSender
+            || commandSender instanceof RemoteConsoleCommandSender) {
+            return MainCommand.onCommand(ConsolePlayer.getConsole(), args);
+        }
+        return false;
+    }
+
+    @Override
+    public List<String> onTabComplete(CommandSender commandSender, Command command, String s,
+        String[] args) {
+        if (!(commandSender instanceof Player)) {
+            return null;
+        }
+        PlotPlayer player = BukkitUtil.getPlayer((Player) commandSender);
+        if (args.length == 0) {
+            return Collections.singletonList("plots");
+        }
+        Collection<com.plotsquared.core.command.Command> objects =
+            MainCommand.getInstance().tab(player, args, s.endsWith(" "));
+        if (objects == null) {
+            return null;
+        }
+        List<String> result = new ArrayList<>();
+        for (com.plotsquared.core.command.Command o : objects) {
+            result.add(o.toString());
+        }
+        return result;
+    }
+}

Bukkit/src/main/java/com/plotsquared/bukkit/chat/ArrayWrapper.java

@@ -0,0 +1,132 @@
+/*
+ *       _____  _       _    _____                                _
+ *      |  __ \| |     | |  / ____|                              | |
+ *      | |__) | | ___ | |_| (___   __ _ _   _  __ _ _ __ ___  __| |
+ *      |  ___/| |/ _ \| __|\___ \ / _` | | | |/ _` | '__/ _ \/ _` |
+ *      | |    | | (_) | |_ ____) | (_| | |_| | (_| | | |  __/ (_| |
+ *      |_|    |_|\___/ \__|_____/ \__, |\__,_|\__,_|_|  \___|\__,_|
+ *                                    | |
+ *                                    |_|
+ *            PlotSquared plot management system for Minecraft
+ *                  Copyright (C) 2021 IntellectualSites
+ *
+ *     This program is free software: you can redistribute it and/or modify
+ *     it under the terms of the GNU 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 General Public License for more details.
+ *
+ *     You should have received a copy of the GNU General Public License
+ *     along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package com.plotsquared.bukkit.chat;
+
+import org.apache.commons.lang.Validate;
+
+import java.lang.reflect.Array;
+import java.util.Arrays;
+import java.util.Collection;
+
+/**
+ * Represents a wrapper around an array class of an arbitrary reference type,
+ * which properly implements "value" hash code and equality functions.
+ * <p>
+ * This class is intended for use as a key to a map.
+ * </p>
+ *
+ * @param <E> The type of elements in the array.
+ * @author Glen Husman
+ * @see Arrays
+ */
+public final class ArrayWrapper<E> {
+
+    private E[] _array;
+
+    /**
+     * Creates an array wrapper with some elements.
+     *
+     * @param elements The elements of the array.
+     */
+    public ArrayWrapper(E... elements) {
+        setArray(elements);
+    }
+
+    /**
+     * Converts an iterable element collection to an array of elements.
+     * The iteration order of the specified object will be used as the array element order.
+     *
+     * @param list The iterable of objects which will be converted to an array.
+     * @param c    The type of the elements of the array.
+     * @return An array of elements in the specified iterable.
+     */
+    @SuppressWarnings("unchecked") public static <T> T[] toArray(Iterable<? extends T> list,
+        Class<T> c) {
+        int size = -1;
+        if (list instanceof Collection<?>) {
+            @SuppressWarnings("rawtypes") Collection coll = (Collection) list;
+            size = coll.size();
+        }
+
+
+        if (size < 0) {
+            size = 0;
+            // Ugly hack: Count it ourselves
+            for (@SuppressWarnings("unused") T element : list) {
+                size++;
+            }
+        }
+
+        T[] result = (T[]) Array.newInstance(c, size);
+        int i = 0;
+        for (T element : list) { // Assumes iteration order is consistent
+            result[i++] = element; // Assign array element at index THEN increment counter
+        }
+        return result;
+    }
+
+    /**
+     * Retrieves a reference to the wrapped array instance.
+     *
+     * @return The array wrapped by this instance.
+     */
+    public E[] getArray() {
+        return _array;
+    }
+
+    /**
+     * Set this wrapper to wrap a new array instance.
+     *
+     * @param array The new wrapped array.
+     */
+    public void setArray(E[] array) {
+        Validate.notNull(array, "The array must not be null.");
+        _array = array;
+    }
+
+    /**
+     * Determines if this object has a value equivalent to another object.
+     *
+     * @see Arrays#equals(Object[], Object[])
+     */
+    @SuppressWarnings("rawtypes") @Override public boolean equals(Object other) {
+        if (!(other instanceof ArrayWrapper)) {
+            return false;
+        }
+        return Arrays.equals(_array, ((ArrayWrapper) other)._array);
+    }
+
+    /**
+     * Gets the hash code represented by this objects value.
+     *
+     * @return This object's hash code.
+     * @see Arrays#hashCode(Object[])
+     */
+    @Override public int hashCode() {
+        return Arrays.hashCode(_array);
+    }
+
+}

Bukkit/src/main/java/com/plotsquared/bukkit/chat/FancyMessage.java

@@ -0,0 +1,944 @@
+/*
+ *       _____  _       _    _____                                _
+ *      |  __ \| |     | |  / ____|                              | |
+ *      | |__) | | ___ | |_| (___   __ _ _   _  __ _ _ __ ___  __| |
+ *      |  ___/| |/ _ \| __|\___ \ / _` | | | |/ _` | '__/ _ \/ _` |
+ *      | |    | | (_) | |_ ____) | (_| | |_| | (_| | | |  __/ (_| |
+ *      |_|    |_|\___/ \__|_____/ \__, |\__,_|\__,_|_|  \___|\__,_|
+ *                                    | |
+ *                                    |_|
+ *            PlotSquared plot management system for Minecraft
+ *                  Copyright (C) 2021 IntellectualSites
+ *
+ *     This program is free software: you can redistribute it and/or modify
+ *     it under the terms of the GNU 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 General Public License for more details.
+ *
+ *     You should have received a copy of the GNU General Public License
+ *     along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package com.plotsquared.bukkit.chat;
+
+import com.google.gson.JsonArray;
+import com.google.gson.JsonElement;
+import com.google.gson.JsonObject;
+import com.google.gson.JsonParser;
+import com.google.gson.stream.JsonWriter;
+import org.bukkit.Bukkit;
+import org.bukkit.ChatColor;
+import org.bukkit.Material;
+import org.bukkit.Statistic;
+import org.bukkit.Statistic.Type;
+import org.bukkit.command.CommandSender;
+import org.bukkit.configuration.serialization.ConfigurationSerializable;
+import org.bukkit.configuration.serialization.ConfigurationSerialization;
+import org.bukkit.entity.EntityType;
+import org.bukkit.entity.Player;
+import org.bukkit.inventory.ItemStack;
+
+import java.io.IOException;
+import java.io.StringWriter;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Field;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.UUID;
+import java.util.logging.Level;
+
+/**
+ * Represents a formattable message. Such messages can use elements such as colors, formatting codes, hover and click data, and other features provided by the vanilla Minecraft <a href="http://minecraft.gamepedia.com/Tellraw#Raw_JSON_Text">JSON message formatter</a>.
+ * This class allows plugins to emulate the functionality of the vanilla Minecraft <a href="http://minecraft.gamepedia.com/Commands#tellraw">tellraw command</a>.
+ * <p>
+ * This class follows the builder pattern, allowing for method chaining.
+ * It is set up such that invocations of property-setting methods will affect the current editing component,
+ * and a call to {@link #then()} or {@link #then(String)} will append a new editing component to the end of the message,
+ * optionally initializing it with text. Further property-setting method calls will affect that editing component.
+ * </p>
+ */
+public class FancyMessage
+    implements JsonRepresentedObject, Cloneable, Iterable<MessagePart>, ConfigurationSerializable {
+
+    private static Constructor<?> nmsPacketPlayOutChatConstructor;
+    // The ChatSerializer's instance of Gson
+    private static Object nmsChatSerializerGsonInstance;
+    private static Object chatMessageType;
+    private static Method fromJsonMethod;
+    private static JsonParser _stringParser = new JsonParser();
+
+    static {
+        ConfigurationSerialization.registerClass(FancyMessage.class);
+    }
+
+    private List<MessagePart> messageParts;
+    private String jsonString;
+    private boolean dirty;
+
+    /**
+     * Creates a JSON message with text.
+     *
+     * @param firstPartText The existing text in the message.
+     */
+    public FancyMessage(final String firstPartText) {
+        this(TextualComponent.rawText(firstPartText));
+    }
+
+    private FancyMessage(final TextualComponent firstPartText) {
+        messageParts = new ArrayList<>();
+        messageParts.add(new MessagePart(firstPartText));
+        jsonString = null;
+        dirty = false;
+        if (nmsPacketPlayOutChatConstructor == null) {
+            try {
+                Class<?> componentClass = Reflection.getNMSClass("IChatBaseComponent");
+                if (!Reflection.getVersion().startsWith("v1_16")) { // < 1.16 TODO needs to be fixed before 1.17 :P
+                    nmsPacketPlayOutChatConstructor = Reflection.getNMSClass("PacketPlayOutChat")
+                            .getDeclaredConstructor(componentClass);
+                } else {
+                    Class<Enum> chatMessageTypeClass = (Class<Enum>) Reflection.getNMSClass("ChatMessageType");
+                    nmsPacketPlayOutChatConstructor = Reflection.getNMSClass("PacketPlayOutChat")
+                            .getDeclaredConstructor(componentClass, chatMessageTypeClass, UUID.class);
+                    chatMessageType = Enum.valueOf(chatMessageTypeClass, "SYSTEM");
+                }
+                nmsPacketPlayOutChatConstructor.setAccessible(true);
+            } catch (NoSuchMethodException e) {
+                Bukkit.getLogger()
+                    .log(Level.SEVERE, "Could not find Minecraft method or constructor.", e);
+            } catch (SecurityException e) {
+                Bukkit.getLogger().log(Level.WARNING, "Could not access constructor.", e);
+            }
+        }
+    }
+
+    /**
+     * Creates a JSON message without text.
+     */
+    public FancyMessage() {
+        this((TextualComponent) null);
+    }
+
+    /**
+     * Deserializes a JSON-represented message from a mapping of key-value pairs.
+     * This is called by the Bukkit serialization API.
+     * It is not intended for direct public API consumption.
+     *
+     * @param serialized The key-value mapping which represents a fancy message.
+     */
+    @SuppressWarnings("unchecked") public static FancyMessage deserialize(
+        Map<String, Object> serialized) {
+        FancyMessage msg = new FancyMessage();
+        msg.messageParts = (List<MessagePart>) serialized.get("messageParts");
+        msg.jsonString = serialized.containsKey("JSON") ? serialized.get("JSON").toString() : null;
+        msg.dirty = !serialized.containsKey("JSON");
+        return msg;
+    }
+
+    /**
+     * Deserializes a fancy message from its JSON representation. This JSON representation is of the format of
+     * that returned by {@link #toJSONString()}, and is compatible with vanilla inputs.
+     *
+     * @param json The JSON string which represents a fancy message.
+     * @return A {@code FancyMessage} representing the parameterized JSON message.
+     */
+    public static FancyMessage deserialize(String json) {
+        JsonObject serialized = _stringParser.parse(json).getAsJsonObject();
+        JsonArray extra = serialized.getAsJsonArray("extra"); // Get the extra component
+        FancyMessage returnVal = new FancyMessage();
+        returnVal.messageParts.clear();
+        for (JsonElement mPrt : extra) {
+            MessagePart component = new MessagePart();
+            JsonObject messagePart = mPrt.getAsJsonObject();
+            for (Map.Entry<String, JsonElement> entry : messagePart.entrySet()) {
+                // Deserialize text
+                if (TextualComponent.isTextKey(entry.getKey())) {
+                    // The map mimics the YAML serialization, which has a "key" field and one or more "value" fields
+                    Map<String, Object> serializedMapForm =
+                        new HashMap<>(); // Must be object due to Bukkit serializer API compliance
+                    serializedMapForm.put("key", entry.getKey());
+                    if (entry.getValue().isJsonPrimitive()) {
+                        // Assume string
+                        serializedMapForm.put("value", entry.getValue().getAsString());
+                    } else {
+                        // Composite object, but we assume each element is a string
+                        for (Map.Entry<String, JsonElement> compositeNestedElement : entry
+                            .getValue().getAsJsonObject().entrySet()) {
+                            serializedMapForm.put("value." + compositeNestedElement.getKey(),
+                                compositeNestedElement.getValue().getAsString());
+                        }
+                    }
+                    component.text = TextualComponent.deserialize(serializedMapForm);
+                } else if (MessagePart.stylesToNames.inverse().containsKey(entry.getKey())) {
+                    if (entry.getValue().getAsBoolean()) {
+                        component.styles
+                            .add(MessagePart.stylesToNames.inverse().get(entry.getKey()));
+                    }
+                } else if (entry.getKey().equals("color")) {
+                    component.color =
+                        ChatColor.valueOf(entry.getValue().getAsString().toUpperCase());
+                } else if (entry.getKey().equals("clickEvent")) {
+                    JsonObject object = entry.getValue().getAsJsonObject();
+                    component.clickActionName = object.get("action").getAsString();
+                    component.clickActionData = object.get("value").getAsString();
+                } else if (entry.getKey().equals("hoverEvent")) {
+                    JsonObject object = entry.getValue().getAsJsonObject();
+                    component.hoverActionName = object.get("action").getAsString();
+                    if (object.get("value").isJsonPrimitive()) {
+                        // Assume string
+                        component.hoverActionData =
+                            new JsonString(object.get("value").getAsString());
+                    } else {
+                        // Assume composite type
+                        // The only composite type we currently store is another FancyMessage
+                        // Therefore, recursion time!
+                        component.hoverActionData = deserialize(object.get("value")
+                            .toString() /* This should properly serialize the JSON object as a JSON string */);
+                    }
+                } else if (entry.getKey().equals("insertion")) {
+                    component.insertionData = entry.getValue().getAsString();
+                } else if (entry.getKey().equals("with")) {
+                    for (JsonElement object : entry.getValue().getAsJsonArray()) {
+                        if (object.isJsonPrimitive()) {
+                            component.translationReplacements
+                                .add(new JsonString(object.getAsString()));
+                        } else {
+                            // Only composite type stored in this array is - again - FancyMessages
+                            // Recurse within this function to parse this as a translation replacement
+                            component.translationReplacements.add(deserialize(object.toString()));
+                        }
+                    }
+                }
+            }
+            returnVal.messageParts.add(component);
+        }
+        return returnVal;
+    }
+
+    @Override public FancyMessage clone() throws CloneNotSupportedException {
+        FancyMessage instance = (FancyMessage) super.clone();
+        instance.messageParts = new ArrayList<>(messageParts.size());
+        for (int i = 0; i < messageParts.size(); i++) {
+            instance.messageParts.add(i, messageParts.get(i).clone());
+        }
+        instance.dirty = false;
+        instance.jsonString = null;
+        return instance;
+    }
+
+    /**
+     * Sets the text of the current editing component to a value.
+     *
+     * @param text The new text of the current editing component.
+     * @return This builder instance.
+     */
+    public FancyMessage text(String text) {
+        MessagePart latest = latest();
+        latest.text = TextualComponent.rawText(text);
+        dirty = true;
+        return this;
+    }
+
+    /**
+     * Sets the text of the current editing component to a value.
+     *
+     * @param text The new text of the current editing component.
+     * @return This builder instance.
+     */
+    public FancyMessage text(TextualComponent text) {
+        MessagePart latest = latest();
+        latest.text = text;
+        dirty = true;
+        return this;
+    }
+
+    /**
+     * Sets the color of the current editing component to a value.
+     *
+     * @param color The new color of the current editing component.
+     * @return This builder instance.
+     * @throws IllegalArgumentException If the specified {@code ChatColor} enumeration value is not a color (but a format value).
+     */
+    public FancyMessage color(final ChatColor color) {
+        if (!color.isColor()) {
+            throw new IllegalArgumentException(color.name() + " is not a color");
+        }
+        latest().color = color;
+        dirty = true;
+        return this;
+    }
+
+    /**
+     * Sets the stylization of the current editing component.
+     *
+     * @param styles The array of styles to apply to the editing component.
+     * @return This builder instance.
+     * @throws IllegalArgumentException If any of the enumeration values in the array do not represent formatters.
+     */
+    public FancyMessage style(ChatColor... styles) {
+        for (final ChatColor style : styles) {
+            if (!style.isFormat()) {
+                throw new IllegalArgumentException(style.name() + " is not a style");
+            }
+        }
+        latest().styles.addAll(Arrays.asList(styles));
+        dirty = true;
+        return this;
+    }
+
+    /**
+     * Set the behavior of the current editing component to instruct the client to open a file on the client side filesystem when the currently edited part of the {@code FancyMessage} is clicked.
+     *
+     * @param path The path of the file on the client filesystem.
+     * @return This builder instance.
+     */
+    public FancyMessage file(final String path) {
+        onClick("open_file", path);
+        return this;
+    }
+
+    /**
+     * Set the behavior of the current editing component to instruct the client to open a webpage in the client's web browser when the currently edited part of the {@code FancyMessage} is clicked.
+     *
+     * @param url The URL of the page to open when the link is clicked.
+     * @return This builder instance.
+     */
+    public FancyMessage link(final String url) {
+        onClick("open_url", url);
+        return this;
+    }
+
+    /**
+     * Set the behavior of the current editing component to instruct the client to replace the chat input box content with the specified string when the currently edited part of the {@code FancyMessage} is clicked.
+     * The client will not immediately send the command to the server to be executed unless the client player submits the command/chat message, usually with the enter key.
+     *
+     * @param command The text to display in the chat bar of the client.
+     * @return This builder instance.
+     */
+    public FancyMessage suggest(final String command) {
+        onClick("suggest_command", command);
+        return this;
+    }
+
+    /**
+     * Set the behavior of the current editing component to instruct the client to append the chat input box content with the specified string when the currently edited part of the {@code FancyMessage} is SHIFT-CLICKED.
+     * The client will not immediately send the command to the server to be executed unless the client player submits the command/chat message, usually with the enter key.
+     *
+     * @param command The text to append to the chat bar of the client.
+     * @return This builder instance.
+     */
+    public FancyMessage insert(final String command) {
+        latest().insertionData = command;
+        dirty = true;
+        return this;
+    }
+
+    /**
+     * Set the behavior of the current editing component to instruct the client to send the specified string to the server as a chat message when the currently edited part of the {@code FancyMessage} is clicked.
+     * The client <b>will</b> immediately send the command to the server to be executed when the editing component is clicked.
+     *
+     * @param command The text to display in the chat bar of the client.
+     * @return This builder instance.
+     */
+    public FancyMessage command(final String command) {
+        onClick("run_command", command);
+        return this;
+    }
+
+    /**
+     * Set the behavior of the current editing component to display information about an achievement when the client hovers over the text.
+     * <p>Tooltips do not inherit display characteristics, such as color and styles, from the message component on which they are applied.</p>
+     *
+     * @param name The name of the achievement to display, excluding the "achievement." prefix.
+     * @return This builder instance.
+     */
+    public FancyMessage achievementTooltip(final String name) {
+        onHover("show_achievement", new JsonString("achievement." + name));
+        return this;
+    }
+
+    /**
+     * Set the behavior of the current editing component to display information about a parameterless statistic when the client hovers over the text.
+     * <p>Tooltips do not inherit display characteristics, such as color and styles, from the message component on which they are applied.</p>
+     *
+     * @param which The statistic to display.
+     * @return This builder instance.
+     * @throws IllegalArgumentException If the statistic requires a parameter which was not supplied.
+     */
+    public FancyMessage statisticTooltip(final Statistic which) {
+        Type type = which.getType();
+        if (type != Type.UNTYPED) {
+            throw new IllegalArgumentException(
+                "That statistic requires an additional " + type + " parameter!");
+        }
+        try {
+            Object statistic = Reflection
+                .getMethod(Reflection.getOBCClass("CraftStatistic"), "getNMSStatistic",
+                    Statistic.class).invoke(null, which);
+            return achievementTooltip(
+                (String) Reflection.getField(Reflection.getNMSClass("Statistic"), "name")
+                    .get(statistic));
+        } catch (IllegalAccessException e) {
+            Bukkit.getLogger().log(Level.WARNING, "Could not access method.", e);
+            return this;
+        } catch (IllegalArgumentException e) {
+            Bukkit.getLogger().log(Level.WARNING, "Argument could not be passed.", e);
+            return this;
+        } catch (InvocationTargetException e) {
+            Bukkit.getLogger()
+                .log(Level.WARNING, "A error has occurred during invoking of method.", e);
+            return this;
+        }
+    }
+
+    /**
+     * Set the behavior of the current editing component to display information about a statistic parameter with a material when the client hovers over the text.
+     * <p>Tooltips do not inherit display characteristics, such as color and styles, from the message component on which they are applied.</p>
+     *
+     * @param which The statistic to display.
+     * @param item  The sole material parameter to the statistic.
+     * @return This builder instance.
+     * @throws IllegalArgumentException If the statistic requires a parameter which was not supplied, or was supplied a parameter that was not required.
+     */
+    public FancyMessage statisticTooltip(final Statistic which, Material item) {
+        Type type = which.getType();
+        if (type == Type.UNTYPED) {
+            throw new IllegalArgumentException("That statistic needs no additional parameter!");
+        }
+        if ((type == Type.BLOCK && item.isBlock()) || type == Type.ENTITY) {
+            throw new IllegalArgumentException(
+                "Wrong parameter type for that statistic - needs " + type + "!");
+        }
+        try {
+            Object statistic = Reflection
+                .getMethod(Reflection.getOBCClass("CraftStatistic"), "getMaterialStatistic",
+                    Statistic.class, Material.class).invoke(null, which, item);
+            return achievementTooltip(
+                (String) Reflection.getField(Reflection.getNMSClass("Statistic"), "name")
+                    .get(statistic));
+        } catch (IllegalAccessException e) {
+            Bukkit.getLogger().log(Level.WARNING, "Could not access method.", e);
+            return this;
+        } catch (IllegalArgumentException e) {
+            Bukkit.getLogger().log(Level.WARNING, "Argument could not be passed.", e);
+            return this;
+        } catch (InvocationTargetException e) {
+            Bukkit.getLogger()
+                .log(Level.WARNING, "A error has occurred during invoking of method.", e);
+            return this;
+        }
+    }
+
+    /**
+     * Set the behavior of the current editing component to display information about a statistic parameter with an entity type when the client hovers over the text.
+     * <p>Tooltips do not inherit display characteristics, such as color and styles, from the message component on which they are applied.</p>
+     *
+     * @param which  The statistic to display.
+     * @param entity The sole entity type parameter to the statistic.
+     * @return This builder instance.
+     * @throws IllegalArgumentException If the statistic requires a parameter which was not supplied, or was supplied a parameter that was not required.
+     */
+    public FancyMessage statisticTooltip(final Statistic which, EntityType entity) {
+        Type type = which.getType();
+        if (type == Type.UNTYPED) {
+            throw new IllegalArgumentException("That statistic needs no additional parameter!");
+        }
+        if (type != Type.ENTITY) {
+            throw new IllegalArgumentException(
+                "Wrong parameter type for that statistic - needs " + type + "!");
+        }
+        try {
+            Object statistic = Reflection
+                .getMethod(Reflection.getOBCClass("CraftStatistic"), "getEntityStatistic",
+                    Statistic.class, EntityType.class).invoke(null, which, entity);
+            return achievementTooltip(
+                (String) Reflection.getField(Reflection.getNMSClass("Statistic"), "name")
+                    .get(statistic));
+        } catch (IllegalAccessException e) {
+            Bukkit.getLogger().log(Level.WARNING, "Could not access method.", e);
+            return this;
+        } catch (IllegalArgumentException e) {
+            Bukkit.getLogger().log(Level.WARNING, "Argument could not be passed.", e);
+            return this;
+        } catch (InvocationTargetException e) {
+            Bukkit.getLogger()
+                .log(Level.WARNING, "A error has occurred during invoking of method.", e);
+            return this;
+        }
+    }
+
+    /**
+     * Set the behavior of the current editing component to display information about an item when the client hovers over the text.
+     * <p>Tooltips do not inherit display characteristics, such as color and styles, from the message component on which they are applied.</p>
+     *
+     * @param itemJSON A string representing the JSON-serialized NBT data tag of an {@link ItemStack}.
+     * @return This builder instance.
+     */
+    public FancyMessage itemTooltip(final String itemJSON) {
+        onHover("show_item", new JsonString(
+            itemJSON)); // Seems a bit hacky, considering we have a JSON object as a parameter
+        return this;
+    }
+
+    /**
+     * Set the behavior of the current editing component to display information about an item when the client hovers over the text.
+     * <p>Tooltips do not inherit display characteristics, such as color and styles, from the message component on which they are applied.</p>
+     *
+     * @param itemStack The stack for which to display information.
+     * @return This builder instance.
+     */
+    public FancyMessage itemTooltip(final ItemStack itemStack) {
+        try {
+            Object nmsItem = Reflection
+                .getMethod(Reflection.getOBCClass("inventory.CraftItemStack"), "asNMSCopy",
+                    ItemStack.class).invoke(null, itemStack);
+            return itemTooltip(Reflection.getMethod(Reflection.getNMSClass("ItemStack"), "save",
+                Reflection.getNMSClass("NBTTagCompound"))
+                .invoke(nmsItem, Reflection.getNMSClass("NBTTagCompound").newInstance())
+                .toString());
+        } catch (Exception e) {
+            e.printStackTrace();
+            return this;
+        }
+    }
+
+    /**
+     * Set the behavior of the current editing component to display raw text when the client hovers over the text.
+     * <p>Tooltips do not inherit display characteristics, such as color and styles, from the message component on which they are applied.</p>
+     *
+     * @param text The text, which supports newlines, which will be displayed to the client upon hovering.
+     * @return This builder instance.
+     */
+    public FancyMessage tooltip(final String text) {
+        onHover("show_text", new JsonString(text));
+        return this;
+    }
+
+    /**
+     * Set the behavior of the current editing component to display raw text when the client hovers over the text.
+     * <p>Tooltips do not inherit display characteristics, such as color and styles, from the message component on which they are applied.</p>
+     *
+     * @param lines The lines of text which will be displayed to the client upon hovering. The iteration order of this object will be the order in which the lines of the tooltip are created.
+     * @return This builder instance.
+     */
+    public FancyMessage tooltip(final Iterable<String> lines) {
+        tooltip(ArrayWrapper.toArray(lines, String.class));
+        return this;
+    }
+    /*
+
+    /**
+     * If the text is a translatable key, and it has replaceable values, this function can be used to set the replacements that will be used in the message.
+     * @param replacements The replacements, in order, that will be used in the language-specific message.
+     * @return This builder instance.
+     */   /* ------------
+    public FancyMessage translationReplacements(final Iterable<? extends CharSequence> replacements){
+        for(CharSequence str : replacements){
+            latest().translationReplacements.add(new JsonString(str));
+        }
+
+        return this;
+    }
+
+    */
+
+    /**
+     * Set the behavior of the current editing component to display raw text when the client hovers over the text.
+     * <p>Tooltips do not inherit display characteristics, such as color and styles, from the message component on which they are applied.</p>
+     *
+     * @param lines The lines of text which will be displayed to the client upon hovering.
+     * @return This builder instance.
+     */
+    public FancyMessage tooltip(final String... lines) {
+        StringBuilder builder = new StringBuilder();
+        for (int i = 0; i < lines.length; i++) {
+            builder.append(lines[i]);
+            if (i != lines.length - 1) {
+                builder.append('\n');
+            }
+        }
+        tooltip(builder.toString());
+        return this;
+    }
+
+    /**
+     * Set the behavior of the current editing component to display formatted text when the client hovers over the text.
+     * <p>Tooltips do not inherit display characteristics, such as color and styles, from the message component on which they are applied.</p>
+     *
+     * @param text The formatted text which will be displayed to the client upon hovering.
+     * @return This builder instance.
+     */
+    public FancyMessage formattedTooltip(FancyMessage text) {
+        for (MessagePart component : text.messageParts) {
+            if (component.clickActionData != null && component.clickActionName != null) {
+                throw new IllegalArgumentException("The tooltip text cannot have click data.");
+            } else if (component.hoverActionData != null && component.hoverActionName != null) {
+                throw new IllegalArgumentException("The tooltip text cannot have a tooltip.");
+            }
+        }
+        onHover("show_text", text);
+        return this;
+    }
+
+    /**
+     * Set the behavior of the current editing component to display the specified lines of formatted text when the client hovers over the text.
+     * <p>Tooltips do not inherit display characteristics, such as color and styles, from the message component on which they are applied.</p>
+     *
+     * @param lines The lines of formatted text which will be displayed to the client upon hovering.
+     * @return This builder instance.
+     */
+    public FancyMessage formattedTooltip(FancyMessage... lines) {
+        if (lines.length < 1) {
+            onHover(null, null); // Clear tooltip
+            return this;
+        }
+
+        FancyMessage result = new FancyMessage();
+        result.messageParts
+            .clear(); // Remove the one existing text component that exists by default, which destabilizes the object
+
+        for (int i = 0; i < lines.length; i++) {
+            try {
+                for (MessagePart component : lines[i]) {
+                    if (component.clickActionData != null && component.clickActionName != null) {
+                        throw new IllegalArgumentException(
+                            "The tooltip text cannot have click data.");
+                    } else if (component.hoverActionData != null
+                        && component.hoverActionName != null) {
+                        throw new IllegalArgumentException(
+                            "The tooltip text cannot have a tooltip.");
+                    }
+                    if (component.hasText()) {
+                        result.messageParts.add(component.clone());
+                    }
+                }
+                if (i != lines.length - 1) {
+                    result.messageParts.add(new MessagePart(TextualComponent.rawText("\n")));
+                }
+            } catch (CloneNotSupportedException e) {
+                Bukkit.getLogger().log(Level.WARNING, "Failed to clone object", e);
+                return this;
+            }
+        }
+        return formattedTooltip(
+            result.messageParts.isEmpty() ? null : result); // Throws NPE if size is 0, intended
+    }
+
+    /**
+     * Set the behavior of the current editing component to display the specified lines of formatted text when the client hovers over the text.
+     * <p>Tooltips do not inherit display characteristics, such as color and styles, from the message component on which they are applied.</p>
+     *
+     * @param lines The lines of text which will be displayed to the client upon hovering. The iteration order of this object will be the order in which the lines of the tooltip are created.
+     * @return This builder instance.
+     */
+    public FancyMessage formattedTooltip(final Iterable<FancyMessage> lines) {
+        return formattedTooltip(ArrayWrapper.toArray(lines, FancyMessage.class));
+    }
+
+    /**
+     * If the text is a translatable key, and it has replaceable values, this function can be used to set the replacements that will be used in the message.
+     *
+     * @param replacements The replacements, in order, that will be used in the language-specific message.
+     * @return This builder instance.
+     */
+    public FancyMessage translationReplacements(final String... replacements) {
+        for (String str : replacements) {
+            latest().translationReplacements.add(new JsonString(str));
+        }
+        dirty = true;
+
+        return this;
+    }
+
+    /**
+     * If the text is a translatable key, and it has replaceable values, this function can be used to set the replacements that will be used in the message.
+     *
+     * @param replacements The replacements, in order, that will be used in the language-specific message.
+     * @return This builder instance.
+     */
+    public FancyMessage translationReplacements(final FancyMessage... replacements) {
+        Collections.addAll(latest().translationReplacements, replacements);
+
+        dirty = true;
+
+        return this;
+    }
+
+    /**
+     * If the text is a translatable key, and it has replaceable values, this function can be used to set the replacements that will be used in the message.
+     *
+     * @param replacements The replacements, in order, that will be used in the language-specific message.
+     * @return This builder instance.
+     */
+    public FancyMessage translationReplacements(final Iterable<FancyMessage> replacements) {
+        return translationReplacements(ArrayWrapper.toArray(replacements, FancyMessage.class));
+    }
+
+    /**
+     * Terminate construction of the current editing component, and begin construction of a new message component.
+     * After a successful call to this method, all setter methods will refer to a new message component, created as a result of the call to this method.
+     *
+     * @param text The text which will populate the new message component.
+     * @return This builder instance.
+     */
+    public FancyMessage then(final String text) {
+        return then(TextualComponent.rawText(text));
+    }
+
+    /**
+     * Terminate construction of the current editing component, and begin construction of a new message component.
+     * After a successful call to this method, all setter methods will refer to a new message component, created as a result of the call to this method.
+     *
+     * @param text The text which will populate the new message component.
+     * @return This builder instance.
+     */
+    public FancyMessage then(final TextualComponent text) {
+        if (!latest().hasText()) {
+            throw new IllegalStateException("previous message part has no text");
+        }
+        messageParts.add(new MessagePart(text));
+        dirty = true;
+        return this;
+    }
+
+    /**
+     * Terminate construction of the current editing component, and begin construction of a new message component.
+     * After a successful call to this method, all setter methods will refer to a new message component, created as a result of the call to this method.
+     *
+     * @return This builder instance.
+     */
+    public FancyMessage then() {
+        if (!latest().hasText()) {
+            throw new IllegalStateException("previous message part has no text");
+        }
+        messageParts.add(new MessagePart());
+        dirty = true;
+        return this;
+    }
+
+    @Override public void writeJson(JsonWriter writer) throws IOException {
+        if (messageParts.size() == 1) {
+            latest().writeJson(writer);
+        } else {
+            writer.beginObject().name("text").value("").name("extra").beginArray();
+            for (final MessagePart part : this) {
+                part.writeJson(writer);
+            }
+            writer.endArray().endObject();
+        }
+    }
+
+    /**
+     * Serialize this fancy message, converting it into syntactically-valid JSON using a {@link JsonWriter}.
+     * This JSON should be compatible with vanilla formatter commands such as {@code /tellraw}.
+     *
+     * @return The JSON string representing this object.
+     */
+    public String toJSONString() {
+        if (!dirty && jsonString != null) {
+            return jsonString;
+        }
+        StringWriter string = new StringWriter();
+        JsonWriter json = new JsonWriter(string);
+        try {
+            writeJson(json);
+            json.close();
+        } catch (IOException e) {
+            throw new RuntimeException("invalid message");
+        }
+        jsonString = string.toString();
+        dirty = false;
+        return jsonString;
+    }
+
+    /**
+     * Sends this message to a player. The player will receive the fully-fledged formatted display of this message.
+     *
+     * @param player The player who will receive the message.
+     */
+    public void send(Player player) {
+        send(player, toJSONString());
+    }
+
+    private void send(CommandSender sender, String jsonString) {
+        if (!(sender instanceof Player)) {
+            sender.sendMessage(toOldMessageFormat());
+            return;
+        }
+        Player player = (Player) sender;
+        try {
+            Object handle = Reflection.getHandle(player);
+            Object connection =
+                Reflection.getField(handle.getClass(), "playerConnection").get(handle);
+            Reflection
+                .getMethod(connection.getClass(), "sendPacket", Reflection.getNMSClass("Packet"))
+                .invoke(connection, createChatPacket(jsonString, ((Player) sender).getUniqueId()));
+        } catch (IllegalArgumentException e) {
+            Bukkit.getLogger().log(Level.WARNING, "Argument could not be passed.", e);
+        } catch (IllegalAccessException e) {
+            Bukkit.getLogger().log(Level.WARNING, "Could not access method.", e);
+        } catch (InstantiationException e) {
+            Bukkit.getLogger().log(Level.WARNING, "Underlying class is abstract.", e);
+        } catch (InvocationTargetException e) {
+            Bukkit.getLogger()
+                .log(Level.WARNING, "A error has occurred during invoking of method.", e);
+        } catch (NoSuchMethodException e) {
+            Bukkit.getLogger().log(Level.WARNING, "Could not find method.", e);
+        } catch (ClassNotFoundException e) {
+            Bukkit.getLogger().log(Level.WARNING, "Could not find class.", e);
+        }
+    }
+
+    private Object createChatPacket(String json, UUID receiver)
+        throws IllegalArgumentException, IllegalAccessException, InstantiationException,
+        InvocationTargetException, NoSuchMethodException, ClassNotFoundException {
+        if (nmsChatSerializerGsonInstance == null) {
+            // Find the field and its value, completely bypassing obfuscation
+            Class<?> chatSerializerClazz;
+
+            // Get the three parts of the version string (major version is currently unused)
+            // vX_Y_RZ
+            //   X = major
+            //   Y = minor
+            //   Z = revision
+            final String version = Reflection.getVersion();
+            String[] split =
+                version.substring(1, version.length() - 1).split("_"); // Remove trailing dot
+            //int majorVersion = Integer.parseInt(split[0]);
+            int minorVersion = Integer.parseInt(split[1]);
+            int revisionVersion = Integer.parseInt(split[2].substring(1)); // Substring to ignore R
+
+            if (minorVersion < 8 || (minorVersion == 8 && revisionVersion == 1)) {
+                chatSerializerClazz = Reflection.getNMSClass("ChatSerializer");
+            } else {
+                chatSerializerClazz = Reflection.getNMSClass("IChatBaseComponent$ChatSerializer");
+            }
+
+            if (chatSerializerClazz == null) {
+                throw new ClassNotFoundException("Can't find the ChatSerializer class");
+            }
+
+            for (Field declaredField : chatSerializerClazz.getDeclaredFields()) {
+                if (Modifier.isFinal(declaredField.getModifiers()) && Modifier
+                    .isStatic(declaredField.getModifiers()) && declaredField.getType().getName()
+                    .endsWith("Gson")) {
+                    // We've found our field
+                    declaredField.setAccessible(true);
+                    nmsChatSerializerGsonInstance = declaredField.get(null);
+                    fromJsonMethod = nmsChatSerializerGsonInstance.getClass()
+                        .getMethod("fromJson", String.class, Class.class);
+                    break;
+                }
+            }
+        }
+
+        // Since the method is so simple, and all the obfuscated methods have the same name, it's easier to reimplement 'IChatBaseComponent a(String)' than to reflectively call it
+        // Of course, the implementation may change, but fuzzy matches might break with signature changes
+        Object serializedChatComponent = fromJsonMethod.invoke(nmsChatSerializerGsonInstance, json,
+            Reflection.getNMSClass("IChatBaseComponent"));
+
+        if (!Reflection.getVersion().startsWith("v1_16")) {
+            return nmsPacketPlayOutChatConstructor.newInstance(serializedChatComponent);
+        } else {
+            return nmsPacketPlayOutChatConstructor.newInstance(serializedChatComponent, chatMessageType, receiver);
+        }
+    }
+
+    /**
+     * Sends this message to a command sender.
+     * If the sender is a player, they will receive the fully-fledged formatted display of this message.
+     * Otherwise, they will receive a version of this message with less formatting.
+     *
+     * @param sender The command sender who will receive the message.
+     * @see #toOldMessageFormat()
+     */
+    public void send(CommandSender sender) {
+        send(sender, toJSONString());
+    }
+
+    /**
+     * Sends this message to multiple command senders.
+     *
+     * @param senders The command senders who will receive the message.
+     * @see #send(CommandSender)
+     */
+    public void send(final Iterable<? extends CommandSender> senders) {
+        String string = toJSONString();
+        for (final CommandSender sender : senders) {
+            send(sender, string);
+        }
+    }
+
+    /**
+     * Convert this message to a human-readable string with limited formatting.
+     * This method is used to send this message to clients without JSON formatting support.
+     * <p>
+     * Serialization of this message by using this message will include (in this order for each message part):
+     * <ol>
+     * <li>The color of each message part.</li>
+     * <li>The applicable stylizations for each message part.</li>
+     * <li>The core text of the message part.</li>
+     * </ol>
+     * The primary omissions are tooltips and clickable actions. Consequently, this method should be used only as a last resort.
+     * <p>
+     * Color and formatting can be removed from the returned string by using {@link ChatColor#stripColor(String)}.</p>
+     *
+     * @return A human-readable string representing limited formatting in addition to the core text of this message.
+     */
+    public String toOldMessageFormat() {
+        StringBuilder result = new StringBuilder();
+        for (MessagePart part : this) {
+            result.append(part.color == null ? "" : part.color);
+            for (ChatColor formatSpecifier : part.styles) {
+                result.append(formatSpecifier);
+            }
+            result.append(part.text);
+        }
+        return result.toString();
+    }
+
+    private MessagePart latest() {
+        return messageParts.get(messageParts.size() - 1);
+    }
+
+    private void onClick(final String name, final String data) {
+        final MessagePart latest = latest();
+        latest.clickActionName = name;
+        latest.clickActionData = data;
+        dirty = true;
+    }
+
+    private void onHover(final String name, final JsonRepresentedObject data) {
+        final MessagePart latest = latest();
+        latest.hoverActionName = name;
+        latest.hoverActionData = data;
+        dirty = true;
+    }
+
+    // Doc copied from interface
+    public Map<String, Object> serialize() {
+        HashMap<String, Object> map = new HashMap<>();
+        map.put("messageParts", messageParts);
+        //		map.put("JSON", toJSONString());
+        return map;
+    }
+
+    /**
+     * <b>Internally called method. Not for API consumption.</b>
+     */
+    public Iterator<MessagePart> iterator() {
+        return messageParts.iterator();
+    }
+
+}

Bukkit/src/main/java/com/plotsquared/bukkit/chat/JsonRepresentedObject.java

@@ -0,0 +1,45 @@
+/*
+ *       _____  _       _    _____                                _
+ *      |  __ \| |     | |  / ____|                              | |
+ *      | |__) | | ___ | |_| (___   __ _ _   _  __ _ _ __ ___  __| |
+ *      |  ___/| |/ _ \| __|\___ \ / _` | | | |/ _` | '__/ _ \/ _` |
+ *      | |    | | (_) | |_ ____) | (_| | |_| | (_| | | |  __/ (_| |
+ *      |_|    |_|\___/ \__|_____/ \__, |\__,_|\__,_|_|  \___|\__,_|
+ *                                    | |
+ *                                    |_|
+ *            PlotSquared plot management system for Minecraft
+ *                  Copyright (C) 2021 IntellectualSites
+ *
+ *     This program is free software: you can redistribute it and/or modify
+ *     it under the terms of the GNU 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 General Public License for more details.
+ *
+ *     You should have received a copy of the GNU General Public License
+ *     along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package com.plotsquared.bukkit.chat;
+
+import com.google.gson.stream.JsonWriter;
+
+import java.io.IOException;
+
+/**
+ * Represents an object that can be serialized to a JSON writer instance.
+ */
+interface JsonRepresentedObject {
+
+    /**
+     * Writes the JSON representation of this object to the specified writer.
+     *
+     * @param writer The JSON writer which will receive the object.
+     * @throws IOException If an error occurs writing to the stream.
+     */
+    public void writeJson(JsonWriter writer) throws IOException;
+
+}

Bukkit/src/main/java/com/plotsquared/bukkit/chat/JsonString.java

@@ -0,0 +1,70 @@
+/*
+ *       _____  _       _    _____                                _
+ *      |  __ \| |     | |  / ____|                              | |
+ *      | |__) | | ___ | |_| (___   __ _ _   _  __ _ _ __ ___  __| |
+ *      |  ___/| |/ _ \| __|\___ \ / _` | | | |/ _` | '__/ _ \/ _` |
+ *      | |    | | (_) | |_ ____) | (_| | |_| | (_| | | |  __/ (_| |
+ *      |_|    |_|\___/ \__|_____/ \__, |\__,_|\__,_|_|  \___|\__,_|
+ *                                    | |
+ *                                    |_|
+ *            PlotSquared plot management system for Minecraft
+ *                  Copyright (C) 2021 IntellectualSites
+ *
+ *     This program is free software: you can redistribute it and/or modify
+ *     it under the terms of the GNU 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 General Public License for more details.
+ *
+ *     You should have received a copy of the GNU General Public License
+ *     along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package com.plotsquared.bukkit.chat;
+
+import com.google.gson.stream.JsonWriter;
+import org.bukkit.configuration.serialization.ConfigurationSerializable;
+
+import java.io.IOException;
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * Represents a JSON string value.
+ * Writes by this object will not write name values nor begin/end objects in the JSON stream.
+ * All writes merely write the represented string value.
+ */
+final class JsonString implements JsonRepresentedObject, ConfigurationSerializable {
+
+    private String _value;
+
+    public JsonString(CharSequence value) {
+        _value = value == null ? null : value.toString();
+    }
+
+    public static JsonString deserialize(Map<String, Object> map) {
+        return new JsonString(map.get("stringValue").toString());
+    }
+
+    @Override public void writeJson(JsonWriter writer) throws IOException {
+        writer.value(getValue());
+    }
+
+    public String getValue() {
+        return _value;
+    }
+
+    public Map<String, Object> serialize() {
+        HashMap<String, Object> theSingleValue = new HashMap<String, Object>();
+        theSingleValue.put("stringValue", _value);
+        return theSingleValue;
+    }
+
+    @Override public String toString() {
+        return _value;
+    }
+
+}

Bukkit/src/main/java/com/plotsquared/bukkit/chat/MessagePart.java

@@ -0,0 +1,179 @@
+/*
+ *       _____  _       _    _____                                _
+ *      |  __ \| |     | |  / ____|                              | |
+ *      | |__) | | ___ | |_| (___   __ _ _   _  __ _ _ __ ___  __| |
+ *      |  ___/| |/ _ \| __|\___ \ / _` | | | |/ _` | '__/ _ \/ _` |
+ *      | |    | | (_) | |_ ____) | (_| | |_| | (_| | | |  __/ (_| |
+ *      |_|    |_|\___/ \__|_____/ \__, |\__,_|\__,_|_|  \___|\__,_|
+ *                                    | |
+ *                                    |_|
+ *            PlotSquared plot management system for Minecraft
+ *                  Copyright (C) 2021 IntellectualSites
+ *
+ *     This program is free software: you can redistribute it and/or modify
+ *     it under the terms of the GNU 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 General Public License for more details.
+ *
+ *     You should have received a copy of the GNU General Public License
+ *     along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package com.plotsquared.bukkit.chat;
+
+import com.google.common.collect.BiMap;
+import com.google.common.collect.ImmutableBiMap;
+import com.google.gson.stream.JsonWriter;
+import org.bukkit.Bukkit;
+import org.bukkit.ChatColor;
+import org.bukkit.configuration.serialization.ConfigurationSerializable;
+import org.bukkit.configuration.serialization.ConfigurationSerialization;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.logging.Level;
+
+/**
+ * Internal class: Represents a component of a JSON-serializable {@link FancyMessage}.
+ */
+final class MessagePart implements JsonRepresentedObject, ConfigurationSerializable, Cloneable {
+
+    static final BiMap<ChatColor, String> stylesToNames;
+
+    static {
+        ImmutableBiMap.Builder<ChatColor, String> builder = ImmutableBiMap.builder();
+        for (final ChatColor style : ChatColor.values()) {
+            if (!style.isFormat()) {
+                continue;
+            }
+
+            String styleName;
+            switch (style) {
+                case MAGIC:
+                    styleName = "obfuscated";
+                    break;
+                case UNDERLINE:
+                    styleName = "underlined";
+                    break;
+                default:
+                    styleName = style.name().toLowerCase();
+                    break;
+            }
+
+            builder.put(style, styleName);
+        }
+        stylesToNames = builder.build();
+    }
+
+    static {
+        ConfigurationSerialization.registerClass(MessagePart.class);
+    }
+
+    ChatColor color = ChatColor.WHITE;
+    ArrayList<ChatColor> styles = new ArrayList<>();
+    String clickActionName = null;
+    String clickActionData = null;
+    String hoverActionName = null;
+    JsonRepresentedObject hoverActionData = null;
+    TextualComponent text = null;
+    String insertionData = null;
+    ArrayList<JsonRepresentedObject> translationReplacements = new ArrayList<>();
+
+    MessagePart(final TextualComponent text) {
+        this.text = text;
+    }
+
+    MessagePart() {
+        this.text = null;
+    }
+
+    @SuppressWarnings("unchecked")
+    public static MessagePart deserialize(Map<String, Object> serialized) {
+        MessagePart part = new MessagePart((TextualComponent) serialized.get("text"));
+        part.styles = (ArrayList<ChatColor>) serialized.get("styles");
+        part.color = ChatColor.getByChar(serialized.get("color").toString());
+        part.hoverActionName = (String) serialized.get("hoverActionName");
+        part.hoverActionData = (JsonRepresentedObject) serialized.get("hoverActionData");
+        part.clickActionName = (String) serialized.get("clickActionName");
+        part.clickActionData = (String) serialized.get("clickActionData");
+        part.insertionData = (String) serialized.get("insertion");
+        part.translationReplacements =
+            (ArrayList<JsonRepresentedObject>) serialized.get("translationReplacements");
+        return part;
+    }
+
+    boolean hasText() {
+        return text != null;
+    }
+
+    @Override @SuppressWarnings("unchecked") public MessagePart clone()
+        throws CloneNotSupportedException {
+        MessagePart obj = (MessagePart) super.clone();
+        obj.styles = (ArrayList<ChatColor>) styles.clone();
+        if (hoverActionData instanceof JsonString) {
+            obj.hoverActionData = new JsonString(((JsonString) hoverActionData).getValue());
+        } else if (hoverActionData instanceof FancyMessage) {
+            obj.hoverActionData = ((FancyMessage) hoverActionData).clone();
+        }
+        obj.translationReplacements =
+            (ArrayList<JsonRepresentedObject>) translationReplacements.clone();
+        return obj;
+
+    }
+
+    public void writeJson(JsonWriter json) {
+        try {
+            json.beginObject();
+            text.writeJson(json);
+            json.name("color").value(color.name().toLowerCase());
+            for (final ChatColor style : styles) {
+                json.name(stylesToNames.get(style)).value(true);
+            }
+            if (clickActionName != null && clickActionData != null) {
+                json.name("clickEvent").beginObject().name("action").value(clickActionName)
+                    .name("value").value(clickActionData).endObject();
+            }
+            if (hoverActionName != null && hoverActionData != null) {
+                json.name("hoverEvent").beginObject().name("action").value(hoverActionName)
+                    .name("value");
+                hoverActionData.writeJson(json);
+                json.endObject();
+            }
+            if (insertionData != null) {
+                json.name("insertion").value(insertionData);
+            }
+            if (translationReplacements.size() > 0 && TextualComponent.isTranslatableText(text)) {
+                json.name("with").beginArray();
+                for (JsonRepresentedObject obj : translationReplacements) {
+                    obj.writeJson(json);
+                }
+                json.endArray();
+            }
+            json.endObject();
+        } catch (IOException e) {
+            Bukkit.getLogger()
+                .log(Level.WARNING, "A problem occurred during writing of JSON string", e);
+        }
+    }
+
+    public Map<String, Object> serialize() {
+        HashMap<String, Object> map = new HashMap<>();
+        map.put("text", text);
+        map.put("styles", styles);
+        map.put("color", color.getChar());
+        map.put("hoverActionName", hoverActionName);
+        map.put("hoverActionData", hoverActionData);
+        map.put("clickActionName", clickActionName);
+        map.put("clickActionData", clickActionData);
+        map.put("insertion", insertionData);
+        map.put("translationReplacements", translationReplacements);
+        return map;
+    }
+
+}

Bukkit/src/main/java/com/plotsquared/bukkit/chat/Reflection.java

@@ -0,0 +1,227 @@
+/*
+ *       _____  _       _    _____                                _
+ *      |  __ \| |     | |  / ____|                              | |
+ *      | |__) | | ___ | |_| (___   __ _ _   _  __ _ _ __ ___  __| |
+ *      |  ___/| |/ _ \| __|\___ \ / _` | | | |/ _` | '__/ _ \/ _` |
+ *      | |    | | (_) | |_ ____) | (_| | |_| | (_| | | |  __/ (_| |
+ *      |_|    |_|\___/ \__|_____/ \__, |\__,_|\__,_|_|  \___|\__,_|
+ *                                    | |
+ *                                    |_|
+ *            PlotSquared plot management system for Minecraft
+ *                  Copyright (C) 2021 IntellectualSites
+ *
+ *     This program is free software: you can redistribute it and/or modify
+ *     it under the terms of the GNU 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 General Public License for more details.
+ *
+ *     You should have received a copy of the GNU General Public License
+ *     along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package com.plotsquared.bukkit.chat;
+
+import org.bukkit.Bukkit;
+
+import java.lang.reflect.Field;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * A class containing static utility methods and caches which are intended as reflective conveniences.
+ * Unless otherwise noted, upon failure methods will return {@code null}.
+ */
+public final class Reflection {
+
+    /**
+     * Stores loaded classes from the {@code net.minecraft.server} package.
+     */
+    private static final Map<String, Class<?>> _loadedNMSClasses = new HashMap<>();
+    /**
+     * Stores loaded classes from the {@code org.bukkit.craftbukkit} package (and subpackages).
+     */
+    private static final Map<String, Class<?>> _loadedOBCClasses = new HashMap<>();
+    private static final Map<Class<?>, Map<String, Field>> _loadedFields = new HashMap<>();
+    /**
+     * Contains loaded methods in a cache.
+     * The map maps [types to maps of [method names to maps of [parameter types to method instances]]].
+     */
+    private static final Map<Class<?>, Map<String, Map<ArrayWrapper<Class<?>>, Method>>>
+        _loadedMethods = new HashMap<>();
+    private static String _versionString;
+
+    private Reflection() {
+    }
+
+    /**
+     * Gets the version string from the package name of the CraftBukkit server implementation.
+     * This is needed to bypass the JAR package name changing on each update.
+     *
+     * @return The version string of the OBC and NMS packages, <em>including the trailing dot</em>.
+     */
+    public synchronized static String getVersion() {
+        if (_versionString == null) {
+            String name = Bukkit.getServer().getClass().getPackage().getName();
+            _versionString = name.substring(name.lastIndexOf('.') + 1) + ".";
+        }
+
+        return _versionString;
+    }
+
+    /**
+     * Gets a {@link Class} object representing a type contained within the {@code net.minecraft.server} versioned package.
+     * The class instances returned by this method are cached, such that no lookup will be done twice (unless multiple threads are accessing this method simultaneously).
+     *
+     * @param className The name of the class, excluding the package, within NMS.
+     * @return The class instance representing the specified NMS class, or {@code null} if it could not be loaded.
+     */
+    public synchronized static Class<?> getNMSClass(String className) {
+        if (_loadedNMSClasses.containsKey(className)) {
+            return _loadedNMSClasses.get(className);
+        }
+
+        String fullName = "net.minecraft.server." + getVersion() + className;
+        Class<?> clazz;
+        try {
+            clazz = Class.forName(fullName);
+        } catch (ClassNotFoundException e) {
+            _loadedNMSClasses.put(className, null);
+            throw new RuntimeException(e);
+        }
+        _loadedNMSClasses.put(className, clazz);
+        return clazz;
+    }
+
+    /**
+     * Gets a {@link Class} object representing a type contained within the {@code org.bukkit.craftbukkit} versioned package.
+     * The class instances returned by this method are cached, such that no lookup will be done twice (unless multiple threads are accessing this method simultaneously).
+     *
+     * @param className The name of the class, excluding the package, within OBC. This name may contain a subpackage name, such as {@code inventory.CraftItemStack}.
+     * @return The class instance representing the specified OBC class, or {@code null} if it could not be loaded.
+     */
+    public synchronized static Class<?> getOBCClass(String className) {
+        if (_loadedOBCClasses.containsKey(className)) {
+            return _loadedOBCClasses.get(className);
+        }
+
+        String fullName = "org.bukkit.craftbukkit." + getVersion() + className;
+        Class<?> clazz;
+        try {
+            clazz = Class.forName(fullName);
+        } catch (ClassNotFoundException e) {
+            _loadedOBCClasses.put(className, null);
+            throw new RuntimeException(e);
+        }
+        _loadedOBCClasses.put(className, clazz);
+        return clazz;
+    }
+
+    /**
+     * Attempts to get the NMS handle of a CraftBukkit object.
+     * <p>
+     * The only match currently attempted by this method is a retrieval by using a parameterless {@code getHandle()} method implemented by the runtime type of the specified object.
+     * </p>
+     *
+     * @param obj The object for which to retrieve an NMS handle.
+     * @return The NMS handle of the specified object, or {@code null} if it could not be retrieved using {@code getHandle()}.
+     */
+    public synchronized static Object getHandle(Object obj)
+        throws InvocationTargetException, IllegalAccessException, IllegalArgumentException {
+        return getMethod(obj.getClass(), "getHandle").invoke(obj);
+    }
+
+    /**
+     * Retrieves a {@link Field} instance declared by the specified class with the specified name.
+     * Java access modifiers are ignored during this retrieval. No guarantee is made as to whether the field
+     * returned will be an instance or static field.
+     * <p>
+     * A global caching mechanism within this class is used to store fields. Combined with synchronization, this guarantees that
+     * no field will be reflectively looked up twice.
+     * </p>
+     * <p>
+     * If a field is deemed suitable for return, {@link Field#setAccessible(boolean) setAccessible} will be invoked with an argument of {@code true} before it is returned.
+     * This ensures that callers do not have to check or worry about Java access modifiers when dealing with the returned instance.
+     * </p>
+     *
+     * @param clazz The class which contains the field to retrieve.
+     * @param name  The declared name of the field in the class.
+     * @return A field object with the specified name declared by the specified class.
+     * @see Class#getDeclaredField(String)
+     */
+    public synchronized static Field getField(Class<?> clazz, String name) {
+        Map<String, Field> loaded;
+        if (!_loadedFields.containsKey(clazz)) {
+            loaded = new HashMap<>();
+            _loadedFields.put(clazz, loaded);
+        } else {
+            loaded = _loadedFields.get(clazz);
+        }
+        if (loaded.containsKey(name)) {
+            // If the field is loaded (or cached as not existing), return the relevant value, which might be null
+            return loaded.get(name);
+        }
+        try {
+            Field field = clazz.getDeclaredField(name);
+            field.setAccessible(true);
+            loaded.put(name, field);
+            return field;
+        } catch (NoSuchFieldException | SecurityException e) {
+            // Error loading
+            e.printStackTrace();
+            // Cache field as not existing
+            loaded.put(name, null);
+            return null;
+        }
+    }
+
+    /**
+     * Retrieves a {@link Method} instance declared by the specified class with the specified name and argument types.
+     * Java access modifiers are ignored during this retrieval. No guarantee is made as to whether the field
+     * returned will be an instance or static field.
+     * <p>
+     * A global caching mechanism within this class is used to store method. Combined with synchronization, this guarantees that
+     * no method will be reflectively looked up twice.
+     * <p>
+     * If a method is deemed suitable for return, {@link Method#setAccessible(boolean) setAccessible} will be invoked with an argument of {@code true} before it is returned.
+     * This ensures that callers do not have to check or worry about Java access modifiers when dealing with the returned instance.
+     * <p>
+     * This method does <em>not</em> search superclasses of the specified type for methods with the specified signature.
+     * Callers wishing this behavior should use {@link Class#getDeclaredMethod(String, Class...)}.
+     *
+     * @param clazz The class which contains the method to retrieve.
+     * @param name  The declared name of the method in the class.
+     * @param args  The formal argument types of the method.
+     * @return A method object with the specified name declared by the specified class.
+     */
+    public synchronized static Method getMethod(Class<?> clazz, String name, Class<?>... args) {
+        _loadedMethods.computeIfAbsent(clazz, k -> new HashMap<>());
+
+        Map<String, Map<ArrayWrapper<Class<?>>, Method>> loadedMethodNames =
+            _loadedMethods.get(clazz);
+        loadedMethodNames.computeIfAbsent(name, k -> new HashMap<>());
+
+        Map<ArrayWrapper<Class<?>>, Method> loadedSignatures = loadedMethodNames.get(name);
+        ArrayWrapper<Class<?>> wrappedArg = new ArrayWrapper<>(args);
+        if (loadedSignatures.containsKey(wrappedArg)) {
+            return loadedSignatures.get(wrappedArg);
+        }
+
+        for (Method m : clazz.getMethods()) {
+            if (m.getName().equals(name) && Arrays.equals(args, m.getParameterTypes())) {
+                m.setAccessible(true);
+                loadedSignatures.put(wrappedArg, m);
+                return m;
+            }
+        }
+        loadedSignatures.put(wrappedArg, null);
+        return null;
+    }
+
+}

Bukkit/src/main/java/com/plotsquared/bukkit/chat/TextualComponent.java

@@ -0,0 +1,338 @@
+/*
+ *       _____  _       _    _____                                _
+ *      |  __ \| |     | |  / ____|                              | |
+ *      | |__) | | ___ | |_| (___   __ _ _   _  __ _ _ __ ___  __| |
+ *      |  ___/| |/ _ \| __|\___ \ / _` | | | |/ _` | '__/ _ \/ _` |
+ *      | |    | | (_) | |_ ____) | (_| | |_| | (_| | | |  __/ (_| |
+ *      |_|    |_|\___/ \__|_____/ \__, |\__,_|\__,_|_|  \___|\__,_|
+ *                                    | |
+ *                                    |_|
+ *            PlotSquared plot management system for Minecraft
+ *                  Copyright (C) 2021 IntellectualSites
+ *
+ *     This program is free software: you can redistribute it and/or modify
+ *     it under the terms of the GNU 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 General Public License for more details.
+ *
+ *     You should have received a copy of the GNU General Public License
+ *     along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package com.plotsquared.bukkit.chat;
+
+import com.google.common.base.Preconditions;
+import com.google.common.collect.ImmutableMap;
+import com.google.gson.stream.JsonWriter;
+import org.bukkit.configuration.serialization.ConfigurationSerializable;
+import org.bukkit.configuration.serialization.ConfigurationSerialization;
+
+import java.io.IOException;
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * Represents a textual component of a message part.
+ * This can be used to not only represent string literals in a JSON message,
+ * but also to represent localized strings and other text values.
+ * <p>Different instances of this class can be created with static constructor methods.</p>
+ */
+public abstract class TextualComponent implements Cloneable {
+
+    static {
+        ConfigurationSerialization.registerClass(TextualComponent.ArbitraryTextTypeComponent.class);
+        ConfigurationSerialization.registerClass(TextualComponent.ComplexTextTypeComponent.class);
+    }
+
+    static TextualComponent deserialize(Map<String, Object> map) {
+        if (map.containsKey("key") && map.size() == 2 && map.containsKey("value")) {
+            // Arbitrary text component
+            return ArbitraryTextTypeComponent.deserialize(map);
+        } else if (map.size() >= 2 && map.containsKey("key") && !map
+            .containsKey("value") /* It contains keys that START WITH value */) {
+            // Complex JSON object
+            return ComplexTextTypeComponent.deserialize(map);
+        }
+
+        return null;
+    }
+
+    static boolean isTextKey(String key) {
+        return key.equals("translate") || key.equals("text") || key.equals("score") || key
+            .equals("selector");
+    }
+
+    static boolean isTranslatableText(TextualComponent component) {
+        return component instanceof ComplexTextTypeComponent && component.getKey()
+            .equals("translate");
+    }
+
+    /**
+     * Create a textual component representing a string literal.
+     *
+     * <p>This is the default type of textual component when a single string
+     * literal is given to a method.
+     *
+     * @param textValue The text which will be represented.
+     * @return The text component representing the specified literal text.
+     */
+    public static TextualComponent rawText(String textValue) {
+        return new ArbitraryTextTypeComponent("text", textValue);
+    }
+
+    /**
+     * Create a textual component representing a localized string.
+     * The client will see this text component as their localized version of the specified string <em>key</em>, which can be overridden by a
+     * resource pack.
+     * <p>
+     * If the specified translation key is not present on the client resource pack, the translation key will be displayed as a string literal to
+     * the client.
+     * </p>
+     *
+     * @param translateKey The string key which maps to localized text.
+     * @return The text component representing the specified localized text.
+     */
+    public static TextualComponent localizedText(String translateKey) {
+        return new ArbitraryTextTypeComponent("translate", translateKey);
+    }
+
+    private static void throwUnsupportedSnapshot() {
+        throw new UnsupportedOperationException(
+            "This feature is only supported in snapshot releases.");
+    }
+
+    /**
+     * Create a textual component representing a scoreboard value.
+     * The client will see their own score for the specified objective as the text represented by this component.
+     * <p>
+     * <b>This method is currently guaranteed to throw an {@code UnsupportedOperationException} as it is only supported on snapshot clients.</b>
+     * </p>
+     *
+     * @param scoreboardObjective The name of the objective for which to display the score.
+     * @return The text component representing the specified scoreboard score (for the viewing player), or {@code null} if an error occurs during
+     * JSON serialization.
+     */
+    public static TextualComponent objectiveScore(String scoreboardObjective) {
+        return objectiveScore("*", scoreboardObjective);
+    }
+
+    /**
+     * Create a textual component representing a scoreboard value.
+     * The client will see the score of the specified player for the specified objective as the text represented by this component.
+     *
+     * <p><b>This method is currently guaranteed to throw an {@code UnsupportedOperationException}
+     * as it is only supported on snapshot clients.</b>
+     *
+     * @param playerName          The name of the player whos score will be shown. If
+     *                            this string represents the single-character sequence
+     *                            "*", the viewing player's score will be displayed.
+     *                            Standard minecraft selectors (@a, @p, etc)
+     *                            are <em>not</em> supported.
+     * @param scoreboardObjective The name of the objective for
+     *                            which to display the score.
+     * @return The text component representing the specified scoreboard score
+     * for the specified player, or {@code null} if an error occurs during JSON serialization.
+     */
+    public static TextualComponent objectiveScore(String playerName, String scoreboardObjective) {
+        throwUnsupportedSnapshot(); // Remove this line when the feature is released to non-snapshot versions, in addition to updating ALL THE
+        // OVERLOADS documentation accordingly
+
+        return new ComplexTextTypeComponent("score",
+            ImmutableMap.<String, String>builder().put("name", playerName)
+                .put("objective", scoreboardObjective).build());
+    }
+
+    /**
+     * Create a textual component representing a player name, retrievable by using a standard minecraft selector.
+     * The client will see the players or entities captured by the specified selector as the text represented by this component.
+     * <p>
+     * <b>This method is currently guaranteed to throw an {@code UnsupportedOperationException} as it is only supported on snapshot clients.</b>
+     * </p>
+     *
+     * @param selector The minecraft player or entity selector which will capture the entities whose string representations will be displayed in
+     *                 the place of this text component.
+     * @return The text component representing the name of the entities captured by the selector.
+     */
+    public static TextualComponent selector(String selector) {
+        throwUnsupportedSnapshot(); // Remove this line when the feature is released to non-snapshot versions, in addition to updating ALL THE
+        // OVERLOADS documentation accordingly
+
+        return new ArbitraryTextTypeComponent("selector", selector);
+    }
+
+    @Override public String toString() {
+        return getReadableString();
+    }
+
+    /**
+     * @return The JSON key used to represent text components of this type.
+     */
+    public abstract String getKey();
+
+    /**
+     * @return A readable String
+     */
+    public abstract String getReadableString();
+
+    /**
+     * Clones a textual component instance.
+     * The returned object should not reference this textual component instance, but should maintain the same key and value.
+     */
+    @Override public abstract TextualComponent clone() throws CloneNotSupportedException;
+
+    /**
+     * Writes the text data represented by this textual component to the specified JSON writer object.
+     * A new object within the writer is not started.
+     *
+     * @param writer The object to which to write the JSON data.
+     * @throws IOException If an error occurs while writing to the stream.
+     */
+    public abstract void writeJson(JsonWriter writer) throws IOException;
+
+    /**
+     * Internal class used to represent all types of text components.
+     * Exception validating done is on keys and values.
+     */
+    private static final class ArbitraryTextTypeComponent extends TextualComponent
+        implements ConfigurationSerializable {
+
+        private String key;
+        private String value;
+
+        public ArbitraryTextTypeComponent(String key, String value) {
+            setKey(key);
+            setValue(value);
+        }
+
+        public static ArbitraryTextTypeComponent deserialize(Map<String, Object> map) {
+            return new ArbitraryTextTypeComponent(map.get("key").toString(),
+                map.get("value").toString());
+        }
+
+        @Override public String getKey() {
+            return key;
+        }
+
+        public void setKey(String key) {
+            Preconditions
+                .checkArgument(key != null && !key.isEmpty(), "The key must be specified.");
+            this.key = key;
+        }
+
+        public String getValue() {
+            return value;
+        }
+
+        public void setValue(String value) {
+            Preconditions.checkArgument(value != null, "The value must be specified.");
+            this.value = value;
+        }
+
+        @Override public TextualComponent clone() throws CloneNotSupportedException {
+            // Since this is a private and final class, we can just reinstantiate this class instead of casting super.clone
+            return new ArbitraryTextTypeComponent(getKey(), getValue());
+        }
+
+        @Override public void writeJson(JsonWriter writer) throws IOException {
+            writer.name(getKey()).value(getValue());
+        }
+
+        @Override @SuppressWarnings("serial") public Map<String, Object> serialize() {
+            return new HashMap<String, Object>() {
+                {
+                    put("key", getKey());
+                    put("value", getValue());
+                }
+            };
+        }
+
+        @Override public String getReadableString() {
+            return getValue();
+        }
+    }
+
+
+    /**
+     * Internal class used to represent a text component with a nested JSON
+     * value.
+     *
+     * <p>Exception validating done is on keys and values.
+     */
+    private static final class ComplexTextTypeComponent extends TextualComponent
+        implements ConfigurationSerializable {
+
+        private String key;
+        private Map<String, String> value;
+
+        public ComplexTextTypeComponent(String key, Map<String, String> values) {
+            setKey(key);
+            setValue(values);
+        }
+
+        public static ComplexTextTypeComponent deserialize(Map<String, Object> map) {
+            String key = null;
+            Map<String, String> value = new HashMap<>();
+            for (Map.Entry<String, Object> valEntry : map.entrySet()) {
+                if (valEntry.getKey().equals("key")) {
+                    key = (String) valEntry.getValue();
+                } else if (valEntry.getKey().startsWith("value.")) {
+                    value.put(valEntry.getKey().substring(6) /* Strips out the value prefix */,
+                        valEntry.getValue().toString());
+                }
+            }
+            return new ComplexTextTypeComponent(key, value);
+        }
+
+        @Override public String getKey() {
+            return key;
+        }
+
+        public void setKey(String key) {
+            Preconditions
+                .checkArgument(key != null && !key.isEmpty(), "The key must be specified.");
+            this.key = key;
+        }
+
+        public Map<String, String> getValue() {
+            return value;
+        }
+
+        public void setValue(Map<String, String> value) {
+            Preconditions.checkArgument(value != null, "The value must be specified.");
+            this.value = value;
+        }
+
+        @Override public TextualComponent clone() {
+            // Since this is a private and final class, we can just reinstantiate this class instead of casting super.clone
+            return new ComplexTextTypeComponent(getKey(), getValue());
+        }
+
+        @Override public void writeJson(JsonWriter writer) throws IOException {
+            writer.name(getKey());
+            writer.beginObject();
+            for (Map.Entry<String, String> jsonPair : value.entrySet()) {
+                writer.name(jsonPair.getKey()).value(jsonPair.getValue());
+            }
+            writer.endObject();
+        }
+
+        @Override @SuppressWarnings("serial") public Map<String, Object> serialize() {
+            return new java.util.HashMap<String, Object>() {
+                {
+                    put("key", getKey());
+                    for (Map.Entry<String, String> valEntry : getValue().entrySet()) {
+                        put("value." + valEntry.getKey(), valEntry.getValue());
+                    }
+                }
+            };
+        }
+
+        @Override public String getReadableString() {
+            return getKey();
+        }
+    }
+}

Bukkit/src/main/java/com/plotsquared/bukkit/entity/AgeableStats.java

@@ -0,0 +1,33 @@
+/*
+ *       _____  _       _    _____                                _
+ *      |  __ \| |     | |  / ____|                              | |
+ *      | |__) | | ___ | |_| (___   __ _ _   _  __ _ _ __ ___  __| |
+ *      |  ___/| |/ _ \| __|\___ \ / _` | | | |/ _` | '__/ _ \/ _` |
+ *      | |    | | (_) | |_ ____) | (_| | |_| | (_| | | |  __/ (_| |
+ *      |_|    |_|\___/ \__|_____/ \__, |\__,_|\__,_|_|  \___|\__,_|
+ *                                    | |
+ *                                    |_|
+ *            PlotSquared plot management system for Minecraft
+ *                  Copyright (C) 2021 IntellectualSites
+ *
+ *     This program is free software: you can redistribute it and/or modify
+ *     it under the terms of the GNU 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 General Public License for more details.
+ *
+ *     You should have received a copy of the GNU General Public License
+ *     along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package com.plotsquared.bukkit.entity;
+
+class AgeableStats {
+
+    int age;
+    boolean locked;
+    boolean adult;
+}

Bukkit/src/main/java/com/plotsquared/bukkit/entity/ArmorStandStats.java

@@ -0,0 +1,40 @@
+/*
+ *       _____  _       _    _____                                _
+ *      |  __ \| |     | |  / ____|                              | |
+ *      | |__) | | ___ | |_| (___   __ _ _   _  __ _ _ __ ___  __| |
+ *      |  ___/| |/ _ \| __|\___ \ / _` | | | |/ _` | '__/ _ \/ _` |
+ *      | |    | | (_) | |_ ____) | (_| | |_| | (_| | | |  __/ (_| |
+ *      |_|    |_|\___/ \__|_____/ \__, |\__,_|\__,_|_|  \___|\__,_|
+ *                                    | |
+ *                                    |_|
+ *            PlotSquared plot management system for Minecraft
+ *                  Copyright (C) 2021 IntellectualSites
+ *
+ *     This program is free software: you can redistribute it and/or modify
+ *     it under the terms of the GNU 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 General Public License for more details.
+ *
+ *     You should have received a copy of the GNU General Public License
+ *     along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package com.plotsquared.bukkit.entity;
+
+class ArmorStandStats {
+
+    final float[] head = new float[3];
+    final float[] body = new float[3];
+    final float[] leftLeg = new float[3];
+    final float[] rightLeg = new float[3];
+    final float[] leftArm = new float[3];
+    final float[] rightArm = new float[3];
+    boolean arms;
+    boolean noPlate;
+    boolean invisible;
+    boolean small;
+}

Bukkit/src/main/java/com/plotsquared/bukkit/entity/EntityBaseStats.java

@@ -0,0 +1,37 @@
+/*
+ *       _____  _       _    _____                                _
+ *      |  __ \| |     | |  / ____|                              | |
+ *      | |__) | | ___ | |_| (___   __ _ _   _  __ _ _ __ ___  __| |
+ *      |  ___/| |/ _ \| __|\___ \ / _` | | | |/ _` | '__/ _ \/ _` |
+ *      | |    | | (_) | |_ ____) | (_| | |_| | (_| | | |  __/ (_| |
+ *      |_|    |_|\___/ \__|_____/ \__, |\__,_|\__,_|_|  \___|\__,_|
+ *                                    | |
+ *                                    |_|
+ *            PlotSquared plot management system for Minecraft
+ *                  Copyright (C) 2021 IntellectualSites
+ *
+ *     This program is free software: you can redistribute it and/or modify
+ *     it under the terms of the GNU 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 General Public License for more details.
+ *
+ *     You should have received a copy of the GNU General Public License
+ *     along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package com.plotsquared.bukkit.entity;
+
+class EntityBaseStats {
+
+    EntityWrapper passenger;
+    float fall;
+    short fire;
+    int age;
+    double vZ;
+    double vY;
+    double vX;
+}

Bukkit/src/main/java/com/plotsquared/bukkit/entity/EntityWrapper.java

@@ -0,0 +1,66 @@
+/*
+ *       _____  _       _    _____                                _
+ *      |  __ \| |     | |  / ____|                              | |
+ *      | |__) | | ___ | |_| (___   __ _ _   _  __ _ _ __ ___  __| |
+ *      |  ___/| |/ _ \| __|\___ \ / _` | | | |/ _` | '__/ _ \/ _` |
+ *      | |    | | (_) | |_ ____) | (_| | |_| | (_| | | |  __/ (_| |
+ *      |_|    |_|\___/ \__|_____/ \__, |\__,_|\__,_|_|  \___|\__,_|
+ *                                    | |
+ *                                    |_|
+ *            PlotSquared plot management system for Minecraft
+ *                  Copyright (C) 2021 IntellectualSites
+ *
+ *     This program is free software: you can redistribute it and/or modify
+ *     it under the terms of the GNU 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 General Public License for more details.
+ *
+ *     You should have received a copy of the GNU General Public License
+ *     along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package com.plotsquared.bukkit.entity;
+
+import lombok.Getter;
+import lombok.NonNull;
+import org.bukkit.Location;
+import org.bukkit.World;
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.EntityType;
+
+@Getter
+public abstract class EntityWrapper {
+
+    protected final float yaw;
+    protected final float pitch;
+    private final Entity entity;
+    private final EntityType type;
+    public double x;
+    public double y;
+    public double z;
+
+    EntityWrapper(@NonNull final Entity entity) {
+        this.entity = entity;
+        this.type = entity.getType();
+
+        final Location location = entity.getLocation();
+        this.x = location.getX();
+        this.y = location.getY();
+        this.z = location.getZ();
+        this.yaw = location.getYaw();
+        this.pitch = location.getPitch();
+    }
+
+    @SuppressWarnings("deprecation") @Override public String toString() {
+        return String.format("[%s, x=%s, y=%s, z=%s]", type.getName(), x, y, z);
+    }
+
+    public abstract Entity spawn(World world, int xOffset, int zOffset);
+
+    public abstract void saveEntity();
+
+}

Bukkit/src/main/java/com/plotsquared/bukkit/entity/HorseStats.java

@@ -0,0 +1,37 @@
+/*
+ *       _____  _       _    _____                                _
+ *      |  __ \| |     | |  / ____|                              | |
+ *      | |__) | | ___ | |_| (___   __ _ _   _  __ _ _ __ ___  __| |
+ *      |  ___/| |/ _ \| __|\___ \ / _` | | | |/ _` | '__/ _ \/ _` |
+ *      | |    | | (_) | |_ ____) | (_| | |_| | (_| | | |  __/ (_| |
+ *      |_|    |_|\___/ \__|_____/ \__, |\__,_|\__,_|_|  \___|\__,_|
+ *                                    | |
+ *                                    |_|
+ *            PlotSquared plot management system for Minecraft
+ *                  Copyright (C) 2021 IntellectualSites
+ *
+ *     This program is free software: you can redistribute it and/or modify
+ *     it under the terms of the GNU 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 General Public License for more details.
+ *
+ *     You should have received a copy of the GNU General Public License
+ *     along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package com.plotsquared.bukkit.entity;
+
+import org.bukkit.entity.Horse;
+
+class HorseStats {
+
+    double jump;
+    boolean chest;
+    Horse.Variant variant;
+    Horse.Color color;
+    Horse.Style style;
+}

Bukkit/src/main/java/com/plotsquared/bukkit/entity/LivingEntityStats.java

@@ -0,0 +1,53 @@
+/*
+ *       _____  _       _    _____                                _
+ *      |  __ \| |     | |  / ____|                              | |
+ *      | |__) | | ___ | |_| (___   __ _ _   _  __ _ _ __ ___  __| |
+ *      |  ___/| |/ _ \| __|\___ \ / _` | | | |/ _` | '__/ _ \/ _` |
+ *      | |    | | (_) | |_ ____) | (_| | |_| | (_| | | |  __/ (_| |
+ *      |_|    |_|\___/ \__|_____/ \__, |\__,_|\__,_|_|  \___|\__,_|
+ *                                    | |
+ *                                    |_|
+ *            PlotSquared plot management system for Minecraft
+ *                  Copyright (C) 2021 IntellectualSites
+ *
+ *     This program is free software: you can redistribute it and/or modify
+ *     it under the terms of the GNU 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 General Public License for more details.
+ *
+ *     You should have received a copy of the GNU General Public License
+ *     along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package com.plotsquared.bukkit.entity;
+
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.potion.PotionEffect;
+
+import java.util.Collection;
+
+class LivingEntityStats {
+
+    boolean loot;
+    String name;
+    boolean visible;
+    float health;
+    short air;
+    boolean persistent;
+    boolean leashed;
+    short leashX;
+    short leashY;
+    short leashZ;
+    boolean equipped;
+    ItemStack mainHand;
+    ItemStack helmet;
+    ItemStack boots;
+    ItemStack leggings;
+    ItemStack chestplate;
+    Collection<PotionEffect> potions;
+    ItemStack offHand;
+}

Bukkit/src/main/java/com/plotsquared/bukkit/entity/ReplicatingEntityWrapper.java

@@ -0,0 +1,760 @@
+/*
+ *       _____  _       _    _____                                _
+ *      |  __ \| |     | |  / ____|                              | |
+ *      | |__) | | ___ | |_| (___   __ _ _   _  __ _ _ __ ___  __| |
+ *      |  ___/| |/ _ \| __|\___ \ / _` | | | |/ _` | '__/ _ \/ _` |
+ *      | |    | | (_) | |_ ____) | (_| | |_| | (_| | | |  __/ (_| |
+ *      |_|    |_|\___/ \__|_____/ \__, |\__,_|\__,_|_|  \___|\__,_|
+ *                                    | |
+ *                                    |_|
+ *            PlotSquared plot management system for Minecraft
+ *                  Copyright (C) 2021 IntellectualSites
+ *
+ *     This program is free software: you can redistribute it and/or modify
+ *     it under the terms of the GNU 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 General Public License for more details.
+ *
+ *     You should have received a copy of the GNU General Public License
+ *     along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package com.plotsquared.bukkit.entity;
+
+import com.plotsquared.core.PlotSquared;
+import org.bukkit.Art;
+import org.bukkit.DyeColor;
+import org.bukkit.Location;
+import org.bukkit.Rotation;
+import org.bukkit.TreeSpecies;
+import org.bukkit.World;
+import org.bukkit.block.BlockFace;
+import org.bukkit.entity.AbstractHorse;
+import org.bukkit.entity.Ageable;
+import org.bukkit.entity.ArmorStand;
+import org.bukkit.entity.Bat;
+import org.bukkit.entity.Boat;
+import org.bukkit.entity.ChestedHorse;
+import org.bukkit.entity.EnderDragon;
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.IronGolem;
+import org.bukkit.entity.Item;
+import org.bukkit.entity.ItemFrame;
+import org.bukkit.entity.LivingEntity;
+import org.bukkit.entity.Painting;
+import org.bukkit.entity.Rabbit;
+import org.bukkit.entity.Sheep;
+import org.bukkit.entity.Slime;
+import org.bukkit.entity.Tameable;
+import org.bukkit.inventory.EntityEquipment;
+import org.bukkit.inventory.InventoryHolder;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.util.EulerAngle;
+import org.bukkit.util.Vector;
+
+import java.util.List;
+
+public final class ReplicatingEntityWrapper extends EntityWrapper {
+
+    private final short depth;
+    private final int hash;
+    private final EntityBaseStats base = new EntityBaseStats();
+
+    private ItemStack[] inventory;
+    // Extended
+    private ItemStack stack;
+    private byte dataByte;
+    private byte dataByte2;
+    private String dataString;
+    private LivingEntityStats lived;
+    private AgeableStats aged;
+    private TameableStats tamed;
+    private ArmorStandStats stand;
+    private HorseStats horse;
+    private boolean noGravity;
+
+    public ReplicatingEntityWrapper(Entity entity, short depth) {
+        super(entity);
+
+        this.hash = entity.getEntityId();
+        this.depth = depth;
+
+        if (depth == 0) {
+            return;
+        }
+        List<Entity> passengers = entity.getPassengers();
+        if (passengers.size() > 0) {
+            this.base.passenger = new ReplicatingEntityWrapper(passengers.get(0), depth);
+        }
+        this.base.fall = entity.getFallDistance();
+        this.base.fire = (short) entity.getFireTicks();
+        this.base.age = entity.getTicksLived();
+        Vector velocity = entity.getVelocity();
+        this.base.vX = velocity.getX();
+        this.base.vY = velocity.getY();
+        this.base.vZ = velocity.getZ();
+        if (depth == 1) {
+            return;
+        }
+        if (!entity.hasGravity()) {
+            this.noGravity = true;
+        }
+        switch (entity.getType().toString()) {
+            case "BOAT":
+                Boat boat = (Boat) entity;
+                this.dataByte = getOrdinal(TreeSpecies.values(), boat.getWoodType());
+                return;
+            case "ARROW":
+            case "EGG":
+            case "ENDER_CRYSTAL":
+            case "ENDER_PEARL":
+            case "ENDER_SIGNAL":
+            case "EXPERIENCE_ORB":
+            case "FALLING_BLOCK":
+            case "FIREBALL":
+            case "FIREWORK":
+            case "FISHING_HOOK":
+            case "LEASH_HITCH":
+            case "LIGHTNING":
+            case "MINECART":
+            case "MINECART_COMMAND":
+            case "MINECART_MOB_SPAWNER":
+            case "MINECART_TNT":
+            case "PLAYER":
+            case "PRIMED_TNT":
+            case "SLIME":
+            case "SMALL_FIREBALL":
+            case "SNOWBALL":
+            case "MINECART_FURNACE":
+            case "SPLASH_POTION":
+            case "THROWN_EXP_BOTTLE":
+            case "WITHER_SKULL":
+            case "UNKNOWN":
+            case "SPECTRAL_ARROW":
+            case "SHULKER_BULLET":
+            case "DRAGON_FIREBALL":
+            case "AREA_EFFECT_CLOUD":
+            case "TRIDENT":
+            case "LLAMA_SPIT":
+                // Do this stuff later
+                return;
+            // MISC //
+            case "DROPPED_ITEM":
+                Item item = (Item) entity;
+                this.stack = item.getItemStack();
+                return;
+            case "ITEM_FRAME":
+                this.x = Math.floor(this.x);
+                this.y = Math.floor(this.y);
+                this.z = Math.floor(this.z);
+                ItemFrame itemFrame = (ItemFrame) entity;
+                this.dataByte = getOrdinal(Rotation.values(), itemFrame.getRotation());
+                this.stack = itemFrame.getItem().clone();
+                return;
+            case "PAINTING":
+                this.x = Math.floor(this.x);
+                this.y = Math.floor(this.y);
+                this.z = Math.floor(this.z);
+                Painting painting = (Painting) entity;
+                Art art = painting.getArt();
+                this.dataByte = getOrdinal(BlockFace.values(), painting.getFacing());
+                int h = art.getBlockHeight();
+                if (h % 2 == 0) {
+                    this.y -= 1;
+                }
+                this.dataString = art.name();
+                return;
+            // END MISC //
+            // INVENTORY HOLDER //
+            case "MINECART_CHEST":
+            case "MINECART_HOPPER":
+                storeInventory((InventoryHolder) entity);
+                return;
+            // START LIVING ENTITY //
+            // START AGEABLE //
+            // START TAMEABLE //
+            case "HORSE":
+            case "DONKEY":
+            case "LLAMA":
+            case "MULE":
+            case "SKELETON_HORSE":
+                AbstractHorse horse = (AbstractHorse) entity;
+                this.horse = new HorseStats();
+                this.horse.jump = horse.getJumpStrength();
+                if (horse instanceof ChestedHorse) {
+                    ChestedHorse horse1 = (ChestedHorse) horse;
+                    this.horse.chest = horse1.isCarryingChest();
+                }
+                //todo these horse features need fixing
+                //this.horse.variant = horse.getVariant();
+                //this.horse.style = horse.getStyle();
+                //this.horse.color = horse.getColor();
+                storeTameable(horse);
+                storeAgeable(horse);
+                storeLiving(horse);
+                storeInventory(horse);
+                return;
+            // END INVENTORY HOLDER //
+            case "WOLF":
+            case "OCELOT":
+                storeTameable((Tameable) entity);
+                storeAgeable((Ageable) entity);
+                storeLiving((LivingEntity) entity);
+                return;
+            // END TAMEABLE //
+            //todo fix sheep
+            case "SHEEP":
+                Sheep sheep = (Sheep) entity;
+                if (sheep.isSheared()) {
+                    this.dataByte = (byte) 1;
+                } else {
+                    this.dataByte = (byte) 0;
+                }
+                this.dataByte2 = sheep.getColor().getDyeData();
+                storeAgeable(sheep);
+                storeLiving(sheep);
+                return;
+            case "VILLAGER":
+            case "CHICKEN":
+            case "COW":
+            case "MUSHROOM_COW":
+            case "PIG":
+            case "TURTLE":
+            case "POLAR_BEAR":
+                storeAgeable((Ageable) entity);
+                storeLiving((LivingEntity) entity);
+                return;
+            case "RABBIT":
+                this.dataByte = getOrdinal(Rabbit.Type.values(), ((Rabbit) entity).getRabbitType());
+                storeAgeable((Ageable) entity);
+                storeLiving((LivingEntity) entity);
+                return;
+            // END AGEABLE //
+            case "ARMOR_STAND":
+                ArmorStand stand = (ArmorStand) entity;
+                this.inventory =
+                    new ItemStack[] {stand.getItemInHand().clone(), stand.getHelmet().clone(),
+                        stand.getChestplate().clone(), stand.getLeggings().clone(),
+                        stand.getBoots().clone()};
+                storeLiving(stand);
+                this.stand = new ArmorStandStats();
+
+                EulerAngle head = stand.getHeadPose();
+                this.stand.head[0] = (float) head.getX();
+                this.stand.head[1] = (float) head.getY();
+                this.stand.head[2] = (float) head.getZ();
+
+                EulerAngle body = stand.getBodyPose();
+                this.stand.body[0] = (float) body.getX();
+                this.stand.body[1] = (float) body.getY();
+                this.stand.body[2] = (float) body.getZ();
+
+                EulerAngle leftLeg = stand.getLeftLegPose();
+                this.stand.leftLeg[0] = (float) leftLeg.getX();
+                this.stand.leftLeg[1] = (float) leftLeg.getY();
+                this.stand.leftLeg[2] = (float) leftLeg.getZ();
+
+                EulerAngle rightLeg = stand.getRightLegPose();
+                this.stand.rightLeg[0] = (float) rightLeg.getX();
+                this.stand.rightLeg[1] = (float) rightLeg.getY();
+                this.stand.rightLeg[2] = (float) rightLeg.getZ();
+
+                EulerAngle leftArm = stand.getLeftArmPose();
+                this.stand.leftArm[0] = (float) leftArm.getX();
+                this.stand.leftArm[1] = (float) leftArm.getY();
+                this.stand.leftArm[2] = (float) leftArm.getZ();
+
+                EulerAngle rightArm = stand.getRightArmPose();
+                this.stand.rightArm[0] = (float) rightArm.getX();
+                this.stand.rightArm[1] = (float) rightArm.getY();
+                this.stand.rightArm[2] = (float) rightArm.getZ();
+
+                if (stand.hasArms()) {
+                    this.stand.arms = true;
+                }
+                if (!stand.hasBasePlate()) {
+                    this.stand.noPlate = true;
+                }
+                if (!stand.isVisible()) {
+                    this.stand.invisible = true;
+                }
+                if (stand.isSmall()) {
+                    this.stand.small = true;
+                }
+                return;
+            case "ENDERMITE":
+                return;
+            case "BAT":
+                if (((Bat) entity).isAwake()) {
+                    this.dataByte = (byte) 1;
+                } else {
+                    this.dataByte = (byte) 0;
+                }
+                return;
+            case "ENDER_DRAGON":
+                EnderDragon entity1 = (EnderDragon) entity;
+                this.dataByte = (byte) entity1.getPhase().ordinal();
+                return;
+            case "SKELETON":
+            case "WITHER_SKELETON":
+            case "GUARDIAN":
+            case "ELDER_GUARDIAN":
+            case "GHAST":
+            case "MAGMA_CUBE":
+            case "SQUID":
+            case "PIG_ZOMBIE":
+            case "HOGLIN":
+            case "ZOMBIFIED_PIGLIN":
+            case "PIGLIN":
+            case "PIGLIN_BRUTE":
+            case "ZOMBIE":
+            case "WITHER":
+            case "WITCH":
+            case "SPIDER":
+            case "CAVE_SPIDER":
+            case "SILVERFISH":
+            case "GIANT":
+            case "ENDERMAN":
+            case "CREEPER":
+            case "BLAZE":
+            case "SHULKER":
+            case "SNOWMAN":
+                storeLiving((LivingEntity) entity);
+                return;
+            case "IRON_GOLEM":
+                if (((IronGolem) entity).isPlayerCreated()) {
+                    this.dataByte = (byte) 1;
+                } else {
+                    this.dataByte = (byte) 0;
+                }
+                storeLiving((LivingEntity) entity);
+                return;
+            // END LIVING //
+            default:
+                PlotSquared.debug("&cCOULD NOT IDENTIFY ENTITY: " + entity.getType());
+        }
+    }
+
+    @Override public boolean equals(Object obj) {
+        return this.hash == obj.hashCode();
+    }
+
+    @Override public int hashCode() {
+        return this.hash;
+    }
+
+    public void storeInventory(InventoryHolder held) {
+        this.inventory = held.getInventory().getContents().clone();
+    }
+
+    void restoreLiving(LivingEntity entity) {
+        entity.setCanPickupItems(this.lived.loot);
+        if (this.lived.name != null) {
+            entity.setCustomName(this.lived.name);
+            entity.setCustomNameVisible(this.lived.visible);
+        }
+        if (this.lived.potions != null && !this.lived.potions.isEmpty()) {
+            entity.addPotionEffects(this.lived.potions);
+        }
+        entity.setRemainingAir(this.lived.air);
+        entity.setRemoveWhenFarAway(this.lived.persistent);
+        if (this.lived.equipped) {
+            this.restoreEquipment(entity);
+        }
+        if (this.lived.leashed) {
+            // TODO leashes
+            //            World world = entity.getWorld();
+            //            Entity leash = world.spawnEntity(new Location(world, Math.floor(x) +
+            //            lived.leashX, Math.floor(y) + lived.leashY, Math.floor(z) + lived.leashZ),
+            //            EntityType.LEASH_HITCH);
+            //            entity.setLeashHolder(leash);
+        }
+    }
+
+    void restoreEquipment(LivingEntity entity) {
+        EntityEquipment equipment = entity.getEquipment();
+        if (equipment != null) {
+            equipment.setItemInMainHand(this.lived.mainHand);
+            equipment.setItemInOffHand(this.lived.offHand);
+            equipment.setHelmet(this.lived.helmet);
+            equipment.setChestplate(this.lived.chestplate);
+            equipment.setLeggings(this.lived.leggings);
+            equipment.setBoots(this.lived.boots);
+        }
+    }
+
+    private void restoreInventory(InventoryHolder entity) {
+        try {
+            entity.getInventory().setContents(this.inventory);
+        } catch (IllegalArgumentException e) {
+            PlotSquared.debug("&c[WARN] Failed to restore inventory.\n Reason: " + e.getMessage());
+        }
+    }
+
+    private void storeLiving(LivingEntity lived) {
+        this.lived = new LivingEntityStats();
+        this.lived.potions = lived.getActivePotionEffects();
+        this.lived.loot = lived.getCanPickupItems();
+        this.lived.name = lived.getCustomName();
+        this.lived.visible = lived.isCustomNameVisible();
+        this.lived.health = (float) lived.getHealth();
+        this.lived.air = (short) lived.getRemainingAir();
+        this.lived.persistent = lived.getRemoveWhenFarAway();
+        this.lived.leashed = lived.isLeashed();
+        if (this.lived.leashed) {
+            Location location = lived.getLeashHolder().getLocation();
+            this.lived.leashX = (short) (this.x - location.getBlockX());
+            this.lived.leashY = (short) (this.y - location.getBlockY());
+            this.lived.leashZ = (short) (this.z - location.getBlockZ());
+        }
+        EntityEquipment equipment = lived.getEquipment();
+        this.lived.equipped = equipment != null;
+        if (this.lived.equipped) {
+            storeEquipment(equipment);
+        }
+    }
+
+    void storeEquipment(EntityEquipment equipment) {
+        this.lived.mainHand = equipment.getItemInMainHand().clone();
+        this.lived.offHand = equipment.getItemInOffHand().clone();
+        this.lived.boots = equipment.getBoots().clone();
+        this.lived.leggings = equipment.getLeggings().clone();
+        this.lived.chestplate = equipment.getChestplate().clone();
+        this.lived.helmet = equipment.getHelmet().clone();
+    }
+
+    private void restoreTameable(Tameable entity) {
+        if (this.tamed.tamed) {
+            if (this.tamed.owner != null) {
+                entity.setTamed(true);
+                entity.setOwner(this.tamed.owner);
+            }
+        }
+    }
+
+    private void restoreAgeable(Ageable entity) {
+        if (!this.aged.adult) {
+            entity.setBaby();
+        }
+        entity.setAgeLock(this.aged.locked);
+        if (this.aged.age > 0) {
+            entity.setAge(this.aged.age);
+        }
+    }
+
+    public void storeAgeable(Ageable aged) {
+        this.aged = new AgeableStats();
+        this.aged.age = aged.getAge();
+        this.aged.locked = aged.getAgeLock();
+        this.aged.adult = aged.isAdult();
+    }
+
+    public void storeTameable(Tameable tamed) {
+        this.tamed = new TameableStats();
+        this.tamed.owner = tamed.getOwner();
+        this.tamed.tamed = tamed.isTamed();
+    }
+
+    @Override public Entity spawn(World world, int xOffset, int zOffset) {
+        Location location = new Location(world, this.x + xOffset, this.y, this.z + zOffset);
+        location.setYaw(this.yaw);
+        location.setPitch(this.pitch);
+        if (!this.getType().isSpawnable()) {
+            return null;
+        }
+        Entity entity;
+        switch (this.getType().toString()) {
+            case "DROPPED_ITEM":
+                return world.dropItem(location, this.stack);
+            case "PLAYER":
+            case "LEASH_HITCH":
+                return null;
+            case "ITEM_FRAME":
+                entity = world.spawn(location, ItemFrame.class);
+                break;
+            case "PAINTING":
+                entity = world.spawn(location, Painting.class);
+                break;
+            default:
+                entity = world.spawnEntity(location, this.getType());
+                break;
+        }
+        if (this.depth == 0) {
+            return entity;
+        }
+        if (this.base.passenger != null) {
+            try {
+                entity.addPassenger(this.base.passenger.spawn(world, xOffset, zOffset));
+            } catch (Exception ignored) {
+            }
+        }
+        if (this.base.fall != 0) {
+            entity.setFallDistance(this.base.fall);
+        }
+        if (this.base.fire != 0) {
+            entity.setFireTicks(this.base.fire);
+        }
+        if (this.base.age != 0) {
+            entity.setTicksLived(this.base.age);
+        }
+        entity.setVelocity(new Vector(this.base.vX, this.base.vY, this.base.vZ));
+        if (this.depth == 1) {
+            return entity;
+        }
+        if (this.noGravity) {
+            entity.setGravity(false);
+        }
+        switch (entity.getType().toString()) {
+            case "BOAT":
+                Boat boat = (Boat) entity;
+                boat.setWoodType(TreeSpecies.values()[dataByte]);
+                return entity;
+            case "SLIME":
+                ((Slime) entity).setSize(this.dataByte);
+                return entity;
+            case "ARROW":
+            case "EGG":
+            case "ENDER_CRYSTAL":
+            case "ENDER_PEARL":
+            case "ENDER_SIGNAL":
+            case "DROPPED_ITEM":
+            case "EXPERIENCE_ORB":
+            case "FALLING_BLOCK":
+            case "FIREBALL":
+            case "FIREWORK":
+            case "FISHING_HOOK":
+            case "LEASH_HITCH":
+            case "LIGHTNING":
+            case "MINECART":
+            case "MINECART_COMMAND":
+            case "MINECART_MOB_SPAWNER":
+            case "MINECART_TNT":
+            case "PLAYER":
+            case "PRIMED_TNT":
+            case "SMALL_FIREBALL":
+            case "SNOWBALL":
+            case "SPLASH_POTION":
+            case "THROWN_EXP_BOTTLE":
+            case "SPECTRAL_ARROW":
+            case "SHULKER_BULLET":
+            case "AREA_EFFECT_CLOUD":
+            case "DRAGON_FIREBALL":
+            case "WITHER_SKULL":
+            case "MINECART_FURNACE":
+            case "LLAMA_SPIT":
+            case "TRIDENT":
+            case "UNKNOWN":
+                // Do this stuff later
+                return entity;
+            // MISC //
+            case "ITEM_FRAME":
+                ItemFrame itemframe = (ItemFrame) entity;
+                itemframe.setRotation(Rotation.values()[this.dataByte]);
+                itemframe.setItem(this.stack);
+                return entity;
+            case "PAINTING":
+                Painting painting = (Painting) entity;
+                painting.setFacingDirection(BlockFace.values()[this.dataByte], true);
+                painting.setArt(Art.getByName(this.dataString), true);
+                return entity;
+            // END MISC //
+            // INVENTORY HOLDER //
+            case "MINECART_CHEST":
+            case "MINECART_HOPPER":
+                restoreInventory((InventoryHolder) entity);
+                return entity;
+            // START LIVING ENTITY //
+            // START AGEABLE //
+            // START TAMEABLE //
+            case "HORSE":
+            case "LLAMA":
+            case "SKELETON_HORSE":
+            case "DONKEY":
+            case "MULE":
+                AbstractHorse horse = (AbstractHorse) entity;
+                horse.setJumpStrength(this.horse.jump);
+                if (horse instanceof ChestedHorse) {
+                    ((ChestedHorse) horse).setCarryingChest(this.horse.chest);
+                }
+                //todo broken as of 1.13
+                //horse.setVariant(this.horse.variant);
+                //horse.setStyle(this.horse.style);
+                //horse.setColor(this.horse.color);
+                restoreTameable(horse);
+                restoreAgeable(horse);
+                restoreLiving(horse);
+                restoreInventory(horse);
+                return entity;
+            // END INVENTORY HOLDER //
+            case "WOLF":
+            case "OCELOT":
+                restoreTameable((Tameable) entity);
+                restoreAgeable((Ageable) entity);
+                restoreLiving((LivingEntity) entity);
+                return entity;
+            // END AGEABLE //
+            case "SHEEP":
+                Sheep sheep = (Sheep) entity;
+                if (this.dataByte == 1) {
+                    sheep.setSheared(true);
+                }
+                if (this.dataByte2 != 0) {
+                    sheep.setColor(DyeColor.getByDyeData(this.dataByte2));
+                }
+                restoreAgeable(sheep);
+                restoreLiving(sheep);
+                return sheep;
+            case "VILLAGER":
+            case "CHICKEN":
+            case "COW":
+            case "TURTLE":
+            case "POLAR_BEAR":
+            case "MUSHROOM_COW":
+            case "PIG":
+                restoreAgeable((Ageable) entity);
+                restoreLiving((LivingEntity) entity);
+                return entity;
+            // END AGEABLE //
+            case "RABBIT":
+                if (this.dataByte != 0) {
+                    ((Rabbit) entity).setRabbitType(Rabbit.Type.values()[this.dataByte]);
+                }
+                restoreAgeable((Ageable) entity);
+                restoreLiving((LivingEntity) entity);
+                return entity;
+            case "ARMOR_STAND":
+                // CHECK positions
+                ArmorStand stand = (ArmorStand) entity;
+                if (this.inventory[0] != null) {
+                    stand.setItemInHand(this.inventory[0]);
+                }
+                if (this.inventory[1] != null) {
+                    stand.setHelmet(this.inventory[1]);
+                }
+                if (this.inventory[2] != null) {
+                    stand.setChestplate(this.inventory[2]);
+                }
+                if (this.inventory[3] != null) {
+                    stand.setLeggings(this.inventory[3]);
+                }
+                if (this.inventory[4] != null) {
+                    stand.setBoots(this.inventory[4]);
+                }
+                if (this.stand.head[0] != 0 || this.stand.head[1] != 0 || this.stand.head[2] != 0) {
+                    EulerAngle pose =
+                        new EulerAngle(this.stand.head[0], this.stand.head[1], this.stand.head[2]);
+                    stand.setHeadPose(pose);
+                }
+                if (this.stand.body[0] != 0 || this.stand.body[1] != 0 || this.stand.body[2] != 0) {
+                    EulerAngle pose =
+                        new EulerAngle(this.stand.body[0], this.stand.body[1], this.stand.body[2]);
+                    stand.setBodyPose(pose);
+                }
+                if (this.stand.leftLeg[0] != 0 || this.stand.leftLeg[1] != 0
+                    || this.stand.leftLeg[2] != 0) {
+                    EulerAngle pose = new EulerAngle(this.stand.leftLeg[0], this.stand.leftLeg[1],
+                        this.stand.leftLeg[2]);
+                    stand.setLeftLegPose(pose);
+                }
+                if (this.stand.rightLeg[0] != 0 || this.stand.rightLeg[1] != 0
+                    || this.stand.rightLeg[2] != 0) {
+                    EulerAngle pose = new EulerAngle(this.stand.rightLeg[0], this.stand.rightLeg[1],
+                        this.stand.rightLeg[2]);
+                    stand.setRightLegPose(pose);
+                }
+                if (this.stand.leftArm[0] != 0 || this.stand.leftArm[1] != 0
+                    || this.stand.leftArm[2] != 0) {
+                    EulerAngle pose = new EulerAngle(this.stand.leftArm[0], this.stand.leftArm[1],
+                        this.stand.leftArm[2]);
+                    stand.setLeftArmPose(pose);
+                }
+                if (this.stand.rightArm[0] != 0 || this.stand.rightArm[1] != 0
+                    || this.stand.rightArm[2] != 0) {
+                    EulerAngle pose = new EulerAngle(this.stand.rightArm[0], this.stand.rightArm[1],
+                        this.stand.rightArm[2]);
+                    stand.setRightArmPose(pose);
+                }
+                if (this.stand.invisible) {
+                    stand.setVisible(false);
+                }
+                if (this.stand.arms) {
+                    stand.setArms(true);
+                }
+                if (this.stand.noPlate) {
+                    stand.setBasePlate(false);
+                }
+                if (this.stand.small) {
+                    stand.setSmall(true);
+                }
+                restoreLiving(stand);
+                return stand;
+            case "BAT":
+                if (this.dataByte != 0) {
+                    ((Bat) entity).setAwake(true);
+                }
+                restoreLiving((LivingEntity) entity);
+                return entity;
+            case "ENDER_DRAGON":
+                if (this.dataByte != 0) {
+                    ((EnderDragon) entity).setPhase(EnderDragon.Phase.values()[this.dataByte]);
+                }
+                restoreLiving((LivingEntity) entity);
+                return entity;
+            case "ENDERMITE":
+            case "GHAST":
+            case "MAGMA_CUBE":
+            case "SQUID":
+            case "PIG_ZOMBIE":
+            case "HOGLIN":
+            case "PIGLIN":
+            case "ZOMBIFIED_PIGLIN":
+            case "PIGLIN_BRUTE":
+            case "ZOMBIE":
+            case "WITHER":
+            case "WITCH":
+            case "SPIDER":
+            case "CAVE_SPIDER":
+            case "SILVERFISH":
+            case "GIANT":
+            case "ENDERMAN":
+            case "CREEPER":
+            case "BLAZE":
+            case "SNOWMAN":
+            case "SHULKER":
+            case "GUARDIAN":
+            case "ELDER_GUARDIAN":
+            case "SKELETON":
+            case "WITHER_SKELETON":
+                restoreLiving((LivingEntity) entity);
+                return entity;
+            case "IRON_GOLEM":
+                if (this.dataByte != 0) {
+                    ((IronGolem) entity).setPlayerCreated(true);
+                }
+                restoreLiving((LivingEntity) entity);
+                return entity;
+            default:
+                PlotSquared.debug("&cCOULD NOT IDENTIFY ENTITY: " + entity.getType());
+                return entity;
+            // END LIVING
+        }
+    }
+
+    public void saveEntity() {
+    }
+
+    private byte getOrdinal(Object[] list, Object value) {
+        for (byte i = 0; i < list.length; i++) {
+            if (list[i].equals(value)) {
+                return i;
+            }
+        }
+        return 0;
+    }
+
+
+}

Bukkit/src/main/java/com/plotsquared/bukkit/entity/TameableStats.java

@@ -0,0 +1,34 @@
+/*
+ *       _____  _       _    _____                                _
+ *      |  __ \| |     | |  / ____|                              | |
+ *      | |__) | | ___ | |_| (___   __ _ _   _  __ _ _ __ ___  __| |
+ *      |  ___/| |/ _ \| __|\___ \ / _` | | | |/ _` | '__/ _ \/ _` |
+ *      | |    | | (_) | |_ ____) | (_| | |_| | (_| | | |  __/ (_| |
+ *      |_|    |_|\___/ \__|_____/ \__, |\__,_|\__,_|_|  \___|\__,_|
+ *                                    | |
+ *                                    |_|
+ *            PlotSquared plot management system for Minecraft
+ *                  Copyright (C) 2021 IntellectualSites
+ *
+ *     This program is free software: you can redistribute it and/or modify
+ *     it under the terms of the GNU 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 General Public License for more details.
+ *
+ *     You should have received a copy of the GNU General Public License
+ *     along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package com.plotsquared.bukkit.entity;
+
+import org.bukkit.entity.AnimalTamer;
+
+class TameableStats {
+
+    AnimalTamer owner;
+    boolean tamed;
+}

Bukkit/src/main/java/com/plotsquared/bukkit/entity/TeleportEntityWrapper.java

@@ -0,0 +1,118 @@
+/*
+ *       _____  _       _    _____                                _
+ *      |  __ \| |     | |  / ____|                              | |
+ *      | |__) | | ___ | |_| (___   __ _ _   _  __ _ _ __ ___  __| |
+ *      |  ___/| |/ _ \| __|\___ \ / _` | | | |/ _` | '__/ _ \/ _` |
+ *      | |    | | (_) | |_ ____) | (_| | |_| | (_| | | |  __/ (_| |
+ *      |_|    |_|\___/ \__|_____/ \__, |\__,_|\__,_|_|  \___|\__,_|
+ *                                    | |
+ *                                    |_|
+ *            PlotSquared plot management system for Minecraft
+ *                  Copyright (C) 2021 IntellectualSites
+ *
+ *     This program is free software: you can redistribute it and/or modify
+ *     it under the terms of the GNU 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 General Public License for more details.
+ *
+ *     You should have received a copy of the GNU General Public License
+ *     along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package com.plotsquared.bukkit.entity;
+
+import com.plotsquared.bukkit.BukkitMain;
+import org.bukkit.Chunk;
+import org.bukkit.Location;
+import org.bukkit.World;
+import org.bukkit.entity.Entity;
+import org.bukkit.metadata.FixedMetadataValue;
+
+public class TeleportEntityWrapper extends EntityWrapper {
+
+    private Location oldLocation;
+    private boolean gravityOld;
+    private boolean invulnerableOld;
+    private int fireTicksOld;
+    private int livingTicksOld;
+
+    public TeleportEntityWrapper(final Entity entity) {
+        super(entity);
+    }
+
+    @Override public Entity spawn(final World world, final int xOffset, final int zOffset) {
+        if (!getEntity().getLocation().getChunk().equals(oldLocation.getChunk())) {
+            final Location oldLocation = this.oldLocation.clone();
+            oldLocation.add(xOffset, 0, xOffset);
+            getEntity().teleport(oldLocation);
+            getEntity().setGravity(gravityOld);
+            getEntity().setInvulnerable(invulnerableOld);
+            getEntity().setFireTicks(fireTicksOld);
+            getEntity().setTicksLived(livingTicksOld);
+            getEntity().removeMetadata("ps-tmp-teleport", BukkitMain.getPlugin(BukkitMain.class));
+        }
+        return getEntity();
+    }
+
+    @Override public void saveEntity() {
+        if (getEntity().hasMetadata("ps-tmp-teleport")) {
+            this.oldLocation = (Location) this.getEntity().getMetadata("ps-tmp-teleport").get(0);
+        } else {
+            this.oldLocation = this.getEntity().getLocation();
+        }
+
+        // To account for offsets in the chunk manager
+        this.oldLocation = oldLocation.clone();
+        this.oldLocation.setX(this.x);
+        this.oldLocation.setY(this.y);
+        this.oldLocation.setZ(this.z);
+
+        this.gravityOld = this.getEntity().hasGravity();
+        this.getEntity().setGravity(false);
+        this.invulnerableOld = this.getEntity().isInvulnerable();
+        this.getEntity().setInvulnerable(true);
+        this.fireTicksOld = this.getEntity().getFireTicks();
+        this.livingTicksOld = this.getEntity().getTicksLived();
+        this.getEntity().setMetadata("ps-tmp-teleport",
+            new FixedMetadataValue(BukkitMain.getPlugin(BukkitMain.class), oldLocation));
+        final Chunk newChunk = getNewChunk();
+        this.getEntity().teleport(
+            new Location(newChunk.getWorld(), newChunk.getX() << 4, 5000, newChunk.getZ() << 4));
+    }
+
+    private Chunk getNewChunk() {
+        final Chunk oldChunk = oldLocation.getChunk();
+        Chunk chunk = null;
+
+        for (Chunk lChunk : oldChunk.getWorld().getLoadedChunks()) {
+            if (!lChunk.equals(oldChunk) && lChunk.isLoaded()) {
+                chunk = lChunk;
+                break;
+            }
+        }
+        if (chunk == null) {
+            for (int dx = 1; dx < Integer.MAX_VALUE; dx++) {
+                for (int dz = 0; dz < Integer.MAX_VALUE; dz++) {
+                    if ((chunk = getChunkRelative(oldChunk, dx, dz)).isLoaded()) {
+                        break;
+                    } else if ((chunk = getChunkRelative(oldChunk, -dx, dz)).isLoaded()) {
+                        break;
+                    } else if ((chunk = getChunkRelative(oldChunk, dx, -dz)).isLoaded()) {
+                        break;
+                    } else if ((chunk = getChunkRelative(oldChunk, -dx, -dz)).isLoaded()) {
+                        break;
+                    }
+                }
+            }
+        }
+        return chunk;
+    }
+
+    private Chunk getChunkRelative(final Chunk chunk, final int dx, final int dz) {
+        return chunk.getWorld().getChunkAt(chunk.getX() + dx, chunk.getZ() + dz);
+    }
+}

Bukkit/src/main/java/com/plotsquared/bukkit/generator/BlockStatePopulator.java

@@ -0,0 +1,66 @@
+/*
+ *       _____  _       _    _____                                _
+ *      |  __ \| |     | |  / ____|                              | |
+ *      | |__) | | ___ | |_| (___   __ _ _   _  __ _ _ __ ___  __| |
+ *      |  ___/| |/ _ \| __|\___ \ / _` | | | |/ _` | '__/ _ \/ _` |
+ *      | |    | | (_) | |_ ____) | (_| | |_| | (_| | | |  __/ (_| |
+ *      |_|    |_|\___/ \__|_____/ \__, |\__,_|\__,_|_|  \___|\__,_|
+ *                                    | |
+ *                                    |_|
+ *            PlotSquared plot management system for Minecraft
+ *                  Copyright (C) 2021 IntellectualSites
+ *
+ *     This program is free software: you can redistribute it and/or modify
+ *     it under the terms of the GNU 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 General Public License for more details.
+ *
+ *     You should have received a copy of the GNU General Public License
+ *     along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package com.plotsquared.bukkit.generator;
+
+import com.plotsquared.core.PlotSquared;
+import com.plotsquared.core.generator.IndependentPlotGenerator;
+import com.plotsquared.core.location.ChunkWrapper;
+import com.plotsquared.core.plot.PlotArea;
+import com.plotsquared.core.queue.GlobalBlockQueue;
+import com.plotsquared.core.queue.LocalBlockQueue;
+import com.plotsquared.core.queue.ScopedLocalBlockQueue;
+import org.bukkit.Chunk;
+import org.bukkit.World;
+import org.bukkit.generator.BlockPopulator;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Random;
+
+final class BlockStatePopulator extends BlockPopulator {
+
+    private final IndependentPlotGenerator plotGenerator;
+    private LocalBlockQueue queue;
+
+    public BlockStatePopulator(IndependentPlotGenerator plotGenerator) {
+        this.plotGenerator = plotGenerator;
+    }
+
+    @Override
+    public void populate(@NotNull final World world, @NotNull final Random random,
+        @NotNull final Chunk source) {
+        if (this.queue == null) {
+            this.queue = GlobalBlockQueue.IMP.getNewQueue(world.getName(), false);
+        }
+        final PlotArea area = PlotSquared.get().getPlotArea(world.getName(), null);
+        final ChunkWrapper wrap =
+            new ChunkWrapper(area.getWorldName(), source.getX(), source.getZ());
+        final ScopedLocalBlockQueue chunk = this.queue.getForChunk(wrap.x, wrap.z);
+        if (this.plotGenerator.populateChunk(chunk, area)) {
+            this.queue.flush();
+        }
+    }
+
+}

Bukkit/src/main/java/com/plotsquared/bukkit/generator/BukkitAugmentedGenerator.java

@@ -0,0 +1,57 @@
+/*
+ *       _____  _       _    _____                                _
+ *      |  __ \| |     | |  / ____|                              | |
+ *      | |__) | | ___ | |_| (___   __ _ _   _  __ _ _ __ ___  __| |
+ *      |  ___/| |/ _ \| __|\___ \ / _` | | | |/ _` | '__/ _ \/ _` |
+ *      | |    | | (_) | |_ ____) | (_| | |_| | (_| | | |  __/ (_| |
+ *      |_|    |_|\___/ \__|_____/ \__, |\__,_|\__,_|_|  \___|\__,_|
+ *                                    | |
+ *                                    |_|
+ *            PlotSquared plot management system for Minecraft
+ *                  Copyright (C) 2021 IntellectualSites
+ *
+ *     This program is free software: you can redistribute it and/or modify
+ *     it under the terms of the GNU 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 General Public License for more details.
+ *
+ *     You should have received a copy of the GNU General Public License
+ *     along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package com.plotsquared.bukkit.generator;
+
+import com.plotsquared.core.generator.AugmentedUtils;
+import org.bukkit.Chunk;
+import org.bukkit.World;
+import org.bukkit.generator.BlockPopulator;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Random;
+
+public class BukkitAugmentedGenerator extends BlockPopulator {
+
+    private static BukkitAugmentedGenerator generator;
+
+    public static BukkitAugmentedGenerator get(World world) {
+        for (BlockPopulator populator : world.getPopulators()) {
+            if (populator instanceof BukkitAugmentedGenerator) {
+                return (BukkitAugmentedGenerator) populator;
+            }
+        }
+        if (generator == null) {
+            generator = new BukkitAugmentedGenerator();
+        }
+        world.getPopulators().add(generator);
+        return generator;
+    }
+
+    @Override
+    public void populate(@NotNull World world, @NotNull Random random, @NotNull Chunk source) {
+        AugmentedUtils.generate(source, world.getName(), source.getX(), source.getZ(), null);
+    }
+}

Bukkit/src/main/java/com/plotsquared/bukkit/generator/BukkitHybridUtils.java

@@ -0,0 +1,33 @@
+/*
+ *       _____  _       _    _____                                _
+ *      |  __ \| |     | |  / ____|                              | |
+ *      | |__) | | ___ | |_| (___   __ _ _   _  __ _ _ __ ___  __| |
+ *      |  ___/| |/ _ \| __|\___ \ / _` | | | |/ _` | '__/ _ \/ _` |
+ *      | |    | | (_) | |_ ____) | (_| | |_| | (_| | | |  __/ (_| |
+ *      |_|    |_|\___/ \__|_____/ \__, |\__,_|\__,_|_|  \___|\__,_|
+ *                                    | |
+ *                                    |_|
+ *            PlotSquared plot management system for Minecraft
+ *                  Copyright (C) 2021 IntellectualSites
+ *
+ *     This program is free software: you can redistribute it and/or modify
+ *     it under the terms of the GNU 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 General Public License for more details.
+ *
+ *     You should have received a copy of the GNU General Public License
+ *     along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package com.plotsquared.bukkit.generator;
+
+import com.plotsquared.core.generator.HybridUtils;
+
+public class BukkitHybridUtils extends HybridUtils {
+
+
+}

Bukkit/src/main/java/com/plotsquared/bukkit/generator/BukkitPlotGenerator.java

@@ -0,0 +1,258 @@
+/*
+ *       _____  _       _    _____                                _
+ *      |  __ \| |     | |  / ____|                              | |
+ *      | |__) | | ___ | |_| (___   __ _ _   _  __ _ _ __ ___  __| |
+ *      |  ___/| |/ _ \| __|\___ \ / _` | | | |/ _` | '__/ _ \/ _` |
+ *      | |    | | (_) | |_ ____) | (_| | |_| | (_| | | |  __/ (_| |
+ *      |_|    |_|\___/ \__|_____/ \__, |\__,_|\__,_|_|  \___|\__,_|
+ *                                    | |
+ *                                    |_|
+ *            PlotSquared plot management system for Minecraft
+ *                  Copyright (C) 2021 IntellectualSites
+ *
+ *     This program is free software: you can redistribute it and/or modify
+ *     it under the terms of the GNU 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 General Public License for more details.
+ *
+ *     You should have received a copy of the GNU General Public License
+ *     along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package com.plotsquared.bukkit.generator;
+
+import com.plotsquared.bukkit.queue.GenChunk;
+import com.plotsquared.bukkit.util.BukkitUtil;
+import com.plotsquared.core.PlotSquared;
+import com.plotsquared.core.generator.GeneratorWrapper;
+import com.plotsquared.core.generator.IndependentPlotGenerator;
+import com.plotsquared.core.generator.SingleWorldGenerator;
+import com.plotsquared.core.location.ChunkWrapper;
+import com.plotsquared.core.plot.PlotArea;
+import com.plotsquared.core.queue.ScopedLocalBlockQueue;
+import com.plotsquared.core.util.ChunkManager;
+import com.plotsquared.core.util.MainUtil;
+import com.sk89q.worldedit.math.BlockVector2;
+import lombok.Getter;
+import org.bukkit.World;
+import org.bukkit.block.Biome;
+import org.bukkit.generator.BlockPopulator;
+import org.bukkit.generator.ChunkGenerator;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Random;
+import java.util.Set;
+
+public class BukkitPlotGenerator extends ChunkGenerator
+    implements GeneratorWrapper<ChunkGenerator> {
+
+    @SuppressWarnings("unused") public final boolean PAPER_ASYNC_SAFE = true;
+
+    private final IndependentPlotGenerator plotGenerator;
+    private final ChunkGenerator platformGenerator;
+    private final boolean full;
+    private List<BlockPopulator> populators;
+    private boolean loaded = false;
+
+    @Getter private final String levelName;
+
+    public BukkitPlotGenerator(String name, IndependentPlotGenerator generator) {
+        if (generator == null) {
+            throw new IllegalArgumentException("Generator may not be null!");
+        }
+        this.levelName = name;
+        this.plotGenerator = generator;
+        this.platformGenerator = this;
+        this.populators = new ArrayList<>();
+        this.populators.add(new BlockStatePopulator(this.plotGenerator));
+        this.full = true;
+        MainUtil.initCache();
+    }
+
+    public BukkitPlotGenerator(final String world, final ChunkGenerator cg) {
+        if (cg instanceof BukkitPlotGenerator) {
+            throw new IllegalArgumentException("ChunkGenerator: " + cg.getClass().getName()
+                + " is already a BukkitPlotGenerator!");
+        }
+        this.levelName = world;
+        this.full = false;
+        this.platformGenerator = cg;
+        this.plotGenerator = new DelegatePlotGenerator(cg, world);
+        MainUtil.initCache();
+    }
+
+    @Override public void augment(PlotArea area) {
+        BukkitAugmentedGenerator.get(BukkitUtil.getWorld(area.getWorldName()));
+    }
+
+    @Override public boolean isFull() {
+        return this.full;
+    }
+
+    @Override public IndependentPlotGenerator getPlotGenerator() {
+        return this.plotGenerator;
+    }
+
+    @Override public ChunkGenerator getPlatformGenerator() {
+        return this.platformGenerator;
+    }
+
+    @Override @NotNull public List<BlockPopulator> getDefaultPopulators(@NotNull World world) {
+        try {
+            if (!this.loaded) {
+                String name = world.getName();
+                PlotSquared.get().loadWorld(name, this);
+                Set<PlotArea> areas = PlotSquared.get().getPlotAreas(name);
+                if (!areas.isEmpty()) {
+                    PlotArea area = areas.iterator().next();
+                    if (!area.isMobSpawning()) {
+                        if (!area.isSpawnEggs()) {
+                            world.setSpawnFlags(false, false);
+                        }
+                        world.setAmbientSpawnLimit(0);
+                        world.setAnimalSpawnLimit(0);
+                        world.setMonsterSpawnLimit(0);
+                        world.setWaterAnimalSpawnLimit(0);
+                    } else {
+                        world.setSpawnFlags(true, true);
+                        world.setAmbientSpawnLimit(-1);
+                        world.setAnimalSpawnLimit(-1);
+                        world.setMonsterSpawnLimit(-1);
+                        world.setWaterAnimalSpawnLimit(-1);
+                    }
+                }
+                this.loaded = true;
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        ArrayList<BlockPopulator> toAdd = new ArrayList<>();
+        List<BlockPopulator> existing = world.getPopulators();
+        if (populators == null && platformGenerator != null) {
+            populators = new ArrayList<>(platformGenerator.getDefaultPopulators(world));
+        }
+        if (populators != null) {
+            for (BlockPopulator populator : this.populators) {
+                if (!existing.contains(populator)) {
+                    toAdd.add(populator);
+                }
+            }
+        }
+        return toAdd;
+    }
+
+    @Override @NotNull
+    public ChunkData generateChunkData(@NotNull World world, @NotNull Random random, int x, int z,
+        @NotNull BiomeGrid biome) {
+
+        GenChunk result = new GenChunk();
+        if (this.getPlotGenerator() instanceof SingleWorldGenerator) {
+            if (result.getChunkData() != null) {
+                for (int chunkX = 0; chunkX < 16; chunkX++) {
+                    for (int chunkZ = 0; chunkZ < 16; chunkZ++) {
+                        for (int y = 0; y < world.getMaxHeight(); y++) {
+                            biome.setBiome(chunkX, y, chunkZ, Biome.PLAINS);
+
+                        }
+                    }
+                }
+                return result.getChunkData();
+            }
+        }
+        // Set the chunk location
+        result.setChunk(new ChunkWrapper(world.getName(), x, z));
+        // Set the result data
+        result.setChunkData(createChunkData(world));
+        result.biomeGrid = biome;
+        result.result = null;
+
+        // Catch any exceptions (as exceptions usually thrown)
+        try {
+            // Fill the result data if necessary
+            if (this.platformGenerator != this) {
+                return this.platformGenerator.generateChunkData(world, random, x, z, biome);
+            } else {
+                generate(BlockVector2.at(x, z), world, result);
+            }
+        } catch (Throwable e) {
+            e.printStackTrace();
+        }
+        // Return the result data
+        return result.getChunkData();
+    }
+
+    private void generate(BlockVector2 loc, World world, ScopedLocalBlockQueue result) {
+        // Load if improperly loaded
+        if (!this.loaded) {
+            String name = world.getName();
+            PlotSquared.get().loadWorld(name, this);
+            this.loaded = true;
+        }
+        // Process the chunk
+        if (ChunkManager.preProcessChunk(loc, result)) {
+            return;
+        }
+        PlotArea area = PlotSquared.get().getPlotArea(world.getName(), null);
+        if (area == null && (area = PlotSquared.get().getPlotArea(this.levelName, null)) == null) {
+            throw new IllegalStateException(
+                "Cannot regenerate chunk that does not belong to a plot area." + " Location: " + loc
+                    + ", world: " + world);
+        }
+        try {
+            this.plotGenerator.generateChunk(result, area);
+        } catch (Throwable e) {
+            // Recover from generator error
+            e.printStackTrace();
+        }
+        ChunkManager.postProcessChunk(loc, result);
+    }
+
+    @Override public boolean canSpawn(@NotNull final World world, final int x, final int z) {
+        return true;
+    }
+
+    public boolean shouldGenerateCaves() {
+        return false;
+    }
+
+    public boolean shouldGenerateDecorations() {
+        return false;
+    }
+
+    public boolean isParallelCapable() {
+        return true;
+    }
+
+    public boolean shouldGenerateMobs() {
+        return false;
+    }
+
+    public boolean shouldGenerateStructures() {
+        return true;
+    }
+
+    @Override public String toString() {
+        if (this.platformGenerator == this) {
+            return this.plotGenerator.getName();
+        }
+        if (this.platformGenerator == null) {
+            return "null";
+        } else {
+            return this.platformGenerator.getClass().getName();
+        }
+    }
+
+    @Override public boolean equals(final Object obj) {
+        if (obj == null) {
+            return false;
+        }
+        return toString().equals(obj.toString()) || toString().equals(obj.getClass().getName());
+    }
+
+}

Bukkit/src/main/java/com/plotsquared/bukkit/generator/DelegatePlotGenerator.java

@@ -0,0 +1,104 @@
+/*
+ *       _____  _       _    _____                                _
+ *      |  __ \| |     | |  / ____|                              | |
+ *      | |__) | | ___ | |_| (___   __ _ _   _  __ _ _ __ ___  __| |
+ *      |  ___/| |/ _ \| __|\___ \ / _` | | | |/ _` | '__/ _ \/ _` |
+ *      | |    | | (_) | |_ ____) | (_| | |_| | (_| | | |  __/ (_| |
+ *      |_|    |_|\___/ \__|_____/ \__, |\__,_|\__,_|_|  \___|\__,_|
+ *                                    | |
+ *                                    |_|
+ *            PlotSquared plot management system for Minecraft
+ *                  Copyright (C) 2021 IntellectualSites
+ *
+ *     This program is free software: you can redistribute it and/or modify
+ *     it under the terms of the GNU 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 General Public License for more details.
+ *
+ *     You should have received a copy of the GNU General Public License
+ *     along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package com.plotsquared.bukkit.generator;
+
+import com.plotsquared.bukkit.util.BukkitUtil;
+import com.plotsquared.core.PlotSquared;
+import com.plotsquared.core.generator.IndependentPlotGenerator;
+import com.plotsquared.core.location.Location;
+import com.plotsquared.core.plot.PlotArea;
+import com.plotsquared.core.plot.PlotId;
+import com.plotsquared.core.queue.ScopedLocalBlockQueue;
+import com.plotsquared.core.util.MathMan;
+import com.sk89q.worldedit.bukkit.BukkitAdapter;
+import org.bukkit.World;
+import org.bukkit.block.Biome;
+import org.bukkit.generator.BlockPopulator;
+import org.bukkit.generator.ChunkGenerator;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Range;
+
+import java.util.Random;
+
+final class DelegatePlotGenerator extends IndependentPlotGenerator {
+
+    private final ChunkGenerator chunkGenerator;
+    private final String world;
+
+    public DelegatePlotGenerator(ChunkGenerator chunkGenerator, String world) {
+        this.chunkGenerator = chunkGenerator;
+        this.world = world;
+    }
+
+    @Override public void initialize(PlotArea area) {
+    }
+
+    @Override public String getName() {
+        return this.chunkGenerator.getClass().getName();
+    }
+
+    @Override public PlotArea getNewPlotArea(String world, String id, PlotId min, PlotId max) {
+        return PlotSquared.get().IMP.getDefaultGenerator().getNewPlotArea(world, id, min, max);
+    }
+
+    @Override public void generateChunk(final ScopedLocalBlockQueue result, PlotArea settings) {
+        World world = BukkitUtil.getWorld(this.world);
+        Location min = result.getMin();
+        int chunkX = min.getX() >> 4;
+        int chunkZ = min.getZ() >> 4;
+        Random random = new Random(MathMan.pair((short) chunkX, (short) chunkZ));
+        try {
+            ChunkGenerator.BiomeGrid grid = new ChunkGenerator.BiomeGrid() {
+                @Override
+                public void setBiome(@Range(from = 0, to = 15) int x,
+                    @Range(from = 0, to = 15) int z, @NotNull Biome biome) {
+                    result.setBiome(x, z, BukkitAdapter.adapt(biome));
+                }
+
+                //do not annotate with Override until we discontinue support for 1.4.4
+                public void setBiome(int x, int y, int z, @NotNull Biome biome) {
+                    result.setBiome(x, z, BukkitAdapter.adapt(biome));
+
+                }
+
+                @Override @NotNull public Biome getBiome(int x, int z) {
+                    return Biome.FOREST;
+                }
+
+                @Override public @NotNull Biome getBiome(int x, int y, int z) {
+                    return Biome.FOREST;
+                }
+            };
+            chunkGenerator.generateChunkData(world, random, chunkX, chunkZ, grid);
+            return;
+        } catch (Throwable ignored) {
+        }
+        for (BlockPopulator populator : chunkGenerator.getDefaultPopulators(world)) {
+            populator.populate(world, random, world.getChunkAt(chunkX, chunkZ));
+        }
+    }
+
+}

Bukkit/src/main/java/com/plotsquared/bukkit/listener/ChunkListener.java

@@ -0,0 +1,319 @@
+/*
+ *       _____  _       _    _____                                _
+ *      |  __ \| |     | |  / ____|                              | |
+ *      | |__) | | ___ | |_| (___   __ _ _   _  __ _ _ __ ___  __| |
+ *      |  ___/| |/ _ \| __|\___ \ / _` | | | |/ _` | '__/ _ \/ _` |
+ *      | |    | | (_) | |_ ____) | (_| | |_| | (_| | | |  __/ (_| |
+ *      |_|    |_|\___/ \__|_____/ \__, |\__,_|\__,_|_|  \___|\__,_|
+ *                                    | |
+ *                                    |_|
+ *            PlotSquared plot management system for Minecraft
+ *                  Copyright (C) 2021 IntellectualSites
+ *
+ *     This program is free software: you can redistribute it and/or modify
+ *     it under the terms of the GNU 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 General Public License for more details.
+ *
+ *     You should have received a copy of the GNU General Public License
+ *     along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package com.plotsquared.bukkit.listener;
+
+import com.plotsquared.core.PlotSquared;
+import com.plotsquared.core.configuration.Settings;
+import com.plotsquared.core.location.Location;
+import com.plotsquared.core.plot.Plot;
+import com.plotsquared.core.util.ReflectionUtils.RefClass;
+import com.plotsquared.core.util.ReflectionUtils.RefField;
+import com.plotsquared.core.util.ReflectionUtils.RefMethod;
+import com.plotsquared.core.util.task.TaskManager;
+import io.papermc.lib.PaperLib;
+import org.bukkit.Bukkit;
+import org.bukkit.Chunk;
+import org.bukkit.Material;
+import org.bukkit.World;
+import org.bukkit.block.BlockState;
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.Item;
+import org.bukkit.entity.LivingEntity;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.Listener;
+import org.bukkit.event.block.BlockPhysicsEvent;
+import org.bukkit.event.entity.CreatureSpawnEvent;
+import org.bukkit.event.entity.ItemSpawnEvent;
+import org.bukkit.event.world.ChunkLoadEvent;
+import org.bukkit.event.world.ChunkUnloadEvent;
+
+import java.lang.reflect.Method;
+import java.util.HashSet;
+
+import static com.plotsquared.core.util.ReflectionUtils.getRefClass;
+
+@SuppressWarnings("unused")
+public class ChunkListener implements Listener {
+
+    private RefMethod methodGetHandleChunk;
+    private RefField mustSave;
+    private Chunk lastChunk;
+    private boolean ignoreUnload = false;
+
+    public ChunkListener() {
+        if (Settings.Chunk_Processor.AUTO_TRIM) {
+            try {
+                RefClass classChunk = getRefClass("{nms}.Chunk");
+                RefClass classCraftChunk = getRefClass("{cb}.CraftChunk");
+                this.mustSave = classChunk.getField("mustSave");
+                this.methodGetHandleChunk = classCraftChunk.getMethod("getHandle");
+            } catch (Throwable ignored) {
+                PlotSquared.debug(PlotSquared.get().IMP.getPluginName()
+                    + "/Server not compatible for chunk processor trim/gc");
+
+                Settings.Chunk_Processor.AUTO_TRIM = false;
+            }
+        }
+        if (!Settings.Chunk_Processor.AUTO_TRIM) {
+            return;
+        }
+        for (World world : Bukkit.getWorlds()) {
+            world.setAutoSave(false);
+        }
+        TaskManager.runTaskRepeat(() -> {
+            try {
+                HashSet<Chunk> toUnload = new HashSet<>();
+                for (World world : Bukkit.getWorlds()) {
+                    String worldName = world.getName();
+                    if (!PlotSquared.get().hasPlotArea(worldName)) {
+                        continue;
+                    }
+                    Object w = world.getClass().getDeclaredMethod("getHandle").invoke(world);
+                    Object chunkMap = w.getClass().getDeclaredMethod("getPlayerChunkMap").invoke(w);
+                    Method methodIsChunkInUse =
+                        chunkMap.getClass().getDeclaredMethod("isChunkInUse", int.class, int.class);
+                    Chunk[] chunks = world.getLoadedChunks();
+                    for (Chunk chunk : chunks) {
+                        if ((boolean) methodIsChunkInUse
+                            .invoke(chunkMap, chunk.getX(), chunk.getZ())) {
+                            continue;
+                        }
+                        int x = chunk.getX();
+                        int z = chunk.getZ();
+                        if (!shouldSave(worldName, x, z)) {
+                            unloadChunk(worldName, chunk, false);
+                            continue;
+                        }
+                        toUnload.add(chunk);
+                    }
+                }
+                if (toUnload.isEmpty()) {
+                    return;
+                }
+                long start = System.currentTimeMillis();
+                for (Chunk chunk : toUnload) {
+                    if (System.currentTimeMillis() - start > 5) {
+                        return;
+                    }
+                    chunk.unload(true);
+                }
+            } catch (Throwable e) {
+                e.printStackTrace();
+            }
+        }, 1);
+    }
+
+    public boolean unloadChunk(String world, Chunk chunk, boolean safe) {
+        if (safe && shouldSave(world, chunk.getX(), chunk.getZ())) {
+            return false;
+        }
+        Object c = this.methodGetHandleChunk.of(chunk).call();
+        RefField.RefExecutor field = this.mustSave.of(c);
+        if ((Boolean) field.get()) {
+            field.set(false);
+            if (chunk.isLoaded()) {
+                ignoreUnload = true;
+                chunk.unload(false);
+                ignoreUnload = false;
+            }
+        }
+        return true;
+    }
+
+    public boolean shouldSave(String world, int chunkX, int chunkZ) {
+        int x = chunkX << 4;
+        int z = chunkZ << 4;
+        int x2 = x + 15;
+        int z2 = z + 15;
+        Plot plot = new Location(world, x, 1, z).getOwnedPlotAbs();
+        if (plot != null && plot.hasOwner()) {
+            return true;
+        }
+        plot = new Location(world, x2, 1, z2).getOwnedPlotAbs();
+        if (plot != null && plot.hasOwner()) {
+            return true;
+        }
+        plot = new Location(world, x2, 1, z).getOwnedPlotAbs();
+        if (plot != null && plot.hasOwner()) {
+            return true;
+        }
+        plot = new Location(world, x, 1, z2).getOwnedPlotAbs();
+        if (plot != null && plot.hasOwner()) {
+            return true;
+        }
+        plot = new Location(world, x + 7, 1, z + 7).getOwnedPlotAbs();
+        return plot != null && plot.hasOwner();
+    }
+
+    @EventHandler public void onChunkUnload(ChunkUnloadEvent event) {
+        if (ignoreUnload) {
+            return;
+        }
+        Chunk chunk = event.getChunk();
+        if (Settings.Chunk_Processor.AUTO_TRIM) {
+            String world = chunk.getWorld().getName();
+            if (PlotSquared.get().hasPlotArea(world)) {
+                if (unloadChunk(world, chunk, true)) {
+                    return;
+                }
+            }
+        }
+        if (processChunk(event.getChunk(), true)) {
+            chunk.setForceLoaded(true);
+        }
+    }
+
+    @EventHandler public void onChunkLoad(ChunkLoadEvent event) {
+        processChunk(event.getChunk(), false);
+    }
+
+    @EventHandler(priority = EventPriority.LOWEST) public void onItemSpawn(ItemSpawnEvent event) {
+        Item entity = event.getEntity();
+        PaperLib.getChunkAtAsync(event.getLocation()).thenAccept(chunk -> {
+            if (chunk == this.lastChunk) {
+                event.getEntity().remove();
+                event.setCancelled(true);
+                return;
+            }
+            if (!PlotSquared.get().hasPlotArea(chunk.getWorld().getName())) {
+                return;
+            }
+            Entity[] entities = chunk.getEntities();
+            if (entities.length > Settings.Chunk_Processor.MAX_ENTITIES) {
+                event.getEntity().remove();
+                event.setCancelled(true);
+                this.lastChunk = chunk;
+            } else {
+                this.lastChunk = null;
+            }
+        });
+    }
+
+    @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
+    public void onBlockPhysics(BlockPhysicsEvent event) {
+        if (Settings.Chunk_Processor.DISABLE_PHYSICS) {
+            event.setCancelled(true);
+        }
+    }
+
+    @EventHandler(priority = EventPriority.LOWEST)
+    public void onEntitySpawn(CreatureSpawnEvent event) {
+        LivingEntity entity = event.getEntity();
+        PaperLib.getChunkAtAsync(event.getLocation()).thenAccept(chunk -> {
+            if (chunk == this.lastChunk) {
+                event.getEntity().remove();
+                event.setCancelled(true);
+                return;
+            }
+            if (!PlotSquared.get().hasPlotArea(chunk.getWorld().getName())) {
+                return;
+            }
+            Entity[] entities = chunk.getEntities();
+            if (entities.length > Settings.Chunk_Processor.MAX_ENTITIES) {
+                event.getEntity().remove();
+                event.setCancelled(true);
+                this.lastChunk = chunk;
+            } else {
+                this.lastChunk = null;
+            }
+        });
+    }
+
+    private void cleanChunk(final Chunk chunk) {
+        TaskManager.index.incrementAndGet();
+        final Integer currentIndex = TaskManager.index.get();
+        Integer task = TaskManager.runTaskRepeat(() -> {
+            if (!chunk.isLoaded()) {
+                Bukkit.getScheduler().cancelTask(TaskManager.tasks.get(currentIndex));
+                TaskManager.tasks.remove(currentIndex);
+                PlotSquared.debug("Successfully processed and unloaded chunk!");
+                chunk.unload(true);
+                return;
+            }
+            BlockState[] tiles = chunk.getTileEntities();
+            if (tiles.length == 0) {
+                Bukkit.getScheduler().cancelTask(TaskManager.tasks.get(currentIndex));
+                TaskManager.tasks.remove(currentIndex);
+                PlotSquared.debug("Successfully processed and unloaded chunk!");
+                chunk.unload(true);
+                return;
+            }
+            long start = System.currentTimeMillis();
+            int i = 0;
+            while (System.currentTimeMillis() - start < 250) {
+                if (i >= tiles.length - Settings.Chunk_Processor.MAX_TILES) {
+                    Bukkit.getScheduler().cancelTask(TaskManager.tasks.get(currentIndex));
+                    TaskManager.tasks.remove(currentIndex);
+                    PlotSquared.debug("Successfully processed and unloaded chunk!");
+                    chunk.unload(true);
+                    return;
+                }
+                tiles[i].getBlock().setType(Material.AIR, false);
+                i++;
+            }
+        }, 5);
+        TaskManager.tasks.put(currentIndex, task);
+    }
+
+    public boolean processChunk(Chunk chunk, boolean unload) {
+        if (!PlotSquared.get().hasPlotArea(chunk.getWorld().getName())) {
+            return false;
+        }
+        Entity[] entities = chunk.getEntities();
+        BlockState[] tiles = chunk.getTileEntities();
+        if (entities.length > Settings.Chunk_Processor.MAX_ENTITIES) {
+            int toRemove = entities.length - Settings.Chunk_Processor.MAX_ENTITIES;
+            int index = 0;
+            while (toRemove > 0 && index < entities.length) {
+                final Entity entity = entities[index++];
+                if (!(entity instanceof Player)) {
+                    entity.remove();
+                    toRemove--;
+                }
+            }
+
+            PlotSquared.debug(
+                "PlotSquared detected unsafe chunk and processed: " + (chunk.getX() << 4) + "," + (
+                    chunk.getX() << 4));
+        }
+        if (tiles.length > Settings.Chunk_Processor.MAX_TILES) {
+            if (unload) {
+                PlotSquared.debug(
+                    "PlotSquared detected unsafe chunk: " + (chunk.getX() << 4) + "," + (
+                        chunk.getX() << 4));
+                cleanChunk(chunk);
+                return true;
+            }
+
+            for (int i = 0 ; i < (tiles.length - Settings.Chunk_Processor.MAX_TILES); i++) {
+                tiles[i].getBlock().setType(Material.AIR, false);
+            }
+        }
+        return false;
+    }
+}

Bukkit/src/main/java/com/plotsquared/bukkit/listener/EntityEventListener.java

@@ -0,0 +1,344 @@
+/*
+ *       _____  _       _    _____                                _
+ *      |  __ \| |     | |  / ____|                              | |
+ *      | |__) | | ___ | |_| (___   __ _ _   _  __ _ _ __ ___  __| |
+ *      |  ___/| |/ _ \| __|\___ \ / _` | | | |/ _` | '__/ _ \/ _` |
+ *      | |    | | (_) | |_ ____) | (_| | |_| | (_| | | |  __/ (_| |
+ *      |_|    |_|\___/ \__|_____/ \__, |\__,_|\__,_|_|  \___|\__,_|
+ *                                    | |
+ *                                    |_|
+ *            PlotSquared plot management system for Minecraft
+ *                  Copyright (C) 2021 IntellectualSites
+ *
+ *     This program is free software: you can redistribute it and/or modify
+ *     it under the terms of the GNU 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 General Public License for more details.
+ *
+ *     You should have received a copy of the GNU General Public License
+ *     along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package com.plotsquared.bukkit.listener;
+
+import com.plotsquared.bukkit.util.BukkitEntityUtil;
+import com.plotsquared.bukkit.util.BukkitUtil;
+import com.plotsquared.core.PlotSquared;
+import com.plotsquared.core.configuration.Settings;
+import com.plotsquared.core.location.Location;
+import com.plotsquared.core.plot.Plot;
+import com.plotsquared.core.plot.PlotArea;
+import com.plotsquared.core.plot.flag.implementations.DisablePhysicsFlag;
+import com.plotsquared.core.plot.flag.implementations.ExplosionFlag;
+import com.plotsquared.core.plot.flag.implementations.InvincibleFlag;
+import com.plotsquared.core.plot.flag.implementations.MobPlaceFlag;
+import org.bukkit.Material;
+import org.bukkit.World;
+import org.bukkit.block.Block;
+import org.bukkit.entity.Ageable;
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.EntityType;
+import org.bukkit.entity.FallingBlock;
+import org.bukkit.entity.TNTPrimed;
+import org.bukkit.entity.Vehicle;
+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.EntityChangeBlockEvent;
+import org.bukkit.event.entity.EntityCombustByEntityEvent;
+import org.bukkit.event.entity.EntityDamageByEntityEvent;
+import org.bukkit.event.entity.EntityDamageEvent;
+import org.bukkit.event.entity.EntityExplodeEvent;
+import org.bukkit.event.entity.ExplosionPrimeEvent;
+import org.bukkit.event.vehicle.VehicleCreateEvent;
+import org.bukkit.metadata.FixedMetadataValue;
+import org.bukkit.metadata.MetadataValue;
+import org.bukkit.plugin.Plugin;
+
+import java.util.Iterator;
+import java.util.List;
+
+@SuppressWarnings("unused")
+public class EntityEventListener implements Listener {
+
+    private float lastRadius;
+
+    @EventHandler(priority = EventPriority.HIGHEST)
+    public void onEntityCombustByEntity(EntityCombustByEntityEvent event) {
+        EntityDamageByEntityEvent eventChange =
+            new EntityDamageByEntityEvent(event.getCombuster(), event.getEntity(),
+                EntityDamageEvent.DamageCause.FIRE_TICK, event.getDuration());
+        onEntityDamageByEntityEvent(eventChange);
+        if (eventChange.isCancelled()) {
+            event.setCancelled(true);
+        }
+    }
+
+    @EventHandler(priority = EventPriority.HIGHEST)
+    public void onEntityDamageByEntityEvent(EntityDamageByEntityEvent event) {
+        Entity damager = event.getDamager();
+        Location location = BukkitUtil.getLocation(damager);
+        if (!PlotSquared.get().hasPlotArea(location.getWorld())) {
+            return;
+        }
+        Entity victim = event.getEntity();
+/*
+        if (victim.getType().equals(EntityType.ITEM_FRAME)) {
+            Plot plot = BukkitUtil.getLocation(victim).getPlot();
+            if (plot != null && !plot.isAdded(damager.getUniqueId())) {
+                event.setCancelled(true);
+                return;
+            }
+        }
+*/
+        if (!BukkitEntityUtil.entityDamage(damager, victim, event.getCause())) {
+            if (event.isCancelled()) {
+                if (victim instanceof Ageable) {
+                    Ageable ageable = (Ageable) victim;
+                    if (ageable.getAge() == -24000) {
+                        ageable.setAge(0);
+                        ageable.setAdult();
+                    }
+                }
+            }
+            event.setCancelled(true);
+        }
+    }
+
+    @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
+    public void creatureSpawnEvent(CreatureSpawnEvent event) {
+        Entity entity = event.getEntity();
+        Location location = BukkitUtil.getLocation(entity.getLocation());
+        PlotArea area = location.getPlotArea();
+        if (area == null) {
+            return;
+        }
+        CreatureSpawnEvent.SpawnReason reason = event.getSpawnReason();
+        switch (reason.toString()) {
+            case "DISPENSE_EGG":
+            case "EGG":
+            case "OCELOT_BABY":
+            case "SPAWNER_EGG":
+                if (!area.isSpawnEggs()) {
+                    event.setCancelled(true);
+                    return;
+                }
+                break;
+            case "REINFORCEMENTS":
+            case "NATURAL":
+            case "MOUNT":
+            case "PATROL":
+            case "RAID":
+            case "SHEARED":
+            case "SHOULDER_ENTITY":
+            case "SILVERFISH_BLOCK":
+            case "TRAP":
+            case "VILLAGE_DEFENSE":
+            case "VILLAGE_INVASION":
+            case "BEEHIVE":
+            case "CHUNK_GEN":
+                if (!area.isMobSpawning()) {
+                    event.setCancelled(true);
+                    return;
+                }
+                break;
+            case "BREEDING":
+                if (!area.isSpawnBreeding()) {
+                    event.setCancelled(true);
+                    return;
+                }
+                break;
+            case "BUILD_IRONGOLEM":
+            case "BUILD_SNOWMAN":
+            case "BUILD_WITHER":
+            case "CUSTOM":
+                if (!area.isSpawnCustom() && entity.getType() != EntityType.ARMOR_STAND) {
+                    event.setCancelled(true);
+                    return;
+                }
+                break;
+            case "SPAWNER":
+                if (!area.isMobSpawnerSpawning()) {
+                    event.setCancelled(true);
+                    return;
+                }
+                break;
+        }
+        Plot plot = area.getOwnedPlotAbs(location);
+        if (plot == null) {
+            if (!area.isMobSpawning()) {
+                event.setCancelled(true);
+            }
+            return;
+        }
+        if (BukkitEntityUtil.checkEntity(entity, plot)) {
+            event.setCancelled(true);
+        }
+    }
+
+    @EventHandler(ignoreCancelled = true, priority = EventPriority.HIGHEST)
+    public void onEntityFall(EntityChangeBlockEvent event) {
+        if (event.getEntityType() != EntityType.FALLING_BLOCK) {
+            return;
+        }
+        Block block = event.getBlock();
+        World world = block.getWorld();
+        String worldName = world.getName();
+        if (!PlotSquared.get().hasPlotArea(worldName)) {
+            return;
+        }
+        Location location = BukkitUtil.getLocation(block.getLocation());
+        PlotArea area = location.getPlotArea();
+        if (area == null) {
+            return;
+        }
+        Plot plot = area.getOwnedPlotAbs(location);
+        if (plot == null || plot.getFlag(DisablePhysicsFlag.class)) {
+            event.setCancelled(true);
+            if (plot != null) {
+                if (block.getType().hasGravity()) {
+                    BlockEventListener.sendBlockChange(block.getLocation(), block.getBlockData());
+                }
+                plot.debug("Falling block event was cancelled because disable-physics = true");
+            }
+            return;
+        }
+        if (event.getTo().hasGravity()) {
+            Entity entity = event.getEntity();
+            List<MetadataValue> meta = entity.getMetadata("plot");
+            if (meta.isEmpty()) {
+                return;
+            }
+            Plot origin = (Plot) meta.get(0).value();
+            if (origin != null && !origin.equals(plot)) {
+                event.setCancelled(true);
+                entity.remove();
+            }
+        } else if (event.getTo() == Material.AIR) {
+            event.getEntity()
+                .setMetadata("plot", new FixedMetadataValue((Plugin) PlotSquared.get().IMP, plot));
+        }
+    }
+
+    @EventHandler(priority = EventPriority.HIGH) public void onDamage(EntityDamageEvent event) {
+        if (event.getEntityType() != EntityType.PLAYER) {
+            return;
+        }
+        Location location = BukkitUtil.getLocation(event.getEntity());
+        PlotArea area = location.getPlotArea();
+        if (area == null) {
+            return;
+        }
+        Plot plot = location.getOwnedPlot();
+        if (plot == null) {
+            if (area.isRoadFlags() && area.getRoadFlag(InvincibleFlag.class)) {
+                event.setCancelled(true);
+            }
+            return;
+        }
+        if (plot.getFlag(InvincibleFlag.class)) {
+            plot.debug(
+                event.getEntity().getName() + " could not take damage because invincible = true");
+            event.setCancelled(true);
+        }
+    }
+
+    @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
+    public void onBigBoom(EntityExplodeEvent event) {
+        Location location = BukkitUtil.getLocation(event.getLocation());
+        PlotArea area = location.getPlotArea();
+        boolean plotArea = location.isPlotArea();
+        if (!plotArea) {
+            if (!PlotSquared.get().hasPlotArea(location.getWorld())) {
+                return;
+            }
+            return;
+        }
+        Plot plot = area.getOwnedPlot(location);
+        if (plot != null) {
+            if (plot.getFlag(ExplosionFlag.class)) {
+                List<MetadataValue> meta = event.getEntity().getMetadata("plot");
+                Plot origin;
+                if (meta.isEmpty()) {
+                    origin = plot;
+                } else {
+                    origin = (Plot) meta.get(0).value();
+                }
+                if (this.lastRadius != 0) {
+                    List<Entity> nearby = event.getEntity()
+                        .getNearbyEntities(this.lastRadius, this.lastRadius, this.lastRadius);
+                    for (Entity near : nearby) {
+                        if (near instanceof TNTPrimed || near.getType()
+                            .equals(EntityType.MINECART_TNT)) {
+                            if (!near.hasMetadata("plot")) {
+                                near.setMetadata("plot",
+                                    new FixedMetadataValue((Plugin) PlotSquared.get().IMP, plot));
+                            }
+                        }
+                    }
+                    this.lastRadius = 0;
+                }
+                Iterator<Block> iterator = event.blockList().iterator();
+                while (iterator.hasNext()) {
+                    Block block = iterator.next();
+                    location = BukkitUtil.getLocation(block.getLocation());
+                    if (!area.contains(location.getX(), location.getZ()) || (origin != null
+                        && !origin.equals(area.getOwnedPlot(location)))) {
+                        iterator.remove();
+                    }
+                }
+                return;
+            } else {
+                plot.debug("Explosion was cancelled because explosion = false");
+            }
+        }
+        event.setCancelled(true);
+    }
+
+    @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
+    public void onPeskyMobsChangeTheWorldLikeWTFEvent(EntityChangeBlockEvent event) {
+        Entity e = event.getEntity();
+        if (!(e instanceof FallingBlock)) {
+            Location location = BukkitUtil.getLocation(event.getBlock().getLocation());
+            PlotArea area = location.getPlotArea();
+            if (area != null) {
+                Plot plot = area.getOwnedPlot(location);
+                if (plot != null && plot.getFlag(MobPlaceFlag.class)) {
+                    return;
+                }
+                if (plot != null) {
+                    plot.debug(e.getType() + " could not change block because mob-place = false");
+                }
+                event.setCancelled(true);
+            }
+        }
+    }
+
+    @EventHandler public void onPrime(ExplosionPrimeEvent event) {
+        this.lastRadius = event.getRadius() + 1;
+    }
+
+    @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
+    public void onVehicleCreate(VehicleCreateEvent event) {
+        Vehicle entity = event.getVehicle();
+        Location location = BukkitUtil.getLocation(entity);
+        PlotArea area = location.getPlotArea();
+        if (area == null) {
+            return;
+        }
+        Plot plot = area.getOwnedPlotAbs(location);
+        if (plot == null || BukkitEntityUtil.checkEntity(entity, plot)) {
+            entity.remove();
+            return;
+        }
+        if (Settings.Enabled_Components.KILL_ROAD_VEHICLES) {
+            entity
+                .setMetadata("plot", new FixedMetadataValue((Plugin) PlotSquared.get().IMP, plot));
+        }
+    }
+}

Bukkit/src/main/java/com/plotsquared/bukkit/listener/EntitySpawnListener.java

@@ -0,0 +1,203 @@
+/*
+ *       _____  _       _    _____                                _
+ *      |  __ \| |     | |  / ____|                              | |
+ *      | |__) | | ___ | |_| (___   __ _ _   _  __ _ _ __ ___  __| |
+ *      |  ___/| |/ _ \| __|\___ \ / _` | | | |/ _` | '__/ _ \/ _` |
+ *      | |    | | (_) | |_ ____) | (_| | |_| | (_| | | |  __/ (_| |
+ *      |_|    |_|\___/ \__|_____/ \__, |\__,_|\__,_|_|  \___|\__,_|
+ *                                    | |
+ *                                    |_|
+ *            PlotSquared plot management system for Minecraft
+ *                  Copyright (C) 2021 IntellectualSites
+ *
+ *     This program is free software: you can redistribute it and/or modify
+ *     it under the terms of the GNU 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 General Public License for more details.
+ *
+ *     You should have received a copy of the GNU General Public License
+ *     along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package com.plotsquared.bukkit.listener;
+
+import com.plotsquared.bukkit.util.BukkitEntityUtil;
+import com.plotsquared.bukkit.util.BukkitUtil;
+import com.plotsquared.core.PlotSquared;
+import com.plotsquared.core.configuration.Settings;
+import com.plotsquared.core.location.Location;
+import com.plotsquared.core.plot.Plot;
+import com.plotsquared.core.plot.PlotArea;
+import com.plotsquared.core.plot.flag.implementations.DoneFlag;
+import io.papermc.lib.PaperLib;
+import org.bukkit.Chunk;
+import org.bukkit.World;
+import org.bukkit.entity.ArmorStand;
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.EntityType;
+import org.bukkit.entity.Vehicle;
+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.EntitySpawnEvent;
+import org.bukkit.event.entity.EntityTeleportEvent;
+import org.bukkit.event.vehicle.VehicleBlockCollisionEvent;
+import org.bukkit.event.vehicle.VehicleCreateEvent;
+import org.bukkit.event.vehicle.VehicleMoveEvent;
+import org.bukkit.event.vehicle.VehicleUpdateEvent;
+import org.bukkit.event.world.ChunkLoadEvent;
+import org.bukkit.metadata.FixedMetadataValue;
+import org.bukkit.metadata.MetadataValue;
+import org.bukkit.plugin.Plugin;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.List;
+
+@SuppressWarnings("unused")
+public class EntitySpawnListener implements Listener {
+
+    private final static String KEY = "P2";
+    private static boolean ignoreTP = false;
+
+    public static void testNether(final Entity entity) {
+        @NotNull World world = entity.getWorld();
+        if (world.getEnvironment() != World.Environment.NETHER
+            && world.getEnvironment() != World.Environment.THE_END) {
+            return;
+        }
+        test(entity);
+    }
+
+    public static void testCreate(final Entity entity) {
+        @NotNull World world = entity.getWorld();
+        if (!PlotSquared.get().hasPlotArea(entity.getWorld().getName())) {
+            return;
+        }
+        test(entity);
+    }
+
+    public static void test(Entity entity) {
+        @NotNull World world = entity.getWorld();
+        List<MetadataValue> meta = entity.getMetadata(KEY);
+        if (meta.isEmpty()) {
+            if (PlotSquared.get().hasPlotArea(world.getName())) {
+                entity.setMetadata(KEY,
+                    new FixedMetadataValue((Plugin) PlotSquared.get().IMP, entity.getLocation()));
+            }
+        } else {
+            org.bukkit.Location origin = (org.bukkit.Location) meta.get(0).value();
+            World originWorld = origin.getWorld();
+            if (!originWorld.equals(world)) {
+                if (!ignoreTP) {
+                    if (!world.getName().equalsIgnoreCase(originWorld + "_the_end")) {
+                        if (entity.getType() == EntityType.PLAYER) {
+                            return;
+                        }
+                        try {
+                            ignoreTP = true;
+                            PaperLib.teleportAsync(entity, origin);
+                        } finally {
+                            ignoreTP = false;
+                        }
+                        if (entity.getLocation().getWorld().equals(world)) {
+                            entity.remove();
+                        }
+                    }
+                } else {
+                    if (entity.getType() == EntityType.PLAYER) {
+                        return;
+                    }
+                    entity.remove();
+                }
+            }
+        }
+    }
+
+    @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
+    public void creatureSpawnEvent(EntitySpawnEvent event) {
+        Entity entity = event.getEntity();
+        Location location = BukkitUtil.getLocation(entity.getLocation());
+        PlotArea area = location.getPlotArea();
+        if (!location.isPlotArea()) {
+            return;
+        }
+        Plot plot = location.getOwnedPlotAbs();
+        if (plot == null) {
+            EntityType type = entity.getType();
+            if (!area.isMobSpawning()) {
+                switch (type) {
+                    case DROPPED_ITEM:
+                        if (Settings.Enabled_Components.KILL_ROAD_ITEMS) {
+                            event.setCancelled(true);
+                            return;
+                        }
+                    case PLAYER:
+                        return;
+                }
+                if (type.isAlive()) {
+                    event.setCancelled(true);
+                }
+            }
+            if (!area.isMiscSpawnUnowned() && !type.isAlive()) {
+                event.setCancelled(true);
+            }
+            return;
+        }
+        if (Settings.Done.RESTRICT_BUILDING && DoneFlag.isDone(plot)) {
+            event.setCancelled(true);
+        }
+        switch (entity.getType()) {
+            case ENDER_CRYSTAL:
+                if (BukkitEntityUtil.checkEntity(entity, plot)) {
+                    event.setCancelled(true);
+                }
+            case SHULKER:
+                if (!entity.hasMetadata("shulkerPlot")) {
+                    entity.setMetadata("shulkerPlot",
+                        new FixedMetadataValue((Plugin) PlotSquared.get().IMP, plot.getId()));
+                }
+        }
+    }
+
+    @EventHandler public void onChunkLoad(ChunkLoadEvent event) {
+        @NotNull Chunk chunk = event.getChunk();
+        for (final Entity entity : chunk.getEntities()) {
+            testCreate(entity);
+        }
+    }
+
+    @EventHandler public void onVehicle(VehicleUpdateEvent event) {
+        testNether(event.getVehicle());
+    }
+
+    @EventHandler public void onVehicle(VehicleCreateEvent event) {
+        testCreate(event.getVehicle());
+    }
+
+    @EventHandler public void onVehicle(VehicleBlockCollisionEvent event) {
+        testNether(event.getVehicle());
+    }
+
+    @EventHandler public void onTeleport(EntityTeleportEvent event) {
+        Entity ent = event.getEntity();
+        if (ent instanceof Vehicle || ent instanceof ArmorStand) {
+            testNether(event.getEntity());
+        }
+    }
+
+    @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
+    public void vehicleMove(VehicleMoveEvent event) {
+        testNether(event.getVehicle());
+    }
+
+    @EventHandler public void spawn(CreatureSpawnEvent event) {
+        if (event.getEntityType() == EntityType.ARMOR_STAND) {
+            testCreate(event.getEntity());
+        }
+    }
+}

Bukkit/src/main/java/com/plotsquared/bukkit/listener/ForceFieldListener.java

@@ -0,0 +1,132 @@
+/*
+ *       _____  _       _    _____                                _
+ *      |  __ \| |     | |  / ____|                              | |
+ *      | |__) | | ___ | |_| (___   __ _ _   _  __ _ _ __ ___  __| |
+ *      |  ___/| |/ _ \| __|\___ \ / _` | | | |/ _` | '__/ _ \/ _` |
+ *      | |    | | (_) | |_ ____) | (_| | |_| | (_| | | |  __/ (_| |
+ *      |_|    |_|\___/ \__|_____/ \__, |\__,_|\__,_|_|  \___|\__,_|
+ *                                    | |
+ *                                    |_|
+ *            PlotSquared plot management system for Minecraft
+ *                  Copyright (C) 2021 IntellectualSites
+ *
+ *     This program is free software: you can redistribute it and/or modify
+ *     it under the terms of the GNU 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 General Public License for more details.
+ *
+ *     You should have received a copy of the GNU General Public License
+ *     along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package com.plotsquared.bukkit.listener;
+
+import com.google.common.collect.Iterables;
+import com.plotsquared.bukkit.player.BukkitPlayer;
+import com.plotsquared.bukkit.util.BukkitUtil;
+import com.plotsquared.core.configuration.Captions;
+import com.plotsquared.core.location.Location;
+import com.plotsquared.core.player.PlotPlayer;
+import com.plotsquared.core.plot.Plot;
+import com.plotsquared.core.plot.flag.implementations.ForcefieldFlag;
+import com.plotsquared.core.util.Permissions;
+import org.bukkit.entity.Player;
+import org.bukkit.util.Vector;
+
+import java.util.HashSet;
+import java.util.Set;
+import java.util.UUID;
+
+@SuppressWarnings("unused")
+public class ForceFieldListener {
+
+    private static Set<PlotPlayer> getNearbyPlayers(Player player, Plot plot) {
+        Set<PlotPlayer> players = new HashSet<>();
+        for (Player nearPlayer : Iterables
+            .filter(player.getNearbyEntities(5d, 5d, 5d), Player.class)) {
+            PlotPlayer plotPlayer;
+            if ((plotPlayer = BukkitUtil.getPlayer(nearPlayer)) == null || !plot
+                .equals(plotPlayer.getCurrentPlot())) {
+                continue;
+            }
+            if (!plot.isAdded(plotPlayer.getUUID())) {
+                players.add(plotPlayer);
+            }
+        }
+        return players;
+    }
+
+    private static PlotPlayer hasNearbyPermitted(Player player, Plot plot) {
+        for (Player nearPlayer : Iterables
+            .filter(player.getNearbyEntities(5d, 5d, 5d), Player.class)) {
+            PlotPlayer plotPlayer;
+            if ((plotPlayer = BukkitUtil.getPlayer(nearPlayer)) == null || !plot
+                .equals(plotPlayer.getCurrentPlot())) {
+                continue;
+            }
+            if (plot.isAdded(plotPlayer.getUUID())) {
+                return plotPlayer;
+            }
+        }
+        return null;
+    }
+
+    private static Vector calculateVelocity(PlotPlayer player, PlotPlayer e) {
+        Location playerLocation = player.getLocationFull();
+        Location oPlayerLocation = e.getLocation();
+        double playerX = playerLocation.getX();
+        double playerY = playerLocation.getY();
+        double playerZ = playerLocation.getZ();
+        double oPlayerX = oPlayerLocation.getX();
+        double oPlayerY = oPlayerLocation.getY();
+        double oPlayerZ = oPlayerLocation.getZ();
+        double x = 0d;
+        if (playerX < oPlayerX) {
+            x = 1.0d;
+        } else if (playerX > oPlayerX) {
+            x = -1.0d;
+        }
+        double y = 0d;
+        if (playerY < oPlayerY) {
+            y = 0.5d;
+        } else if (playerY > oPlayerY) {
+            y = -0.5d;
+        }
+        double z = 0d;
+        if (playerZ < oPlayerZ) {
+            z = 1.0d;
+        } else if (playerZ > oPlayerZ) {
+            z = -1.0d;
+        }
+        return new Vector(x, y, z);
+    }
+
+    public static void handleForcefield(Player player, PlotPlayer plotPlayer, Plot plot) {
+        if (plot.getFlag(ForcefieldFlag.class)) {
+            UUID uuid = plotPlayer.getUUID();
+            if (plot.isAdded(uuid)) {
+                Set<PlotPlayer> players = getNearbyPlayers(player, plot);
+                for (PlotPlayer oPlayer : players) {
+                    if (!Permissions
+                        .hasPermission(oPlayer, Captions.PERMISSION_ADMIN_ENTRY_FORCEFIELD)) {
+                        ((BukkitPlayer) oPlayer).player
+                            .setVelocity(calculateVelocity(plotPlayer, oPlayer));
+                    }
+                }
+            } else {
+                PlotPlayer oPlayer = hasNearbyPermitted(player, plot);
+                if (oPlayer == null) {
+                    return;
+                }
+                if (!Permissions
+                    .hasPermission(plotPlayer, Captions.PERMISSION_ADMIN_ENTRY_FORCEFIELD)) {
+                    player.setVelocity(calculateVelocity(oPlayer, plotPlayer));
+                }
+            }
+        }
+    }
+}

Bukkit/src/main/java/com/plotsquared/bukkit/listener/PaperListener.java

@@ -0,0 +1,364 @@
+/*
+ *       _____  _       _    _____                                _
+ *      |  __ \| |     | |  / ____|                              | |
+ *      | |__) | | ___ | |_| (___   __ _ _   _  __ _ _ __ ___  __| |
+ *      |  ___/| |/ _ \| __|\___ \ / _` | | | |/ _` | '__/ _ \/ _` |
+ *      | |    | | (_) | |_ ____) | (_| | |_| | (_| | | |  __/ (_| |
+ *      |_|    |_|\___/ \__|_____/ \__, |\__,_|\__,_|_|  \___|\__,_|
+ *                                    | |
+ *                                    |_|
+ *            PlotSquared plot management system for Minecraft
+ *                  Copyright (C) 2021 IntellectualSites
+ *
+ *     This program is free software: you can redistribute it and/or modify
+ *     it under the terms of the GNU 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 General Public License for more details.
+ *
+ *     You should have received a copy of the GNU General Public License
+ *     along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package com.plotsquared.bukkit.listener;
+
+import com.destroystokyo.paper.event.entity.EntityPathfindEvent;
+import com.destroystokyo.paper.event.entity.PlayerNaturallySpawnCreaturesEvent;
+import com.destroystokyo.paper.event.entity.PreCreatureSpawnEvent;
+import com.destroystokyo.paper.event.entity.PreSpawnerSpawnEvent;
+import com.destroystokyo.paper.event.entity.SlimePathfindEvent;
+import com.destroystokyo.paper.event.player.PlayerLaunchProjectileEvent;
+import com.destroystokyo.paper.event.server.AsyncTabCompleteEvent;
+import com.plotsquared.bukkit.util.BukkitUtil;
+import com.plotsquared.core.PlotSquared;
+import com.plotsquared.core.command.Command;
+import com.plotsquared.core.command.MainCommand;
+import com.plotsquared.core.configuration.Captions;
+import com.plotsquared.core.configuration.Settings;
+import com.plotsquared.core.location.Location;
+import com.plotsquared.core.player.PlotPlayer;
+import com.plotsquared.core.plot.Plot;
+import com.plotsquared.core.plot.PlotArea;
+import com.plotsquared.core.plot.flag.implementations.DoneFlag;
+import org.bukkit.Chunk;
+import org.bukkit.block.Block;
+import org.bukkit.block.TileState;
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.EntityType;
+import org.bukkit.entity.Player;
+import org.bukkit.entity.Projectile;
+import org.bukkit.entity.Slime;
+import org.bukkit.entity.ThrownPotion;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.Listener;
+import org.bukkit.event.block.BlockPlaceEvent;
+import org.bukkit.event.entity.CreatureSpawnEvent;
+import org.bukkit.projectiles.ProjectileSource;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+import java.util.Locale;
+import java.util.regex.Pattern;
+
+/**
+ * Events specific to Paper. Some toit nups here
+ */
+@SuppressWarnings("unused")
+public class PaperListener implements Listener {
+
+    private Chunk lastChunk;
+
+    @EventHandler public void onEntityPathfind(EntityPathfindEvent event) {
+        if (!Settings.Paper_Components.ENTITY_PATHING) {
+            return;
+        }
+        Location toLoc = BukkitUtil.getLocation(event.getLoc());
+        Location fromLoc = BukkitUtil.getLocation(event.getEntity().getLocation());
+        PlotArea tarea = toLoc.getPlotArea();
+        if (tarea == null) {
+            return;
+        }
+        PlotArea farea = fromLoc.getPlotArea();
+        if (farea == null) {
+            return;
+        }
+        if (tarea != farea) {
+            event.setCancelled(true);
+            return;
+        }
+        Plot tplot = toLoc.getPlot();
+        Plot fplot = fromLoc.getPlot();
+        if (tplot == null ^ fplot == null) {
+            event.setCancelled(true);
+            return;
+        }
+        if (tplot == null || tplot.getId().hashCode() == fplot.getId().hashCode()) {
+            return;
+        }
+        if (fplot.isMerged() && fplot.getConnectedPlots().contains(fplot)) {
+            return;
+        }
+        event.setCancelled(true);
+    }
+
+    @EventHandler public void onEntityPathfind(SlimePathfindEvent event) {
+        if (!Settings.Paper_Components.ENTITY_PATHING) {
+            return;
+        }
+        Slime slime = event.getEntity();
+
+        Block b = slime.getTargetBlock(4);
+        if (b == null) {
+            return;
+        }
+
+        Location toLoc = BukkitUtil.getLocation(b.getLocation());
+        Location fromLoc = BukkitUtil.getLocation(event.getEntity().getLocation());
+        PlotArea tarea = toLoc.getPlotArea();
+        if (tarea == null) {
+            return;
+        }
+        PlotArea farea = fromLoc.getPlotArea();
+        if (farea == null) {
+            return;
+        }
+
+        if (tarea != farea) {
+            event.setCancelled(true);
+            return;
+        }
+        Plot tplot = toLoc.getPlot();
+        Plot fplot = fromLoc.getPlot();
+        if (tplot == null ^ fplot == null) {
+            event.setCancelled(true);
+            return;
+        }
+        if (tplot == null || tplot.getId().hashCode() == fplot.getId().hashCode()) {
+            return;
+        }
+        if (fplot.isMerged() && fplot.getConnectedPlots().contains(fplot)) {
+            return;
+        }
+        event.setCancelled(true);
+    }
+
+    @EventHandler public void onPreCreatureSpawnEvent(PreCreatureSpawnEvent event) {
+        if (!Settings.Paper_Components.CREATURE_SPAWN) {
+            return;
+        }
+        Location location = BukkitUtil.getLocation(event.getSpawnLocation());
+        PlotArea area = location.getPlotArea();
+        if (!location.isPlotArea()) {
+            return;
+        }
+        //If entities are spawning... the chunk should be loaded?
+        Entity[] entities = event.getSpawnLocation().getChunk().getEntities();
+        if (entities.length > Settings.Chunk_Processor.MAX_ENTITIES) {
+            event.setShouldAbortSpawn(true);
+            event.setCancelled(true);
+            return;
+        }
+        CreatureSpawnEvent.SpawnReason reason = event.getReason();
+        switch (reason.toString()) {
+            case "DISPENSE_EGG":
+            case "EGG":
+            case "OCELOT_BABY":
+            case "SPAWNER_EGG":
+                if (!area.isSpawnEggs()) {
+                    event.setShouldAbortSpawn(true);
+                    event.setCancelled(true);
+                    return;
+                }
+                break;
+            case "REINFORCEMENTS":
+            case "NATURAL":
+            case "MOUNT":
+            case "PATROL":
+            case "RAID":
+            case "SHEARED":
+            case "SHOULDER_ENTITY":
+            case "SILVERFISH_BLOCK":
+            case "TRAP":
+            case "VILLAGE_DEFENSE":
+            case "VILLAGE_INVASION":
+            case "BEEHIVE":
+            case "CHUNK_GEN":
+                if (!area.isMobSpawning()) {
+                    event.setShouldAbortSpawn(true);
+                    event.setCancelled(true);
+                    return;
+                }
+                break;
+            case "BREEDING":
+                if (!area.isSpawnBreeding()) {
+                    event.setShouldAbortSpawn(true);
+                    event.setCancelled(true);
+                    return;
+                }
+                break;
+            case "BUILD_IRONGOLEM":
+            case "BUILD_SNOWMAN":
+            case "BUILD_WITHER":
+            case "CUSTOM":
+                if (!area.isSpawnCustom() && event.getType() != EntityType.ARMOR_STAND) {
+                    event.setShouldAbortSpawn(true);
+                    event.setCancelled(true);
+                    return;
+                }
+                break;
+            case "SPAWNER":
+                if (!area.isMobSpawnerSpawning()) {
+                    event.setShouldAbortSpawn(true);
+                    event.setCancelled(true);
+                    return;
+                }
+                break;
+        }
+        Plot plot = location.getOwnedPlotAbs();
+        if (plot == null) {
+            EntityType type = event.getType();
+            if (!area.isMobSpawning()) {
+                switch (type) {
+                    case DROPPED_ITEM:
+                        if (Settings.Enabled_Components.KILL_ROAD_ITEMS) {
+                            event.setShouldAbortSpawn(true);
+                            event.setCancelled(true);
+                            return;
+                        }
+                    case PLAYER:
+                        return;
+                }
+                if (type.isAlive()) {
+                    event.setShouldAbortSpawn(true);
+                    event.setCancelled(true);
+                }
+            }
+            if (!area.isMiscSpawnUnowned() && !type.isAlive()) {
+                event.setShouldAbortSpawn(true);
+                event.setCancelled(true);
+            }
+            return;
+        }
+        if (Settings.Done.RESTRICT_BUILDING && DoneFlag.isDone(plot)) {
+            event.setShouldAbortSpawn(true);
+            event.setCancelled(true);
+        }
+    }
+
+    @EventHandler
+    public void onPlayerNaturallySpawnCreaturesEvent(PlayerNaturallySpawnCreaturesEvent event) {
+        if (Settings.Paper_Components.CANCEL_CHUNK_SPAWN) {
+            Location location = BukkitUtil.getLocation(event.getPlayer().getLocation());
+            PlotArea area = location.getPlotArea();
+            if (area != null && !area.isMobSpawning()) {
+                event.setCancelled(true);
+            }
+        }
+    }
+
+    @EventHandler public void onPreSpawnerSpawnEvent(PreSpawnerSpawnEvent event) {
+        if (Settings.Paper_Components.SPAWNER_SPAWN) {
+            Location location = BukkitUtil.getLocation(event.getSpawnerLocation());
+            PlotArea area = location.getPlotArea();
+            if (area != null && !area.isMobSpawnerSpawning()) {
+                event.setCancelled(true);
+                event.setShouldAbortSpawn(true);
+            }
+        }
+    }
+
+    @EventHandler(priority = EventPriority.HIGHEST) public void onBlockPlace(BlockPlaceEvent event) {
+        if (!Settings.Paper_Components.TILE_ENTITY_CHECK || !Settings.Enabled_Components.CHUNK_PROCESSOR) {
+            return;
+        }
+        if (!(event.getBlock().getState(false) instanceof TileState)) {
+            return;
+        }
+        final Location location = BukkitUtil.getLocation(event.getBlock().getLocation());
+        final PlotArea plotArea = location.getPlotArea();
+        if (plotArea == null) {
+            return;
+        }
+        final int tileEntityCount = event.getBlock().getChunk().getTileEntities(false).length;
+        if (tileEntityCount >= Settings.Chunk_Processor.MAX_TILES) {
+            final PlotPlayer<?> plotPlayer = BukkitUtil.getPlayer(event.getPlayer());
+            Captions.TILE_ENTITY_CAP_REACHED.send(plotPlayer, Settings.Chunk_Processor.MAX_TILES);
+            event.setCancelled(true);
+            event.setBuild(false);
+        }
+    }
+
+    /**
+     * Unsure if this will be any performance improvement over the spigot version,
+     * but here it is anyway :)
+     *
+     * @param event Paper's PlayerLaunchProjectileEvent
+     */
+    @EventHandler public void onProjectileLaunch(PlayerLaunchProjectileEvent event) {
+        if (!Settings.Paper_Components.PLAYER_PROJECTILE) {
+            return;
+        }
+        Projectile entity = event.getProjectile();
+        if (!(entity instanceof ThrownPotion)) {
+            return;
+        }
+        ProjectileSource shooter = entity.getShooter();
+        if (!(shooter instanceof Player)) {
+            return;
+        }
+        Location location = BukkitUtil.getLocation(entity);
+        if (!PlotSquared.get().hasPlotArea(location.getWorld())) {
+            return;
+        }
+        PlotPlayer<?> pp = BukkitUtil.getPlayer((Player) shooter);
+        Plot plot = location.getOwnedPlot();
+        if (plot != null && !plot.isAdded(pp.getUUID())) {
+            entity.remove();
+            event.setCancelled(true);
+        }
+    }
+
+    @EventHandler public void onAsyncTabCompletion(final AsyncTabCompleteEvent event) {
+        if (!Settings.Paper_Components.ASYNC_TAB_COMPLETION) {
+            return;
+        }
+        String buffer = event.getBuffer();
+        if (!(event.getSender() instanceof Player)) {
+            return;
+        }
+        if ((!event.isCommand() && !buffer.startsWith("/")) || buffer.indexOf(' ') == -1) {
+            return;
+        }
+        if (buffer.startsWith("/")) {
+            buffer = buffer.substring(1);
+        }
+        final String[] unprocessedArgs = buffer.split(Pattern.quote(" "));
+        if (unprocessedArgs.length == 1) {
+            return; // We don't do anything in this case
+        } else if (!Settings.Enabled_Components.TAB_COMPLETED_ALIASES
+            .contains(unprocessedArgs[0].toLowerCase(Locale.ENGLISH))) {
+            return;
+        }
+        final String[] args = new String[unprocessedArgs.length - 1];
+        System.arraycopy(unprocessedArgs, 1, args, 0, args.length);
+        try {
+            final PlotPlayer<?> player = BukkitUtil.getPlayer((Player) event.getSender());
+            final Collection<Command> objects = MainCommand.getInstance().tab(player, args, buffer.endsWith(" "));
+            if (objects == null) {
+                return;
+            }
+            final List<String> result = new ArrayList<>();
+            for (final com.plotsquared.core.command.Command o : objects) {
+                result.add(o.toString());
+            }
+            event.setCompletions(result);
+            event.setHandled(true);
+        } catch (final Exception ignored) {}
+    }
+
+}

Bukkit/src/main/java/com/plotsquared/bukkit/listener/PaperListener113.java

@@ -0,0 +1,83 @@
+/*
+ *       _____  _       _    _____                                _
+ *      |  __ \| |     | |  / ____|                              | |
+ *      | |__) | | ___ | |_| (___   __ _ _   _  __ _ _ __ ___  __| |
+ *      |  ___/| |/ _ \| __|\___ \ / _` | | | |/ _` | '__/ _ \/ _` |
+ *      | |    | | (_) | |_ ____) | (_| | |_| | (_| | | |  __/ (_| |
+ *      |_|    |_|\___/ \__|_____/ \__, |\__,_|\__,_|_|  \___|\__,_|
+ *                                    | |
+ *                                    |_|
+ *            PlotSquared plot management system for Minecraft
+ *                  Copyright (C) 2021 IntellectualSites
+ *
+ *     This program is free software: you can redistribute it and/or modify
+ *     it under the terms of the GNU 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 General Public License for more details.
+ *
+ *     You should have received a copy of the GNU General Public License
+ *     along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package com.plotsquared.bukkit.listener;
+
+import com.plotsquared.bukkit.util.BukkitUtil;
+import com.plotsquared.core.configuration.Captions;
+import com.plotsquared.core.configuration.Settings;
+import com.plotsquared.core.location.Location;
+import com.plotsquared.core.player.PlotPlayer;
+import com.plotsquared.core.plot.PlotArea;
+import org.bukkit.block.Banner;
+import org.bukkit.block.Beacon;
+import org.bukkit.block.Bed;
+import org.bukkit.block.BlockState;
+import org.bukkit.block.CommandBlock;
+import org.bukkit.block.Comparator;
+import org.bukkit.block.Conduit;
+import org.bukkit.block.Container;
+import org.bukkit.block.CreatureSpawner;
+import org.bukkit.block.DaylightDetector;
+import org.bukkit.block.EnchantingTable;
+import org.bukkit.block.EndGateway;
+import org.bukkit.block.EnderChest;
+import org.bukkit.block.Jukebox;
+import org.bukkit.block.Sign;
+import org.bukkit.block.Skull;
+import org.bukkit.block.Structure;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.block.BlockPlaceEvent;
+
+public class PaperListener113 extends PaperListener {
+
+    @EventHandler
+    public void onBlockPlace(BlockPlaceEvent event) {
+        if (!Settings.Paper_Components.TILE_ENTITY_CHECK || !Settings.Enabled_Components.CHUNK_PROCESSOR) {
+            return;
+        }
+        BlockState state = event.getBlock().getState(false);
+        if (!(state instanceof Banner || state instanceof Beacon || state instanceof Bed
+                || state instanceof CommandBlock || state instanceof Comparator || state instanceof Conduit
+                || state instanceof Container || state instanceof CreatureSpawner || state instanceof DaylightDetector
+                || state instanceof EnchantingTable || state instanceof EnderChest || state instanceof EndGateway
+                || state instanceof Jukebox || state instanceof Sign || state instanceof Skull
+                || state instanceof Structure)) {
+            return;
+        }
+        final Location location = BukkitUtil.getLocation(event.getBlock().getLocation());
+        final PlotArea plotArea = location.getPlotArea();
+        if (plotArea == null) {
+            return;
+        }
+        final int tileEntityCount = event.getBlock().getChunk().getTileEntities(false).length;
+        if (tileEntityCount >= Settings.Chunk_Processor.MAX_TILES) {
+            final PlotPlayer<?> plotPlayer = BukkitUtil.getPlayer(event.getPlayer());
+            Captions.TILE_ENTITY_CAP_REACHED.send(plotPlayer, Settings.Chunk_Processor.MAX_TILES);
+            event.setCancelled(true);
+            event.setBuild(false);
+        }
+    }
+}

Bukkit/src/main/java/com/plotsquared/bukkit/listener/ProjectileEventListener.java

@@ -0,0 +1,156 @@
+/*
+ *       _____  _       _    _____                                _
+ *      |  __ \| |     | |  / ____|                              | |
+ *      | |__) | | ___ | |_| (___   __ _ _   _  __ _ _ __ ___  __| |
+ *      |  ___/| |/ _ \| __|\___ \ / _` | | | |/ _` | '__/ _ \/ _` |
+ *      | |    | | (_) | |_ ____) | (_| | |_| | (_| | | |  __/ (_| |
+ *      |_|    |_|\___/ \__|_____/ \__, |\__,_|\__,_|_|  \___|\__,_|
+ *                                    | |
+ *                                    |_|
+ *            PlotSquared plot management system for Minecraft
+ *                  Copyright (C) 2021 IntellectualSites
+ *
+ *     This program is free software: you can redistribute it and/or modify
+ *     it under the terms of the GNU 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 General Public License for more details.
+ *
+ *     You should have received a copy of the GNU General Public License
+ *     along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package com.plotsquared.bukkit.listener;
+
+import com.plotsquared.bukkit.util.BukkitEntityUtil;
+import com.plotsquared.bukkit.util.BukkitUtil;
+import com.plotsquared.core.PlotSquared;
+import com.plotsquared.core.configuration.Captions;
+import com.plotsquared.core.location.Location;
+import com.plotsquared.core.player.PlotPlayer;
+import com.plotsquared.core.plot.Plot;
+import com.plotsquared.core.plot.PlotArea;
+import com.plotsquared.core.plot.PlotHandler;
+import com.plotsquared.core.util.Permissions;
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.LivingEntity;
+import org.bukkit.entity.Player;
+import org.bukkit.entity.Projectile;
+import org.bukkit.entity.ThrownPotion;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.Listener;
+import org.bukkit.event.entity.LingeringPotionSplashEvent;
+import org.bukkit.event.entity.PotionSplashEvent;
+import org.bukkit.event.entity.ProjectileHitEvent;
+import org.bukkit.event.entity.ProjectileLaunchEvent;
+import org.bukkit.projectiles.BlockProjectileSource;
+import org.bukkit.projectiles.ProjectileSource;
+
+@SuppressWarnings("unused")
+public class ProjectileEventListener implements Listener {
+
+    @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
+    public void onPotionSplash(LingeringPotionSplashEvent event) {
+        Projectile entity = event.getEntity();
+        Location location = BukkitUtil.getLocation(entity);
+        if (!PlotSquared.get().hasPlotArea(location.getWorld())) {
+            return;
+        }
+        if (!this.onProjectileHit(event)) {
+            event.setCancelled(true);
+        }
+    }
+
+    @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
+    public void onPotionSplash(PotionSplashEvent event) {
+        ThrownPotion damager = event.getPotion();
+        Location location = BukkitUtil.getLocation(damager);
+        if (!PlotSquared.get().hasPlotArea(location.getWorld())) {
+            return;
+        }
+        int count = 0;
+        for (LivingEntity victim : event.getAffectedEntities()) {
+            if (!BukkitEntityUtil.entityDamage(damager, victim)) {
+                event.setIntensity(victim, 0);
+                count++;
+            }
+        }
+        if ((count > 0 && count == event.getAffectedEntities().size()) || !onProjectileHit(event)) {
+            event.setCancelled(true);
+        }
+    }
+
+    @EventHandler public void onProjectileLaunch(ProjectileLaunchEvent event) {
+        Projectile entity = event.getEntity();
+        if (!(entity instanceof ThrownPotion)) {
+            return;
+        }
+        ProjectileSource shooter = entity.getShooter();
+        if (!(shooter instanceof Player)) {
+            return;
+        }
+        Location location = BukkitUtil.getLocation(entity);
+        if (!PlotSquared.get().hasPlotArea(location.getWorld())) {
+            return;
+        }
+        PlotPlayer<Player> pp = BukkitUtil.getPlayer((Player) shooter);
+        Plot plot = location.getOwnedPlot();
+        if (plot != null && !plot.isAdded(pp.getUUID())) {
+            entity.remove();
+            event.setCancelled(true);
+        }
+    }
+
+    @SuppressWarnings({"BooleanMethodIsAlwaysInverted", "cos it's not... dum IntelliJ"}) @EventHandler
+    public boolean onProjectileHit(ProjectileHitEvent event) {
+        Projectile entity = event.getEntity();
+        Location location = BukkitUtil.getLocation(entity);
+        if (!PlotSquared.get().hasPlotArea(location.getWorld())) {
+            return true;
+        }
+        PlotArea area = location.getPlotArea();
+        if (area == null) {
+            return true;
+        }
+        Plot plot = area.getPlot(location);
+        ProjectileSource shooter = entity.getShooter();
+        if (shooter instanceof Player) {
+            PlotPlayer<?> pp = BukkitUtil.getPlayer((Player) shooter);
+            if (plot == null) {
+                if (!Permissions.hasPermission(pp, Captions.PERMISSION_PROJECTILE_UNOWNED)) {
+                    entity.remove();
+                    return false;
+                }
+                return true;
+            }
+            if (plot.isAdded(pp.getUUID()) || Permissions
+                .hasPermission(pp, Captions.PERMISSION_PROJECTILE_OTHER)) {
+                return true;
+            }
+            entity.remove();
+            return false;
+        }
+        if (!(shooter instanceof Entity) && shooter != null) {
+            if (plot == null) {
+                entity.remove();
+                return false;
+            }
+            Location sLoc =
+                BukkitUtil.getLocation(((BlockProjectileSource) shooter).getBlock().getLocation());
+            if (!area.contains(sLoc.getX(), sLoc.getZ())) {
+                entity.remove();
+                return false;
+            }
+            Plot sPlot = area.getOwnedPlotAbs(sLoc);
+            if (sPlot == null || !PlotHandler.sameOwners(plot, sPlot)) {
+                entity.remove();
+                return false;
+            }
+        }
+        return true;
+    }
+}

Bukkit/src/main/java/com/plotsquared/bukkit/listener/ServerListener.java

@@ -0,0 +1,52 @@
+/*
+ *       _____  _       _    _____                                _
+ *      |  __ \| |     | |  / ____|                              | |
+ *      | |__) | | ___ | |_| (___   __ _ _   _  __ _ _ __ ___  __| |
+ *      |  ___/| |/ _ \| __|\___ \ / _` | | | |/ _` | '__/ _ \/ _` |
+ *      | |    | | (_) | |_ ____) | (_| | |_| | (_| | | |  __/ (_| |
+ *      |_|    |_|\___/ \__|_____/ \__, |\__,_|\__,_|_|  \___|\__,_|
+ *                                    | |
+ *                                    |_|
+ *            PlotSquared plot management system for Minecraft
+ *                  Copyright (C) 2021 IntellectualSites
+ *
+ *     This program is free software: you can redistribute it and/or modify
+ *     it under the terms of the GNU 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 General Public License for more details.
+ *
+ *     You should have received a copy of the GNU General Public License
+ *     along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package com.plotsquared.bukkit.listener;
+
+import com.plotsquared.bukkit.BukkitMain;
+import com.plotsquared.bukkit.placeholder.MVdWPlaceholders;
+import com.plotsquared.core.PlotSquared;
+import com.plotsquared.core.configuration.Captions;
+import com.plotsquared.core.configuration.Settings;
+import org.bukkit.Bukkit;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.server.ServerLoadEvent;
+
+public class ServerListener implements Listener {
+
+    private final BukkitMain plugin;
+
+    public ServerListener(BukkitMain plugin) {
+        this.plugin = plugin;
+    }
+
+    @EventHandler public void onServerLoad(ServerLoadEvent event) {
+        if (Bukkit.getPluginManager().getPlugin("MVdWPlaceholderAPI") != null && Settings.Enabled_Components.USE_MVDWAPI) {
+            new MVdWPlaceholders(this.plugin, PlotSquared.get().getPlaceholderRegistry());
+            PlotSquared.log(Captions.PREFIX + "&6PlotSquared hooked into MVdWPlaceholderAPI");
+        }
+    }
+}

Bukkit/src/main/java/com/plotsquared/bukkit/listener/SingleWorldListener.java

@@ -0,0 +1,132 @@
+/*
+ *       _____  _       _    _____                                _
+ *      |  __ \| |     | |  / ____|                              | |
+ *      | |__) | | ___ | |_| (___   __ _ _   _  __ _ _ __ ___  __| |
+ *      |  ___/| |/ _ \| __|\___ \ / _` | | | |/ _` | '__/ _ \/ _` |
+ *      | |    | | (_) | |_ ____) | (_| | |_| | (_| | | |  __/ (_| |
+ *      |_|    |_|\___/ \__|_____/ \__, |\__,_|\__,_|_|  \___|\__,_|
+ *                                    | |
+ *                                    |_|
+ *            PlotSquared plot management system for Minecraft
+ *                  Copyright (C) 2021 IntellectualSites
+ *
+ *     This program is free software: you can redistribute it and/or modify
+ *     it under the terms of the GNU 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 General Public License for more details.
+ *
+ *     You should have received a copy of the GNU General Public License
+ *     along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package com.plotsquared.bukkit.listener;
+
+import com.plotsquared.core.PlotSquared;
+import com.plotsquared.core.plot.world.PlotAreaManager;
+import com.plotsquared.core.plot.world.SinglePlotAreaManager;
+import com.plotsquared.core.util.ReflectionUtils;
+import org.bukkit.Bukkit;
+import org.bukkit.Chunk;
+import org.bukkit.World;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.Listener;
+import org.bukkit.event.world.ChunkEvent;
+import org.bukkit.event.world.ChunkLoadEvent;
+import org.bukkit.plugin.Plugin;
+
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+
+import static com.plotsquared.core.util.ReflectionUtils.getRefClass;
+
+@SuppressWarnings("unused")
+public class SingleWorldListener implements Listener {
+
+    private Method methodGetHandleChunk;
+    private Field mustSave;
+    private boolean isTrueForNotSave = true;
+
+    public SingleWorldListener(Plugin plugin) throws Exception {
+        ReflectionUtils.RefClass classChunk = getRefClass("{nms}.Chunk");
+        ReflectionUtils.RefClass classCraftChunk = getRefClass("{cb}.CraftChunk");
+        this.methodGetHandleChunk = classCraftChunk.getMethod("getHandle").getRealMethod();
+        try {
+            if (PlotSquared.get().IMP.getServerVersion()[1] == 13) {
+                this.mustSave = classChunk.getField("mustSave").getRealField();
+                this.isTrueForNotSave = false;
+            } else {
+                this.mustSave = classChunk.getField("mustNotSave").getRealField();
+            }
+        } catch (NoSuchFieldException e) {
+            e.printStackTrace();
+        }
+        Bukkit.getPluginManager().registerEvents(this, plugin);
+    }
+
+    public void markChunkAsClean(Chunk chunk) {
+        try {
+            Object nmsChunk = methodGetHandleChunk.invoke(chunk);
+            if (mustSave != null) {
+                this.mustSave.set(nmsChunk, false);
+            }
+        } catch (Throwable e) {
+            e.printStackTrace();
+        }
+    }
+
+    private void handle(ChunkEvent event) {
+        World world = event.getWorld();
+        String name = world.getName();
+        PlotAreaManager man = PlotSquared.get().getPlotAreaManager();
+        if (!(man instanceof SinglePlotAreaManager)) {
+            return;
+        }
+        if (!isPlotId(name)) {
+            return;
+        }
+
+        markChunkAsClean(event.getChunk());
+    }
+
+    //    @EventHandler
+    //    public void onPopulate(ChunkPopulateEvent event) {
+    //        handle(event);
+    //    }
+
+    @EventHandler(priority = EventPriority.LOWEST) public void onChunkLoad(ChunkLoadEvent event) {
+        handle(event);
+    }
+
+    private boolean isPlotId(String worldName) {
+        int len = worldName.length();
+        int separator = 0;
+        for (int i = 0; i < len; i++) {
+            switch (worldName.charAt(i)) {
+                case ',':
+                case ';':
+                    separator++;
+                    break;
+                case '-':
+                case '0':
+                case '1':
+                case '2':
+                case '3':
+                case '4':
+                case '5':
+                case '6':
+                case '7':
+                case '8':
+                case '9':
+                    break;
+                default:
+                    return false;
+            }
+        }
+        return separator == 1;
+    }
+}

Bukkit/src/main/java/com/plotsquared/bukkit/listener/WorldEvents.java

@@ -0,0 +1,62 @@
+/*
+ *       _____  _       _    _____                                _
+ *      |  __ \| |     | |  / ____|                              | |
+ *      | |__) | | ___ | |_| (___   __ _ _   _  __ _ _ __ ___  __| |
+ *      |  ___/| |/ _ \| __|\___ \ / _` | | | |/ _` | '__/ _ \/ _` |
+ *      | |    | | (_) | |_ ____) | (_| | |_| | (_| | | |  __/ (_| |
+ *      |_|    |_|\___/ \__|_____/ \__, |\__,_|\__,_|_|  \___|\__,_|
+ *                                    | |
+ *                                    |_|
+ *            PlotSquared plot management system for Minecraft
+ *                  Copyright (C) 2021 IntellectualSites
+ *
+ *     This program is free software: you can redistribute it and/or modify
+ *     it under the terms of the GNU 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 General Public License for more details.
+ *
+ *     You should have received a copy of the GNU General Public License
+ *     along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package com.plotsquared.bukkit.listener;
+
+import com.plotsquared.bukkit.generator.BukkitPlotGenerator;
+import com.plotsquared.core.PlotSquared;
+import com.plotsquared.core.generator.GeneratorWrapper;
+import com.plotsquared.core.plot.world.PlotAreaManager;
+import com.plotsquared.core.plot.world.SinglePlotAreaManager;
+import org.bukkit.World;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.Listener;
+import org.bukkit.event.world.WorldInitEvent;
+import org.bukkit.generator.ChunkGenerator;
+
+@SuppressWarnings("unused")
+public class WorldEvents implements Listener {
+
+    @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
+    public void onWorldInit(WorldInitEvent event) {
+        World world = event.getWorld();
+        String name = world.getName();
+        PlotAreaManager manager = PlotSquared.get().getPlotAreaManager();
+        if (manager instanceof SinglePlotAreaManager) {
+            SinglePlotAreaManager single = (SinglePlotAreaManager) manager;
+            if (single.isWorld(name)) {
+                world.setKeepSpawnInMemory(false);
+                return;
+            }
+        }
+        ChunkGenerator gen = world.getGenerator();
+        if (gen instanceof GeneratorWrapper) {
+            PlotSquared.get().loadWorld(name, (GeneratorWrapper<?>) gen);
+        } else {
+            PlotSquared.get().loadWorld(name, new BukkitPlotGenerator(name, gen));
+        }
+    }
+}

Bukkit/src/main/java/com/plotsquared/bukkit/managers/BukkitWorldManager.java

@@ -0,0 +1,91 @@
+/*
+ *       _____  _       _    _____                                _
+ *      |  __ \| |     | |  / ____|                              | |
+ *      | |__) | | ___ | |_| (___   __ _ _   _  __ _ _ __ ___  __| |
+ *      |  ___/| |/ _ \| __|\___ \ / _` | | | |/ _` | '__/ _ \/ _` |
+ *      | |    | | (_) | |_ ____) | (_| | |_| | (_| | | |  __/ (_| |
+ *      |_|    |_|\___/ \__|_____/ \__, |\__,_|\__,_|_|  \___|\__,_|
+ *                                    | |
+ *                                    |_|
+ *            PlotSquared plot management system for Minecraft
+ *                  Copyright (C) 2021 IntellectualSites
+ *
+ *     This program is free software: you can redistribute it and/or modify
+ *     it under the terms of the GNU 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 General Public License for more details.
+ *
+ *     You should have received a copy of the GNU General Public License
+ *     along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package com.plotsquared.bukkit.managers;
+
+import com.plotsquared.core.configuration.file.YamlConfiguration;
+import com.plotsquared.core.util.PlatformWorldManager;
+import org.bukkit.Bukkit;
+import org.bukkit.World;
+import org.bukkit.WorldCreator;
+import org.bukkit.WorldType;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+
+/**
+ * Default Bukkit world manager. It will handle world creation by
+ * registering the generator in bukkit.yml
+ */
+public class BukkitWorldManager implements PlatformWorldManager<World> {
+
+    @Override public void initialize() {
+    }
+
+    @Override @Nullable
+    public World handleWorldCreation(@NotNull String worldName, @Nullable String generator) {
+        this.setGenerator(worldName, generator);
+        final WorldCreator wc = new WorldCreator(worldName);
+        wc.environment(World.Environment.NORMAL);
+        if (generator != null) {
+            wc.generator(generator);
+            wc.type(WorldType.FLAT);
+        }
+        return Bukkit.createWorld(wc);
+    }
+
+    protected void setGenerator(@Nullable final String worldName, @Nullable final String generator) {
+        if (generator == null || worldName != null && worldName.contains(".")) {
+            return;
+        }
+        File file = new File("bukkit.yml").getAbsoluteFile();
+        YamlConfiguration yml = YamlConfiguration.loadConfiguration(file);
+        yml.set(String.format("worlds.%s.generator", worldName), generator);
+        try {
+            yml.save(file);
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+    }
+
+    @Override public String getName() {
+        return "bukkit";
+    }
+
+    @Override public Collection<String> getWorlds() {
+        final List<World> worlds = Bukkit.getWorlds();
+        final List<String> worldNames = new ArrayList<>();
+        for (final World world : worlds) {
+            worldNames.add(world.getName());
+        }
+        return worldNames;
+    }
+
+}

Bukkit/src/main/java/com/plotsquared/bukkit/managers/HyperverseWorldManager.java

@@ -0,0 +1,66 @@
+/*
+ *       _____  _       _    _____                                _
+ *      |  __ \| |     | |  / ____|                              | |
+ *      | |__) | | ___ | |_| (___   __ _ _   _  __ _ _ __ ___  __| |
+ *      |  ___/| |/ _ \| __|\___ \ / _` | | | |/ _` | '__/ _ \/ _` |
+ *      | |    | | (_) | |_ ____) | (_| | |_| | (_| | | |  __/ (_| |
+ *      |_|    |_|\___/ \__|_____/ \__, |\__,_|\__,_|_|  \___|\__,_|
+ *                                    | |
+ *                                    |_|
+ *            PlotSquared plot management system for Minecraft
+ *                  Copyright (C) 2021 IntellectualSites
+ *
+ *     This program is free software: you can redistribute it and/or modify
+ *     it under the terms of the GNU 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 General Public License for more details.
+ *
+ *     You should have received a copy of the GNU General Public License
+ *     along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package com.plotsquared.bukkit.managers;
+
+import org.bukkit.World;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import se.hyperver.hyperverse.Hyperverse;
+import se.hyperver.hyperverse.world.WorldConfiguration;
+import se.hyperver.hyperverse.world.WorldConfigurationBuilder;
+import se.hyperver.hyperverse.world.WorldFeatures;
+import se.hyperver.hyperverse.world.WorldType;
+
+/**
+ * Hyperverse specific manager that creates worlds
+ * using Hyperverse's API
+ */
+public class HyperverseWorldManager extends BukkitWorldManager {
+
+    @Override @Nullable
+    public World handleWorldCreation(@NotNull String worldName, @Nullable String generator) {
+        // First let Bukkit register the world
+        this.setGenerator(worldName, generator);
+        // Create the world
+        final WorldConfigurationBuilder worldConfigurationBuilder = WorldConfiguration.builder()
+            .setName(worldName).setType(WorldType.OVER_WORLD);
+        if (generator != null) {
+            worldConfigurationBuilder.setGenerator(generator).setWorldFeatures(WorldFeatures.FLATLAND);
+        }
+        try {
+            return Hyperverse.getApi().createWorld(worldConfigurationBuilder.createWorldConfiguration())
+                .getBukkitWorld();
+        } catch (final Exception e) {
+            e.printStackTrace();
+        }
+        return null;
+    }
+
+    @Override public String getName() {
+        return "bukkit-hyperverse";
+    }
+
+}

Bukkit/src/main/java/com/plotsquared/bukkit/managers/MultiverseWorldManager.java

@@ -0,0 +1,57 @@
+/*
+ *       _____  _       _    _____                                _
+ *      |  __ \| |     | |  / ____|                              | |
+ *      | |__) | | ___ | |_| (___   __ _ _   _  __ _ _ __ ___  __| |
+ *      |  ___/| |/ _ \| __|\___ \ / _` | | | |/ _` | '__/ _ \/ _` |
+ *      | |    | | (_) | |_ ____) | (_| | |_| | (_| | | |  __/ (_| |
+ *      |_|    |_|\___/ \__|_____/ \__, |\__,_|\__,_|_|  \___|\__,_|
+ *                                    | |
+ *                                    |_|
+ *            PlotSquared plot management system for Minecraft
+ *                  Copyright (C) 2021 IntellectualSites
+ *
+ *     This program is free software: you can redistribute it and/or modify
+ *     it under the terms of the GNU 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 General Public License for more details.
+ *
+ *     You should have received a copy of the GNU General Public License
+ *     along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package com.plotsquared.bukkit.managers;
+
+import org.bukkit.Bukkit;
+import org.bukkit.World;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+/**
+ * Multiverse specific manager that informs Multiverse of
+ * world creation by executing a console command
+ */
+public class MultiverseWorldManager extends BukkitWorldManager {
+
+    @Override @Nullable
+    public World handleWorldCreation(@NotNull final String worldName, @Nullable final String generator) {
+        // First let Bukkit register the world
+        this.setGenerator(worldName, generator);
+        // Then we send the console command
+        final StringBuilder commandBuilder = new StringBuilder("mv create ")
+            .append(worldName).append(" normal");
+        if (generator != null) {
+            commandBuilder.append(" -g ").append(generator);
+        }
+        Bukkit.getServer().dispatchCommand(Bukkit.getServer().getConsoleSender(), commandBuilder.toString());
+        return Bukkit.getWorld(worldName);
+    }
+
+    @Override public String getName() {
+        return "bukkit-multiverse";
+    }
+
+}

Bukkit/src/main/java/com/plotsquared/bukkit/placeholder/MVdWPlaceholders.java

@@ -0,0 +1,78 @@
+/*
+ *       _____  _       _    _____                                _
+ *      |  __ \| |     | |  / ____|                              | |
+ *      | |__) | | ___ | |_| (___   __ _ _   _  __ _ _ __ ___  __| |
+ *      |  ___/| |/ _ \| __|\___ \ / _` | | | |/ _` | '__/ _ \/ _` |
+ *      | |    | | (_) | |_ ____) | (_| | |_| | (_| | | |  __/ (_| |
+ *      |_|    |_|\___/ \__|_____/ \__, |\__,_|\__,_|_|  \___|\__,_|
+ *                                    | |
+ *                                    |_|
+ *            PlotSquared plot management system for Minecraft
+ *                  Copyright (C) 2021 IntellectualSites
+ *
+ *     This program is free software: you can redistribute it and/or modify
+ *     it under the terms of the GNU 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 General Public License for more details.
+ *
+ *     You should have received a copy of the GNU General Public License
+ *     along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package com.plotsquared.bukkit.placeholder;
+
+import be.maximvdw.placeholderapi.PlaceholderAPI;
+import com.google.common.eventbus.Subscribe;
+import com.plotsquared.bukkit.util.BukkitUtil;
+import com.plotsquared.core.PlotSquared;
+import com.plotsquared.core.player.PlotPlayer;
+import com.plotsquared.core.util.placeholders.Placeholder;
+import com.plotsquared.core.util.placeholders.PlaceholderRegistry;
+import org.bukkit.entity.Player;
+import org.bukkit.plugin.Plugin;
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * Placeholder support for MVdWPlaceholderAPI
+ */
+public class MVdWPlaceholders {
+
+    private static final String PREFIX = "plotsquared_";
+    private final Plugin plugin;
+    private final PlaceholderRegistry registry;
+
+    public MVdWPlaceholders(@NotNull final Plugin plugin,
+                            @NotNull final PlaceholderRegistry registry) {
+        this.plugin = plugin;
+        this.registry = registry;
+        for (final Placeholder placeholder : registry.getPlaceholders()) {
+            this.addPlaceholder(placeholder);
+        }
+        PlotSquared.get().getEventDispatcher().registerListener(this);
+    }
+
+    @Subscribe public void onNewPlaceholder(@NotNull final
+        PlaceholderRegistry.PlaceholderAddedEvent event) {
+        this.addPlaceholder(event.getPlaceholder());
+    }
+
+    private void addPlaceholder(@NotNull final Placeholder placeholder) {
+        PlaceholderAPI.registerPlaceholder(plugin, PREFIX + String.format("%s", placeholder.getKey()),
+            placeholderReplaceEvent -> {
+                if (!placeholderReplaceEvent.isOnline() || placeholderReplaceEvent.getPlayer() == null) {
+                    return "";
+                }
+                final PlotPlayer<Player> player = BukkitUtil.getPlayer(placeholderReplaceEvent.getPlayer());
+                if (player == null) {
+                    return "";
+                }
+                String key = placeholderReplaceEvent.getPlaceholder().substring(PREFIX.length());
+                return registry.getPlaceholderValue(key, player);
+            });
+    }
+
+}

Bukkit/src/main/java/com/plotsquared/bukkit/placeholder/PAPIPlaceholders.java

@@ -0,0 +1,89 @@
+/*
+ *       _____  _       _    _____                                _
+ *      |  __ \| |     | |  / ____|                              | |
+ *      | |__) | | ___ | |_| (___   __ _ _   _  __ _ _ __ ___  __| |
+ *      |  ___/| |/ _ \| __|\___ \ / _` | | | |/ _` | '__/ _ \/ _` |
+ *      | |    | | (_) | |_ ____) | (_| | |_| | (_| | | |  __/ (_| |
+ *      |_|    |_|\___/ \__|_____/ \__, |\__,_|\__,_|_|  \___|\__,_|
+ *                                    | |
+ *                                    |_|
+ *            PlotSquared plot management system for Minecraft
+ *                  Copyright (C) 2021 IntellectualSites
+ *
+ *     This program is free software: you can redistribute it and/or modify
+ *     it under the terms of the GNU 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 General Public License for more details.
+ *
+ *     You should have received a copy of the GNU General Public License
+ *     along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package com.plotsquared.bukkit.placeholder;
+
+import com.plotsquared.core.PlotSquared;
+import com.plotsquared.core.player.PlotPlayer;
+import me.clip.placeholderapi.PlaceholderAPIPlugin;
+import me.clip.placeholderapi.expansion.PlaceholderExpansion;
+import org.bukkit.entity.Player;
+
+public class PAPIPlaceholders extends PlaceholderExpansion {
+
+    public PAPIPlaceholders() {
+    }
+
+    @Override public boolean persist() {
+        return true;
+    }
+
+    @Override public boolean canRegister() {
+        return true;
+    }
+
+    @Override public String getAuthor() {
+        return "IntellectualSites";
+    }
+
+    @Override public String getIdentifier() {
+        return "plotsquared";
+    }
+
+    @Override public String getVersion() {
+        return "3";
+    }
+
+    @Override public String onPlaceholderRequest(Player p, String identifier) {
+        final PlotPlayer<?> pl = PlotSquared.imp().getPlayerManager().getPlayerIfExists(p.getUniqueId());
+
+        if (pl == null) {
+            return "";
+        }
+
+        // PAPI specific ones that don't translate well over into other placeholder APIs
+        if (identifier.startsWith("has_plot_")) {
+            identifier = identifier.substring("has_plot_".length());
+            if (identifier.isEmpty())
+                return "";
+
+            return pl.getPlotCount(identifier) > 0 ?
+                PlaceholderAPIPlugin.booleanTrue() :
+                PlaceholderAPIPlugin.booleanFalse();
+        }
+
+        if (identifier.startsWith("plot_count_")) {
+            identifier = identifier.substring("plot_count_".length());
+            if (identifier.isEmpty())
+                return "";
+
+            return String.valueOf(pl.getPlotCount(identifier));
+        }
+
+        // PlotSquared placeholders
+        return PlotSquared.get().getPlaceholderRegistry().getPlaceholderValue(identifier, pl);
+    }
+
+}

Bukkit/src/main/java/com/plotsquared/bukkit/placeholder/PlaceholderFormatter.java

@@ -0,0 +1,48 @@
+/*
+ *       _____  _       _    _____                                _
+ *      |  __ \| |     | |  / ____|                              | |
+ *      | |__) | | ___ | |_| (___   __ _ _   _  __ _ _ __ ___  __| |
+ *      |  ___/| |/ _ \| __|\___ \ / _` | | | |/ _` | '__/ _ \/ _` |
+ *      | |    | | (_) | |_ ____) | (_| | |_| | (_| | | |  __/ (_| |
+ *      |_|    |_|\___/ \__|_____/ \__, |\__,_|\__,_|_|  \___|\__,_|
+ *                                    | |
+ *                                    |_|
+ *            PlotSquared plot management system for Minecraft
+ *                  Copyright (C) 2021 IntellectualSites
+ *
+ *     This program is free software: you can redistribute it and/or modify
+ *     it under the terms of the GNU 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 General Public License for more details.
+ *
+ *     You should have received a copy of the GNU General Public License
+ *     along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package com.plotsquared.bukkit.placeholder;
+
+import com.plotsquared.bukkit.player.BukkitPlayer;
+import com.plotsquared.core.configuration.ChatFormatter;
+import com.plotsquared.core.player.PlotPlayer;
+import me.clip.placeholderapi.PlaceholderAPI;
+import org.bukkit.entity.Player;
+
+public class PlaceholderFormatter implements ChatFormatter {
+
+    @Override public void format(final ChatContext context) {
+        final PlotPlayer recipient = context.getRecipient();
+        if (recipient instanceof BukkitPlayer) {
+            if (context.isRawOutput()) {
+                context.setMessage(context.getMessage().replace('%', '\u2010'));
+            } else {
+                final Player player = ((BukkitPlayer) recipient).player;
+                context.setMessage(PlaceholderAPI.setPlaceholders(player, context.getMessage()));
+            }
+        }
+    }
+
+}

Bukkit/src/main/java/com/plotsquared/bukkit/player/BukkitOfflinePlayer.java

@@ -0,0 +1,63 @@
+/*
+ *       _____  _       _    _____                                _
+ *      |  __ \| |     | |  / ____|                              | |
+ *      | |__) | | ___ | |_| (___   __ _ _   _  __ _ _ __ ___  __| |
+ *      |  ___/| |/ _ \| __|\___ \ / _` | | | |/ _` | '__/ _ \/ _` |
+ *      | |    | | (_) | |_ ____) | (_| | |_| | (_| | | |  __/ (_| |
+ *      |_|    |_|\___/ \__|_____/ \__, |\__,_|\__,_|_|  \___|\__,_|
+ *                                    | |
+ *                                    |_|
+ *            PlotSquared plot management system for Minecraft
+ *                  Copyright (C) 2021 IntellectualSites
+ *
+ *     This program is free software: you can redistribute it and/or modify
+ *     it under the terms of the GNU 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 General Public License for more details.
+ *
+ *     You should have received a copy of the GNU General Public License
+ *     along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package com.plotsquared.bukkit.player;
+
+import com.plotsquared.core.player.OfflinePlotPlayer;
+import org.bukkit.OfflinePlayer;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.UUID;
+
+public class BukkitOfflinePlayer implements OfflinePlotPlayer {
+
+    public final OfflinePlayer player;
+
+    /**
+     * Please do not use this method. Instead use BukkitUtil.getPlayer(Player),
+     * as it caches player objects.
+     *
+     * @param player
+     */
+    public BukkitOfflinePlayer(OfflinePlayer player) {
+        this.player = player;
+    }
+
+    @NotNull @Override public UUID getUUID() {
+        return this.player.getUniqueId();
+    }
+
+    @Override public long getLastPlayed() {
+        return this.player.getLastPlayed();
+    }
+
+    @Override public boolean isOnline() {
+        return this.player.isOnline();
+    }
+
+    @Override public String getName() {
+        return this.player.getName();
+    }
+}

Bukkit/src/main/java/com/plotsquared/bukkit/player/BukkitPlayer.java

@@ -0,0 +1,378 @@
+/*
+ *       _____  _       _    _____                                _
+ *      |  __ \| |     | |  / ____|                              | |
+ *      | |__) | | ___ | |_| (___   __ _ _   _  __ _ _ __ ___  __| |
+ *      |  ___/| |/ _ \| __|\___ \ / _` | | | |/ _` | '__/ _ \/ _` |
+ *      | |    | | (_) | |_ ____) | (_| | |_| | (_| | | |  __/ (_| |
+ *      |_|    |_|\___/ \__|_____/ \__, |\__,_|\__,_|_|  \___|\__,_|
+ *                                    | |
+ *                                    |_|
+ *            PlotSquared plot management system for Minecraft
+ *                  Copyright (C) 2021 IntellectualSites
+ *
+ *     This program is free software: you can redistribute it and/or modify
+ *     it under the terms of the GNU 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 General Public License for more details.
+ *
+ *     You should have received a copy of the GNU General Public License
+ *     along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package com.plotsquared.bukkit.player;
+
+import com.google.common.base.Charsets;
+import com.plotsquared.bukkit.util.BukkitUtil;
+import com.plotsquared.core.PlotSquared;
+import com.plotsquared.core.configuration.Captions;
+import com.plotsquared.core.configuration.Settings;
+import com.plotsquared.core.events.TeleportCause;
+import com.plotsquared.core.location.Location;
+import com.plotsquared.core.player.ConsolePlayer;
+import com.plotsquared.core.player.PlotPlayer;
+import com.plotsquared.core.plot.PlotWeather;
+import com.plotsquared.core.util.EconHandler;
+import com.plotsquared.core.util.MathMan;
+import com.plotsquared.core.util.StringMan;
+import com.sk89q.worldedit.bukkit.BukkitAdapter;
+import com.sk89q.worldedit.extension.platform.Actor;
+import com.sk89q.worldedit.world.item.ItemType;
+import com.sk89q.worldedit.world.item.ItemTypes;
+import io.papermc.lib.PaperLib;
+import org.bukkit.GameMode;
+import org.bukkit.Sound;
+import org.bukkit.WeatherType;
+import org.bukkit.entity.Player;
+import org.bukkit.event.Event;
+import org.bukkit.event.EventException;
+import org.bukkit.event.player.PlayerTeleportEvent;
+import org.bukkit.permissions.PermissionAttachmentInfo;
+import org.bukkit.plugin.RegisteredListener;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Arrays;
+import java.util.Set;
+import java.util.UUID;
+import java.util.stream.Collectors;
+
+import static com.sk89q.worldedit.world.gamemode.GameModes.ADVENTURE;
+import static com.sk89q.worldedit.world.gamemode.GameModes.CREATIVE;
+import static com.sk89q.worldedit.world.gamemode.GameModes.SPECTATOR;
+import static com.sk89q.worldedit.world.gamemode.GameModes.SURVIVAL;
+
+public class BukkitPlayer extends PlotPlayer<Player> {
+
+    private static boolean CHECK_EFFECTIVE = true;
+    public final Player player;
+    private boolean offline;
+    private String name;
+
+    /**
+     * <p>Please do not use this method. Instead use
+     * BukkitUtil.getPlayer(Player), as it caches player objects.</p>
+     *
+     * @param player Bukkit player instance
+     */
+    public BukkitPlayer(@NotNull final Player player) {
+        this(player, false);
+    }
+
+    public BukkitPlayer(@NotNull final Player player, final boolean offline) {
+        this(player, offline, true);
+    }
+
+    public BukkitPlayer(@NotNull final Player player, final boolean offline, final boolean realPlayer) {
+        this.player = player;
+        this.offline = offline;
+        if (realPlayer) {
+            super.populatePersistentMetaMap();
+        }
+    }
+
+    @Override public Actor toActor() {
+        return BukkitAdapter.adapt(player);
+    }
+
+    @Override public Player getPlatformPlayer() {
+        return this.player;
+    }
+
+    @NotNull @Override public Location getLocation() {
+        final Location location = super.getLocation();
+        return location == null ? BukkitUtil.getLocation(this.player) : location;
+    }
+
+    @NotNull @Override public UUID getUUID() {
+        if (Settings.UUID.OFFLINE) {
+            if (Settings.UUID.FORCE_LOWERCASE) {
+                return UUID.nameUUIDFromBytes(("OfflinePlayer:" +
+                    getName().toLowerCase()).getBytes(Charsets.UTF_8));
+            } else {
+                return UUID.nameUUIDFromBytes(("OfflinePlayer:" +
+                    getName()).getBytes(Charsets.UTF_8));
+            }
+        }
+        return player.getUniqueId();
+    }
+
+    @Override public long getLastPlayed() {
+        return this.player.getLastPlayed();
+    }
+
+    @Override public boolean canTeleport(@NotNull final Location location) {
+        final org.bukkit.Location to = BukkitUtil.getLocation(location);
+        final org.bukkit.Location from = player.getLocation();
+        PlayerTeleportEvent event = new PlayerTeleportEvent(player, from, to);
+        callEvent(event);
+        if (event.isCancelled() || !event.getTo().equals(to)) {
+            return false;
+        }
+        event = new PlayerTeleportEvent(player, to, from);
+        callEvent(event);
+        return true;
+    }
+
+    @Override
+    public void sendTitle(String title, String subtitle, int fadeIn, int stay, int fadeOut) {
+        player.sendTitle(title, subtitle, fadeIn, stay, fadeOut);
+    }
+
+    private void callEvent(@NotNull final Event event) {
+        final RegisteredListener[] listeners = event.getHandlers().getRegisteredListeners();
+        for (final RegisteredListener listener : listeners) {
+            if (listener.getPlugin().getName().equals(PlotSquared.imp().getPluginName())) {
+                continue;
+            }
+            try {
+                listener.callEvent(event);
+            } catch (final EventException e) {
+                e.printStackTrace();
+            }
+        }
+    }
+
+    @Override public boolean hasPermission(final String permission) {
+        if (this.offline && EconHandler.getEconHandler() != null) {
+            return EconHandler.getEconHandler().hasPermission(getName(), permission);
+        }
+        return this.player.hasPermission(permission);
+    }
+
+    @Override public int hasPermissionRange(final String stub, final int range) {
+        if (hasPermission(Captions.PERMISSION_ADMIN.getTranslated())) {
+            return Integer.MAX_VALUE;
+        }
+        final String[] nodes = stub.split("\\.");
+        final StringBuilder n = new StringBuilder();
+        for (int i = 0; i < (nodes.length - 1); i++) {
+            n.append(nodes[i]).append(".");
+            if (!stub.equals(n + Captions.PERMISSION_STAR.getTranslated())) {
+                if (hasPermission(n + Captions.PERMISSION_STAR.getTranslated())) {
+                    return Integer.MAX_VALUE;
+                }
+            }
+        }
+        if (hasPermission(stub + ".*")) {
+            return Integer.MAX_VALUE;
+        }
+        int max = 0;
+        if (CHECK_EFFECTIVE) {
+            boolean hasAny = false;
+            String stubPlus = stub + ".";
+            final Set<PermissionAttachmentInfo> effective = player.getEffectivePermissions();
+            if (!effective.isEmpty()) {
+                for (PermissionAttachmentInfo attach : effective) {
+                    String permStr = attach.getPermission();
+                    if (permStr.startsWith(stubPlus)) {
+                        hasAny = true;
+                        String end = permStr.substring(stubPlus.length());
+                        if (MathMan.isInteger(end)) {
+                            int val = Integer.parseInt(end);
+                            if (val > range) {
+                                return val;
+                            }
+                            if (val > max) {
+                                max = val;
+                            }
+                        }
+                    }
+                }
+                if (hasAny) {
+                    return max;
+                }
+                // Workaround
+                for (PermissionAttachmentInfo attach : effective) {
+                    String permStr = attach.getPermission();
+                    if (permStr.startsWith("plots.") && !permStr.equals("plots.use")) {
+                        return max;
+                    }
+                }
+                CHECK_EFFECTIVE = false;
+            }
+        }
+        for (int i = range; i > 0; i--) {
+            if (hasPermission(stub + "." + i)) {
+                return i;
+            }
+        }
+        return max;
+    }
+
+    @Override public boolean isPermissionSet(final String permission) {
+        return this.player.isPermissionSet(permission);
+    }
+
+    @Override public void sendMessage(String message) {
+        message = message.replace('\u2010', '%').replace('\u2021', '&').replace('\u2030', '&');
+        if (!StringMan.isEqual(this.getMeta("lastMessage"), message) || (
+            System.currentTimeMillis() - this.<Long>getMeta("lastMessageTime") > 5000)) {
+            setMeta("lastMessage", message);
+            setMeta("lastMessageTime", System.currentTimeMillis());
+            this.player.sendMessage(message);
+        }
+    }
+
+    @Override
+    public void teleport(@NotNull final Location location, @NotNull final TeleportCause cause) {
+        if (Math.abs(location.getX()) >= 30000000 || Math.abs(location.getZ()) >= 30000000) {
+            return;
+        }
+        final org.bukkit.Location bukkitLocation =
+            new org.bukkit.Location(BukkitUtil.getWorld(location.getWorld()), location.getX() + 0.5,
+                location.getY(), location.getZ() + 0.5, location.getYaw(), location.getPitch());
+        PaperLib.teleportAsync(player, bukkitLocation, getTeleportCause(cause));
+    }
+
+    @Override public String getName() {
+        if (this.name == null) {
+            this.name = this.player.getName();
+        }
+        return this.name;
+    }
+
+    @Override public boolean isOnline() {
+        return !this.offline && this.player.isOnline();
+    }
+
+    @Override public void setCompassTarget(Location location) {
+        this.player.setCompassTarget(
+            new org.bukkit.Location(BukkitUtil.getWorld(location.getWorld()), location.getX(),
+                location.getY(), location.getZ()));
+    }
+
+    @Override public Location getLocationFull() {
+        return BukkitUtil.getLocationFull(this.player);
+    }
+
+    @Override public void setWeather(@NotNull final PlotWeather weather) {
+        switch (weather) {
+            case CLEAR:
+                this.player.setPlayerWeather(WeatherType.CLEAR);
+                break;
+            case RAIN:
+                this.player.setPlayerWeather(WeatherType.DOWNFALL);
+                break;
+            case WORLD:
+                this.player.resetPlayerWeather();
+                break;
+            default:
+                //do nothing as this is PlotWeather.OFF
+                break;
+        }
+    }
+
+    @NotNull @Override public com.sk89q.worldedit.world.gamemode.GameMode getGameMode() {
+        switch (this.player.getGameMode()) {
+            case ADVENTURE:
+                return ADVENTURE;
+            case CREATIVE:
+                return CREATIVE;
+            case SPECTATOR:
+                return SPECTATOR;
+            case SURVIVAL:
+            default:
+                return SURVIVAL;
+        }
+    }
+
+    @Override
+    public void setGameMode(@NotNull final com.sk89q.worldedit.world.gamemode.GameMode gameMode) {
+        if (ADVENTURE.equals(gameMode)) {
+            this.player.setGameMode(GameMode.ADVENTURE);
+        } else if (CREATIVE.equals(gameMode)) {
+            this.player.setGameMode(GameMode.CREATIVE);
+        } else if (SPECTATOR.equals(gameMode)) {
+            this.player.setGameMode(GameMode.SPECTATOR);
+        } else {
+            this.player.setGameMode(GameMode.SURVIVAL);
+        }
+    }
+
+    @Override public void setTime(final long time) {
+        if (time != Long.MAX_VALUE) {
+            this.player.setPlayerTime(time, false);
+        } else {
+            this.player.resetPlayerTime();
+        }
+    }
+
+    @Override public boolean getFlight() {
+        return player.getAllowFlight();
+    }
+
+    @Override public void setFlight(boolean fly) {
+        this.player.setAllowFlight(fly);
+    }
+
+    @Override public void playMusic(@NotNull final Location location, @NotNull final ItemType id) {
+        if (id == ItemTypes.AIR) {
+            // Let's just stop all the discs because why not?
+            for (final Sound sound : Arrays.stream(Sound.values())
+                .filter(sound -> sound.name().contains("DISC")).collect(Collectors.toList())) {
+                player.stopSound(sound);
+            }
+            // this.player.playEffect(BukkitUtil.getLocation(location), Effect.RECORD_PLAY, Material.AIR);
+        } else {
+            // this.player.playEffect(BukkitUtil.getLocation(location), Effect.RECORD_PLAY, id.to(Material.class));
+            this.player.playSound(BukkitUtil.getLocation(location),
+                Sound.valueOf(BukkitAdapter.adapt(id).name()), Float.MAX_VALUE, 1f);
+        }
+    }
+
+    @Override public void kick(final String message) {
+        this.player.kickPlayer(message);
+    }
+
+    @Override public void stopSpectating() {
+        if (getGameMode() == SPECTATOR) {
+            this.player.setSpectatorTarget(null);
+        }
+    }
+
+    @Override public boolean isBanned() {
+        return this.player.isBanned();
+    }
+
+    @Override public boolean canSee(final PlotPlayer<?> other) {
+        if (other instanceof ConsolePlayer) {
+            return true;
+        } else {
+            return this.player.canSee(((BukkitPlayer) other).getPlatformPlayer());
+        }
+    }
+
+    public PlayerTeleportEvent.TeleportCause getTeleportCause(@NotNull final TeleportCause cause) {
+        switch (cause) {
+            case COMMAND:
+                return PlayerTeleportEvent.TeleportCause.COMMAND;
+            case PLUGIN:
+                return PlayerTeleportEvent.TeleportCause.PLUGIN;
+            default:
+                return PlayerTeleportEvent.TeleportCause.UNKNOWN;
+        }
+    }
+}

Bukkit/src/main/java/com/plotsquared/bukkit/player/BukkitPlayerManager.java

@@ -0,0 +1,68 @@
+/*
+ *       _____  _       _    _____                                _
+ *      |  __ \| |     | |  / ____|                              | |
+ *      | |__) | | ___ | |_| (___   __ _ _   _  __ _ _ __ ___  __| |
+ *      |  ___/| |/ _ \| __|\___ \ / _` | | | |/ _` | '__/ _ \/ _` |
+ *      | |    | | (_) | |_ ____) | (_| | |_| | (_| | | |  __/ (_| |
+ *      |_|    |_|\___/ \__|_____/ \__, |\__,_|\__,_|_|  \___|\__,_|
+ *                                    | |
+ *                                    |_|
+ *            PlotSquared plot management system for Minecraft
+ *                  Copyright (C) 2021 IntellectualSites
+ *
+ *     This program is free software: you can redistribute it and/or modify
+ *     it under the terms of the GNU 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 General Public License for more details.
+ *
+ *     You should have received a copy of the GNU General Public License
+ *     along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package com.plotsquared.bukkit.player;
+
+import com.plotsquared.core.util.PlayerManager;
+import org.bukkit.Bukkit;
+import org.bukkit.entity.Player;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.UUID;
+
+/**
+ * Player manager providing {@link BukkitPlayer Bukkit players}
+ */
+public class BukkitPlayerManager extends PlayerManager<BukkitPlayer, Player> {
+
+    @NotNull @Override public BukkitPlayer getPlayer(@NotNull final Player object) {
+        try {
+            return getPlayer(object.getUniqueId());
+        } catch (final NoSuchPlayerException exception) {
+            return new BukkitPlayer(object, object.isOnline(), false);
+        }
+    }
+
+    @Override @NotNull public BukkitPlayer createPlayer(@NotNull final UUID uuid) {
+        final Player player = Bukkit.getPlayer(uuid);
+        if (player == null || !player.isOnline()) {
+            throw new NoSuchPlayerException(uuid);
+        }
+        return new BukkitPlayer(player);
+    }
+
+    @Nullable @Override public BukkitOfflinePlayer getOfflinePlayer(@Nullable final UUID uuid) {
+        if (uuid == null) {
+            return null;
+        }
+        return new BukkitOfflinePlayer(Bukkit.getOfflinePlayer(uuid));
+    }
+
+    @NotNull @Override public BukkitOfflinePlayer getOfflinePlayer(@NotNull final String username) {
+        return new BukkitOfflinePlayer(Bukkit.getOfflinePlayer(username));
+    }
+
+}

Bukkit/src/main/java/com/plotsquared/bukkit/queue/BukkitLocalQueue.java

@@ -0,0 +1,245 @@
+/*
+ *       _____  _       _    _____                                _
+ *      |  __ \| |     | |  / ____|                              | |
+ *      | |__) | | ___ | |_| (___   __ _ _   _  __ _ _ __ ___  __| |
+ *      |  ___/| |/ _ \| __|\___ \ / _` | | | |/ _` | '__/ _ \/ _` |
+ *      | |    | | (_) | |_ ____) | (_| | |_| | (_| | | |  __/ (_| |
+ *      |_|    |_|\___/ \__|_____/ \__, |\__,_|\__,_|_|  \___|\__,_|
+ *                                    | |
+ *                                    |_|
+ *            PlotSquared plot management system for Minecraft
+ *                  Copyright (C) 2021 IntellectualSites
+ *
+ *     This program is free software: you can redistribute it and/or modify
+ *     it under the terms of the GNU 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 General Public License for more details.
+ *
+ *     You should have received a copy of the GNU General Public License
+ *     along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package com.plotsquared.bukkit.queue;
+
+import com.plotsquared.bukkit.schematic.StateWrapper;
+import com.plotsquared.bukkit.util.BukkitBlockUtil;
+import com.plotsquared.core.PlotSquared;
+import com.plotsquared.core.queue.BasicLocalBlockQueue;
+import com.plotsquared.core.util.BlockUtil;
+import com.plotsquared.core.util.MainUtil;
+import com.plotsquared.core.util.task.TaskManager;
+import com.sk89q.jnbt.CompoundTag;
+import com.sk89q.worldedit.EditSession;
+import com.sk89q.worldedit.WorldEdit;
+import com.sk89q.worldedit.bukkit.BukkitAdapter;
+import com.sk89q.worldedit.math.BlockVector3;
+import com.sk89q.worldedit.regions.CuboidRegion;
+import com.sk89q.worldedit.world.biome.BiomeType;
+import com.sk89q.worldedit.world.block.BaseBlock;
+import com.sk89q.worldedit.world.block.BlockState;
+import io.papermc.lib.PaperLib;
+import lombok.NonNull;
+import org.bukkit.Bukkit;
+import org.bukkit.Chunk;
+import org.bukkit.Material;
+import org.bukkit.World;
+import org.bukkit.block.Biome;
+import org.bukkit.block.Block;
+import org.bukkit.block.Container;
+import org.bukkit.block.data.BlockData;
+
+import java.util.concurrent.ExecutionException;
+import java.util.function.Consumer;
+
+public class BukkitLocalQueue extends BasicLocalBlockQueue {
+
+    public BukkitLocalQueue(String world) {
+        super(world);
+    }
+
+    @Override public LocalChunk getLocalChunk(int x, int z) {
+        return new BasicLocalChunk(this, x, z) {
+            // Custom stuff?
+        };
+    }
+
+    @Override public void optimize() {
+
+    }
+
+    @Override public BlockState getBlock(int x, int y, int z) {
+        World worldObj = Bukkit.getWorld(getWorld());
+        if (worldObj != null) {
+            Block block = worldObj.getBlockAt(x, y, z);
+            return BukkitBlockUtil.get(block);
+        } else {
+            return BlockUtil.get(0, 0);
+        }
+    }
+
+    @Override public void refreshChunk(int x, int z) {
+        World worldObj = Bukkit.getWorld(getWorld());
+        if (worldObj != null) {
+            worldObj.refreshChunk(x, z);
+        } else {
+            PlotSquared.debug("Error Refreshing Chunk");
+        }
+    }
+
+    @Override public void fixChunkLighting(int x, int z) {
+        // Do nothing
+    }
+
+    @Override public final void regenChunk(int x, int z) {
+        World worldObj = Bukkit.getWorld(getWorld());
+        if (worldObj != null) {
+            try {
+                worldObj.regenerateChunk(x, z);
+            } catch (UnsupportedOperationException e) {
+                com.sk89q.worldedit.world.World world = BukkitAdapter.adapt(worldObj);
+                try (EditSession editSession = WorldEdit.getInstance().getEditSessionFactory()
+                    .getEditSession(world, -1);) {
+                    CuboidRegion region =
+                        new CuboidRegion(world, BlockVector3.at((x << 4), 0, (z << 4)),
+                            BlockVector3.at((x << 4) + 15, 255, (z << 4) + 15));
+                    world.regenerate(region, editSession);
+                }
+            }
+        } else {
+            PlotSquared.debug("Error Regenerating Chunk");
+        }
+    }
+
+    @Override public final void setComponents(LocalChunk lc)
+        throws ExecutionException, InterruptedException {
+        setBaseBlocks(lc);
+    }
+
+    public void setBaseBlocks(LocalChunk localChunk) {
+        World worldObj = Bukkit.getWorld(getWorld());
+        if (worldObj == null) {
+            throw new NullPointerException("World cannot be null.");
+        }
+        final Consumer<Chunk> chunkConsumer = chunk -> {
+            for (int layer = 0; layer < localChunk.baseblocks.length; layer++) {
+                BaseBlock[] blocksLayer = localChunk.baseblocks[layer];
+                if (blocksLayer != null) {
+                    for (int j = 0; j < blocksLayer.length; j++) {
+                        if (blocksLayer[j] != null) {
+                            BaseBlock block = blocksLayer[j];
+                            int x = MainUtil.x_loc[layer][j];
+                            int y = MainUtil.y_loc[layer][j];
+                            int z = MainUtil.z_loc[layer][j];
+
+                            BlockData blockData = BukkitAdapter.adapt(block);
+
+                            Block existing = chunk.getBlock(x, y, z);
+                            final BlockState existingBaseBlock =
+                                BukkitAdapter.adapt(existing.getBlockData());
+                            if (BukkitBlockUtil.get(existing).equals(existingBaseBlock) && existing
+                                .getBlockData().matches(blockData)) {
+                                continue;
+                            }
+
+                            if (existing.getState() instanceof Container) {
+                                ((Container) existing.getState()).getInventory().clear();
+                            }
+
+                            existing.setType(BukkitAdapter.adapt(block.getBlockType()), false);
+                            existing.setBlockData(blockData, false);
+                            if (block.hasNbtData()) {
+                                CompoundTag tag = block.getNbtData();
+                                StateWrapper sw = new StateWrapper(tag);
+
+                                sw.restoreTag(worldObj.getName(), existing.getX(), existing.getY(),
+                                    existing.getZ());
+                            }
+                        }
+                    }
+                }
+            }
+            if (setBiome() && localChunk.biomes != null) {
+                for (int x = 0; x < localChunk.biomes.length; x++) {
+                    BiomeType[] biomeZ = localChunk.biomes[x];
+                    if (biomeZ != null) {
+                        for (int z = 0; z < biomeZ.length; z++) {
+                            if (biomeZ[z] != null) {
+                                BiomeType biomeType = biomeZ[z];
+
+                                Biome biome = BukkitAdapter.adapt(biomeType);
+                                worldObj.setBiome((chunk.getX() << 4) + x, (chunk.getZ() << 4) + z,
+                                    biome);
+                            }
+                        }
+                    }
+                }
+            }
+        };
+        if (isForceSync()) {
+            chunkConsumer.accept(getChunk(worldObj, localChunk));
+        } else {
+            PaperLib.getChunkAtAsync(worldObj, localChunk.getX(), localChunk.getZ(), true)
+                .thenAccept(chunkConsumer);
+        }
+    }
+
+    private Chunk getChunk(final World world, final LocalChunk localChunk) {
+        Chunk chunk = null;
+        if (this.getChunkObject() != null && this.getChunkObject() instanceof Chunk) {
+            chunk = (Chunk) this.getChunkObject();
+        }
+        if (chunk == null) {
+            chunk = world.getChunkAt(localChunk.getX(), localChunk.getZ());
+        }
+        if (!chunk.isLoaded()) {
+            chunk.load(true);
+        }
+        return chunk;
+    }
+
+    private void setMaterial(@NonNull final BlockState plotBlock, @NonNull final Block block) {
+        Material material = BukkitAdapter.adapt(plotBlock.getBlockType());
+        block.setType(material, false);
+    }
+
+    private boolean equals(@NonNull final BlockState plotBlock, @NonNull final Block block) {
+        return plotBlock.equals(BukkitBlockUtil.get(block));
+    }
+
+    public void setBiomes(LocalChunk lc) {
+        World worldObj = Bukkit.getWorld(getWorld());
+        if (worldObj == null) {
+            throw new NullPointerException("World cannot be null.");
+        }
+        if (lc.biomes == null) {
+            throw new NullPointerException("Biomes cannot be null.");
+        }
+        final Consumer<Chunk> chunkConsumer = chunk -> {
+            for (int x = 0; x < lc.biomes.length; x++) {
+                BiomeType[] biomeZ = lc.biomes[x];
+                if (biomeZ != null) {
+                    for (int z = 0; z < biomeZ.length; z++) {
+                        if (biomeZ[z] != null) {
+                            BiomeType biomeType = biomeZ[z];
+
+                            Biome biome = BukkitAdapter.adapt(biomeType);
+                            worldObj
+                                .setBiome((chunk.getX() << 4) + x, (chunk.getZ() << 4) + z, biome);
+                        }
+                    }
+                }
+            }
+        };
+        if (this.isForceSync()) {
+            chunkConsumer.accept(getChunk(worldObj, lc));
+        } else {
+            PaperLib.getChunkAtAsync(worldObj, lc.getX(), lc.getZ(), true)
+                .thenAccept(chunkConsumer);
+        }
+    }
+
+}

Bukkit/src/main/java/com/plotsquared/bukkit/queue/ChunkCoordinator.java

@@ -0,0 +1,326 @@
+/*
+ *       _____  _       _    _____                                _
+ *      |  __ \| |     | |  / ____|                              | |
+ *      | |__) | | ___ | |_| (___   __ _ _   _  __ _ _ __ ___  __| |
+ *      |  ___/| |/ _ \| __|\___ \ / _` | | | |/ _` | '__/ _ \/ _` |
+ *      | |    | | (_) | |_ ____) | (_| | |_| | (_| | | |  __/ (_| |
+ *      |_|    |_|\___/ \__|_____/ \__, |\__,_|\__,_|_|  \___|\__,_|
+ *                                    | |
+ *                                    |_|
+ *            PlotSquared plot management system for Minecraft
+ *                  Copyright (C) 2021 IntellectualSites
+ *
+ *     This program is free software: you can redistribute it and/or modify
+ *     it under the terms of the GNU 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 General Public License for more details.
+ *
+ *     You should have received a copy of the GNU General Public License
+ *     along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package com.plotsquared.bukkit.queue;
+
+import com.google.common.base.Preconditions;
+import com.plotsquared.bukkit.BukkitMain;
+import com.sk89q.worldedit.math.BlockVector2;
+import io.papermc.lib.PaperLib;
+import org.bukkit.Chunk;
+import org.bukkit.World;
+import org.bukkit.plugin.Plugin;
+import org.bukkit.plugin.java.JavaPlugin;
+import org.bukkit.scheduler.BukkitRunnable;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Collection;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Queue;
+import java.util.concurrent.LinkedBlockingQueue;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.function.Consumer;
+
+/**
+ * Utility that allows for the loading and coordination of chunk actions
+ * <p>
+ * The coordinator takes in collection of chunk coordinates, loads them
+ * and allows the caller to specify a sink for the loaded chunks. The
+ * coordinator will prevent the chunks from being unloaded until the sink
+ * has fully consumed the chunk
+ * <p>
+ * Usage:
+ * <pre>{@code
+ * final ChunkCoordinator chunkCoordinator = ChunkCoordinator.builder()
+ *     .inWorld(Objects.requireNonNull(Bukkit.getWorld("world"))).withChunk(BlockVector2.at(0, 0))
+ *     .withConsumer(chunk -> System.out.printf("Got chunk %d;%d", chunk.getX(), chunk.getZ()))
+ *     .withFinalAction(() -> System.out.println("All chunks have been loaded"))
+ *     .withThrowableConsumer(throwable -> System.err.println("Something went wrong... =("))
+ *     .withMaxIterationTime(25L)
+ *     .build();
+ * chunkCoordinator.subscribeToProgress((coordinator, progress) ->
+ *     System.out.printf("Progress: %.1f", progress * 100.0f));
+ * chunkCoordinator.start();
+ * }</pre>
+ *
+ * @author Alexander Söderberg
+ * @see #builder() To create a new coordinator instance
+ */
+public final class ChunkCoordinator extends BukkitRunnable {
+
+    private final List<ProgressSubscriber> progressSubscribers = new LinkedList<>();
+
+    private final Queue<BlockVector2> requestedChunks;
+    private final Queue<Chunk> availableChunks;
+    private final long maxIterationTime;
+    private final Plugin plugin;
+    private final Consumer<Chunk> chunkConsumer;
+    private final World world;
+    private final Runnable whenDone;
+    private final Consumer<Throwable> throwableConsumer;
+    private final int totalSize;
+
+    private AtomicInteger expectedSize;
+    private int batchSize;
+
+    private ChunkCoordinator(final long maxIterationTime, final int initialBatchSize,
+        @NotNull final Consumer<Chunk> chunkConsumer, @NotNull final World world,
+        @NotNull final Collection<BlockVector2> requestedChunks, @NotNull final Runnable whenDone,
+        @NotNull final Consumer<Throwable> throwableConsumer) {
+        this.requestedChunks = new LinkedBlockingQueue<>(requestedChunks);
+        this.availableChunks = new LinkedBlockingQueue<>();
+        this.totalSize = requestedChunks.size();
+        this.expectedSize = new AtomicInteger(this.totalSize);
+        this.world = world;
+        this.batchSize = initialBatchSize;
+        this.chunkConsumer = chunkConsumer;
+        this.maxIterationTime = maxIterationTime;
+        this.whenDone = whenDone;
+        this.throwableConsumer = throwableConsumer;
+        this.plugin = JavaPlugin.getPlugin(BukkitMain.class);
+    }
+
+    /**
+     * Create a new {@link ChunkCoordinator} instance
+     *
+     * @return Coordinator builder instance
+     */
+    @NotNull public static ChunkCoordinatorBuilder builder() {
+        return new ChunkCoordinatorBuilder();
+    }
+
+    /**
+     * Start the coordinator instance
+     */
+    public void start() {
+        // Request initial batch
+        this.requestBatch();
+        // Wait until next tick to give the chunks a chance to be loaded
+        this.runTaskTimer(this.plugin, 1L, 1L);
+    }
+
+    @Override public void run() {
+        Chunk chunk = this.availableChunks.poll();
+        if (chunk == null) {
+            return;
+        }
+        long iterationTime;
+        int processedChunks = 0;
+        do {
+            final long start = System.currentTimeMillis();
+            try {
+                this.chunkConsumer.accept(chunk);
+            } catch (final Throwable throwable) {
+                this.throwableConsumer.accept(throwable);
+            }
+            this.freeChunk(chunk);
+            processedChunks++;
+            final long end = System.currentTimeMillis();
+            // Update iteration time
+            iterationTime = end - start;
+        } while (2 * iterationTime /* last chunk + next chunk */ < this.maxIterationTime
+            && (chunk = availableChunks.poll()) != null);
+        if (processedChunks < this.batchSize) {
+            // Adjust batch size based on the amount of processed chunks per tick
+            this.batchSize = processedChunks;
+        }
+
+        final int expected = this.expectedSize.addAndGet(-processedChunks);
+
+        final float progress = ((float) totalSize - (float) expected) / (float) totalSize;
+        for (final ProgressSubscriber subscriber : this.progressSubscribers) {
+            subscriber.notifyProgress(this, progress);
+        }
+
+        if (expected <= 0) {
+            try {
+                this.whenDone.run();
+            } catch (final Throwable throwable) {
+                this.throwableConsumer.accept(throwable);
+            }
+            this.cancel();
+        } else {
+            if (this.availableChunks.size() < processedChunks) {
+                this.requestBatch();
+            }
+        }
+    }
+
+    private void requestBatch() {
+        BlockVector2 chunk;
+        for (int i = 0; i < this.batchSize && (chunk = this.requestedChunks.poll()) != null; i++) {
+            // This required PaperLib to be bumped to version 1.0.4 to mark the request as urgent
+            PaperLib.getChunkAtAsync(this.world, chunk.getX(), chunk.getZ(), true, true)
+                .whenComplete((chunkObject, throwable) -> {
+                    if (throwable != null) {
+                        throwable.printStackTrace();
+                        // We want one less because this couldn't be processed
+                        this.expectedSize.decrementAndGet();
+                    } else {
+                        this.processChunk(chunkObject);
+                    }
+                });
+        }
+    }
+
+    private void processChunk(@NotNull final Chunk chunk) {
+        if (!chunk.isLoaded()) {
+            throw new IllegalArgumentException(
+                String.format("Chunk %d;%d is is not loaded", chunk.getX(), chunk.getZ()));
+        }
+        chunk.addPluginChunkTicket(this.plugin);
+        this.availableChunks.add(chunk);
+    }
+
+    private void freeChunk(@NotNull final Chunk chunk) {
+        if (!chunk.isLoaded()) {
+            throw new IllegalArgumentException(
+                String.format("Chunk %d;%d is is not loaded", chunk.getX(), chunk.getZ()));
+        }
+        chunk.removePluginChunkTicket(this.plugin);
+    }
+
+    /**
+     * Get the amount of remaining chunks (at the time of the method call)
+     *
+     * @return Snapshot view of remaining chunk count
+     */
+    public int getRemainingChunks() {
+        return this.expectedSize.get();
+    }
+
+    /**
+     * Get the amount of requested chunks
+     *
+     * @return Requested chunk count
+     */
+    public int getTotalChunks() {
+        return this.totalSize;
+    }
+
+    /**
+     * Subscribe to coordinator progress updates
+     *
+     * @param subscriber Subscriber
+     */
+    public void subscribeToProgress(@NotNull final ChunkCoordinator.ProgressSubscriber subscriber) {
+        this.progressSubscribers.add(subscriber);
+    }
+
+
+    @FunctionalInterface
+    public interface ProgressSubscriber {
+
+        /**
+         * Notify about a progress update in the coordinator
+         *
+         * @param coordinator Coordinator instance that triggered the notification
+         * @param progress    Progress in the range [0, 1]
+         */
+        void notifyProgress(@NotNull final ChunkCoordinator coordinator, final float progress);
+
+    }
+
+
+    public static final class ChunkCoordinatorBuilder {
+
+        private final List<BlockVector2> requestedChunks = new LinkedList<>();
+        private Consumer<Throwable> throwableConsumer = Throwable::printStackTrace;
+        private World world;
+        private Consumer<Chunk> chunkConsumer;
+        private Runnable whenDone = () -> {
+        };
+        private long maxIterationTime = 60; // A little over 1 tick;
+        private int initialBatchSize = 4;
+
+        private ChunkCoordinatorBuilder() {
+        }
+
+        @NotNull public ChunkCoordinatorBuilder inWorld(@NotNull final World world) {
+            this.world = Preconditions.checkNotNull(world, "World may not be null");
+            return this;
+        }
+
+        @NotNull
+        public ChunkCoordinatorBuilder withChunk(@NotNull final BlockVector2 chunkLocation) {
+            this.requestedChunks
+                .add(Preconditions.checkNotNull(chunkLocation, "Chunk location may not be null"));
+            return this;
+        }
+
+        @NotNull public ChunkCoordinatorBuilder withChunks(
+            @NotNull final Collection<BlockVector2> chunkLocations) {
+            chunkLocations.forEach(this::withChunk);
+            return this;
+        }
+
+        @NotNull
+        public ChunkCoordinatorBuilder withConsumer(@NotNull final Consumer<Chunk> chunkConsumer) {
+            this.chunkConsumer =
+                Preconditions.checkNotNull(chunkConsumer, "Chunk consumer may not be null");
+            return this;
+        }
+
+        @NotNull public ChunkCoordinatorBuilder withFinalAction(@NotNull final Runnable whenDone) {
+            this.whenDone = Preconditions.checkNotNull(whenDone, "Final action may not be null");
+            return this;
+        }
+
+        @NotNull public ChunkCoordinatorBuilder withMaxIterationTime(final long maxIterationTime) {
+            Preconditions
+                .checkArgument(maxIterationTime > 0, "Max iteration time must be positive");
+            this.maxIterationTime = maxIterationTime;
+            return this;
+        }
+
+        @NotNull public ChunkCoordinatorBuilder withInitialBatchSize(final int initialBatchSize) {
+            Preconditions
+                .checkArgument(initialBatchSize > 0, "Initial batch size must be positive");
+            this.initialBatchSize = initialBatchSize;
+            return this;
+        }
+
+        @NotNull public ChunkCoordinatorBuilder withThrowableConsumer(
+            @NotNull final Consumer<Throwable> throwableConsumer) {
+            this.throwableConsumer =
+                Preconditions.checkNotNull(throwableConsumer, "Throwable consumer may not be null");
+            return this;
+        }
+
+        @NotNull public ChunkCoordinator build() {
+            Preconditions.checkNotNull(this.world, "No world was supplied");
+            Preconditions.checkNotNull(this.chunkConsumer, "No chunk consumer was supplied");
+            Preconditions.checkNotNull(this.whenDone, "No final action was supplied");
+            Preconditions
+                .checkNotNull(this.throwableConsumer, "No throwable consumer was supplied");
+            return new ChunkCoordinator(this.maxIterationTime, this.initialBatchSize,
+                this.chunkConsumer, this.world, this.requestedChunks, this.whenDone,
+                this.throwableConsumer);
+        }
+
+    }
+
+}

Bukkit/src/main/java/com/plotsquared/bukkit/queue/GenChunk.java

@@ -0,0 +1,220 @@
+/*
+ *       _____  _       _    _____                                _
+ *      |  __ \| |     | |  / ____|                              | |
+ *      | |__) | | ___ | |_| (___   __ _ _   _  __ _ _ __ ___  __| |
+ *      |  ___/| |/ _ \| __|\___ \ / _` | | | |/ _` | '__/ _ \/ _` |
+ *      | |    | | (_) | |_ ____) | (_| | |_| | (_| | | |  __/ (_| |
+ *      |_|    |_|\___/ \__|_____/ \__, |\__,_|\__,_|_|  \___|\__,_|
+ *                                    | |
+ *                                    |_|
+ *            PlotSquared plot management system for Minecraft
+ *                  Copyright (C) 2021 IntellectualSites
+ *
+ *     This program is free software: you can redistribute it and/or modify
+ *     it under the terms of the GNU 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 General Public License for more details.
+ *
+ *     You should have received a copy of the GNU General Public License
+ *     along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package com.plotsquared.bukkit.queue;
+
+import com.google.common.base.Preconditions;
+import com.plotsquared.bukkit.util.BukkitBlockUtil;
+import com.plotsquared.bukkit.util.BukkitUtil;
+import com.plotsquared.core.location.ChunkWrapper;
+import com.plotsquared.core.location.Location;
+import com.plotsquared.core.queue.ScopedLocalBlockQueue;
+import com.plotsquared.core.util.MainUtil;
+import com.plotsquared.core.util.PatternUtil;
+import com.sk89q.worldedit.bukkit.BukkitAdapter;
+import com.sk89q.worldedit.function.pattern.Pattern;
+import com.sk89q.worldedit.world.biome.BiomeType;
+import com.sk89q.worldedit.world.block.BaseBlock;
+import com.sk89q.worldedit.world.block.BlockState;
+import com.sk89q.worldedit.world.block.BlockTypes;
+import lombok.Getter;
+import lombok.Setter;
+import org.bukkit.Chunk;
+import org.bukkit.World;
+import org.bukkit.block.Biome;
+import org.bukkit.generator.ChunkGenerator.BiomeGrid;
+import org.bukkit.generator.ChunkGenerator.ChunkData;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Arrays;
+
+public class GenChunk extends ScopedLocalBlockQueue {
+
+    public final Biome[] biomes;
+    public BlockState[][] result;
+    public BiomeGrid biomeGrid;
+    public Chunk chunk;
+    public String world;
+    public int chunkX;
+    public int chunkZ;
+    @Getter @Setter private ChunkData chunkData = null;
+
+    public GenChunk() {
+        super(null, new Location(null, 0, 0, 0), new Location(null, 15, 255, 15));
+        this.biomes = Biome.values();
+    }
+
+    public Chunk getChunk() {
+        if (chunk == null) {
+            World worldObj = BukkitUtil.getWorld(world);
+            if (worldObj != null) {
+                this.chunk = worldObj.getChunkAt(chunkX, chunkZ);
+            }
+        }
+        return chunk;
+    }
+
+    public void setChunk(Chunk chunk) {
+        this.chunk = chunk;
+    }
+
+    public void setChunk(ChunkWrapper wrap) {
+        chunk = null;
+        world = wrap.world;
+        chunkX = wrap.x;
+        chunkZ = wrap.z;
+    }
+
+    @Override public void fillBiome(BiomeType biomeType) {
+        if (biomeGrid == null) {
+            return;
+        }
+        Biome biome = BukkitAdapter.adapt(biomeType);
+        for (int x = 0; x < 16; x++) {
+            for (int z = 0; z < 16; z++) {
+                this.biomeGrid.setBiome(x, z, biome);
+            }
+        }
+    }
+
+    @Override public void setCuboid(Location pos1, Location pos2, BlockState block) {
+        if (result != null && pos1.getX() == 0 && pos1.getZ() == 0 && pos2.getX() == 15
+            && pos2.getZ() == 15) {
+            for (int y = pos1.getY(); y <= pos2.getY(); y++) {
+                int layer = y >> 4;
+                BlockState[] data = result[layer];
+                if (data == null) {
+                    result[layer] = data = new BlockState[4096];
+                }
+                int start = y << 8;
+                int end = start + 256;
+                Arrays.fill(data, start, end, block);
+            }
+        }
+        int minX = Math.min(pos1.getX(), pos2.getX());
+        int minY = Math.min(pos1.getY(), pos2.getY());
+        int minZ = Math.min(pos1.getZ(), pos2.getZ());
+        int maxX = Math.max(pos1.getX(), pos2.getX());
+        int maxY = Math.max(pos1.getY(), pos2.getY());
+        int maxZ = Math.max(pos1.getZ(), pos2.getZ());
+        chunkData
+            .setRegion(minX, minY, minZ, maxX + 1, maxY + 1, maxZ + 1, BukkitAdapter.adapt(block));
+    }
+
+    @Override public boolean setBiome(int x, int z, BiomeType biomeType) {
+        return setBiome(x, z, BukkitAdapter.adapt(biomeType));
+    }
+
+    public boolean setBiome(int x, int z, Biome biome) {
+        if (this.biomeGrid != null) {
+            this.biomeGrid.setBiome(x, z, biome);
+            return true;
+        }
+        return false;
+    }
+
+    @Override public boolean setBlock(int x, int y, int z, @NotNull Pattern pattern) {
+        return setBlock(x, y, z, PatternUtil
+            .apply(Preconditions.checkNotNull(pattern, "Pattern may not be null"), x, y, z));
+    }
+
+    @Override public boolean setBlock(int x, int y, int z, BlockState id) {
+        if (this.result == null) {
+            this.chunkData.setBlock(x, y, z, BukkitAdapter.adapt(id));
+            return true;
+        }
+        this.chunkData.setBlock(x, y, z, BukkitAdapter.adapt(id));
+        this.storeCache(x, y, z, id);
+        return true;
+    }
+
+    private void storeCache(final int x, final int y, final int z, final BlockState id) {
+        int i = MainUtil.CACHE_I[y][x][z];
+        BlockState[] v = this.result[i];
+        if (v == null) {
+            this.result[i] = v = new BlockState[4096];
+        }
+        int j = MainUtil.CACHE_J[y][x][z];
+        v[j] = id;
+    }
+
+    @Override public boolean setBlock(int x, int y, int z, BaseBlock id) {
+        if (this.result == null) {
+            this.chunkData.setBlock(x, y, z, BukkitAdapter.adapt(id));
+            return true;
+        }
+        this.chunkData.setBlock(x, y, z, BukkitAdapter.adapt(id));
+        this.storeCache(x, y, z, id.toImmutableState());
+        return true;
+    }
+
+    @Override public BlockState getBlock(int x, int y, int z) {
+        int i = MainUtil.CACHE_I[y][x][z];
+        if (result == null) {
+            return BukkitBlockUtil.get(chunkData.getType(x, y, z));
+        }
+        BlockState[] array = result[i];
+        if (array == null) {
+            return BlockTypes.AIR.getDefaultState();
+        }
+        int j = MainUtil.CACHE_J[y][x][z];
+        return array[j];
+    }
+
+    public int getX() {
+        return chunk == null ? chunkX : chunk.getX();
+    }
+
+    public int getZ() {
+        return chunk == null ? chunkZ : chunk.getZ();
+    }
+
+    @Override public String getWorld() {
+        return chunk == null ? world : chunk.getWorld().getName();
+    }
+
+    @Override public Location getMax() {
+        return new Location(getWorld(), 15 + (getX() << 4), 255, 15 + (getZ() << 4));
+    }
+
+    @Override public Location getMin() {
+        return new Location(getWorld(), getX() << 4, 0, getZ() << 4);
+    }
+
+    public GenChunk clone() {
+        GenChunk toReturn = new GenChunk();
+        if (this.result != null) {
+            for (int i = 0; i < this.result.length; i++) {
+                BlockState[] matrix = this.result[i];
+                if (matrix != null) {
+                    toReturn.result[i] = new BlockState[matrix.length];
+                    System.arraycopy(matrix, 0, toReturn.result[i], 0, matrix.length);
+                }
+            }
+        }
+        toReturn.chunkData = this.chunkData;
+        return toReturn;
+    }
+}

Bukkit/src/main/java/com/plotsquared/bukkit/schematic/BukkitSchematicHandler.java

@@ -0,0 +1,41 @@
+/*
+ *       _____  _       _    _____                                _
+ *      |  __ \| |     | |  / ____|                              | |
+ *      | |__) | | ___ | |_| (___   __ _ _   _  __ _ _ __ ___  __| |
+ *      |  ___/| |/ _ \| __|\___ \ / _` | | | |/ _` | '__/ _ \/ _` |
+ *      | |    | | (_) | |_ ____) | (_| | |_| | (_| | | |  __/ (_| |
+ *      |_|    |_|\___/ \__|_____/ \__, |\__,_|\__,_|_|  \___|\__,_|
+ *                                    | |
+ *                                    |_|
+ *            PlotSquared plot management system for Minecraft
+ *                  Copyright (C) 2021 IntellectualSites
+ *
+ *     This program is free software: you can redistribute it and/or modify
+ *     it under the terms of the GNU 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 General Public License for more details.
+ *
+ *     You should have received a copy of the GNU General Public License
+ *     along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package com.plotsquared.bukkit.schematic;
+
+import com.plotsquared.core.queue.LocalBlockQueue;
+import com.plotsquared.core.util.SchematicHandler;
+import com.sk89q.jnbt.CompoundTag;
+
+/**
+ * Schematic Handler.
+ */
+public class BukkitSchematicHandler extends SchematicHandler {
+
+    @Override
+    public boolean restoreTile(LocalBlockQueue queue, CompoundTag ct, int x, int y, int z) {
+        return new StateWrapper(ct).restoreTag(queue.getWorld(), x, y, z);
+    }
+}

Bukkit/src/main/java/com/plotsquared/bukkit/schematic/StateWrapper.java

@@ -0,0 +1,280 @@
+/*
+ *       _____  _       _    _____                                _
+ *      |  __ \| |     | |  / ____|                              | |
+ *      | |__) | | ___ | |_| (___   __ _ _   _  __ _ _ __ ___  __| |
+ *      |  ___/| |/ _ \| __|\___ \ / _` | | | |/ _` | '__/ _ \/ _` |
+ *      | |    | | (_) | |_ ____) | (_| | |_| | (_| | | |  __/ (_| |
+ *      |_|    |_|\___/ \__|_____/ \__, |\__,_|\__,_|_|  \___|\__,_|
+ *                                    | |
+ *                                    |_|
+ *            PlotSquared plot management system for Minecraft
+ *                  Copyright (C) 2021 IntellectualSites
+ *
+ *     This program is free software: you can redistribute it and/or modify
+ *     it under the terms of the GNU 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 General Public License for more details.
+ *
+ *     You should have received a copy of the GNU General Public License
+ *     along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package com.plotsquared.bukkit.schematic;
+
+import com.plotsquared.bukkit.util.BukkitUtil;
+import com.plotsquared.core.configuration.Captions;
+import com.sk89q.jnbt.ByteTag;
+import com.sk89q.jnbt.CompoundTag;
+import com.sk89q.jnbt.ListTag;
+import com.sk89q.jnbt.ShortTag;
+import com.sk89q.jnbt.StringTag;
+import com.sk89q.jnbt.Tag;
+import com.sk89q.worldedit.blocks.BaseItemStack;
+import com.sk89q.worldedit.bukkit.BukkitAdapter;
+import com.sk89q.worldedit.world.item.ItemType;
+import org.bukkit.World;
+import org.bukkit.block.Block;
+import org.bukkit.block.Container;
+import org.bukkit.block.Sign;
+import org.bukkit.enchantments.Enchantment;
+import org.bukkit.inventory.Inventory;
+import org.bukkit.inventory.InventoryHolder;
+import org.bukkit.inventory.ItemStack;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+
+public class StateWrapper {
+
+    public org.bukkit.block.BlockState state = null;
+    public CompoundTag tag = null;
+
+    public StateWrapper(org.bukkit.block.BlockState state) {
+        this.state = state;
+    }
+
+    public StateWrapper(CompoundTag tag) {
+        this.tag = tag;
+    }
+
+    public static String jsonToColourCode(String str) {
+        str = str.replace("{\"extra\":", "").replace("],\"text\":\"\"}", "]")
+            .replace("[{\"color\":\"black\",\"text\":\"", "&0")
+            .replace("[{\"color\":\"dark_blue\",\"text\":\"", "&1")
+            .replace("[{\"color\":\"dark_green\",\"text\":\"", "&2")
+            .replace("[{\"color\":\"dark_aqua\",\"text\":\"", "&3")
+            .replace("[{\"color\":\"dark_red\",\"text\":\"", "&4")
+            .replace("[{\"color\":\"dark_purple\",\"text\":\"", "&5")
+            .replace("[{\"color\":\"gold\",\"text\":\"", "&6")
+            .replace("[{\"color\":\"gray\",\"text\":\"", "&7")
+            .replace("[{\"color\":\"dark_gray\",\"text\":\"", "&8")
+            .replace("[{\"color\":\"blue\",\"text\":\"", "&9")
+            .replace("[{\"color\":\"green\",\"text\":\"", "&a")
+            .replace("[{\"color\":\"aqua\",\"text\":\"", "&b")
+            .replace("[{\"color\":\"red\",\"text\":\"", "&c")
+            .replace("[{\"color\":\"light_purple\",\"text\":\"", "&d")
+            .replace("[{\"color\":\"yellow\",\"text\":\"", "&e")
+            .replace("[{\"color\":\"white\",\"text\":\"", "&f")
+            .replace("[{\"obfuscated\":true,\"text\":\"", "&k")
+            .replace("[{\"bold\":true,\"text\":\"", "&l")
+            .replace("[{\"strikethrough\":true,\"text\":\"", "&m")
+            .replace("[{\"underlined\":true,\"text\":\"", "&n")
+            .replace("[{\"italic\":true,\"text\":\"", "&o").replace("[{\"color\":\"black\",", "&0")
+            .replace("[{\"color\":\"dark_blue\",", "&1")
+            .replace("[{\"color\":\"dark_green\",", "&2")
+            .replace("[{\"color\":\"dark_aqua\",", "&3").replace("[{\"color\":\"dark_red\",", "&4")
+            .replace("[{\"color\":\"dark_purple\",", "&5").replace("[{\"color\":\"gold\",", "&6")
+            .replace("[{\"color\":\"gray\",", "&7").replace("[{\"color\":\"dark_gray\",", "&8")
+            .replace("[{\"color\":\"blue\",", "&9").replace("[{\"color\":\"green\",", "&a")
+            .replace("[{\"color\":\"aqua\",", "&b").replace("[{\"color\":\"red\",", "&c")
+            .replace("[{\"color\":\"light_purple\",", "&d").replace("[{\"color\":\"yellow\",", "&e")
+            .replace("[{\"color\":\"white\",", "&f").replace("[{\"obfuscated\":true,", "&k")
+            .replace("[{\"bold\":true,", "&l").replace("[{\"strikethrough\":true,", "&m")
+            .replace("[{\"underlined\":true,", "&n").replace("[{\"italic\":true,", "&o")
+            .replace("{\"color\":\"black\",\"text\":\"", "&0")
+            .replace("{\"color\":\"dark_blue\",\"text\":\"", "&1")
+            .replace("{\"color\":\"dark_green\",\"text\":\"", "&2")
+            .replace("{\"color\":\"dark_aqua\",\"text\":\"", "&3")
+            .replace("{\"color\":\"dark_red\",\"text\":\"", "&4")
+            .replace("{\"color\":\"dark_purple\",\"text\":\"", "&5")
+            .replace("{\"color\":\"gold\",\"text\":\"", "&6")
+            .replace("{\"color\":\"gray\",\"text\":\"", "&7")
+            .replace("{\"color\":\"dark_gray\",\"text\":\"", "&8")
+            .replace("{\"color\":\"blue\",\"text\":\"", "&9")
+            .replace("{\"color\":\"green\",\"text\":\"", "&a")
+            .replace("{\"color\":\"aqua\",\"text\":\"", "&b")
+            .replace("{\"color\":\"red\",\"text\":\"", "&c")
+            .replace("{\"color\":\"light_purple\",\"text\":\"", "&d")
+            .replace("{\"color\":\"yellow\",\"text\":\"", "&e")
+            .replace("{\"color\":\"white\",\"text\":\"", "&f")
+            .replace("{\"obfuscated\":true,\"text\":\"", "&k")
+            .replace("{\"bold\":true,\"text\":\"", "&l")
+            .replace("{\"strikethrough\":true,\"text\":\"", "&m")
+            .replace("{\"underlined\":true,\"text\":\"", "&n")
+            .replace("{\"italic\":true,\"text\":\"", "&o").replace("{\"color\":\"black\",", "&0")
+            .replace("{\"color\":\"dark_blue\",", "&1").replace("{\"color\":\"dark_green\",", "&2")
+            .replace("{\"color\":\"dark_aqua\",", "&3").replace("{\"color\":\"dark_red\",", "&4")
+            .replace("{\"color\":\"dark_purple\",", "&5").replace("{\"color\":\"gold\",", "&6")
+            .replace("{\"color\":\"gray\",", "&7").replace("{\"color\":\"dark_gray\",", "&8")
+            .replace("{\"color\":\"blue\",", "&9").replace("{\"color\":\"green\",", "&a")
+            .replace("{\"color\":\"aqua\",", "&b").replace("{\"color\":\"red\",", "&c")
+            .replace("{\"color\":\"light_purple\",", "&d").replace("{\"color\":\"yellow\",", "&e")
+            .replace("{\"color\":\"white\",", "&f").replace("{\"obfuscated\":true,", "&k")
+            .replace("{\"bold\":true,", "&l").replace("{\"strikethrough\":true,", "&m")
+            .replace("{\"underlined\":true,", "&n").replace("{\"italic\":true,", "&o")
+            .replace("\"color\":\"black\",\"text\":\"", "&0")
+            .replace("\"color\":\"dark_blue\",\"text\":\"", "&1")
+            .replace("\"color\":\"dark_green\",\"text\":\"", "&2")
+            .replace("\"color\":\"dark_aqua\",\"text\":\"", "&3")
+            .replace("\"color\":\"dark_red\",\"text\":\"", "&4")
+            .replace("\"color\":\"dark_purple\",\"text\":\"", "&5")
+            .replace("\"color\":\"gold\",\"text\":\"", "&6")
+            .replace("\"color\":\"gray\",\"text\":\"", "&7")
+            .replace("\"color\":\"dark_gray\",\"text\":\"", "&8")
+            .replace("\"color\":\"blue\",\"text\":\"", "&9")
+            .replace("\"color\":\"green\",\"text\":\"", "&a")
+            .replace("\"color\":\"aqua\",\"text\":\"", "&b")
+            .replace("\"color\":\"red\",\"text\":\"", "&c")
+            .replace("\"color\":\"light_purple\",\"text\":\"", "&d")
+            .replace("\"color\":\"yellow\",\"text\":\"", "&e")
+            .replace("\"color\":\"white\",\"text\":\"", "&f")
+            .replace("\"obfuscated\":true,\"text\":\"", "&k")
+            .replace("\"bold\":true,\"text\":\"", "&l")
+            .replace("\"strikethrough\":true,\"text\":\"", "&m")
+            .replace("\"underlined\":true,\"text\":\"", "&n")
+            .replace("\"italic\":true,\"text\":\"", "&o").replace("\"color\":\"black\",", "&0")
+            .replace("\"color\":\"dark_blue\",", "&1").replace("\"color\":\"dark_green\",", "&2")
+            .replace("\"color\":\"dark_aqua\",", "&3").replace("\"color\":\"dark_red\",", "&4")
+            .replace("\"color\":\"dark_purple\",", "&5").replace("\"color\":\"gold\",", "&6")
+            .replace("\"color\":\"gray\",", "&7").replace("\"color\":\"dark_gray\",", "&8")
+            .replace("\"color\":\"blue\",", "&9").replace("\"color\":\"green\",", "&a")
+            .replace("\"color\":\"aqua\",", "&b").replace("\"color\":\"red\",", "&c")
+            .replace("\"color\":\"light_purple\",", "&d").replace("\"color\":\"yellow\",", "&e")
+            .replace("\"color\":\"white\",", "&f").replace("\"obfuscated\":true,", "&k")
+            .replace("\"bold\":true,", "&l").replace("\"strikethrough\":true,", "&m")
+            .replace("\"underlined\":true,", "&n").replace("\"italic\":true,", "&o")
+            .replace("[{\"text\":\"", "&0").replace("{\"text\":\"", "&0").replace("\"},", "")
+            .replace("\"}]", "").replace("\"}", "");
+        for (Entry<String, String> entry : Captions.replacements.entrySet()) {
+            str = str.replace(entry.getKey(), entry.getValue());
+        }
+        return str;
+    }
+
+    public boolean restoreTag(String worldName, int x, int y, int z) {
+        if (this.tag == null) {
+            return false;
+        }
+        World world = BukkitUtil.getWorld(worldName);
+        Block block = world.getBlockAt(x, y, z);
+        if (block == null) {
+            return false;
+        }
+        org.bukkit.block.BlockState state = block.getState();
+        switch (getId()) {
+            case "chest":
+            case "beacon":
+            case "brewingstand":
+            case "dispenser":
+            case "dropper":
+            case "furnace":
+            case "hopper":
+            case "shulkerbox":
+                if (!(state instanceof Container)) {
+                    return false;
+                }
+                List<Tag> itemsTag = this.tag.getListTag("Items").getValue();
+                Container container = (Container) state;
+                Inventory inv = container.getSnapshotInventory();
+                for (Tag itemTag : itemsTag) {
+                    CompoundTag itemComp = (CompoundTag) itemTag;
+                    ItemType type = ItemType.REGISTRY.get(itemComp.getString("id").toLowerCase());
+                    if (type == null) {
+                        continue;
+                    }
+                    int count = itemComp.getByte("Count");
+                    int slot = itemComp.getByte("Slot");
+                    CompoundTag tag = (CompoundTag) itemComp.getValue().get("tag");
+                    BaseItemStack baseItemStack = new BaseItemStack(type, tag, count);
+                    ItemStack itemStack = BukkitAdapter.adapt(baseItemStack);
+                    inv.setItem(slot, itemStack);
+                }
+                container.update(true, false);
+                return true;
+            case "sign":
+                if (state instanceof Sign) {
+                    Sign sign = (Sign) state;
+                    sign.setLine(0, jsonToColourCode(tag.getString("Text1")));
+                    sign.setLine(1, jsonToColourCode(tag.getString("Text2")));
+                    sign.setLine(2, jsonToColourCode(tag.getString("Text3")));
+                    sign.setLine(3, jsonToColourCode(tag.getString("Text4")));
+                    state.update(true);
+                    return true;
+                }
+                return false;
+        }
+        return false;
+    }
+
+    public CompoundTag getTag() {
+        if (this.tag != null) {
+            return this.tag;
+        }
+        if (this.state instanceof InventoryHolder) {
+            InventoryHolder inv = (InventoryHolder) this.state;
+            ItemStack[] contents = inv.getInventory().getContents();
+            Map<String, Tag> values = new HashMap<>();
+            values.put("Items", new ListTag(CompoundTag.class, serializeInventory(contents)));
+            return new CompoundTag(values);
+        }
+        return null;
+    }
+
+    public String getId() {
+        String tileid = this.tag.getString("id").toLowerCase();
+        if (tileid.startsWith("minecraft:")) {
+            tileid = tileid.replace("minecraft:", "");
+        }
+        return tileid;
+    }
+
+    public List<CompoundTag> serializeInventory(ItemStack[] items) {
+        List<CompoundTag> tags = new ArrayList<>();
+        for (int i = 0; i < items.length; ++i) {
+            if (items[i] != null) {
+                Map<String, Tag> tagData = serializeItem(items[i]);
+                tagData.put("Slot", new ByteTag((byte) i));
+                tags.add(new CompoundTag(tagData));
+            }
+        }
+        return tags;
+    }
+
+    public Map<String, Tag> serializeItem(ItemStack item) {
+        Map<String, Tag> data = new HashMap<>();
+        data.put("id", new StringTag(item.getType().name()));
+        data.put("Damage", new ShortTag(item.getDurability()));
+        data.put("Count", new ByteTag((byte) item.getAmount()));
+        if (!item.getEnchantments().isEmpty()) {
+            List<CompoundTag> enchantmentList = new ArrayList<>();
+            for (Entry<Enchantment, Integer> entry : item.getEnchantments().entrySet()) {
+                Map<String, Tag> enchantment = new HashMap<>();
+                enchantment.put("id", new StringTag(entry.getKey().toString()));
+                enchantment.put("lvl", new ShortTag(entry.getValue().shortValue()));
+                enchantmentList.add(new CompoundTag(enchantment));
+            }
+            Map<String, Tag> auxData = new HashMap<>();
+            auxData.put("ench", new ListTag(CompoundTag.class, enchantmentList));
+            data.put("tag", new CompoundTag(auxData));
+        }
+        return data;
+    }
+
+}

Bukkit/src/main/java/com/plotsquared/bukkit/util/BukkitBlockUtil.java

@@ -0,0 +1,56 @@
+/*
+ *       _____  _       _    _____                                _
+ *      |  __ \| |     | |  / ____|                              | |
+ *      | |__) | | ___ | |_| (___   __ _ _   _  __ _ _ __ ___  __| |
+ *      |  ___/| |/ _ \| __|\___ \ / _` | | | |/ _` | '__/ _ \/ _` |
+ *      | |    | | (_) | |_ ____) | (_| | |_| | (_| | | |  __/ (_| |
+ *      |_|    |_|\___/ \__|_____/ \__, |\__,_|\__,_|_|  \___|\__,_|
+ *                                    | |
+ *                                    |_|
+ *            PlotSquared plot management system for Minecraft
+ *                  Copyright (C) 2021 IntellectualSites
+ *
+ *     This program is free software: you can redistribute it and/or modify
+ *     it under the terms of the GNU 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 General Public License for more details.
+ *
+ *     You should have received a copy of the GNU General Public License
+ *     along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package com.plotsquared.bukkit.util;
+
+import com.sk89q.worldedit.bukkit.BukkitAdapter;
+import com.sk89q.worldedit.world.block.BlockState;
+import com.sk89q.worldedit.world.item.ItemType;
+import org.bukkit.Material;
+import org.bukkit.block.Block;
+
+import java.util.function.Supplier;
+
+public class BukkitBlockUtil {
+    public static Supplier<ItemType> supplyItem(Block block) {
+        return new Supplier<ItemType>() {
+            @Override public ItemType get() {
+                return BukkitAdapter.asItemType(block.getType());
+            }
+        };
+    }
+
+    public static Supplier<ItemType> supplyItem(Material type) {
+        return () -> BukkitAdapter.asItemType(type);
+    }
+
+    public static BlockState get(Block block) {
+        return get(block.getType());
+    }
+
+    public static BlockState get(Material material) {
+        return BukkitAdapter.asBlockType(material).getDefaultState();
+    }
+}

Bukkit/src/main/java/com/plotsquared/bukkit/util/BukkitChatManager.java

@@ -0,0 +1,78 @@
+/*
+ *       _____  _       _    _____                                _
+ *      |  __ \| |     | |  / ____|                              | |
+ *      | |__) | | ___ | |_| (___   __ _ _   _  __ _ _ __ ___  __| |
+ *      |  ___/| |/ _ \| __|\___ \ / _` | | | |/ _` | '__/ _ \/ _` |
+ *      | |    | | (_) | |_ ____) | (_| | |_| | (_| | | |  __/ (_| |
+ *      |_|    |_|\___/ \__|_____/ \__, |\__,_|\__,_|_|  \___|\__,_|
+ *                                    | |
+ *                                    |_|
+ *            PlotSquared plot management system for Minecraft
+ *                  Copyright (C) 2021 IntellectualSites
+ *
+ *     This program is free software: you can redistribute it and/or modify
+ *     it under the terms of the GNU 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 General Public License for more details.
+ *
+ *     You should have received a copy of the GNU General Public License
+ *     along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package com.plotsquared.bukkit.util;
+
+import com.plotsquared.bukkit.chat.FancyMessage;
+import com.plotsquared.bukkit.player.BukkitPlayer;
+import com.plotsquared.core.configuration.Captions;
+import com.plotsquared.core.configuration.Settings;
+import com.plotsquared.core.player.ConsolePlayer;
+import com.plotsquared.core.player.PlotPlayer;
+import com.plotsquared.core.plot.message.PlotMessage;
+import com.plotsquared.core.util.ChatManager;
+import org.bukkit.ChatColor;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.stream.Collectors;
+
+public class BukkitChatManager extends ChatManager<FancyMessage> {
+
+    @Override public FancyMessage builder() {
+        return new FancyMessage("");
+    }
+
+    @Override public void color(PlotMessage message, String color) {
+        message.$(this).color(ChatColor.getByChar(Captions.color(color).substring(1)));
+    }
+
+    @Override public void tooltip(PlotMessage message, PlotMessage... tooltips) {
+        List<FancyMessage> lines =
+            Arrays.stream(tooltips).map(tooltip -> tooltip.$(this)).collect(Collectors.toList());
+        message.$(this).formattedTooltip(lines);
+    }
+
+    @Override public void command(PlotMessage message, String command) {
+        message.$(this).command(command);
+    }
+
+    @Override public void text(PlotMessage message, String text) {
+        message.$(this).then(ChatColor.stripColor(text));
+    }
+
+    @Override public void send(PlotMessage plotMessage, PlotPlayer player) {
+        if (player instanceof ConsolePlayer || !Settings.Chat.INTERACTIVE) {
+            player.sendMessage(plotMessage.$(this).toOldMessageFormat());
+        } else {
+            plotMessage.$(this).send(((BukkitPlayer) player).player);
+        }
+    }
+
+    @Override public void suggest(PlotMessage plotMessage, String command) {
+        plotMessage.$(this).suggest(command);
+    }
+
+}

Bukkit/src/main/java/com/plotsquared/bukkit/util/BukkitChunkManager.java

@@ -0,0 +1,165 @@
+/*
+ *       _____  _       _    _____                                _
+ *      |  __ \| |     | |  / ____|                              | |
+ *      | |__) | | ___ | |_| (___   __ _ _   _  __ _ _ __ ___  __| |
+ *      |  ___/| |/ _ \| __|\___ \ / _` | | | |/ _` | '__/ _ \/ _` |
+ *      | |    | | (_) | |_ ____) | (_| | |_| | (_| | | |  __/ (_| |
+ *      |_|    |_|\___/ \__|_____/ \__, |\__,_|\__,_|_|  \___|\__,_|
+ *                                    | |
+ *                                    |_|
+ *            PlotSquared plot management system for Minecraft
+ *                  Copyright (C) 2021 IntellectualSites
+ *
+ *     This program is free software: you can redistribute it and/or modify
+ *     it under the terms of the GNU 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 General Public License for more details.
+ *
+ *     You should have received a copy of the GNU General Public License
+ *     along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package com.plotsquared.bukkit.util;
+
+import com.plotsquared.core.PlotSquared;
+import com.plotsquared.core.listener.WEExtent;
+import com.plotsquared.core.queue.GlobalBlockQueue;
+import com.plotsquared.core.queue.LocalBlockQueue;
+import com.plotsquared.core.util.ChunkManager;
+import com.plotsquared.core.util.entity.EntityCategories;
+import com.plotsquared.core.util.task.TaskManager;
+import com.sk89q.worldedit.bukkit.BukkitAdapter;
+import com.sk89q.worldedit.bukkit.BukkitWorld;
+import com.sk89q.worldedit.math.BlockVector2;
+import com.sk89q.worldedit.math.BlockVector3;
+import com.sk89q.worldedit.regions.CuboidRegion;
+import com.sk89q.worldedit.world.block.BaseBlock;
+import io.papermc.lib.PaperLib;
+import org.bukkit.Chunk;
+import org.bukkit.World;
+import org.bukkit.block.Block;
+import org.bukkit.block.data.BlockData;
+import org.bukkit.entity.Entity;
+
+import java.util.concurrent.CompletableFuture;
+
+import static com.plotsquared.core.util.entity.EntityCategories.CAP_ANIMAL;
+import static com.plotsquared.core.util.entity.EntityCategories.CAP_ENTITY;
+import static com.plotsquared.core.util.entity.EntityCategories.CAP_MISC;
+import static com.plotsquared.core.util.entity.EntityCategories.CAP_MOB;
+import static com.plotsquared.core.util.entity.EntityCategories.CAP_MONSTER;
+import static com.plotsquared.core.util.entity.EntityCategories.CAP_VEHICLE;
+
+public class BukkitChunkManager extends ChunkManager {
+
+    public static boolean isIn(CuboidRegion region, int x, int z) {
+        return x >= region.getMinimumPoint().getX() && x <= region.getMaximumPoint().getX()
+            && z >= region.getMinimumPoint().getZ() && z <= region.getMaximumPoint().getZ();
+    }
+
+    public static ContentMap swapChunk(World world1, World world2, Chunk pos1, Chunk pos2,
+        CuboidRegion r1, CuboidRegion r2) {
+        ContentMap map = new ContentMap();
+        int relX = r2.getMinimumPoint().getX() - r1.getMinimumPoint().getX();
+        int relZ = r2.getMinimumPoint().getZ() - r1.getMinimumPoint().getZ();
+
+        map.saveEntitiesIn(pos1, r1, relX, relZ, true);
+        map.saveEntitiesIn(pos2, r2, -relX, -relZ, true);
+
+        int sx = pos1.getX() << 4;
+        int sz = pos1.getZ() << 4;
+
+        String worldName1 = world1.getName();
+        String worldName2 = world2.getName();
+
+        BukkitWorld bukkitWorld1 = new BukkitWorld(world1);
+        BukkitWorld bukkitWorld2 = new BukkitWorld(world2);
+
+        LocalBlockQueue queue1 = GlobalBlockQueue.IMP.getNewQueue(worldName1, false);
+        LocalBlockQueue queue2 = GlobalBlockQueue.IMP.getNewQueue(worldName2, false);
+
+        for (int x = Math.max(r1.getMinimumPoint().getX(), sx);
+             x <= Math.min(r1.getMaximumPoint().getX(), sx + 15); x++) {
+            for (int z = Math.max(r1.getMinimumPoint().getZ(), sz);
+                 z <= Math.min(r1.getMaximumPoint().getZ(), sz + 15); z++) {
+                for (int y = 0; y < 256; y++) {
+                    Block block1 = world1.getBlockAt(x, y, z);
+                    BaseBlock baseBlock1 = bukkitWorld1.getFullBlock(BlockVector3.at(x, y, z));
+                    BlockData data1 = block1.getBlockData();
+
+                    int xx = x + relX;
+                    int zz = z + relZ;
+
+                    Block block2 = world2.getBlockAt(xx, y, zz);
+                    BaseBlock baseBlock2 = bukkitWorld2.getFullBlock(BlockVector3.at(xx, y, zz));
+                    BlockData data2 = block2.getBlockData();
+
+                    if (block1.isEmpty()) {
+                        if (!block2.isEmpty()) {
+                            queue1.setBlock(x, y, z, baseBlock2);
+                            queue2.setBlock(xx, y, zz, WEExtent.AIRBASE);
+                        }
+                    } else if (block2.isEmpty()) {
+                        queue1.setBlock(x, y, z, WEExtent.AIRBASE);
+                        queue2.setBlock(xx, y, zz, baseBlock1);
+                    } else if (block1.equals(block2)) {
+                        if (!data1.matches(data2)) {
+                            block1.setBlockData(data2);
+                            block2.setBlockData(data1);
+                        }
+                    } else {
+                        queue1.setBlock(x, y, z, baseBlock2);
+                        queue2.setBlock(xx, y, zz, baseBlock1);
+                    }
+                }
+            }
+        }
+        queue1.enqueue();
+        queue2.enqueue();
+        return map;
+    }
+
+    @Override
+    public CompletableFuture<?> loadChunk(String world, BlockVector2 chunkLoc, boolean force) {
+        return PaperLib
+            .getChunkAtAsync(BukkitUtil.getWorld(world), chunkLoc.getX(), chunkLoc.getZ(), force);
+    }
+
+    @Override
+    public void unloadChunk(final String world, final BlockVector2 chunkLoc, final boolean save) {
+        if (!PlotSquared.get().isMainThread(Thread.currentThread())) {
+            TaskManager.runTask(() -> BukkitUtil.getWorld(world)
+                .unloadChunk(chunkLoc.getX(), chunkLoc.getZ(), save));
+        } else {
+            BukkitUtil.getWorld(world).unloadChunk(chunkLoc.getX(), chunkLoc.getZ(), save);
+        }
+    }
+
+    private void count(int[] count, Entity entity) {
+        final com.sk89q.worldedit.world.entity.EntityType entityType =
+            BukkitAdapter.adapt(entity.getType());
+
+        if (EntityCategories.PLAYER.contains(entityType)) {
+            return;
+        } else if (EntityCategories.PROJECTILE.contains(entityType) || EntityCategories.OTHER
+            .contains(entityType) || EntityCategories.HANGING.contains(entityType)) {
+            count[CAP_MISC]++;
+        } else if (EntityCategories.ANIMAL.contains(entityType) || EntityCategories.VILLAGER
+            .contains(entityType) || EntityCategories.TAMEABLE.contains(entityType)) {
+            count[CAP_MOB]++;
+            count[CAP_ANIMAL]++;
+        } else if (EntityCategories.VEHICLE.contains(entityType)) {
+            count[CAP_VEHICLE]++;
+        } else if (EntityCategories.HOSTILE.contains(entityType)) {
+            count[CAP_MOB]++;
+            count[CAP_MONSTER]++;
+        }
+        count[CAP_ENTITY]++;
+    }
+
+
+}

Bukkit/src/main/java/com/plotsquared/bukkit/util/BukkitEconHandler.java

@@ -0,0 +1,97 @@
+/*
+ *       _____  _       _    _____                                _
+ *      |  __ \| |     | |  / ____|                              | |
+ *      | |__) | | ___ | |_| (___   __ _ _   _  __ _ _ __ ___  __| |
+ *      |  ___/| |/ _ \| __|\___ \ / _` | | | |/ _` | '__/ _ \/ _` |
+ *      | |    | | (_) | |_ ____) | (_| | |_| | (_| | | |  __/ (_| |
+ *      |_|    |_|\___/ \__|_____/ \__, |\__,_|\__,_|_|  \___|\__,_|
+ *                                    | |
+ *                                    |_|
+ *            PlotSquared plot management system for Minecraft
+ *                  Copyright (C) 2021 IntellectualSites
+ *
+ *     This program is free software: you can redistribute it and/or modify
+ *     it under the terms of the GNU 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 General Public License for more details.
+ *
+ *     You should have received a copy of the GNU General Public License
+ *     along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package com.plotsquared.bukkit.util;
+
+import com.plotsquared.bukkit.player.BukkitOfflinePlayer;
+import com.plotsquared.bukkit.player.BukkitPlayer;
+import com.plotsquared.core.PlotSquared;
+import com.plotsquared.core.player.OfflinePlotPlayer;
+import com.plotsquared.core.player.PlotPlayer;
+import com.plotsquared.core.util.EconHandler;
+import com.plotsquared.core.util.PermHandler;
+import net.milkbowl.vault.economy.Economy;
+import org.bukkit.Bukkit;
+import org.bukkit.plugin.RegisteredServiceProvider;
+
+public class BukkitEconHandler extends EconHandler {
+
+    private Economy econ;
+
+    @Override
+    public boolean init() {
+        if (this.econ == null) {
+            setupEconomy();
+        }
+        return this.econ != null;
+    }
+
+    private void setupEconomy() {
+        if (Bukkit.getServer().getPluginManager().getPlugin("Vault") == null) {
+            return;
+        }
+        RegisteredServiceProvider<Economy> economyProvider =
+            Bukkit.getServer().getServicesManager().getRegistration(Economy.class);
+        if (economyProvider != null) {
+            this.econ = economyProvider.getProvider();
+        }
+    }
+
+    @Override public double getMoney(PlotPlayer<?> player) {
+        double bal = super.getMoney(player);
+        if (Double.isNaN(bal)) {
+            return this.econ.getBalance(((BukkitPlayer) player).player);
+        }
+        return bal;
+    }
+
+    @Override public void withdrawMoney(PlotPlayer<?> player, double amount) {
+        this.econ.withdrawPlayer(((BukkitPlayer) player).player, amount);
+    }
+
+    @Override public void depositMoney(PlotPlayer<?> player, double amount) {
+        this.econ.depositPlayer(((BukkitPlayer) player).player, amount);
+    }
+
+    @Override public void depositMoney(OfflinePlotPlayer player, double amount) {
+        this.econ.depositPlayer(((BukkitOfflinePlayer) player).player, amount);
+    }
+
+    /**
+     * @deprecated Use {@link PermHandler#hasPermission(String, String, String)} instead
+     */
+    @Deprecated @Override public boolean hasPermission(String world, String player, String perm) {
+        if (PlotSquared.imp().getPermissionHandler() != null) {
+            return PlotSquared.imp().getPermissionHandler().hasPermission(world, player, perm);
+        } else {
+            return false;
+        }
+    }
+
+    @Override public double getBalance(PlotPlayer<?> player) {
+        return this.econ.getBalance(player.getName());
+    }
+
+}

Bukkit/src/main/java/com/plotsquared/bukkit/util/BukkitEntityUtil.java

@@ -0,0 +1,364 @@
+/*
+ *       _____  _       _    _____                                _
+ *      |  __ \| |     | |  / ____|                              | |
+ *      | |__) | | ___ | |_| (___   __ _ _   _  __ _ _ __ ___  __| |
+ *      |  ___/| |/ _ \| __|\___ \ / _` | | | |/ _` | '__/ _ \/ _` |
+ *      | |    | | (_) | |_ ____) | (_| | |_| | (_| | | |  __/ (_| |
+ *      |_|    |_|\___/ \__|_____/ \__, |\__,_|\__,_|_|  \___|\__,_|
+ *                                    | |
+ *                                    |_|
+ *            PlotSquared plot management system for Minecraft
+ *                  Copyright (C) 2021 IntellectualSites
+ *
+ *     This program is free software: you can redistribute it and/or modify
+ *     it under the terms of the GNU 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 General Public License for more details.
+ *
+ *     You should have received a copy of the GNU General Public License
+ *     along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package com.plotsquared.bukkit.util;
+
+import com.plotsquared.bukkit.player.BukkitPlayer;
+import com.plotsquared.core.configuration.Captions;
+import com.plotsquared.core.configuration.Settings;
+import com.plotsquared.core.location.Location;
+import com.plotsquared.core.plot.Plot;
+import com.plotsquared.core.plot.PlotArea;
+import com.plotsquared.core.plot.flag.implementations.AnimalAttackFlag;
+import com.plotsquared.core.plot.flag.implementations.AnimalCapFlag;
+import com.plotsquared.core.plot.flag.implementations.DoneFlag;
+import com.plotsquared.core.plot.flag.implementations.EntityCapFlag;
+import com.plotsquared.core.plot.flag.implementations.HangingBreakFlag;
+import com.plotsquared.core.plot.flag.implementations.HostileAttackFlag;
+import com.plotsquared.core.plot.flag.implementations.HostileCapFlag;
+import com.plotsquared.core.plot.flag.implementations.MiscBreakFlag;
+import com.plotsquared.core.plot.flag.implementations.MiscCapFlag;
+import com.plotsquared.core.plot.flag.implementations.MobCapFlag;
+import com.plotsquared.core.plot.flag.implementations.PveFlag;
+import com.plotsquared.core.plot.flag.implementations.PvpFlag;
+import com.plotsquared.core.plot.flag.implementations.TamedAttackFlag;
+import com.plotsquared.core.plot.flag.implementations.VehicleCapFlag;
+import com.plotsquared.core.util.EntityUtil;
+import com.plotsquared.core.util.MainUtil;
+import com.plotsquared.core.util.Permissions;
+import com.plotsquared.core.util.entity.EntityCategories;
+import com.sk89q.worldedit.bukkit.BukkitAdapter;
+import org.bukkit.entity.Arrow;
+import org.bukkit.entity.Creature;
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.EntityType;
+import org.bukkit.entity.Player;
+import org.bukkit.entity.Projectile;
+import org.bukkit.event.entity.EntityDamageEvent;
+import org.bukkit.projectiles.BlockProjectileSource;
+import org.bukkit.projectiles.ProjectileSource;
+
+import java.util.Objects;
+
+public class BukkitEntityUtil {
+
+    public static final com.sk89q.worldedit.world.entity.EntityType FAKE_ENTITY_TYPE =
+        new com.sk89q.worldedit.world.entity.EntityType("plotsquared:fake");
+
+    public static boolean entityDamage(Entity damager, Entity victim) {
+        return entityDamage(damager, victim, null);
+    }
+
+    public static boolean entityDamage(Entity damager, Entity victim,
+        EntityDamageEvent.DamageCause cause) {
+        Location dloc = BukkitUtil.getLocation(damager);
+        Location vloc = BukkitUtil.getLocation(victim);
+        PlotArea dArea = dloc.getPlotArea();
+        PlotArea vArea;
+        if (dArea != null && dArea.contains(vloc.getX(), vloc.getZ())) {
+            vArea = dArea;
+        } else {
+            vArea = vloc.getPlotArea();
+        }
+        if (dArea == null && vArea == null) {
+            return true;
+        }
+
+        Plot dplot;
+        if (dArea != null) {
+            dplot = dArea.getPlot(dloc);
+        } else {
+            dplot = null;
+        }
+        Plot vplot;
+        if (vArea != null) {
+            vplot = vArea.getPlot(vloc);
+        } else {
+            vplot = null;
+        }
+
+        Plot plot;
+        String stub;
+        boolean isPlot = true;
+        if (dplot == null && vplot == null) {
+            if (dArea == null) {
+                return true;
+            }
+            plot = null;
+            stub = "road";
+            isPlot = false;
+        } else {
+            // Prioritize plots for close to seamless pvp zones
+            if (victim.getTicksLived() > damager.getTicksLived()) {
+                if (dplot == null || !(victim instanceof Player)) {
+                    if (vplot == null) {
+                        plot = dplot;
+                    } else {
+                        plot = vplot;
+                    }
+                } else {
+                    plot = dplot;
+                }
+            } else if (dplot == null || !(victim instanceof Player)) {
+                if (vplot == null) {
+                    plot = dplot;
+                } else {
+                    plot = vplot;
+                }
+            } else if (vplot == null) {
+                plot = dplot;
+            } else {
+                plot = vplot;
+            }
+            if (plot.hasOwner()) {
+                stub = "other";
+            } else {
+                stub = "unowned";
+            }
+        }
+        boolean roadFlags = vArea != null ? vArea.isRoadFlags() : dArea.isRoadFlags();
+        PlotArea area = vArea != null ? vArea : dArea;
+
+        Player player;
+        if (damager instanceof Player) { // attacker is player
+            player = (Player) damager;
+        } else if (damager instanceof Projectile) {
+            Projectile projectile = (Projectile) damager;
+            ProjectileSource shooter = projectile.getShooter();
+            if (shooter instanceof Player) { // shooter is player
+                player = (Player) shooter;
+            } else { // shooter is not player
+                if (shooter instanceof BlockProjectileSource) {
+                    Location sLoc = BukkitUtil
+                        .getLocation(((BlockProjectileSource) shooter).getBlock().getLocation());
+                    dplot = dArea.getPlot(sLoc);
+                }
+                player = null;
+            }
+        } else { // Attacker is not player
+            player = null;
+        }
+        if (player != null) {
+            BukkitPlayer plotPlayer = BukkitUtil.getPlayer(player);
+
+            final com.sk89q.worldedit.world.entity.EntityType entityType;
+
+            // Create a fake entity type if the type does not have a name
+            if (victim.getType().getName() == null) {
+                entityType = FAKE_ENTITY_TYPE;
+            } else {
+                entityType = BukkitAdapter.adapt(victim.getType());
+            }
+
+            if (EntityCategories.HANGING.contains(entityType)) { // hanging
+                if (plot != null && (plot.getFlag(HangingBreakFlag.class) || plot
+                    .isAdded(plotPlayer.getUUID()))) {
+                    if (Settings.Done.RESTRICT_BUILDING && DoneFlag.isDone(plot)) {
+                        if (!Permissions
+                            .hasPermission(plotPlayer, Captions.PERMISSION_ADMIN_BUILD_OTHER)) {
+                            MainUtil.sendMessage(plotPlayer, Captions.NO_PERMISSION_EVENT,
+                                Captions.PERMISSION_ADMIN_BUILD_OTHER);
+                            return false;
+                        }
+                    }
+                    return true;
+                }
+                if (!Permissions.hasPermission(plotPlayer, "plots.admin.destroy." + stub)) {
+                    MainUtil.sendMessage(plotPlayer, Captions.NO_PERMISSION_EVENT,
+                        "plots.admin.destroy." + stub);
+                    return false;
+                }
+            } else if (victim.getType() == EntityType.ARMOR_STAND) {
+                if (plot != null && (plot.getFlag(MiscBreakFlag.class) || plot
+                    .isAdded(plotPlayer.getUUID()))) {
+                    return true;
+                }
+                if (!Permissions.hasPermission(plotPlayer, "plots.admin.destroy." + stub)) {
+                    MainUtil.sendMessage(plotPlayer, Captions.NO_PERMISSION_EVENT,
+                        "plots.admin.destroy." + stub);
+                    if (plot != null) {
+                        plot.debug(player.getName()
+                            + " could not break armor stand because misc-break = false");
+                    }
+                    return false;
+                }
+            } else if (EntityCategories.HOSTILE.contains(entityType)) {
+                if (isPlot) {
+                    if (plot.getFlag(HostileAttackFlag.class) || plot.getFlag(PveFlag.class) || plot
+                        .isAdded(plotPlayer.getUUID())) {
+                        return true;
+                    }
+                } else if (roadFlags && (area.getRoadFlag(HostileAttackFlag.class) || area
+                    .getFlag(PveFlag.class))) {
+                    return true;
+                }
+                if (!Permissions.hasPermission(plotPlayer, "plots.admin.pve." + stub)) {
+                    MainUtil.sendMessage(plotPlayer, Captions.NO_PERMISSION_EVENT,
+                        "plots.admin.pve." + stub);
+                    if (plot != null) {
+                        plot.debug(player.getName() + " could not attack " + entityType
+                            + " because pve = false OR hostile-attack = false");
+                    }
+                    return false;
+                }
+            } else if (EntityCategories.TAMEABLE.contains(entityType)) { // victim is tameable
+                if (isPlot) {
+                    if (plot.getFlag(TamedAttackFlag.class) || plot.getFlag(PveFlag.class) || plot
+                        .isAdded(plotPlayer.getUUID())) {
+                        return true;
+                    }
+                } else if (roadFlags && (area.getRoadFlag(TamedAttackFlag.class) || area
+                    .getFlag(PveFlag.class))) {
+                    return true;
+                }
+                if (!Permissions.hasPermission(plotPlayer, "plots.admin.pve." + stub)) {
+                    MainUtil.sendMessage(plotPlayer, Captions.NO_PERMISSION_EVENT,
+                        "plots.admin.pve." + stub);
+                    if (plot != null) {
+                        plot.debug(player.getName() + " could not attack " + entityType
+                            + " because pve = false OR tamned-attack = false");
+                    }
+                    return false;
+                }
+            } else if (EntityCategories.PLAYER.contains(entityType)) {
+                if (isPlot) {
+                    if (!plot.getFlag(PvpFlag.class) && !Permissions
+                        .hasPermission(plotPlayer, "plots.admin.pvp." + stub)) {
+                        MainUtil.sendMessage(plotPlayer, Captions.NO_PERMISSION_EVENT,
+                            "plots.admin.pvp." + stub);
+                        plot.debug(player.getName() + " could not attack " + entityType
+                            + " because pve = false");
+                        return false;
+                    } else {
+                        return true;
+                    }
+                } else if (roadFlags && area.getRoadFlag(PvpFlag.class)) {
+                    return true;
+                }
+                if (!Permissions.hasPermission(plotPlayer, "plots.admin.pvp." + stub)) {
+                    MainUtil.sendMessage(plotPlayer, Captions.NO_PERMISSION_EVENT,
+                        "plots.admin.pvp." + stub);
+                    return false;
+                }
+            } else if (EntityCategories.ANIMAL.contains(entityType)) { // victim is animal
+                if (isPlot) {
+                    if (plot.getFlag(AnimalAttackFlag.class) || plot.getFlag(PveFlag.class) || plot
+                        .isAdded(plotPlayer.getUUID())) {
+                        plot.debug(player.getName() + " could not attack " + entityType
+                            + " because pve = false OR animal-attack = false");
+                        return true;
+                    }
+                } else if (roadFlags && (area.getRoadFlag(AnimalAttackFlag.class) || area
+                    .getFlag(PveFlag.class))) {
+                    return true;
+                }
+                if (!Permissions.hasPermission(plotPlayer, "plots.admin.pve." + stub)) {
+                    MainUtil.sendMessage(plotPlayer, Captions.NO_PERMISSION_EVENT,
+                        "plots.admin.pve." + stub);
+                    return false;
+                }
+            } else if (EntityCategories.VEHICLE
+                .contains(entityType)) { // Vehicles are managed in vehicle destroy event
+                return true;
+            } else { // victim is something else
+                if (isPlot) {
+                    if (plot.getFlag(PveFlag.class) || plot.isAdded(plotPlayer.getUUID())) {
+                        return true;
+                    }
+                } else if (roadFlags && area.getRoadFlag(PveFlag.class)) {
+                    return true;
+                }
+                if (!Permissions.hasPermission(plotPlayer, "plots.admin.pve." + stub)) {
+                    MainUtil.sendMessage(plotPlayer, Captions.NO_PERMISSION_EVENT,
+                        "plots.admin.pve." + stub);
+                    if (plot != null) {
+                        plot.debug(player.getName() + " could not attack " + entityType
+                            + " because pve = false");
+                    }
+                    return false;
+                }
+            }
+            return true;
+        } else if (dplot != null && (!dplot.equals(vplot) || Objects
+            .equals(dplot.getOwnerAbs(), vplot.getOwnerAbs()))) {
+            return vplot != null && vplot.getFlag(PveFlag.class);
+        }
+        //disable the firework damage. too much of a headache to support at the moment.
+        if (vplot != null) {
+            if (EntityDamageEvent.DamageCause.ENTITY_EXPLOSION == cause
+                && damager.getType() == EntityType.FIREWORK) {
+                return false;
+            }
+        }
+        if (vplot == null && roadFlags && area.getRoadFlag(PveFlag.class)) {
+            return true;
+        }
+        return ((vplot != null && vplot.getFlag(PveFlag.class)) || !(damager instanceof Arrow
+            && !(victim instanceof Creature)));
+    }
+
+    public static boolean checkEntity(Entity entity, Plot plot) {
+        if (plot == null || !plot.hasOwner() || plot.getFlags().isEmpty() && plot.getArea()
+            .getFlagContainer().getFlagMap().isEmpty()) {
+            return false;
+        }
+
+        final com.sk89q.worldedit.world.entity.EntityType entityType =
+            BukkitAdapter.adapt(entity.getType());
+
+        if (EntityCategories.PLAYER.contains(entityType)) {
+            return false;
+        }
+
+        if (EntityCategories.PROJECTILE.contains(entityType) || EntityCategories.OTHER
+            .contains(entityType) || EntityCategories.HANGING.contains(entityType)) {
+            return EntityUtil.checkEntity(plot, EntityCapFlag.ENTITY_CAP_UNLIMITED,
+                MiscCapFlag.MISC_CAP_UNLIMITED);
+        }
+
+        // Has to go go before vehicle as horses are both
+        // animals and vehicles
+        if (EntityCategories.ANIMAL.contains(entityType) || EntityCategories.VILLAGER
+            .contains(entityType) || EntityCategories.TAMEABLE.contains(entityType)) {
+            return EntityUtil
+                .checkEntity(plot, EntityCapFlag.ENTITY_CAP_UNLIMITED, MobCapFlag.MOB_CAP_UNLIMITED,
+                    AnimalCapFlag.ANIMAL_CAP_UNLIMITED);
+        }
+
+        if (EntityCategories.HOSTILE.contains(entityType)) {
+            return EntityUtil
+                .checkEntity(plot, EntityCapFlag.ENTITY_CAP_UNLIMITED, MobCapFlag.MOB_CAP_UNLIMITED,
+                    HostileCapFlag.HOSTILE_CAP_UNLIMITED);
+        }
+
+        if (EntityCategories.VEHICLE.contains(entityType)) {
+            return EntityUtil.checkEntity(plot, EntityCapFlag.ENTITY_CAP_UNLIMITED,
+                VehicleCapFlag.VEHICLE_CAP_UNLIMITED);
+        }
+
+        return EntityUtil.checkEntity(plot, EntityCapFlag.ENTITY_CAP_UNLIMITED);
+    }
+
+}

Bukkit/src/main/java/com/plotsquared/bukkit/util/BukkitInventoryUtil.java

@@ -0,0 +1,152 @@
+/*
+ *       _____  _       _    _____                                _
+ *      |  __ \| |     | |  / ____|                              | |
+ *      | |__) | | ___ | |_| (___   __ _ _   _  __ _ _ __ ___  __| |
+ *      |  ___/| |/ _ \| __|\___ \ / _` | | | |/ _` | '__/ _ \/ _` |
+ *      | |    | | (_) | |_ ____) | (_| | |_| | (_| | | |  __/ (_| |
+ *      |_|    |_|\___/ \__|_____/ \__, |\__,_|\__,_|_|  \___|\__,_|
+ *                                    | |
+ *                                    |_|
+ *            PlotSquared plot management system for Minecraft
+ *                  Copyright (C) 2021 IntellectualSites
+ *
+ *     This program is free software: you can redistribute it and/or modify
+ *     it under the terms of the GNU 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 General Public License for more details.
+ *
+ *     You should have received a copy of the GNU General Public License
+ *     along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package com.plotsquared.bukkit.util;
+
+import com.plotsquared.bukkit.player.BukkitPlayer;
+import com.plotsquared.core.player.PlotPlayer;
+import com.plotsquared.core.plot.PlotInventory;
+import com.plotsquared.core.plot.PlotItemStack;
+import com.plotsquared.core.util.InventoryUtil;
+import com.sk89q.worldedit.bukkit.BukkitAdapter;
+import org.bukkit.Bukkit;
+import org.bukkit.ChatColor;
+import org.bukkit.Material;
+import org.bukkit.event.inventory.InventoryType;
+import org.bukkit.inventory.Inventory;
+import org.bukkit.inventory.InventoryView;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.inventory.PlayerInventory;
+import org.bukkit.inventory.meta.ItemMeta;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.stream.IntStream;
+
+public class BukkitInventoryUtil extends InventoryUtil {
+
+    @Override public void open(PlotInventory inv) {
+        BukkitPlayer bp = (BukkitPlayer) inv.player;
+        Inventory inventory = Bukkit.createInventory(null, inv.size * 9,
+            ChatColor.translateAlternateColorCodes('&', inv.getTitle()));
+        PlotItemStack[] items = inv.getItems();
+        for (int i = 0; i < inv.size * 9; i++) {
+            PlotItemStack item = items[i];
+            if (item != null) {
+                inventory.setItem(i, getItem(item));
+            }
+        }
+        bp.player.openInventory(inventory);
+    }
+
+    @Override public void close(PlotInventory inv) {
+        if (!inv.isOpen()) {
+            return;
+        }
+        BukkitPlayer bp = (BukkitPlayer) inv.player;
+        bp.player.closeInventory();
+    }
+
+    @Override public void setItem(PlotInventory inv, int index, PlotItemStack item) {
+        BukkitPlayer bp = (BukkitPlayer) inv.player;
+        InventoryView opened = bp.player.getOpenInventory();
+        if (!inv.isOpen()) {
+            return;
+        }
+        opened.setItem(index, getItem(item));
+        bp.player.updateInventory();
+    }
+
+    private static ItemStack getItem(PlotItemStack item) {
+        if (item == null) {
+            return null;
+        }
+        ItemStack stack = new ItemStack(BukkitAdapter.adapt(item.getType()), item.amount);
+        ItemMeta meta = null;
+        if (item.name != null) {
+            meta = stack.getItemMeta();
+            meta.setDisplayName(ChatColor.translateAlternateColorCodes('&', item.name));
+        }
+        if (item.lore != null) {
+            if (meta == null) {
+                meta = stack.getItemMeta();
+            }
+            List<String> lore = new ArrayList<>();
+            for (String entry : item.lore) {
+                lore.add(ChatColor.translateAlternateColorCodes('&', entry));
+            }
+            meta.setLore(lore);
+        }
+        if (meta != null) {
+            stack.setItemMeta(meta);
+        }
+        return stack;
+    }
+
+    public PlotItemStack getItem(ItemStack item) {
+        if (item == null) {
+            return null;
+        }
+        // int id = item.getTypeId();
+        Material id = item.getType();
+        ItemMeta meta = item.getItemMeta();
+        int amount = item.getAmount();
+        String name = null;
+        String[] lore = null;
+        if (item.hasItemMeta()) {
+            assert meta != null;
+            if (meta.hasDisplayName()) {
+                name = meta.getDisplayName();
+            }
+            if (meta.hasLore()) {
+                List<String> itemLore = meta.getLore();
+                assert itemLore != null;
+                lore = itemLore.toArray(new String[0]);
+            }
+        }
+        return new PlotItemStack(id.name(), amount, name, lore);
+    }
+
+    @Override public PlotItemStack[] getItems(PlotPlayer player) {
+        BukkitPlayer bp = (BukkitPlayer) player;
+        PlayerInventory inv = bp.player.getInventory();
+        return IntStream.range(0, 36).mapToObj(i -> getItem(inv.getItem(i)))
+            .toArray(PlotItemStack[]::new);
+    }
+
+    @Override public boolean isOpen(PlotInventory plotInventory) {
+        if (!plotInventory.isOpen()) {
+            return false;
+        }
+        BukkitPlayer bp = (BukkitPlayer) plotInventory.player;
+        InventoryView opened = bp.player.getOpenInventory();
+        if (plotInventory.isOpen()) {
+            if (opened.getType() == InventoryType.CRAFTING) {
+                opened.getTitle();
+            }
+        }
+        return false;
+    }
+}

Bukkit/src/main/java/com/plotsquared/bukkit/util/BukkitPermHandler.java

@@ -0,0 +1,59 @@
+/*
+ *       _____  _       _    _____                                _
+ *      |  __ \| |     | |  / ____|                              | |
+ *      | |__) | | ___ | |_| (___   __ _ _   _  __ _ _ __ ___  __| |
+ *      |  ___/| |/ _ \| __|\___ \ / _` | | | |/ _` | '__/ _ \/ _` |
+ *      | |    | | (_) | |_ ____) | (_| | |_| | (_| | | |  __/ (_| |
+ *      |_|    |_|\___/ \__|_____/ \__, |\__,_|\__,_|_|  \___|\__,_|
+ *                                    | |
+ *                                    |_|
+ *            PlotSquared plot management system for Minecraft
+ *                  Copyright (C) 2021 IntellectualSites
+ *
+ *     This program is free software: you can redistribute it and/or modify
+ *     it under the terms of the GNU 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 General Public License for more details.
+ *
+ *     You should have received a copy of the GNU General Public License
+ *     along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package com.plotsquared.bukkit.util;
+
+import com.plotsquared.core.util.PermHandler;
+import net.milkbowl.vault.permission.Permission;
+import org.bukkit.Bukkit;
+import org.bukkit.plugin.RegisteredServiceProvider;
+
+public class BukkitPermHandler extends PermHandler {
+
+    private Permission perms;
+
+    @Override
+    public boolean init() {
+        if (this.perms == null) {
+            setupPermissions();
+        }
+        return this.perms != null;
+    }
+
+    private void setupPermissions() {
+        if (Bukkit.getServer().getPluginManager().getPlugin("Vault") == null) {
+            return;
+        }
+        RegisteredServiceProvider<Permission> permissionProvider =
+            Bukkit.getServer().getServicesManager().getRegistration(Permission.class);
+        if (permissionProvider != null) {
+            this.perms = permissionProvider.getProvider();
+        }
+    }
+
+    @Override public boolean hasPermission(String world, String player, String perm) {
+        return this.perms.playerHas(world, Bukkit.getOfflinePlayer(player), perm);
+    }
+}

Bukkit/src/main/java/com/plotsquared/bukkit/util/BukkitRegionManager.java

@@ -0,0 +1,497 @@
+/*
+ *       _____  _       _    _____                                _
+ *      |  __ \| |     | |  / ____|                              | |
+ *      | |__) | | ___ | |_| (___   __ _ _   _  __ _ _ __ ___  __| |
+ *      |  ___/| |/ _ \| __|\___ \ / _` | | | |/ _` | '__/ _ \/ _` |
+ *      | |    | | (_) | |_ ____) | (_| | |_| | (_| | | |  __/ (_| |
+ *      |_|    |_|\___/ \__|_____/ \__, |\__,_|\__,_|_|  \___|\__,_|
+ *                                    | |
+ *                                    |_|
+ *            PlotSquared plot management system for Minecraft
+ *                  Copyright (C) 2021 IntellectualSites
+ *
+ *     This program is free software: you can redistribute it and/or modify
+ *     it under the terms of the GNU 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 General Public License for more details.
+ *
+ *     You should have received a copy of the GNU General Public License
+ *     along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package com.plotsquared.bukkit.util;
+
+import com.plotsquared.bukkit.BukkitMain;
+import com.plotsquared.core.PlotSquared;
+import com.plotsquared.core.generator.AugmentedUtils;
+import com.plotsquared.core.location.Location;
+import com.plotsquared.core.location.PlotLoc;
+import com.plotsquared.core.plot.Plot;
+import com.plotsquared.core.plot.PlotArea;
+import com.plotsquared.core.plot.PlotManager;
+import com.plotsquared.core.queue.GlobalBlockQueue;
+import com.plotsquared.core.queue.LocalBlockQueue;
+import com.plotsquared.core.queue.ScopedLocalBlockQueue;
+import com.plotsquared.core.util.ChunkManager;
+import com.plotsquared.core.util.MainUtil;
+import com.plotsquared.core.util.RegionManager;
+import com.plotsquared.core.util.RegionUtil;
+import com.plotsquared.core.util.entity.EntityCategories;
+import com.plotsquared.core.util.task.RunnableVal;
+import com.plotsquared.core.util.task.TaskManager;
+import com.sk89q.worldedit.bukkit.BukkitAdapter;
+import com.sk89q.worldedit.bukkit.BukkitWorld;
+import com.sk89q.worldedit.math.BlockVector2;
+import com.sk89q.worldedit.regions.CuboidRegion;
+import com.sk89q.worldedit.world.biome.BiomeType;
+import com.sk89q.worldedit.world.block.BaseBlock;
+import com.sk89q.worldedit.world.block.BlockTypes;
+import io.papermc.lib.PaperLib;
+import org.bukkit.Bukkit;
+import org.bukkit.Chunk;
+import org.bukkit.World;
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.Player;
+
+import java.util.ArrayDeque;
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map.Entry;
+import java.util.Objects;
+import java.util.Set;
+import java.util.concurrent.Semaphore;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+import static com.plotsquared.core.util.entity.EntityCategories.CAP_ANIMAL;
+import static com.plotsquared.core.util.entity.EntityCategories.CAP_ENTITY;
+import static com.plotsquared.core.util.entity.EntityCategories.CAP_MISC;
+import static com.plotsquared.core.util.entity.EntityCategories.CAP_MOB;
+import static com.plotsquared.core.util.entity.EntityCategories.CAP_MONSTER;
+import static com.plotsquared.core.util.entity.EntityCategories.CAP_VEHICLE;
+
+public class BukkitRegionManager extends RegionManager {
+
+    public static boolean isIn(CuboidRegion region, int x, int z) {
+        return x >= region.getMinimumPoint().getX() && x <= region.getMaximumPoint().getX()
+            && z >= region.getMinimumPoint().getZ() && z <= region.getMaximumPoint().getZ();
+    }
+
+    @Override public Set<BlockVector2> getChunkChunks(String world) {
+        Set<BlockVector2> chunks = super.getChunkChunks(world);
+        if (Bukkit.isPrimaryThread()) {
+            for (Chunk chunk : Objects.requireNonNull(Bukkit.getWorld(world)).getLoadedChunks()) {
+                BlockVector2 loc = BlockVector2.at(chunk.getX() >> 5, chunk.getZ() >> 5);
+                chunks.add(loc);
+            }
+        } else {
+            final Semaphore semaphore = new Semaphore(1);
+            try {
+                PlotSquared.debug("Attempting to make an asynchronous call to getLoadedChunks."
+                    + " Will halt the calling thread until completed.");
+                semaphore.acquire();
+                Bukkit.getScheduler().runTask(BukkitMain.getPlugin(BukkitMain.class), () -> {
+                    for (Chunk chunk : Objects.requireNonNull(Bukkit.getWorld(world))
+                        .getLoadedChunks()) {
+                        BlockVector2 loc = BlockVector2.at(chunk.getX() >> 5, chunk.getZ() >> 5);
+                        chunks.add(loc);
+                    }
+                    semaphore.release();
+                });
+                semaphore.acquireUninterruptibly();
+            } catch (final Exception e) {
+                e.printStackTrace();
+            }
+        }
+        return chunks;
+    }
+
+    @Override public boolean handleClear(Plot plot, Runnable whenDone, PlotManager manager) {
+        return false;
+    }
+
+    @Override public int[] countEntities(Plot plot) {
+        int[] existing = (int[]) plot.getMeta("EntityCount");
+        if (existing != null && (System.currentTimeMillis() - (long) plot.getMeta("EntityCountTime")
+            < 1000)) {
+            return existing;
+        }
+        PlotArea area = plot.getArea();
+        World world = BukkitUtil.getWorld(area.getWorldName());
+
+        Location bot = plot.getBottomAbs();
+        Location top = plot.getTopAbs();
+        int bx = bot.getX() >> 4;
+        int bz = bot.getZ() >> 4;
+
+        int tx = top.getX() >> 4;
+        int tz = top.getZ() >> 4;
+
+        int size = tx - bx << 4;
+
+        Set<Chunk> chunks = new HashSet<>();
+        for (int X = bx; X <= tx; X++) {
+            for (int Z = bz; Z <= tz; Z++) {
+                if (world.isChunkLoaded(X, Z)) {
+                    chunks.add(world.getChunkAt(X, Z));
+                }
+            }
+        }
+
+        boolean doWhole = false;
+        List<Entity> entities = null;
+        if (size > 200 && chunks.size() > 200) {
+            entities = world.getEntities();
+            if (entities.size() < 16 + size / 8) {
+                doWhole = true;
+            }
+        }
+
+        int[] count = new int[6];
+        if (doWhole) {
+            for (Entity entity : entities) {
+                org.bukkit.Location location = entity.getLocation();
+                PaperLib.getChunkAtAsync(location).thenAccept(chunk -> {
+                    if (chunks.contains(chunk)) {
+                        int X = chunk.getX();
+                        int Z = chunk.getZ();
+                        if (X > bx && X < tx && Z > bz && Z < tz) {
+                            count(count, entity);
+                        } else {
+                            Plot other = area.getPlot(BukkitUtil.getLocation(location));
+                            if (plot.equals(other)) {
+                                count(count, entity);
+                            }
+                        }
+                    }
+                });
+            }
+        } else {
+            for (Chunk chunk : chunks) {
+                int X = chunk.getX();
+                int Z = chunk.getZ();
+                Entity[] entities1 = chunk.getEntities();
+                for (Entity entity : entities1) {
+                    if (X == bx || X == tx || Z == bz || Z == tz) {
+                        Plot other = area.getPlot(BukkitUtil.getLocation(entity));
+                        if (plot.equals(other)) {
+                            count(count, entity);
+                        }
+                    } else {
+                        count(count, entity);
+                    }
+                }
+            }
+        }
+        return count;
+    }
+
+    @Override
+    public boolean copyRegion(Location pos1, Location pos2, Location newPos,
+        final Runnable whenDone) {
+        final int relX = newPos.getX() - pos1.getX();
+        final int relZ = newPos.getZ() - pos1.getZ();
+
+        final CuboidRegion region =
+            RegionUtil.createRegion(pos1.getX(), pos2.getX(), pos1.getZ(), pos2.getZ());
+        final World oldWorld = Bukkit.getWorld(pos1.getWorld());
+        final BukkitWorld oldBukkitWorld = new BukkitWorld(oldWorld);
+        final World newWorld = Bukkit.getWorld(newPos.getWorld());
+        assert newWorld != null;
+        assert oldWorld != null;
+        final String newWorldName = newWorld.getName();
+        final ContentMap map = new ContentMap();
+        final LocalBlockQueue queue = GlobalBlockQueue.IMP.getNewQueue(newWorldName, false);
+        ChunkManager.chunkTask(pos1, pos2, new RunnableVal<int[]>() {
+            @Override public void run(int[] value) {
+                int bx = value[2];
+                int bz = value[3];
+                int tx = value[4];
+                int tz = value[5];
+                BlockVector2 loc = BlockVector2.at(value[0], value[1]);
+                int cxx = loc.getX() << 4;
+                int czz = loc.getZ() << 4;
+                PaperLib.getChunkAtAsync(oldWorld, loc.getX(), loc.getZ())
+                    .thenAccept(chunk1 -> map.saveEntitiesIn(chunk1, region)).thenRun(() -> {
+                    for (int x = bx & 15; x <= (tx & 15); x++) {
+                        for (int z = bz & 15; z <= (tz & 15); z++) {
+                            map.saveBlocks(oldBukkitWorld, 256, cxx + x, czz + z, relX, relZ);
+                        }
+                    }
+                });
+            }
+        }, () -> {
+            for (Entry<PlotLoc, BaseBlock[]> entry : map.allBlocks.entrySet()) {
+                PlotLoc loc = entry.getKey();
+                BaseBlock[] blocks = entry.getValue();
+                for (int y = 0; y < blocks.length; y++) {
+                    if (blocks[y] != null) {
+                        BaseBlock block = blocks[y];
+                        queue.setBlock(loc.getX(), y, loc.getZ(), block);
+                    }
+                }
+            }
+            queue.enqueue();
+            GlobalBlockQueue.IMP.addEmptyTask(() -> {
+                //map.restoreBlocks(newWorld, 0, 0);
+                map.restoreEntities(newWorld, relX, relZ);
+                TaskManager.runTask(whenDone);
+            });
+        }, 5);
+        return true;
+    }
+
+    @Override
+    public boolean regenerateRegion(final Location pos1, final Location pos2,
+        final boolean ignoreAugment, final Runnable whenDone) {
+        final String world = pos1.getWorld();
+
+        final int p1x = pos1.getX();
+        final int p1z = pos1.getZ();
+        final int p2x = pos2.getX();
+        final int p2z = pos2.getZ();
+        final int bcx = p1x >> 4;
+        final int bcz = p1z >> 4;
+        final int tcx = p2x >> 4;
+        final int tcz = p2z >> 4;
+
+        final List<BlockVector2> chunks = new ArrayList<>();
+
+        for (int x = bcx; x <= tcx; x++) {
+            for (int z = bcz; z <= tcz; z++) {
+                chunks.add(BlockVector2.at(x, z));
+            }
+        }
+        final World worldObj = Bukkit.getWorld(world);
+        checkNotNull(worldObj, "Critical error during regeneration.");
+        final BukkitWorld bukkitWorldObj = new BukkitWorld(worldObj);
+        TaskManager.runTask(new Runnable() {
+            @Override public void run() {
+                long start = System.currentTimeMillis();
+                while (!chunks.isEmpty() && System.currentTimeMillis() - start < 5) {
+                    final BlockVector2 chunk = chunks.remove(0);
+                    int x = chunk.getX();
+                    int z = chunk.getZ();
+                    int xxb = x << 4;
+                    int zzb = z << 4;
+                    int xxt = xxb + 15;
+                    int zzt = zzb + 15;
+                    PaperLib.getChunkAtAsync(worldObj, x, z, false).thenAccept(chunkObj -> {
+                        if (chunkObj == null) {
+                            return;
+                        }
+                        final LocalBlockQueue queue =
+                            GlobalBlockQueue.IMP.getNewQueue(world, false);
+                        if (xxb >= p1x && xxt <= p2x && zzb >= p1z && zzt <= p2z) {
+                            AugmentedUtils.bypass(ignoreAugment,
+                                () -> queue.regenChunkSafe(chunk.getX(), chunk.getZ()));
+                            return;
+                        }
+                        boolean checkX1 = false;
+
+                        int xxb2;
+
+                        if (x == bcx) {
+                            xxb2 = p1x - 1;
+                            checkX1 = true;
+                        } else {
+                            xxb2 = xxb;
+                        }
+                        boolean checkX2 = false;
+                        int xxt2;
+                        if (x == tcx) {
+                            xxt2 = p2x + 1;
+                            checkX2 = true;
+                        } else {
+                            xxt2 = xxt;
+                        }
+                        boolean checkZ1 = false;
+                        int zzb2;
+                        if (z == bcz) {
+                            zzb2 = p1z - 1;
+                            checkZ1 = true;
+                        } else {
+                            zzb2 = zzb;
+                        }
+                        boolean checkZ2 = false;
+                        int zzt2;
+                        if (z == tcz) {
+                            zzt2 = p2z + 1;
+                            checkZ2 = true;
+                        } else {
+                            zzt2 = zzt;
+                        }
+                        final ContentMap map = new ContentMap();
+                        if (checkX1) {
+                            map.saveRegion(bukkitWorldObj, xxb, xxb2, zzb2, zzt2); //
+                        }
+                        if (checkX2) {
+                            map.saveRegion(bukkitWorldObj, xxt2, xxt, zzb2, zzt2); //
+                        }
+                        if (checkZ1) {
+                            map.saveRegion(bukkitWorldObj, xxb2, xxt2, zzb, zzb2); //
+                        }
+                        if (checkZ2) {
+                            map.saveRegion(bukkitWorldObj, xxb2, xxt2, zzt2, zzt); //
+                        }
+                        if (checkX1 && checkZ1) {
+                            map.saveRegion(bukkitWorldObj, xxb, xxb2, zzb, zzb2); //
+                        }
+                        if (checkX2 && checkZ1) {
+                            map.saveRegion(bukkitWorldObj, xxt2, xxt, zzb, zzb2); // ?
+                        }
+                        if (checkX1 && checkZ2) {
+                            map.saveRegion(bukkitWorldObj, xxb, xxb2, zzt2, zzt); // ?
+                        }
+                        if (checkX2 && checkZ2) {
+                            map.saveRegion(bukkitWorldObj, xxt2, xxt, zzt2, zzt); //
+                        }
+                        CuboidRegion currentPlotClear = RegionUtil
+                            .createRegion(pos1.getX(), pos2.getX(), pos1.getZ(), pos2.getZ());
+                        map.saveEntitiesOut(chunkObj, currentPlotClear);
+                        AugmentedUtils.bypass(ignoreAugment, () -> ChunkManager
+                            .setChunkInPlotArea(null, new RunnableVal<ScopedLocalBlockQueue>() {
+                                @Override public void run(ScopedLocalBlockQueue value) {
+                                    Location min = value.getMin();
+                                    int bx = min.getX();
+                                    int bz = min.getZ();
+                                    for (int x1 = 0; x1 < 16; x1++) {
+                                        for (int z1 = 0; z1 < 16; z1++) {
+                                            PlotLoc plotLoc = new PlotLoc(bx + x1, bz + z1);
+                                            BaseBlock[] ids = map.allBlocks.get(plotLoc);
+                                            if (ids != null) {
+                                                for (int y = 0;
+                                                     y < Math.min(128, ids.length); y++) {
+                                                    BaseBlock id = ids[y];
+                                                    if (id != null) {
+                                                        value.setBlock(x1, y, z1, id);
+                                                    } else {
+                                                        value.setBlock(x1, y, z1,
+                                                            BlockTypes.AIR.getDefaultState());
+                                                    }
+                                                }
+                                                for (int y = Math.min(128, ids.length);
+                                                     y < ids.length; y++) {
+                                                    BaseBlock id = ids[y];
+                                                    if (id != null) {
+                                                        value.setBlock(x1, y, z1, id);
+                                                    }
+                                                }
+                                            }
+                                        }
+                                    }
+                                }
+                            }, world, chunk));
+                        //map.restoreBlocks(worldObj, 0, 0);
+                        map.restoreEntities(worldObj, 0, 0);
+                    });
+                }
+                if (!chunks.isEmpty()) {
+                    TaskManager.runTaskLater(this, 1);
+                } else {
+                    TaskManager.runTaskLater(whenDone, 1);
+                }
+            }
+        });
+        return true;
+    }
+
+    @Override public void clearAllEntities(Location pos1, Location pos2) {
+        String world = pos1.getWorld();
+        List<Entity> entities = BukkitUtil.getEntities(world);
+        int bx = pos1.getX();
+        int bz = pos1.getZ();
+        int tx = pos2.getX();
+        int tz = pos2.getZ();
+        for (Entity entity : entities) {
+            if (!(entity instanceof Player)) {
+                org.bukkit.Location location = entity.getLocation();
+                if (location.getX() >= bx && location.getX() <= tx && location.getZ() >= bz
+                    && location.getZ() <= tz) {
+                    if (entity.hasMetadata("ps-tmp-teleport")) {
+                        continue;
+                    }
+                    entity.remove();
+                }
+            }
+        }
+    }
+
+    @Override
+    public void swap(Location bot1, Location top1, Location bot2, Location top2,
+        final Runnable whenDone) {
+        CuboidRegion region1 =
+            RegionUtil.createRegion(bot1.getX(), top1.getX(), bot1.getZ(), top1.getZ());
+        CuboidRegion region2 =
+            RegionUtil.createRegion(bot2.getX(), top2.getX(), bot2.getZ(), top2.getZ());
+        final World world1 = Bukkit.getWorld(bot1.getWorld());
+        final World world2 = Bukkit.getWorld(bot2.getWorld());
+        checkNotNull(world1, "Critical error during swap.");
+        checkNotNull(world2, "Critical error during swap.");
+        int relX = bot2.getX() - bot1.getX();
+        int relZ = bot2.getZ() - bot1.getZ();
+
+        final ArrayDeque<ContentMap> maps = new ArrayDeque<>();
+
+        for (int x = bot1.getX() >> 4; x <= top1.getX() >> 4; x++) {
+            for (int z = bot1.getZ() >> 4; z <= top1.getZ() >> 4; z++) {
+                Chunk chunk1 = world1.getChunkAt(x, z);
+                Chunk chunk2 = world2.getChunkAt(x + (relX >> 4), z + (relZ >> 4));
+                maps.add(
+                    BukkitChunkManager.swapChunk(world1, world2, chunk1, chunk2, region1, region2));
+            }
+        }
+        GlobalBlockQueue.IMP.addEmptyTask(() -> {
+            for (ContentMap map : maps) {
+                map.restoreEntities(world1, 0, 0);
+                TaskManager.runTaskLater(whenDone, 1);
+            }
+        });
+    }
+
+    @Override
+    public void setBiome(final CuboidRegion region, final int extendBiome, final BiomeType biome,
+        final String world, final Runnable whenDone) {
+        Location pos1 = new Location(world, region.getMinimumPoint().getX() - extendBiome,
+            region.getMinimumPoint().getY(), region.getMinimumPoint().getZ() - extendBiome);
+        Location pos2 = new Location(world, region.getMaximumPoint().getX() + extendBiome,
+            region.getMaximumPoint().getY(), region.getMaximumPoint().getZ() + extendBiome);
+        final LocalBlockQueue queue = GlobalBlockQueue.IMP.getNewQueue(world, false);
+
+        ChunkManager.chunkTask(pos1, pos2, new RunnableVal<int[]>() {
+            @Override public void run(int[] value) {
+                BlockVector2 loc = BlockVector2.at(value[0], value[1]);
+                ChunkManager.manager.loadChunk(world, loc, false).thenRun(() -> {
+                    MainUtil.setBiome(world, value[2], value[3], value[4], value[5], biome);
+                    queue.refreshChunk(value[0], value[1]);
+                });
+            }
+        }, whenDone, 5);
+    }
+
+    private void count(int[] count, Entity entity) {
+        final com.sk89q.worldedit.world.entity.EntityType entityType =
+            BukkitAdapter.adapt(entity.getType());
+
+        if (EntityCategories.PLAYER.contains(entityType)) {
+            return;
+        } else if (EntityCategories.PROJECTILE.contains(entityType) || EntityCategories.OTHER
+            .contains(entityType) || EntityCategories.HANGING.contains(entityType)) {
+            count[CAP_MISC]++;
+        } else if (EntityCategories.ANIMAL.contains(entityType) || EntityCategories.VILLAGER
+            .contains(entityType) || EntityCategories.TAMEABLE.contains(entityType)) {
+            count[CAP_MOB]++;
+            count[CAP_ANIMAL]++;
+        } else if (EntityCategories.VEHICLE.contains(entityType)) {
+            count[CAP_VEHICLE]++;
+        } else if (EntityCategories.HOSTILE.contains(entityType)) {
+            count[CAP_MOB]++;
+            count[CAP_MONSTER]++;
+        }
+        count[CAP_ENTITY]++;
+    }
+}

Bukkit/src/main/java/com/plotsquared/bukkit/util/BukkitSetupUtils.java

@@ -0,0 +1,346 @@
+/*
+ *       _____  _       _    _____                                _
+ *      |  __ \| |     | |  / ____|                              | |
+ *      | |__) | | ___ | |_| (___   __ _ _   _  __ _ _ __ ___  __| |
+ *      |  ___/| |/ _ \| __|\___ \ / _` | | | |/ _` | '__/ _ \/ _` |
+ *      | |    | | (_) | |_ ____) | (_| | |_| | (_| | | |  __/ (_| |
+ *      |_|    |_|\___/ \__|_____/ \__, |\__,_|\__,_|_|  \___|\__,_|
+ *                                    | |
+ *                                    |_|
+ *            PlotSquared plot management system for Minecraft
+ *                  Copyright (C) 2021 IntellectualSites
+ *
+ *     This program is free software: you can redistribute it and/or modify
+ *     it under the terms of the GNU 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 General Public License for more details.
+ *
+ *     You should have received a copy of the GNU General Public License
+ *     along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package com.plotsquared.bukkit.util;
+
+import com.plotsquared.bukkit.generator.BukkitPlotGenerator;
+import com.plotsquared.core.PlotSquared;
+import com.plotsquared.core.configuration.ConfigurationNode;
+import com.plotsquared.core.configuration.ConfigurationSection;
+import com.plotsquared.core.generator.GeneratorWrapper;
+import com.plotsquared.core.plot.PlotArea;
+import com.plotsquared.core.plot.PlotAreaType;
+import com.plotsquared.core.plot.SetupObject;
+import com.plotsquared.core.setup.PlotAreaBuilder;
+import com.plotsquared.core.util.SetupUtils;
+import io.papermc.lib.PaperLib;
+import org.bukkit.Bukkit;
+import org.bukkit.Chunk;
+import org.bukkit.World;
+import org.bukkit.entity.Player;
+import org.bukkit.generator.ChunkGenerator;
+import org.bukkit.plugin.Plugin;
+
+import java.io.IOException;
+import java.util.HashMap;
+import java.util.Map.Entry;
+import java.util.Objects;
+
+public class BukkitSetupUtils extends SetupUtils {
+
+    @Override public void updateGenerators() {
+        if (!SetupUtils.generators.isEmpty()) {
+            return;
+        }
+        String testWorld = "CheckingPlotSquaredGenerator";
+        for (Plugin plugin : Bukkit.getPluginManager().getPlugins()) {
+            try {
+                if (plugin.isEnabled()) {
+                    ChunkGenerator generator = plugin.getDefaultWorldGenerator(testWorld, "");
+                    if (generator != null) {
+                        PlotSquared.get().removePlotAreas(testWorld);
+                        String name = plugin.getDescription().getName();
+                        GeneratorWrapper<?> wrapped;
+                        if (generator instanceof GeneratorWrapper<?>) {
+                            wrapped = (GeneratorWrapper<?>) generator;
+                        } else {
+                            wrapped = new BukkitPlotGenerator(testWorld, generator);
+                        }
+                        SetupUtils.generators.put(name, wrapped);
+                    }
+                }
+            } catch (Throwable e) { // Recover from third party generator error
+                e.printStackTrace();
+            }
+        }
+    }
+
+    @Override public void unload(String worldName, boolean save) {
+        World world = Bukkit.getWorld(worldName);
+        if (world == null) {
+            return;
+        }
+        World dw = Bukkit.getWorlds().get(0);
+        for (Player player : world.getPlayers()) {
+            PaperLib.teleportAsync(player, dw.getSpawnLocation());
+        }
+        if (save) {
+            for (Chunk chunk : world.getLoadedChunks()) {
+                chunk.unload(true);
+            }
+        } else {
+            for (Chunk chunk : world.getLoadedChunks()) {
+                chunk.unload(false);
+            }
+        }
+        Bukkit.unloadWorld(world, false);
+    }
+
+    @Deprecated @Override public String setupWorld(SetupObject object) {
+        SetupUtils.manager.updateGenerators();
+        ConfigurationNode[] steps = object.step == null ? new ConfigurationNode[0] : object.step;
+        String world = object.world;
+        PlotAreaType type = object.type;
+        String worldPath = "worlds." + object.world;
+        switch (type) {
+            case PARTIAL: {
+                if (object.id != null) {
+                    if (!PlotSquared.get().worlds.contains(worldPath)) {
+                        PlotSquared.get().worlds.createSection(worldPath);
+                    }
+                    ConfigurationSection worldSection =
+                        PlotSquared.get().worlds.getConfigurationSection(worldPath);
+                    String areaName = object.id + "-" + object.min + "-" + object.max;
+                    String areaPath = "areas." + areaName;
+                    if (!worldSection.contains(areaPath)) {
+                        worldSection.createSection(areaPath);
+                    }
+                    ConfigurationSection areaSection =
+                        worldSection.getConfigurationSection(areaPath);
+                    HashMap<String, Object> options = new HashMap<>();
+                    for (ConfigurationNode step : steps) {
+                        options.put(step.getConstant(), step.getValue());
+                    }
+                    options.put("generator.type", object.type.toString());
+                    options.put("generator.terrain", object.terrain.toString());
+                    options.put("generator.plugin", object.plotManager);
+                    if (object.setupGenerator != null && !object.setupGenerator
+                        .equals(object.plotManager)) {
+                        options.put("generator.init", object.setupGenerator);
+                    }
+                    for (Entry<String, Object> entry : options.entrySet()) {
+                        String key = entry.getKey();
+                        Object value = entry.getValue();
+                        if (worldSection.contains(key)) {
+                            Object current = worldSection.get(key);
+                            if (!Objects.equals(value, current)) {
+                                areaSection.set(key, value);
+                            }
+                        } else {
+                            worldSection.set(key, value);
+                        }
+                    }
+                }
+                GeneratorWrapper<?> gen = SetupUtils.generators.get(object.setupGenerator);
+                if (gen != null && gen.isFull()) {
+                    object.setupGenerator = null;
+                }
+                break;
+            }
+            case AUGMENTED: {
+                if (!object.plotManager.endsWith(":single")) {
+                    if (!PlotSquared.get().worlds.contains(worldPath)) {
+                        PlotSquared.get().worlds.createSection(worldPath);
+                    }
+                    if (steps.length != 0) {
+                        ConfigurationSection worldSection =
+                            PlotSquared.get().worlds.getConfigurationSection(worldPath);
+                        for (ConfigurationNode step : steps) {
+                            worldSection.set(step.getConstant(), step.getValue());
+                        }
+                    }
+                    PlotSquared.get().worlds
+                        .set("worlds." + world + ".generator.type", object.type.toString());
+                    PlotSquared.get().worlds
+                        .set("worlds." + world + ".generator.terrain", object.terrain.toString());
+                    PlotSquared.get().worlds
+                        .set("worlds." + world + ".generator.plugin", object.plotManager);
+                    if (object.setupGenerator != null && !object.setupGenerator
+                        .equals(object.plotManager)) {
+                        PlotSquared.get().worlds
+                            .set("worlds." + world + ".generator.init", object.setupGenerator);
+                    }
+                }
+                GeneratorWrapper<?> gen = SetupUtils.generators.get(object.setupGenerator);
+                if (gen != null && gen.isFull()) {
+                    object.setupGenerator = null;
+                }
+                break;
+            }
+            case NORMAL: {
+                if (steps.length != 0) {
+                    if (!PlotSquared.get().worlds.contains(worldPath)) {
+                        PlotSquared.get().worlds.createSection(worldPath);
+                    }
+                    ConfigurationSection worldSection =
+                        PlotSquared.get().worlds.getConfigurationSection(worldPath);
+                    for (ConfigurationNode step : steps) {
+                        worldSection.set(step.getConstant(), step.getValue());
+                    }
+                }
+                break;
+            }
+        }
+
+        try {
+            PlotSquared.get().worlds.save(PlotSquared.get().worldsFile);
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+
+        Objects.requireNonNull(PlotSquared.imp()).getWorldManager()
+            .handleWorldCreation(object.world, object.setupGenerator);
+
+        if (Bukkit.getWorld(world) != null) {
+            return world;
+        }
+
+        return object.world;
+    }
+
+    @Override public String setupWorld(PlotAreaBuilder builder) {
+        SetupUtils.manager.updateGenerators();
+        ConfigurationNode[] steps = builder.settingsNodesWrapper() == null ?
+                new ConfigurationNode[0] : builder.settingsNodesWrapper().getSettingsNodes();
+        String world = builder.worldName();
+        PlotAreaType type = builder.plotAreaType();
+        String worldPath = "worlds." + builder.worldName();
+        switch (type) {
+            case PARTIAL: {
+                if (builder.areaName() != null) {
+                    if (!PlotSquared.get().worlds.contains(worldPath)) {
+                        PlotSquared.get().worlds.createSection(worldPath);
+                    }
+                    ConfigurationSection worldSection =
+                            PlotSquared.get().worlds.getConfigurationSection(worldPath);
+                    String areaName = builder.areaName() + "-" + builder.minimumId() + "-" + builder.maximumId();
+                    String areaPath = "areas." + areaName;
+                    if (!worldSection.contains(areaPath)) {
+                        worldSection.createSection(areaPath);
+                    }
+                    ConfigurationSection areaSection =
+                            worldSection.getConfigurationSection(areaPath);
+                    HashMap<String, Object> options = new HashMap<>();
+                    for (ConfigurationNode step : steps) {
+                        options.put(step.getConstant(), step.getValue());
+                    }
+                    options.put("generator.type", builder.plotAreaType().toString());
+                    options.put("generator.terrain", builder.terrainType().toString());
+                    options.put("generator.plugin", builder.plotManager());
+                    if (builder.generatorName() != null && !builder.generatorName()
+                            .equals(builder.plotManager())) {
+                        options.put("generator.init", builder.generatorName());
+                    }
+                    for (Entry<String, Object> entry : options.entrySet()) {
+                        String key = entry.getKey();
+                        Object value = entry.getValue();
+                        if (worldSection.contains(key)) {
+                            Object current = worldSection.get(key);
+                            if (!Objects.equals(value, current)) {
+                                areaSection.set(key, value);
+                            }
+                        } else {
+                            worldSection.set(key, value);
+                        }
+                    }
+                }
+                GeneratorWrapper<?> gen = SetupUtils.generators.get(builder.generatorName());
+                if (gen != null && gen.isFull()) {
+                    builder.generatorName(null);
+                }
+                break;
+            }
+            case AUGMENTED: {
+                if (!builder.plotManager().endsWith(":single")) {
+                    if (!PlotSquared.get().worlds.contains(worldPath)) {
+                        PlotSquared.get().worlds.createSection(worldPath);
+                    }
+                    if (steps.length != 0) {
+                        ConfigurationSection worldSection =
+                                PlotSquared.get().worlds.getConfigurationSection(worldPath);
+                        for (ConfigurationNode step : steps) {
+                            worldSection.set(step.getConstant(), step.getValue());
+                        }
+                    }
+                    PlotSquared.get().worlds
+                            .set("worlds." + world + ".generator.type", builder.plotAreaType().toString());
+                    PlotSquared.get().worlds
+                            .set("worlds." + world + ".generator.terrain", builder.terrainType().toString());
+                    PlotSquared.get().worlds
+                            .set("worlds." + world + ".generator.plugin", builder.plotManager());
+                    if (builder.generatorName() != null && !builder.generatorName()
+                            .equals(builder.plotManager())) {
+                        PlotSquared.get().worlds
+                                .set("worlds." + world + ".generator.init", builder.generatorName());
+                    }
+                }
+                GeneratorWrapper<?> gen = SetupUtils.generators.get(builder.generatorName());
+                if (gen != null && gen.isFull()) {
+                    builder.generatorName(null);
+                }
+                break;
+            }
+            case NORMAL: {
+                if (steps.length != 0) {
+                    if (!PlotSquared.get().worlds.contains(worldPath)) {
+                        PlotSquared.get().worlds.createSection(worldPath);
+                    }
+                    ConfigurationSection worldSection =
+                            PlotSquared.get().worlds.getConfigurationSection(worldPath);
+                    for (ConfigurationNode step : steps) {
+                        worldSection.set(step.getConstant(), step.getValue());
+                    }
+                }
+                break;
+            }
+        }
+
+        try {
+            PlotSquared.get().worlds.save(PlotSquared.get().worldsFile);
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+
+        Objects.requireNonNull(PlotSquared.imp()).getWorldManager()
+                .handleWorldCreation(builder.worldName(), builder.generatorName());
+
+        if (Bukkit.getWorld(world) != null) {
+            return world;
+        }
+
+        return builder.worldName();
+    }
+
+    @Override public String getGenerator(PlotArea plotArea) {
+        if (SetupUtils.generators.isEmpty()) {
+            updateGenerators();
+        }
+        World world = Bukkit.getWorld(plotArea.getWorldName());
+        if (world == null) {
+            return null;
+        }
+        ChunkGenerator generator = world.getGenerator();
+        if (!(generator instanceof BukkitPlotGenerator)) {
+            return null;
+        }
+        for (Entry<String, GeneratorWrapper<?>> entry : SetupUtils.generators.entrySet()) {
+            GeneratorWrapper<?> current = entry.getValue();
+            if (current.equals(generator)) {
+                return entry.getKey();
+            }
+        }
+        return null;
+    }
+}

Bukkit/src/main/java/com/plotsquared/bukkit/util/BukkitTaskManager.java

@@ -0,0 +1,79 @@
+/*
+ *       _____  _       _    _____                                _
+ *      |  __ \| |     | |  / ____|                              | |
+ *      | |__) | | ___ | |_| (___   __ _ _   _  __ _ _ __ ___  __| |
+ *      |  ___/| |/ _ \| __|\___ \ / _` | | | |/ _` | '__/ _ \/ _` |
+ *      | |    | | (_) | |_ ____) | (_| | |_| | (_| | | |  __/ (_| |
+ *      |_|    |_|\___/ \__|_____/ \__, |\__,_|\__,_|_|  \___|\__,_|
+ *                                    | |
+ *                                    |_|
+ *            PlotSquared plot management system for Minecraft
+ *                  Copyright (C) 2021 IntellectualSites
+ *
+ *     This program is free software: you can redistribute it and/or modify
+ *     it under the terms of the GNU 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 General Public License for more details.
+ *
+ *     You should have received a copy of the GNU General Public License
+ *     along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package com.plotsquared.bukkit.util;
+
+import com.plotsquared.bukkit.BukkitMain;
+import com.plotsquared.core.util.task.TaskManager;
+import org.bukkit.Bukkit;
+
+public class BukkitTaskManager extends TaskManager {
+
+    private final BukkitMain bukkitMain;
+
+    public BukkitTaskManager(BukkitMain bukkitMain) {
+        this.bukkitMain = bukkitMain;
+    }
+
+    @Override public int taskRepeat(Runnable runnable, int interval) {
+        return this.bukkitMain.getServer().getScheduler()
+            .scheduleSyncRepeatingTask(this.bukkitMain, runnable, interval, interval);
+    }
+
+    @SuppressWarnings("deprecation") @Override
+    public int taskRepeatAsync(Runnable runnable, int interval) {
+        return this.bukkitMain.getServer().getScheduler()
+            .scheduleAsyncRepeatingTask(this.bukkitMain, runnable, interval, interval);
+    }
+
+    @Override public void taskAsync(Runnable runnable) {
+        if (this.bukkitMain.isEnabled()) {
+            this.bukkitMain.getServer().getScheduler()
+                .runTaskAsynchronously(this.bukkitMain, runnable);
+        } else {
+            runnable.run();
+        }
+    }
+
+    @Override public void task(Runnable runnable) {
+        this.bukkitMain.getServer().getScheduler().runTask(this.bukkitMain, runnable).getTaskId();
+    }
+
+    @Override public void taskLater(Runnable runnable, int delay) {
+        this.bukkitMain.getServer().getScheduler().runTaskLater(this.bukkitMain, runnable, delay)
+            .getTaskId();
+    }
+
+    @Override public void taskLaterAsync(Runnable runnable, int delay) {
+        this.bukkitMain.getServer().getScheduler()
+            .runTaskLaterAsynchronously(this.bukkitMain, runnable, delay);
+    }
+
+    @Override public void cancelTask(int task) {
+        if (task != -1) {
+            Bukkit.getScheduler().cancelTask(task);
+        }
+    }
+}

Bukkit/src/main/java/com/plotsquared/bukkit/util/BukkitUtil.java

@@ -0,0 +1,695 @@
+/*
+ *       _____  _       _    _____                                _
+ *      |  __ \| |     | |  / ____|                              | |
+ *      | |__) | | ___ | |_| (___   __ _ _   _  __ _ _ __ ___  __| |
+ *      |  ___/| |/ _ \| __|\___ \ / _` | | | |/ _` | '__/ _ \/ _` |
+ *      | |    | | (_) | |_ ____) | (_| | |_| | (_| | | |  __/ (_| |
+ *      |_|    |_|\___/ \__|_____/ \__, |\__,_|\__,_|_|  \___|\__,_|
+ *                                    | |
+ *                                    |_|
+ *            PlotSquared plot management system for Minecraft
+ *                  Copyright (C) 2021 IntellectualSites
+ *
+ *     This program is free software: you can redistribute it and/or modify
+ *     it under the terms of the GNU 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 General Public License for more details.
+ *
+ *     You should have received a copy of the GNU General Public License
+ *     along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package com.plotsquared.bukkit.util;
+
+import com.plotsquared.bukkit.BukkitMain;
+import com.plotsquared.bukkit.player.BukkitPlayer;
+import com.plotsquared.bukkit.player.BukkitPlayerManager;
+import com.plotsquared.core.PlotSquared;
+import com.plotsquared.core.configuration.Captions;
+import com.plotsquared.core.location.Location;
+import com.plotsquared.core.player.PlotPlayer;
+import com.plotsquared.core.plot.Plot;
+import com.plotsquared.core.util.BlockUtil;
+import com.plotsquared.core.util.MainUtil;
+import com.plotsquared.core.util.MathMan;
+import com.plotsquared.core.util.PlayerManager;
+import com.plotsquared.core.util.StringComparison;
+import com.plotsquared.core.util.WorldUtil;
+import com.plotsquared.core.util.task.RunnableVal;
+import com.plotsquared.core.util.task.TaskManager;
+import com.sk89q.worldedit.bukkit.BukkitAdapter;
+import com.sk89q.worldedit.bukkit.BukkitWorld;
+import com.sk89q.worldedit.math.BlockVector2;
+import com.sk89q.worldedit.regions.CuboidRegion;
+import com.sk89q.worldedit.world.biome.BiomeType;
+import com.sk89q.worldedit.world.block.BlockCategories;
+import com.sk89q.worldedit.world.block.BlockState;
+import com.sk89q.worldedit.world.block.BlockType;
+import com.sk89q.worldedit.world.block.BlockTypes;
+import io.papermc.lib.PaperLib;
+import lombok.NonNull;
+import org.bukkit.Bukkit;
+import org.bukkit.Chunk;
+import org.bukkit.Material;
+import org.bukkit.OfflinePlayer;
+import org.bukkit.World;
+import org.bukkit.block.Biome;
+import org.bukkit.block.Block;
+import org.bukkit.block.BlockFace;
+import org.bukkit.block.Sign;
+import org.bukkit.block.data.Directional;
+import org.bukkit.block.data.type.WallSign;
+import org.bukkit.entity.Ambient;
+import org.bukkit.entity.Animals;
+import org.bukkit.entity.AreaEffectCloud;
+import org.bukkit.entity.ArmorStand;
+import org.bukkit.entity.Boss;
+import org.bukkit.entity.EnderCrystal;
+import org.bukkit.entity.EnderSignal;
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.EntityType;
+import org.bukkit.entity.EvokerFangs;
+import org.bukkit.entity.ExperienceOrb;
+import org.bukkit.entity.Explosive;
+import org.bukkit.entity.FallingBlock;
+import org.bukkit.entity.Firework;
+import org.bukkit.entity.Ghast;
+import org.bukkit.entity.Hanging;
+import org.bukkit.entity.IronGolem;
+import org.bukkit.entity.Item;
+import org.bukkit.entity.LightningStrike;
+import org.bukkit.entity.Monster;
+import org.bukkit.entity.NPC;
+import org.bukkit.entity.Phantom;
+import org.bukkit.entity.Player;
+import org.bukkit.entity.Projectile;
+import org.bukkit.entity.Shulker;
+import org.bukkit.entity.Slime;
+import org.bukkit.entity.Snowman;
+import org.bukkit.entity.Tameable;
+import org.bukkit.entity.Vehicle;
+import org.bukkit.entity.WaterMob;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Objects;
+import java.util.Set;
+import java.util.UUID;
+import java.util.function.Consumer;
+import java.util.function.IntConsumer;
+import java.util.stream.Stream;
+
+@SuppressWarnings({"unused", "WeakerAccess"})
+public class BukkitUtil extends WorldUtil {
+
+    private static String lastString = null;
+    private static World lastWorld = null;
+
+    private static Player lastPlayer = null;
+    private static BukkitPlayer lastPlotPlayer = null;
+
+    public static void removePlayer(UUID uuid) {
+        lastPlayer = null;
+        lastPlotPlayer = null;
+        // Make sure that it's removed internally
+        PlotSquared.imp().getPlayerManager().removePlayer(uuid);
+    }
+
+    public static PlotPlayer<Player> getPlayer(@NonNull final OfflinePlayer op) {
+        if (op.isOnline()) {
+            return getPlayer(op.getPlayer());
+        }
+        final Player player = OfflinePlayerUtil.loadPlayer(op);
+        player.loadData();
+        return new BukkitPlayer(player, true);
+    }
+
+    /**
+     * Get a plot based on the location.
+     *
+     * @param location the location to check
+     * @return plot if found, otherwise it creates a temporary plot
+     * @see Plot
+     */
+    public static Plot getPlot(org.bukkit.Location location) {
+        if (location == null) {
+            return null;
+        }
+        return getLocation(location).getPlot();
+    }
+
+    /**
+     * Get a plot based on the player location.
+     *
+     * @param player the player to check
+     * @return plot if found, otherwise it creates a temporary plot
+     * @see #getPlot(org.bukkit.Location)
+     * @see Plot
+     */
+    public static Plot getPlot(Player player) {
+        return getPlot(player.getLocation());
+    }
+
+    /**
+     * Get the PlotPlayer for an offline player.
+     *
+     * <p>Note that this will work if the player is offline, however not all
+     * functionality will work.
+     *
+     * @param player the player to wrap
+     * @return a {@code PlotPlayer}
+     * @see PlotPlayer#wrap(Object)
+     */
+    public static PlotPlayer<?> wrapPlayer(OfflinePlayer player) {
+        return PlotPlayer.wrap(player);
+    }
+
+    /**
+     * Gets the PlotPlayer for a player. The PlotPlayer is usually cached and
+     * will provide useful functions relating to players.
+     *
+     * @param player the player to wrap
+     * @return a {@code PlotPlayer}
+     * @see PlotPlayer#wrap(Object)
+     */
+    public static PlotPlayer<?> wrapPlayer(Player player) {
+        return PlotPlayer.wrap(player);
+    }
+
+    /**
+     * Gets the PlotPlayer for a UUID. The PlotPlayer is usually cached and
+     * will provide useful functions relating to players.
+     *
+     * @param uuid the uuid to wrap
+     * @return a {@code PlotPlayer}
+     * @see PlotPlayer#wrap(Object)
+     */
+    @Override public PlotPlayer<?> wrapPlayer(UUID uuid) {
+        return PlotPlayer.wrap(Bukkit.getOfflinePlayer(uuid));
+    }
+
+    /**
+     * Gets the number of plots, which the player is able to build in.
+     *
+     * @param player player, for whom we're getting the plots
+     * @return the number of allowed plots
+     */
+    public static int getAllowedPlots(Player player) {
+        PlotPlayer<?> plotPlayer = PlotPlayer.wrap(player);
+        return plotPlayer.getAllowedPlots();
+    }
+
+    /**
+     * Check whether or not a player is in a plot.
+     *
+     * @param player who we're checking for
+     * @return true if the player is in a plot, false if not-
+     */
+    public static boolean isInPlot(Player player) {
+        return getPlot(player) != null;
+    }
+
+    /**
+     * Gets a collection containing the players plots.
+     *
+     * @param world  Specify the world we want to select the plots from
+     * @param player Player, for whom we're getting the plots
+     * @return a set containing the players plots
+     * @see Plot
+     */
+    public static Set<Plot> getPlayerPlots(String world, Player player) {
+        if (world == null) {
+            return new HashSet<>();
+        }
+        return BukkitPlayer.wrap(player).getPlots(world);
+    }
+
+    /**
+     * Send a message to a player. The message supports color codes.
+     *
+     * @param player the recipient of the message
+     * @param string the message
+     * @see MainUtil#sendMessage(PlotPlayer, String)
+     */
+    public static void sendMessage(Player player, String string) {
+        MainUtil.sendMessage(BukkitUtil.getPlayer(player), string);
+    }
+
+    /**
+     * Gets the player plot count.
+     *
+     * @param world  Specify the world we want to select the plots from
+     * @param player Player, for whom we're getting the plot count
+     * @return the number of plots the player has
+     */
+    public static int getPlayerPlotCount(String world, Player player) {
+        if (world == null) {
+            return 0;
+        }
+        return BukkitUtil.getPlayer(player).getPlotCount(world);
+    }
+
+    /**
+     * Send a message to a player.
+     *
+     * @param player  the recipient of the message
+     * @param caption the message
+     */
+    public static void sendMessage(Player player, Captions caption) {
+        MainUtil.sendMessage(BukkitUtil.getPlayer(player), caption);
+    }
+
+    public static BukkitPlayer getPlayer(@NonNull final Player player) {
+        if (player == lastPlayer) {
+            return lastPlotPlayer;
+        }
+        final PlayerManager<?, ?> playerManager = PlotSquared.imp().getPlayerManager();
+        return ((BukkitPlayerManager) playerManager).getPlayer(player);
+    }
+
+    public static Location getLocation(@NonNull final org.bukkit.Location location) {
+        return new Location(location.getWorld().getName(), MathMan.roundInt(location.getX()),
+            MathMan.roundInt(location.getY()), MathMan.roundInt(location.getZ()));
+    }
+
+    public static Location getLocationFull(@NonNull final org.bukkit.Location location) {
+        return new Location(location.getWorld().getName(), MathMan.roundInt(location.getX()),
+            MathMan.roundInt(location.getY()), MathMan.roundInt(location.getZ()), location.getYaw(),
+            location.getPitch());
+    }
+
+    public static org.bukkit.Location getLocation(@NonNull final Location location) {
+        return new org.bukkit.Location(getWorld(location.getWorld()), location.getX(),
+            location.getY(), location.getZ());
+    }
+
+    public static World getWorld(@NonNull final String string) {
+        return Bukkit.getWorld(string);
+    }
+
+    public static String getWorld(@NonNull final Entity entity) {
+        return entity.getWorld().getName();
+    }
+
+    public static List<Entity> getEntities(@NonNull final String worldName) {
+        World world = getWorld(worldName);
+        if (world != null) {
+            return world.getEntities();
+        } else {
+            return new ArrayList<>();
+        }
+    }
+
+    public static Location getLocation(@NonNull final Entity entity) {
+        final org.bukkit.Location location = entity.getLocation();
+        String world = location.getWorld().getName();
+        return new Location(world, location.getBlockX(), location.getBlockY(),
+            location.getBlockZ());
+    }
+
+    @NotNull public static Location getLocationFull(@NonNull final Entity entity) {
+        final org.bukkit.Location location = entity.getLocation();
+        return new Location(location.getWorld().getName(), MathMan.roundInt(location.getX()),
+            MathMan.roundInt(location.getY()), MathMan.roundInt(location.getZ()), location.getYaw(),
+            location.getPitch());
+    }
+
+    public static Material getMaterial(@NonNull final BlockState plotBlock) {
+        return BukkitAdapter.adapt(plotBlock.getBlockType());
+    }
+
+    @Override public boolean isBlockSame(BlockState block1, BlockState block2) {
+        if (block1.equals(block2)) {
+            return true;
+        }
+        Material mat1 = getMaterial(block1), mat2 = getMaterial(block2);
+        return mat1 == mat2;
+    }
+
+    @Override public boolean isWorld(@NonNull final String worldName) {
+        return getWorld(worldName) != null;
+    }
+
+    @Override public void getBiome(String world, int x, int z, final Consumer<BiomeType> result) {
+        ensureLoaded(world, x, z,
+            chunk -> result.accept(BukkitAdapter.adapt(getWorld(world).getBiome(x, z))));
+    }
+
+    @Override public BiomeType getBiomeSynchronous(String world, int x, int z) {
+        return BukkitAdapter.adapt(getWorld(world).getBiome(x, z));
+    }
+
+    @Override
+    public void getHighestBlock(@NonNull final String world, final int x, final int z,
+        final IntConsumer result) {
+        ensureLoaded(world, x, z, chunk -> {
+            final World bukkitWorld = getWorld(world);
+            // Skip top and bottom block
+            int air = 1;
+            for (int y = bukkitWorld.getMaxHeight() - 1; y >= 0; y--) {
+                Block block = bukkitWorld.getBlockAt(x, y, z);
+                Material type = block.getType();
+                if (type.isSolid()) {
+                    if (air > 1) {
+                        result.accept(y);
+                        return;
+                    }
+                    air = 0;
+                } else {
+                    if (block.isLiquid()) {
+                        result.accept(y);
+                        return;
+                    }
+                    air++;
+                }
+            }
+            result.accept(bukkitWorld.getMaxHeight() - 1);
+        });
+    }
+
+    @Override public int getHighestBlockSynchronous(String world, int x, int z) {
+        final World bukkitWorld = getWorld(world);
+        // Skip top and bottom block
+        int air = 1;
+        for (int y = bukkitWorld.getMaxHeight() - 1; y >= 0; y--) {
+            Block block = bukkitWorld.getBlockAt(x, y, z);
+            Material type = block.getType();
+            if (type.isSolid()) {
+                if (air > 1) {
+                    return y;
+                }
+                air = 0;
+            } else {
+                if (block.isLiquid()) {
+                    return y;
+                }
+                air++;
+            }
+        }
+        return bukkitWorld.getMaxHeight() - 1;
+    }
+
+    @Override
+    public void getSign(@NonNull final Location location, final Consumer<String[]> result) {
+        ensureLoaded(location, chunk -> {
+            final Block block = chunk.getWorld().getBlockAt(getLocation(location));
+            if (block.getState() instanceof Sign) {
+                Sign sign = (Sign) block.getState();
+                result.accept(sign.getLines());
+            }
+        });
+    }
+
+    @Override @Nullable public String[] getSignSynchronous(@NonNull final Location location) {
+        Block block = getWorld(location.getWorld())
+            .getBlockAt(location.getX(), location.getY(), location.getZ());
+        return TaskManager.IMP.sync(new RunnableVal<String[]>() {
+            @Override public void run(String[] value) {
+                if (block.getState() instanceof Sign) {
+                    Sign sign = (Sign) block.getState();
+                    this.value = sign.getLines();
+                }
+            }
+        });
+    }
+
+    @Override public Location getSpawn(@NonNull final String world) {
+        final org.bukkit.Location temp = getWorld(world).getSpawnLocation();
+        return new Location(world, temp.getBlockX(), temp.getBlockY(), temp.getBlockZ(),
+            temp.getYaw(), temp.getPitch());
+    }
+
+    @Override public void setSpawn(@NonNull final Location location) {
+        final World world = getWorld(location.getWorld());
+        if (world != null) {
+            world.setSpawnLocation(location.getX(), location.getY(), location.getZ());
+        }
+    }
+
+    @Override public void saveWorld(@NonNull final String worldName) {
+        final World world = getWorld(worldName);
+        if (world != null) {
+            world.save();
+        }
+    }
+
+    @Override @SuppressWarnings("deprecation")
+    public void setSign(@NonNull final String worldName, final int x, final int y, final int z,
+        @NonNull final String[] lines) {
+        ensureLoaded(worldName, x, z, chunk -> {
+            final World world = getWorld(worldName);
+            final Block block = world.getBlockAt(x, y, z);
+            //        block.setType(Material.AIR);
+            final Material type = block.getType();
+            if (type != Material.LEGACY_SIGN && type != Material.LEGACY_WALL_SIGN) {
+                BlockFace facing = BlockFace.EAST;
+                if (world.getBlockAt(x, y, z + 1).getType().isSolid()) {
+                    facing = BlockFace.NORTH;
+                } else if (world.getBlockAt(x + 1, y, z).getType().isSolid()) {
+                    facing = BlockFace.WEST;
+                } else if (world.getBlockAt(x, y, z - 1).getType().isSolid()) {
+                    facing = BlockFace.SOUTH;
+                }
+                if (PlotSquared.get().IMP.getServerVersion()[1] == 13) {
+                    block.setType(Material.valueOf("WALL_SIGN"), false);
+                } else {
+                    block.setType(Material.valueOf("OAK_WALL_SIGN"), false);
+                }
+                if (!(block.getBlockData() instanceof WallSign)) {
+                    PlotSquared.debug(block.getBlockData().getAsString());
+                    throw new RuntimeException("Something went wrong generating a sign");
+                }
+                final Directional sign = (Directional) block.getBlockData();
+                sign.setFacing(facing);
+                block.setBlockData(sign, false);
+            }
+            final org.bukkit.block.BlockState blockstate = block.getState();
+            if (blockstate instanceof Sign) {
+                final Sign sign = (Sign) blockstate;
+                for (int i = 0; i < lines.length; i++) {
+                    sign.setLine(i, lines[i]);
+                }
+                sign.update(true);
+            }
+        });
+    }
+
+    @Override public boolean isBlockSolid(@NonNull final BlockState block) {
+        return block.getBlockType().getMaterial().isSolid();
+    }
+
+    @Override public String getClosestMatchingName(@NonNull final BlockState block) {
+        try {
+            return getMaterial(block).name();
+        } catch (Exception ignored) {
+            return null;
+        }
+    }
+
+    @Override @Nullable
+    public StringComparison<BlockState>.ComparisonResult getClosestBlock(String name) {
+        BlockState state = BlockUtil.get(name);
+        return new StringComparison<BlockState>().new ComparisonResult(1, state);
+    }
+
+    @Override
+    public void setBiomes(@NonNull final String worldName, @NonNull final CuboidRegion region,
+        @NonNull final BiomeType biomeType) {
+        final World world = getWorld(worldName);
+        if (world == null) {
+            PlotSquared.log("An error occurred setting the biome because the world was null.");
+            return;
+        }
+        final Biome biome = BukkitAdapter.adapt(biomeType);
+        for (int x = region.getMinimumPoint().getX(); x <= region.getMaximumPoint().getX(); x++) {
+            for (int z = region.getMinimumPoint().getZ();
+                 z <= region.getMaximumPoint().getZ(); z++) {
+                if (world.getBiome(x, z) != biome) {
+                    world.setBiome(x, z, biome);
+                }
+            }
+        }
+    }
+
+    public com.sk89q.worldedit.world.World getWeWorld(String world) {
+        return new BukkitWorld(Bukkit.getWorld(world));
+    }
+
+    @Override
+    public void getBlock(@NonNull final Location location, final Consumer<BlockState> result) {
+        ensureLoaded(location, chunk -> {
+            final World world = getWorld(location.getWorld());
+            final Block block = world.getBlockAt(location.getX(), location.getY(), location.getZ());
+            result.accept(BukkitAdapter.asBlockType(block.getType()).getDefaultState());
+        });
+    }
+
+    @Override public BlockState getBlockSynchronous(@NonNull final Location location) {
+        final World world = getWorld(location.getWorld());
+        final Block block = world.getBlockAt(location.getX(), location.getY(), location.getZ());
+        return BukkitAdapter.asBlockType(block.getType()).getDefaultState();
+    }
+
+    @Override public String getMainWorld() {
+        return Bukkit.getWorlds().get(0).getName();
+    }
+
+    @Override public double getHealth(PlotPlayer player) {
+        return Bukkit.getPlayer(player.getUUID()).getHealth();
+    }
+
+    @Override public int getFoodLevel(PlotPlayer player) {
+        return Bukkit.getPlayer(player.getUUID()).getFoodLevel();
+    }
+
+    @Override public void setHealth(PlotPlayer player, double health) {
+        Bukkit.getPlayer(player.getUUID()).setHealth(health);
+    }
+
+    @Override public void setFoodLevel(PlotPlayer player, int foodLevel) {
+        Bukkit.getPlayer(player.getUUID()).setFoodLevel(foodLevel);
+    }
+
+    @Override
+    public Set<com.sk89q.worldedit.world.entity.EntityType> getTypesInCategory(
+        final String category) {
+        final Collection<Class<?>> allowedInterfaces = new HashSet<>();
+        switch (category) {
+            case "animal": {
+                allowedInterfaces.add(IronGolem.class);
+                allowedInterfaces.add(Snowman.class);
+                allowedInterfaces.add(Animals.class);
+                allowedInterfaces.add(WaterMob.class);
+                allowedInterfaces.add(Ambient.class);
+            }
+            break;
+            case "tameable": {
+                allowedInterfaces.add(Tameable.class);
+            }
+            break;
+            case "vehicle": {
+                allowedInterfaces.add(Vehicle.class);
+            }
+            break;
+            case "hostile": {
+                allowedInterfaces.add(Shulker.class);
+                allowedInterfaces.add(Monster.class);
+                allowedInterfaces.add(Boss.class);
+                allowedInterfaces.add(Slime.class);
+                allowedInterfaces.add(Ghast.class);
+                allowedInterfaces.add(Phantom.class);
+                allowedInterfaces.add(EnderCrystal.class);
+            }
+            break;
+            case "hanging": {
+                allowedInterfaces.add(Hanging.class);
+            }
+            break;
+            case "villager": {
+                allowedInterfaces.add(NPC.class);
+            }
+            break;
+            case "projectile": {
+                allowedInterfaces.add(Projectile.class);
+            }
+            break;
+            case "other": {
+                allowedInterfaces.add(ArmorStand.class);
+                allowedInterfaces.add(FallingBlock.class);
+                allowedInterfaces.add(Item.class);
+                allowedInterfaces.add(Explosive.class);
+                allowedInterfaces.add(AreaEffectCloud.class);
+                allowedInterfaces.add(EvokerFangs.class);
+                allowedInterfaces.add(LightningStrike.class);
+                allowedInterfaces.add(ExperienceOrb.class);
+                allowedInterfaces.add(EnderSignal.class);
+                allowedInterfaces.add(Firework.class);
+            }
+            break;
+            case "player": {
+                allowedInterfaces.add(Player.class);
+            }
+            break;
+            default: {
+                PlotSquared.log(Captions.PREFIX + "Unknown entity category requested: " + category);
+            }
+            break;
+        }
+        final Set<com.sk89q.worldedit.world.entity.EntityType> types = new HashSet<>();
+        outer:
+        for (final EntityType bukkitType : EntityType.values()) {
+            final Class<? extends Entity> entityClass = bukkitType.getEntityClass();
+            if (entityClass == null) {
+                continue;
+            }
+            for (final Class<?> allowedInterface : allowedInterfaces) {
+                if (allowedInterface.isAssignableFrom(entityClass)) {
+                    types.add(BukkitAdapter.adapt(bukkitType));
+                    continue outer;
+                }
+            }
+        }
+        return types;
+    }
+
+    private final Collection<BlockType> tileEntityTypes = new HashSet<>();
+    @Override public Collection<BlockType> getTileEntityTypes() {
+        if (this.tileEntityTypes.isEmpty()) {
+            // Categories
+            tileEntityTypes.addAll(BlockCategories.BANNERS.getAll());
+            tileEntityTypes.addAll(BlockCategories.SIGNS.getAll());
+            tileEntityTypes.addAll(BlockCategories.BEDS.getAll());
+            tileEntityTypes.addAll(BlockCategories.FLOWER_POTS.getAll());
+            // Individual Types
+            // Add these from strings
+            Stream.of("barrel", "beacon", "beehive", "bee_nest", "bell", "blast_furnace",
+                "brewing_stand", "campfire", "chest", "ender_chest", "trapped_chest",
+                "command_block", "end_gateway", "hopper", "jigsaw", "jubekox",
+                "lectern", "note_block", "black_shulker_box", "blue_shulker_box",
+                "brown_shulker_box", "cyan_shulker_box", "gray_shulker_box", "green_shulker_box",
+                "light_blue_shulker_box", "light_gray_shulker_box", "lime_shulker_box",
+                "magenta_shulker_box", "orange_shulker_box", "pink_shulker_box",
+                "purple_shulker_box", "red_shulker_box", "shulker_box", "white_shulker_box",
+                "yellow_shulker_box", "smoker", "structure_block", "structure_void")
+                .map(BlockTypes::get)
+                .filter(Objects::nonNull)
+                .forEach(tileEntityTypes::add);
+        }
+        return this.tileEntityTypes;
+    }
+
+    @Override
+    public int getTileEntityCount(String world, BlockVector2 chunk) {
+        return Bukkit.getWorld(world).getChunkAt(chunk.getBlockX(), chunk.getBlockZ())
+            .getTileEntities().length;
+    }
+
+    private static void ensureLoaded(final String world, final int x, final int z,
+        final Consumer<Chunk> chunkConsumer) {
+        PaperLib.getChunkAtAsync(getWorld(world), x >> 4, z >> 4, true)
+            .thenAccept(chunk -> ensureMainThread(chunkConsumer, chunk));
+    }
+
+    private static void ensureLoaded(final Location location, final Consumer<Chunk> chunkConsumer) {
+        PaperLib.getChunkAtAsync(getLocation(location), true)
+            .thenAccept(chunk -> ensureMainThread(chunkConsumer, chunk));
+    }
+
+    private static <T> void ensureMainThread(final Consumer<T> consumer, final T value) {
+        if (Bukkit.isPrimaryThread()) {
+            consumer.accept(value);
+        } else {
+            Bukkit.getScheduler()
+                .runTask(BukkitMain.getPlugin(BukkitMain.class), () -> consumer.accept(value));
+        }
+    }
+
+}

Bukkit/src/main/java/com/plotsquared/bukkit/util/ContentMap.java

@@ -0,0 +1,144 @@
+/*
+ *       _____  _       _    _____                                _
+ *      |  __ \| |     | |  / ____|                              | |
+ *      | |__) | | ___ | |_| (___   __ _ _   _  __ _ _ __ ___  __| |
+ *      |  ___/| |/ _ \| __|\___ \ / _` | | | |/ _` | '__/ _ \/ _` |
+ *      | |    | | (_) | |_ ____) | (_| | |_| | (_| | | |  __/ (_| |
+ *      |_|    |_|\___/ \__|_____/ \__, |\__,_|\__,_|_|  \___|\__,_|
+ *                                    | |
+ *                                    |_|
+ *            PlotSquared plot management system for Minecraft
+ *                  Copyright (C) 2021 IntellectualSites
+ *
+ *     This program is free software: you can redistribute it and/or modify
+ *     it under the terms of the GNU 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 General Public License for more details.
+ *
+ *     You should have received a copy of the GNU General Public License
+ *     along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package com.plotsquared.bukkit.util;
+
+import com.plotsquared.bukkit.entity.EntityWrapper;
+import com.plotsquared.bukkit.entity.ReplicatingEntityWrapper;
+import com.plotsquared.core.PlotSquared;
+import com.plotsquared.core.location.Location;
+import com.plotsquared.core.location.PlotLoc;
+import com.sk89q.worldedit.bukkit.BukkitWorld;
+import com.sk89q.worldedit.math.BlockVector3;
+import com.sk89q.worldedit.regions.CuboidRegion;
+import com.sk89q.worldedit.world.block.BaseBlock;
+import org.bukkit.Chunk;
+import org.bukkit.World;
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.Player;
+
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+
+public class ContentMap {
+
+    final Set<EntityWrapper> entities;
+    final Map<PlotLoc, BaseBlock[]> allBlocks;
+
+    ContentMap() {
+        this.entities = new HashSet<>();
+        this.allBlocks = new HashMap<>();
+    }
+
+    public void saveRegion(BukkitWorld world, int x1, int x2, int z1, int z2) {
+        if (z1 > z2) {
+            int tmp = z1;
+            z1 = z2;
+            z2 = tmp;
+        }
+        if (x1 > x2) {
+            int tmp = x1;
+            x1 = x2;
+            x2 = tmp;
+        }
+        for (int x = x1; x <= x2; x++) {
+            for (int z = z1; z <= z2; z++) {
+                saveBlocks(world, 256, x, z, 0, 0);
+            }
+        }
+    }
+
+    void saveEntitiesOut(Chunk chunk, CuboidRegion region) {
+        for (Entity entity : chunk.getEntities()) {
+            Location location = BukkitUtil.getLocation(entity);
+            int x = location.getX();
+            int z = location.getZ();
+            if (BukkitChunkManager.isIn(region, x, z)) {
+                continue;
+            }
+            if (entity.getVehicle() != null) {
+                continue;
+            }
+            EntityWrapper wrap = new ReplicatingEntityWrapper(entity, (short) 2);
+            wrap.saveEntity();
+            this.entities.add(wrap);
+        }
+    }
+
+    void saveEntitiesIn(Chunk chunk, CuboidRegion region) {
+        saveEntitiesIn(chunk, region, 0, 0, false);
+    }
+
+    void saveEntitiesIn(Chunk chunk, CuboidRegion region, int offsetX, int offsetZ,
+        boolean delete) {
+        for (Entity entity : chunk.getEntities()) {
+            Location location = BukkitUtil.getLocation(entity);
+            int x = location.getX();
+            int z = location.getZ();
+            if (!BukkitChunkManager.isIn(region, x, z)) {
+                continue;
+            }
+            if (entity.getVehicle() != null) {
+                continue;
+            }
+            EntityWrapper wrap = new ReplicatingEntityWrapper(entity, (short) 2);
+            wrap.x += offsetX;
+            wrap.z += offsetZ;
+            wrap.saveEntity();
+            this.entities.add(wrap);
+            if (delete) {
+                if (!(entity instanceof Player)) {
+                    entity.remove();
+                }
+            }
+        }
+    }
+
+    void restoreEntities(World world, int xOffset, int zOffset) {
+        for (EntityWrapper entity : this.entities) {
+            try {
+                entity.spawn(world, xOffset, zOffset);
+            } catch (Exception e) {
+                PlotSquared.debug("Failed to restore entity (e): " + e.toString());
+                e.printStackTrace();
+            }
+        }
+        this.entities.clear();
+    }
+
+    //todo optimize maxY
+    void saveBlocks(BukkitWorld world, int maxY, int x, int z, int offsetX, int offsetZ) {
+        maxY = Math.min(255, maxY);
+        BaseBlock[] ids = new BaseBlock[maxY + 1];
+        for (short y = 0; y <= maxY; y++) {
+            BaseBlock block = world.getFullBlock(BlockVector3.at(x, y, z));
+            ids[y] = block;
+        }
+        PlotLoc loc = new PlotLoc(x + offsetX, z + offsetZ);
+        this.allBlocks.put(loc, ids);
+    }
+}

Bukkit/src/main/java/com/plotsquared/bukkit/util/OfflinePlayerUtil.java

@@ -0,0 +1,157 @@
+/*
+ *       _____  _       _    _____                                _
+ *      |  __ \| |     | |  / ____|                              | |
+ *      | |__) | | ___ | |_| (___   __ _ _   _  __ _ _ __ ___  __| |
+ *      |  ___/| |/ _ \| __|\___ \ / _` | | | |/ _` | '__/ _ \/ _` |
+ *      | |    | | (_) | |_ ____) | (_| | |_| | (_| | | |  __/ (_| |
+ *      |_|    |_|\___/ \__|_____/ \__, |\__,_|\__,_|_|  \___|\__,_|
+ *                                    | |
+ *                                    |_|
+ *            PlotSquared plot management system for Minecraft
+ *                  Copyright (C) 2021 IntellectualSites
+ *
+ *     This program is free software: you can redistribute it and/or modify
+ *     it under the terms of the GNU 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 General Public License for more details.
+ *
+ *     You should have received a copy of the GNU General Public License
+ *     along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package com.plotsquared.bukkit.util;
+
+import org.bukkit.Bukkit;
+import org.bukkit.OfflinePlayer;
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.Player;
+
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Method;
+import java.util.UUID;
+
+import static com.plotsquared.core.util.ReflectionUtils.callConstructor;
+import static com.plotsquared.core.util.ReflectionUtils.callMethod;
+import static com.plotsquared.core.util.ReflectionUtils.getCbClass;
+import static com.plotsquared.core.util.ReflectionUtils.getField;
+import static com.plotsquared.core.util.ReflectionUtils.getNmsClass;
+import static com.plotsquared.core.util.ReflectionUtils.getUtilClass;
+import static com.plotsquared.core.util.ReflectionUtils.makeConstructor;
+import static com.plotsquared.core.util.ReflectionUtils.makeField;
+import static com.plotsquared.core.util.ReflectionUtils.makeMethod;
+
+public class OfflinePlayerUtil {
+
+    public static Player loadPlayer(OfflinePlayer player) {
+        if (player == null) {
+            return null;
+        }
+        if (player instanceof Player) {
+            return (Player) player;
+        }
+        return loadPlayer(player.getUniqueId(), player.getName());
+    }
+
+    private static Player loadPlayer(UUID id, String name) {
+        Object server = getMinecraftServer();
+        Object interactManager = newPlayerInteractManager();
+        Object worldServer = getWorldServer();
+        Object profile = newGameProfile(id, name);
+        Class<?> entityPlayerClass = getNmsClass("EntityPlayer");
+        Constructor entityPlayerConstructor =
+                makeConstructor(entityPlayerClass, getNmsClass("MinecraftServer"),
+                        getNmsClass("WorldServer"), getUtilClass("com.mojang.authlib.GameProfile"),
+                        getNmsClass("PlayerInteractManager"));
+        Object entityPlayer =
+                callConstructor(entityPlayerConstructor, server, worldServer, profile, interactManager);
+        return (Player) getBukkitEntity(entityPlayer);
+    }
+
+    private static Object newGameProfile(UUID id, String name) {
+        Class<?> gameProfileClass = getUtilClass("com.mojang.authlib.GameProfile");
+        if (gameProfileClass == null) { //Before uuids
+            return name;
+        }
+        Constructor gameProfileConstructor =
+            makeConstructor(gameProfileClass, UUID.class, String.class);
+        if (gameProfileConstructor == null) { //Version has string constructor
+            gameProfileConstructor = makeConstructor(gameProfileClass, String.class, String.class);
+            return callConstructor(gameProfileConstructor, id.toString(), name);
+        } else { //Version has uuid constructor
+            return callConstructor(gameProfileConstructor, id, name);
+        }
+    }
+
+    private static Object newPlayerInteractManager() {
+        Object worldServer = getWorldServer();
+        Class<?> playerInteractClass = getNmsClass("PlayerInteractManager");
+        Class<?> worldClass = getNmsClass("World");
+        Constructor<?> c = makeConstructor(playerInteractClass, worldClass);
+        if (c == null) {
+            c = makeConstructor(playerInteractClass, getNmsClass("WorldServer"));
+        }
+        return callConstructor(c, worldServer);
+    }
+
+    public static Object getWorldServer116() {
+        Object server = getMinecraftServer();
+        Class<?> minecraftServerClass = getNmsClass("MinecraftServer");
+        Class<?> genericResourceKey = getNmsClass("ResourceKey");
+        Class<?> minecraftKey = getNmsClass("MinecraftKey");
+        // MinecraftKey + MinecraftKey -> ResourceKey
+        Method constructResourceKey = makeMethod(genericResourceKey, "a", minecraftKey, minecraftKey);
+        // MinecraftKey(String)
+        Constructor<Object> minecraftKeyConstructor = makeConstructor(minecraftKey, String.class);
+        // minecraft:overworld
+        Object overworldKey = callConstructor(minecraftKeyConstructor, "overworld");
+        // minecraft:dimension
+        Object dimensionKey = callConstructor(minecraftKeyConstructor, "dimension");
+        // ResourceKey[minecraft:dimension / minecraft:overworld]
+        Object resourceKey = callMethod(constructResourceKey, null, dimensionKey, overworldKey);
+        Method getWorldServer =
+                makeMethod(minecraftServerClass, "getWorldServer", genericResourceKey);
+        return callMethod(getWorldServer, server, resourceKey);
+    }
+
+    public static Object getWorldServerNew() {
+        Object server = getMinecraftServer();
+        Class<?> minecraftServerClass = getNmsClass("MinecraftServer");
+        Class<?> dimensionManager = getNmsClass("DimensionManager");
+        Object overworld = getField(makeField(dimensionManager, "OVERWORLD"), null);
+        Method getWorldServer =
+            makeMethod(minecraftServerClass, "getWorldServer", dimensionManager);
+        return callMethod(getWorldServer, server, overworld);
+    }
+
+    private static Object getWorldServer() {
+        Object server = getMinecraftServer();
+        Class<?> minecraftServerClass = getNmsClass("MinecraftServer");
+        Method getWorldServer = makeMethod(minecraftServerClass, "getWorldServer", int.class);
+        Object o;
+        try {
+            o = callMethod(getWorldServer, server, 0);
+        } catch (final RuntimeException e) {
+            try {
+                o = getWorldServerNew();
+            } catch (final RuntimeException f) {
+                o = getWorldServer116();
+            }
+        }
+        return o;
+    }
+
+    //NMS Utils
+
+    private static Object getMinecraftServer() {
+        return callMethod(makeMethod(getCbClass("CraftServer"), "getServer"), Bukkit.getServer());
+    }
+
+    private static Entity getBukkitEntity(Object o) {
+        Method getBukkitEntity = makeMethod(o.getClass(), "getBukkitEntity");
+        return callMethod(getBukkitEntity, o);
+    }
+}

Bukkit/src/main/java/com/plotsquared/bukkit/util/SetGenCB.java

@@ -0,0 +1,77 @@
+/*
+ *       _____  _       _    _____                                _
+ *      |  __ \| |     | |  / ____|                              | |
+ *      | |__) | | ___ | |_| (___   __ _ _   _  __ _ _ __ ___  __| |
+ *      |  ___/| |/ _ \| __|\___ \ / _` | | | |/ _` | '__/ _ \/ _` |
+ *      | |    | | (_) | |_ ____) | (_| | |_| | (_| | | |  __/ (_| |
+ *      |_|    |_|\___/ \__|_____/ \__, |\__,_|\__,_|_|  \___|\__,_|
+ *                                    | |
+ *                                    |_|
+ *            PlotSquared plot management system for Minecraft
+ *                  Copyright (C) 2021 IntellectualSites
+ *
+ *     This program is free software: you can redistribute it and/or modify
+ *     it under the terms of the GNU 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 General Public License for more details.
+ *
+ *     You should have received a copy of the GNU General Public License
+ *     along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package com.plotsquared.bukkit.util;
+
+import com.plotsquared.bukkit.generator.BukkitAugmentedGenerator;
+import com.plotsquared.core.PlotSquared;
+import com.plotsquared.core.generator.GeneratorWrapper;
+import com.plotsquared.core.util.SetupUtils;
+import org.bukkit.World;
+import org.bukkit.generator.ChunkGenerator;
+
+import java.lang.reflect.Field;
+import java.util.ArrayList;
+
+public class SetGenCB {
+
+    public static void setGenerator(World world) throws Exception {
+        SetupUtils.manager.updateGenerators();
+        PlotSquared.get().removePlotAreas(world.getName());
+        ChunkGenerator gen = world.getGenerator();
+        if (gen == null) {
+            return;
+        }
+        String name = gen.getClass().getCanonicalName();
+        boolean set = false;
+        for (GeneratorWrapper<?> wrapper : SetupUtils.generators.values()) {
+            ChunkGenerator newGen = (ChunkGenerator) wrapper.getPlatformGenerator();
+            if (newGen == null) {
+                newGen = (ChunkGenerator) wrapper;
+            }
+            if (newGen.getClass().getCanonicalName().equals(name)) {
+                // set generator
+                Field generator = world.getClass().getDeclaredField("generator");
+                Field populators = world.getClass().getDeclaredField("populators");
+                generator.setAccessible(true);
+                populators.setAccessible(true);
+                // Set populators (just in case)
+                populators.set(world, new ArrayList<>());
+                // Set generator
+                generator.set(world, newGen);
+                populators.set(world, newGen.getDefaultPopulators(world));
+                // end
+                set = true;
+                break;
+            }
+        }
+        if (!set) {
+            world.getPopulators()
+                .removeIf(blockPopulator -> blockPopulator instanceof BukkitAugmentedGenerator);
+        }
+        PlotSquared.get()
+            .loadWorld(world.getName(), PlotSquared.get().IMP.getGenerator(world.getName(), null));
+    }
+}

Bukkit/src/main/java/com/plotsquared/bukkit/util/UpdateUtility.java

@@ -0,0 +1,98 @@
+/*
+ *       _____  _       _    _____                                _
+ *      |  __ \| |     | |  / ____|                              | |
+ *      | |__) | | ___ | |_| (___   __ _ _   _  __ _ _ __ ___  __| |
+ *      |  ___/| |/ _ \| __|\___ \ / _` | | | |/ _` | '__/ _ \/ _` |
+ *      | |    | | (_) | |_ ____) | (_| | |_| | (_| | | |  __/ (_| |
+ *      |_|    |_|\___/ \__|_____/ \__, |\__,_|\__,_|_|  \___|\__,_|
+ *                                    | |
+ *                                    |_|
+ *            PlotSquared plot management system for Minecraft
+ *                  Copyright (C) 2021 IntellectualSites
+ *
+ *     This program is free software: you can redistribute it and/or modify
+ *     it under the terms of the GNU 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 General Public License for more details.
+ *
+ *     You should have received a copy of the GNU General Public License
+ *     along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package com.plotsquared.bukkit.util;
+
+import com.google.gson.JsonObject;
+import com.google.gson.JsonParser;
+import com.google.gson.stream.JsonReader;
+import com.plotsquared.core.PlotSquared;
+import com.plotsquared.core.PlotVersion;
+import com.plotsquared.core.configuration.Captions;
+import com.plotsquared.core.configuration.Settings;
+import org.bukkit.Bukkit;
+import org.bukkit.event.Listener;
+import org.bukkit.plugin.java.JavaPlugin;
+import org.bukkit.scheduler.BukkitTask;
+
+import javax.net.ssl.HttpsURLConnection;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.net.URL;
+
+public class UpdateUtility implements Listener {
+
+    public static PlotVersion internalVersion;
+    public static String spigotVersion;
+    public static boolean hasUpdate;
+    private static BukkitTask task;
+    public final JavaPlugin javaPlugin;
+    private boolean notify = true;
+
+    public UpdateUtility(final JavaPlugin javaPlugin) {
+        this.javaPlugin = javaPlugin;
+        internalVersion = PlotSquared.get().getVersion();
+    }
+
+    public void updateChecker() {
+        task = Bukkit.getScheduler().runTaskTimerAsynchronously(this.javaPlugin, () -> {
+            try {
+                HttpsURLConnection connection = (HttpsURLConnection) new URL(
+                    "https://api.spigotmc.org/simple/0.1/index.php?action=getResource&id=77506")
+                    .openConnection();
+                connection.setRequestMethod("GET");
+                JsonObject result = (new JsonParser())
+                    .parse(new JsonReader(new InputStreamReader(connection.getInputStream())))
+                    .getAsJsonObject();
+                spigotVersion = result.get("current_version").getAsString();
+            } catch (IOException e) {
+                PlotSquared.log(Captions.PREFIX + "&cUnable to check for updates because: " + e);
+                return;
+            }
+
+            if (internalVersion.isLaterVersion(spigotVersion)) {
+                PlotSquared
+                    .log(Captions.PREFIX + "&6There appears to be a PlotSquared update available!");
+                PlotSquared.log(
+                    Captions.PREFIX + "&6You are running version " + internalVersion.versionString()
+                        + ", &6latest version is " + spigotVersion);
+                PlotSquared
+                    .log(Captions.PREFIX + "&6https://www.spigotmc.org/resources/77506/updates");
+                hasUpdate = true;
+                if (Settings.UpdateChecker.NOTIFY_ONCE) {
+                    cancelTask();
+                }
+            } else if (notify) {
+                notify = false;
+                PlotSquared.log(Captions.PREFIX
+                    + "Congratulations! You are running the latest PlotSquared version.");
+            }
+        }, 0L, Settings.UpdateChecker.POLL_RATE * 60 * 20);
+    }
+
+    private void cancelTask() {
+        Bukkit.getScheduler().runTaskLater(javaPlugin, () -> task.cancel(), 20L);
+    }
+}

Bukkit/src/main/java/com/plotsquared/bukkit/uuid/EssentialsUUIDService.java

@@ -0,0 +1,70 @@
+/*
+ *       _____  _       _    _____                                _
+ *      |  __ \| |     | |  / ____|                              | |
+ *      | |__) | | ___ | |_| (___   __ _ _   _  __ _ _ __ ___  __| |
+ *      |  ___/| |/ _ \| __|\___ \ / _` | | | |/ _` | '__/ _ \/ _` |
+ *      | |    | | (_) | |_ ____) | (_| | |_| | (_| | | |  __/ (_| |
+ *      |_|    |_|\___/ \__|_____/ \__, |\__,_|\__,_|_|  \___|\__,_|
+ *                                    | |
+ *                                    |_|
+ *            PlotSquared plot management system for Minecraft
+ *                  Copyright (C) 2021 IntellectualSites
+ *
+ *     This program is free software: you can redistribute it and/or modify
+ *     it under the terms of the GNU 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 General Public License for more details.
+ *
+ *     You should have received a copy of the GNU General Public License
+ *     along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package com.plotsquared.bukkit.uuid;
+
+import com.earth2me.essentials.Essentials;
+import com.earth2me.essentials.User;
+import com.plotsquared.core.uuid.UUIDMapping;
+import com.plotsquared.core.uuid.UUIDService;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.UUID;
+
+/**
+ * UUID service using the EssentialsX API
+ */
+public class EssentialsUUIDService implements UUIDService {
+
+    private final Essentials essentials;
+
+    public EssentialsUUIDService() {
+        this.essentials = Essentials.getPlugin(Essentials.class);
+    }
+
+    @Override @NotNull public List<UUIDMapping> getNames(@NotNull final List<UUID> uuids) {
+        return Collections.emptyList();
+    }
+
+    @Override @NotNull public List<UUIDMapping> getUUIDs(@NotNull final List<String> usernames) {
+        final List<UUIDMapping> mappings = new ArrayList<>(usernames.size());
+        for (final String username : usernames) {
+            try {
+                final User user = essentials.getUser(username);
+                if (user != null) {
+                    final UUID uuid = user.getConfigUUID();
+                    if (uuid != null) {
+                        mappings.add(new UUIDMapping(uuid, username));
+                    }
+                }
+            } catch (final Exception ignored){}
+        }
+        return mappings;
+    }
+
+}

Bukkit/src/main/java/com/plotsquared/bukkit/uuid/LuckPermsUUIDService.java

@@ -0,0 +1,84 @@
+/*
+ *       _____  _       _    _____                                _
+ *      |  __ \| |     | |  / ____|                              | |
+ *      | |__) | | ___ | |_| (___   __ _ _   _  __ _ _ __ ___  __| |
+ *      |  ___/| |/ _ \| __|\___ \ / _` | | | |/ _` | '__/ _ \/ _` |
+ *      | |    | | (_) | |_ ____) | (_| | |_| | (_| | | |  __/ (_| |
+ *      |_|    |_|\___/ \__|_____/ \__, |\__,_|\__,_|_|  \___|\__,_|
+ *                                    | |
+ *                                    |_|
+ *            PlotSquared plot management system for Minecraft
+ *                  Copyright (C) 2021 IntellectualSites
+ *
+ *     This program is free software: you can redistribute it and/or modify
+ *     it under the terms of the GNU 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 General Public License for more details.
+ *
+ *     You should have received a copy of the GNU General Public License
+ *     along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package com.plotsquared.bukkit.uuid;
+
+import com.plotsquared.core.uuid.UUIDMapping;
+import com.plotsquared.core.uuid.UUIDService;
+import net.luckperms.api.LuckPerms;
+import net.luckperms.api.model.user.UserManager;
+import org.bukkit.Bukkit;
+import org.bukkit.plugin.RegisteredServiceProvider;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.UUID;
+
+/**
+ * UUID service that uses the LuckPerms API
+ */
+public class LuckPermsUUIDService implements UUIDService {
+
+    private final LuckPerms luckPerms;
+
+    public LuckPermsUUIDService() {
+        final RegisteredServiceProvider<LuckPerms> provider = Bukkit.getServicesManager().getRegistration(LuckPerms.class);
+        if (provider != null) {
+            this.luckPerms = provider.getProvider();
+        } else {
+            throw new IllegalStateException("LuckPerms not available");
+        }
+    }
+
+    @Override @NotNull public List<UUIDMapping> getNames(@NotNull final List<UUID> uuids) {
+       final List<UUIDMapping> mappings = new ArrayList<>(uuids.size());
+       final UserManager userManager = this.luckPerms.getUserManager();
+       for (final UUID uuid : uuids) {
+           try {
+               final String username = userManager.lookupUsername(uuid).get();
+               if (username != null) {
+                   mappings.add(new UUIDMapping(uuid, username));
+               }
+           } catch (final Exception ignored) {}
+       }
+       return mappings;
+    }
+
+    @Override @NotNull public List<UUIDMapping> getUUIDs(@NotNull final List<String> usernames) {
+        final List<UUIDMapping> mappings = new ArrayList<>(usernames.size());
+        final UserManager userManager = this.luckPerms.getUserManager();
+        for (final String username : usernames) {
+            try {
+                final UUID uuid = userManager.lookupUniqueId(username).get();
+                if (username != null) {
+                    mappings.add(new UUIDMapping(uuid, username));
+                }
+            } catch (final Exception ignored) {}
+        }
+        return mappings;
+    }
+
+}

Bukkit/src/main/java/com/plotsquared/bukkit/uuid/OfflinePlayerUUIDService.java

@@ -0,0 +1,85 @@
+/*
+ *       _____  _       _    _____                                _
+ *      |  __ \| |     | |  / ____|                              | |
+ *      | |__) | | ___ | |_| (___   __ _ _   _  __ _ _ __ ___  __| |
+ *      |  ___/| |/ _ \| __|\___ \ / _` | | | |/ _` | '__/ _ \/ _` |
+ *      | |    | | (_) | |_ ____) | (_| | |_| | (_| | | |  __/ (_| |
+ *      |_|    |_|\___/ \__|_____/ \__, |\__,_|\__,_|_|  \___|\__,_|
+ *                                    | |
+ *                                    |_|
+ *            PlotSquared plot management system for Minecraft
+ *                  Copyright (C) 2021 IntellectualSites
+ *
+ *     This program is free software: you can redistribute it and/or modify
+ *     it under the terms of the GNU 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 General Public License for more details.
+ *
+ *     You should have received a copy of the GNU General Public License
+ *     along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package com.plotsquared.bukkit.uuid;
+
+import com.google.common.base.Charsets;
+import com.plotsquared.core.configuration.Settings;
+import com.plotsquared.core.uuid.UUIDMapping;
+import com.plotsquared.core.uuid.UUIDService;
+import org.bukkit.Bukkit;
+import org.bukkit.OfflinePlayer;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.UUID;
+
+/**
+ * UUID service that use {@link org.bukkit.OfflinePlayer offline players}
+ */
+public class OfflinePlayerUUIDService implements UUIDService {
+
+    @Override @NotNull public List<UUIDMapping> getNames(@NotNull final List<UUID> uuids) {
+        if (Settings.UUID.FORCE_LOWERCASE || Bukkit.getWorlds().isEmpty()) {
+            return Collections.emptyList(); // This is useless now
+        }
+        final List<UUIDMapping> wrappers = new ArrayList<>(uuids.size());
+        for (final UUID uuid : uuids) {
+            final OfflinePlayer offlinePlayer = Bukkit.getOfflinePlayer(uuid);
+            try {
+                if (offlinePlayer.hasPlayedBefore()) {
+                    wrappers.add(new UUIDMapping(uuid, offlinePlayer.getName()));
+                }
+            } catch (final Exception ignored) {} /* This can be safely ignored. If this happens, it is
+                                                    probably because it's called before the worlds have
+                                                    been loaded. This is bad, but does not break anything */
+        }
+        return wrappers;
+    }
+
+    @Override @NotNull public List<UUIDMapping> getUUIDs(@NotNull final List<String> usernames) {
+        final List<UUIDMapping> wrappers = new ArrayList<>(usernames.size());
+        for (final String username : usernames) {
+            if (Settings.UUID.OFFLINE) {
+                if (Settings.UUID.FORCE_LOWERCASE) {
+                    wrappers.add(new UUIDMapping(UUID.nameUUIDFromBytes(("OfflinePlayer:" +
+                            username.toLowerCase()).getBytes(Charsets.UTF_8)), username));
+                } else {
+                    wrappers.add(new UUIDMapping(UUID.nameUUIDFromBytes(("OfflinePlayer:" +
+                            username).getBytes(Charsets.UTF_8)), username));
+                }
+            } else {
+                final OfflinePlayer offlinePlayer = Bukkit.getOfflinePlayer(username);
+                if (offlinePlayer.hasPlayedBefore()) {
+                    wrappers.add(new UUIDMapping(offlinePlayer.getUniqueId(), offlinePlayer.getName()));
+                }
+            }
+        }
+        return wrappers;
+    }
+
+}

Bukkit/src/main/java/com/plotsquared/bukkit/uuid/PaperUUIDService.java

@@ -0,0 +1,65 @@
+/*
+ *       _____  _       _    _____                                _
+ *      |  __ \| |     | |  / ____|                              | |
+ *      | |__) | | ___ | |_| (___   __ _ _   _  __ _ _ __ ___  __| |
+ *      |  ___/| |/ _ \| __|\___ \ / _` | | | |/ _` | '__/ _ \/ _` |
+ *      | |    | | (_) | |_ ____) | (_| | |_| | (_| | | |  __/ (_| |
+ *      |_|    |_|\___/ \__|_____/ \__, |\__,_|\__,_|_|  \___|\__,_|
+ *                                    | |
+ *                                    |_|
+ *            PlotSquared plot management system for Minecraft
+ *                  Copyright (C) 2021 IntellectualSites
+ *
+ *     This program is free software: you can redistribute it and/or modify
+ *     it under the terms of the GNU 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 General Public License for more details.
+ *
+ *     You should have received a copy of the GNU General Public License
+ *     along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package com.plotsquared.bukkit.uuid;
+
+import com.destroystokyo.paper.profile.PlayerProfile;
+import com.plotsquared.core.uuid.UUIDMapping;
+import com.plotsquared.core.uuid.UUIDService;
+import org.bukkit.Bukkit;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.UUID;
+
+/**
+ * UUID service that uses the Paper profile API
+ */
+public class PaperUUIDService implements UUIDService {
+
+    @Override @NotNull public List<UUIDMapping> getNames(@NotNull final List<UUID> uuids) {
+        final List<UUIDMapping> mappings = new ArrayList<>(uuids.size());
+        for (final UUID uuid : uuids) {
+            final PlayerProfile playerProfile = Bukkit.createProfile(uuid);
+            if ((playerProfile.isComplete() || playerProfile.completeFromCache()) && playerProfile.getId() != null) {
+                mappings.add(new UUIDMapping(playerProfile.getId(), playerProfile.getName()));
+            }
+        }
+        return mappings;
+    }
+
+    @Override @NotNull public List<UUIDMapping> getUUIDs(@NotNull final List<String> usernames) {
+        final List<UUIDMapping> mappings = new ArrayList<>(usernames.size());
+        for (final String username : usernames) {
+            final PlayerProfile playerProfile = Bukkit.createProfile(username);
+            if ((playerProfile.isComplete() || playerProfile.completeFromCache()) && playerProfile.getId() != null) {
+                mappings.add(new UUIDMapping(playerProfile.getId(), playerProfile.getName()));
+            }
+        }
+        return mappings;
+    }
+
+}

Bukkit/src/main/java/com/plotsquared/bukkit/uuid/SQLiteUUIDService.java

@@ -0,0 +1,145 @@
+/*
+ *       _____  _       _    _____                                _
+ *      |  __ \| |     | |  / ____|                              | |
+ *      | |__) | | ___ | |_| (___   __ _ _   _  __ _ _ __ ___  __| |
+ *      |  ___/| |/ _ \| __|\___ \ / _` | | | |/ _` | '__/ _ \/ _` |
+ *      | |    | | (_) | |_ ____) | (_| | |_| | (_| | | |  __/ (_| |
+ *      |_|    |_|\___/ \__|_____/ \__, |\__,_|\__,_|_|  \___|\__,_|
+ *                                    | |
+ *                                    |_|
+ *            PlotSquared plot management system for Minecraft
+ *                  Copyright (C) 2021 IntellectualSites
+ *
+ *     This program is free software: you can redistribute it and/or modify
+ *     it under the terms of the GNU 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 General Public License for more details.
+ *
+ *     You should have received a copy of the GNU General Public License
+ *     along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package com.plotsquared.bukkit.uuid;
+
+import com.plotsquared.core.PlotSquared;
+import com.plotsquared.core.database.SQLite;
+import com.plotsquared.core.util.MainUtil;
+import com.plotsquared.core.uuid.UUIDMapping;
+import com.plotsquared.core.uuid.UUIDService;
+import org.jetbrains.annotations.NotNull;
+
+import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.util.ArrayList;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.UUID;
+import java.util.function.Consumer;
+
+/**
+ * UUID service that uses the (legacy) SQL UUID cache
+ */
+public class SQLiteUUIDService implements UUIDService, Consumer<List<UUIDMapping>> {
+
+    private final SQLite sqlite;
+
+    public SQLiteUUIDService(final String fileName) {
+        this.sqlite =
+            new SQLite(MainUtil.getFile(PlotSquared.get().IMP.getDirectory(), fileName));
+        try {
+            this.sqlite.openConnection();
+        } catch (ClassNotFoundException | SQLException e) {
+            e.printStackTrace();
+        }
+
+        try (PreparedStatement stmt = getConnection().prepareStatement(
+            "CREATE TABLE IF NOT EXISTS `usercache` (uuid VARCHAR(32) NOT NULL, username VARCHAR(32) NOT NULL, PRIMARY KEY (uuid))")) {
+            stmt.execute();
+        } catch (SQLException e) {
+            e.printStackTrace();
+        }
+    }
+
+    private Connection getConnection() {
+        synchronized (this.sqlite) {
+            return this.sqlite.getConnection();
+        }
+    }
+
+    @Override @NotNull public List<UUIDMapping> getNames(@NotNull final List<UUID> uuids) {
+        final List<UUIDMapping> mappings = new ArrayList<>(uuids.size());
+        try (final PreparedStatement statement = getConnection()
+            .prepareStatement("SELECT `username` FROM `usercache` WHERE `uuid` = ?")) {
+            for (final UUID uuid : uuids) {
+                statement.setString(1, uuid.toString());
+                try (final ResultSet resultSet = statement.executeQuery()) {
+                    if (resultSet.next()) {
+                        mappings.add(new UUIDMapping(uuid, resultSet.getString("username")));
+                    }
+                }
+            }
+        } catch (final Exception e) {
+            e.printStackTrace();
+        }
+        return mappings;
+    }
+
+    @Override @NotNull public List<UUIDMapping> getUUIDs(@NotNull List<String> usernames) {
+        final List<UUIDMapping> mappings = new ArrayList<>(usernames.size());
+        try (final PreparedStatement statement = getConnection()
+            .prepareStatement("SELECT `uuid` FROM `usercache` WHERE `username` = ?")) {
+            for (final String username : usernames) {
+                statement.setString(1, username);
+                try (final ResultSet resultSet = statement.executeQuery()) {
+                    if (resultSet.next()) {
+                        mappings.add(new UUIDMapping(UUID.fromString(resultSet.getString("uuid")),
+                            username));
+                    }
+                }
+            }
+        } catch (final Exception e) {
+            e.printStackTrace();
+        }
+        return mappings;
+    }
+
+    @Override public void accept(final List<UUIDMapping> uuidWrappers) {
+        try (final PreparedStatement statement = getConnection()
+            .prepareStatement("INSERT OR REPLACE INTO `usercache` (`uuid`, `username`) VALUES(?, ?)")) {
+            for (final UUIDMapping mapping : uuidWrappers) {
+                statement.setString(1, mapping.getUuid().toString());
+                statement.setString(2, mapping.getUsername());
+                statement.executeUpdate();
+            }
+        } catch (SQLException e) {
+            e.printStackTrace();
+        }
+    }
+
+    /**
+     * Read the entire cache at once
+     *
+     * @return All read mappings
+     */
+    @NotNull public List<UUIDMapping> getAll() {
+        final List<UUIDMapping> mappings = new LinkedList<>();
+        try (final PreparedStatement statement = getConnection().prepareStatement("SELECT * FROM `usercache`")) {
+            try (final ResultSet resultSet = statement.executeQuery()) {
+                while (resultSet.next()) {
+                    mappings.add(new UUIDMapping(UUID.fromString(resultSet.getString("uuid")), resultSet.getString("username")));
+                }
+            }
+        } catch (final Exception e) {
+            e.printStackTrace();
+        }
+        return mappings;
+    }
+
+
+}

Bukkit/src/main/java/com/plotsquared/bukkit/uuid/SquirrelIdUUIDService.java

@@ -0,0 +1,112 @@
+/*
+ *       _____  _       _    _____                                _
+ *      |  __ \| |     | |  / ____|                              | |
+ *      | |__) | | ___ | |_| (___   __ _ _   _  __ _ _ __ ___  __| |
+ *      |  ___/| |/ _ \| __|\___ \ / _` | | | |/ _` | '__/ _ \/ _` |
+ *      | |    | | (_) | |_ ____) | (_| | |_| | (_| | | |  __/ (_| |
+ *      |_|    |_|\___/ \__|_____/ \__, |\__,_|\__,_|_|  \___|\__,_|
+ *                                    | |
+ *                                    |_|
+ *            PlotSquared plot management system for Minecraft
+ *                  Copyright (C) 2021 IntellectualSites
+ *
+ *     This program is free software: you can redistribute it and/or modify
+ *     it under the terms of the GNU 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 General Public License for more details.
+ *
+ *     You should have received a copy of the GNU General Public License
+ *     along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package com.plotsquared.bukkit.uuid;
+
+import com.google.common.util.concurrent.RateLimiter;
+import com.plotsquared.core.PlotSquared;
+import com.plotsquared.core.configuration.Captions;
+import com.plotsquared.core.uuid.UUIDMapping;
+import com.plotsquared.core.uuid.UUIDService;
+import com.sk89q.squirrelid.Profile;
+import com.sk89q.squirrelid.resolver.HttpRepositoryService;
+import com.sk89q.squirrelid.resolver.ProfileService;
+import org.jetbrains.annotations.NotNull;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.UUID;
+
+/**
+ * UUID service using SquirrelID
+ */
+@SuppressWarnings("UnstableApiUsage")
+public class SquirrelIdUUIDService implements UUIDService {
+
+    private final ProfileService profileService;
+    private final RateLimiter rateLimiter;
+
+    /**
+     * Create a new SquirrelID UUID service
+     *
+     * @param rateLimit Mojangs rate limit is 600 requests per 10 minutes.
+     *                  This parameter specifies how many of those requests
+     *                  we can use before our internal rate limit kicks in.
+     */
+    public SquirrelIdUUIDService(final int rateLimit) {
+        this.profileService = HttpRepositoryService.forMinecraft();
+        // RateLimiter uses request per seconds. The constructor
+        // parameter rateLimit is requests per 600 seconds
+        this.rateLimiter = RateLimiter.create(rateLimit / 600.0D);
+    }
+
+    @Override @NotNull public List<UUIDMapping> getNames(@NotNull final List<UUID> uuids) {
+        final List<UUIDMapping> results = new ArrayList<>(uuids.size());
+        this.rateLimiter.acquire(uuids.size());
+        try {
+            try {
+                for (final Profile profile : this.profileService.findAllById(uuids)) {
+                    results.add(new UUIDMapping(profile.getUniqueId(), profile.getName()));
+                }
+            } catch (final IllegalArgumentException illegalArgumentException) {
+                //
+                // This means that the UUID was invalid for whatever reason, we'll try to
+                // go through them one by one
+                //
+                if (uuids.size() >= 2) {
+                    PlotSquared.debug(Captions.PREFIX + "(UUID) Found invalid UUID in batch. Will try each UUID individually.");
+                    for (final UUID uuid : uuids) {
+                        final List<UUIDMapping> result = this.getNames(Collections.singletonList(uuid));
+                        if (result.isEmpty()) {
+                            continue;
+                        }
+                        results.add(result.get(0));
+                    }
+                } else if (uuids.size() == 1) {
+                    PlotSquared.debug(Captions.PREFIX + "(UUID) Found invalid UUID: " + uuids.get(0));
+                }
+            }
+        } catch (IOException | InterruptedException e) {
+            e.printStackTrace();
+        }
+        return results;
+    }
+
+    @Override @NotNull public List<UUIDMapping> getUUIDs(@NotNull final List<String> usernames) {
+        final List<UUIDMapping> results = new ArrayList<>(usernames.size());
+        this.rateLimiter.acquire(usernames.size());
+        try {
+            for (final Profile profile : this.profileService.findAllByName(usernames)) {
+                results.add(new UUIDMapping(profile.getUniqueId(), profile.getName()));
+            }
+        } catch (IOException | InterruptedException e) {
+            e.printStackTrace();
+        }
+        return results;
+    }
+
+}

Bukkit/src/main/resources/plugin.yml

@@ -0,0 +1,314 @@
+name: ${name}
+main: com.plotsquared.bukkit.BukkitMain
+api-version: "1.13"
+version: "${version}"
+load: STARTUP
+description: "Easy, yet powerful Plot World generation and management."
+authors: [Citymonstret, Empire92, MattBDev, dordsor21, NotMyFault, SirYwell]
+website: https://www.spigotmc.org/resources/77506/
+softdepend: [Vault, PlaceholderAPI, Essentials, LuckPerms, BungeePerms, MVdWPlaceholderAPI]
+loadbefore: [MultiWorld, Multiverse-Core]
+depend: [WorldEdit]
+database: false
+commands:
+  plots:
+    description: Plot command.
+    aliases: [p,plot,ps,plotsquared,p2,2,plotme]
+    permission: plots.use
+    permission-message: "You are lacking the permission node 'plots.use'"
+permissions:
+  plots.use:
+    default: true
+  plots.teleport.delay.bypass:
+    default: op
+  plots.permpack.basicflags:
+    default: op
+    children:
+      plots.set.flag: true
+      plots.flag: true
+      plots.flag.add: true
+      plots.flag.remove: true
+      plots.flag.list: true
+      plots.flag.info: true
+      plots.set.flag.titles.*: true
+      plots.set.flag.greeting.*: true
+      plots.set.flag.farewell.*: true
+      plots.set.flag.notify-enter.*: true
+      plots.set.flag.notify-leave.*: true
+      plots.set.flag.feed.*: true
+      plots.set.flag.heal.*: true
+      plots.set.flag.invincible.*: true
+      plots.set.flag.instabreak.*: true
+      plots.set.flag.fly.*: true
+      plots.set.flag.gamemode: true
+      plots.set.flag.gamemode.creative: true
+      plots.set.flag.gamemode.survival: true
+      plots.set.flag.gamemode.adventure: true
+      plots.set.flag.time.*: true
+      plots.set.flag.weather.*: true
+      plots.set.flag.music.*: true
+      plots.set.flag.disable-physics.*: true
+      plots.set.flag.pve.*: true
+      plots.set.flag.pvp.*: true
+      plots.set.flag.explosion.*: true
+      plots.set.flag.hostile-interact.*: true
+      plots.set.flag.hostile-attack.*: true
+      plots.set.flag.player-interact.*: true
+      plots.set.flag.animal-interact.*: true
+      plots.set.flag.animal-attack.*: true
+      plots.set.flag.tamed-interact.*: true
+      plots.set.flag.tamed-attack.*: true
+      plots.set.flag.misc-interact.*: true
+      plots.set.flag.hanging-place.*: true
+      plots.set.flag.hanging-break.*: true
+      plots.set.flag.vehicle-use.*: true
+      plots.set.flag.vehicle-place.*: true
+      plots.set.flag.vehicle-break.*: true
+      plots.set.flag.place.*: true
+      plots.set.flag.break.*: true
+      plots.set.flag.use.*: true
+      plots.set.flag.forcefield.*: true
+      plots.set.flag.price.*: true
+      plots.set.flag.no-worldedit.*: true
+  plots.permpack.basicinbox:
+    default: op
+    children:
+      comments.notifications.enabled: true
+      plots.inbox.read.public: true
+      plots.inbox.modify.public: true
+      plots.inbox.write.public: true
+      plots.inbox.read.report: true
+      plots.inbox.write.report: true
+      plots.inbox.read.owner: true
+      plots.inbox.modify.owner: true
+      plots.inbox.write.owner: true
+      plots.comment: true
+      plots.inbox: true
+  plots.permpack.wilderness:
+    default: op
+    children:
+      plots.admin.interact.unowned: true
+      plots.admin.destroy.unowned: true
+      plots.admin.build.unowned: true
+      plots.projectile.unowned: true
+      plots.admin.vehicle.break.unowned: true
+      plots.admin.pve.unowned: true
+  plots.permpack.basic:
+    default: op
+    children:
+      plots.use: true
+      plots.info: true
+      plots.claim: true
+      plots.auto: true
+      plots.home: true
+      plots.clear: true
+      plots.delete: true
+      plots.music: true
+      plots.list: true
+      plots.list.mine: true
+      plots.list.shared: true
+      plots.list.world: true
+      plots.list.all: true
+      plots.list.forsale: true
+      plots.list.unowned: true
+      plots.list.unknown: true
+      plots.set: true
+      plots.visit: true
+      plots.visit.owned: true
+      plots.visit.shared: true
+      plots.set.flag: true
+      plots.flag.add: true
+      plots.flag.remove: true
+      plots.flag.list: true
+      plots.flag.info: true
+      plots.flag: true
+      plots.buy: true
+      plots.chat: true
+      plots.confirm: true
+      plots.toggle: true
+      plots.toggle.titles: true
+      plots.toggle.chat: true
+      plots.toggle.time: true
+      plots.set.biome: true
+      plots.set.home: true
+      plots.set.alias: true
+      plots.alias.set: true
+      plots.alias.remove: true
+      plots.set.description: true
+      plots.description: true
+      plots.alias: true
+      plots.merge: true
+      plots.merge.other: true
+      plots.merge.4: true
+      plots.unlink: true
+      plots.denied: true
+      plots.add: true
+      plots.trust: true
+      plots.deny: true
+      plots.remove: true
+      plots.untrust: true
+      plots.undeny: true
+      plots.kick: true
+      plots.download: true
+      plots.save: true
+      plots.done: true
+      plots.continue: true
+      plots.middle: true
+  plots.worldedit.bypass:
+    default: false
+  plots.gamemode.bypass:
+    default: op
+  plots.confirm.bypass:
+    default: false
+  plotme.use:
+    description: Gives default user commands
+    children:
+      plots.permpack.basic: true
+      plots.plot.1: true
+  plotme.admin:
+    description: Gives default administrator commands
+    children:
+      plots.admin: true
+  plotme.use.middle:
+    children:
+      plots.middle: true
+  plotme.use.buy:
+    children:
+      plots.buy: true
+  plotme.use.sell:
+    children:
+      plots.set: true
+      plots.flag: true
+      plots.set.flag: true
+      plots.set.price.*: true
+  plotme.use.dispose:
+    children:
+      plots.delete: true
+  plotme.use.done:
+    children:
+      plots.done: true
+  plotme.use.claim:
+    children:
+      plots.claim: true
+  plotme.use.auto:
+    children:
+      plots.auto: true
+  plotme.use.reset:
+    children:
+      plots.delete: true
+  plotme.use.home:
+    children:
+      plots.home: true
+  plotme.use.info:
+    children:
+      plots.info: true
+  plotme.use.biome:
+    children:
+      plots.set: true
+      plots.set.biome: true
+  plotme.use.clear:
+    children:
+      plots.clear: true
+  plotme.use.list:
+    children:
+      plots.list: true
+      plots.list.forsale: true
+      plots.list.mine: true
+      plots.list.shared: true
+  plotme.use.add:
+    children:
+      plots.add: true
+      plots.trust: true
+      plots.add.everyone: true
+      plots.trust.everyone: true
+  plotme.use.deny:
+    children:
+      plots.deny: true
+      plots.deny.everyone: true
+  plotme.use.remove:
+    children:
+      plots.remove: true
+  plotme.use.undeny:
+    children:
+      plots.remove: true
+  plotme.use.protect:
+    children:
+      plots.set: true
+      plots.flag: true
+      plots.set.flag: true
+      plots.set.keep.*: true
+  plotme.use.nameplot:
+    children:
+      plots.set.alias: true
+      plots.alias.set: true
+      plots.alias.remove: true
+  plotme.limit.*:
+    children:
+      plots.plot.*: true
+  plotme.limit.1:
+    children:
+      plots.plot.1: true
+  plotme.limit.5:
+    children:
+      plots.plot.5: true
+  plotme.limit.10:
+    children:
+      plots.plot.10: true
+  plotme.admin.clear:
+    children:
+      plots.admin.command.clear: true
+  plotme.admin.reset:
+    children:
+      plots.admin.command.delete: true
+  plotme.admin.add:
+    children:
+      plots.admin.command.add: true
+  plotme.admin.deny:
+    children:
+      plots.admin.command.deny: true
+  plotme.admin.remove:
+    children:
+      plots.admin.command.remove: true
+  plotme.admin.undeny:
+    children:
+      plots.admin.command.remove: true
+  plotme.admin.bypassdeny:
+    children:
+      plots.admin.entry.denied: true
+  plotme.admin.setowner:
+    children:
+      plots.admin.command.setowner: true
+  plotme.admin.move:
+    children:
+      plots.admin.command.move: true
+  plotme.admin.weanywhere:
+    children:
+      plots.worldedit.bypass: true
+  plotme.admin.list:
+    children:
+      plots.list.world: true
+      plots.list.world.*: true
+      plots.list.top: true
+      plots.list.all: true
+      plots.list.unowned: true
+      plots.list.unknown: true
+      plots.list.player: true
+      plots.list.done: true
+      plots.list.expired: true
+      plots.list.fuzzy: true
+      plots.list.area: true
+  plotme.admin.dispose:
+    children:
+      plots.admin.command.delete: true
+  plotme.admin.done:
+    children:
+      plots.admin.command.done: true
+  plotme.admin.expired:
+    children:
+      plots.list.expired: true
+  plotme.admin.buildanywhere:
+    children:
+      plots.admin.vehicle.*: true
+      plots.admin.interact.*: true
+      plots.admin.build.*: true
+      plots.admin.destroy.*: true

CODE_OF_CONDUCT.md

@@ -0,0 +1,76 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+In the interest of fostering an open and welcoming environment, we as
+contributors and maintainers pledge to making participation in our project and
+our community a harassment-free experience for everyone, regardless of age, body
+size, disability, ethnicity, sex characteristics, gender identity and expression,
+level of experience, education, socio-economic status, nationality, personal
+appearance, race, religion, or sexual identity and orientation.
+
+## Our Standards
+
+Examples of behavior that contributes to creating a positive environment
+include:
+
+* Using welcoming and inclusive language
+* Being respectful of differing viewpoints and experiences
+* Gracefully accepting constructive criticism
+* Focusing on what is best for the community
+* Showing empathy towards other community members
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery and unwelcome sexual attention or
+ advances
+* Trolling, insulting/derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or electronic
+ address, without explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+ professional setting
+
+## Our Responsibilities
+
+Project maintainers are responsible for clarifying the standards of acceptable
+behavior and are expected to take appropriate and fair corrective action in
+response to any instances of unacceptable behavior.
+
+Project maintainers have the right and responsibility to remove, edit, or
+reject comments, commits, code, wiki edits, issues, and other contributions
+that are not aligned to this Code of Conduct, or to ban temporarily or
+permanently any contributor for other behaviors that they deem inappropriate,
+threatening, offensive, or harmful.
+
+## Scope
+
+This Code of Conduct applies both within project spaces and in public spaces
+when an individual is representing the project or its community. Examples of
+representing a project or community include using an official project e-mail
+address, posting via an official social media account, or acting as an appointed
+representative at an online or offline event. Representation of a project may be
+further defined and clarified by project maintainers.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported by contacting the project team at contact@alexander-soderberg.com. All
+complaints will be reviewed and investigated and will result in a response that
+is deemed necessary and appropriate to the circumstances. The project team is
+obligated to maintain confidentiality with regard to the reporter of an incident.
+Further details of specific enforcement policies may be posted separately.
+
+Project maintainers who do not follow or enforce the Code of Conduct in good
+faith may face temporary or permanent repercussions as determined by other
+members of the project's leadership.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4,
+available at https://www.contributor-covenant.org/version/1/4/code-of-conduct.html
+
+[homepage]: https://www.contributor-covenant.org
+
+For answers to common questions about this code of conduct, see
+https://www.contributor-covenant.org/faq

CONTRIBUTING.md

@@ -0,0 +1,9 @@
+# Contributing
+If you feel like you can improve the plugin any way, then you are more than welcome to contribute to PlotSquared. It would be highly appreciated if you made sure to test your code before committing it, as it will save us a lot of time and effort.
+
+### Code Style
+If you are planning to commit any changes to the project, it would be highly appreciated if you were to follow the project code style conventions. To make this easier we have provided settings that can be imported into your IDE.
+
+Eclipse: `Window > Preferences > Java > Code Style > Formatter` Press `Import` and select `...path/to/project/code_style.xml`
+
+IntelliJ: `File > Settings > Editor > Code Style`. Next to "Scheme" there is a cog wheel, press that and then `Import Scheme > IntelliJ IDEA Code Style XML` and then select `..path/to/project/code_style.xml`

Core/build.gradle

@@ -0,0 +1,97 @@
+repositories {
+    maven { url = "https://jitpack.io" }
+    maven { url = "https://mvn.intellectualsites.com/content/repositories/snapshots" }
+}
+def textVersion = "3.0.2"
+
+dependencies {
+    implementation("org.yaml:snakeyaml:1.26")
+    implementation("com.google.code.gson:gson:2.8.6") {
+        because("Minecraft uses GSON 2.8.0")
+        force = true
+    }
+    implementation("org.projectlombok:lombok:1.18.12")
+    compileOnly("org.projectlombok:lombok:1.18.12")
+    testCompileOnly("org.projectlombok:lombok:1.18.8")
+    annotationProcessor("org.projectlombok:lombok:1.18.8")
+    testAnnotationProcessor("org.projectlombok:lombok:1.18.8")
+    implementation("org.jetbrains.kotlin:kotlin-stdlib:1.4.0")
+    implementation("org.jetbrains:annotations:20.1.0")
+    implementation("org.khelekore:prtree:1.7.0-SNAPSHOT")
+    implementation("com.intellectualsites.paster:Paster:1.0.2-SNAPSHOT"){ transitive = false }
+}
+
+sourceCompatibility = 1.8
+targetCompatibility = 1.8
+
+processResources {
+    from("src/main/resources") {
+        include "plugin.properties"
+        expand(
+                version: "${project.parent.version}",
+                name: project.parent.name,
+                commit: "${git.head().abbreviatedId}",
+                date: "${git.head().getDate().format("yy.MM.dd")}",
+        )
+    }
+}
+
+//noinspection GroovyAssignabilityCheck
+jar.archiveFileName = "PlotSquared-${project.parent.version}.jar"
+jar.destinationDirectory = file("../mvn/com/plotsquared/PlotSquared/" + project.parent.version)
+task createPom {
+    doLast {
+        pom {
+            project {
+                groupId = rootProject.group
+                artifactId = "PlotSquared"
+                version = project.parent.version
+            }
+        }.writeTo("../mvn/com/plotsquared/PlotSquared/${project.parent.version}/PlotSquared-${project.parent.version}.pom")
+        pom {
+            project {
+                groupId = rootProject.group
+                artifactId = "PlotSquared"
+                version = "latest"
+            }
+        }.writeTo("../mvn/com/plotsquared/PlotSquared/latest/PlotSquared-latest.pom")
+         .writeTo("pom.xml")
+    }
+}
+
+task copyFiles {
+    doLast {
+        copy {
+            from("../mvn/com/plotsquared/PlotSquared/${project.parent.version}/")
+            into("../mvn/com/plotsquared/PlotSquared/latest/")
+            include("*.jar")
+            rename("PlotSquared-${project.parent.version}.jar", "PlotSquared-latest.jar")
+        }
+    }
+}
+
+shadowJar {
+    dependencies {
+        include(dependency("net.kyori:text-api:3.0.2"))
+        include(dependency("net.kyori:text-serializer-gson:3.0.2"))
+        include(dependency("net.kyori:text-serializer-legacy:3.0.2"))
+        include(dependency("net.kyori:text-serializer-plain:3.0.2"))
+        include(dependency("org.khelekore:prtree:1.7.0-SNAPSHOT"))
+        include(dependency("com.intellectualsites.paster:Paster:1.0.2-SNAPSHOT"))
+    }
+    relocate('net.kyori.text', 'com.plotsquared.formatting.text')
+    relocate("org.json", "com.plotsquared.json") {
+        exclude "org/json/simple/**"
+    }
+    relocate('com.intellectualsites.paster', 'com.plotsquared.core.paster')
+}
+
+shadowJar.doLast {
+    task ->
+        ant.checksum file: task.archivePath
+}
+
+build.dependsOn(shadowJar)
+
+build.finalizedBy(copyFiles)
+copyFiles.dependsOn(createPom)

Core/pom.xml

@@ -0,0 +1,120 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd" xmlns="http://maven.apache.org/POM/4.0.0"
+    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
+  <modelVersion>4.0.0</modelVersion>
+  <groupId>com.plotsquared</groupId>
+  <artifactId>PlotSquared</artifactId>
+  <version>latest</version>
+  <dependencies>
+    <dependency>
+      <groupId>org.json</groupId>
+      <artifactId>json</artifactId>
+      <version>20200518</version>
+      <scope>compile</scope>
+    </dependency>
+    <dependency>
+      <groupId>org.projectlombok</groupId>
+      <artifactId>lombok</artifactId>
+      <version>1.18.12</version>
+      <scope>runtime</scope>
+    </dependency>
+    <dependency>
+      <groupId>org.jetbrains</groupId>
+      <artifactId>annotations</artifactId>
+      <version>20.1.0</version>
+      <scope>runtime</scope>
+    </dependency>
+    <dependency>
+      <groupId>com.sk89q.worldedit</groupId>
+      <artifactId>worldedit-core</artifactId>
+      <version>7.2.0</version>
+      <scope>runtime</scope>
+      <exclusions>
+        <exclusion>
+          <artifactId>dummypermscompat</artifactId>
+          <groupId>*</groupId>
+        </exclusion>
+        <exclusion>
+          <artifactId>bukkit-classloader-check</artifactId>
+          <groupId>*</groupId>
+        </exclusion>
+        <exclusion>
+          <artifactId>mockito-core</artifactId>
+          <groupId>*</groupId>
+        </exclusion>
+      </exclusions>
+    </dependency>
+    <dependency>
+      <groupId>net.kyori</groupId>
+      <artifactId>text-api</artifactId>
+      <version>3.0.2</version>
+      <scope>runtime</scope>
+    </dependency>
+    <dependency>
+      <groupId>net.kyori</groupId>
+      <artifactId>text-serializer-gson</artifactId>
+      <version>3.0.2</version>
+      <scope>runtime</scope>
+    </dependency>
+    <dependency>
+      <groupId>net.kyori</groupId>
+      <artifactId>text-serializer-legacy</artifactId>
+      <version>3.0.2</version>
+      <scope>runtime</scope>
+    </dependency>
+    <dependency>
+      <groupId>net.kyori</groupId>
+      <artifactId>text-serializer-plain</artifactId>
+      <version>3.0.2</version>
+      <scope>runtime</scope>
+    </dependency>
+    <dependency>
+      <groupId>com.google.guava</groupId>
+      <artifactId>guava</artifactId>
+      <version>21.0</version>
+      <scope>runtime</scope>
+    </dependency>
+    <dependency>
+      <groupId>org.yaml</groupId>
+      <artifactId>snakeyaml</artifactId>
+      <version>1.26</version>
+      <scope>runtime</scope>
+    </dependency>
+    <dependency>
+      <groupId>com.google.code.gson</groupId>
+      <artifactId>gson</artifactId>
+      <version>2.8.6</version>
+      <scope>runtime</scope>
+    </dependency>
+    <dependency>
+      <groupId>org.jetbrains.kotlin</groupId>
+      <artifactId>kotlin-stdlib</artifactId>
+      <version>1.4.0</version>
+      <scope>runtime</scope>
+    </dependency>
+    <dependency>
+      <groupId>org.khelekore</groupId>
+      <artifactId>prtree</artifactId>
+      <version>1.7.0-SNAPSHOT</version>
+      <scope>runtime</scope>
+    </dependency>
+    <dependency>
+      <groupId>com.intellectualsites.paster</groupId>
+      <artifactId>Paster</artifactId>
+      <version>1.0.2-SNAPSHOT</version>
+      <scope>runtime</scope>
+      <exclusions>
+        <exclusion>
+          <artifactId>*</artifactId>
+          <groupId>*</groupId>
+        </exclusion>
+      </exclusions>
+    </dependency>
+    <dependency>
+      <groupId>junit</groupId>
+      <artifactId>junit</artifactId>
+      <version>4.13</version>
+      <scope>test</scope>
+    </dependency>
+  </dependencies>
+</project>

Core/src/main/java/com/plotsquared/core/IPlotMain.java

@@ -0,0 +1,310 @@
+/*
+ *       _____  _       _    _____                                _
+ *      |  __ \| |     | |  / ____|                              | |
+ *      | |__) | | ___ | |_| (___   __ _ _   _  __ _ _ __ ___  __| |
+ *      |  ___/| |/ _ \| __|\___ \ / _` | | | |/ _` | '__/ _ \/ _` |
+ *      | |    | | (_) | |_ ____) | (_| | |_| | (_| | | |  __/ (_| |
+ *      |_|    |_|\___/ \__|_____/ \__, |\__,_|\__,_|_|  \___|\__,_|
+ *                                    | |
+ *                                    |_|
+ *            PlotSquared plot management system for Minecraft
+ *                  Copyright (C) 2021 IntellectualSites
+ *
+ *     This program is free software: you can redistribute it and/or modify
+ *     it under the terms of the GNU 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 General Public License for more details.
+ *
+ *     You should have received a copy of the GNU General Public License
+ *     along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package com.plotsquared.core;
+
+import com.plotsquared.core.backup.BackupManager;
+import com.plotsquared.core.generator.GeneratorWrapper;
+import com.plotsquared.core.generator.HybridUtils;
+import com.plotsquared.core.generator.IndependentPlotGenerator;
+import com.plotsquared.core.player.PlotPlayer;
+import com.plotsquared.core.queue.QueueProvider;
+import com.plotsquared.core.util.ChatManager;
+import com.plotsquared.core.util.ChunkManager;
+import com.plotsquared.core.util.EconHandler;
+import com.plotsquared.core.util.InventoryUtil;
+import com.plotsquared.core.util.PermHandler;
+import com.plotsquared.core.util.PlatformWorldManager;
+import com.plotsquared.core.util.PlayerManager;
+import com.plotsquared.core.util.RegionManager;
+import com.plotsquared.core.util.SchematicHandler;
+import com.plotsquared.core.util.SetupUtils;
+import com.plotsquared.core.util.WorldUtil;
+import com.plotsquared.core.util.logger.ILogger;
+import com.plotsquared.core.util.task.TaskManager;
+import com.sk89q.worldedit.extension.platform.Actor;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.io.File;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * PlotSquared main utility class
+ *
+ * @param <P> Player type
+ */
+public interface IPlotMain<P> extends ILogger {
+
+    /**
+     * Logs a message to console.
+     *
+     * @param message the message to log
+     */
+    void log(String message);
+
+    /**
+     * Gets the directory which contains PlotSquared files. The directory may not exist.
+     *
+     * @return the PlotSquared directory
+     */
+    File getDirectory();
+
+    /**
+     * Gets the folder where all world data is stored.
+     *
+     * @return the world folder
+     */
+    File getWorldContainer();
+
+    /**
+     * Wraps a player into a PlotPlayer object.
+     *
+     * @param player The player to convert to a PlotPlayer
+     * @return A PlotPlayer
+     */
+    @Nullable PlotPlayer<P> wrapPlayer(Object player);
+
+    /**
+     * Completely shuts down the plugin.
+     */
+    void shutdown();
+
+    /**
+     * Gets the version of the PlotSquared being used.
+     *
+     * @return the plugin version
+     */
+    int[] getPluginVersion();
+
+    /**
+     * Gets the version of the PlotSquared being used as a string.
+     *
+     * @return the plugin version as a string
+     */
+    String getPluginVersionString();
+
+    default String getPluginName() {
+        return "PlotSquared";
+    }
+
+    /**
+     * Gets the version of Minecraft that is running.
+     */
+    int[] getServerVersion();
+
+    /**
+     * Gets the server implementation name and version
+     */
+    String getServerImplementation();
+
+    /**
+     * Gets the NMS package prefix.
+     *
+     * @return The NMS package prefix
+     */
+    String getNMSPackage();
+
+    /**
+     * Gets the schematic handler.
+     *
+     * @return The {@link SchematicHandler}
+     */
+    SchematicHandler initSchematicHandler();
+
+    /**
+     * Starts the {@link ChatManager}.
+     *
+     * @return the ChatManager
+     */
+    ChatManager initChatManager();
+
+    /**
+     * The task manager will run and manage Minecraft tasks.
+     *
+     * @return the PlotSquared task manager
+     */
+    TaskManager getTaskManager();
+
+    /**
+     * Run the task that will kill road mobs.
+     */
+    void runEntityTask();
+
+    /**
+     * Registerss the implementation specific commands.
+     */
+    void registerCommands();
+
+    /**
+     * Register the protection system.
+     */
+    void registerEvents();
+
+    /**
+     * Register force field events.
+     */
+    void registerForceFieldEvents();
+
+    /**
+     * Registers the WorldEdit hook.
+     */
+    boolean initWorldEdit();
+
+    /**
+     * Gets the economy provider, if there is one
+     *
+     * @return the PlotSquared economy manager
+     */
+    @Nullable EconHandler getEconomyHandler();
+
+    /**
+     * Gets the permission provider, if there is one
+     *
+     * @return the PlotSquared permission manager
+     */
+    @Nullable PermHandler getPermissionHandler();
+
+    /**
+     * Gets the {@link QueueProvider} class.
+     */
+    QueueProvider initBlockQueue();
+
+    /**
+     * Gets the {@link WorldUtil} class.
+     */
+    WorldUtil initWorldUtil();
+
+    /**
+     * Gets the chunk manager.
+     *
+     * @return the PlotSquared chunk manager
+     */
+    ChunkManager initChunkManager();
+
+    /**
+     * Gets the region manager.
+     *
+     * @return the PlotSquared region manager
+     */
+    RegionManager initRegionManager();
+
+    /**
+     * Gets the {@link SetupUtils} class.
+     */
+    SetupUtils initSetupUtils();
+
+    /**
+     * Gets {@link HybridUtils} class.
+     */
+    HybridUtils initHybridUtils();
+
+    /**
+     * Start Metrics.
+     */
+    void startMetrics();
+
+    /**
+     * If a world is already loaded, set the generator (use NMS if required).
+     *
+     * @param world The world to set the generator
+     */
+    void setGenerator(String world);
+
+    /**
+     * Gets the {@link InventoryUtil} class (used for implementation specific
+     * inventory guis).
+     */
+    InventoryUtil initInventoryUtil();
+
+    /**
+     * Unregisters a {@link PlotPlayer} from cache e.g. if they have logged off.
+     *
+     * @param player the player to remove
+     */
+    void unregister(PlotPlayer player);
+
+    /**
+     * Gets the generator wrapper for a world (world) and generator (name).
+     *
+     * @param world the world to get the generator from
+     * @param name  the name of the generator
+     * @return the generator being used for the provided world
+     */
+    GeneratorWrapper<?> getGenerator(String world, String name);
+
+    GeneratorWrapper<?> wrapPlotGenerator(String world, IndependentPlotGenerator generator);
+
+    /**
+     * Register the chunk processor which will clean out chunks that have too
+     * many block states or entities.
+     */
+    void registerChunkProcessor();
+
+    /**
+     * Register the world initialization events (used to keep track of worlds
+     * being generated).
+     */
+    void registerWorldEvents();
+
+    /**
+     * Register events related to the server
+     */
+    void registerServerEvents();
+
+    /**
+     * Usually HybridGen
+     *
+     * @return Default implementation generator
+     */
+    @NotNull IndependentPlotGenerator getDefaultGenerator();
+
+    String getPluginList();
+
+    Actor getConsole();
+
+    /**
+     * Get the backup manager instance
+     *
+     * @return Backup manager
+     */
+    @NotNull BackupManager getBackupManager();
+
+    /**
+     * Get the platform specific world manager
+     *
+     * @return World manager
+     */
+    @NotNull PlatformWorldManager<?> getWorldManager();
+
+    /**
+     * Get the player manager implementation for the platform
+     *
+     * @return Player manager
+     */
+    @NotNull PlayerManager<? extends PlotPlayer<P>, ? extends P> getPlayerManager();
+
+}

Core/src/main/java/com/plotsquared/core/Platform.java

@@ -0,0 +1,31 @@
+/*
+ *       _____  _       _    _____                                _
+ *      |  __ \| |     | |  / ____|                              | |
+ *      | |__) | | ___ | |_| (___   __ _ _   _  __ _ _ __ ___  __| |
+ *      |  ___/| |/ _ \| __|\___ \ / _` | | | |/ _` | '__/ _ \/ _` |
+ *      | |    | | (_) | |_ ____) | (_| | |_| | (_| | | |  __/ (_| |
+ *      |_|    |_|\___/ \__|_____/ \__, |\__,_|\__,_|_|  \___|\__,_|
+ *                                    | |
+ *                                    |_|
+ *            PlotSquared plot management system for Minecraft
+ *                  Copyright (C) 2021 IntellectualSites
+ *
+ *     This program is free software: you can redistribute it and/or modify
+ *     it under the terms of the GNU 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 General Public License for more details.
+ *
+ *     You should have received a copy of the GNU General Public License
+ *     along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package com.plotsquared.core;
+
+public enum Platform {
+    Bukkit, Sponge, Spigot, Paper
+
+}

Core/src/main/java/com/plotsquared/core/PlotVersion.java

@@ -0,0 +1,141 @@
+/*
+ *       _____  _       _    _____                                _
+ *      |  __ \| |     | |  / ____|                              | |
+ *      | |__) | | ___ | |_| (___   __ _ _   _  __ _ _ __ ___  __| |
+ *      |  ___/| |/ _ \| __|\___ \ / _` | | | |/ _` | '__/ _ \/ _` |
+ *      | |    | | (_) | |_ ____) | (_| | |_| | (_| | | |  __/ (_| |
+ *      |_|    |_|\___/ \__|_____/ \__, |\__,_|\__,_|_|  \___|\__,_|
+ *                                    | |
+ *                                    |_|
+ *            PlotSquared plot management system for Minecraft
+ *                  Copyright (C) 2021 IntellectualSites
+ *
+ *     This program is free software: you can redistribute it and/or modify
+ *     it under the terms of the GNU 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 General Public License for more details.
+ *
+ *     You should have received a copy of the GNU General Public License
+ *     along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package com.plotsquared.core;
+
+public class PlotVersion {
+    public final int year, month, day, hash;
+    public final String versionString;
+    public final int[] version;
+    public final String suffix;
+
+    public PlotVersion(int year, int month, int day, int hash, String versionString) {
+        this.year = year;
+        this.month = month;
+        this.day = day;
+        this.hash = hash;
+        int dash = versionString.indexOf('-');
+        if (dash != -1) {
+            suffix = versionString.substring(dash);
+            versionString = versionString.substring(0, dash);
+        } else {
+            suffix = "";
+        }
+        this.versionString = versionString.substring(versionString.indexOf('=') + 1);
+        version = new int[3];
+        String[] verArray = versionString.substring(versionString.indexOf('=') + 1).split("\\.");
+        version[0] = verArray.length > 0 ? Integer.parseInt(verArray[0]) : 0;
+        version[1] = verArray.length > 1 ? Integer.parseInt(verArray[1]) : 0;
+        version[2] = verArray.length > 2 ? Integer.parseInt(verArray[2]) : 0;
+    }
+
+    public PlotVersion(String versionString, String commit, String date) {
+        int dash = versionString.indexOf('-');
+        if (dash != -1) {
+            suffix = versionString.substring(dash);
+            versionString = versionString.substring(0, dash);
+        } else {
+            suffix = "";
+        }
+        this.versionString = versionString.substring(versionString.indexOf('=') + 1);
+        version = new int[3];
+        String[] verArray = this.versionString.split("\\.");
+        version[0] = verArray.length > 0 ? Integer.parseInt(verArray[0]) : 0;
+        version[1] = verArray.length > 1 ? Integer.parseInt(verArray[1]) : 0;
+        version[2] = verArray.length > 2 ? Integer.parseInt(verArray[2]) : 0;
+
+        this.hash = Integer.parseInt(commit.substring(commit.indexOf('=') + 1), 16);
+        String[] split1 = date.substring(date.indexOf('=') + 1).split("\\.");
+        this.year = Integer.parseInt(split1[0]);
+        this.month = Integer.parseInt(split1[1]);
+        this.day = Integer.parseInt(split1[2]);
+    }
+
+    public static PlotVersion tryParse(String versionString, String commit, String date) {
+        try {
+            return new PlotVersion(versionString, commit, date);
+        } catch (Exception e) {
+            e.printStackTrace();
+            return new PlotVersion(0, 0, 0, 0, "0");
+        }
+    }
+
+    public String versionString() {
+        if (hash == 0 && versionString == null) {
+            return "NoVer-SNAPSHOT";
+        } else {
+            return versionString + suffix;
+        }
+    }
+
+    @Override public String toString() {
+        if (hash == 0 && versionString == null) {
+            return "PlotSquared-NoVer-SNAPSHOT";
+        } else {
+            return "PlotSquared-" + versionString + suffix;
+        }
+    }
+
+    /**
+     * Compare a given version string with the one cached here.
+     *
+     * @param versionString the version to compare
+     * @return true if the given version is a "later" version
+     */
+    public boolean isLaterVersion(String versionString) {
+        int dash = versionString.indexOf('-');
+        String[] verArray =
+            versionString.substring(0, dash == -1 ? versionString.length() : dash).split("\\.");
+        int one = Integer.parseInt(verArray[0]);
+        int two = Integer.parseInt(verArray[1]);
+        int three = Integer.parseInt(verArray[2]);
+        if (one > version[0]) {
+            return true;
+        } else if (one == version[0] && two > version[1]) {
+            return true;
+        } else {
+            return one == version[0] && two == version[1] && three > version[2];
+        }
+    }
+
+    /**
+     * Compare a given version with the one cached here.
+     *
+     * @param verArray the version to compare
+     * @return true if the given version is a "later" version
+     */
+    public boolean isLaterVersion(int[] verArray) {
+        if (verArray[0] > version[0]) {
+            return true;
+        } else if (verArray[0] == version[0] && verArray[1] > version[1]) {
+            return true;
+        } else {
+            return verArray[0] == version[0] && verArray[1] == version[1]
+                && verArray[2] > version[2];
+        }
+    }
+
+
+}

Core/src/main/java/com/plotsquared/core/api/PlotAPI.java

@@ -0,0 +1,228 @@
+/*
+ *       _____  _       _    _____                                _
+ *      |  __ \| |     | |  / ____|                              | |
+ *      | |__) | | ___ | |_| (___   __ _ _   _  __ _ _ __ ___  __| |
+ *      |  ___/| |/ _ \| __|\___ \ / _` | | | |/ _` | '__/ _ \/ _` |
+ *      | |    | | (_) | |_ ____) | (_| | |_| | (_| | | |  __/ (_| |
+ *      |_|    |_|\___/ \__|_____/ \__, |\__,_|\__,_|_|  \___|\__,_|
+ *                                    | |
+ *                                    |_|
+ *            PlotSquared plot management system for Minecraft
+ *                  Copyright (C) 2021 IntellectualSites
+ *
+ *     This program is free software: you can redistribute it and/or modify
+ *     it under the terms of the GNU 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 General Public License for more details.
+ *
+ *     You should have received a copy of the GNU General Public License
+ *     along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package com.plotsquared.core.api;
+
+import com.plotsquared.core.PlotSquared;
+import com.plotsquared.core.configuration.Caption;
+import com.plotsquared.core.configuration.Captions;
+import com.plotsquared.core.configuration.file.YamlConfiguration;
+import com.plotsquared.core.location.Location;
+import com.plotsquared.core.player.PlotPlayer;
+import com.plotsquared.core.plot.Plot;
+import com.plotsquared.core.plot.PlotArea;
+import com.plotsquared.core.queue.GlobalBlockQueue;
+import com.plotsquared.core.util.ChunkManager;
+import com.plotsquared.core.util.EventDispatcher;
+import com.plotsquared.core.util.MainUtil;
+import com.plotsquared.core.util.SchematicHandler;
+import lombok.NoArgsConstructor;
+
+import java.util.Collections;
+import java.util.Set;
+import java.util.UUID;
+
+/**
+ * PlotSquared API.
+ *
+ * <p>Useful classes:
+ * <ul>
+ * <li>{@link PlotPlayer}</li>
+ * <li>{@link Plot}</li>
+ * <li>{@link Location}</li>
+ * <li>{@link PlotArea}</li>
+ * <li>{@link PlotSquared}</li>
+ * </ul>
+ *
+ * @version 5
+ */
+@SuppressWarnings({"unused", "WeakerAccess"}) @NoArgsConstructor public class PlotAPI {
+
+    /**
+     * Gets all plots.
+     *
+     * @return all plots
+     * @see PlotSquared#getPlots()
+     */
+    public Set<Plot> getAllPlots() {
+        return PlotSquared.get().getPlots();
+    }
+
+    /**
+     * Gets all plots for a player.
+     *
+     * @param player Player, whose plots to search for
+     * @return all plots that a player owns
+     */
+    public Set<Plot> getPlayerPlots(PlotPlayer player) {
+        return PlotSquared.get().getPlots(player);
+    }
+
+    /**
+     * Adds a plot world.
+     *
+     * @param plotArea Plot World Object
+     * @see PlotSquared#addPlotArea(PlotArea)
+     */
+    public void addPlotArea(PlotArea plotArea) {
+        PlotSquared.get().addPlotArea(plotArea);
+    }
+
+    /**
+     * Gets the configuration file for this plugin.
+     *
+     * @return the configuration file for PlotSquared
+     * =
+     */
+    public YamlConfiguration getConfig() {
+        return PlotSquared.get().getConfig();
+    }
+
+    /**
+     * Gets the PlotSquared storage file.
+     *
+     * @return storage configuration
+     * @see PlotSquared#storage
+     */
+    public YamlConfiguration getStorage() {
+        return PlotSquared.get().storage;
+    }
+
+    /**
+     * ChunkManager class contains several useful methods.
+     * <ul>
+     * <li>Chunk deletion</li>
+     * <li>Moving or copying regions</li>
+     * <li>Plot swapping</li>
+     * <li>Entity Tracking</li>
+     * <li>Region Regeneration</li>
+     * </ul>
+     *
+     * @return ChunkManager
+     * @see ChunkManager
+     */
+    public ChunkManager getChunkManager() {
+        return ChunkManager.manager;
+    }
+
+    /**
+     * Gets the block/biome set queue
+     *
+     * @return GlobalBlockQueue.IMP
+     */
+    public GlobalBlockQueue getBlockQueue() {
+        return GlobalBlockQueue.IMP;
+    }
+
+    /**
+     * SchematicHandler class contains methods related to pasting, reading
+     * and writing schematics.
+     *
+     * @return SchematicHandler
+     * @see SchematicHandler
+     */
+    public SchematicHandler getSchematicHandler() {
+        return SchematicHandler.manager;
+    }
+
+    /**
+     * Gets a list of PlotAreas in the world.
+     *
+     * @param world The world to check for plot areas
+     * @return A set of PlotAreas
+     */
+    public Set<PlotArea> getPlotAreas(String world) {
+        if (world == null) {
+            return Collections.emptySet();
+        }
+        return PlotSquared.get().getPlotAreas(world);
+    }
+
+    /**
+     * Send a message to the console. The message supports color codes.
+     *
+     * @param message the message
+     * @see MainUtil#sendConsoleMessage(Captions, String...)
+     */
+    public void sendConsoleMessage(String message) {
+        PlotSquared.log(message);
+    }
+
+    /**
+     * Sends a message to the console.
+     *
+     * @param caption the message
+     * @see #sendConsoleMessage(String)
+     * @see Captions
+     */
+    public void sendConsoleMessage(Caption caption) {
+        sendConsoleMessage(caption.getTranslated());
+    }
+
+    /**
+     * Gets the PlotSquared class.
+     *
+     * @return PlotSquared Class
+     * @see PlotSquared
+     */
+    public PlotSquared getPlotSquared() {
+        return PlotSquared.get();
+    }
+
+    /**
+     * Gets the PlotPlayer for a UUID.
+     *
+     * <p><i>Please note that PlotSquared can be configured to provide
+     * different UUIDs than bukkit</i>
+     *
+     * @param uuid the uuid of the player to wrap
+     * @return a {@code PlotPlayer}
+     * @see PlotPlayer#wrap(Object)
+     */
+    public PlotPlayer wrapPlayer(UUID uuid) {
+        return PlotPlayer.wrap(uuid);
+    }
+
+    /**
+     * Gets the PlotPlayer for a username.
+     *
+     * @param player the player to wrap
+     * @return a {@code PlotPlayer}
+     * @see PlotPlayer#wrap(Object)
+     */
+    public PlotPlayer wrapPlayer(String player) {
+        return PlotPlayer.wrap(player);
+    }
+
+    /**
+     * Registers a listener for PlotSquared Events
+     *
+     * @param listener the listener class to register
+     * @see EventDispatcher#registerListener(Object)
+     */
+    public void registerListener(Object listener) {
+        PlotSquared.get().getEventDispatcher().registerListener(listener);
+    }
+}

Core/src/main/java/com/plotsquared/core/backup/Backup.java

@@ -0,0 +1,60 @@
+/*
+ *       _____  _       _    _____                                _
+ *      |  __ \| |     | |  / ____|                              | |
+ *      | |__) | | ___ | |_| (___   __ _ _   _  __ _ _ __ ___  __| |
+ *      |  ___/| |/ _ \| __|\___ \ / _` | | | |/ _` | '__/ _ \/ _` |
+ *      | |    | | (_) | |_ ____) | (_| | |_| | (_| | | |  __/ (_| |
+ *      |_|    |_|\___/ \__|_____/ \__, |\__,_|\__,_|_|  \___|\__,_|
+ *                                    | |
+ *                                    |_|
+ *            PlotSquared plot management system for Minecraft
+ *                  Copyright (C) 2021 IntellectualSites
+ *
+ *     This program is free software: you can redistribute it and/or modify
+ *     it under the terms of the GNU 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 General Public License for more details.
+ *
+ *     You should have received a copy of the GNU General Public License
+ *     along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package com.plotsquared.core.backup;
+
+import lombok.AccessLevel;
+import lombok.Getter;
+import lombok.RequiredArgsConstructor;
+import org.jetbrains.annotations.Nullable;
+
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+
+/**
+ * Object representing a plot backup. This does not actually contain the
+ * backup itself, it is just a pointer to an available backup
+ */
+@RequiredArgsConstructor(access = AccessLevel.PACKAGE) @Getter public class Backup {
+
+    private final BackupProfile owner;
+    private final long creationTime;
+    @Nullable private final Path file;
+
+    /**
+     * Delete the backup
+     */
+    public void delete() {
+        if (file != null) {
+            try {
+                Files.deleteIfExists(file);
+            } catch (final IOException e) {
+                e.printStackTrace();
+            }
+        }
+    }
+
+}

Core/src/main/java/com/plotsquared/core/backup/BackupManager.java

@@ -0,0 +1,95 @@
+/*
+ *       _____  _       _    _____                                _
+ *      |  __ \| |     | |  / ____|                              | |
+ *      | |__) | | ___ | |_| (___   __ _ _   _  __ _ _ __ ___  __| |
+ *      |  ___/| |/ _ \| __|\___ \ / _` | | | |/ _` | '__/ _ \/ _` |
+ *      | |    | | (_) | |_ ____) | (_| | |_| | (_| | | |  __/ (_| |
+ *      |_|    |_|\___/ \__|_____/ \__, |\__,_|\__,_|_|  \___|\__,_|
+ *                                    | |
+ *                                    |_|
+ *            PlotSquared plot management system for Minecraft
+ *                  Copyright (C) 2021 IntellectualSites
+ *
+ *     This program is free software: you can redistribute it and/or modify
+ *     it under the terms of the GNU 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 General Public License for more details.
+ *
+ *     You should have received a copy of the GNU General Public License
+ *     along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package com.plotsquared.core.backup;
+
+import com.plotsquared.core.PlotSquared;
+import com.plotsquared.core.player.PlotPlayer;
+import com.plotsquared.core.plot.Plot;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.nio.file.Path;
+import java.util.Objects;
+
+public interface BackupManager {
+
+    /**
+     * This will perform an automatic backup of the plot iff the plot has an owner,
+     * automatic backups are enabled and the plot is not merged.
+     * Otherwise it will complete immediately.
+     *
+     * @param player   Player that triggered the backup
+     * @param plot     Plot to perform the automatic backup on
+     * @param whenDone Action that runs when the automatic backup has been completed
+     */
+    static void backup(@Nullable PlotPlayer player, @NotNull final Plot plot, @NotNull Runnable whenDone) {
+        Objects.requireNonNull(PlotSquared.imp()).getBackupManager().automaticBackup(player, plot, whenDone);
+    }
+
+    /**
+     * Get the backup profile for a plot based on its
+     * current owner (if there is one)
+     *
+     * @param plot Plot to get the backup profile for
+     * @return Backup profile
+     */
+    @NotNull BackupProfile getProfile(@NotNull final Plot plot);
+
+    /**
+     * This will perform an automatic backup of the plot iff the plot has an owner,
+     * automatic backups are enabled and the plot is not merged.
+     * Otherwise it will complete immediately.
+     *
+     * @param player   Player that triggered the backup
+     * @param plot     Plot to perform the automatic backup on
+     * @param whenDone Action that runs when the automatic backup has been completed
+     */
+    void automaticBackup(@Nullable PlotPlayer player, @NotNull final Plot plot, @NotNull Runnable whenDone);
+
+    /**
+     * Get the directory in which backups are stored
+     *
+     * @return Backup directory path
+     */
+    @NotNull Path getBackupPath();
+
+    /**
+     * Get the maximum amount of backups that may be stored for
+     * a plot-owner combo
+     *
+     * @return Backup limit
+     */
+    int getBackupLimit();
+
+    /**
+     * Returns true if (potentially) destructive actions should cause
+     * PlotSquared to create automatic plot backups
+     *
+     * @return True if automatic backups are enabled
+     */
+    boolean shouldAutomaticallyBackup();
+
+}

Core/src/main/java/com/plotsquared/core/backup/BackupProfile.java

@@ -0,0 +1,72 @@
+/*
+ *       _____  _       _    _____                                _
+ *      |  __ \| |     | |  / ____|                              | |
+ *      | |__) | | ___ | |_| (___   __ _ _   _  __ _ _ __ ___  __| |
+ *      |  ___/| |/ _ \| __|\___ \ / _` | | | |/ _` | '__/ _ \/ _` |
+ *      | |    | | (_) | |_ ____) | (_| | |_| | (_| | | |  __/ (_| |
+ *      |_|    |_|\___/ \__|_____/ \__, |\__,_|\__,_|_|  \___|\__,_|
+ *                                    | |
+ *                                    |_|
+ *            PlotSquared plot management system for Minecraft
+ *                  Copyright (C) 2021 IntellectualSites
+ *
+ *     This program is free software: you can redistribute it and/or modify
+ *     it under the terms of the GNU 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 General Public License for more details.
+ *
+ *     You should have received a copy of the GNU General Public License
+ *     along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package com.plotsquared.core.backup;
+
+import org.jetbrains.annotations.NotNull;
+
+import java.nio.file.Path;
+import java.util.List;
+import java.util.concurrent.CompletableFuture;
+
+public interface BackupProfile {
+
+    /**
+     * Asynchronously populate a list of available backups under this profile
+     *
+     * @return Future that will be completed with available backups
+     */
+    @NotNull CompletableFuture<List<Backup>> listBackups();
+
+    /**
+     * Remove all backups stored for this profile
+     */
+    void destroy();
+
+    /**
+     * Get the directory containing the backups for this profile.
+     * This directory may not actually exist.
+     *
+     * @return Folder that contains the backups for this profile
+     */
+    @NotNull Path getBackupDirectory();
+
+    /**
+     * Create a backup of the plot. If the profile is at the
+     * maximum backup capacity, the oldest backup will be deleted.
+     *
+     * @return Future that completes with the created backup.
+     */
+    @NotNull CompletableFuture<Backup> createBackup();
+
+    /**
+     * Restore a backup
+     *
+     * @param backup Backup to restore
+     * @return Future that completes when the backup has finished
+     */
+    @NotNull CompletableFuture<Void> restoreBackup(@NotNull final Backup backup);
+
+}

Core/src/main/java/com/plotsquared/core/backup/NullBackupManager.java

@@ -0,0 +1,63 @@
+/*
+ *       _____  _       _    _____                                _
+ *      |  __ \| |     | |  / ____|                              | |
+ *      | |__) | | ___ | |_| (___   __ _ _   _  __ _ _ __ ___  __| |
+ *      |  ___/| |/ _ \| __|\___ \ / _` | | | |/ _` | '__/ _ \/ _` |
+ *      | |    | | (_) | |_ ____) | (_| | |_| | (_| | | |  __/ (_| |
+ *      |_|    |_|\___/ \__|_____/ \__, |\__,_|\__,_|_|  \___|\__,_|
+ *                                    | |
+ *                                    |_|
+ *            PlotSquared plot management system for Minecraft
+ *                  Copyright (C) 2021 IntellectualSites
+ *
+ *     This program is free software: you can redistribute it and/or modify
+ *     it under the terms of the GNU 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 General Public License for more details.
+ *
+ *     You should have received a copy of the GNU General Public License
+ *     along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package com.plotsquared.core.backup;
+
+import com.plotsquared.core.PlotSquared;
+import com.plotsquared.core.player.PlotPlayer;
+import com.plotsquared.core.plot.Plot;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.nio.file.Path;
+import java.util.Objects;
+
+/**
+ * {@inheritDoc}
+ */
+public class NullBackupManager implements BackupManager {
+
+    @Override @NotNull public BackupProfile getProfile(@NotNull Plot plot) {
+        return new NullBackupProfile();
+    }
+
+    @Override public void automaticBackup(@Nullable PlotPlayer plotPlayer,
+        @NotNull Plot plot, @NotNull Runnable whenDone) {
+        whenDone.run();
+    }
+
+    @Override @NotNull public Path getBackupPath() {
+        return Objects.requireNonNull(PlotSquared.imp()).getDirectory().toPath();
+    }
+
+    @Override public int getBackupLimit() {
+        return 0;
+    }
+
+    @Override public boolean shouldAutomaticallyBackup() {
+        return false;
+    }
+
+}

Core/src/main/java/com/plotsquared/core/backup/NullBackupProfile.java

@@ -0,0 +1,61 @@
+/*
+ *       _____  _       _    _____                                _
+ *      |  __ \| |     | |  / ____|                              | |
+ *      | |__) | | ___ | |_| (___   __ _ _   _  __ _ _ __ ___  __| |
+ *      |  ___/| |/ _ \| __|\___ \ / _` | | | |/ _` | '__/ _ \/ _` |
+ *      | |    | | (_) | |_ ____) | (_| | |_| | (_| | | |  __/ (_| |
+ *      |_|    |_|\___/ \__|_____/ \__, |\__,_|\__,_|_|  \___|\__,_|
+ *                                    | |
+ *                                    |_|
+ *            PlotSquared plot management system for Minecraft
+ *                  Copyright (C) 2021 IntellectualSites
+ *
+ *     This program is free software: you can redistribute it and/or modify
+ *     it under the terms of the GNU 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 General Public License for more details.
+ *
+ *     You should have received a copy of the GNU General Public License
+ *     along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package com.plotsquared.core.backup;
+
+import org.jetbrains.annotations.NotNull;
+
+import java.io.File;
+import java.nio.file.Path;
+import java.util.Collections;
+import java.util.List;
+import java.util.concurrent.CompletableFuture;
+
+/**
+ * Backup profile for a plot without an owner
+ * {@inheritDoc}
+ */
+public class NullBackupProfile implements BackupProfile {
+
+    @Override @NotNull public CompletableFuture<List<Backup>> listBackups() {
+        return CompletableFuture.completedFuture(Collections.emptyList());
+    }
+
+    @Override public void destroy(){
+    }
+
+    @Override @NotNull public Path getBackupDirectory() {
+        return new File(".").toPath();
+    }
+
+    @Override @NotNull public CompletableFuture<Backup> createBackup() {
+        throw new UnsupportedOperationException("Cannot create backup of an unowned plot");
+    }
+
+    @Override @NotNull public CompletableFuture<Void> restoreBackup(@NotNull final Backup backup) {
+        return CompletableFuture.completedFuture(null);
+    }
+
+}

Core/src/main/java/com/plotsquared/core/backup/PlayerBackupProfile.java

@@ -0,0 +1,186 @@
+/*
+ *       _____  _       _    _____                                _
+ *      |  __ \| |     | |  / ____|                              | |
+ *      | |__) | | ___ | |_| (___   __ _ _   _  __ _ _ __ ___  __| |
+ *      |  ___/| |/ _ \| __|\___ \ / _` | | | |/ _` | '__/ _ \/ _` |
+ *      | |    | | (_) | |_ ____) | (_| | |_| | (_| | | |  __/ (_| |
+ *      |_|    |_|\___/ \__|_____/ \__, |\__,_|\__,_|_|  \___|\__,_|
+ *                                    | |
+ *                                    |_|
+ *            PlotSquared plot management system for Minecraft
+ *                  Copyright (C) 2021 IntellectualSites
+ *
+ *     This program is free software: you can redistribute it and/or modify
+ *     it under the terms of the GNU 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 General Public License for more details.
+ *
+ *     You should have received a copy of the GNU General Public License
+ *     along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package com.plotsquared.core.backup;
+
+import com.plotsquared.core.configuration.Captions;
+import com.plotsquared.core.plot.Plot;
+import com.plotsquared.core.plot.schematic.Schematic;
+import com.plotsquared.core.util.SchematicHandler;
+import com.plotsquared.core.util.task.RunnableVal;
+import com.plotsquared.core.util.task.TaskManager;
+import lombok.RequiredArgsConstructor;
+import org.jetbrains.annotations.NotNull;
+
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.attribute.BasicFileAttributes;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.List;
+import java.util.Objects;
+import java.util.UUID;
+import java.util.concurrent.CompletableFuture;
+
+/**
+ * A profile associated with a player (normally a plot owner) and a
+ * plot, which is used to store and retrieve plot backups
+ * {@inheritDoc}
+ */
+@RequiredArgsConstructor
+public class PlayerBackupProfile implements BackupProfile {
+
+    private final UUID owner;
+    private final Plot plot;
+    private final BackupManager backupManager;
+
+    private volatile List<Backup> backupCache;
+    private final Object backupLock = new Object();
+
+    private static boolean isValidFile(@NotNull final Path path) {
+        final String name = path.getFileName().toString();
+        return name.endsWith(".schem") || name.endsWith(".schematic");
+    }
+
+    @Override @NotNull public CompletableFuture<List<Backup>> listBackups() {
+        synchronized (this.backupLock) {
+            if (this.backupCache != null) {
+                return CompletableFuture.completedFuture(backupCache);
+            }
+            return CompletableFuture.supplyAsync(() -> {
+                final Path path = this.getBackupDirectory();
+                if (!Files.exists(path)) {
+                    try {
+                        Files.createDirectories(path);
+                    } catch (IOException e) {
+                        e.printStackTrace();
+                        return Collections.emptyList();
+                    }
+                }
+                final List<Backup> backups = new ArrayList<>();
+                try {
+                    Files.walk(path).filter(PlayerBackupProfile::isValidFile).forEach(file -> {
+                        try {
+                            final BasicFileAttributes basicFileAttributes =
+                                Files.readAttributes(file, BasicFileAttributes.class);
+                            backups.add(
+                                new Backup(this, basicFileAttributes.creationTime().toMillis(), file));
+                        } catch (IOException e) {
+                            e.printStackTrace();
+                        }
+                    });
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+                backups.sort(Comparator.comparingLong(Backup::getCreationTime).reversed());
+                return (this.backupCache = backups);
+            });
+        }
+    }
+
+    @Override public void destroy() {
+        this.listBackups().whenCompleteAsync((backups, error) -> {
+           if (error != null) {
+               error.printStackTrace();
+           }
+           backups.forEach(Backup::delete);
+           this.backupCache = null;
+        });
+    }
+
+    @NotNull public Path getBackupDirectory() {
+        return resolve(resolve(resolve(backupManager.getBackupPath(), Objects.requireNonNull(plot.getArea().toString(), "plot area id")),
+            Objects.requireNonNull(plot.getId().toDashSeparatedString(), "plot id")), Objects.requireNonNull(owner.toString(), "owner"));
+    }
+
+    private static Path resolve(@NotNull final Path parent, final String child) {
+        Path path = parent;
+        try {
+            if (!Files.exists(parent)) {
+                Files.createDirectory(parent);
+            }
+            path = parent.resolve(child);
+            if (!Files.exists(path)) {
+                Files.createDirectory(path);
+            }
+        } catch (final Exception e) {
+            e.printStackTrace();
+        }
+        return path;
+    }
+
+    @Override @NotNull public CompletableFuture<Backup> createBackup() {
+        final CompletableFuture<Backup> future = new CompletableFuture<>();
+        this.listBackups().thenAcceptAsync(backups -> {
+            synchronized (this.backupLock) {
+                if (backups.size() == backupManager.getBackupLimit()) {
+                    backups.get(backups.size() - 1).delete();
+                }
+                final List<Plot> plots = Collections.singletonList(plot);
+                final boolean result = SchematicHandler.manager.exportAll(plots, getBackupDirectory().toFile(),
+                    "%world%-%id%-" + System.currentTimeMillis(), () ->
+                    future.complete(new Backup(this, System.currentTimeMillis(), null)));
+                if (!result) {
+                    future.completeExceptionally(new RuntimeException("Failed to complete the backup"));
+                }
+                this.backupCache = null;
+            }
+        });
+        return future;
+    }
+
+    @Override @NotNull public CompletableFuture<Void> restoreBackup(@NotNull final Backup backup) {
+        final CompletableFuture<Void> future = new CompletableFuture<>();
+        if (backup.getFile() == null || !Files.exists(backup.getFile())) {
+            future.completeExceptionally(new IllegalArgumentException("The specific backup does not exist"));
+        } else {
+            TaskManager.runTaskAsync(() -> {
+                Schematic schematic = null;
+                try {
+                    schematic = SchematicHandler.manager.getSchematic(backup.getFile().toFile());
+                } catch (SchematicHandler.UnsupportedFormatException e) {
+                    e.printStackTrace();
+                }
+                if (schematic == null) {
+                    future.completeExceptionally(new IllegalArgumentException("The backup is non-existent or not in the correct format"));
+                } else {
+                    SchematicHandler.manager.paste(schematic, plot, 0, 1, 0, false, new RunnableVal<Boolean>() {
+                        @Override public void run(Boolean value) {
+                            if (value) {
+                                future.complete(null);
+                            } else {
+                                future.completeExceptionally(new RuntimeException(Captions.SCHEMATIC_PASTE_FAILED.toString()));
+                            }
+                        }
+                    });
+                }
+            });
+        }
+        return future;
+    }
+
+}

Core/src/main/java/com/plotsquared/core/backup/SimpleBackupManager.java

@@ -0,0 +1,131 @@
+/*
+ *       _____  _       _    _____                                _
+ *      |  __ \| |     | |  / ____|                              | |
+ *      | |__) | | ___ | |_| (___   __ _ _   _  __ _ _ __ ___  __| |
+ *      |  ___/| |/ _ \| __|\___ \ / _` | | | |/ _` | '__/ _ \/ _` |
+ *      | |    | | (_) | |_ ____) | (_| | |_| | (_| | | |  __/ (_| |
+ *      |_|    |_|\___/ \__|_____/ \__, |\__,_|\__,_|_|  \___|\__,_|
+ *                                    | |
+ *                                    |_|
+ *            PlotSquared plot management system for Minecraft
+ *                  Copyright (C) 2021 IntellectualSites
+ *
+ *     This program is free software: you can redistribute it and/or modify
+ *     it under the terms of the GNU 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 General Public License for more details.
+ *
+ *     You should have received a copy of the GNU General Public License
+ *     along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package com.plotsquared.core.backup;
+
+import com.google.common.cache.Cache;
+import com.google.common.cache.CacheBuilder;
+import com.plotsquared.core.PlotSquared;
+import com.plotsquared.core.configuration.Captions;
+import com.plotsquared.core.configuration.Settings;
+import com.plotsquared.core.player.PlotPlayer;
+import com.plotsquared.core.plot.Plot;
+import com.plotsquared.core.util.task.TaskManager;
+import lombok.AccessLevel;
+import lombok.Getter;
+import lombok.RequiredArgsConstructor;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.Objects;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+
+/**
+ * {@inheritDoc}
+ */
+@RequiredArgsConstructor public class SimpleBackupManager implements BackupManager {
+
+    @Getter private final Path backupPath;
+    private final boolean automaticBackup;
+    @Getter private final int backupLimit;
+    private final Cache<PlotCacheKey, BackupProfile> backupProfileCache = CacheBuilder.newBuilder()
+        .expireAfterAccess(3, TimeUnit.MINUTES).build();
+
+    public SimpleBackupManager() throws Exception {
+        this.backupPath = Objects.requireNonNull(PlotSquared.imp()).getDirectory().toPath().resolve("backups");
+        if (!Files.exists(backupPath)) {
+            Files.createDirectory(backupPath);
+        }
+        this.automaticBackup = Settings.Backup.AUTOMATIC_BACKUPS;
+        this.backupLimit = Settings.Backup.BACKUP_LIMIT;
+    }
+
+    @Override @NotNull public BackupProfile getProfile(@NotNull final Plot plot) {
+        if (plot.hasOwner() && !plot.isMerged()) {
+            try {
+                return backupProfileCache.get(new PlotCacheKey(plot), () -> new PlayerBackupProfile(plot.getOwnerAbs(), plot, this));
+            } catch (ExecutionException e) {
+                final BackupProfile profile = new PlayerBackupProfile(plot.getOwnerAbs(), plot, this);
+                this.backupProfileCache.put(new PlotCacheKey(plot), profile);
+                return profile;
+            }
+        }
+        return new NullBackupProfile();
+    }
+
+    @Override public void automaticBackup(@Nullable PlotPlayer player, @NotNull final Plot plot, @NotNull Runnable whenDone) {
+        final BackupProfile profile;
+        if (!this.shouldAutomaticallyBackup() || (profile = getProfile(plot)) instanceof NullBackupProfile) {
+            whenDone.run();
+        } else {
+            if (player != null) {
+                Captions.BACKUP_AUTOMATIC_STARTED.send(player);
+            }
+            profile.createBackup().whenComplete((backup, throwable) -> {
+               if (throwable != null) {
+                   if (player != null) {
+                       Captions.BACKUP_AUTOMATIC_FAILURE.send(player, throwable.getMessage());
+                   }
+                   throwable.printStackTrace();
+               } else {
+                   if (player != null) {
+                       Captions.BACKUP_AUTOMATIC_FINISHED.send(player);
+                       TaskManager.runTaskAsync(whenDone);
+                   }
+               }
+            });
+        }
+    }
+
+    @Override public boolean shouldAutomaticallyBackup() {
+        return this.automaticBackup;
+    }
+
+    @RequiredArgsConstructor(access = AccessLevel.PRIVATE) private static final class PlotCacheKey {
+
+        private final Plot plot;
+
+        @Override public boolean equals(final Object o) {
+            if (this == o) {
+                return true;
+            }
+            if (o == null || getClass() != o.getClass()) {
+                return false;
+            }
+            final PlotCacheKey that = (PlotCacheKey) o;
+            return Objects.equals(plot.getArea(), that.plot.getArea())
+                && Objects.equals(plot.getId(), that.plot.getId())
+                && Objects.equals(plot.getOwnerAbs(), that.plot.getOwnerAbs());
+        }
+
+        @Override public int hashCode() {
+            return Objects.hash(plot.getArea(), plot.getId(), plot.getOwnerAbs());
+        }
+    }
+
+}

Core/src/main/java/com/plotsquared/core/collection/ArrayUtil.java

@@ -0,0 +1,44 @@
+/*
+ *       _____  _       _    _____                                _
+ *      |  __ \| |     | |  / ____|                              | |
+ *      | |__) | | ___ | |_| (___   __ _ _   _  __ _ _ __ ___  __| |
+ *      |  ___/| |/ _ \| __|\___ \ / _` | | | |/ _` | '__/ _ \/ _` |
+ *      | |    | | (_) | |_ ____) | (_| | |_| | (_| | | |  __/ (_| |
+ *      |_|    |_|\___/ \__|_____/ \__, |\__,_|\__,_|_|  \___|\__,_|
+ *                                    | |
+ *                                    |_|
+ *            PlotSquared plot management system for Minecraft
+ *                  Copyright (C) 2021 IntellectualSites
+ *
+ *     This program is free software: you can redistribute it and/or modify
+ *     it under the terms of the GNU 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 General Public License for more details.
+ *
+ *     You should have received a copy of the GNU General Public License
+ *     along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package com.plotsquared.core.collection;
+
+import java.util.Arrays;
+
+public class ArrayUtil {
+    public static final <T> T[] concatAll(T[] first, T[]... rest) {
+        int totalLength = first.length;
+        for (T[] array : rest) {
+            totalLength += array.length;
+        }
+        T[] result = Arrays.copyOf(first, totalLength);
+        int offset = first.length;
+        for (T[] array : rest) {
+            System.arraycopy(array, 0, result, offset, array.length);
+            offset += array.length;
+        }
+        return result;
+    }
+}