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

@@ -1,2 +0,0 @@
-### Bugs
-Please provide a `/plot debugpaste` if you are reporting a bug.

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

@@ -1,12 +0,0 @@
-# Bug report template (Follow this template unless you are making a feature request.)
-**Debug paste link**:
-
-**Description of the problem:**
-
-**How to replicate**:
-
-Make sure you've completed the following steps (put an X between of brackets):
-- [] Include `/plot debugpaste`
-- [] Made sure there aren't duplicates of this report [(Use Search)](https://github.com/IntellectualSites/PlotSquared/issues)
-- [] Made sure you're using an updated version of PlotSquared
-- [] Made sure the bug/error isn't caused by any other plugin

.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 @@
-### Others ###
-*.bat
-*.cmd
-*.sh
-*.prefs
-Sponge/build
-Core/build
-Bukkit/build
-
-### Maven ###
-/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
-
-
-### Java ###
-*.class
-
-# Mobile Tools for Java (J2ME)
-.mtj.tmp/
-
-# Package Files #
-*.jar
-*.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
+### 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

@@ -1,38 +1,125 @@
-dependencies {
-    compile project(':Core')
-    compile 'org.bukkit:bukkit:1.9-R0.1-SNAPSHOT'
-    compile 'org.mcstats.bukkit:metrics:R7'
-    compile 'net.milkbowl.vault:VaultAPI:1.5'
+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()
 }
 
-sourceCompatibility = 1.7
-targetCompatibility = 1.7
+
+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'
+    from("src/main/resources") {
+        include("plugin.yml")
         expand(
-            name: project.parent.name,
-            version: project.parent.version
+                name: project.parent.name,
+                version: project.parent.version
         )
     }
 }
 
-apply plugin: 'com.github.johnrengelman.shadow'
-// We only want the shadow jar produced
-jar.enabled = false
-shadowJar {
-    dependencies {
-        include(dependency(':Core'))
-        include(dependency('org.mcstats.bukkit:metrics:R7'))
+//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")
     }
-    relocate 'org.mcstats', 'com.plotsquared.stats'
-    archiveName = "${parent.name}-${project.name}-${parent.version}.jar"
-    destinationDir = file '../target'
-}
-shadowJar.doLast {
-    task ->
-    ant.checksum file: task.archivePath
 }
 
-build.dependsOn(shadowJar);
+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/intellectualcrafters/plot/api/PlotAPI.java

@@ -1,760 +0,0 @@
-package com.intellectualcrafters.plot.api;
-
-import com.intellectualcrafters.configuration.file.YamlConfiguration;
-import com.intellectualcrafters.plot.PS;
-import com.intellectualcrafters.plot.commands.SubCommand;
-import com.intellectualcrafters.plot.config.C;
-import com.intellectualcrafters.plot.flag.AbstractFlag;
-import com.intellectualcrafters.plot.flag.FlagManager;
-import com.intellectualcrafters.plot.object.Plot;
-import com.intellectualcrafters.plot.object.PlotArea;
-import com.intellectualcrafters.plot.object.PlotId;
-import com.intellectualcrafters.plot.object.PlotManager;
-import com.intellectualcrafters.plot.object.PlotPlayer;
-import com.intellectualcrafters.plot.util.ChunkManager;
-import com.intellectualcrafters.plot.util.MainUtil;
-import com.intellectualcrafters.plot.util.SchematicHandler;
-import com.intellectualcrafters.plot.util.SetQueue;
-import com.intellectualcrafters.plot.util.UUIDHandler;
-import com.intellectualcrafters.plot.uuid.UUIDWrapper;
-import com.plotsquared.bukkit.util.BukkitUtil;
-import org.bukkit.Location;
-import org.bukkit.OfflinePlayer;
-import org.bukkit.World;
-import org.bukkit.entity.Player;
-import org.bukkit.plugin.java.JavaPlugin;
-
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.HashSet;
-import java.util.Set;
-import java.util.UUID;
-
-/**
- * PlotSquared API.
- * <br>
- * <br>
- * Useful classes:<br>
- * @see BukkitUtil
- * @see PlotPlayer
- * @see Plot
- * @see com.intellectualcrafters.plot.object.Location
- * @see PlotArea
- * @see PS
- * @version 3.3.3
->>>>>>> origin/master
- */
-public class PlotAPI {
-
-    /**
-     * Permission that allows for admin access, this permission node will allow
-     * the player to use any part of the plugin, without limitations.
-     * @deprecated Use C.PERMISSION_ADMIN instead
-     */
-    @Deprecated
-    public static final String ADMIN_PERMISSION = C.PERMISSION_ADMIN.s();
-
-    /**
-     * Deprecated, does nothing.
-     * @param plugin not needed
-     * @deprecated Not needed
-     */
-    @Deprecated
-    public PlotAPI(JavaPlugin plugin) {
-    }
-
-    /**
-     * Default Constructor that does nothing.
-     *
-     * @deprecated Use this class if you just want to do a few simple things
-     *      <ul>
-     *          <li>It will remain stable for future versions
-     *              of the plugin</li>
-     *          <li>The PlotPlayer and Plot class should be considered
-     *              relatively safe</li>
-     *          <li>For more advanced/intensive tasks you should consider
-     *              using other classes</li>
-     *      </ul>
-     *
-     */
-    @Deprecated
-    public PlotAPI() {
-    }
-
-    /**
-     * Get all plots.
-     *
-     * @return all plots
-     *
-     * @see PS#getPlots()
-     */
-    public Set<Plot> getAllPlots() {
-        return PS.get().getPlots();
-    }
-
-    /**
-     * Return all plots for a player.
-     *
-     * @param player Player, whose plots to search for
-     *
-     * @return all plots that a player owns
-     */
-    public Set<Plot> getPlayerPlots(Player player) {
-        return PS.get().getPlots(BukkitUtil.getPlayer(player));
-    }
-
-    /**
-     * Add a plot world.
-     *
-     * @param plotArea Plot World Object
-     * @see PS#addPlotArea(PlotArea)
-     */
-    public void addPlotArea(PlotArea plotArea) {
-        PS.get().addPlotArea(plotArea);
-    }
-
-    /**
-     * Returns the PlotSquared configurations file.
-     * @return main configuration
-     *
-     * @see PS#config
-     */
-    public YamlConfiguration getConfig() {
-        return PS.get().config;
-    }
-
-    /**
-     * Get the PlotSquared storage file.
-     * @return storage configuration
-     *
-     * @see PS#storage
-     */
-    public YamlConfiguration getStorage() {
-        return PS.get().storage;
-    }
-
-    /**
-     * Get the main class for this plugin. Only use this if you really need it.
-     *
-     * @return PlotSquared PlotSquared Main Class
-     *
-     * @see PS
-     */
-    public PS getMain() {
-        return PS.get();
-    }
-
-    /**
-     * 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 com.intellectualcrafters.plot.util.ChunkManager
-     */
-    public ChunkManager getChunkManager() {
-        return ChunkManager.manager;
-    }
-
-    /**
-     * Get the block/biome set queue
-     * @return SetQueue.IMP
-     */
-    public SetQueue getSetQueue() {
-        return SetQueue.IMP;
-    }
-
-    /**
-     * UUIDWrapper class has basic methods for getting UUIDS. It's recommended
-     * to use the UUIDHandler class instead.
-     *
-     * @return UUIDWrapper
-     *
-     * @see com.intellectualcrafters.plot.uuid.UUIDWrapper
-     */
-    public UUIDWrapper getUUIDWrapper() {
-        return UUIDHandler.getUUIDWrapper();
-    }
-
-    /**
-     * Do not use this. Instead use FlagManager.[method] in your code.
-     *  - Flag related stuff
-     *
-     * @return FlagManager
-     *
-     * @deprecated Use {@link FlagManager} directly
-     */
-    @Deprecated
-    public FlagManager getFlagManager() {
-        return new FlagManager();
-    }
-
-    /**
-     * Do not use this. Instead use MainUtil.[method] in your code.
-     *
-     * @return MainUtil
-     * @deprecated Use {@link MainUtil} directly
-     */
-    @Deprecated
-    public MainUtil getMainUtil() {
-        return new MainUtil();
-    }
-
-    /**
-     * Do not use this. Instead use C.PERMISSION_[method] in your code.
-     *
-     * @return Array of strings
-     *
-     * @see com.intellectualcrafters.plot.util.Permissions
-     * @deprecated Use {@link C} to list all the permissions
-     */
-    @Deprecated
-    public String[] getPermissions() {
-        ArrayList<String> perms = new ArrayList<>();
-        for (C c : C.values()) {
-            if ("static.permissions".equals(c.getCategory())) {
-                perms.add(c.s());
-            }
-        }
-        return perms.toArray(new String[perms.size()]);
-    }
-
-    /**
-     * SchematicHandler class contains methods related to pasting, reading
-     * and writing schematics.
-     *
-     * @return SchematicHandler
-     *
-     * @see com.intellectualcrafters.plot.util.SchematicHandler
-     */
-    public SchematicHandler getSchematicHandler() {
-        return SchematicHandler.manager;
-    }
-
-    /**
-     * Use C.[caption] instead
-     *
-     * @return C
-     * @deprecated Use {@link C}
-     */
-    @Deprecated
-    public C[] getCaptions() {
-        return C.values();
-    }
-
-    /**
-     * Get the plot manager for a world. Most of these methods can be accessed
-     * through the MainUtil.
-     *
-     * @param world Which manager to get
-     *
-     * @return PlotManager
-     *
-     * @see com.intellectualcrafters.plot.object.PlotManager
-     * @see PS#getPlotManager(Plot)
-     */
-    @Deprecated
-    public PlotManager getPlotManager(World world) {
-        if (world == null) {
-            return null;
-        }
-        return getPlotManager(world.getName());
-    }
-
-    /**
-     * Get 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(World world) {
-        if (world == null) {
-            return new HashSet<>();
-        }
-        return PS.get().getPlotAreas(world.getName());
-    }
-
-    /**
-     * Get the plot manager for a world. Contains useful low level methods for
-     * plot merging, clearing, and tessellation.
-     *
-     * @param world The world
-     *
-     * @return PlotManager
-     *
-     * @see PS#getPlotManager(Plot)
-     * @see com.intellectualcrafters.plot.object.PlotManager
-     */
-    @Deprecated
-    public PlotManager getPlotManager(String world) {
-        Set<PlotArea> areas = PS.get().getPlotAreas(world);
-        switch (areas.size()) {
-            case 0:
-                return null;
-            case 1:
-                return areas.iterator().next().manager;
-            default:
-                PS.debug("PlotAPI#getPlotManager(org.bukkit.World) is deprecated and doesn't support multi plot area worlds.");
-                return null;
-        }
-    }
-
-    /**
-     * Get the settings for a world (settings bundled in PlotArea class). You
-     * will need to downcast for the specific settings a Generator has. e.g.
-     * DefaultPlotWorld class implements PlotArea
-     *
-     * @param world The World
-     *
-     * @return The {@link PlotArea} for the world or null if not in plotworld
-     *
-     * @see #getPlotAreas(World)
-     * @see com.intellectualcrafters.plot.object.PlotArea
-     */
-    @Deprecated
-    public PlotArea getWorldSettings(World world) {
-        if (world == null) {
-            return null;
-        }
-        return getWorldSettings(world.getName());
-    }
-
-    /**
-     * Get the settings for a world.
-     *
-     * @param world The world
-     *
-     * @return The {@link PlotArea} for the world or null if not in plotworld
-     *
-     * @see PS#getPlotArea(String, String)
-     * @see com.intellectualcrafters.plot.object.PlotArea
-     */
-    @Deprecated
-    public PlotArea getWorldSettings(String world) {
-        if (world == null) {
-            return null;
-        }
-        Set<PlotArea> areas = PS.get().getPlotAreas(world);
-        switch (areas.size()) {
-            case 0:
-                return null;
-            case 1:
-                return areas.iterator().next();
-            default:
-                PS.debug("PlotAPI#getWorldSettings(org.bukkit.World) is deprecated and doesn't support multi plot area worlds.");
-                return null;
-        }
-    }
-
-    /**
-     * Send a message to a player.
-     *
-     * @param player Player that will receive the message
-     * @param caption Caption
-     *
-     * @see MainUtil#sendMessage(PlotPlayer, C, String...)
-     */
-    public void sendMessage(Player player, C caption) {
-        MainUtil.sendMessage(BukkitUtil.getPlayer(player), caption);
-    }
-
-    /**
-     * Send a message to a player. Supports color codes.
-     *
-     * @param player Player that will receive the message
-     * @param string The message
-     *
-     * @see MainUtil#sendMessage(PlotPlayer, String)
-     */
-    public void sendMessage(Player player, String string) {
-        MainUtil.sendMessage(BukkitUtil.getPlayer(player), string);
-    }
-
-    /**
-     * Send a message to the console. Supports color codes.
-     *
-     * @param message Message that should be sent to the console
-     *
-     * @see MainUtil#sendConsoleMessage(C, String...)
-     */
-    public void sendConsoleMessage(String message) {
-        PS.log(message);
-    }
-
-    /**
-     * Send a message to the console.
-     *
-     * @param caption The caption
-     *
-     * @see #sendConsoleMessage(String)
-     * @see com.intellectualcrafters.plot.config.C
-     */
-    public void sendConsoleMessage(C caption) {
-        sendConsoleMessage(caption.s());
-    }
-
-    /**
-     * Register a flag for use in plots.
-     *
-     * @param flag Flag that should be registered
-     *
-     * @see com.intellectualcrafters.plot.flag.FlagManager#addFlag(com.intellectualcrafters.plot.flag.AbstractFlag)
-     * @see com.intellectualcrafters.plot.flag.AbstractFlag
-     */
-    public void addFlag(AbstractFlag flag) {
-        FlagManager.addFlag(flag);
-    }
-
-    /**
-     * get all the currently registered flags.
-     *
-     * @return array of Flag[]
-     *
-     * @see com.intellectualcrafters.plot.flag.FlagManager#getFlags()
-     * @see com.intellectualcrafters.plot.flag.AbstractFlag
-     */
-    public AbstractFlag[] getFlags() {
-        return FlagManager.getFlags().toArray(new AbstractFlag[FlagManager.getFlags().size()]);
-    }
-
-    /**
-     * Get a plot based on the ID.
-     *
-     * @param world World in which the plot is located
-     * @param x The PlotID x coordinate
-     * @param z The PlotID y coordinate
-     *
-     * @return plot, null if ID is wrong
-     *
-     * @see PlotArea#getPlot(PlotId)
-     */
-    @Deprecated
-    public Plot getPlot(World world, int x, int z) {
-        if (world == null) {
-            return null;
-        }
-        PlotArea area = getWorldSettings(world);
-        if (area == null) {
-            return null;
-        }
-        return area.getPlot(new PlotId(x, z));
-    }
-
-    /**
-     * Get a plot based on the location.
-     *
-     * @param location The location to retrieve the plot from
-     *
-     * @return plot if found, otherwise it creates a temporary plot
-     *
-     * @see Plot
-     */
-    public Plot getPlot(Location location) {
-        if (location == null) {
-            return null;
-        }
-        return BukkitUtil.getLocation(location).getPlot();
-    }
-
-    /**
-     * Get a plot based on the player location.
-     *
-     * @param player Get the current plot for the player location
-     *
-     * @return plot if found, otherwise it creates a temporary plot
-     *
-     * @see #getPlot(org.bukkit.Location)
-     * @see Plot
-     */
-    public Plot getPlot(Player player) {
-        return this.getPlot(player.getLocation());
-    }
-
-    /**
-     * Check whether or not a player has a plot.
-     *
-     * @param player Player that you want to check for
-     * @param world The world to check
-     * @return true if player has a plot, false if not.
-     *
-     * @see #getPlots(World, Player, boolean)
-     */
-    @Deprecated
-    public boolean hasPlot(World world, Player player) {
-        return getPlots(world, player, true).length > 0;
-    }
-
-    /**
-     * Get all plots for the player.
-     *
-     * @param world The world to retrieve plots from
-     * @param player The player to search for
-     * @param justOwner should we just search for owner? Or with rights?
-     * @return An array of plots for the player
-     */
-    @Deprecated
-    public Plot[] getPlots(World world, Player player, boolean justOwner) {
-        ArrayList<Plot> pPlots = new ArrayList<>();
-        UUID uuid = BukkitUtil.getPlayer(player).getUUID();
-        for (Plot plot : PS.get().getPlots(world.getName())) {
-            if (justOwner) {
-                if (plot.hasOwner() && plot.isOwner(uuid)) {
-                    pPlots.add(plot);
-                }
-            } else if (plot.isAdded(uuid)) {
-                pPlots.add(plot);
-            }
-        }
-        return pPlots.toArray(new Plot[pPlots.size()]);
-    }
-
-    /**
-     * Get all plots for the world.
-     *
-     * @param world to get plots of
-     *
-     * @return Plot[] - array of plot objects in world
-     *
-     * @see PS#getPlots(String)
-     * @see Plot
-     */
-    @Deprecated
-    public Plot[] getPlots(World world) {
-        if (world == null) {
-            return new Plot[0];
-        }
-        Collection<Plot> plots = PS.get().getPlots(world.getName());
-        return plots.toArray(new Plot[plots.size()]);
-    }
-
-    /**
-     * Get all plot worlds.
-     *
-     * @return World[] - array of plot worlds
-     *
-     */
-    @Deprecated
-    public String[] getPlotWorlds() {
-        Set<String> plotWorldStrings = PS.get().getPlotWorldStrings();
-        return plotWorldStrings.toArray(new String[plotWorldStrings.size()]);
-    }
-
-    /**
-     * Get if plotworld.
-     *
-     * @param world The world to check
-     *
-     * @return boolean (if plot world or not)
-     *
-     * @see PS#hasPlotArea(String)
-     */
-    @Deprecated
-    public boolean isPlotWorld(World world) {
-        return PS.get().hasPlotArea(world.getName());
-    }
-
-    /**
-     * Get plot locations.
-     *
-     * @param plot Plot to get the locations for
-     *
-     * @return [0] = bottomLc, [1] = topLoc, [2] = home
-     *
-     * @deprecated As merged plots may not have a rectangular shape
-     *
-     * @see Plot
-     */
-    @Deprecated
-    public Location[] getLocations(Plot plot) {
-        Location bukkitBottom = BukkitUtil.getLocation(plot.getCorners()[0]);
-        Location bukkitTop = BukkitUtil.getLocation(plot.getCorners()[1]);
-        Location bukkitHome = BukkitUtil.getLocation(plot.getHome());
-        return new Location[]{bukkitBottom, bukkitTop, bukkitHome};
-    }
-
-    /**
-     * Get home location.
-     *
-     * @param plot Plot that you want to get the location for
-     *
-     * @return plot bottom location
-     *
-     * @see Plot
-     */
-    public Location getHomeLocation(Plot plot) {
-        return BukkitUtil.getLocation(plot.getHome());
-    }
-
-    /**
-     * Get Bottom Location (min, min, min).
-     *
-     * @param plot Plot that you want to get the location for
-     *
-     * @return plot bottom location
-     *
-     * @deprecated As merged plots may not have a rectangular shape
-     *
-     * @see Plot
-     */
-    @Deprecated
-    public Location getBottomLocation(Plot plot) {
-        return BukkitUtil.getLocation(plot.getBottom());
-    }
-
-    /**
-     * Get Top Location (max, max, max).
-     *
-     * @param plot Plot that you want to get the location for
-     *
-     * @return plot top location
-     *
-     * @deprecated As merged plots may not have a rectangular shape
-     *
-     * @see Plot
-     */
-    @Deprecated
-    public Location getTopLocation(Plot plot) {
-        return BukkitUtil.getLocation(plot.getTop());
-    }
-
-    /**
-     * 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 boolean isInPlot(Player player) {
-        return getPlot(player) != null;
-    }
-
-    /**
-     * Register a subcommand.
-     * @deprecated Command registration is done on object creation
-     * @param c SubCommand, that we want to register
-     * @see com.intellectualcrafters.plot.commands.SubCommand
-     */
-    @Deprecated
-    public void registerCommand(SubCommand c) {
-        PS.debug("SubCommands are now registered on creation");
-    }
-
-    /**
-     * Get the PlotSquared class.
-     *
-     * @return PlotSquared Class
-     *
-     * @see PS
-     */
-    public PS getPlotSquared() {
-        return PS.get();
-    }
-
-    /**
-     * Get 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 int getPlayerPlotCount(World world, Player player) {
-        if (world == null) {
-            return 0;
-        }
-        return BukkitUtil.getPlayer(player).getPlotCount(world.getName());
-    }
-
-    /**
-     * Get 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 PS#getPlots(String, PlotPlayer)
-     *
-     * @see Plot
-     */
-    public Set<Plot> getPlayerPlots(World world, Player player) {
-        if (world == null) {
-            return new HashSet<>();
-        }
-        return BukkitUtil.getPlayer(player).getPlots(world.getName());
-    }
-
-    /**
-     * Get the numbers 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 int getAllowedPlots(Player player) {
-        PlotPlayer pp = BukkitUtil.getPlayer(player);
-        return pp.getAllowedPlots();
-    }
-
-    /**
-     * Get the PlotPlayer for a player. The PlotPlayer is usually cached and
-     * will provide useful functions relating to players.
-     *
-     * @see PlotPlayer#wrap(Object)
-     *
-     * @param player The player to wrap
-     * @return A PlotPlayer
-     */
-    public PlotPlayer wrapPlayer(Player player) {
-        return PlotPlayer.wrap(player);
-    }
-
-    /**
-     * Get the PlotPlayer for a UUID.
-     *
-     * <p><i>Please note that PlotSquared can be configured to provide
-     * different UUIDs than bukkit</i></p>
-     *
-     * @see PlotPlayer#wrap(Object)
-     *
-     * @param uuid The uuid of the player to wrap
-     * @return A PlotPlayer
-     */
-    public PlotPlayer wrapPlayer(UUID uuid) {
-        return PlotPlayer.wrap(uuid);
-    }
-
-    /**
-     * Get the PlotPlayer for a username.
-     *
-     * @see PlotPlayer#wrap(Object)
-     *
-     * @param player The player to wrap
-     * @return The PlotPlayer
-     */
-    public PlotPlayer wrapPlayer(String player) {
-        return PlotPlayer.wrap(player);
-    }
-
-    /**
-     * Get the PlotPlayer for an offline player.
-     * <p>Note that this will work if the player is offline, however not all
-     * functionality will work</p>
-     *
-     * @see PlotPlayer#wrap(Object)
-     *
-     * @param player The player to wrap
-     * @return The PlotPlayer
-     */
-    public PlotPlayer wrapPlayer(OfflinePlayer player) {
-        return PlotPlayer.wrap(player);
-    }
-}

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

@@ -1,3 +1,28 @@
+/*
+ *       _____  _       _    _____                                _
+ *      |  __ \| |     | |  / ____|                              | |
+ *      | |__) | | ___ | |_| (___   __ _ _   _  __ _ _ __ ___  __| |
+ *      |  ___/| |/ _ \| __|\___ \ / _` | | | |/ _` | '__/ _ \/ _` |
+ *      | |    | | (_) | |_ ____) | (_| | |_| | (_| | | |  __/ (_| |
+ *      |_|    |_|\___/ \__|_____/ \__, |\__,_|\__,_|_|  \___|\__,_|
+ *                                    | |
+ *                                    |_|
+ *            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;
@@ -12,16 +37,18 @@ import java.util.Collection;
  * <p>
  * This class is intended for use as a key to a map.
  * </p>
- * @author Glen Husman
+ *
  * @param <E> The type of elements in the array.
+ * @author Glen Husman
  * @see Arrays
  */
 public final class ArrayWrapper<E> {
 
-    private E[] array;
+    private E[] _array;
 
     /**
      * Creates an array wrapper with some elements.
+     *
      * @param elements The elements of the array.
      */
     public ArrayWrapper(E... elements) {
@@ -31,18 +58,20 @@ public final class ArrayWrapper<E> {
     /**
      * 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.
+     * @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) {
+    @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
@@ -61,41 +90,43 @@ public final class ArrayWrapper<E> {
 
     /**
      * Retrieves a reference to the wrapped array instance.
+     *
      * @return The array wrapped by this instance.
      */
     public E[] getArray() {
-        return this.array;
+        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.");
-        this.array = array;
+        _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) {
+    @SuppressWarnings("rawtypes") @Override public boolean equals(Object other) {
         if (!(other instanceof ArrayWrapper)) {
             return false;
         }
-        return Arrays.equals(this.array, ((ArrayWrapper) other).array);
+        return Arrays.equals(_array, ((ArrayWrapper) other)._array);
     }
 
     /**
      * Gets the hash code represented by this objects value.
-     * @see Arrays#hashCode(Object[])
+     *
      * @return This object's hash code.
+     * @see Arrays#hashCode(Object[])
      */
-    @Override
-    public int hashCode() {
-        return Arrays.hashCode(this.array);
+    @Override public int hashCode() {
+        return Arrays.hashCode(_array);
     }
+
 }

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

@@ -1,3 +1,28 @@
+/*
+ *       _____  _       _    _____                                _
+ *      |  __ \| |     | |  / ____|                              | |
+ *      | |__) | | ___ | |_| (___   __ _ _   _  __ _ _ __ ___  __| |
+ *      |  ___/| |/ _ \| __|\___ \ / _` | | | |/ _` | '__/ _ \/ _` |
+ *      | |    | | (_) | |_ ____) | (_| | |_| | (_| | | |  __/ (_| |
+ *      |_|    |_|\___/ \__|_____/ \__, |\__,_|\__,_|_|  \___|\__,_|
+ *                                    | |
+ *                                    |_|
+ *            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;
@@ -11,9 +36,10 @@ 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.
      */
-    void writeJson(JsonWriter writer) throws IOException;
+    public void writeJson(JsonWriter writer) throws IOException;
 
 }

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

@@ -1,7 +1,32 @@
+/*
+ *       _____  _       _    _____                                _
+ *      |  __ \| |     | |  / ____|                              | |
+ *      | |__) | | ___ | |_| (___   __ _ _   _  __ _ _ __ ___  __| |
+ *      |  ___/| |/ _ \| __|\___ \ / _` | | | |/ _` | '__/ _ \/ _` |
+ *      | |    | | (_) | |_ ____) | (_| | |_| | (_| | | |  __/ (_| |
+ *      |_|    |_|\___/ \__|_____/ \__, |\__,_|\__,_|_|  \___|\__,_|
+ *                                    | |
+ *                                    |_|
+ *            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 com.intellectualcrafters.configuration.serialization.ConfigurationSerializable;
+import org.bukkit.configuration.serialization.ConfigurationSerializable;
 
 import java.io.IOException;
 import java.util.HashMap;
@@ -14,34 +39,32 @@ import java.util.Map;
  */
 final class JsonString implements JsonRepresentedObject, ConfigurationSerializable {
 
-    private final String value;
+    private String _value;
 
     public JsonString(CharSequence value) {
-        this.value = value == null ? null : value.toString();
+        _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 {
+    @Override public void writeJson(JsonWriter writer) throws IOException {
         writer.value(getValue());
     }
 
     public String getValue() {
-        return this.value;
+        return _value;
     }
 
-    @Override
     public Map<String, Object> serialize() {
-        HashMap<String, Object> theSingleValue = new HashMap<>();
-        theSingleValue.put("stringValue", this.value);
+        HashMap<String, Object> theSingleValue = new HashMap<String, Object>();
+        theSingleValue.put("stringValue", _value);
         return theSingleValue;
     }
 
-    @Override
-    public String toString() {
-        return this.value;
+    @Override public String toString() {
+        return _value;
     }
+
 }

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

@@ -1,12 +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.chat;
 
 import com.google.common.collect.BiMap;
 import com.google.common.collect.ImmutableBiMap;
 import com.google.gson.stream.JsonWriter;
-import com.intellectualcrafters.configuration.serialization.ConfigurationSerializable;
-import com.intellectualcrafters.configuration.serialization.ConfigurationSerialization;
 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;
@@ -23,7 +48,7 @@ final class MessagePart implements JsonRepresentedObject, ConfigurationSerializa
 
     static {
         ImmutableBiMap.Builder<ChatColor, String> builder = ImmutableBiMap.builder();
-        for (ChatColor style : ChatColor.values()) {
+        for (final ChatColor style : ChatColor.values()) {
             if (!style.isFormat()) {
                 continue;
             }
@@ -52,13 +77,15 @@ final class MessagePart implements JsonRepresentedObject, ConfigurationSerializa
 
     ChatColor color = ChatColor.WHITE;
     ArrayList<ChatColor> styles = new ArrayList<>();
-    String clickActionName = null, clickActionData = null, hoverActionName = null;
+    String clickActionName = null;
+    String clickActionData = null;
+    String hoverActionName = null;
     JsonRepresentedObject hoverActionData = null;
     TextualComponent text = null;
     String insertionData = null;
     ArrayList<JsonRepresentedObject> translationReplacements = new ArrayList<>();
 
-    MessagePart(TextualComponent text) {
+    MessagePart(final TextualComponent text) {
         this.text = text;
     }
 
@@ -76,75 +103,76 @@ final class MessagePart implements JsonRepresentedObject, ConfigurationSerializa
         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");
+        part.translationReplacements =
+            (ArrayList<JsonRepresentedObject>) serialized.get("translationReplacements");
         return part;
     }
 
     boolean hasText() {
-        return this.text != null;
+        return text != null;
     }
 
-    @Override
-    @SuppressWarnings("unchecked")
-    public MessagePart clone() throws CloneNotSupportedException {
+    @Override @SuppressWarnings("unchecked") public MessagePart clone()
+        throws CloneNotSupportedException {
         MessagePart obj = (MessagePart) super.clone();
-        obj.styles = (ArrayList<ChatColor>) this.styles.clone();
-        if (this.hoverActionData instanceof JsonString) {
-            obj.hoverActionData = new JsonString(((JsonString) this.hoverActionData).getValue());
-        } else if (this.hoverActionData instanceof FancyMessage) {
-            obj.hoverActionData = ((FancyMessage) this.hoverActionData).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>) this.translationReplacements.clone();
+        obj.translationReplacements =
+            (ArrayList<JsonRepresentedObject>) translationReplacements.clone();
         return obj;
 
     }
 
-    @Override
     public void writeJson(JsonWriter json) {
         try {
             json.beginObject();
-            this.text.writeJson(json);
-            json.name("color").value(this.color.name().toLowerCase());
-            for (ChatColor style : this.styles) {
+            text.writeJson(json);
+            json.name("color").value(color.name().toLowerCase());
+            for (final ChatColor style : styles) {
                 json.name(stylesToNames.get(style)).value(true);
             }
-            if ((this.clickActionName != null) && (this.clickActionData != null)) {
-                json.name("clickEvent").beginObject().name("action").value(this.clickActionName).name("value").value(this.clickActionData)
-                        .endObject();
+            if (clickActionName != null && clickActionData != null) {
+                json.name("clickEvent").beginObject().name("action").value(clickActionName)
+                    .name("value").value(clickActionData).endObject();
             }
-            if ((this.hoverActionName != null) && (this.hoverActionData != null)) {
-                json.name("hoverEvent").beginObject().name("action").value(this.hoverActionName).name("value");
-                this.hoverActionData.writeJson(json);
+            if (hoverActionName != null && hoverActionData != null) {
+                json.name("hoverEvent").beginObject().name("action").value(hoverActionName)
+                    .name("value");
+                hoverActionData.writeJson(json);
                 json.endObject();
             }
-            if (this.insertionData != null) {
-                json.name("insertion").value(this.insertionData);
+            if (insertionData != null) {
+                json.name("insertion").value(insertionData);
             }
-            if (!this.translationReplacements.isEmpty() && (this.text != null) && TextualComponent.isTranslatableText(this.text)) {
+            if (translationReplacements.size() > 0 && TextualComponent.isTranslatableText(text)) {
                 json.name("with").beginArray();
-                for (JsonRepresentedObject obj : this.translationReplacements) {
+                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);
+            Bukkit.getLogger()
+                .log(Level.WARNING, "A problem occurred during writing of JSON string", e);
         }
     }
 
-    @Override
     public Map<String, Object> serialize() {
         HashMap<String, Object> map = new HashMap<>();
-        map.put("text", this.text);
-        map.put("styles", this.styles);
-        map.put("color", this.color.getChar());
-        map.put("hoverActionName", this.hoverActionName);
-        map.put("hoverActionData", this.hoverActionData);
-        map.put("clickActionName", this.clickActionName);
-        map.put("clickActionData", this.clickActionData);
-        map.put("insertion", this.insertionData);
-        map.put("translationReplacements", this.translationReplacements);
+        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

@@ -1,6 +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.bukkit.chat;
 
-import com.intellectualcrafters.plot.PS;
+import org.bukkit.Bukkit;
 
 import java.lang.reflect.Field;
 import java.lang.reflect.InvocationTargetException;
@@ -28,37 +53,47 @@ public final class Reflection {
      * 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 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 static synchronized String getVersion() {
-        return PS.get().IMP.getNMSPackage();
+    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).
+     * 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 static synchronized Class<?> getNMSClass(String className) {
+    public synchronized static Class<?> getNMSClass(String className) {
         if (_loadedNMSClasses.containsKey(className)) {
             return _loadedNMSClasses.get(className);
         }
 
-        String fullName = "net.minecraft.server." + getVersion() + "." + className;
+        String fullName = "net.minecraft.server." + getVersion() + className;
         Class<?> clazz;
         try {
             clazz = Class.forName(fullName);
         } catch (ClassNotFoundException e) {
-            e.printStackTrace();
             _loadedNMSClasses.put(className, null);
-            return null;
+            throw new RuntimeException(e);
         }
         _loadedNMSClasses.put(className, clazz);
         return clazz;
@@ -66,25 +101,23 @@ public final class Reflection {
 
     /**
      * 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}.
+     * 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 static synchronized Class<?> getOBCClass(String className) {
+    public synchronized static Class<?> getOBCClass(String className) {
         if (_loadedOBCClasses.containsKey(className)) {
             return _loadedOBCClasses.get(className);
         }
 
-        String fullName = "org.bukkit.craftbukkit." + getVersion() + "." + className;
+        String fullName = "org.bukkit.craftbukkit." + getVersion() + className;
         Class<?> clazz;
         try {
             clazz = Class.forName(fullName);
         } catch (ClassNotFoundException e) {
-            e.printStackTrace();
             _loadedOBCClasses.put(className, null);
-            return null;
+            throw new RuntimeException(e);
         }
         _loadedOBCClasses.put(className, clazz);
         return clazz;
@@ -93,41 +126,36 @@ public final class Reflection {
     /**
      * 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.
+     * 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 static synchronized Object getHandle(Object obj) {
-        try {
-            return getMethod(obj.getClass(), "getHandle").invoke(obj);
-        } catch (IllegalAccessException | InvocationTargetException | IllegalArgumentException e) {
-            e.printStackTrace();
-            return null;
-        }
+    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.
+     * 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.
+     * 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.
+     * @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 static synchronized Field getField(Class<?> clazz, String name) {
+    public synchronized static Field getField(Class<?> clazz, String name) {
         Map<String, Field> loaded;
         if (!_loadedFields.containsKey(clazz)) {
             loaded = new HashMap<>();
@@ -160,30 +188,24 @@ public final class Reflection {
      * <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>
      * <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.
+     * 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>
-     *
      * <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.
+     * @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 static synchronized Method getMethod(Class<?> clazz, String name, Class<?>... args) {
-        if (!_loadedMethods.containsKey(clazz)) {
-            _loadedMethods.put(clazz, new HashMap<String, Map<ArrayWrapper<Class<?>>, Method>>());
-        }
+    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);
-        if (!loadedMethodNames.containsKey(name)) {
-            loadedMethodNames.put(name, new HashMap<ArrayWrapper<Class<?>>, Method>());
-        }
+        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);

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

@@ -1,10 +1,35 @@
+/*
+ *       _____  _       _    _____                                _
+ *      |  __ \| |     | |  / ____|                              | |
+ *      | |__) | | ___ | |_| (___   __ _ _   _  __ _ _ __ ___  __| |
+ *      |  ___/| |/ _ \| __|\___ \ / _` | | | |/ _` | '__/ _ \/ _` |
+ *      | |    | | (_) | |_ ____) | (_| | |_| | (_| | | |  __/ (_| |
+ *      |_|    |_|\___/ \__|_____/ \__, |\__,_|\__,_|_|  \___|\__,_|
+ *                                    | |
+ *                                    |_|
+ *            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 com.intellectualcrafters.configuration.serialization.ConfigurationSerializable;
-import com.intellectualcrafters.configuration.serialization.ConfigurationSerialization;
+import org.bukkit.configuration.serialization.ConfigurationSerializable;
+import org.bukkit.configuration.serialization.ConfigurationSerialization;
 
 import java.io.IOException;
 import java.util.HashMap;
@@ -24,10 +49,11 @@ public abstract class TextualComponent implements Cloneable {
     }
 
     static TextualComponent deserialize(Map<String, Object> map) {
-        if (map.containsKey("key") && (map.size() == 2) && map.containsKey("value")) {
+        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 */) {
+        } 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);
         }
@@ -36,16 +62,21 @@ public abstract class TextualComponent implements Cloneable {
     }
 
     static boolean isTextKey(String key) {
-        return key.equals("translate") || key.equals("text") || key.equals("score") || key.equals("selector");
+        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");
+        return component instanceof ComplexTextTypeComponent && component.getKey()
+            .equals("translate");
     }
 
     /**
      * Create a textual component representing a string literal.
-     * This is the default type of textual component when a single string literal is given to a method.
+     *
+     * <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.
      */
@@ -61,6 +92,7 @@ public abstract class TextualComponent implements Cloneable {
      * 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.
      */
@@ -69,7 +101,8 @@ public abstract class TextualComponent implements Cloneable {
     }
 
     private static void throwUnsupportedSnapshot() {
-        throw new UnsupportedOperationException("This feature is only supported in snapshot releases.");
+        throw new UnsupportedOperationException(
+            "This feature is only supported in snapshot releases.");
     }
 
     /**
@@ -78,6 +111,7 @@ public abstract class TextualComponent implements Cloneable {
      * <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.
@@ -89,22 +123,27 @@ public abstract class TextualComponent implements Cloneable {
     /**
      * 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>
-     * </p>
-     * @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.
+     *
+     * <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());
+            ImmutableMap.<String, String>builder().put("name", playerName)
+                .put("objective", scoreboardObjective).build());
     }
 
     /**
@@ -113,8 +152,9 @@ public abstract class TextualComponent implements Cloneable {
      * <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.
+     *                 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) {
@@ -124,8 +164,7 @@ public abstract class TextualComponent implements Cloneable {
         return new ArbitraryTextTypeComponent("selector", selector);
     }
 
-    @Override
-    public String toString() {
+    @Override public String toString() {
         return getReadableString();
     }
 
@@ -143,12 +182,12 @@ public abstract class TextualComponent implements Cloneable {
      * 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;
+    @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.
      */
@@ -158,10 +197,11 @@ public abstract class TextualComponent implements Cloneable {
      * 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 static final class ArbitraryTextTypeComponent extends TextualComponent
+        implements ConfigurationSerializable {
 
-        private String _key;
-        private String _value;
+        private String key;
+        private String value;
 
         public ArbitraryTextTypeComponent(String key, String value) {
             setKey(key);
@@ -169,42 +209,39 @@ public abstract class TextualComponent implements Cloneable {
         }
 
         public static ArbitraryTextTypeComponent deserialize(Map<String, Object> map) {
-            return new ArbitraryTextTypeComponent(map.get("key").toString(), map.get("value").toString());
+            return new ArbitraryTextTypeComponent(map.get("key").toString(),
+                map.get("value").toString());
         }
 
-        @Override
-        public String getKey() {
-            return this._key;
+        @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;
+            Preconditions
+                .checkArgument(key != null && !key.isEmpty(), "The key must be specified.");
+            this.key = key;
         }
 
         public String getValue() {
-            return this._value;
+            return value;
         }
 
         public void setValue(String value) {
             Preconditions.checkArgument(value != null, "The value must be specified.");
-            this._value = value;
+            this.value = value;
         }
 
-        @Override
-        public TextualComponent clone() throws CloneNotSupportedException {
+        @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 {
+        @Override public void writeJson(JsonWriter writer) throws IOException {
             writer.name(getKey()).value(getValue());
         }
 
-        @Override
-        @SuppressWarnings("serial")
-        public Map<String, Object> serialize() {
+        @Override @SuppressWarnings("serial") public Map<String, Object> serialize() {
             return new HashMap<String, Object>() {
                 {
                     put("key", getKey());
@@ -213,20 +250,23 @@ public abstract class TextualComponent implements Cloneable {
             };
         }
 
-        @Override
-        public String getReadableString() {
+        @Override public String getReadableString() {
             return getValue();
         }
     }
 
-    /**
-     * Internal class used to represent a text component with a nested JSON value.
-     * 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;
+    /**
+     * 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);
@@ -235,55 +275,52 @@ public abstract class TextualComponent implements Cloneable {
 
         public static ComplexTextTypeComponent deserialize(Map<String, Object> map) {
             String key = null;
-            Map<String, String> value = new HashMap<String, String>();
+            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());
+                    value.put(valEntry.getKey().substring(6) /* Strips out the value prefix */,
+                        valEntry.getValue().toString());
                 }
             }
             return new ComplexTextTypeComponent(key, value);
         }
 
-        @Override
-        public String getKey() {
-            return this._key;
+        @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;
+            Preconditions
+                .checkArgument(key != null && !key.isEmpty(), "The key must be specified.");
+            this.key = key;
         }
 
         public Map<String, String> getValue() {
-            return this._value;
+            return value;
         }
 
         public void setValue(Map<String, String> value) {
             Preconditions.checkArgument(value != null, "The value must be specified.");
-            this._value = value;
+            this.value = value;
         }
 
-        @Override
-        public TextualComponent clone() throws CloneNotSupportedException {
+        @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 {
+        @Override public void writeJson(JsonWriter writer) throws IOException {
             writer.name(getKey());
             writer.beginObject();
-            for (Map.Entry<String, String> jsonPair : this._value.entrySet()) {
+            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() {
+        @Override @SuppressWarnings("serial") public Map<String, Object> serialize() {
             return new java.util.HashMap<String, Object>() {
                 {
                     put("key", getKey());
@@ -294,8 +331,7 @@ public abstract class TextualComponent implements Cloneable {
             };
         }
 
-        @Override
-        public String getReadableString() {
+        @Override public String getReadableString() {
             return getKey();
         }
     }

Bukkit/src/main/java/com/plotsquared/bukkit/commands/DebugUUID.java

@@ -1,313 +0,0 @@
-package com.plotsquared.bukkit.commands;
-
-import com.intellectualcrafters.plot.PS;
-import com.intellectualcrafters.plot.commands.CommandCategory;
-import com.intellectualcrafters.plot.commands.RequiredType;
-import com.intellectualcrafters.plot.commands.SubCommand;
-import com.intellectualcrafters.plot.config.C;
-import com.intellectualcrafters.plot.database.AbstractDB;
-import com.intellectualcrafters.plot.database.DBFunc;
-import com.intellectualcrafters.plot.object.OfflinePlotPlayer;
-import com.intellectualcrafters.plot.object.Plot;
-import com.intellectualcrafters.plot.object.PlotPlayer;
-import com.intellectualcrafters.plot.object.StringWrapper;
-import com.intellectualcrafters.plot.util.MainUtil;
-import com.intellectualcrafters.plot.util.StringMan;
-import com.intellectualcrafters.plot.util.TaskManager;
-import com.intellectualcrafters.plot.util.UUIDHandler;
-import com.intellectualcrafters.plot.util.WorldUtil;
-import com.intellectualcrafters.plot.uuid.UUIDWrapper;
-import com.plotsquared.bukkit.uuid.DefaultUUIDWrapper;
-import com.plotsquared.bukkit.uuid.LowerOfflineUUIDWrapper;
-import com.plotsquared.bukkit.uuid.OfflineUUIDWrapper;
-import com.plotsquared.general.commands.Argument;
-import com.plotsquared.general.commands.CommandDeclaration;
-
-import java.io.File;
-import java.io.FilenameFilter;
-import java.io.IOException;
-import java.nio.charset.StandardCharsets;
-import java.nio.file.Files;
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Map.Entry;
-import java.util.UUID;
-
-@CommandDeclaration(
-        command = "uuidconvert",
-        permission = "plots.admin",
-        description = "Debug UUID conversion",
-        usage = "/plot uuidconvert <lower|offline|online>",
-        requiredType = RequiredType.CONSOLE,
-        category = CommandCategory.DEBUG)
-public class DebugUUID extends SubCommand {
-
-    public DebugUUID() {
-        super(Argument.String);
-    }
-
-    @Override
-    public boolean onCommand(final PlotPlayer player, String[] args) {
-        final UUIDWrapper currentUUIDWrapper = UUIDHandler.getUUIDWrapper();
-        final UUIDWrapper newWrapper;
-
-        switch (args[0].toLowerCase()) {
-            case "lower":
-                newWrapper = new LowerOfflineUUIDWrapper();
-                break;
-            case "offline":
-                newWrapper = new OfflineUUIDWrapper();
-                break;
-            case "online":
-                newWrapper = new DefaultUUIDWrapper();
-                break;
-            default:
-                try {
-                    Class<?> clazz = Class.forName(args[0]);
-                    newWrapper = (UUIDWrapper) clazz.newInstance();
-                } catch (ClassNotFoundException | IllegalAccessException | InstantiationException e) {
-                    MainUtil.sendMessage(player, C.COMMAND_SYNTAX, "/plot uuidconvert <lower|offline|online>");
-                    return false;
-                }
-        }
-
-        if (args.length != 2 || !"-o".equals(args[1])) {
-            MainUtil.sendMessage(player, C.COMMAND_SYNTAX, "/plot uuidconvert " + args[0] + " - o");
-            MainUtil.sendMessage(player, "&cBe aware of the following!");
-            MainUtil.sendMessage(player, "&8 - &cUse the database command or another method to backup your plots beforehand");
-            MainUtil.sendMessage(player, "&8 - &cIf the process is interrupted, all plots could be deleted");
-            MainUtil.sendMessage(player, "&8 - &cIf an error occurs, all plots could be deleted");
-            MainUtil.sendMessage(player, "&8 - &cPlot settings WILL be lost upon conversion");
-            MainUtil.sendMessage(player, "&cTO REITERATE: BACK UP YOUR DATABASE BEFORE USING THIS!!!");
-            MainUtil.sendMessage(player, "&7Retype the command with the override parameter when ready :)");
-            return false;
-        }
-
-        if (currentUUIDWrapper.getClass().getCanonicalName().equals(newWrapper.getClass().getCanonicalName())) {
-            MainUtil.sendMessage(player, "&cUUID mode already in use!");
-            return false;
-        }
-        MainUtil.sendMessage(player, "&6Beginning UUID mode conversion");
-        MainUtil.sendMessage(player, "&7 - Disconnecting players");
-        for (Entry<String, PlotPlayer> entry : UUIDHandler.getPlayers().entrySet()) {
-            entry.getValue().kick("PlotSquared UUID conversion has been initiated. You may reconnect when finished.");
-        }
-
-        MainUtil.sendMessage(player, "&7 - Initializing map");
-
-        final HashMap<UUID, UUID> uCMap = new HashMap<>();
-        final HashMap<UUID, UUID> uCReverse = new HashMap<>();
-
-        MainUtil.sendMessage(player, "&7 - Collecting playerdata");
-
-        HashSet<String> worlds = new HashSet<>();
-        worlds.add(WorldUtil.IMP.getMainWorld());
-        worlds.add("world");
-        HashSet<UUID> uuids = new HashSet<>();
-        HashSet<String> names = new HashSet<>();
-        for (String worldName : worlds) {
-            File playerDataFolder = new File(worldName + File.separator + "playerdata");
-            String[] dat = playerDataFolder.list(new FilenameFilter() {
-                @Override
-                public boolean accept(File f, String s) {
-                    return s.endsWith(".dat");
-                }
-            });
-            if (dat != null) {
-                for (String current : dat) {
-                    String s = current.replaceAll(".dat$", "");
-                    try {
-                        UUID uuid = UUID.fromString(s);
-                        uuids.add(uuid);
-                    } catch (Exception e) {
-                        MainUtil.sendMessage(player, C.PREFIX + "Invalid playerdata: " + current);
-                    }
-                }
-            }
-            File playersFolder = new File(worldName + File.separator + "players");
-            dat = playersFolder.list(new FilenameFilter() {
-                @Override
-                public boolean accept(File f, String s) {
-                    return s.endsWith(".dat");
-                }
-            });
-            if (dat != null) {
-                for (String current : dat) {
-                    names.add(current.replaceAll(".dat$", ""));
-                }
-            }
-        }
-
-        MainUtil.sendMessage(player, "&7 - Populating map");
-        UUID uuid2;
-        UUIDWrapper wrapper = new DefaultUUIDWrapper();
-        for (UUID uuid : uuids) {
-            try {
-                OfflinePlotPlayer op = wrapper.getOfflinePlayer(uuid);
-                uuid = currentUUIDWrapper.getUUID(op);
-                uuid2 = newWrapper.getUUID(op);
-                if (!uuid.equals(uuid2) && !uCMap.containsKey(uuid) && !uCReverse.containsKey(uuid2)) {
-                    uCMap.put(uuid, uuid2);
-                    uCReverse.put(uuid2, uuid);
-                }
-            } catch (Throwable e) {
-                MainUtil.sendMessage(player, C.PREFIX + "&6Invalid playerdata: " + uuid.toString() + ".dat");
-            }
-        }
-        for (String name : names) {
-            UUID uuid = currentUUIDWrapper.getUUID(name);
-            uuid2 = newWrapper.getUUID(name);
-            if (!uuid.equals(uuid2)) {
-                uCMap.put(uuid, uuid2);
-                uCReverse.put(uuid2, uuid);
-            }
-        }
-        if (uCMap.isEmpty()) {
-            MainUtil.sendMessage(player, "&c - Error! Attempting to repopulate");
-            for (OfflinePlotPlayer op : currentUUIDWrapper.getOfflinePlayers()) {
-                if (op.getLastPlayed() != 0) {
-                    //                    String name = op.getName();
-                    //                    StringWrapper wrap = new StringWrapper(name);
-                    UUID uuid = currentUUIDWrapper.getUUID(op);
-                    uuid2 = newWrapper.getUUID(op);
-                    if (!uuid.equals(uuid2)) {
-                        uCMap.put(uuid, uuid2);
-                        uCReverse.put(uuid2, uuid);
-                    }
-                }
-            }
-            if (uCMap.isEmpty()) {
-                MainUtil.sendMessage(player, "&cError. Failed to collect UUIDs!");
-                return false;
-            } else {
-                MainUtil.sendMessage(player, "&a - Successfully repopulated");
-            }
-        }
-
-        MainUtil.sendMessage(player, "&7 - Replacing cache");
-        TaskManager.runTaskAsync(new Runnable() {
-            @Override
-            public void run() {
-                for (Entry<UUID, UUID> entry : uCMap.entrySet()) {
-                    String name = UUIDHandler.getName(entry.getKey());
-                    if (name != null) {
-                        UUIDHandler.add(new StringWrapper(name), entry.getValue());
-                    }
-                }
-
-                MainUtil.sendMessage(player, "&7 - Scanning for applicable files (uuids.txt)");
-
-                File file = new File(PS.get().IMP.getDirectory(), "uuids.txt");
-                if (file.exists()) {
-                    try {
-                        List<String> lines = Files.readAllLines(file.toPath(), StandardCharsets.UTF_8);
-                        for (String line : lines) {
-                            try {
-                                line = line.trim();
-                                if (line.isEmpty()) {
-                                    continue;
-                                }
-                                line = line.replaceAll("[\\|][0-9]+[\\|][0-9]+[\\|]", "");
-                                String[] split = line.split("\\|");
-                                String name = split[0];
-                                if (name.isEmpty() || name.length() > 16 || !StringMan.isAlphanumericUnd(name)) {
-                                    continue;
-                                }
-                                UUID old = currentUUIDWrapper.getUUID(name);
-                                if (old == null) {
-                                    continue;
-                                }
-                                UUID now = newWrapper.getUUID(name);
-                                UUIDHandler.add(new StringWrapper(name), now);
-                                uCMap.put(old, now);
-                                uCReverse.put(now, old);
-                            } catch (Exception e2) {
-                                e2.printStackTrace();
-                            }
-                        }
-                    } catch (IOException e) {
-                        e.printStackTrace();
-                    }
-                }
-
-                MainUtil.sendMessage(player, "&7 - Replacing wrapper");
-                UUIDHandler.setUUIDWrapper(newWrapper);
-
-                MainUtil.sendMessage(player, "&7 - Updating plot objects");
-
-                for (Plot plot : PS.get().getPlots()) {
-                    UUID value = uCMap.get(plot.owner);
-                    if (value != null) {
-                        plot.owner = value;
-                    }
-                    plot.getTrusted().clear();
-                    plot.getMembers().clear();
-                    plot.getDenied().clear();
-                }
-
-                MainUtil.sendMessage(player, "&7 - Deleting database");
-                final AbstractDB database = DBFunc.dbManager;
-                boolean result = database.deleteTables();
-
-                MainUtil.sendMessage(player, "&7 - Creating tables");
-
-                try {
-                    database.createTables();
-                    if (!result) {
-                        MainUtil.sendMessage(player, "&cConversion failed! Attempting recovery");
-                        for (Plot plot : PS.get().getPlots()) {
-                            UUID value = uCReverse.get(plot.owner);
-                            if (value != null) {
-                                plot.owner = value;
-                            }
-                        }
-                        database.createPlotsAndData(new ArrayList<>(PS.get().getPlots()), new Runnable() {
-                            @Override
-                            public void run() {
-                                MainUtil.sendMessage(player, "&6Recovery was successful!");
-                            }
-                        });
-                        return;
-                    }
-                } catch (Exception e) {
-                    e.printStackTrace();
-                    return;
-                }
-
-                if (newWrapper instanceof OfflineUUIDWrapper) {
-                    PS.get().config.set("UUID.force-lowercase", false);
-                    PS.get().config.set("UUID.offline", true);
-                } else if (newWrapper instanceof DefaultUUIDWrapper) {
-                    PS.get().config.set("UUID.force-lowercase", false);
-                    PS.get().config.set("UUID.offline", false);
-                }
-                try {
-                    PS.get().config.save(PS.get().configFile);
-                } catch (IOException e) {
-                    MainUtil.sendMessage(player, "Could not save configuration. It will need to be manual set!");
-                }
-
-                MainUtil.sendMessage(player, "&7 - Populating tables");
-
-                TaskManager.runTaskAsync(new Runnable() {
-                    @Override
-                    public void run() {
-                        ArrayList<Plot> plots = new ArrayList<>(PS.get().getPlots());
-                        database.createPlotsAndData(plots, new Runnable() {
-                            @Override
-                            public void run() {
-                                MainUtil.sendMessage(player, "&aConversion complete!");
-                            }
-                        });
-                    }
-                });
-
-                MainUtil.sendMessage(player, "&aIt is now safe for players to join");
-                MainUtil.sendMessage(player, "&cConversion is still in progress, you will be notified when it is complete");
-            }
-        });
-        return true;
-    }
-}

Bukkit/src/main/java/com/plotsquared/bukkit/database/plotme/APlotMeConnector.java

@@ -1,93 +0,0 @@
-package com.plotsquared.bukkit.database.plotme;
-
-import com.intellectualcrafters.configuration.file.FileConfiguration;
-import com.intellectualcrafters.plot.PS;
-import com.intellectualcrafters.plot.object.Location;
-import com.intellectualcrafters.plot.object.Plot;
-import com.intellectualcrafters.plot.object.PlotId;
-import org.bukkit.Bukkit;
-import org.bukkit.World;
-
-import java.sql.Connection;
-import java.sql.SQLException;
-import java.util.Collections;
-import java.util.HashMap;
-
-abstract class APlotMeConnector {
-
-    public abstract Connection getPlotMeConnection(String plugin, FileConfiguration plotConfig, String dataFolder);
-
-    public abstract HashMap<String, HashMap<PlotId, Plot>> getPlotMePlots(Connection connection) throws SQLException;
-
-    public abstract boolean accepts(String version);
-
-    public String getWorld(String world) {
-        for (World newWorld : Bukkit.getWorlds()) {
-            if (newWorld.getName().equalsIgnoreCase(world)) {
-                return newWorld.getName();
-            }
-        }
-        return world;
-    }
-
-    public boolean isValidConnection(Connection connection) {
-        return connection != null;
-    }
-
-    public void copyConfig(FileConfiguration plotConfig, String world, String actualWorldName) {
-        int pathWidth = plotConfig.getInt("worlds." + world + ".PathWidth"); //
-        PS.get().config.set("worlds." + actualWorldName + ".road.width", pathWidth);
-        int plotSize = plotConfig.getInt("worlds." + world + ".PlotSize"); //
-        PS.get().config.set("worlds." + actualWorldName + ".plot.size", plotSize);
-        String wallBlock = plotConfig.getString("worlds." + world + ".WallBlockId"); //
-        PS.get().config.set("worlds." + actualWorldName + ".wall.block", wallBlock);
-        String floor = plotConfig.getString("worlds." + world + ".PlotFloorBlockId"); //
-        PS.get().config.set("worlds." + actualWorldName + ".plot.floor", Collections.singletonList(floor));
-        String filling = plotConfig.getString("worlds." + world + ".PlotFillingBlockId"); //
-        PS.get().config.set("worlds." + actualWorldName + ".plot.filling", Collections.singletonList(filling));
-        String road = plotConfig.getString("worlds." + world + ".RoadMainBlockId");
-        PS.get().config.set("worlds." + actualWorldName + ".road.block", road);
-        int height = plotConfig.getInt("worlds." + world + ".RoadHeight"); //
-        PS.get().config.set("worlds." + actualWorldName + ".road.height", height);
-        PS.get().config.set("worlds." + actualWorldName + ".plot.height", height);
-        PS.get().config.set("worlds." + actualWorldName + ".wall.height", height);
-    }
-
-    public Location getPlotTopLocAbs(int path, int plot, PlotId plotid) {
-        int px = plotid.x;
-        int pz = plotid.y;
-        int x = px * (path + plot) - (int) Math.floor(path / 2) - 1;
-        int z = pz * (path + plot) - (int) Math.floor(path / 2) - 1;
-        return new Location(null, x, 256, z);
-    }
-
-    public Location getPlotBottomLocAbs(int path, int plot, PlotId plotid) {
-        int px = plotid.x;
-        int pz = plotid.y;
-        int x = px * (path + plot) - plot - (int) Math.floor(path / 2) - 1;
-        int z = pz * (path + plot) - plot - (int) Math.floor(path / 2) - 1;
-        return new Location(null, x, 1, z);
-    }
-
-    public void setMerged(HashMap<String, HashMap<PlotId, boolean[]>> merges, String world, PlotId id, int direction) {
-        HashMap<PlotId, boolean[]> plots = merges.get(world);
-        PlotId id2 = new PlotId(id.x, id.y);
-        boolean[] merge1;
-        if (plots.containsKey(id)) {
-            merge1 = plots.get(id);
-        } else {
-            merge1 = new boolean[] { false, false, false, false };
-        }
-        boolean[] merge2;
-        if (plots.containsKey(id2)) {
-            merge2 = plots.get(id2);
-        } else {
-            merge2 = new boolean[] { false, false, false, false };
-        }
-        merge1[direction] = true;
-        merge2[(direction + 2) % 4] = true;
-        plots.put(id, merge1);
-        plots.put(id2, merge1);
-    }
-    
-}

Bukkit/src/main/java/com/plotsquared/bukkit/database/plotme/ClassicPlotMeConnector.java

@@ -1,272 +0,0 @@
-package com.plotsquared.bukkit.database.plotme;
-
-import com.google.common.base.Charsets;
-import com.intellectualcrafters.configuration.file.FileConfiguration;
-import com.intellectualcrafters.plot.PS;
-import com.intellectualcrafters.plot.config.Settings;
-import com.intellectualcrafters.plot.database.DBFunc;
-import com.intellectualcrafters.plot.database.SQLite;
-import com.intellectualcrafters.plot.object.Location;
-import com.intellectualcrafters.plot.object.Plot;
-import com.intellectualcrafters.plot.object.PlotArea;
-import com.intellectualcrafters.plot.object.PlotId;
-import com.intellectualcrafters.plot.object.StringWrapper;
-import com.intellectualcrafters.plot.util.UUIDHandler;
-
-import java.io.File;
-import java.nio.ByteBuffer;
-import java.sql.Connection;
-import java.sql.DriverManager;
-import java.sql.PreparedStatement;
-import java.sql.ResultSet;
-import java.sql.SQLException;
-import java.util.HashMap;
-import java.util.Map.Entry;
-import java.util.UUID;
-
-public class ClassicPlotMeConnector extends APlotMeConnector {
-
-    private String plugin;
-    private String prefix;
-
-    @Override
-    public Connection getPlotMeConnection(String plugin, FileConfiguration plotConfig, String dataFolder) {
-        this.plugin = plugin.toLowerCase();
-        this.prefix = plotConfig.getString("mySQLprefix", plugin.toLowerCase());
-        try {
-            if (plotConfig.getBoolean("usemySQL")) {
-                String user = plotConfig.getString("mySQLuname");
-                String password = plotConfig.getString("mySQLpass");
-                String con = plotConfig.getString("mySQLconn");
-                return DriverManager.getConnection(con, user, password);
-                //                return new MySQL(plotsquared, hostname, port, database, username, password)
-            } else {
-                return new SQLite(dataFolder + File.separator + "plots.db").openConnection();
-            }
-        } catch (SQLException | ClassNotFoundException ignored) {
-            //ignored
-            ignored.printStackTrace();
-        }
-        return null;
-    }
-
-    @Override
-    public HashMap<String, HashMap<PlotId, Plot>> getPlotMePlots(Connection connection) throws SQLException {
-        HashMap<String, Integer> plotWidth = new HashMap<>();
-        HashMap<String, Integer> roadWidth = new HashMap<>();
-        HashMap<String, HashMap<PlotId, Plot>> plots = new HashMap<>();
-        HashMap<String, HashMap<PlotId, boolean[]>> merges = new HashMap<>();
-        PreparedStatement statement = connection.prepareStatement("SELECT * FROM `" + this.prefix + "Plots`");
-        ResultSet resultSet = statement.executeQuery();
-        String column = null;
-        boolean checkUUID = DBFunc.hasColumn(resultSet, "ownerid");
-        boolean checkUUID2 = DBFunc.hasColumn(resultSet, "ownerId");
-        if (checkUUID) {
-            column = "ownerid";
-        } else if (checkUUID2) {
-            column = "ownerId";
-        }
-        boolean merge = !"plotme".equalsIgnoreCase(this.plugin) && Settings.CONVERT_PLOTME;
-        int missing = 0;
-        while (resultSet.next()) {
-            PlotId id = new PlotId(resultSet.getInt("idX"), resultSet.getInt("idZ"));
-            String name = resultSet.getString("owner");
-            String world = LikePlotMeConverter.getWorld(resultSet.getString("world"));
-            if (!plots.containsKey(world)) {
-                plots.put(world, new HashMap<PlotId, Plot>());
-                if (merge) {
-                    int plot = PS.get().config.getInt("worlds." + world + ".plot.size");
-                    int path = PS.get().config.getInt("worlds." + world + ".road.width");
-                    plotWidth.put(world, plot);
-                    roadWidth.put(world, path);
-                    merges.put(world, new HashMap<PlotId, boolean[]>());
-                }
-            }
-            if (merge) {
-                int tx = resultSet.getInt("topX");
-                int tz = resultSet.getInt("topZ");
-                int bx = resultSet.getInt("bottomX") - 1;
-                int bz = resultSet.getInt("bottomZ") - 1;
-                int path = roadWidth.get(world);
-                int plot = plotWidth.get(world);
-                Location top = getPlotTopLocAbs(path, plot, id);
-                Location bot = getPlotBottomLocAbs(path, plot, id);
-                if (tx > top.getX()) {
-                    setMerged(merges, world, id, 1);
-                }
-                if (tz > top.getZ()) {
-                    setMerged(merges, world, id, 2);
-                }
-                if (bx < bot.getX()) {
-                    setMerged(merges, world, id, 3);
-                }
-                if (bz > bot.getZ()) {
-                    setMerged(merges, world, id, 0);
-                }
-            }
-            UUID owner = UUIDHandler.getUUID(name, null);
-            if (owner == null) {
-                if ("*".equals(name)) {
-                    owner = DBFunc.everyone;
-                } else {
-                    if (checkUUID || checkUUID2) {
-                        try {
-                            byte[] bytes = resultSet.getBytes(column);
-                            if (bytes != null) {
-                                try {
-                                    ByteBuffer bb = ByteBuffer.wrap(bytes);
-                                    long high = bb.getLong();
-                                    long low = bb.getLong();
-                                    owner = new UUID(high, low);
-                                } catch (Exception e) {
-                                    e.printStackTrace();
-                                    owner = UUID.nameUUIDFromBytes(bytes);
-                                }
-                                UUIDHandler.add(new StringWrapper(name), owner);
-                            }
-                        } catch (SQLException e) {
-                            e.printStackTrace();
-                        }
-                    }
-                    if (owner == null) {
-                        if (name.isEmpty()) {
-                            PS.log("&cCould not identify owner for plot: " + id + " -> '" + name + "'");
-                            missing++;
-                            continue;
-                        }
-                        owner = UUID.nameUUIDFromBytes(("OfflinePlayer:" + name.toLowerCase()).getBytes(Charsets.UTF_8));
-                    }
-                }
-            } else {
-                UUIDHandler.add(new StringWrapper(name), owner);
-            }
-            Plot plot = new Plot(PlotArea.createGeneric(world), id, owner);
-            plots.get(world).put(id, plot);
-        }
-        if (missing > 0) {
-            PS.log("&cSome names could not be identified:");
-            PS.log("&7 - Empty quotes mean PlotMe just stored an unowned plot in the database");
-            PS.log("&7 - Names you have never seen before could be from people mistyping commands");
-            PS.log("&7 - Converting from a non-uuid version of PlotMe can't identify owners if the playerdata files are deleted (these plots will "
-                    + "remain unknown until the player connects)");
-        }
-
-        for (Entry<String, HashMap<PlotId, boolean[]>> entry : merges.entrySet()) {
-            String world = entry.getKey();
-            for (Entry<PlotId, boolean[]> entry2 : entry.getValue().entrySet()) {
-                HashMap<PlotId, Plot> newPlots = plots.get(world);
-                Plot plot = newPlots.get(entry2.getKey());
-                if (plot != null) {
-                    plot.setMerged(entry2.getValue());
-                }
-            }
-        }
-
-        resultSet.close();
-        statement.close();
-
-        try {
-
-            PS.log(" - " + this.prefix + "Denied");
-            statement = connection.prepareStatement("SELECT * FROM `" + this.prefix + "Denied`");
-            resultSet = statement.executeQuery();
-
-            while (resultSet.next()) {
-                PlotId id = new PlotId(resultSet.getInt("idX"), resultSet.getInt("idZ"));
-                String name = resultSet.getString("player");
-                String world = LikePlotMeConverter.getWorld(resultSet.getString("world"));
-                UUID denied = UUIDHandler.getUUID(name, null);
-                if (denied == null) {
-                    if ("*".equals(name)) {
-                        denied = DBFunc.everyone;
-                    } else if (DBFunc.hasColumn(resultSet, "playerid")) {
-                        try {
-                            byte[] bytes = resultSet.getBytes("playerid");
-                            if (bytes != null) {
-                                try {
-                                    ByteBuffer bb = ByteBuffer.wrap(bytes);
-                                    long high = bb.getLong();
-                                    long low = bb.getLong();
-                                    denied = new UUID(high, low);
-                                } catch (Exception e) {
-                                    e.printStackTrace();
-                                    denied = UUID.nameUUIDFromBytes(bytes);
-                                }
-                                UUIDHandler.add(new StringWrapper(name), denied);
-                            }
-                        } catch (SQLException e) {
-                            e.printStackTrace();
-                        }
-                    }
-                    if (denied == null) {
-                        PS.log("&6Could not identify denied for plot: " + id);
-                        continue;
-                    }
-                }
-                HashMap<PlotId, Plot> worldMap = plots.get(world);
-                if (worldMap != null) {
-                    Plot plot = worldMap.get(id);
-                    if (plot != null) {
-                        plot.getDenied().add(denied);
-                    }
-                }
-            }
-
-            statement = connection.prepareStatement("SELECT * FROM `" + this.plugin + "Allowed`");
-            resultSet = statement.executeQuery();
-
-            while (resultSet.next()) {
-                PlotId id = new PlotId(resultSet.getInt("idX"), resultSet.getInt("idZ"));
-                String name = resultSet.getString("player");
-                String world = LikePlotMeConverter.getWorld(resultSet.getString("world"));
-                UUID helper = UUIDHandler.getUUID(name, null);
-                if (helper == null) {
-                    if ("*".equals(name)) {
-                        helper = DBFunc.everyone;
-                    } else if (DBFunc.hasColumn(resultSet, "playerid")) {
-                        try {
-                            byte[] bytes = resultSet.getBytes("playerid");
-                            if (bytes != null) {
-                                try {
-                                    ByteBuffer bb = ByteBuffer.wrap(bytes);
-                                    long high = bb.getLong();
-                                    long low = bb.getLong();
-                                    helper = new UUID(high, low);
-                                } catch (Exception e) {
-                                    e.printStackTrace();
-                                    helper = UUID.nameUUIDFromBytes(bytes);
-                                }
-                                UUIDHandler.add(new StringWrapper(name), helper);
-                            }
-                        } catch (SQLException e) {
-                            e.printStackTrace();
-                        }
-                    }
-                    if (helper == null) {
-                        PS.log("&6Could not identify helper for plot: " + id);
-                        continue;
-                    }
-                }
-                HashMap<PlotId, Plot> worldMap = plots.get(world);
-                if (worldMap != null) {
-                    Plot plot = worldMap.get(id);
-                    if (plot != null) {
-                        plot.getTrusted().add(helper);
-                    }
-                }
-            }
-
-            resultSet.close();
-            statement.close();
-
-        } catch (SQLException ignored) {
-            //ignored
-        }
-        return plots;
-    }
-
-    @Override
-    public boolean accepts(String version) {
-        return version == null || PS.get().canUpdate(version, "0.17.0") || PS.get().canUpdate("0.999.999", version);
-    }
-}

Bukkit/src/main/java/com/plotsquared/bukkit/database/plotme/LikePlotMeConverter.java

@@ -1,377 +0,0 @@
-package com.plotsquared.bukkit.database.plotme;
-
-import com.intellectualcrafters.configuration.MemorySection;
-import com.intellectualcrafters.configuration.file.FileConfiguration;
-import com.intellectualcrafters.configuration.file.YamlConfiguration;
-import com.intellectualcrafters.plot.PS;
-import com.intellectualcrafters.plot.config.Settings;
-import com.intellectualcrafters.plot.database.DBFunc;
-import com.intellectualcrafters.plot.generator.HybridGen;
-import com.intellectualcrafters.plot.object.Plot;
-import com.intellectualcrafters.plot.object.PlotArea;
-import com.intellectualcrafters.plot.object.PlotId;
-import com.intellectualcrafters.plot.util.TaskManager;
-import com.plotsquared.bukkit.generator.BukkitPlotGenerator;
-import org.bukkit.Bukkit;
-import org.bukkit.World;
-import org.bukkit.WorldCreator;
-import org.bukkit.command.CommandException;
-
-import java.io.File;
-import java.io.IOException;
-import java.nio.charset.StandardCharsets;
-import java.nio.file.Files;
-import java.nio.file.Path;
-import java.nio.file.Paths;
-import java.sql.Connection;
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.HashMap;
-import java.util.Map.Entry;
-import java.util.Set;
-import java.util.concurrent.atomic.AtomicBoolean;
-
-public class LikePlotMeConverter {
-
-    private final String plugin;
-
-    /**
-     * Constructor.
-     *
-     * @param plugin Plugin Used to run the converter
-     */
-    public LikePlotMeConverter(String plugin) {
-        this.plugin = plugin;
-    }
-
-    public static String getWorld(String world) {
-        for (World newWorld : Bukkit.getWorlds()) {
-            if (newWorld.getName().equalsIgnoreCase(world)) {
-                return newWorld.getName();
-            }
-        }
-        return world;
-    }
-
-    private void sendMessage(String message) {
-        PS.debug("&3PlotMe&8->&3PlotSquared&8: &7" + message);
-    }
-
-    public String getPlotMePath() {
-        return new File(".").getAbsolutePath() + File.separator + "plugins" + File.separator + this.plugin + File.separator;
-    }
-
-    public String getAthionPlotsPath() {
-        return new File(".").getAbsolutePath() + File.separator + "plugins" + File.separator + this.plugin + File.separator;
-    }
-
-    public FileConfiguration getPlotMeConfig(String dataFolder) {
-        File plotMeFile = new File(dataFolder + "config.yml");
-        if (!plotMeFile.exists()) {
-            return null;
-        }
-        return YamlConfiguration.loadConfiguration(plotMeFile);
-    }
-
-    public Set<String> getPlotMeWorlds(FileConfiguration plotConfig) {
-        return plotConfig.getConfigurationSection("worlds").getKeys(false);
-    }
-
-    public void mergeWorldYml(String plugin, FileConfiguration plotConfig) {
-        try {
-            File genConfig =
-                    new File("plugins" + File.separator + plugin + File.separator + "PlotMe-DefaultGenerator" + File.separator + "config.yml");
-            if (genConfig.exists()) {
-                YamlConfiguration yml = YamlConfiguration.loadConfiguration(genConfig);
-                for (String key : yml.getKeys(true)) {
-                    if (!plotConfig.contains(key)) {
-                        Object value = yml.get(key);
-                        if (!(value instanceof MemorySection)) {
-                            plotConfig.set(key, value);
-                        }
-                    }
-                }
-            }
-        } catch (Exception e) {
-            e.printStackTrace();
-        }
-    }
-
-    public void updateWorldYml(String plugin, String location) {
-        try {
-            Path path = Paths.get(location);
-            File file = new File(location);
-            if (!file.exists()) {
-                return;
-            }
-            String content = new String(Files.readAllBytes(path), StandardCharsets.UTF_8);
-            content = content.replaceAll("PlotMe-DefaultGenerator", "PlotSquared");
-            content = content.replaceAll(plugin, "PlotSquared");
-            Files.write(path, content.getBytes(StandardCharsets.UTF_8));
-        } catch (IOException ignored) {
-            //ignored
-        }
-    }
-
-    public boolean run(APlotMeConnector connector) {
-        try {
-            String dataFolder = getPlotMePath();
-            FileConfiguration plotConfig = getPlotMeConfig(dataFolder);
-            if (plotConfig == null) {
-                return false;
-            }
-
-            String version = plotConfig.getString("Version");
-            if (version == null) {
-                version = plotConfig.getString("version");
-            }
-            if (!connector.accepts(version)) {
-                return false;
-            }
-
-            PS.debug("&3Using connector: " + connector.getClass().getCanonicalName());
-
-            Connection connection = connector.getPlotMeConnection(this.plugin, plotConfig, dataFolder);
-
-            if (!connector.isValidConnection(connection)) {
-                sendMessage("Cannot connect to PlotMe DB. Conversion process will not continue");
-                return false;
-            }
-
-            sendMessage(this.plugin + " conversion has started. To disable this, please set 'plotme-convert.enabled' to false in the 'settings.yml'");
-
-            mergeWorldYml(this.plugin, plotConfig);
-
-            sendMessage("Connecting to " + this.plugin + " DB");
-
-            ArrayList<Plot> createdPlots = new ArrayList<>();
-
-            sendMessage("Collecting plot data");
-
-            String dbPrefix = this.plugin.toLowerCase();
-            sendMessage(" - " + dbPrefix + "Plots");
-            final Set<String> worlds = getPlotMeWorlds(plotConfig);
-
-            if (Settings.CONVERT_PLOTME) {
-                sendMessage("Updating bukkit.yml");
-                updateWorldYml(this.plugin, "bukkit.yml");
-                updateWorldYml(this.plugin, "plugins/Multiverse-Core/worlds.yml");
-                for (String world : plotConfig.getConfigurationSection("worlds").getKeys(false)) {
-                    sendMessage("Copying config for: " + world);
-                    try {
-                        String actualWorldName = getWorld(world);
-                        connector.copyConfig(plotConfig, world, actualWorldName);
-                        PS.get().config.save(PS.get().configFile);
-                    } catch (IOException e) {
-                        e.printStackTrace();
-                        sendMessage("&c-- &lFailed to save configuration for world '" + world
-                                + "'\nThis will need to be done using the setup command, or manually");
-                    }
-                }
-            }
-            HashMap<String, HashMap<PlotId, Plot>> plots = connector.getPlotMePlots(connection);
-            int plotCount = 0;
-            for (Entry<String, HashMap<PlotId, Plot>> entry : plots.entrySet()) {
-                plotCount += entry.getValue().size();
-            }
-            if (!Settings.CONVERT_PLOTME) {
-                return false;
-            }
-
-            sendMessage(" - " + dbPrefix + "Allowed");
-
-            sendMessage("Collected " + plotCount + " plots from PlotMe");
-            File plotmeDgFile = new File(dataFolder + File.separator + "PlotMe-DefaultGenerator" + File.separator + "config.yml");
-            if (plotmeDgFile.exists()) {
-                YamlConfiguration plotmeDgYml = YamlConfiguration.loadConfiguration(plotmeDgFile);
-                try {
-                    for (String world : plots.keySet()) {
-                        String actualWorldName = getWorld(world);
-                        String plotMeWorldName = world.toLowerCase();
-                        Integer pathwidth = plotmeDgYml.getInt("worlds." + plotMeWorldName + ".PathWidth"); //
-                        /*
-                         * TODO: dead code
-                         * 
-                        if (pathwidth == null) {
-                            pathwidth = 7;
-                        }
-                        */
-                        PS.get().config.set("worlds." + world + ".road.width", pathwidth);
-
-                        Integer pathheight = plotmeDgYml.getInt("worlds." + plotMeWorldName + ".RoadHeight"); //
-                        if (pathheight == 0) {
-                            pathheight = 64;
-                        }
-                        PS.get().config.set("worlds." + world + ".road.height", pathheight);
-                        PS.get().config.set("worlds." + world + ".wall.height", pathheight);
-                        PS.get().config.set("worlds." + world + ".plot.height", pathheight);
-                        Integer plotSize = plotmeDgYml.getInt("worlds." + plotMeWorldName + ".PlotSize"); //
-                        if (plotSize == 0) {
-                            plotSize = 32;
-                        }
-                        PS.get().config.set("worlds." + world + ".plot.size", plotSize);
-                        String wallblock = plotmeDgYml.getString("worlds." + plotMeWorldName + ".WallBlock", "44"); //
-                        PS.get().config.set("worlds." + world + ".wall.block", wallblock);
-                        String floor = plotmeDgYml.getString("worlds." + plotMeWorldName + ".PlotFloorBlock", "2"); //
-                        PS.get().config.set("worlds." + world + ".plot.floor", Collections.singletonList(floor));
-                        String filling = plotmeDgYml.getString("worlds." + plotMeWorldName + ".FillBlock", "3"); //
-                        PS.get().config.set("worlds." + world + ".plot.filling", Collections.singletonList(filling));
-                        String road = plotmeDgYml.getString("worlds." + plotMeWorldName + ".RoadMainBlock", "5");
-                        PS.get().config.set("worlds." + world + ".road.block", road);
-                        Integer height = plotmeDgYml.getInt("worlds." + plotMeWorldName + ".RoadHeight"); //
-                        if (height == 0) {
-                            height = plotmeDgYml.getInt("worlds." + plotMeWorldName + ".GroundHeight"); //
-                            if (height == 0) {
-                                height = 64;
-                            }
-                        }
-                        PS.get().config.set("worlds." + actualWorldName + ".road.height", height);
-                        PS.get().config.set("worlds." + actualWorldName + ".plot.height", height);
-                        PS.get().config.set("worlds." + actualWorldName + ".wall.height", height);
-                        PS.get().config.save(PS.get().configFile);
-                    }
-                } catch (IOException ignored) {
-                    //ignored
-                }
-            }
-            for (Entry<String, HashMap<PlotId, Plot>> entry : plots.entrySet()) {
-                String world = entry.getKey();
-                PlotArea area = PS.get().getPlotArea(world, null);
-                int duplicate = 0;
-                if (area != null) {
-                    for (Entry<PlotId, Plot> entry2 : entry.getValue().entrySet()) {
-                        if (area.getOwnedPlotAbs(entry2.getKey()) != null) {
-                            duplicate++;
-                        } else {
-                            createdPlots.add(entry2.getValue());
-                        }
-                    }
-                    if (duplicate > 0) {
-                        PS.debug("&c[WARNING] Found " + duplicate + " duplicate plots already in DB for world: '" + world
-                                + "'. Have you run the converter already?");
-                    }
-                } else {
-                    if (PS.get().plots_tmp != null) {
-                        HashMap<PlotId, Plot> map = PS.get().plots_tmp.get(world);
-                        if (map != null) {
-                            for (Entry<PlotId, Plot> entry2 : entry.getValue().entrySet()) {
-                                if (map.containsKey(entry2.getKey())) {
-                                    duplicate++;
-                                } else {
-                                    createdPlots.add(entry2.getValue());
-                                }
-                            }
-                            if (duplicate > 0) {
-                                PS.debug("&c[WARNING] Found " + duplicate + " duplicate plots already in DB for world: '" + world
-                                        + "'. Have you run the converter already?");
-                            }
-                            continue;
-                        }
-                    }
-                    createdPlots.addAll(entry.getValue().values());
-                }
-            }
-            sendMessage("Creating plot DB");
-            Thread.sleep(1000);
-            final AtomicBoolean done = new AtomicBoolean(false);
-            DBFunc.createPlotsAndData(createdPlots, new Runnable() {
-                @Override
-                public void run() {
-                    if (done.get()) {
-                        done();
-                        sendMessage("&aDatabase conversion is now complete!");
-                        PS.debug("&c - Stop the server");
-                        PS.debug("&c - Disable 'plotme-convert.enabled' and 'plotme-convert.cache-uuids' in the settings.yml");
-                        PS.debug("&c - Correct any generator settings that haven't copied to 'settings.yml' properly");
-                        PS.debug("&c - Start the server");
-                        PS.get().setPlots(DBFunc.getPlots());
-                    } else {
-                        sendMessage("&cPlease wait until database conversion is complete. You will be notified with instructions when this happens!");
-                        done.set(true);
-                    }
-                }
-            });
-            sendMessage("Saving configuration...");
-            try {
-                PS.get().config.save(PS.get().configFile);
-            } catch (IOException e) {
-                sendMessage(" - &cFailed to save configuration.");
-            }
-            TaskManager.runTask(new Runnable() {
-                @Override
-                public void run() {
-                    try {
-                        boolean mv = false;
-                        boolean mw = false;
-                        if ((Bukkit.getPluginManager().getPlugin("Multiverse-Core") != null) && Bukkit.getPluginManager().getPlugin("Multiverse-Core")
-                                .isEnabled()) {
-                            mv = true;
-                        } else if ((Bukkit.getPluginManager().getPlugin("MultiWorld") != null) && Bukkit.getPluginManager().getPlugin("MultiWorld")
-                                .isEnabled()) {
-                            mw = true;
-                        }
-                        for (String worldName : worlds) {
-                            World world = Bukkit.getWorld(getWorld(worldName));
-                            if (world == null) {
-                                sendMessage("&cInvalid world in PlotMe configuration: " + worldName);
-                            }
-                            String actualWorldName = world.getName();
-                            sendMessage("Reloading generator for world: '" + actualWorldName + "'...");
-                            PS.get().removePlotAreas(actualWorldName);
-                            if (mv) {
-                                // unload world with MV
-                                Bukkit.getServer().dispatchCommand(Bukkit.getServer().getConsoleSender(), "mv unload " + actualWorldName);
-                                try {
-                                    Thread.sleep(1000);
-                                } catch (InterruptedException ex) {
-                                    Thread.currentThread().interrupt();
-                                }
-                                // load world with MV
-                                Bukkit.getServer().dispatchCommand(Bukkit.getServer().getConsoleSender(),
-                                        "mv import " + actualWorldName + " normal -g PlotSquared");
-                            } else if (mw) {
-                                // unload world with MW
-                                Bukkit.getServer().dispatchCommand(Bukkit.getServer().getConsoleSender(), "mw unload " + actualWorldName);
-                                try {
-                                    Thread.sleep(1000);
-                                } catch (InterruptedException ex) {
-                                    Thread.currentThread().interrupt();
-                                }
-                                // load world with MW
-                                Bukkit.getServer().dispatchCommand(Bukkit.getServer().getConsoleSender(),
-                                        "mw create " + actualWorldName + " plugin:PlotSquared");
-                            } else {
-                                // Load using Bukkit API
-                                // - User must set generator manually
-                                Bukkit.getServer().unloadWorld(world, true);
-                                World myWorld = WorldCreator.name(actualWorldName).generator(new BukkitPlotGenerator(new HybridGen())).createWorld();
-                                myWorld.save();
-                            }
-                        }
-                    } catch (CommandException e) {
-                        e.printStackTrace();
-                    }
-                    if (done.get()) {
-                        done();
-                        sendMessage("&aDatabase conversion is now complete!");
-                        PS.debug("&c - Stop the server");
-                        PS.debug("&c - Disable 'plotme-convert.enabled' and 'plotme-convert.cache-uuids' in the settings.yml");
-                        PS.debug("&c - Correct any generator settings that haven't copied to 'settings.yml' properly");
-                        PS.debug("&c - Start the server");
-                    } else {
-                        sendMessage("&cPlease wait until database conversion is complete. You will be notified with instructions when this happens!");
-                        done.set(true);
-                    }
-                }
-            });
-        } catch (Exception e) {
-            e.printStackTrace();
-            PS.debug("&/end/");
-        }
-        return true;
-    }
-
-    public void done() {
-        PS.get().setPlots(DBFunc.getPlots());
-    }
-}

Bukkit/src/main/java/com/plotsquared/bukkit/database/plotme/PlotMeConnector_017.java

@@ -1,202 +0,0 @@
-package com.plotsquared.bukkit.database.plotme;
-
-import com.intellectualcrafters.configuration.file.FileConfiguration;
-import com.intellectualcrafters.plot.PS;
-import com.intellectualcrafters.plot.config.Settings;
-import com.intellectualcrafters.plot.database.DBFunc;
-import com.intellectualcrafters.plot.database.SQLite;
-import com.intellectualcrafters.plot.object.Location;
-import com.intellectualcrafters.plot.object.Plot;
-import com.intellectualcrafters.plot.object.PlotArea;
-import com.intellectualcrafters.plot.object.PlotId;
-import com.intellectualcrafters.plot.object.StringWrapper;
-import com.intellectualcrafters.plot.util.UUIDHandler;
-
-import java.io.File;
-import java.sql.Connection;
-import java.sql.DriverManager;
-import java.sql.PreparedStatement;
-import java.sql.ResultSet;
-import java.sql.SQLException;
-import java.util.HashMap;
-import java.util.Map.Entry;
-import java.util.UUID;
-
-public class PlotMeConnector_017 extends APlotMeConnector {
-
-    private String plugin;
-
-    @Override
-    public Connection getPlotMeConnection(String plugin, FileConfiguration plotConfig, String dataFolder) {
-        this.plugin = plugin.toLowerCase();
-        try {
-            if (plotConfig.getBoolean("usemySQL")) {
-                String user = plotConfig.getString("mySQLuname");
-                String password = plotConfig.getString("mySQLpass");
-                String con = plotConfig.getString("mySQLconn");
-                return DriverManager.getConnection(con, user, password);
-            } else {
-                File file = new File(dataFolder + File.separator + "plotmecore.db");
-                if (file.exists()) {
-                    return new SQLite(dataFolder + File.separator + "plotmecore.db").openConnection();
-                }
-                return new SQLite(dataFolder + File.separator + "plots.db").openConnection();
-            }
-        } catch (SQLException | ClassNotFoundException ignored) {
-            //ignored
-            ignored.printStackTrace();
-        }
-        return null;
-    }
-
-    @Override
-    public HashMap<String, HashMap<PlotId, Plot>> getPlotMePlots(Connection connection) throws SQLException {
-        ResultSet resultSet;
-        PreparedStatement statement;
-        HashMap<String, Integer> plotWidth = new HashMap<>();
-        HashMap<String, Integer> roadWidth = new HashMap<>();
-        HashMap<Integer, Plot> plots = new HashMap<>();
-        HashMap<String, HashMap<PlotId, boolean[]>> merges = new HashMap<>();
-        try {
-            statement = connection.prepareStatement("SELECT * FROM `" + this.plugin + "core_plots`");
-            resultSet = statement.executeQuery();
-        } catch (SQLException e) {
-            PS.debug("========= Table does not exist =========");
-            e.printStackTrace();
-            PS.debug("=======================================");
-            PS.debug("&8 - &7The database does not match the version specified in the PlotMe config");
-            PS.debug("&8 - &7Please correct this, or if you are unsure, the most common is 0.16.3");
-            return null;
-        }
-        boolean checkUUID = DBFunc.hasColumn(resultSet, "ownerID");
-        boolean merge = !this.plugin.equals("plotme") && Settings.CONVERT_PLOTME;
-        while (resultSet.next()) {
-            int key = resultSet.getInt("plot_id");
-            PlotId id = new PlotId(resultSet.getInt("plotX"), resultSet.getInt("plotZ"));
-            String name = resultSet.getString("owner");
-            String world = LikePlotMeConverter.getWorld(resultSet.getString("world"));
-            if (!plots.containsKey(world) && merge) {
-                int plot = PS.get().config.getInt("worlds." + world + ".plot.size");
-                int path = PS.get().config.getInt("worlds." + world + ".road.width");
-                plotWidth.put(world, plot);
-                roadWidth.put(world, path);
-                merges.put(world, new HashMap<PlotId, boolean[]>());
-            }
-            if (merge) {
-                int tx = resultSet.getInt("topX");
-                int tz = resultSet.getInt("topZ");
-                int bx = resultSet.getInt("bottomX") - 1;
-                int bz = resultSet.getInt("bottomZ") - 1;
-                int path = roadWidth.get(world);
-                int plot = plotWidth.get(world);
-                Location top = getPlotTopLocAbs(path, plot, id);
-                Location bot = getPlotBottomLocAbs(path, plot, id);
-                if (tx > top.getX()) {
-                    setMerged(merges, world, id, 1);
-                }
-                if (tz > top.getZ()) {
-                    setMerged(merges, world, id, 2);
-                }
-                if (bx < bot.getX()) {
-                    setMerged(merges, world, id, 3);
-                }
-                if (bz > bot.getZ()) {
-                    setMerged(merges, world, id, 0);
-                }
-            }
-            UUID owner = UUIDHandler.getUUID(name, null);
-            if (owner == null) {
-                if (name.equals("*")) {
-                    owner = DBFunc.everyone;
-                } else {
-                    if (checkUUID) {
-                        try {
-                            byte[] bytes = resultSet.getBytes("ownerid");
-                            if (bytes != null) {
-                                owner = UUID.nameUUIDFromBytes(bytes);
-                                UUIDHandler.add(new StringWrapper(name), owner);
-                            }
-                        } catch (Exception e) {
-                            e.printStackTrace();
-                        }
-                    }
-                    if (owner == null) {
-                        PS.log("&cCould not identify owner for plot: " + id + " -> '" + name + "'");
-                        continue;
-                    }
-                }
-            } else {
-                UUIDHandler.add(new StringWrapper(name), owner);
-            }
-            Plot plot = new Plot(PlotArea.createGeneric(world), id, owner);
-            plots.put(key, plot);
-        }
-        for (Entry<Integer, Plot> entry : plots.entrySet()) {
-            Plot plot = entry.getValue();
-            HashMap<PlotId, boolean[]> mergeMap = merges.get(plot.getArea().worldname);
-            if (mergeMap != null) {
-                if (mergeMap.containsKey(plot.getId())) {
-                    plot.setMerged(mergeMap.get(plot.getId()));
-                }
-            }
-        }
-        resultSet.close();
-        statement.close();
-        try {
-            PS.log(" - " + this.plugin + "core_denied");
-            statement = connection.prepareStatement("SELECT * FROM `" + this.plugin + "core_denied`");
-            resultSet = statement.executeQuery();
-
-            while (resultSet.next()) {
-                int key = resultSet.getInt("plot_id");
-                Plot plot = plots.get(key);
-                if (plot == null) {
-                    PS.log("&6Denied (" + key + ") references deleted plot; ignoring entry.");
-                    continue;
-                }
-                UUID denied = UUID.fromString(resultSet.getString("player"));
-                plot.getDenied().add(denied);
-            }
-
-            PS.log(" - " + this.plugin + "core_allowed");
-            statement = connection.prepareStatement("SELECT * FROM `" + this.plugin + "core_allowed`");
-            resultSet = statement.executeQuery();
-
-            while (resultSet.next()) {
-                int key = resultSet.getInt("plot_id");
-                Plot plot = plots.get(key);
-                if (plot == null) {
-                    PS.log("&6Allowed (" + key + ") references deleted plot; ignoring entry.");
-                    continue;
-                }
-                UUID allowed = UUID.fromString(resultSet.getString("player"));
-                plot.getTrusted().add(allowed);
-            }
-            resultSet.close();
-            statement.close();
-
-        } catch (SQLException e) {
-            e.printStackTrace();
-        }
-        HashMap<String, HashMap<PlotId, Plot>> processed = new HashMap<>();
-
-        for (Entry<Integer, Plot> entry : plots.entrySet()) {
-            Plot plot = entry.getValue();
-            HashMap<PlotId, Plot> map = processed.get(plot.getArea().worldname);
-            if (map == null) {
-                map = new HashMap<>();
-                processed.put(plot.getArea().worldname, map);
-            }
-            map.put(plot.getId(), plot);
-        }
-        return processed;
-    }
-
-    @Override
-    public boolean accepts(String version) {
-        if (version == null) {
-            return false;
-        }
-        return !PS.get().canUpdate(version, "0.17");
-    }
-}

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/events/ClusterFlagRemoveEvent.java

@@ -1,66 +0,0 @@
-package com.plotsquared.bukkit.events;
-
-import com.intellectualcrafters.plot.flag.Flag;
-import com.intellectualcrafters.plot.object.PlotCluster;
-import org.bukkit.event.Cancellable;
-import org.bukkit.event.Event;
-import org.bukkit.event.HandlerList;
-
-/**
- * Called when a flag is removed from a plot.
- */
-public class ClusterFlagRemoveEvent extends Event implements Cancellable {
-
-    private static final HandlerList handlers = new HandlerList();
-    private final PlotCluster cluster;
-    private final Flag flag;
-    private boolean cancelled;
-
-    /**
-     * PlotFlagRemoveEvent: Called when a flag is removed from a plot.
-     *
-     * @param flag Flag that was removed
-     * @param cluster PlotCluster from which the flag was removed
-     */
-    public ClusterFlagRemoveEvent(Flag flag, PlotCluster cluster) {
-        this.cluster = cluster;
-        this.flag = flag;
-    }
-
-    public static HandlerList getHandlerList() {
-        return handlers;
-    }
-
-    /**
-     * Get the cluster involved.
-     *
-     * @return PlotCluster
-     */
-    public PlotCluster getCluster() {
-        return this.cluster;
-    }
-
-    /**
-     * Get the flag involved.
-     *
-     * @return Flag
-     */
-    public Flag getFlag() {
-        return this.flag;
-    }
-
-    @Override
-    public HandlerList getHandlers() {
-        return handlers;
-    }
-
-    @Override
-    public boolean isCancelled() {
-        return this.cancelled;
-    }
-
-    @Override
-    public void setCancelled(boolean b) {
-        this.cancelled = b;
-    }
-}

Bukkit/src/main/java/com/plotsquared/bukkit/events/PlayerClaimPlotEvent.java

@@ -1,62 +0,0 @@
-package com.plotsquared.bukkit.events;
-
-import com.intellectualcrafters.plot.object.Plot;
-import org.bukkit.entity.Player;
-import org.bukkit.event.Cancellable;
-import org.bukkit.event.HandlerList;
-import org.bukkit.event.player.PlayerEvent;
-
-public class PlayerClaimPlotEvent extends PlayerEvent implements Cancellable {
-
-    private static final HandlerList handlers = new HandlerList();
-    private final Plot plot;
-    private final boolean auto;
-    private boolean cancelled;
-
-    /**
-     * PlayerClaimPlotEvent: Called when a plot is claimed.
-     *
-     * @param player Player that claimed the plot
-     * @param plot   Plot that was claimed
-     */
-    public PlayerClaimPlotEvent(Player player, Plot plot, boolean auto) {
-        super(player);
-        this.plot = plot;
-        this.auto = auto;
-    }
-
-    public static HandlerList getHandlerList() {
-        return handlers;
-    }
-
-    /**
-     * Get the plot involved
-     *
-     * @return Plot
-     */
-    public Plot getPlot() {
-        return this.plot;
-    }
-
-    /**
-     * @return true if it was an automated claim, else false
-     */
-    public boolean wasAuto() {
-        return this.auto;
-    }
-
-    @Override
-    public HandlerList getHandlers() {
-        return handlers;
-    }
-
-    @Override
-    public boolean isCancelled() {
-        return this.cancelled;
-    }
-
-    @Override
-    public void setCancelled(boolean b) {
-        this.cancelled = b;
-    }
-}

Bukkit/src/main/java/com/plotsquared/bukkit/events/PlayerEnterPlotEvent.java

@@ -1,41 +0,0 @@
-package com.plotsquared.bukkit.events;
-
-import com.intellectualcrafters.plot.object.Plot;
-import org.bukkit.entity.Player;
-import org.bukkit.event.HandlerList;
-import org.bukkit.event.player.PlayerEvent;
-
-public class PlayerEnterPlotEvent extends PlayerEvent {
-
-    private static final HandlerList handlers = new HandlerList();
-    private final Plot plot;
-
-    /**
-     * Called when a player leaves a plot.
-     *
-     * @param player Player that entered the plot
-     * @param plot   Plot that was entered
-     */
-    public PlayerEnterPlotEvent(Player player, Plot plot) {
-        super(player);
-        this.plot = plot;
-    }
-
-    public static HandlerList getHandlerList() {
-        return handlers;
-    }
-
-    /**
-     * Get the plot involved.
-     *
-     * @return Plot
-     */
-    public Plot getPlot() {
-        return this.plot;
-    }
-
-    @Override
-    public HandlerList getHandlers() {
-        return handlers;
-    }
-}

Bukkit/src/main/java/com/plotsquared/bukkit/events/PlayerLeavePlotEvent.java

@@ -1,45 +0,0 @@
-package com.plotsquared.bukkit.events;
-
-import com.intellectualcrafters.plot.object.Plot;
-import org.bukkit.entity.Player;
-import org.bukkit.event.HandlerList;
-import org.bukkit.event.player.PlayerEvent;
-
-/**
-
-
- */
-public class PlayerLeavePlotEvent extends PlayerEvent {
-
-    private static final HandlerList handlers = new HandlerList();
-    private final Plot plot;
-
-    /**
-     * PlayerLeavePlotEvent: Called when a player leaves a plot
-     *
-     * @param player Player that left the plot
-     * @param plot   Plot that was left
-     */
-    public PlayerLeavePlotEvent(Player player, Plot plot) {
-        super(player);
-        this.plot = plot;
-    }
-
-    public static HandlerList getHandlerList() {
-        return handlers;
-    }
-
-    /**
-     * Get the plot involved
-     *
-     * @return Plot
-     */
-    public Plot getPlot() {
-        return this.plot;
-    }
-
-    @Override
-    public HandlerList getHandlers() {
-        return handlers;
-    }
-}

Bukkit/src/main/java/com/plotsquared/bukkit/events/PlayerPlotDeniedEvent.java

@@ -1,66 +0,0 @@
-package com.plotsquared.bukkit.events;
-
-import com.intellectualcrafters.plot.object.Plot;
-import org.bukkit.entity.Player;
-import org.bukkit.event.HandlerList;
-
-import java.util.UUID;
-
-public class PlayerPlotDeniedEvent extends PlotEvent {
-
-    private static final HandlerList handlers = new HandlerList();
-    private final Player initiator;
-    private final boolean added;
-    private final UUID player;
-
-    /**
-     * PlayerPlotDeniedEvent: Called when the denied UUID list is modified for a plot.
-     *
-     * @param initiator Player that initiated the event
-     * @param plot      Plot in which the event occurred
-     * @param player    Player that was denied/un-denied
-     * @param added     true of add to deny list, false if removed
-     */
-    public PlayerPlotDeniedEvent(Player initiator, Plot plot, UUID player, boolean added) {
-        super(plot);
-        this.initiator = initiator;
-        this.added = added;
-        this.player = player;
-    }
-
-    public static HandlerList getHandlerList() {
-        return handlers;
-    }
-
-    /**
-     * If a user was added.
-     *
-     * @return boolean
-     */
-    public boolean wasAdded() {
-        return this.added;
-    }
-
-    /**
-     * The player added/removed.
-     *
-     * @return UUID
-     */
-    public UUID getPlayer() {
-        return this.player;
-    }
-
-    /**
-     * The player initiating the action.
-     *
-     * @return Player
-     */
-    public Player getInitiator() {
-        return this.initiator;
-    }
-
-    @Override
-    public HandlerList getHandlers() {
-        return handlers;
-    }
-}

Bukkit/src/main/java/com/plotsquared/bukkit/events/PlayerPlotHelperEvent.java

@@ -1,70 +0,0 @@
-package com.plotsquared.bukkit.events;
-
-import com.intellectualcrafters.plot.object.Plot;
-import org.bukkit.entity.Player;
-import org.bukkit.event.HandlerList;
-
-import java.util.UUID;
-
-/**
-
-
- */
-public class PlayerPlotHelperEvent extends PlotEvent {
-
-    private static final HandlerList handlers = new HandlerList();
-    private final Player initiator;
-    private final boolean added;
-    private final UUID player;
-
-    /**
-     * PlayerPlotHelperEvent: Called when a plot helper is added/removed
-     *
-     * @param initiator Player that initiated the event
-     * @param plot      Plot in which the event occurred
-     * @param player    Player that was added/removed from the helper list
-     * @param added     true of the player was added, false if the player was removed
-     */
-    public PlayerPlotHelperEvent(Player initiator, Plot plot, UUID player, boolean added) {
-        super(plot);
-        this.initiator = initiator;
-        this.added = added;
-        this.player = player;
-    }
-
-    public static HandlerList getHandlerList() {
-        return handlers;
-    }
-
-    /**
-     * If a player was added
-     *
-     * @return boolean
-     */
-    public boolean wasAdded() {
-        return this.added;
-    }
-
-    /**
-     * The UUID added/removed
-     *
-     * @return UUID
-     */
-    public UUID getPlayer() {
-        return this.player;
-    }
-
-    /**
-     * The player initiating the action
-     *
-     * @return Player
-     */
-    public Player getInitiator() {
-        return this.initiator;
-    }
-
-    @Override
-    public HandlerList getHandlers() {
-        return handlers;
-    }
-}

Bukkit/src/main/java/com/plotsquared/bukkit/events/PlayerPlotTrustedEvent.java

@@ -1,70 +0,0 @@
-package com.plotsquared.bukkit.events;
-
-import com.intellectualcrafters.plot.object.Plot;
-import org.bukkit.entity.Player;
-import org.bukkit.event.HandlerList;
-
-import java.util.UUID;
-
-/**
-
-
- */
-public class PlayerPlotTrustedEvent extends PlotEvent {
-
-    private static final HandlerList handlers = new HandlerList();
-    private final Player initiator;
-    private final boolean added;
-    private final UUID player;
-
-    /**
-     * PlayerPlotTrustedEvent: Called when a plot trusted user is added/removed
-     *
-     * @param initiator Player that initiated the event
-     * @param plot      Plot in which the event occurred
-     * @param player    Player that was added/removed from the trusted list
-     * @param added     true of the player was added, false if the player was removed
-     */
-    public PlayerPlotTrustedEvent(Player initiator, Plot plot, UUID player, boolean added) {
-        super(plot);
-        this.initiator = initiator;
-        this.added = added;
-        this.player = player;
-    }
-
-    public static HandlerList getHandlerList() {
-        return handlers;
-    }
-
-    /**
-     * If a player was added
-     *
-     * @return boolean
-     */
-    public boolean wasAdded() {
-        return this.added;
-    }
-
-    /**
-     * The UUID added/removed
-     *
-     * @return UUID
-     */
-    public UUID getPlayer() {
-        return this.player;
-    }
-
-    /**
-     * The player initiating the action
-     *
-     * @return Player
-     */
-    public Player getInitiator() {
-        return this.initiator;
-    }
-
-    @Override
-    public HandlerList getHandlers() {
-        return handlers;
-    }
-}

Bukkit/src/main/java/com/plotsquared/bukkit/events/PlayerTeleportToPlotEvent.java

@@ -1,72 +0,0 @@
-package com.plotsquared.bukkit.events;
-
-import com.intellectualcrafters.plot.object.Location;
-import com.intellectualcrafters.plot.object.Plot;
-import org.bukkit.entity.Player;
-import org.bukkit.event.Cancellable;
-import org.bukkit.event.HandlerList;
-import org.bukkit.event.player.PlayerEvent;
-
-/**
- * Called when a player teleports to a plot
- *
-
-
- */
-public class PlayerTeleportToPlotEvent extends PlayerEvent implements Cancellable {
-
-    private static final HandlerList handlers = new HandlerList();
-    private final Location from;
-    private final Plot plot;
-    private boolean cancelled;
-
-    /**
-     * PlayerTeleportToPlotEvent: Called when a player teleports to a plot
-     *
-     * @param player That was teleported
-     * @param from   Start location
-     * @param plot   Plot to which the player was teleported
-     */
-    public PlayerTeleportToPlotEvent(Player player, Location from, Plot plot) {
-        super(player);
-        this.from = from;
-        this.plot = plot;
-    }
-
-    public static HandlerList getHandlerList() {
-        return handlers;
-    }
-
-    @Override
-    public HandlerList getHandlers() {
-        return handlers;
-    }
-
-    /**
-     * Get the from location
-     *
-     * @return Location
-     */
-    public Location getFrom() {
-        return this.from;
-    }
-
-    /**
-     * Get the plot involved
-     *
-     * @return Plot
-     */
-    public Plot getPlot() {
-        return this.plot;
-    }
-
-    @Override
-    public boolean isCancelled() {
-        return this.cancelled;
-    }
-
-    @Override
-    public void setCancelled(boolean cancelled) {
-        this.cancelled = cancelled;
-    }
-}

Bukkit/src/main/java/com/plotsquared/bukkit/events/PlotClearEvent.java

@@ -1,56 +0,0 @@
-package com.plotsquared.bukkit.events;
-
-import com.intellectualcrafters.plot.object.Plot;
-import com.intellectualcrafters.plot.object.PlotId;
-import org.bukkit.event.Cancellable;
-import org.bukkit.event.HandlerList;
-
-/**
- * Called when a plot is cleared
- *
- */
-public class PlotClearEvent extends PlotEvent implements Cancellable {
-
-    private static final HandlerList handlers = new HandlerList();
-    private boolean cancelled;
-    public PlotClearEvent(Plot plot) {
-        super(plot);
-    }
-
-    public static HandlerList getHandlerList() {
-        return handlers;
-    }
-
-    /**
-     * Get the PlotId.
-     *
-     * @return PlotId
-     */
-    public PlotId getPlotId() {
-        return getPlot().getId();
-    }
-
-    /**
-     * Get the world name.
-     *
-     * @return String
-     */
-    public String getWorld() {
-        return getPlot().getArea().worldname;
-    }
-
-    @Override
-    public HandlerList getHandlers() {
-        return handlers;
-    }
-
-    @Override
-    public boolean isCancelled() {
-        return this.cancelled;
-    }
-
-    @Override
-    public void setCancelled(boolean b) {
-        this.cancelled = b;
-    }
-}

Bukkit/src/main/java/com/plotsquared/bukkit/events/PlotDeleteEvent.java

@@ -1,45 +0,0 @@
-package com.plotsquared.bukkit.events;
-
-import com.intellectualcrafters.plot.object.Plot;
-import com.intellectualcrafters.plot.object.PlotId;
-import org.bukkit.event.HandlerList;
-
-/**
- * Called when a plot is deleted
- *
- */
-public class PlotDeleteEvent extends PlotEvent {
-
-    private static final HandlerList handlers = new HandlerList();
-
-    public PlotDeleteEvent(Plot plot) {
-        super(plot);
-    }
-
-    public static HandlerList getHandlerList() {
-        return handlers;
-    }
-
-    /**
-     * Get the PlotId
-     *
-     * @return PlotId
-     */
-    public PlotId getPlotId() {
-        return getPlot().getId();
-    }
-
-    /**
-     * Get the world name
-     *
-     * @return String
-     */
-    public String getWorld() {
-        return getPlot().getArea().worldname;
-    }
-
-    @Override
-    public HandlerList getHandlers() {
-        return handlers;
-    }
-}

Bukkit/src/main/java/com/plotsquared/bukkit/events/PlotEvent.java

@@ -1,18 +0,0 @@
-package com.plotsquared.bukkit.events;
-
-import com.intellectualcrafters.plot.object.Plot;
-import org.bukkit.event.Event;
-
-public abstract class PlotEvent extends Event {
-
-    private final Plot plot;
-
-    public PlotEvent(Plot plot) {
-        this.plot = plot;
-    }
-
-    public final Plot getPlot() {
-        return this.plot;
-    }
-
-}

Bukkit/src/main/java/com/plotsquared/bukkit/events/PlotFlagAddEvent.java

@@ -1,56 +0,0 @@
-package com.plotsquared.bukkit.events;
-
-import com.intellectualcrafters.plot.flag.Flag;
-import com.intellectualcrafters.plot.object.Plot;
-import org.bukkit.event.Cancellable;
-import org.bukkit.event.HandlerList;
-
-/**
- * Called when a Flag is added to a plot.
- *
- */
-public class PlotFlagAddEvent extends PlotEvent implements Cancellable {
-
-    private static final HandlerList handlers = new HandlerList();
-    private final Flag flag;
-    private boolean cancelled;
-
-    /**
-     * PlotFlagAddEvent: Called when a Flag is added to a plot.
-     *
-     * @param flag Flag that was added
-     * @param plot Plot to which the flag was added
-     */
-    public PlotFlagAddEvent(Flag flag, Plot plot) {
-        super(plot);
-        this.flag = flag;
-    }
-
-    public static HandlerList getHandlerList() {
-        return handlers;
-    }
-
-    /**
-     * Get the flag involved.
-     *
-     * @return Flag
-     */
-    public Flag getFlag() {
-        return this.flag;
-    }
-
-    @Override
-    public HandlerList getHandlers() {
-        return handlers;
-    }
-
-    @Override
-    public final boolean isCancelled() {
-        return this.cancelled;
-    }
-
-    @Override
-    public final void setCancelled(boolean cancelled) {
-        this.cancelled = cancelled;
-    }
-}

Bukkit/src/main/java/com/plotsquared/bukkit/events/PlotFlagRemoveEvent.java

@@ -1,56 +0,0 @@
-package com.plotsquared.bukkit.events;
-
-import com.intellectualcrafters.plot.flag.Flag;
-import com.intellectualcrafters.plot.object.Plot;
-import org.bukkit.event.Cancellable;
-import org.bukkit.event.HandlerList;
-
-/**
- * Called when a flag is removed from a plot
- *
- */
-public class PlotFlagRemoveEvent extends PlotEvent implements Cancellable {
-
-    private static final HandlerList handlers = new HandlerList();
-    private final Flag flag;
-    private boolean cancelled;
-
-    /**
-     * PlotFlagRemoveEvent: Called when a flag is removed from a plot
-     *
-     * @param flag Flag that was removed
-     * @param plot Plot from which the flag was removed
-     */
-    public PlotFlagRemoveEvent(Flag flag, Plot plot) {
-        super(plot);
-        this.flag = flag;
-    }
-
-    public static HandlerList getHandlerList() {
-        return handlers;
-    }
-
-    /**
-     * Get the flag involved
-     *
-     * @return Flag
-     */
-    public Flag getFlag() {
-        return this.flag;
-    }
-
-    @Override
-    public HandlerList getHandlers() {
-        return handlers;
-    }
-
-    @Override
-    public final boolean isCancelled() {
-        return this.cancelled;
-    }
-
-    @Override
-    public final void setCancelled(boolean cancelled) {
-        this.cancelled = cancelled;
-    }
-}

Bukkit/src/main/java/com/plotsquared/bukkit/events/PlotMergeEvent.java

@@ -1,62 +0,0 @@
-package com.plotsquared.bukkit.events;
-
-import com.intellectualcrafters.plot.object.Plot;
-import com.intellectualcrafters.plot.object.PlotId;
-import org.bukkit.World;
-import org.bukkit.event.Cancellable;
-import org.bukkit.event.HandlerList;
-
-import java.util.ArrayList;
-
-public class PlotMergeEvent extends PlotEvent implements Cancellable {
-
-    private static final HandlerList handlers = new HandlerList();
-    private final ArrayList<PlotId> plots;
-    private final World world;
-    private boolean cancelled;
-
-    /**
-     * PlotMergeEvent: Called when plots are merged
-     *
-     * @param world World in which the event occurred
-     * @param plot  Plot that was merged
-     * @param plots A list of plots involved in the event
-     */
-    public PlotMergeEvent(World world, Plot plot, ArrayList<PlotId> plots) {
-        super(plot);
-        this.world = world;
-        this.plots = plots;
-    }
-
-    public static HandlerList getHandlerList() {
-        return handlers;
-    }
-
-    /**
-     * Get the plots being added.
-     *
-     * @return Plot
-     */
-    public ArrayList<PlotId> getPlots() {
-        return this.plots;
-    }
-
-    public World getWorld() {
-        return this.world;
-    }
-
-    @Override
-    public HandlerList getHandlers() {
-        return handlers;
-    }
-
-    @Override
-    public boolean isCancelled() {
-        return this.cancelled;
-    }
-
-    @Override
-    public void setCancelled(boolean b) {
-        this.cancelled = b;
-    }
-}

Bukkit/src/main/java/com/plotsquared/bukkit/events/PlotRateEvent.java

@@ -1,41 +0,0 @@
-package com.plotsquared.bukkit.events;
-
-import com.intellectualcrafters.plot.object.Plot;
-import com.intellectualcrafters.plot.object.PlotPlayer;
-import com.intellectualcrafters.plot.object.Rating;
-import org.bukkit.event.HandlerList;
-
-public class PlotRateEvent extends PlotEvent {
-
-    private static final HandlerList handlers = new HandlerList();
-    private final PlotPlayer rater;
-    private Rating rating;
-
-    public PlotRateEvent(PlotPlayer rater, Rating rating, Plot plot) {
-        super(plot);
-        this.rater = rater;
-        this.rating = rating;
-    }
-
-    public static HandlerList getHandlerList() {
-        return handlers;
-    }
-
-    public PlotPlayer getRater() {
-        return this.rater;
-    }
-
-    public Rating getRating() {
-        return this.rating;
-    }
-
-    public void setRating(Rating rating) {
-        this.rating = rating;
-    }
-
-    @Override
-    public HandlerList getHandlers() {
-        return handlers;
-    }
-
-}

Bukkit/src/main/java/com/plotsquared/bukkit/events/PlotUnlinkEvent.java

@@ -1,67 +0,0 @@
-package com.plotsquared.bukkit.events;
-
-import com.intellectualcrafters.plot.object.PlotArea;
-import com.intellectualcrafters.plot.object.PlotId;
-import org.bukkit.World;
-import org.bukkit.event.Cancellable;
-import org.bukkit.event.Event;
-import org.bukkit.event.HandlerList;
-
-import java.util.ArrayList;
-
-public class PlotUnlinkEvent extends Event implements Cancellable {
-
-    private static final HandlerList handlers = new HandlerList();
-    private final ArrayList<PlotId> plots;
-    private final World world;
-    private final PlotArea area;
-    private boolean cancelled;
-
-    /**
-     * Called when a mega-plot is unlinked.
-     *
-     * @param world World in which the event occurred
-     * @param plots Plots that are involved in the event
-     */
-    public PlotUnlinkEvent(World world, PlotArea area, ArrayList<PlotId> plots) {
-        this.plots = plots;
-        this.world = world;
-        this.area = area;
-    }
-
-    public static HandlerList getHandlerList() {
-        return handlers;
-    }
-
-    /**
-     * Get the plots involved.
-     *
-     * @return The {@link PlotId}'s of the plots involved
-     */
-    public ArrayList<PlotId> getPlots() {
-        return this.plots;
-    }
-
-    public World getWorld() {
-        return this.world;
-    }
-
-    public PlotArea getArea() {
-        return this.area;
-    }
-
-    @Override
-    public HandlerList getHandlers() {
-        return handlers;
-    }
-
-    @Override
-    public boolean isCancelled() {
-        return this.cancelled;
-    }
-
-    @Override
-    public void setCancelled(boolean b) {
-        this.cancelled = b;
-    }
-}

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

@@ -1,14 +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.generator;
 
-import com.intellectualcrafters.plot.generator.AugmentedUtils;
+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) {
@@ -25,7 +51,7 @@ public class BukkitAugmentedGenerator extends BlockPopulator {
     }
 
     @Override
-    public void populate(World world, Random r, Chunk chunk) {
-        AugmentedUtils.generate(world.getName(), chunk.getX(), chunk.getZ(), null);
+    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

@@ -1,198 +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.generator;
 
-import com.intellectualcrafters.plot.PS;
-import com.intellectualcrafters.plot.generator.GeneratorWrapper;
-import com.intellectualcrafters.plot.generator.HybridGen;
-import com.intellectualcrafters.plot.generator.IndependentPlotGenerator;
-import com.intellectualcrafters.plot.object.PlotArea;
-import com.intellectualcrafters.plot.object.PlotId;
-import com.intellectualcrafters.plot.object.PlotManager;
-import com.intellectualcrafters.plot.object.PseudoRandom;
-import com.intellectualcrafters.plot.object.SetupObject;
-import com.intellectualcrafters.plot.util.ChunkManager;
-import com.intellectualcrafters.plot.util.MainUtil;
-import com.intellectualcrafters.plot.util.PlotChunk;
-import com.intellectualcrafters.plot.util.SetQueue;
+import com.plotsquared.bukkit.queue.GenChunk;
 import com.plotsquared.bukkit.util.BukkitUtil;
-import com.plotsquared.bukkit.util.block.GenChunk;
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Random;
-import java.util.Set;
-import org.bukkit.Chunk;
+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;
 
-public class BukkitPlotGenerator extends ChunkGenerator implements GeneratorWrapper<ChunkGenerator> {
-    
-    private final PlotChunk<Chunk> chunkSetter;
-    private final PseudoRandom random = new PseudoRandom();
     private final IndependentPlotGenerator plotGenerator;
-    private final List<BlockPopulator> populators = new ArrayList<>();
     private final ChunkGenerator platformGenerator;
     private final boolean full;
+    private List<BlockPopulator> populators;
     private boolean loaded = false;
 
-    public BukkitPlotGenerator(IndependentPlotGenerator generator) {
+    @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.add(new BlockPopulator() {
-            @Override
-            public void populate(World world, Random r, Chunk c) {
-                GenChunk result = (GenChunk) BukkitPlotGenerator.this.chunkSetter;
-                if (result.result_data != null) {
-                    for (int i = 0; i < result.result_data.length; i++) {
-                        byte[] section = result.result_data[i];
-                        if (section == null) {
-                            continue;
-                        }
-                        for (int j = 0; j < section.length; j++) {
-                            int x = MainUtil.x_loc[i][j];
-                            int y = MainUtil.y_loc[i][j];
-                            int z = MainUtil.z_loc[i][j];
-                            c.getBlock(x, y, z).setData(section[j]);
-                        }
-                    }
-                }
-                random.state = c.getX() << 16 | c.getZ() & 0xFFFF;
-                PlotArea area = PS.get().getPlotArea(world.getName(), null);
-                SetQueue.ChunkWrapper wrap = SetQueue.IMP.new ChunkWrapper(area.worldname, c.getX(), c.getZ());
-                PlotChunk<?> chunk = SetQueue.IMP.queue.getChunk(wrap);
-                if (plotGenerator.populateChunk(chunk, area, random)) {
-                    chunk.addToQueue();
-                }
-            }
-        });
-        this.chunkSetter = new GenChunk(null, null);
+        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!");
+            throw new IllegalArgumentException("ChunkGenerator: " + cg.getClass().getName()
+                + " is already a BukkitPlotGenerator!");
         }
+        this.levelName = world;
         this.full = false;
-        PS.debug("BukkitPlotGenerator does not fully support: " + cg);
         this.platformGenerator = cg;
-        this.plotGenerator = new IndependentPlotGenerator() {
-            @Override
-            public void processSetup(SetupObject setup) {}
-            
-            @Override
-            public void initialize(PlotArea area) {}
-            
-            @Override
-            public PlotManager getNewPlotManager() {
-                return new HybridGen().getNewPlotManager();
-            }
-            
-            @Override
-            public String getName() {
-                return cg.getClass().getName();
-            }
-            
-            @Override
-            public PlotArea getNewPlotArea(String world, String id, PlotId min, PlotId max) {
-                return new HybridGen().getNewPlotArea(world, id, min, max);
-            }
-            
-            @Override
-            public void generateChunk(final PlotChunk<?> result, PlotArea settings, PseudoRandom random) {
-                World w = BukkitUtil.getWorld(world);
-                Random r = new Random(result.getChunkWrapper().hashCode());
-                BiomeGrid grid = new BiomeGrid() {
-                    @Override
-                    public void setBiome(int x, int z, Biome biome) {
-                        result.setBiome(x, z, biome.ordinal());
-                    }
-                    
-                    @Override
-                    public Biome getBiome(int arg0, int arg1) {
-                        return Biome.FOREST;
-                    }
-                };
-                try {
-                    // ChunkData will spill a bit
-                    ChunkData data = cg.generateChunkData(w, r, result.getX(), result.getZ(), grid);
-                    if (data != null) {
-                        return;
-                    }
-                } catch (Throwable e) {
-                    //ignored
-                }
-                // Populator spillage
-                short[][] tmp = cg.generateExtBlockSections(w, r, result.getX(), result.getZ(), grid);
-                if (tmp != null) {
-                    for (int i = 0; i < tmp.length; i++) {
-                        short[] section = tmp[i];
-                        if (section == null) {
-                            if (i < 7) {
-                                for (int x = 0; x < 16; x++) {
-                                    for (int z = 0; z < 16; z++) {
-                                        for (int y = i << 4; y < (i << 4) + 16; y++) {
-                                            result.setBlock(x, y, z, (short) 0, (byte) 0);
-                                        }
-                                    }
-                                }
-                            }
-                            continue;
-                        }
-                        for (int j = 0; j < section.length; j++) {
-                            int x = MainUtil.x_loc[i][j];
-                            int y = MainUtil.y_loc[i][j];
-                            int z = MainUtil.z_loc[i][j];
-                            result.setBlock(x, y, z, section[j], (byte) 0);
-                        }
-                    }
-                }
-                for (BlockPopulator populator : cg.getDefaultPopulators(w)) {
-                    populator.populate(w, r, (Chunk) result.getChunk());
-                }
-            }
-        };
-        this.chunkSetter = new GenChunk(null, SetQueue.IMP.new ChunkWrapper(world, 0, 0));
-        if (cg != null) {
-            this.populators.addAll(cg.getDefaultPopulators(BukkitUtil.getWorld(world)));
-        }
+        this.plotGenerator = new DelegatePlotGenerator(cg, world);
         MainUtil.initCache();
     }
-    
-    @Override
-    public void augment(PlotArea area) {
-        BukkitAugmentedGenerator.get(BukkitUtil.getWorld(area.worldname));
+
+    @Override public void augment(PlotArea area) {
+        BukkitAugmentedGenerator.get(BukkitUtil.getWorld(area.getWorldName()));
     }
-    
-    @Override
-    public boolean isFull() {
+
+    @Override public boolean isFull() {
         return this.full;
     }
-    
-    @Override
-    public IndependentPlotGenerator getPlotGenerator() {
+
+    @Override public IndependentPlotGenerator getPlotGenerator() {
         return this.plotGenerator;
     }
-    
-    @Override
-    public ChunkGenerator getPlatformGenerator() {
+
+    @Override public ChunkGenerator getPlatformGenerator() {
         return this.platformGenerator;
     }
 
-
-
-    @Override
-    public List<BlockPopulator> getDefaultPopulators(World world) {
+    @Override @NotNull public List<BlockPopulator> getDefaultPopulators(@NotNull World world) {
         try {
             if (!this.loaded) {
                 String name = world.getName();
-                PS.get().loadWorld(name, this);
-                Set<PlotArea> areas = PS.get().getPlotAreas(name);
+                PlotSquared.get().loadWorld(name, this);
+                Set<PlotArea> areas = PlotSquared.get().getPlotAreas(name);
                 if (!areas.isEmpty()) {
                     PlotArea area = areas.iterator().next();
-                    if (!area.MOB_SPAWNING) {
-                        if (!area.SPAWN_EGGS) {
+                    if (!area.isMobSpawning()) {
+                        if (!area.isSpawnEggs()) {
                             world.setSpawnFlags(false, false);
                         }
                         world.setAmbientSpawnLimit(0);
@@ -212,103 +132,114 @@ public class BukkitPlotGenerator extends ChunkGenerator implements GeneratorWrap
         } catch (Exception e) {
             e.printStackTrace();
         }
-        if (world == null) {
-            return populators;
-        }
-        ArrayList<BlockPopulator> toAdd = new ArrayList<BlockPopulator>();
+        ArrayList<BlockPopulator> toAdd = new ArrayList<>();
         List<BlockPopulator> existing = world.getPopulators();
-        for (BlockPopulator populator : populators) {
-            if (!existing.contains(populator)) {
-                toAdd.add(populator);
+        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
-    public ChunkData generateChunkData(World world, Random random, int cx, int cz, BiomeGrid grid) {
-        GenChunk result = (GenChunk) this.chunkSetter;
+    @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.setChunkWrapper(SetQueue.IMP.new ChunkWrapper(world.getName(), cx, cz));
+        result.setChunk(new ChunkWrapper(world.getName(), x, z));
         // Set the result data
-        result.cd = createChunkData(world);
-        result.grid = grid;
+        result.setChunkData(createChunkData(world));
+        result.biomeGrid = biome;
         result.result = null;
-        result.result_data = 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, cx, cz, grid);
+                return this.platformGenerator.generateChunkData(world, random, x, z, biome);
             } else {
-                generate(world, cx, cz, result);
+                generate(BlockVector2.at(x, z), world, result);
             }
         } catch (Throwable e) {
             e.printStackTrace();
         }
         // Return the result data
-        return result.cd;
+        return result.getChunkData();
     }
-    
-    public void generate(World world, int cx, int cz, GenChunk result) {
+
+    private void generate(BlockVector2 loc, World world, ScopedLocalBlockQueue result) {
         // Load if improperly loaded
         if (!this.loaded) {
             String name = world.getName();
-            PS.get().loadWorld(name, this);
+            PlotSquared.get().loadWorld(name, this);
             this.loaded = true;
         }
-        // Set random seed
-        this.random.state = cx << 16 | cz & 0xFFFF;
         // Process the chunk
-        if (ChunkManager.preProcessChunk(result)) {
+        if (ChunkManager.preProcessChunk(loc, result)) {
             return;
         }
-        PlotArea area = PS.get().getPlotArea(world.getName(), null);
-        this.plotGenerator.generateChunk(this.chunkSetter, area, this.random);
-        ChunkManager.postProcessChunk(result);
-    }
-    
-    @Override
-    public short[][] generateExtBlockSections(World world, Random r, int cx, int cz, BiomeGrid grid) {
-        GenChunk result = (GenChunk) this.chunkSetter;
-        // Set the chunk location
-        result.setChunkWrapper(SetQueue.IMP.new ChunkWrapper(world.getName(), cx, cz));
-        // Set the result data
-        result.result = new short[16][];
-        result.result_data = new byte[16][];
-        result.grid = grid;
-        result.cd = null;
-        // Catch any exceptions (as exceptions usually thrown)
+        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 {
-            // Fill the result data
-            if (this.platformGenerator != this) {
-                return this.platformGenerator.generateExtBlockSections(world, r, cx, cz, grid);
-            } else {
-                generate(world, cx, cz, result);
-            }
+            this.plotGenerator.generateChunk(result, area);
         } catch (Throwable e) {
+            // Recover from generator error
             e.printStackTrace();
         }
-        // Return the result data
-        return result.result;
+        ChunkManager.postProcessChunk(loc, result);
     }
-    
-    /**
-     * Allow spawning everywhere.
-     * @param world Ignored
-     * @param x Ignored
-     * @param z Ignored
-     * @return always true
-     */
-    @Override
-    public boolean canSpawn(World world, int x, int z) {
+
+    @Override public boolean canSpawn(@NotNull final World world, final int x, final int z) {
         return true;
     }
-    
-    @Override
-    public String toString() {
+
+    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;
+            return this.plotGenerator.getName();
         }
         if (this.platformGenerator == null) {
             return "null";
@@ -316,12 +247,12 @@ public class BukkitPlotGenerator extends ChunkGenerator implements GeneratorWrap
             return this.platformGenerator.getClass().getName();
         }
     }
-    
-    @Override
-    public boolean equals(Object obj) {
+
+    @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/listeners/ChunkListener.java

@@ -1,326 +0,0 @@
-package com.plotsquared.bukkit.listeners;
-
-import static com.intellectualcrafters.plot.util.ReflectionUtils.getRefClass;
-
-import com.intellectualcrafters.plot.PS;
-import com.intellectualcrafters.plot.config.Settings;
-import com.intellectualcrafters.plot.object.ChunkLoc;
-import com.intellectualcrafters.plot.object.Location;
-import com.intellectualcrafters.plot.object.Plot;
-import com.intellectualcrafters.plot.object.PlotPlayer;
-import com.intellectualcrafters.plot.util.ReflectionUtils.RefClass;
-import com.intellectualcrafters.plot.util.ReflectionUtils.RefField;
-import com.intellectualcrafters.plot.util.ReflectionUtils.RefMethod;
-import com.intellectualcrafters.plot.util.TaskManager;
-import com.intellectualcrafters.plot.util.UUIDHandler;
-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.util.ArrayDeque;
-import java.util.HashMap;
-import java.util.Map.Entry;
-
-public class ChunkListener implements Listener {
-
-    private RefMethod methodGetHandleChunk;
-    private RefField mustSave;
-    private Chunk lastChunk;
-
-    
-    public ChunkListener() {
-        if (Settings.CHUNK_PROCESSOR_GC || Settings.CHUNK_PROCESSOR_TRIM_ON_SAVE) {
-            try {
-                RefClass classChunk = getRefClass("{nms}.Chunk");
-                RefClass classCraftChunk = getRefClass("{cb}.CraftChunk");
-                this.mustSave = classChunk.getField("mustSave");
-                this.methodGetHandleChunk = classCraftChunk.getMethod("getHandle");
-            } catch (Throwable e) {
-                PS.debug("PlotSquared/Server not compatible for chunk processor trim/gc");
-                Settings.CHUNK_PROCESSOR_GC = false;
-                Settings.CHUNK_PROCESSOR_TRIM_ON_SAVE = false;
-            }
-        }
-        if (!Settings.CHUNK_PROCESSOR_GC) {
-            return;
-        }
-        TaskManager.runTask(new Runnable() {
-            @Override
-            public void run() {
-                int distance = Bukkit.getViewDistance() + 2;
-                HashMap<String, HashMap<ChunkLoc, Integer>> players = new HashMap<>();
-                for (Entry<String, PlotPlayer> entry : UUIDHandler.getPlayers().entrySet()) {
-                    PlotPlayer pp = entry.getValue();
-                    Location location = pp.getLocation();
-                    String world = location.getWorld();
-                    if (!PS.get().hasPlotArea(world)) {
-                        continue;
-                    }
-                    HashMap<ChunkLoc, Integer> map = players.get(world);
-                    if (map == null) {
-                        map = new HashMap<>();
-                        players.put(world, map);
-                    }
-                    ChunkLoc origin = new ChunkLoc(location.getX() >> 4, location.getZ() >> 4);
-                    Integer val = map.get(origin);
-                    int check;
-                    if (val != null) {
-                        if (val == distance) {
-                            continue;
-                        }
-                        check = distance - val;
-                    } else {
-                        check = distance;
-                        map.put(origin, distance);
-                    }
-                    for (int x = -distance; x <= distance; x++) {
-                        if (x >= check || -x >= check) {
-                            continue;
-                        }
-                        for (int z = -distance; z <= distance; z++) {
-                            if (z >= check || -z >= check) {
-                                continue;
-                            }
-                            int weight = distance - Math.max(Math.abs(x), Math.abs(z));
-                            ChunkLoc chunk = new ChunkLoc(x + origin.x, z + origin.z);
-                            val = map.get(chunk);
-                            if (val == null || val < weight) {
-                                map.put(chunk, weight);
-                            }
-
-                        }
-                    }
-                }
-                int time = 300;
-                for (World world : Bukkit.getWorlds()) {
-                    String name = world.getName();
-                    if (!PS.get().hasPlotArea(name)) {
-                        continue;
-                    }
-                    boolean autoSave = world.isAutoSave();
-                    if (autoSave) {
-                        world.setAutoSave(false);
-                    }
-                    HashMap<ChunkLoc, Integer> map = players.get(name);
-                    if (map == null || map.isEmpty()) {
-                        continue;
-                    }
-                    Chunk[] chunks = world.getLoadedChunks();
-                    ArrayDeque<Chunk> toUnload = new ArrayDeque<>();
-                    for (Chunk chunk : chunks) {
-                        int x = chunk.getX();
-                        int z = chunk.getZ();
-                        if (!map.containsKey(new ChunkLoc(x, z))) {
-                            toUnload.add(chunk);
-                        }
-                    }
-                    if (!toUnload.isEmpty()) {
-                        long start = System.currentTimeMillis();
-                        Chunk chunk;
-                        while ((chunk = toUnload.poll()) != null && System.currentTimeMillis() - start < 5) {
-                            if (!Settings.CHUNK_PROCESSOR_TRIM_ON_SAVE || !unloadChunk(name, chunk)) {
-                                if (chunk.isLoaded()) {
-                                    chunk.unload(true, false);
-                                }
-                            }
-                        }
-                        if (!toUnload.isEmpty()) {
-                            time = 1;
-                        }
-                    }
-                    if (!Settings.CHUNK_PROCESSOR_TRIM_ON_SAVE && autoSave) {
-                        world.setAutoSave(true);
-                    }
-                }
-                TaskManager.runTaskLater(this, time);
-            }
-        });
-    }
-
-    public boolean unloadChunk(String world, Chunk chunk) {
-        int X = chunk.getX();
-        int Z = chunk.getZ();
-        int x = X << 4;
-        int z = Z << 4;
-        int x2 = x + 15;
-        int z2 = z + 15;
-        Plot plot = new Location(world, x, 1, z).getOwnedPlotAbs();
-        if (plot != null && plot.hasOwner()) {
-            return false;
-        }
-        plot = new Location(world, x2, 1, z2).getOwnedPlotAbs();
-        if (plot != null && plot.hasOwner()) {
-            return false;
-        }
-        plot = new Location(world, x2, 1, z).getOwnedPlotAbs();
-        if (plot != null && plot.hasOwner()) {
-            return false;
-        }
-        plot = new Location(world, x, 1, z2).getOwnedPlotAbs();
-        if (plot != null && plot.hasOwner()) {
-            return false;
-        }
-        plot = new Location(world, x + 7, 1, z + 7).getOwnedPlotAbs();
-        if (plot != null && plot.hasOwner()) {
-            return false;
-        }
-        Object c = this.methodGetHandleChunk.of(chunk).call();
-        this.mustSave.of(c).set(false);
-        if (chunk.isLoaded()) {
-            chunk.unload(false, false);
-        }
-        return true;
-    }
-    
-    @EventHandler
-    public void onChunkUnload(ChunkUnloadEvent event) {
-        if (Settings.CHUNK_PROCESSOR_TRIM_ON_SAVE) {
-            Chunk chunk = event.getChunk();
-            String world = chunk.getWorld().getName();
-            if (PS.get().hasPlotArea(world)) {
-                if (unloadChunk(world, chunk)) {
-                    return;
-                }
-            }
-        }
-        if (processChunk(event.getChunk(), true)) {
-            event.setCancelled(true);
-        }
-    }
-    
-    @EventHandler
-    public void onChunkLoad(ChunkLoadEvent event) {
-        processChunk(event.getChunk(), false);
-    }
-    
-    @EventHandler(priority = EventPriority.LOWEST)
-    public void onItemSpawn(ItemSpawnEvent event) {
-        Item entity = event.getEntity();
-        Chunk chunk = entity.getLocation().getChunk();
-        if (chunk == this.lastChunk) {
-            event.getEntity().remove();
-            event.setCancelled(true);
-            return;
-        }
-        if (!PS.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();
-        Chunk chunk = entity.getLocation().getChunk();
-        if (chunk == this.lastChunk) {
-            event.getEntity().remove();
-            event.setCancelled(true);
-            return;
-        }
-        if (!PS.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(new Runnable() {
-            @Override
-            public void run() {
-                if (!chunk.isLoaded()) {
-                    Bukkit.getScheduler().cancelTask(TaskManager.tasks.get(currentIndex));
-                    TaskManager.tasks.remove(currentIndex);
-                    PS.debug("[PlotSquared] &aSuccessfully processed and unloaded chunk!");
-                    chunk.unload(true, true);
-                    return;
-                }
-                BlockState[] tiles = chunk.getTileEntities();
-                if (tiles.length == 0) {
-                    Bukkit.getScheduler().cancelTask(TaskManager.tasks.get(currentIndex));
-                    TaskManager.tasks.remove(currentIndex);
-                    PS.debug("[PlotSquared] &aSuccessfully processed and unloaded chunk!");
-                    chunk.unload(true, true);
-                    return;
-                }
-                long start = System.currentTimeMillis();
-                int i = 0;
-                while (System.currentTimeMillis() - start < 250) {
-                    if (i >= tiles.length) {
-                        Bukkit.getScheduler().cancelTask(TaskManager.tasks.get(currentIndex));
-                        TaskManager.tasks.remove(currentIndex);
-                        PS.debug("[PlotSquared] &aSuccessfully processed and unloaded chunk!");
-                        chunk.unload(true, true);
-                        return;
-                    }
-                    tiles[i].getBlock().setType(Material.AIR, false);
-                    i++;
-                }
-            }
-        }, 5);
-        TaskManager.tasks.put(currentIndex, task);
-    }
-
-    public boolean processChunk(Chunk chunk, boolean unload) {
-        if (!PS.get().hasPlotArea(chunk.getWorld().getName())) {
-            return false;
-        }
-        Entity[] entities = chunk.getEntities();
-        BlockState[] tiles = chunk.getTileEntities();
-        if (entities.length > Settings.CHUNK_PROCESSOR_MAX_ENTITIES) {
-            for (Entity ent : entities) {
-                if (!(ent instanceof Player)) {
-                    ent.remove();
-                }
-            }
-            PS.debug("[PlotSquared] &a detected unsafe chunk and processed: " + (chunk.getX() << 4) + "," + (chunk.getX() << 4));
-        }
-        if (tiles.length > Settings.CHUNK_PROCESSOR_MAX_BLOCKSTATES) {
-            if (unload) {
-                PS.debug("[PlotSquared] &c detected unsafe chunk: " + (chunk.getX() << 4) + "," + (chunk.getX() << 4));
-                cleanChunk(chunk);
-                return true;
-            }
-            for (BlockState tile : tiles) {
-                tile.getBlock().setType(Material.AIR, false);
-            }
-        }
-        return false;
-    }
-}

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

@@ -1,105 +0,0 @@
-package com.plotsquared.bukkit.listeners;
-
-import com.intellectualcrafters.plot.flag.FlagManager;
-import com.intellectualcrafters.plot.object.Location;
-import com.intellectualcrafters.plot.object.Plot;
-import com.intellectualcrafters.plot.object.PlotPlayer;
-import com.plotsquared.bukkit.events.PlayerEnterPlotEvent;
-import com.plotsquared.bukkit.object.BukkitPlayer;
-import com.plotsquared.bukkit.util.BukkitUtil;
-import org.bukkit.entity.Entity;
-import org.bukkit.entity.Player;
-import org.bukkit.event.EventHandler;
-import org.bukkit.event.Listener;
-import org.bukkit.util.Vector;
-
-import java.util.HashSet;
-import java.util.Set;
-import java.util.UUID;
-
-public class ForceFieldListener implements Listener {
-
-    private Set<PlotPlayer> getNearbyPlayers(Player player, Plot plot) {
-        Set<PlotPlayer> players = new HashSet<>();
-        for (Entity entity : player.getNearbyEntities(5d, 5d, 5d)) {
-            PlotPlayer pp;
-            if (!(entity instanceof Player) || ((pp = BukkitUtil.getPlayer((Player) entity)) == null) || !plot.equals(pp.getCurrentPlot())) {
-                continue;
-            }
-            if (!plot.isAdded(pp.getUUID())) {
-                players.add(pp);
-            }
-        }
-        return players;
-    }
-
-    private PlotPlayer hasNearbyPermitted(Player player, Plot plot) {
-        for (Entity entity : player.getNearbyEntities(5d, 5d, 5d)) {
-            PlotPlayer pp;
-            if (!(entity instanceof Player) || ((pp = BukkitUtil.getPlayer((Player) entity)) == null) || !plot.equals(pp.getCurrentPlot())) {
-                continue;
-            }
-            if (plot.isAdded(pp.getUUID())) {
-                return pp;
-            }
-        }
-        return null;
-    }
-
-    public Vector calculateVelocity(PlotPlayer pp, PlotPlayer e) {
-        Location playerLocation = pp.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);
-    }
-
-    @EventHandler
-    public void onPlotEntry(PlayerEnterPlotEvent event) {
-        Player player = event.getPlayer();
-        PlotPlayer pp = BukkitUtil.getPlayer(player);
-        Plot plot = event.getPlot();
-        if (plot == null) {
-            return;
-        }
-        if ((FlagManager.getPlotFlagRaw(plot, "forcefield") != null) && FlagManager.getPlotFlagRaw(plot, "forcefield").getValue().equals("true")) {
-            if (!FlagManager.isBooleanFlag(plot, "forcefield", false)) {
-                UUID uuid = pp.getUUID();
-                if (plot.isAdded(uuid)) {
-                    Set<PlotPlayer> players = getNearbyPlayers(player, plot);
-                    for (PlotPlayer oPlayer : players) {
-                        ((BukkitPlayer) oPlayer).player.setVelocity(calculateVelocity(pp, oPlayer));
-                    }
-                } else {
-                    PlotPlayer oPlayer = hasNearbyPermitted(player, plot);
-                    if (oPlayer == null) {
-                        return;
-                    }
-                    player.setVelocity(calculateVelocity(oPlayer, pp));
-                }
-            }
-        }
-    }
-}

Bukkit/src/main/java/com/plotsquared/bukkit/listeners/PlayerEvents183.java

@@ -1,49 +0,0 @@
-package com.plotsquared.bukkit.listeners;
-
-import com.intellectualcrafters.plot.PS;
-import com.intellectualcrafters.plot.flag.FlagManager;
-import com.intellectualcrafters.plot.object.Location;
-import com.intellectualcrafters.plot.object.Plot;
-import com.intellectualcrafters.plot.object.PlotArea;
-import com.plotsquared.bukkit.util.BukkitUtil;
-import org.bukkit.block.Block;
-import org.bukkit.event.EventHandler;
-import org.bukkit.event.EventPriority;
-import org.bukkit.event.Listener;
-import org.bukkit.event.block.BlockExplodeEvent;
-
-import java.util.Iterator;
-
-public class PlayerEvents183 implements Listener {
-    @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
-    public void onBigBoom(BlockExplodeEvent event) {
-        Block block = event.getBlock();
-        Location loc = BukkitUtil.getLocation(block.getLocation());
-        String world = loc.getWorld();
-        if (!PS.get().hasPlotArea(world)) {
-            return;
-        }
-        PlotArea area = loc.getPlotArea();
-        if (area == null) {
-            Iterator<Block> iterator = event.blockList().iterator();
-            while (iterator.hasNext()) {
-                loc = BukkitUtil.getLocation(iterator.next().getLocation());
-                if (loc.getPlotArea() != null) {
-                    iterator.remove();
-                }
-            }
-            return;
-        }
-        Plot plot = area.getOwnedPlot(loc);
-        if (plot == null || !FlagManager.isPlotFlagTrue(plot, "explosion")) {
-            event.setCancelled(true);
-        }
-        Iterator<Block> iterator = event.blockList().iterator();
-        while (iterator.hasNext()) {
-            Block b = iterator.next();
-            if (!plot.equals(area.getOwnedPlot(BukkitUtil.getLocation(b.getLocation())))) {
-                iterator.remove();
-            }
-        }
-    }
-}

Bukkit/src/main/java/com/plotsquared/bukkit/listeners/PlayerEvents_1_8.java

@@ -1,150 +0,0 @@
-package com.plotsquared.bukkit.listeners;
-
-import com.intellectualcrafters.plot.PS;
-import com.intellectualcrafters.plot.config.C;
-import com.intellectualcrafters.plot.object.Location;
-import com.intellectualcrafters.plot.object.Plot;
-import com.intellectualcrafters.plot.object.PlotArea;
-import com.intellectualcrafters.plot.object.PlotPlayer;
-import com.intellectualcrafters.plot.util.MainUtil;
-import com.intellectualcrafters.plot.util.Permissions;
-import com.plotsquared.bukkit.util.BukkitUtil;
-import com.plotsquared.listener.PlotListener;
-import org.bukkit.block.Block;
-import org.bukkit.block.BlockState;
-import org.bukkit.entity.ArmorStand;
-import org.bukkit.entity.Entity;
-import org.bukkit.entity.HumanEntity;
-import org.bukkit.entity.Player;
-import org.bukkit.event.EventHandler;
-import org.bukkit.event.EventPriority;
-import org.bukkit.event.Listener;
-import org.bukkit.event.inventory.InventoryAction;
-import org.bukkit.event.inventory.InventoryClickEvent;
-import org.bukkit.event.player.PlayerInteractAtEntityEvent;
-import org.bukkit.inventory.ItemStack;
-import org.bukkit.inventory.PlayerInventory;
-import org.bukkit.inventory.meta.ItemMeta;
-
-import java.util.HashSet;
-import java.util.List;
-import java.util.UUID;
-
-public class PlayerEvents_1_8 extends PlotListener implements Listener {
-    
-    @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
-    public void onInventoryClick(InventoryClickEvent event) {
-        if (!event.isLeftClick() || (event.getAction() != InventoryAction.PLACE_ALL) || event.isShiftClick()) {
-            return;
-        }
-        HumanEntity entity = event.getWhoClicked();
-        if (!(entity instanceof Player) || !PS.get().hasPlotArea(entity.getWorld().getName())) {
-            return;
-        }
-        Player player = (Player) entity;
-        PlayerInventory inv = player.getInventory();
-        int slot = inv.getHeldItemSlot();
-        if ((slot != event.getSlot()) || (slot > 8) || !event.getEventName().equals("InventoryCreativeEvent")) {
-            return;
-        }
-        ItemStack current = inv.getItemInHand();
-        ItemStack newItem = event.getCursor();
-        ItemMeta newMeta = newItem.getItemMeta();
-        ItemMeta oldMeta = newItem.getItemMeta();
-        String newLore = "";
-        if (newMeta != null) {
-            List<String> lore = newMeta.getLore();
-            if (lore != null) {
-                newLore = lore.toString();
-            }
-        }
-        String oldLore = "";
-        if (oldMeta != null) {
-            List<String> lore = oldMeta.getLore();
-            if (lore != null) {
-                oldLore = lore.toString();
-            }
-        }
-        if (!newLore.equals("[(+NBT)]") || (current.equals(newItem) && newLore.equals(oldLore))) {
-            return;
-        }
-        HashSet<Byte> blocks = null;
-        Block block = player.getTargetBlock(blocks, 7);
-        BlockState state = block.getState();
-        if (state == null) {
-            return;
-        }
-        if (state.getType() != newItem.getType()) {
-            return;
-        }
-        Location l = BukkitUtil.getLocation(state.getLocation());
-        PlotArea area = l.getPlotArea();
-        if (area == null) {
-            return;
-        }
-        Plot plot = area.getPlotAbs(l);
-        PlotPlayer pp = BukkitUtil.getPlayer(player);
-        boolean cancelled = false;
-        if (plot == null) {
-            if (!Permissions.hasPermission(pp, "plots.admin.interact.road")) {
-                MainUtil.sendMessage(pp, C.NO_PERMISSION_EVENT, "plots.admin.interact.road");
-                cancelled = true;
-            }
-        } else if (!plot.hasOwner()) {
-            if (!Permissions.hasPermission(pp, "plots.admin.interact.unowned")) {
-                MainUtil.sendMessage(pp, C.NO_PERMISSION_EVENT, "plots.admin.interact.unowned");
-                cancelled = true;
-            }
-        } else {
-            UUID uuid = pp.getUUID();
-            if (!plot.isAdded(uuid)) {
-                if (!Permissions.hasPermission(pp, "plots.admin.interact.other")) {
-                    MainUtil.sendMessage(pp, C.NO_PERMISSION_EVENT, "plots.admin.interact.other");
-                    cancelled = true;
-                }
-            }
-        }
-        if (cancelled) {
-            if ((current.getType() == newItem.getType()) && (current.getDurability() == newItem.getDurability())) {
-                event.setCursor(new ItemStack(newItem.getType(), newItem.getAmount(), newItem.getDurability()));
-                event.setCancelled(true);
-                return;
-            }
-            event.setCursor(new ItemStack(newItem.getType(), newItem.getAmount(), newItem.getDurability()));
-        }
-    }
-    
-    @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
-    public void onInteract(PlayerInteractAtEntityEvent e) {
-        Entity entity = e.getRightClicked();
-        if (!(entity instanceof ArmorStand)) {
-            return;
-        }
-        Location l = BukkitUtil.getLocation(e.getRightClicked().getLocation());
-        PlotArea area = l.getPlotArea();
-        if (area == null) {
-            return;
-        }
-        Plot plot = area.getPlotAbs(l);
-        PlotPlayer pp = BukkitUtil.getPlayer(e.getPlayer());
-        if (plot == null) {
-            if (!Permissions.hasPermission(pp, "plots.admin.interact.road")) {
-                MainUtil.sendMessage(pp, C.NO_PERMISSION_EVENT, "plots.admin.interact.road");
-                e.setCancelled(true);
-            }
-        } else if (!plot.hasOwner()) {
-            if (!Permissions.hasPermission(pp, "plots.admin.interact.unowned")) {
-                MainUtil.sendMessage(pp, C.NO_PERMISSION_EVENT, "plots.admin.interact.unowned");
-                e.setCancelled(true);
-            }
-        } else {
-            UUID uuid = pp.getUUID();
-            if (!plot.isAdded(uuid)) {
-                if (!Permissions.hasPermission(pp, "plots.admin.interact.other")) {
-                    MainUtil.sendMessage(pp, C.NO_PERMISSION_EVENT, "plots.admin.interact.other");
-                    e.setCancelled(true);
-                }
-            }
-        }
-    }
-}

Bukkit/src/main/java/com/plotsquared/bukkit/listeners/PlayerEvents_1_9.java

@@ -1,34 +0,0 @@
-package com.plotsquared.bukkit.listeners;
-
-import com.intellectualcrafters.plot.PS;
-import com.intellectualcrafters.plot.object.Location;
-import com.plotsquared.bukkit.util.BukkitUtil;
-import org.bukkit.entity.LingeringPotion;
-import org.bukkit.event.EventHandler;
-import org.bukkit.event.EventPriority;
-import org.bukkit.event.Listener;
-import org.bukkit.event.entity.LingeringPotionSplashEvent;
-
-/**
- * Created by Jesse on 3/30/2016.
- */
-public class PlayerEvents_1_9 implements Listener {
-
-    private final PlayerEvents parent;
-
-    public PlayerEvents_1_9(PlayerEvents parent) {
-        this.parent = parent;
-    }
-
-    @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
-    public void onPotionSplash(LingeringPotionSplashEvent event) {
-        LingeringPotion entity = event.getEntity();
-        Location l = BukkitUtil.getLocation(entity);
-        if (!PS.get().hasPlotArea(l.getWorld())) {
-            return;
-        }
-        if (!parent.onProjectileHit(event)) {
-            event.setCancelled(true);
-        }
-    }
-}

Bukkit/src/main/java/com/plotsquared/bukkit/listeners/PlotPlusListener.java

@@ -1,190 +0,0 @@
-package com.plotsquared.bukkit.listeners;
-
-import com.intellectualcrafters.plot.flag.Flag;
-import com.intellectualcrafters.plot.flag.FlagManager;
-import com.intellectualcrafters.plot.object.Plot;
-import com.intellectualcrafters.plot.object.PlotPlayer;
-import com.plotsquared.bukkit.events.PlayerEnterPlotEvent;
-import com.plotsquared.bukkit.events.PlayerLeavePlotEvent;
-import com.plotsquared.bukkit.util.BukkitUtil;
-import com.plotsquared.listener.PlotListener;
-import org.bukkit.Bukkit;
-import org.bukkit.GameMode;
-import org.bukkit.entity.EntityType;
-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.BlockDamageEvent;
-import org.bukkit.event.entity.EntityDamageEvent;
-import org.bukkit.event.player.PlayerDropItemEvent;
-import org.bukkit.event.player.PlayerPickupItemEvent;
-import org.bukkit.event.player.PlayerQuitEvent;
-import org.bukkit.plugin.java.JavaPlugin;
-
-import java.util.HashMap;
-import java.util.Iterator;
-import java.util.Map.Entry;
-import java.util.UUID;
-
-public class PlotPlusListener extends PlotListener implements Listener {
-
-    private static final HashMap<String, Interval> feedRunnable = new HashMap<>();
-    private static final HashMap<String, Interval> healRunnable = new HashMap<>();
-
-    public static void startRunnable(JavaPlugin plugin) {
-        plugin.getServer().getScheduler().scheduleSyncRepeatingTask(plugin, new Runnable() {
-            @Override
-            public void run() {
-                if (!healRunnable.isEmpty()) {
-                    for (Iterator<Entry<String, Interval>> iterator = healRunnable.entrySet().iterator(); iterator.hasNext(); ) {
-                        Entry<String, Interval> entry = iterator.next();
-                        Interval value = entry.getValue();
-                        ++value.count;
-                        if (value.count == value.interval) {
-                            value.count = 0;
-                            Player player = Bukkit.getPlayer(entry.getKey());
-                            if (player == null) {
-                                iterator.remove();
-                                continue;
-                            }
-                            double level = player.getHealth();
-                            if (level != value.max) {
-                                player.setHealth(Math.min(level + value.amount, value.max));
-                            }
-                        }
-                    }
-                }
-                if (!feedRunnable.isEmpty()) {
-                    for (Iterator<Entry<String, Interval>> iterator = feedRunnable.entrySet().iterator(); iterator.hasNext(); ) {
-                        Entry<String, Interval> entry = iterator.next();
-                        Interval value = entry.getValue();
-                        ++value.count;
-                        if (value.count == value.interval) {
-                            value.count = 0;
-                            Player player = Bukkit.getPlayer(entry.getKey());
-                            if (player == null) {
-                                iterator.remove();
-                                continue;
-                            }
-                            int level = player.getFoodLevel();
-                            if (level != value.max) {
-                                player.setFoodLevel(Math.min(level + value.amount, value.max));
-                            }
-                        }
-                    }
-                }
-            }
-        }, 0L, 20L);
-    }
-
-    @EventHandler(priority = EventPriority.HIGH)
-    public void onInteract(BlockDamageEvent event) {
-        Player player = event.getPlayer();
-        if (player.getGameMode() != GameMode.SURVIVAL) {
-            return;
-        }
-        Plot plot = BukkitUtil.getLocation(player).getOwnedPlot();
-        if (plot == null) {
-            return;
-        }
-        if (FlagManager.isBooleanFlag(plot, "instabreak", false)) {
-            event.getBlock().breakNaturally();
-        }
-    }
-    
-    @EventHandler(priority = EventPriority.HIGH)
-    public void onDamage(EntityDamageEvent event) {
-        if (event.getEntityType() != EntityType.PLAYER) {
-            return;
-        }
-        Player player = (Player) event.getEntity();
-        Plot plot = BukkitUtil.getLocation(player).getOwnedPlot();
-        if (plot == null) {
-            return;
-        }
-        if (FlagManager.isBooleanFlag(plot, "invincible", false)) {
-            event.setCancelled(true);
-        }
-    }
-    
-    @EventHandler
-    public void onItemPickup(PlayerPickupItemEvent event) {
-        Player player = event.getPlayer();
-        PlotPlayer pp = BukkitUtil.getPlayer(player);
-        Plot plot = BukkitUtil.getLocation(player).getOwnedPlot();
-        if (plot == null) {
-            return;
-        }
-        UUID uuid = pp.getUUID();
-        if (plot.isAdded(uuid) && FlagManager.isBooleanFlag(plot, "drop-protection", false)) {
-            event.setCancelled(true);
-        }
-    }
-    
-    @EventHandler
-    public void onItemDrop(PlayerDropItemEvent event) {
-        Player player = event.getPlayer();
-        PlotPlayer pp = BukkitUtil.getPlayer(player);
-        Plot plot = BukkitUtil.getLocation(player).getOwnedPlot();
-        if (plot == null) {
-            return;
-        }
-        UUID uuid = pp.getUUID();
-        if (plot.isAdded(uuid) && FlagManager.isBooleanFlag(plot, "item-drop", false)) {
-            event.setCancelled(true);
-        }
-    }
-    
-    @EventHandler
-    public void onPlotEnter(PlayerEnterPlotEvent event) {
-        Player player = event.getPlayer();
-        Plot plot = event.getPlot();
-        Flag feed = FlagManager.getPlotFlagRaw(plot, "feed");
-        if (feed != null) {
-            Integer[] value = (Integer[]) feed.getValue();
-            feedRunnable.put(player.getName(), new Interval(value[0], value[1], 20));
-        }
-        Flag heal = FlagManager.getPlotFlagRaw(plot, "heal");
-        if (heal != null) {
-            Integer[] value = (Integer[]) heal.getValue();
-            healRunnable.put(player.getName(), new Interval(value[0], value[1], 20));
-        }
-    }
-    
-    @EventHandler
-    public void onPlayerQuit(PlayerQuitEvent event) {
-        Player player = event.getPlayer();
-        String name = player.getName();
-        feedRunnable.remove(name);
-        healRunnable.remove(name);
-    }
-    
-    @EventHandler
-    public void onPlotLeave(PlayerLeavePlotEvent event) {
-        Player leaver = event.getPlayer();
-        Plot plot = event.getPlot();
-        if (!plot.hasOwner()) {
-            return;
-        }
-        BukkitUtil.getPlayer(leaver);
-        String name = leaver.getName();
-        feedRunnable.remove(name);
-        healRunnable.remove(name);
-    }
-
-    private static class Interval {
-
-        final int interval;
-        final int amount;
-        final int max;
-        public int count = 0;
-
-        Interval(int interval, int amount, int max) {
-            this.interval = interval;
-            this.amount = amount;
-            this.max = max;
-        }
-    }
-
-}

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

@@ -1,26 +0,0 @@
-package com.plotsquared.bukkit.listeners;
-
-import com.intellectualcrafters.plot.PS;
-import com.intellectualcrafters.plot.generator.GeneratorWrapper;
-import com.plotsquared.bukkit.generator.BukkitPlotGenerator;
-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;
-
-public class WorldEvents implements Listener {
-    
-    @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
-    public void onWorldInit(WorldInitEvent event) {
-        World world = event.getWorld();
-        String name = world.getName();
-        ChunkGenerator gen = world.getGenerator();
-        if (gen instanceof GeneratorWrapper) {
-            PS.get().loadWorld(name, (GeneratorWrapper<?>) gen);
-        } else {
-            PS.get().loadWorld(name, new BukkitPlotGenerator(name, gen));
-        }
-    }
-}

Bukkit/src/main/java/com/plotsquared/bukkit/listeners/worldedit/WEListener.java

@@ -1,329 +0,0 @@
-package com.plotsquared.bukkit.listeners.worldedit;
-
-import com.intellectualcrafters.plot.PS;
-import com.intellectualcrafters.plot.config.C;
-import com.intellectualcrafters.plot.config.Settings;
-import com.intellectualcrafters.plot.object.Plot;
-import com.intellectualcrafters.plot.object.PlotPlayer;
-import com.intellectualcrafters.plot.object.RegionWrapper;
-import com.intellectualcrafters.plot.util.MainUtil;
-import com.intellectualcrafters.plot.util.Permissions;
-import com.intellectualcrafters.plot.util.SetQueue;
-import com.plotsquared.bukkit.BukkitMain;
-import com.plotsquared.bukkit.util.BukkitUtil;
-import com.plotsquared.listener.WEManager;
-import com.sk89q.worldedit.BlockVector;
-import com.sk89q.worldedit.bukkit.WorldEditPlugin;
-import com.sk89q.worldedit.bukkit.selections.Selection;
-import org.bukkit.Bukkit;
-import org.bukkit.entity.Player;
-import org.bukkit.event.Cancellable;
-import org.bukkit.event.EventHandler;
-import org.bukkit.event.EventPriority;
-import org.bukkit.event.HandlerList;
-import org.bukkit.event.Listener;
-import org.bukkit.event.player.PlayerCommandPreprocessEvent;
-
-import java.util.Arrays;
-import java.util.Collections;
-import java.util.HashSet;
-
-public class WEListener implements Listener {
-
-    public final HashSet<String> rad1 = new HashSet<>(
-            Arrays.asList("forestgen", "pumpkins", "drain", "fixwater", "fixlava", "replacenear", "snow", "thaw", "ex", "butcher", "size"));
-    public final HashSet<String> rad2 = new HashSet<>(Arrays.asList("fill", "fillr", "removenear", "remove"));
-    public final HashSet<String> rad2_1 = new HashSet<>(Arrays.asList("hcyl", "cyl"));
-    public final HashSet<String> rad2_2 = new HashSet<>(Arrays.asList("sphere", "pyramid"));
-    public final HashSet<String> rad2_3 = new HashSet<>(Collections.singletonList("brush smooth"));
-    public final HashSet<String> rad3_1 = new HashSet<>(Collections.singletonList("brush gravity"));
-    public final HashSet<String> rad3_2 = new HashSet<>(Arrays.asList("brush sphere", "brush cylinder"));
-
-    public final HashSet<String> region = new HashSet<>(
-            Arrays.asList("move", "set", "replace", "overlay", "walls", "outline", "deform", "hollow", "smooth", "naturalize", "paste", "count",
-                    "distr",
-                    "regen", "copy", "cut", "green", "setbiome"));
-    public final HashSet<String> regionExtend = new HashSet<>(Collections.singletonList("stack"));
-    public final HashSet<String> restricted = new HashSet<>(Collections.singletonList("up"));
-    public final HashSet<String> other = new HashSet<>(Arrays.asList("undo", "redo"));
-
-    public String reduceCmd(String cmd, boolean single) {
-        if (cmd.startsWith("/worldedit:/")) {
-            return cmd.substring(12);
-        }
-        if (cmd.startsWith("/worldedit:")) {
-            return cmd.substring(11);
-        }
-        if (cmd.startsWith("//")) {
-            return cmd.substring(2);
-        }
-        if (single && cmd.startsWith("/")) {
-            return cmd.substring(1);
-        }
-        return cmd;
-    }
-
-    public int getInt(String s) {
-        try {
-            int max = 0;
-            String[] split = s.split(",");
-            for (String rad : split) {
-                int val = Integer.parseInt(rad);
-                if (val > max) {
-                    max = val;
-                }
-            }
-            return max;
-        } catch (NumberFormatException e) {
-            return 0;
-        }
-    }
-
-    public boolean checkVolume(PlotPlayer player, long volume, long max, Cancellable e) {
-        if (volume > max) {
-            MainUtil.sendMessage(player, C.WORLDEDIT_VOLUME.s().replaceAll("%current%", volume + "").replaceAll("%max%", max + ""));
-            e.setCancelled(true);
-        }
-        if (Permissions.hasPermission(player, "plots.worldedit.bypass")) {
-            MainUtil.sendMessage(player, C.WORLDEDIT_BYPASS);
-        }
-        return true;
-    }
-
-    public boolean checkSelection(Player p, PlotPlayer pp, int modifier, long max, Cancellable e) {
-        Selection selection = BukkitMain.worldEdit.getSelection(p);
-        if (selection == null) {
-            return true;
-        }
-        BlockVector pos1 = selection.getNativeMinimumPoint().toBlockVector();
-        BlockVector pos2 = selection.getNativeMaximumPoint().toBlockVector();
-        HashSet<RegionWrapper> mask = WEManager.getMask(pp);
-        RegionWrapper region = new RegionWrapper(pos1.getBlockX(), pos2.getBlockX(), pos1.getBlockZ(), pos2.getBlockZ());
-        if (Settings.REQUIRE_SELECTION) {
-            String arg = null;
-            if (!WEManager.regionContains(region, mask)) {
-                arg = "pos1 + pos2";
-            } else if (!WEManager.maskContains(mask, pos1.getBlockX(), pos1.getBlockY(), pos1.getBlockZ())) {
-                arg = "pos1";
-            } else if (!WEManager.maskContains(mask, pos2.getBlockX(), pos2.getBlockY(), pos2.getBlockZ())) {
-                arg = "pos2";
-            }
-            if (arg != null) {
-                e.setCancelled(true);
-                MainUtil.sendMessage(pp, C.REQUIRE_SELECTION_IN_MASK, arg);
-                if (Permissions.hasPermission(pp, "plots.worldedit.bypass")) {
-                    MainUtil.sendMessage(pp, C.WORLDEDIT_BYPASS);
-                }
-                return true;
-            }
-            if (!WEManager.regionContains(region, mask)) {
-                MainUtil.sendMessage(pp, C.REQUIRE_SELECTION_IN_MASK, "pos1 + pos2");
-                e.setCancelled(true);
-                if (Permissions.hasPermission(pp, "plots.worldedit.bypass")) {
-                    MainUtil.sendMessage(pp, C.WORLDEDIT_BYPASS);
-                }
-                return true;
-            }
-        }
-        long volume = Math.abs((pos1.getBlockX() - pos2.getBlockX()) * (pos1.getBlockY() - pos2.getBlockY()) * (pos1.getBlockZ() - pos2.getBlockZ()))
-                * modifier;
-        return checkVolume(pp, volume, max, e);
-    }
-
-    public boolean delay(final Player player, final String command, boolean delayed) {
-        if (!Settings.QUEUE_COMMANDS || !Settings.EXPERIMENTAL_FAST_ASYNC_WORLDEDIT) {
-            return false;
-        }
-        boolean free = SetQueue.IMP.addTask(null);
-        if (free) {
-            if (delayed) {
-                MainUtil.sendMessage(BukkitUtil.getPlayer(player), C.WORLDEDIT_RUN, command);
-                Bukkit.getServer().dispatchCommand(player, command.substring(1));
-            } else {
-                return false;
-            }
-        } else {
-            if (!delayed) {
-                MainUtil.sendMessage(BukkitUtil.getPlayer(player), C.WORLDEDIT_DELAYED);
-            }
-            SetQueue.IMP.addTask(new Runnable() {
-                @Override
-                public void run() {
-                    delay(player, command, true);
-                }
-            });
-        }
-        return true;
-    }
-
-    @EventHandler(priority = EventPriority.LOWEST, ignoreCancelled = true)
-    public boolean onPlayerCommand(PlayerCommandPreprocessEvent e) {
-        WorldEditPlugin worldedit = BukkitMain.worldEdit;
-        if (worldedit == null) {
-            HandlerList.unregisterAll(this);
-            return true;
-        }
-        Player p = e.getPlayer();
-        PlotPlayer pp = BukkitUtil.getPlayer(p);
-        if (!PS.get().hasPlotArea(p.getWorld().getName())) {
-            return true;
-        }
-        String message = e.getMessage();
-        String cmd = message.toLowerCase();
-        String[] split = cmd.split(" ");
-
-        long maxVolume = Settings.WE_MAX_VOLUME;
-        long maxIterations = Settings.WE_MAX_ITERATIONS;
-        if (pp.getAttribute("worldedit")) {
-            return true;
-        }
-        boolean single = true;
-        if (split.length >= 2) {
-            String reduced = reduceCmd(split[0], single);
-            String reduced2 = reduceCmd(split[0] + " " + split[1], single);
-            if (this.rad1.contains(reduced)) {
-                if (delay(p, message, false)) {
-                    e.setCancelled(true);
-                    return true;
-                }
-                long volume = getInt(split[1]) * 256;
-                return checkVolume(pp, volume, maxVolume, e);
-            }
-            if (this.rad2.contains(reduced)) {
-                if (delay(p, message, false)) {
-                    e.setCancelled(true);
-                    return true;
-                }
-                if (split.length >= 3) {
-                    long volume = getInt(split[2]) * 256;
-                    return checkVolume(pp, volume, maxVolume, e);
-                }
-                return true;
-            }
-            if (this.rad2_1.contains(reduced)) {
-                if (delay(p, message, false)) {
-                    e.setCancelled(true);
-                    return true;
-                }
-                if (split.length >= 4) {
-                    long volume = getInt(split[2]) * getInt(split[3]);
-                    return checkVolume(pp, volume, maxVolume, e);
-                }
-                return true;
-            }
-            if (this.rad2_2.contains(reduced)) {
-                if (delay(p, message, false)) {
-                    e.setCancelled(true);
-                    return true;
-                }
-                if (split.length >= 3) {
-                    long radius = getInt(split[2]);
-                    long volume = radius * radius;
-                    return checkVolume(pp, volume, maxVolume, e);
-                }
-                return true;
-            }
-            if (this.rad2_3.contains(reduced2)) {
-                if (delay(p, message, false)) {
-                    e.setCancelled(true);
-                    return true;
-                }
-                if (split.length >= 3) {
-                    if (split.length == 4) {
-                        int iterations = getInt(split[3]);
-                        if (iterations > maxIterations) {
-                            MainUtil.sendMessage(pp,
-                                    C.WORLDEDIT_ITERATIONS.s().replaceAll("%current%", iterations + "").replaceAll("%max%", maxIterations + ""));
-                            e.setCancelled(true);
-                            if (Permissions.hasPermission(pp, "plots.worldedit.bypass")) {
-                                MainUtil.sendMessage(pp, C.WORLDEDIT_BYPASS);
-                            }
-                            return true;
-                        }
-                    }
-                    long radius = getInt(split[2]);
-                    long volume = radius * radius;
-                    return checkVolume(pp, volume, maxVolume, e);
-                }
-                return true;
-            }
-            if (this.rad3_1.contains(reduced2)) {
-                if (delay(p, message, false)) {
-                    e.setCancelled(true);
-                    return true;
-                }
-                if (split.length >= 3) {
-                    int i = 2;
-                    if (split[i].equalsIgnoreCase("-h")) {
-                        i = 3;
-                    }
-                    long radius = getInt(split[i]);
-                    long volume = radius * radius;
-                    return checkVolume(pp, volume, maxVolume, e);
-                }
-                return true;
-            }
-            if (this.rad3_2.contains(reduced2)) {
-                if (delay(p, message, false)) {
-                    e.setCancelled(true);
-                    return true;
-                }
-                if (split.length >= 4) {
-                    int i = 3;
-                    if (split[i].equalsIgnoreCase("-h")) {
-                        i = 4;
-                    }
-                    long radius = getInt(split[i]);
-                    long volume = radius * radius;
-                    return checkVolume(pp, volume, maxVolume, e);
-                }
-                return true;
-            }
-            if (this.regionExtend.contains(reduced)) {
-                if (delay(p, message, false)) {
-                    e.setCancelled(true);
-                    return true;
-                }
-                return checkSelection(p, pp, getInt(split[1]), maxVolume, e);
-            }
-        }
-        String reduced = reduceCmd(split[0], single);
-        if (Settings.WE_BLACKLIST.contains(reduced)) {
-            MainUtil.sendMessage(pp, C.WORLDEDIT_UNSAFE);
-            e.setCancelled(true);
-            if (Permissions.hasPermission(pp, "plots.worldedit.bypass")) {
-                MainUtil.sendMessage(pp, C.WORLDEDIT_BYPASS);
-            }
-        }
-        if (this.restricted.contains(reduced)) {
-            Plot plot = pp.getCurrentPlot();
-            if ((plot != null) && plot.isAdded(pp.getUUID())) {
-                if (delay(p, message, false)) {
-                    e.setCancelled(true);
-                    return true;
-                }
-                return true;
-            }
-            e.setCancelled(true);
-            MainUtil.sendMessage(pp, C.NO_PLOT_PERMS);
-            if (Permissions.hasPermission(pp, "plots.worldedit.bypass")) {
-                MainUtil.sendMessage(pp, C.WORLDEDIT_BYPASS);
-            }
-            return true;
-        }
-        if (this.region.contains(reduced)) {
-            if (delay(p, message, false)) {
-                e.setCancelled(true);
-                return true;
-            }
-            return checkSelection(p, pp, 1, maxVolume, e);
-        }
-        if (this.other.contains(reduced)) {
-            if (delay(p, message, false)) {
-                e.setCancelled(true);
-                return true;
-            }
-        }
-        return true;
-    }
-}

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/object/BukkitLazyBlock.java

@@ -1,138 +0,0 @@
-package com.plotsquared.bukkit.object;
-
-import com.intellectualcrafters.plot.object.LazyBlock;
-import com.intellectualcrafters.plot.object.PlotBlock;
-import org.bukkit.block.Block;
-
-public class BukkitLazyBlock extends LazyBlock {
-
-    private int id;
-    private Block block;
-    private PlotBlock pb;
-
-    public BukkitLazyBlock(int id, Block block) {
-        this.id = id;
-        this.block = block;
-    }
-
-    public BukkitLazyBlock(PlotBlock pb) {
-        this.id = pb.id;
-        this.pb = pb;
-    }
-
-    public BukkitLazyBlock(Block block) {
-        this.block = block;
-    }
-
-    @Override
-    public PlotBlock getPlotBlock() {
-        if (this.pb != null) {
-            return this.pb;
-        }
-        if (this.id == 0) {
-            this.id = this.block.getTypeId();
-        }
-        byte data;
-        switch (this.id) {
-            case 0:
-            case 2:
-            case 4:
-            case 13:
-            case 14:
-            case 15:
-            case 20:
-            case 21:
-            case 22:
-            case 24:
-            case 25:
-            case 30:
-            case 32:
-            case 37:
-            case 39:
-            case 40:
-            case 41:
-            case 42:
-            case 45:
-            case 46:
-            case 47:
-            case 48:
-            case 49:
-            case 51:
-            case 52:
-            case 54:
-            case 55:
-            case 56:
-            case 57:
-            case 58:
-            case 60:
-            case 61:
-            case 62:
-            case 7:
-            case 8:
-            case 9:
-            case 10:
-            case 11:
-            case 73:
-            case 74:
-            case 78:
-            case 79:
-            case 80:
-            case 81:
-            case 82:
-            case 83:
-            case 84:
-            case 85:
-            case 87:
-            case 88:
-            case 101:
-            case 102:
-            case 103:
-            case 110:
-            case 112:
-            case 113:
-            case 117:
-            case 121:
-            case 122:
-            case 123:
-            case 124:
-            case 129:
-            case 133:
-            case 138:
-            case 137:
-            case 140:
-            case 165:
-            case 166:
-            case 169:
-            case 170:
-            case 172:
-            case 173:
-            case 174:
-            case 176:
-            case 177:
-            case 181:
-            case 182:
-            case 188:
-            case 189:
-            case 190:
-            case 191:
-            case 192:
-                data = 0;
-                break;
-            default:
-                data = this.block.getData();
-                break;
-        }
-        this.pb = new PlotBlock((short) this.id, data);
-        return this.pb;
-
-    }
-
-    @Override
-    public int getId() {
-        if (this.id == 0) {
-            this.id = this.block.getTypeId();
-        }
-        return this.id;
-    }
-
-}

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

@@ -1,41 +0,0 @@
-package com.plotsquared.bukkit.object;
-
-import com.intellectualcrafters.plot.object.OfflinePlotPlayer;
-import org.bukkit.OfflinePlayer;
-
-import java.util.UUID;
-
-public class BukkitOfflinePlayer implements OfflinePlotPlayer {
-
-    public final OfflinePlayer player;
-
-    /**
-     * <p>Please do not use this method. Instead use BukkitUtil.getPlayer(Player),
-     * as it caches player objects.</p>
-     *
-     * @param player
-     */
-    public BukkitOfflinePlayer(OfflinePlayer player) {
-        this.player = player;
-    }
-
-    @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/object/BukkitPlayer.java

@@ -1,201 +0,0 @@
-package com.plotsquared.bukkit.object;
-
-import com.intellectualcrafters.plot.object.Location;
-import com.intellectualcrafters.plot.object.PlotPlayer;
-import com.intellectualcrafters.plot.util.EconHandler;
-import com.intellectualcrafters.plot.util.PlotGameMode;
-import com.intellectualcrafters.plot.util.PlotWeather;
-import com.intellectualcrafters.plot.util.UUIDHandler;
-import com.plotsquared.bukkit.util.BukkitUtil;
-import org.bukkit.Effect;
-import org.bukkit.GameMode;
-import org.bukkit.WeatherType;
-import org.bukkit.entity.Player;
-import org.bukkit.event.player.PlayerTeleportEvent.TeleportCause;
-
-import java.util.UUID;
-
-public class BukkitPlayer extends PlotPlayer {
-    
-    public final Player player;
-    public boolean offline;
-    private UUID uuid;
-    private String name;
-    private long last = 0;
-    
-    /**
-     * <p>Please do not use this method. Instead use
-     * BukkitUtil.getPlayer(Player), as it caches player objects.</p>
-     * @param player
-     */
-    public BukkitPlayer(Player player) {
-        this.player = player;
-        super.populatePersistentMetaMap();
-    }
-
-    public BukkitPlayer(Player player, boolean offline) {
-        this.player = player;
-        this.offline = offline;
-        super.populatePersistentMetaMap();
-    }
-    
-    @Override
-    public long getPreviousLogin() {
-        if (this.last == 0) {
-            this.last = this.player.getLastPlayed();
-        }
-        return this.last;
-    }
-    
-    @Override
-    public Location getLocation() {
-        Location location = super.getLocation();
-        return location == null ? BukkitUtil.getLocation(this.player) : location;
-    }
-    
-    @Override
-    public UUID getUUID() {
-        if (this.uuid == null) {
-            this.uuid = UUIDHandler.getUUID(this);
-        }
-        return this.uuid;
-    }
-    
-    @Override
-    public boolean hasPermission(String permission) {
-        if (this.offline && EconHandler.manager != null) {
-            return EconHandler.manager.hasPermission(getName(), permission);
-        }
-        return this.player.hasPermission(permission);
-    }
-
-    @Override
-    public void sendMessage(String message) {
-        this.player.sendMessage(message);
-    }
-    
-    @Override
-    public void teleport(Location location) {
-        if (Math.abs(location.getX()) >= 30000000 || Math.abs(location.getZ()) >= 30000000) {
-            return;
-        }
-        this.player.teleport(
-                new org.bukkit.Location(BukkitUtil.getWorld(location.getWorld()), location.getX() + 0.5, location.getY(), location.getZ() + 0.5,
-                        location.getYaw(), location.getPitch()), TeleportCause.COMMAND);
-    }
-    
-    @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(PlotWeather weather) {
-        switch (weather) {
-            case CLEAR:
-                this.player.setPlayerWeather(WeatherType.CLEAR);
-                break;
-            case RAIN:
-                this.player.setPlayerWeather(WeatherType.DOWNFALL);
-                break;
-            case RESET:
-                this.player.resetPlayerWeather();
-                break;
-            default:
-                this.player.resetPlayerWeather();
-                break;
-        }
-    }
-    
-    @Override
-    public PlotGameMode getGameMode() {
-        switch (this.player.getGameMode()) {
-            case ADVENTURE:
-                return PlotGameMode.ADVENTURE;
-            case CREATIVE:
-                return PlotGameMode.CREATIVE;
-            case SPECTATOR:
-                return PlotGameMode.SPECTATOR;
-            case SURVIVAL:
-                return PlotGameMode.SURVIVAL;
-            default:
-                return PlotGameMode.NOT_SET;
-        }
-    }
-    
-    @Override
-    public void setGameMode(PlotGameMode gameMode) {
-        switch (gameMode) {
-            case ADVENTURE:
-                this.player.setGameMode(GameMode.ADVENTURE);
-                break;
-            case CREATIVE:
-                this.player.setGameMode(GameMode.CREATIVE);
-                break;
-            case SPECTATOR:
-                this.player.setGameMode(GameMode.SPECTATOR);
-                break;
-            case SURVIVAL:
-                this.player.setGameMode(GameMode.SURVIVAL);
-                break;
-            default:
-                this.player.setGameMode(GameMode.SURVIVAL);
-                break;
-        }
-    }
-    
-    @Override
-    public void setTime(long time) {
-        if (time != Long.MAX_VALUE) {
-            this.player.setPlayerTime(time, false);
-        } else {
-            this.player.resetPlayerTime();
-        }
-    }
-    
-    @Override
-    public void setFlight(boolean fly) {
-        this.player.setAllowFlight(fly);
-    }
-    
-    @Override
-    public void playMusic(Location location, int id) {
-        this.player.playEffect(BukkitUtil.getLocation(location), Effect.RECORD_PLAY, id);
-    }
-    
-    @Override
-    public void kick(String message) {
-        this.player.kickPlayer(message);
-    }
-
-    @Override public void stopSpectating() {
-        if (getGameMode() == PlotGameMode.SPECTATOR) {
-            this.player.setSpectatorTarget(null);
-        }
-    }
-
-    @Override
-    public boolean isBanned() {
-        return this.player.isBanned();
-    }
-}

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

@@ -1,7 +0,0 @@
-package com.plotsquared.bukkit.object.entity;
-
-public class AgeableStats {
-    public int age;
-    public boolean locked;
-    public boolean adult;
-}

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

@@ -1,16 +0,0 @@
-package com.plotsquared.bukkit.object.entity;
-
-public class ArmorStandStats {
-
-    public final float[] head = new float[3];
-    public final float[] body = new float[3];
-    public final float[] leftLeg = new float[3];
-    public final float[] rightLeg = new float[3];
-    public final float[] leftArm = new float[3];
-    public final float[] rightArm = new float[3];
-    public boolean arms;
-    public boolean noplate;
-    public boolean nogravity;
-    public boolean invisible;
-    public boolean small;
-}

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

@@ -1,12 +0,0 @@
-package com.plotsquared.bukkit.object.entity;
-
-
-public class EntityBaseStats {
-    public EntityWrapper passenger;
-    public float fall;
-    public short fire;
-    public int age;
-    public double v_z;
-    public double v_y;
-    public double v_x;
-}

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

@@ -1,650 +0,0 @@
-package com.plotsquared.bukkit.object.entity;
-
-import com.intellectualcrafters.plot.PS;
-import org.bukkit.Art;
-import org.bukkit.DyeColor;
-import org.bukkit.Location;
-import org.bukkit.Rotation;
-import org.bukkit.World;
-import org.bukkit.block.BlockFace;
-import org.bukkit.entity.Ageable;
-import org.bukkit.entity.ArmorStand;
-import org.bukkit.entity.Entity;
-import org.bukkit.entity.EntityType;
-import org.bukkit.entity.Guardian;
-import org.bukkit.entity.Horse;
-import org.bukkit.entity.Horse.Color;
-import org.bukkit.entity.Horse.Style;
-import org.bukkit.entity.Horse.Variant;
-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.Rabbit.Type;
-import org.bukkit.entity.Sheep;
-import org.bukkit.entity.Skeleton;
-import org.bukkit.entity.Skeleton.SkeletonType;
-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;
-
-public class EntityWrapper {
-
-    private final int hash;
-    public EntityType type;
-    public float yaw;
-    public float pitch;
-    public double x;
-    public double y;
-    public double z;
-    public short depth;
-    public EntityBaseStats base = null;
-    // Extended
-    public ItemStack stack;
-    public ItemStack[] inventory;
-    public byte dataByte;
-    public byte dataByte2;
-    public String dataString;
-    public LivingEntityStats lived;
-    public AgeableStats aged;
-    public TameableStats tamed;
-    private HorseStats horse;
-    private ArmorStandStats stand;
-    
-    @SuppressWarnings("deprecation")
-    public EntityWrapper(Entity entity, short depth) {
-        this.hash = entity.getEntityId();
-        this.depth = depth;
-        Location loc = entity.getLocation();
-        this.yaw = loc.getYaw();
-        this.pitch = loc.getPitch();
-        this.x = loc.getX();
-        this.y = loc.getY();
-        this.z = loc.getZ();
-        this.type = entity.getType();
-        if (depth == 0) {
-            return;
-        }
-        this.base = new EntityBaseStats();
-        Entity p = entity.getPassenger();
-        if (p != null) {
-            this.base.passenger = new EntityWrapper(p, depth);
-        }
-        this.base.fall = entity.getFallDistance();
-        this.base.fire = (short) entity.getFireTicks();
-        this.base.age = entity.getTicksLived();
-        Vector velocity = entity.getVelocity();
-        this.base.v_x = velocity.getX();
-        this.base.v_y = velocity.getY();
-        this.base.v_z = velocity.getZ();
-        if (depth == 1) {
-            return;
-        }
-        switch (entity.getType()) {
-            case ARROW:
-            case BOAT:
-            case COMPLEX_PART:
-            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 WEATHER:
-            case WITHER_SKULL:
-            case UNKNOWN:
-            case TIPPED_ARROW:
-            case SPECTRAL_ARROW:
-            case SHULKER_BULLET:
-            case DRAGON_FIREBALL:
-            case LINGERING_POTION:
-            case AREA_EFFECT_CLOUD:
-                // Do this stuff later
-                return;
-            default:
-                PS.debug("&cCOULD NOT IDENTIFY ENTITY: " + entity.getType());
-                return;
-            // MISC //
-            case DROPPED_ITEM:
-                Item item = (Item) entity;
-                this.stack = item.getItemStack();
-                return;
-            case ITEM_FRAME:
-                ItemFrame itemframe = (ItemFrame) entity;
-                this.x = Math.floor(this.x);
-                this.y = Math.floor(this.y);
-                this.z = Math.floor(this.z);
-                this.dataByte = getOrdinal(Rotation.values(), itemframe.getRotation());
-                this.stack = itemframe.getItem().clone();
-                return;
-            case PAINTING:
-                Painting painting = (Painting) entity;
-                this.x = Math.floor(this.x);
-                this.y = Math.floor(this.y);
-                this.z = Math.floor(this.z);
-                Art a = painting.getArt();
-                this.dataByte = getOrdinal(BlockFace.values(), painting.getFacing());
-                int h = a.getBlockHeight();
-                if (h % 2 == 0) {
-                    this.y -= 1;
-                }
-                this.dataString = a.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:
-                Horse horse = (Horse) entity;
-                this.horse = new HorseStats();
-                this.horse.jump = horse.getJumpStrength();
-                this.horse.chest = horse.isCarryingChest();
-                this.horse.variant = getOrdinal(Variant.values(), horse.getVariant());
-                this.horse.style = getOrdinal(Style.values(), horse.getStyle());
-                this.horse.color = getOrdinal(Color.values(), horse.getColor());
-                storeTameable((Tameable) entity);
-                storeAgeable((Ageable) entity);
-                storeLiving((LivingEntity) entity);
-                storeInventory((InventoryHolder) entity);
-                return;
-            // END INVENTORY HOLDER //
-            case WOLF:
-            case OCELOT:
-                storeTameable((Tameable) entity);
-                storeAgeable((Ageable) entity);
-                storeLiving((LivingEntity) entity);
-                return;
-            // END TAMEABLE //
-            case SHEEP:
-                Sheep sheep = (Sheep) entity;
-                this.dataByte = (byte) (sheep.isSheared() ? 1 : 0);
-                this.dataByte2 = sheep.getColor().getDyeData();
-                storeAgeable((Ageable) entity);
-                storeLiving((LivingEntity) entity);
-                return;
-            case VILLAGER:
-            case CHICKEN:
-            case COW:
-            case MUSHROOM_COW:
-            case PIG:
-                storeAgeable((Ageable) entity);
-                storeLiving((LivingEntity) entity);
-                return;
-            case RABBIT:  // NEW
-                this.dataByte = getOrdinal(Type.values(), ((Rabbit) entity).getRabbitType());
-                storeAgeable((Ageable) entity);
-                storeLiving((LivingEntity) entity);
-                return;
-            // END AGEABLE //
-            case GUARDIAN:  // NEW
-                this.dataByte = (byte) (((Guardian) entity).isElder() ? 1 : 0);
-                storeLiving((LivingEntity) entity);
-                return;
-            case SKELETON:  // NEW
-                this.dataByte = (byte) ((Skeleton) entity).getSkeletonType().getId();
-                storeLiving((LivingEntity) entity);
-                return;
-            case ARMOR_STAND:  // NEW
-                // CHECK positions
-                ArmorStand stand = (ArmorStand) entity;
-                this.inventory = new ItemStack[]{stand.getItemInHand().clone(), stand.getHelmet().clone(), stand.getChestplate().clone(),
-                        stand.getLeggings().clone(), stand.getBoots().clone()};
-                storeLiving((LivingEntity) entity);
-                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.hasGravity()) {
-                    this.stand.nogravity = true;
-                }
-                if (!stand.isVisible()) {
-                    this.stand.invisible = true;
-                }
-                if (stand.isSmall()) {
-                    this.stand.small = true;
-                }
-                return;
-            case ENDERMITE: // NEW
-            case BAT:
-            case ENDER_DRAGON:
-            case GHAST:
-            case MAGMA_CUBE:
-            case SQUID:
-            case PIG_ZOMBIE:
-            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:
-            case IRON_GOLEM:
-                storeLiving((LivingEntity) entity);
-                // END LIVING //
-        }
-    }
-
-    @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();
-    }
-
-    private 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) {
-            EntityEquipment equipment = entity.getEquipment();
-            equipment.setItemInHand(this.lived.hands);
-            equipment.setHelmet(this.lived.helmet);
-            equipment.setChestplate(this.lived.chestplate);
-            equipment.setLeggings(this.lived.leggings);
-            equipment.setBoots(this.lived.boots);
-        }
-        if (this.lived.leashed) {
-            // TODO leashes
-            //            World world = entity.getWorld();
-            //            Entity leash = world.spawnEntity(new Location(world, Math.floor(x) + lived.leash_x, Math.floor(y) + lived.leash_y, Math
-            // .floor(z) + lived.leash_z), EntityType.LEASH_HITCH);
-            //            entity.setLeashHolder(leash);
-        }
-    }
-
-    private void restoreInventory(InventoryHolder entity) {
-        entity.getInventory().setContents(this.inventory);
-    }
-
-    public 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 loc = lived.getLeashHolder().getLocation();
-            this.lived.leash_x = (short) (this.x - loc.getBlockX());
-            this.lived.leash_y = (short) (this.y - loc.getBlockY());
-            this.lived.leash_z = (short) (this.z - loc.getBlockZ());
-        }
-        EntityEquipment equipment = lived.getEquipment();
-        this.lived.equipped = equipment != null;
-        if (this.lived.equipped) {
-            this.lived.hands = equipment.getItemInHand().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();
-    }
-
-    @SuppressWarnings("deprecation")
-    public Entity spawn(World world, int x_offset, int z_offset) {
-        Location loc = new Location(world, this.x + x_offset, this.y, this.z + z_offset);
-        loc.setYaw(this.yaw);
-        loc.setPitch(this.pitch);
-        if (!this.type.isSpawnable()) {
-            return null;
-        }
-        Entity entity;
-        switch (this.type) {
-            case DROPPED_ITEM:
-                return world.dropItem(loc, this.stack);
-            case PLAYER:
-            case LEASH_HITCH:
-                return null;
-            case ITEM_FRAME:
-                entity = world.spawn(loc, ItemFrame.class);
-                break;
-            case PAINTING:
-                entity = world.spawn(loc, Painting.class);
-                break;
-            default:
-                entity = world.spawnEntity(loc, this.type);
-                break;
-        }
-        if (this.depth == 0) {
-            return entity;
-        }
-        if (this.base.passenger != null) {
-            try {
-                entity.setPassenger(this.base.passenger.spawn(world, x_offset, z_offset));
-            } catch (Exception e) {
-            }
-        }
-        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.v_x, this.base.v_y, this.base.v_z));
-        if (this.depth == 1) {
-            return entity;
-        }
-        switch (entity.getType()) {
-            case ARROW:
-            case BOAT:
-            case COMPLEX_PART:
-            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 SPLASH_POTION:
-            case THROWN_EXP_BOTTLE:
-            case WEATHER:
-            case WITHER_SKULL:
-            case MINECART_FURNACE:
-            case UNKNOWN:
-                // Do this stuff later
-                return entity;
-            default:
-                PS.debug("&cCOULD NOT IDENTIFY ENTITY: " + entity.getType());
-                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:
-                Horse horse = (Horse) entity;
-                horse.setJumpStrength(this.horse.jump);
-                horse.setCarryingChest(this.horse.chest);
-                horse.setVariant(Variant.values()[this.horse.variant]);
-                horse.setStyle(Style.values()[this.horse.style]);
-                horse.setColor(Color.values()[this.horse.color]);
-                restoreTameable((Tameable) entity);
-                restoreAgeable((Ageable) entity);
-                restoreLiving((LivingEntity) entity);
-                restoreInventory((InventoryHolder) entity);
-                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((Ageable) entity);
-                restoreLiving((LivingEntity) entity);
-                return entity;
-            case VILLAGER:
-            case CHICKEN:
-            case COW:
-            case MUSHROOM_COW:
-            case PIG:
-                restoreAgeable((Ageable) entity);
-                restoreLiving((LivingEntity) entity);
-                return entity;
-            // END AGEABLE //
-            case RABBIT:  // NEW
-                if (this.dataByte != 0) {
-                    ((Rabbit) entity).setRabbitType(Type.values()[this.dataByte]);
-                }
-                restoreAgeable((Ageable) entity);
-                restoreLiving((LivingEntity) entity);
-                return entity;
-            case GUARDIAN:  // NEW
-                if (this.dataByte != 0) {
-                    ((Guardian) entity).setElder(true);
-                }
-                restoreLiving((LivingEntity) entity);
-                return entity;
-            case SKELETON:  // NEW
-                if (this.dataByte != 0) {
-                    ((Skeleton) entity).setSkeletonType(SkeletonType.values()[this.dataByte]);
-                }
-                storeLiving((LivingEntity) entity);
-                return entity;
-            case ARMOR_STAND:  // NEW
-                // 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.nogravity) {
-                    stand.setGravity(false);
-                }
-                if (this.stand.noplate) {
-                    stand.setBasePlate(false);
-                }
-                if (this.stand.small) {
-                    stand.setSmall(true);
-                }
-                restoreLiving((LivingEntity) entity);
-                return entity;
-            case ENDERMITE: // NEW
-            case BAT:
-            case ENDER_DRAGON:
-            case GHAST:
-            case MAGMA_CUBE:
-            case SQUID:
-            case PIG_ZOMBIE:
-            case ZOMBIE:
-            case WITHER:
-            case WITCH:
-            case SPIDER:
-            case CAVE_SPIDER:
-            case SILVERFISH:
-            case GIANT:
-            case ENDERMAN:
-            case CREEPER:
-            case BLAZE:
-            case SNOWMAN:
-            case IRON_GOLEM:
-                restoreLiving((LivingEntity) entity);
-                return entity;
-            // END LIVING //
-        }
-    }
-
-    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/object/entity/HorseStats.java

@@ -1,9 +0,0 @@
-package com.plotsquared.bukkit.object.entity;
-
-public class HorseStats {
-    public double jump;
-    public boolean chest;
-    public int variant;
-    public int color;
-    public int style;
-}

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

@@ -1,26 +0,0 @@
-package com.plotsquared.bukkit.object.entity;
-
-import java.util.Collection;
-
-import org.bukkit.inventory.ItemStack;
-import org.bukkit.potion.PotionEffect;
-
-public class LivingEntityStats {
-    public boolean loot;
-    public String name;
-    public boolean visible;
-    public float health;
-    public short air;
-    public boolean persistent;
-    public boolean leashed;
-    public short leash_x;
-    public short leash_y;
-    public short leash_z;
-    public boolean equipped;
-    public ItemStack hands;
-    public ItemStack helmet;
-    public ItemStack boots;
-    public ItemStack leggings;
-    public ItemStack chestplate;
-    public Collection<PotionEffect> potions;
-}

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

@@ -1,8 +0,0 @@
-package com.plotsquared.bukkit.object.entity;
-
-import org.bukkit.entity.AnimalTamer;
-
-public class TameableStats {
-    public AnimalTamer owner;
-    public boolean tamed;
-}

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

@@ -1,146 +0,0 @@
-package com.plotsquared.bukkit.object.schematic;
-
-import com.intellectualcrafters.jnbt.ByteTag;
-import com.intellectualcrafters.jnbt.CompoundTag;
-import com.intellectualcrafters.jnbt.ListTag;
-import com.intellectualcrafters.jnbt.ShortTag;
-import com.intellectualcrafters.jnbt.Tag;
-import com.intellectualcrafters.plot.object.schematic.ItemType;
-import com.intellectualcrafters.plot.util.MathMan;
-import com.plotsquared.bukkit.util.BukkitUtil;
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.Map.Entry;
-import org.bukkit.World;
-import org.bukkit.block.Block;
-import org.bukkit.block.BlockState;
-import org.bukkit.enchantments.Enchantment;
-import org.bukkit.inventory.Inventory;
-import org.bukkit.inventory.InventoryHolder;
-import org.bukkit.inventory.ItemStack;
-
-public class StateWrapper {
-
-    public BlockState state = null;
-    public CompoundTag tag = null;
-
-    public StateWrapper(BlockState state) {
-        this.state = state;
-    }
-
-    public StateWrapper(CompoundTag tag) {
-        this.tag = tag;
-    }
-
-    public boolean restoreTag(String worldName, int x, int y, int z) {
-        if (this.tag == null) {
-            return false;
-        }
-        switch (tag.getString("id").toLowerCase()) {
-            case "chest": {
-                List<Tag> itemsTag = this.tag.getListTag("Items").getValue();
-                int length = itemsTag.size();
-                short[] ids = new short[length];
-                byte[] datas = new byte[length];
-                byte[] amounts = new byte[length];
-                byte[] slots = new byte[length];
-                for (int i = 0; i < length; i++) {
-                    Tag itemTag = itemsTag.get(i);
-                    CompoundTag itemComp = (CompoundTag) itemTag;
-                    short id = itemComp.getShort("id");
-                    String idStr = itemComp.getString("id");
-                    if (idStr != null && !MathMan.isInteger(idStr)) {
-                        idStr = idStr.split(":")[1].toLowerCase();
-                        id = (short) ItemType.getId(idStr);
-                    }
-                    ids[i] = id;
-                    datas[i] = (byte) itemComp.getShort("Damage");
-                    amounts[i] = itemComp.getByte("Count");
-                    slots[i] = itemComp.getByte("Slot");
-                }
-                World world = BukkitUtil.getWorld(worldName);
-                Block block = world.getBlockAt(x, y, z);
-                if (block == null) {
-                    return false;
-                }
-                BlockState state = block.getState();
-                if (state instanceof InventoryHolder) {
-                    InventoryHolder holder = (InventoryHolder) state;
-                    Inventory inv = holder.getInventory();
-                    for (int i = 0; i < ids.length; i++) {
-                        ItemStack item = new ItemStack(ids[i], amounts[i], datas[i]);
-                        inv.addItem(item);
-                    }
-                    state.update(true);
-                    return true;
-                } else {
-                }
-            }
-        }
-        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("Items", CompoundTag.class, serializeInventory(contents)));
-            return new CompoundTag(values);
-        }
-        return null;
-    }
-
-    public String getId() {
-        return "Chest";
-    }
-
-    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("Slot", (byte) i));
-                tags.add(new CompoundTag(tagData));
-            }
-        }
-        return tags;
-    }
-
-    /*
-     * TODO: Move this into the sponge module!
-     *
-    public Map<String, Tag> serializeItem(final org.spongepowered.api.item.inventory.ItemStack item) {
-        final Map<String, Tag> data = new HashMap<String, Tag>();
-        
-        // FIXME serialize sponge item
-        
-        return data;
-    }
-    */
-
-    public Map<String, Tag> serializeItem(ItemStack item) {
-        Map<String, Tag> data = new HashMap<>();
-        data.put("id", new ShortTag("id", (short) item.getTypeId()));
-        data.put("Damage", new ShortTag("Damage", item.getDurability()));
-        data.put("Count", new ByteTag("Count", (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 ShortTag("id", (short) entry.getKey().getId()));
-                enchantment.put("lvl", new ShortTag("lvl", entry.getValue().shortValue()));
-                enchantmentList.add(new CompoundTag(enchantment));
-            }
-            Map<String, Tag> auxData = new HashMap<>();
-            auxData.put("ench", new ListTag("ench", CompoundTag.class, enchantmentList));
-            data.put("tag", new CompoundTag("tag", auxData));
-        }
-        return data;
-    }
-}

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));
+    }
+
+}