v2.2.6: Crafting inventory safety, Maria v11 support (#153)

* Clear player inventory crafting slots on sync

* Bundle Maria driver for v11 support

.github/dependabot.yml

@@ -0,0 +1,7 @@
+# Dependabot configuration file for GitHub
+version: 2
+updates:
+  - package-ecosystem: "gradle" # See documentation for possible values
+    directory: "/" # Location of package manifests
+    schedule:
+      interval: "daily"

.github/funding.yml

@@ -0,0 +1,3 @@
+# Funding metadata for GitHub
+github: WiIIiam278
+custom: https://buymeacoff.ee/william278

.github/workflows/ci.yml

@@ -0,0 +1,37 @@
+# Builds, tests the project with Gradle
+name: CI Tests
+
+on:
+  push:
+    branches: [ 'master' ]
+    paths-ignore:
+      - 'docs/**'
+      - 'workflows/**'
+      - 'README.md'
+
+permissions:
+  contents: read
+  checks: write
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - name: Set up JDK 17
+        uses: actions/setup-java@v3
+        with:
+          java-version: '17'
+          distribution: 'temurin'
+      - name: Build with Gradle
+        uses: gradle/gradle-build-action@v2
+        with:
+          arguments: build test publish
+        env:
+            SNAPSHOTS_MAVEN_USERNAME: ${{ secrets.MAVEN_USERNAME }}
+            SNAPSHOTS_MAVEN_PASSWORD: ${{ secrets.MAVEN_PASSWORD }}
+      - name: Publish Test Report
+        uses: mikepenz/action-junit-report@v3
+        if: success() || failure() # always run even if the previous step fails
+        with:
+          report_paths: '**/build/test-results/test/TEST-*.xml'

.github/workflows/pr_tests.yml

@@ -0,0 +1,24 @@
+# Carry out tests on pull requests
+name: PR Tests
+
+on:
+  pull_request:
+    branches: [ 'master' ]
+
+permissions:
+  contents: read
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - name: Set up JDK 17
+        uses: actions/setup-java@v3
+        with:
+          java-version: '17'
+          distribution: 'temurin'
+      - name: Test Pull Request
+        uses: gradle/gradle-build-action@v2
+        with:
+          arguments: test

.github/workflows/release.yml

@@ -0,0 +1,33 @@
+# Builds, tests and publishes to maven when a release is published
+name: Release Tests
+
+on:
+  release:
+    types: [ published ]
+
+permissions:
+  contents: read
+  checks: write
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - name: Set up JDK 17
+        uses: actions/setup-java@v3
+        with:
+          java-version: '17'
+          distribution: 'temurin'
+      - name: Build with Gradle
+        uses: gradle/gradle-build-action@v2
+        with:
+          arguments: build test publish
+        env:
+          RELEASES_MAVEN_USERNAME: ${{ secrets.MAVEN_USERNAME }}
+          RELEASES_MAVEN_PASSWORD: ${{ secrets.MAVEN_PASSWORD }}
+      - name: Publish Test Report
+        uses: mikepenz/action-junit-report@v3
+        if: success() || failure() # always run even if the previous step fails
+        with:
+          report_paths: '**/build/test-results/test/TEST-*.xml'

.github/workflows/update_docs.yml

@@ -0,0 +1,28 @@
+# Update the GitHub Wiki documentation when a push is made to docs/
+name: Update Docs
+
+on:
+  push:
+    branches: [ 'master' ]
+    paths:
+      - 'docs/**'
+      - 'workflows/**'
+    tags-ignore:
+      - '*'
+
+permissions:
+  contents: write
+
+jobs:
+  deploy-wiki:
+    runs-on: ubuntu-latest
+    steps:
+      - name: 'Checkout Code'
+        uses: actions/checkout@v3
+      - name: 'Push Changes to Wiki'
+        uses: Andrew-Chen-Wang/github-wiki-action@v3
+        env:
+          WIKI_DIR: 'docs/'
+          GH_TOKEN: ${{ github.token }}
+          GH_MAIL: 'actions@github.com'
+          GH_NAME: 'github-actions[bot]'

.jitpack/install-mpdb-converter

@@ -1,5 +0,0 @@
-#!/bin/bash
-
-echo "mvn-installing mpdbdataconverter..."
-curl "-L" "-O" "https://github.com/WiIIiam278/MPDBDataConverter/releases/download/1.0/mpdbdataconverter-1.0.jar"
-mvn "install:install-file" "-Dfile=mpdbdataconverter-1.0.jar" "-DgroupId=net.william278" "-DartifactId=mpdbdataconverter" "-Dversion=1.0" "-Dpackaging=jar" "-DgeneratePom=true" "-e"

HEADER

@@ -0,0 +1,16 @@
+This file is part of HuskSync, licensed under the Apache License 2.0.
+
+ Copyright (c) William278 <will27528@gmail.com>
+ Copyright (c) contributors
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.

LICENSE

@@ -1,21 +1,202 @@
-Copyright © William278 2022. All rights reserved
 
-LICENSE
+                                 Apache License
-This source code is provided as reference to licensed individuals that have purchased the HuskSync
+                           Version 2.0, January 2004
-plugin once from any of the official sources it is provided. The availability of this code does 
+                        http://www.apache.org/licenses/
-not grant you the rights to modify, re-distribute, compile or redistribute this source code or 
-"plugin" outside this intended purpose. This license does not cover libraries developed by third
-parties that are utilised in the plugin.
 
-CONTRIBUTOR AGREEMENT
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-By contributing code to this repository, contributors agree that they forfeit their contributions
-to the copyright holder and only the copyright holder.
-In exchange for contributing, the copyright holder may give, at their discretion, permission to use
-the plugin in commercial contexts
 
-DEFINITIONS
+   1. Definitions.
-"plugin"; the jar file compiled from this source code
+
-"source code"; the java source code and gradle configurations provided in this repository, however
+      "License" shall mean the terms and conditions for use, reproduction,
-excludes libraries
+      and distribution as defined by Sections 1 through 9 of this document.
-"copyright holder"; William278
+
-"contributor(s)"; person(s) who submit (contribute) code through a pull request to this repository
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

README.md

@@ -1,229 +1,85 @@
-[![HuskSync Banner](images/banner-graphic.png)](https://github.com/WiIIiam278/HuskSync)
+<!--suppress ALL -->
-# HuskSync
+<p align="center">
-[![Discord](https://img.shields.io/discord/818135932103557162?color=7289da&logo=discord)](https://discord.gg/tVYhJfyDWG)
+    <img src="images/banner.png" alt="HuskSync" />
+    <a href="https://github.com/WiIIiam278/HuskSync/actions/workflows/ci.yml">
+        <img src="https://img.shields.io/github/actions/workflow/status/WiIIiam278/HuskSync/ci.yml?branch=master&logo=github"/>
+    </a> 
+    <a href="https://jitpack.io/#net.william278/HuskSync">
+        <img src="https://img.shields.io/jitpack/version/net.william278/HuskSync?color=%2300fb9a&label=api&logo=gradle" />
+    </a> 
+    <a href="https://discord.gg/tVYhJfyDWG">
+        <img src="https://img.shields.io/discord/818135932103557162.svg?label=&logo=discord&logoColor=fff&color=7389D8&labelColor=6A7EC2" />
+    </a> 
+    <br/>
+    <b>
+        <a href="https://www.spigotmc.org/resources/husksync.97144/">Spigot</a>
+    </b> —
+    <b>
+        <a href="https://william278.net/docs/husksync/setup">Setup</a>
+    </b> — 
+    <b>
+        <a href="https://william278.net/docs/husksync/">Docs</a>
+    </b> — 
+    <b>
+        <a href="https://github.com/WiIIiam278/HuskSync/issues">Issues</a>
+    </b>
+</p>
+<br/>
 
-**HuskSync** is a modern, cross-server player data synchronisation system that allows player data (inventories, health, hunger & status effects) to be synchronised across servers through the use of **Redis**. 
+**HuskSync** is a modern, cross-server player data synchronisation system that enables the comprehensive synchronisation of your user's data across multiple proxied servers. It does this by making use of Redis and MySQL to optimally cache data while players change servers.
 
-## Disclaimer
+## Features
-This source code is provided as reference to licensed individuals that have purchased the HuskSync plugin once from any of the official sources it is provided. The availability of this code does not grant you the rights to re-distribute, compile or share this source code outside this intended purpose. 
+**⭐ Seamless synchronisation** &mdash; Utilises optimised Redis caching when players change server to sync player data super quickly for a seamless experience.
 
-Are you a developer? [Read below for information about code bounty licensing](#Contributing).
+**⭐ Complete player synchronisation** &mdash; Sync inventories, Ender Chests, health, hunger, effects, advancements, statistics, locked maps & [more](https://william278.net/docs/husksync/sync-features)—no data left behind!
+
+**⭐ Backup, restore & rotate** &mdash; Something gone wrong? Restore players back to a previous data state. Rotate and manage data snapshots in-game!
+
+**⭐ Import existing data** &mdash; Import your MySQLPlayerDataBridge data—or from your existing world data! No server reset needed!
+
+**⭐ Works great with Plan** &mdash; Stay in touch with your community through HuskSync analytics on your Plan web panel.
+
+**⭐ Extensible API & open-source** &mdash; Need more? Extend the plugin with the Developer API. Or, submit a pull request through our code bounty system!
+
+**Ready?** [It's syncing time!](https://william278.net/docs/husksync/setup)
 
 ## Setup
-### Requirements
+Requires a MySQL (v8.0+) database, a Redis (v5.0+) server and any number of Spigot-based 1.16.5+ Minecraft servers, running Java 16+.
-* A BungeeCord or Velocity-based proxy server
-* A Spigot-based game server
-* A Redis server
 
-### Installation
+1. Place the plugin jar file in the /plugins/ directory of each Spigot server. You do not need to install HuskSync as a proxy plugin.
-1. Install HuskSync in the `/plugins/` folder of both your Spigot and Proxy servers.
+2. Start, then stop every server to let HuskSync generate the config file.
-2. Start your servers, then stop them again to allow the configuration files to generate.  
+3. Navigate to the HuskSync config file on each server (~/plugins/HuskSync/config.yml) and fill in both the MySQL and Redis database credentials.
-3. Navigate to the generated `config.yml` files on your Spigot server and Proxy (located in `/plugins/HuskSync/`) and fill in the credentials of your redis server. 
+4. Start every server again and synchronization will begin.
-   1. On the Proxy server, you can additionally configure a MySQL database to save player data in, as by default the plugin will create a SQLite database. 
-   3. By default, everything except player locations are synchronised. If you would like to change what gets synchronised, you can do this by editing the `config.yml` files of each Spigot server.
-4. Once you have finished setting everything up, make sure to restart all of your servers and proxy server. Then, log in and data should be synchronised!
 
-### Migration from MySQLPlayerDataBridge
+## Development
-HuskSync supports the migration of player data from [MySQLPlayerDataBridge](https://www.spigotmc.org/resources/mysql-player-data-bridge.8117/). Please note that HuskSync is not compatible with MySQLPlayerInventoryBridge, as that has a different system for data handling.
+To build HuskSync, simply run the following in the root of the repository:
 
-To migrate from MySQLPLayerDataBridge, you need a Proxy server with HuskSync installed and one Spigot server with both HuskSync and MySQLPlayerDataBridge installed. To migrate:
+```bash
-1. Make sure HuskSync is set up correctly on the Proxy and Spigot server, making sure that the two are able to communicate with Redis (it will display a handshake confirmation message in both consoles when communications have been established)
-2. Make sure your database is configured correctly on your Proxy server. For example, if you would like to change from SQLite to MySQL, you should do this now because the data from MySQLPlayerDataBridge will be moved into it.
-3. Make sure no players are online, then in the Proxy server's console run `husksync migrate`
-4. Follow the steps in the Migration wizard to ensure the connection credentials and details of the database containing your MySQLPlayerDataBridge are correct, changing settings with `husksync migrate setting <setting> <new value>` as necessary.
-5. Run `husksync migrate start` in the Proxy server's console to start the migration. This could take some time, depending on the amount of data that needs migrating and the speed of your database/server. When the migration is complete, it will display a "Migration complete" message. 
-
-### Troubleshooting
-#### Commands do not function
-Please check that the plugin is installed and enabled on both the proxy and bukkit server you are trying to execute the command from and that both plugins connected to Redis. (A connection handshake confirmation message is logged to console when communications are successfully established.)
-
-#### Data not being synced on player join and SQL errors in proxy console
-This issue frequently occurs in users running Cracked (illegal) servers. I do not support piracy and so will be limited in my ability to help you.
-If you are running an offline server for a legitimate reason, however, make sure that in the `paper.yml` of your Bukkit servers `bungee-online-mode` is set to the correct value - and that both your Proxy (BungeeCord, Waterfall, etc.) server and Bukkit (Spigot, paper, etc.) servers are set up correctly to work with offline mode.
-
-#### Data sometimes not syncing between servers
-There are two primary reasons this may happen:
-* On your proxy server, you are running _FlameCord_ or a similar fork of Waterfall. Due to the nature of these forks changing security parameters, they can block or interfere with Redis packets being sent to and from your server. FlameCord, XCord and other forks are not compatible with HuskSync. For security-conscious users, I recommend Velocity.
-* Your backend servers/proxy and Redis server have noticeably different amounts of latency between each other. This is particularly relevant for users running across multiple machines, where some backend servers / the proxy are installed with Redis and other backend servers are on a different machine. The solution to this is to have your BungeeCord and Redis alone on one machine, and your backend servers across the others - or have a separate machine with equal latency to the others that has Redis on. In the future, I may have a look at automatically correcting and accounting for differences in latency.
-
-## How it works
-![Flow chart showing different processes of how the plugin works](images/flow-chart.png)
-HuskSync saves a player's data when they log out to a cache on your proxy server, and redistributes that data to players when they join another HuskSync-enabled server. Player data in the cache is then saved to a database (be it SQLite or MySQL) and this is loaded from when a player joins your network.
-
-To facilitate the transfer of data between servers, HuskSync serializes player data and then makes use of Redis to communicate between the Proxy and Spigot servers.
-
-### What is synchronised
-Everything except player locations are synchronised by default. You can enable or disable what data is loaded on a server by modifying these values in the `/plugins/HuskSync/config.yml` file on each Spigot server.
-* Player inventory
-   * Player armour and off-hand
-   * Player currently selected hotbar slot
-* Player ender chest
-* Player experience points & levels
-* Player health
-   * Player max health
-   * Player health scale
-* Player hunger
-   * Player saturation
-   * Player exhaustion
-* Player game mode
-* Player advancements
-* Player statistics (ESC → Statistics menu)
-* Player location
-   * Player flight status 
-
-### Commands
-Commands are handled by the proxy server, rather than each spigot server. Some will only work on Spigot servers with HuskSync installed. Please remember that you will need a Proxy permission plugin (e.g. LuckPermsBungee) to set permissions for proxy commands.
-
-| Command                               | Description                          | Permission                     |
-|---------------------------------------|--------------------------------------|--------------------------------|
-| `/husksync about`                     | View plugin information              | _None_                         |
-| `/husksync update`                    | Check if an update is available      | `husksync.command.admin`       |
-| `/husksync status`                    | View system status information       | `husksync.command.admin`       |
-| `/husksync reload`                    | Reload config & message files        | `husksync.command.admin`       |
-| `/husksync invsee <player> [cluster]` | View an offline player's inventory   | `husksync.command.inventory`   |
-| `/husksync echest <player> [cluster]` | View an offline player's ender chest | `husksync.command.ender_chest` |
-| `/husksync migrate [args]           ` | Migrate data from MPDB               | _Console-only_                 |
-
-### Frequently Asked Questions (FAQs)
-#### Is Redis required?
-Yes. Redis is both free, easy to install and multiplatform, though. Pterodactyl users can also run it in an egg with relatively low overheads.
-
-#### What is Redis?
-Redis is server software that acts as an in-memory data store. Minecraft server software typically makes use of its function to send messages efficiently.
-
-#### Is Economy / Vault synchronization supported?
-No.
-
-Synchronising economy data like MySQLPlayerDataBridge does causes a number of issues and incompatibilities that mean that MySQLPlayerDataBridge has had to add integrations with a number of plugins just to make them work. This leads to poor compatibility and more bugs as plugins change their APIs and systems. In the case of HuskSync, this would require both plugin authors and myself to manually support each other, which would inevitably increase update times, lead to a bottomless pit of "add support for this plugin" requests and these integrations would then inevitably break when authors decide to update their plugins, requiring me to update manually.
-
-I strongly recommend making use of economy plugins that provide built-in support for cross-server synchronisation instead, which do not have the same issues. I have personally used [XConomy](https://www.spigotmc.org/resources/xconomy.75669/) in the past and reccommend it.
-
-#### Will this work on servers running multiple proxies?
-Short answer: Not right now, but improved support for this is planned in the future.
-
-Long answer: This is a difficult question to unpack because of the wide variety of setups that involve multiple proxies, however currently the architecture of how messages are sent between servers assumes that one proxy will serve multiple Bukkit servers, so having multiple proxies will lead to data going out of sync, among other issues.
-
-#### Does it work with Velocity?
-Yes! Servers running the Velocity proxy software are supported as of HuskSync 1.2+.
-
-#### Is this faster than MySqlPlayerDataBridge (MPDB)?
-It's difficult to say, and will depend on your server. 
-
-MPDB stores data in a MySQL database (hence the name) and operates by querying a database for said data when a player joins a Bukkit server. 
-HuskSync stores player data in a central cache on the Proxy server and servers request data from said cache; data is only queried from the database when a player joins the network, not when switching servers within it.
-
-HuskSync should operate faster in theory, then, as it does not need to query large amounts of data from a database file as often. However, any performance enhancements you might see will heavily depend on the speed of your existing database and your server hardware.
-
-#### Are modded items supported?
-Most likely not - and I cannot support it - but feel free to test it, as depending on the implementation of your modding API it may work just fine.
-
-## Developers
-### API
-HuskSync has an API for Bukkit providing events that fire when synchronisation takes place as well as a method to access and deserialize player data on demand. There is no API for the proxy side currently.
-
-HuskSync's API is available on [JitPack](https://jitpack.io/#net.william278/HuskSync/Tag). You can view the [HuskSync JavaDocs here](https://javadoc.jitpack.io/net/william278/HuskSync/latest/javadoc/index.html). You should only use stuff in the `husksync.bukkit.api` and `husksync.bukkit.data` packages (as well as the PlayerData class located in the `husksync` root package.
-
-#### Including the API in your project
-With Maven, add the repository to your pom.xml:
-```xml
-	<repositories>
-		<repository>
-		    <id>jitpack.io</id>
-		    <url>https://jitpack.io</url>
-		</repository>
-	</repositories>
-```
-Then, add the dependency. Replace `version` with the latest version of HuskSync: [![](https://jitpack.io/v/WiIIiam278/HuskSync.svg)](https://jitpack.io/#net.william278/HuskSync)
-```xml
-	<dependency>
-            <groupId>net.william278</groupId>
-            <artifactId>HuskSync</artifactId>
-            <version>version</version>
-            <scope>provided</scope>
-	</dependency>
-```
-
-Or, with Gradle, add the dependency like so to your build.gradle:
-```
-	allprojects {
-		repositories {
-			...
-			maven { url 'https://jitpack.io' }
-		}
-	}
-```
-Then add the dependency as follows. Replace `version` with the latest version of HuskSync: [![](https://jitpack.io/v/net.william278/HuskSync.svg)](https://jitpack.io/#net.william278/HuskSync)
-```
-    dependencies {
-	    compileOnly 'net.william278:HuskSync:version'
-	}
-```
-
-#### API Events
-* **SyncCompleteEvent** - Fires when a player's data has finished synchronising. Use #getData to get the PlayerData being set.
-* **SyncEvent** - Fires just before a player's data is synchronised. Can be cancelled. Use #getData to get the PlayerData being set, and #setData to set it.
-
-#### Fetching player data on demand
-To fetch PlayerData from a UUID as you need it, create an instance of the HuskSyncAPI class and use the `#getPlayerData` method. Note that data returned in this method is only the data from the central cache. That is to say, if the player is online, the data returned in this way will not necessarily be the same as the player's actual current data.
-```java
-HuskSyncAPI huskSyncApi = HuskSyncAPI.getInstance();
-try {
-    CompletableFuture<PlayerData> playerDataCompletableFuture = huskSyncApi.getPlayerData(playerUUID);
-    // thenAccept blocks the thread until HuskSync has grabbed the data, so you may wish to run this asynchronously (e.g. Bukkit.getScheduler().runTaskAsynchronously(plugin, () -> {});.
-    playerDataCompletableFuture.thenAccept(playerData -> {
-        // You now have a PlayerData object which you can get serialized data from and deserialize with the DataSerializer static methods 
-    });
-} catch (IOException e) {
-    Bukkit.getLogger().severe("An error occurred fetching player data!");
-}
-```
-
-#### Getting ItemStacks and usable data from PlayerData
-Use the static methods provided in the [DataSerializer class](https://javadoc.jitpack.io/net.william278/HuskSync/latest/javadoc/net/william278/husksync/bukkit/data/DataSerializer.html). For instance, to get a player's inventory as an `ItemStack[]` from a `PlayerData` object.
-```java
-ItemStack[] inventoryItems = DataSerializer.serializeInventory(playerData.getSerializedInventory());
-ItemStack[] enderChestItems = DataSerializer.serializeInventory(playerData.getSerializedEnderChest());
-```
-
-#### Updating PlayerData
-You can then update PlayerData back to the central cache using the `HuskSyncAPI#updatePlayerData(playerData)` method. For example:
-```java
-// Update a value in the player data object
-playerData.setHealth(20);
-try {
-    // Update the player data to the cache
-    huskSyncApi.updatePlayerData(playerData);
-} catch (IOException e) {
-    Bukkit.getLogger().severe("An error occurred updating player data!");
-}
-```
-
-
-### Contributing
-A code bounty program is in place for HuskSync, where developers making significant code contributions to HuskSync may be entitled to a discretionary license to use HuskSync in commercial contexts without having to purchase the resource, so please feel free to submit pull requests with improvements, fixes and features!
-
-### Translation
-While the code bounty program is not available for translation contributors, they are still strongly appreciated in making the plugin more accessible. If you'd like to contribute translated message strings for your language, you can submit a Pull Request that creates a .yml file in `bungeecord/src/main/resources/languages` with the correct translations.
-
-### Building
-You can build HuskSync yourself, though please read the license and buy yourself a copy as HuskSync is indeed a premium resource. 
-
-To build HuskSync, you'll need to get the [MPDBConverter](https://github.com/WiIIiam278/MPDBDataConverter) library, either by authenticating through GitHub packages or by downloading and running `mvn install-file` to publish it to your local maven repository.
-
-Then, to build the plugin, run the following in the root of the repository:
-```
 ./gradlew clean build
 ```
 
-## bStats
+### License
-This plugin uses bStats to provide me with metrics about its usage:
+HuskSync is licensed under the Apache 2.0 license.
-* [View Bukkit metrics](https://bstats.org/plugin/bukkit/HuskSync%20-%20Bukkit/13140)
-* [View BungeeCord metrics](https://bstats.org/plugin/bungeecord/HuskSync%20-%20BungeeCord/13141)
-* [View Velocity metrics](https://bstats.org/plugin/velocity/HuskSync%20-%20Velocity/13489)
 
-You can turn metric collection off by navigating to `~/plugins/bStats/config.yml` and editing the config to disable plugin metrics.
+- [License](https://github.com/WiIIiam278/HuskSync/blob/master/LICENSE)
 
-## Support
+Contributions to the project are welcome&mdash;feel free to open a pull request with new features, improvements and/or fixes!
-* Report bugs: [Click here](https://github.com/WiIIiam278/HuskSync/issues)
+
-* Discord support: Join the [HuskHelp Discord](https://discord.gg/tVYhJfyDWG)!
+### Support
-    * Proof of purchase is required for support.
+Due to its complexity, official support for HuskSync is provided through a paid model. This means that support is only available to users who have purchased a license to the plugin from Spigot, Polymart, or Craftaro and have provided proof of purchase. Please join our Discord server if you have done so and need help!
+
+### Translations
+Translations of the plugin locales are welcome to help make the plugin more accessible. Please submit a pull request with your translations as a `.yml` file.
+
+- [Locales Directory](https://github.com/WiIIiam278/HuskSync/tree/master/common/src/main/resources/languages)
+- [English Locales](https://github.com/WiIIiam278/HuskSync/tree/master/common/src/main/resources/languages/en-gb.yml)
+
+## Links
+- [Docs](https://william278.net/docs/husksync/) &mdash; Read the plugin documentation!
+- [Spigot](https://www.spigotmc.org/resources/husksync.97144/) &mdash; View the Spigot resource page (Also: [Polymart](https://polymart.org/resource/husksync.1634), [Craftaro](https://craftaro.com/marketplace/product/husksync.758))
+- [Issues](https://github.com/WiIIiam278/HuskSync/issues) &mdash; File a bug report or feature request
+- [Discord](https://discord.gg/tVYhJfyDWG) &mdash; Get help, ask questions (Purchase required)
+- [bStats](https://bstats.org/plugin/bukkit/HuskSync%20-%20Bukkit/13140) &mdash; View plugin metrics
+
+---
+&copy; [William278](https://william278.net/), 2023. Licensed under the Apache-2.0 License.

api/build.gradle

@@ -1,20 +0,0 @@
-dependencies {
-    compileOnly project(path: ':common')
-    implementation project(path: ':bukkit')
-
-    compileOnly 'org.spigotmc:spigot-api:1.16.5-R0.1-SNAPSHOT'
-    compileOnly 'org.jetbrains:annotations:23.0.0'
-}
-
-shadowJar {
-    relocate 'de.themoep', 'net.william278.husksync.libraries'
-    relocate 'org.bstats', 'net.william278.husksync.libraries.bstats'
-    relocate 'redis.clients', 'net.william278.husksync.libraries'
-    relocate 'org.apache', 'net.william278.husksync.libraries'
-    relocate 'net.william278.mpdbconverter', 'net.william278.husksync.libraries.mpdbconverter'
-}
-
-java {
-    withSourcesJar()
-    withJavadocJar()
-}

api/src/main/java/net/william278/husksync/bukkit/api/HuskSyncAPI.java

@@ -1,81 +0,0 @@
-package net.william278.husksync.bukkit.api;
-
-import net.william278.husksync.PlayerData;
-import net.william278.husksync.Settings;
-import net.william278.husksync.bukkit.listener.BukkitRedisListener;
-import net.william278.husksync.redis.RedisMessage;
-
-import java.io.IOException;
-import java.util.UUID;
-import java.util.concurrent.CompletableFuture;
-
-/**
- * HuskSync's API. To access methods, use the {@link #getInstance()} entrypoint.
- *
- * @author William
- */
-public class HuskSyncAPI {
-
-    private HuskSyncAPI() {
-    }
-
-    private static HuskSyncAPI instance;
-
-    /**
-     * The API entry point. Returns an instance of the {@link HuskSyncAPI}
-     *
-     * @return instance of the {@link HuskSyncAPI}
-     */
-    public static HuskSyncAPI getInstance() {
-        if (instance == null) {
-            instance = new HuskSyncAPI();
-        }
-        return instance;
-    }
-
-    /**
-     * Returns a {@link CompletableFuture} that will fetch the {@link PlayerData} for a user given their {@link UUID},
-     * which contains serialized synchronised data.
-     * <p>
-     * This can then be deserialized into ItemStacks and other usable values using the {@code DataSerializer} class.
-     * <p>
-     * If no data could be returned, such as if an invalid UUID is specified, the CompletableFuture will be cancelled.
-     *
-     * @param playerUUID The {@link UUID} of the player to get data for
-     * @return a {@link CompletableFuture} with the user's {@link PlayerData} accessible on completion
-     * @throws IOException If an exception occurs with serializing during processing of the request
-     * @apiNote This only returns the latest saved and cached data of the user. This is <b>not</b> necessarily the current state of their inventory if they are online.
-     */
-    public CompletableFuture<PlayerData> getPlayerData(UUID playerUUID) throws IOException {
-        // Create the request to be completed
-        final UUID requestUUID = UUID.randomUUID();
-        BukkitRedisListener.apiRequests.put(requestUUID, new CompletableFuture<>());
-
-        // Remove the request from the map on completion
-        BukkitRedisListener.apiRequests.get(requestUUID).whenComplete((playerData, throwable) -> BukkitRedisListener.apiRequests.remove(requestUUID));
-
-        // Request the data via the proxy
-        new RedisMessage(RedisMessage.MessageType.API_DATA_REQUEST,
-                new RedisMessage.MessageTarget(Settings.ServerType.PROXY, null, Settings.cluster),
-                playerUUID.toString(), requestUUID.toString()).send();
-
-        return BukkitRedisListener.apiRequests.get(requestUUID);
-    }
-
-    /**
-     * Updates a player's {@link PlayerData} to the proxy cache and database.
-     * <p>
-     * If the player is online on the Proxy network, they will be updated and overwritten with this data.
-     *
-     * @param playerData The {@link PlayerData} (which contains the {@link UUID}) of the player data to update to the central cache and database
-     * @throws IOException If an exception occurs with serializing during processing of the update
-     */
-    public void updatePlayerData(PlayerData playerData) throws IOException {
-        // Serialize and send the updated player data
-        final String serializedPlayerData = RedisMessage.serialize(playerData);
-        new RedisMessage(RedisMessage.MessageType.PLAYER_DATA_UPDATE,
-                new RedisMessage.MessageTarget(Settings.ServerType.PROXY, null, Settings.cluster),
-                serializedPlayerData, Boolean.toString(true)).send();
-    }
-
-}

build.gradle

@@ -1,20 +1,32 @@
 plugins {
-    id 'com.github.johnrengelman.shadow' version '7.1.0'
+    id 'com.github.johnrengelman.shadow' version '8.1.1'
-    id 'org.ajoberstar.grgit' version '4.1.1'
+    id 'org.cadixdev.licenser' version '0.6.1' apply false
+    id 'org.ajoberstar.grgit' version '5.2.0'
+    id 'maven-publish'
     id 'java'
 }
 
 group 'net.william278'
-version "$ext.plugin_version+${versionMetadata()}"
+version "$ext.plugin_version${versionMetadata()}"
+description "$ext.plugin_description"
+defaultTasks 'licenseFormat', 'build'
 
 ext {
     set 'version', version.toString()
+    set 'description', description.toString()
+
+    set 'jedis_version', jedis_version.toString()
+    set 'mysql_driver_version', mysql_driver_version.toString()
+    set 'mariadb_driver_version', mariadb_driver_version.toString()
+    set 'snappy_version', snappy_version.toString()
+    set 'commons_text_version', commons_text_version.toString()
 }
 
 import org.apache.tools.ant.filters.ReplaceTokens
 
 allprojects {
     apply plugin: 'com.github.johnrengelman.shadow'
+    apply plugin: 'org.cadixdev.licenser'
     apply plugin: 'java'
 
     compileJava.options.encoding = 'UTF-8'
@@ -27,18 +39,27 @@ allprojects {
         mavenLocal()
         mavenCentral()
         maven { url 'https://hub.spigotmc.org/nexus/content/repositories/snapshots/' }
-        maven { url 'https://repo.velocitypowered.com/snapshots/' }
         maven { url 'https://repo.minebench.de/' }
-        maven { url 'https://repo.codemc.org/repository/maven-public' }
         maven { url 'https://repo.alessiodp.com/releases/' }
+        maven { url 'https://repo.mattstudios.me/artifactory/public/' }
         maven { url 'https://jitpack.io' }
+        maven { url 'https://libraries.minecraft.net/' }
+        maven { url 'https://william278.net/releases/' }
     }
 
     dependencies {
-        implementation('redis.clients:jedis:4.2.3') {
+        testImplementation 'org.junit.jupiter:junit-jupiter-api:5.10.0'
-            //noinspection GroovyAssignabilityCheck
+        testImplementation 'org.junit.jupiter:junit-jupiter-engine:5.10.0'
-            exclude module: 'slf4j-api'
+    }
-        }
+
+    test {
+        useJUnitPlatform()
+    }
+
+    license {
+        header = rootProject.file('HEADER')
+        include '**/*.java'
+        newLine = true
     }
 
     processResources {
@@ -51,12 +72,74 @@ subprojects {
     version rootProject.version
     archivesBaseName = "${rootProject.name}-${project.name.capitalize()}"
 
-    if (['bukkit', 'api', 'bungeecord', 'velocity', 'plugin'].contains(project.name)) {
+    jar {
+        from '../LICENSE'
+    }
+
+    if (['bukkit', 'plugin'].contains(project.name)) {
         shadowJar {
             destinationDirectory.set(file("$rootDir/target"))
             archiveClassifier.set('')
         }
-        jar.dependsOn shadowJar
+
+        // API publishing
+        if ('bukkit'.contains(project.name)) {
+            java {
+                withSourcesJar()
+                withJavadocJar()
+            }
+            sourcesJar {
+                destinationDirectory.set(file("$rootDir/target"))
+            }
+            javadocJar {
+                destinationDirectory.set(file("$rootDir/target"))
+            }
+            shadowJar.dependsOn(sourcesJar, javadocJar)
+
+            publishing {
+                repositories {
+                    if (System.getenv("RELEASES_MAVEN_USERNAME") != null) {
+                        maven {
+                            name = "william278-releases"
+                            url = "https://repo.william278.net/releases"
+                            credentials {
+                                username = System.getenv("RELEASES_MAVEN_USERNAME")
+                                password = System.getenv("RELEASES_MAVEN_PASSWORD")
+                            }
+                            authentication {
+                                basic(BasicAuthentication)
+                            }
+                        }
+                    }
+                    if (System.getenv("SNAPSHOTS_MAVEN_USERNAME") != null) {
+                        maven {
+                            name = "william278-snapshots"
+                            url = "https://repo.william278.net/snapshots"
+                            credentials {
+                                username = System.getenv("SNAPSHOTS_MAVEN_USERNAME")
+                                password = System.getenv("SNAPSHOTS_MAVEN_PASSWORD")
+                            }
+                            authentication {
+                                basic(BasicAuthentication)
+                            }
+                        }
+                    }
+                }
+
+                publications {
+                    mavenJava(MavenPublication) {
+                        groupId = 'net.william278'
+                        artifactId = 'husksync'
+                        version = "$rootProject.version"
+                        artifact shadowJar
+                        artifact javadocJar
+                        artifact sourcesJar
+                    }
+                }
+            }
+        }
+
+        jar.dependsOn(shadowJar)
         clean.delete "$rootDir/target"
     }
 }
@@ -65,8 +148,15 @@ logger.lifecycle("Building HuskSync ${version} by William278")
 
 @SuppressWarnings('GrMethodMayBeStatic')
 def versionMetadata() {
-    if (grgit == null) {
+    // Get if there is a tag for this commit
-        return System.getenv("GITHUB_RUN_NUMBER") ? 'build.' + System.getenv("GITHUB_RUN_NUMBER") : 'unknown'
+    def tag = grgit.tag.list().find { it.commit.id == grgit.head().id }
+    if (tag != null) {
+        return ''
     }
-    return 'rev.' + grgit.head().abbreviatedId + (grgit.status().clean ? '' : '-indev')
+
+    // Otherwise, get the last commit hash and if it's a clean head
+    if (grgit == null) {
+        return '-' + System.getenv("GITHUB_RUN_NUMBER") ? 'build.' + System.getenv("GITHUB_RUN_NUMBER") : 'unknown'
+    }
+    return '-' + grgit.head().abbreviatedId + (grgit.status().clean ? '' : '-indev')
 }

bukkit/build.gradle

@@ -1,18 +1,50 @@
 dependencies {
     implementation project(path: ':common')
-
+    implementation 'org.bstats:bstats-bukkit:3.0.2'
-    implementation 'org.bstats:bstats-bukkit:3.0.0'
+    implementation 'net.william278:mpdbdataconverter:1.0.1'
-    implementation 'de.themoep:minedown:1.7.1-SNAPSHOT'
+    implementation 'net.william278:hsldataconverter:1.0'
-    implementation 'net.william278:mpdbdataconverter:1.0'
+    implementation 'net.william278:MapDataAPI:1.0.2'
+    implementation 'net.william278:AndJam:1.0.2'
+    implementation 'me.lucko:commodore:2.2'
+    implementation 'net.kyori:adventure-platform-bukkit:4.3.0'
+    implementation 'dev.triumphteam:triumph-gui:3.1.5'
 
     compileOnly 'org.spigotmc:spigot-api:1.16.5-R0.1-SNAPSHOT'
-    compileOnly 'org.jetbrains:annotations:23.0.0'
+    compileOnly 'commons-io:commons-io:2.13.0'
+    compileOnly 'de.themoep:minedown-adventure:1.7.2-SNAPSHOT'
+    compileOnly 'dev.dejvokep:boosted-yaml:1.3.1'
+    compileOnly 'com.zaxxer:HikariCP:5.0.1'
+    compileOnly 'redis.clients:jedis:' + jedis_version
+    compileOnly 'net.william278:DesertWell:2.0.4'
+    compileOnly 'net.william278:Annotaml:2.0.1'
+    compileOnly 'net.william278:AdvancementAPI:97a9583413'
 }
 
 shadowJar {
+    dependencies {
+        exclude(dependency('com.mojang:brigadier'))
+    }
+
+    relocate 'org.apache.commons.io', 'net.william278.husksync.libraries.commons.io'
+    relocate 'com.google.gson', 'net.william278.husksync.libraries.gson'
     relocate 'de.themoep', 'net.william278.husksync.libraries'
+    relocate 'net.kyori', 'net.william278.husksync.libraries'
+    relocate 'org.jetbrains', 'net.william278.husksync.libraries'
+    relocate 'org.intellij', 'net.william278.husksync.libraries'
+    relocate 'com.zaxxer', 'net.william278.husksync.libraries'
+    relocate 'dev.dejvokep', 'net.william278.husksync.libraries'
+    relocate 'net.william278.desertwell', 'net.william278.husksync.libraries.desertwell'
+    relocate 'net.william278.paginedown', 'net.william278.husksync.libraries.paginedown'
+    relocate 'net.william278.mapdataapi', 'net.william278.husksync.libraries.mapdataapi'
+    relocate 'net.william278.andjam', 'net.william278.husksync.libraries.andjam'
+    relocate 'net.querz', 'net.william278.husksync.libraries.nbt'
+    relocate 'net.roxeez', 'net.william278.husksync.libraries'
+
+    relocate 'me.lucko.commodore', 'net.william278.husksync.libraries.commodore'
+    relocate 'net.byteflux.libby', 'net.william278.husksync.libraries.libby'
     relocate 'org.bstats', 'net.william278.husksync.libraries.bstats'
-    relocate 'redis.clients', 'net.william278.husksync.libraries'
+    relocate 'dev.triumphteam.gui', 'net.william278.husksync.libraries.triumphgui'
-    relocate 'org.apache', 'net.william278.husksync.libraries'
     relocate 'net.william278.mpdbconverter', 'net.william278.husksync.libraries.mpdbconverter'
+    relocate 'net.william278.hslmigrator', 'net.william278.husksync.libraries.hslconverter'
+    relocate 'net.william278.annotaml', 'net.william278.husksync.libraries.annotaml'
 }

bukkit/src/main/java/me.william278.husksync.bukkit.data/DataSerializer.java

@@ -1,57 +0,0 @@
-package me.william278.husksync.bukkit.data;
-
-import org.bukkit.Material;
-import org.bukkit.Statistic;
-import org.bukkit.World;
-import org.bukkit.entity.EntityType;
-
-import java.io.Serializable;
-import java.time.Instant;
-import java.util.*;
-
-/**
- * Holds legacy data store methods for data storage
- */
-@Deprecated
-@SuppressWarnings("DeprecatedIsStillUsed")
-public class DataSerializer {
-
-    /**
-     * A record used to store data for advancement synchronisation
-     *
-     * @deprecated Old format - Use {@link AdvancementRecordDate} instead
-     */
-    @Deprecated
-    @SuppressWarnings("DeprecatedIsStillUsed")
-    // Suppress deprecation warnings here (still used for backwards compatibility)
-    public record AdvancementRecord(String advancementKey,
-                                    ArrayList<String> awardedAdvancementCriteria) implements Serializable {
-    }
-
-    /**
-     * A record used to store data for a player's statistics
-     */
-    public record StatisticData(HashMap<Statistic, Integer> untypedStatisticValues,
-                                HashMap<Statistic, HashMap<Material, Integer>> blockStatisticValues,
-                                HashMap<Statistic, HashMap<Material, Integer>> itemStatisticValues,
-                                HashMap<Statistic, HashMap<EntityType, Integer>> entityStatisticValues) implements Serializable {
-    }
-
-    /**
-     * A record used to store data for native advancement synchronisation, tracking advancement date progress
-     */
-    public record AdvancementRecordDate(String key, Map<String, Date> criteriaMap) implements Serializable {
-        public AdvancementRecordDate(String key, List<String> criteriaList) {
-            this(key, new HashMap<>() {{
-                criteriaList.forEach(s -> put(s, Date.from(Instant.EPOCH)));
-            }});
-        }
-    }
-
-    /**
-     * A record used to store data for a player's location
-     */
-    public record PlayerLocation(double x, double y, double z, float yaw, float pitch,
-                                 String worldName, World.Environment environment) implements Serializable {
-    }
-}

bukkit/src/main/java/net/william278/husksync/BukkitHuskSync.java

@@ -0,0 +1,341 @@
+/*
+ * This file is part of HuskSync, licensed under the Apache License 2.0.
+ *
+ *  Copyright (c) William278 <will27528@gmail.com>
+ *  Copyright (c) contributors
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+package net.william278.husksync;
+
+import net.kyori.adventure.platform.bukkit.BukkitAudiences;
+import net.william278.annotaml.Annotaml;
+import net.william278.desertwell.util.Version;
+import net.william278.husksync.command.BukkitCommand;
+import net.william278.husksync.command.BukkitCommandType;
+import net.william278.husksync.command.Permission;
+import net.william278.husksync.config.Locales;
+import net.william278.husksync.config.Settings;
+import net.william278.husksync.data.CompressedDataAdapter;
+import net.william278.husksync.data.DataAdapter;
+import net.william278.husksync.data.JsonDataAdapter;
+import net.william278.husksync.database.Database;
+import net.william278.husksync.database.MySqlDatabase;
+import net.william278.husksync.event.BukkitEventCannon;
+import net.william278.husksync.event.EventCannon;
+import net.william278.husksync.hook.PlanHook;
+import net.william278.husksync.listener.BukkitEventListener;
+import net.william278.husksync.listener.EventListener;
+import net.william278.husksync.migrator.LegacyMigrator;
+import net.william278.husksync.migrator.Migrator;
+import net.william278.husksync.migrator.MpdbMigrator;
+import net.william278.husksync.player.BukkitPlayer;
+import net.william278.husksync.player.OnlineUser;
+import net.william278.husksync.redis.RedisManager;
+import org.bstats.bukkit.Metrics;
+import org.bukkit.Bukkit;
+import org.bukkit.command.PluginCommand;
+import org.bukkit.entity.Player;
+import org.bukkit.permissions.PermissionDefault;
+import org.bukkit.plugin.Plugin;
+import org.bukkit.plugin.java.JavaPlugin;
+import org.jetbrains.annotations.NotNull;
+
+import java.io.File;
+import java.io.IOException;
+import java.lang.reflect.InvocationTargetException;
+import java.util.*;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.logging.Level;
+import java.util.stream.Collectors;
+
+public class BukkitHuskSync extends JavaPlugin implements HuskSync {
+
+    /**
+     * Metrics ID for <a href="https://bstats.org/plugin/bukkit/HuskSync%20-%20Bukkit/13140">HuskSync on Bukkit</a>.
+     */
+    private static final int METRICS_ID = 13140;
+    private Database database;
+    private RedisManager redisManager;
+    private EventListener eventListener;
+    private DataAdapter dataAdapter;
+    private EventCannon eventCannon;
+    private Settings settings;
+    private Locales locales;
+    private List<Migrator> availableMigrators;
+
+    private BukkitAudiences audiences;
+    private static BukkitHuskSync instance;
+
+    /**
+     * (<b>Internal use only)</b> Returns the instance of the implementing Bukkit plugin
+     *
+     * @return the instance of the Bukkit plugin
+     */
+    public static BukkitHuskSync getInstance() {
+        return instance;
+    }
+
+    @Override
+    public void onLoad() {
+        instance = this;
+    }
+
+    @Override
+    public void onEnable() {
+        // Initialize HuskSync
+        final AtomicBoolean initialized = new AtomicBoolean(true);
+        try {
+            // Create adventure audience
+            this.audiences = BukkitAudiences.create(this);
+
+            // Load settings and locales
+            log(Level.INFO, "Loading plugin configuration settings & locales...");
+            initialized.set(reload().join());
+            if (initialized.get()) {
+                log(Level.INFO, "Successfully loaded plugin configuration settings & locales");
+            } else {
+                throw new HuskSyncInitializationException("Failed to load plugin configuration settings and/or locales");
+            }
+
+            // Prepare data adapter
+            if (settings.doCompressData()) {
+                dataAdapter = new CompressedDataAdapter();
+            } else {
+                dataAdapter = new JsonDataAdapter();
+            }
+
+            // Prepare event cannon
+            eventCannon = new BukkitEventCannon();
+
+            // Prepare migrators
+            availableMigrators = new ArrayList<>();
+            availableMigrators.add(new LegacyMigrator(this));
+            final Plugin mySqlPlayerDataBridge = Bukkit.getPluginManager().getPlugin("MySqlPlayerDataBridge");
+            if (mySqlPlayerDataBridge != null) {
+                availableMigrators.add(new MpdbMigrator(this, mySqlPlayerDataBridge));
+            }
+
+            // Prepare database connection
+            this.database = new MySqlDatabase(this);
+            log(Level.INFO, "Attempting to establish connection to the " + settings.getDatabaseType().getDisplayName() + " database...");
+            this.database.initialize();
+            if (initialized.get()) {
+                log(Level.INFO, "Successfully established a connection to the database");
+            } else {
+                throw new HuskSyncInitializationException("Failed to establish a connection to the database. " +
+                        "Please check the supplied database credentials in the config file");
+            }
+
+            // Prepare redis connection
+            this.redisManager = new RedisManager(this);
+            log(Level.INFO, "Attempting to establish connection to the Redis server...");
+            initialized.set(this.redisManager.initialize());
+            if (initialized.get()) {
+                log(Level.INFO, "Successfully established a connection to the Redis server");
+            } else {
+                throw new HuskSyncInitializationException("Failed to establish a connection to the Redis server. " +
+                        "Please check the supplied Redis credentials in the config file");
+            }
+
+            // Register events
+            log(Level.INFO, "Registering events...");
+            this.eventListener = new BukkitEventListener(this);
+            log(Level.INFO, "Successfully registered events listener");
+
+            // Register permissions
+            log(Level.INFO, "Registering permissions & commands...");
+            Arrays.stream(Permission.values()).forEach(permission -> getServer().getPluginManager()
+                    .addPermission(new org.bukkit.permissions.Permission(permission.node, switch (permission.defaultAccess) {
+                        case EVERYONE -> PermissionDefault.TRUE;
+                        case NOBODY -> PermissionDefault.FALSE;
+                        case OPERATORS -> PermissionDefault.OP;
+                    })));
+
+            // Register commands
+            for (final BukkitCommandType bukkitCommandType : BukkitCommandType.values()) {
+                final PluginCommand pluginCommand = getCommand(bukkitCommandType.commandBase.command);
+                if (pluginCommand != null) {
+                    new BukkitCommand(bukkitCommandType.commandBase, this).register(pluginCommand);
+                }
+            }
+            log(Level.INFO, "Successfully registered permissions & commands");
+
+            // Hook into plan
+            if (Bukkit.getPluginManager().getPlugin("Plan") != null) {
+                log(Level.INFO, "Enabling Plan integration...");
+                new PlanHook(this).hookIntoPlan();
+                log(Level.INFO, "Plan integration enabled!");
+            }
+
+            // Hook into bStats metrics
+            try {
+                new Metrics(this, METRICS_ID);
+            } catch (final Exception e) {
+                log(Level.WARNING, "Skipped bStats metrics initialization due to an exception.");
+            }
+
+            // Check for updates
+            if (settings.doCheckForUpdates()) {
+                log(Level.INFO, "Checking for updates...");
+                getLatestVersionIfOutdated().thenAccept(newestVersion ->
+                        newestVersion.ifPresent(newVersion -> log(Level.WARNING,
+                                "An update is available for HuskSync, v" + newVersion
+                                        + " (Currently running v" + getPluginVersion() + ")")));
+            }
+        } catch (IllegalStateException exception) {
+            log(Level.SEVERE, """
+                    ***************************************************
+                               
+                              Failed to initialize HuskSync!
+                               
+                    ***************************************************
+                    The plugin was disabled due to an error. Please check
+                    the logs below for details.
+                    No user data will be synchronised.
+                    ***************************************************
+                    Caused by: %error_message%
+                    """
+                    .replaceAll("%error_message%", exception.getMessage()));
+            initialized.set(false);
+        } catch (Exception exception) {
+            log(Level.SEVERE, "An unhandled exception occurred initializing HuskSync!", exception);
+            initialized.set(false);
+        } finally {
+            // Validate initialization
+            if (initialized.get()) {
+                log(Level.INFO, "Successfully enabled HuskSync v" + getPluginVersion());
+            } else {
+                log(Level.SEVERE, "Failed to initialize HuskSync. The plugin will now be disabled");
+                getServer().getPluginManager().disablePlugin(this);
+            }
+        }
+    }
+
+    @Override
+    public void onDisable() {
+        if (this.eventListener != null) {
+            this.eventListener.handlePluginDisable();
+        }
+        log(Level.INFO, "Successfully disabled HuskSync v" + getPluginVersion());
+    }
+
+    @Override
+    public @NotNull Set<OnlineUser> getOnlineUsers() {
+        return Bukkit.getOnlinePlayers().stream().map(BukkitPlayer::adapt).collect(Collectors.toSet());
+    }
+
+    @Override
+    public @NotNull Optional<OnlineUser> getOnlineUser(@NotNull UUID uuid) {
+        final Player player = Bukkit.getPlayer(uuid);
+        if (player == null) {
+            return Optional.empty();
+        }
+        return Optional.of(BukkitPlayer.adapt(player));
+    }
+
+    @Override
+    public @NotNull Database getDatabase() {
+        return database;
+    }
+
+    @Override
+    public @NotNull RedisManager getRedisManager() {
+        return redisManager;
+    }
+
+    @Override
+    public @NotNull DataAdapter getDataAdapter() {
+        return dataAdapter;
+    }
+
+    @Override
+    public @NotNull EventCannon getEventCannon() {
+        return eventCannon;
+    }
+
+    @NotNull
+    @Override
+    public List<Migrator> getAvailableMigrators() {
+        return availableMigrators;
+    }
+
+    @Override
+    public @NotNull Settings getSettings() {
+        return settings;
+    }
+
+    @Override
+    public @NotNull Locales getLocales() {
+        return locales;
+    }
+
+    @Override
+    public void log(@NotNull Level level, @NotNull String message, @NotNull Throwable... throwable) {
+        if (throwable.length > 0) {
+            getLogger().log(level, message, throwable[0]);
+        } else {
+            getLogger().log(level, message);
+        }
+    }
+
+    @NotNull
+    @Override
+    public Version getPluginVersion() {
+        return Version.fromString(getDescription().getVersion(), "-");
+    }
+
+    @NotNull
+    @Override
+    public Version getMinecraftVersion() {
+        return Version.fromString(Bukkit.getBukkitVersion());
+    }
+
+    /**
+     * Returns the adventure Bukkit audiences
+     *
+     * @return The adventure Bukkit audiences
+     */
+    @NotNull
+    public BukkitAudiences getAudiences() {
+        return audiences;
+    }
+
+    @Override
+    public Set<UUID> getLockedPlayers() {
+        return this.eventListener.getLockedPlayers();
+    }
+
+    @Override
+    public CompletableFuture<Boolean> reload() {
+        return CompletableFuture.supplyAsync(() -> {
+            try {
+                // Load plugin settings
+                this.settings = Annotaml.create(new File(getDataFolder(), "config.yml"), new Settings()).get();
+
+                // Load locales from language preset default
+                final Locales languagePresets = Annotaml.create(Locales.class,
+                        Objects.requireNonNull(getResource("locales/" + settings.getLanguage() + ".yml"))).get();
+                this.locales = Annotaml.create(new File(getDataFolder(), "messages_" + settings.getLanguage() + ".yml"),
+                        languagePresets).get();
+                return true;
+            } catch (IOException | NullPointerException | InvocationTargetException | IllegalAccessException |
+                     InstantiationException e) {
+                log(Level.SEVERE, "Failed to load data from the config", e);
+                return false;
+            }
+        });
+    }
+}

bukkit/src/main/java/net/william278/husksync/HuskSyncBukkit.java

@@ -1,163 +0,0 @@
-package net.william278.husksync;
-
-import net.william278.husksync.Settings;
-import net.william278.husksync.bukkit.util.BukkitUpdateChecker;
-import net.william278.husksync.bukkit.util.PlayerSetter;
-import net.william278.husksync.bukkit.config.ConfigLoader;
-import net.william278.husksync.bukkit.data.BukkitDataCache;
-import net.william278.husksync.bukkit.listener.BukkitRedisListener;
-import net.william278.husksync.bukkit.listener.BukkitEventListener;
-import net.william278.husksync.bukkit.migrator.MPDBDeserializer;
-import net.william278.husksync.redis.RedisMessage;
-import org.bstats.bukkit.Metrics;
-import org.bukkit.Bukkit;
-import org.bukkit.entity.Player;
-import org.bukkit.plugin.Plugin;
-import org.bukkit.plugin.java.JavaPlugin;
-import org.bukkit.scheduler.BukkitTask;
-
-import java.io.IOException;
-import java.util.UUID;
-import java.util.logging.Level;
-
-public final class HuskSyncBukkit extends JavaPlugin {
-
-    // Bukkit bStats ID (Different to BungeeCord)
-    private static final int METRICS_ID = 13140;
-
-    private static HuskSyncBukkit instance;
-    public static HuskSyncBukkit getInstance() {
-        return instance;
-    }
-
-    public static BukkitDataCache bukkitCache;
-
-    public static BukkitRedisListener redisListener;
-
-    // Used for establishing a handshake with redis
-    public static UUID serverUUID;
-
-    // Has a handshake been established with the Bungee?
-    public static boolean handshakeCompleted = false;
-
-    // The handshake task to execute
-    private static BukkitTask handshakeTask;
-
-    // Whether MySqlPlayerDataBridge is installed
-    public static boolean isMySqlPlayerDataBridgeInstalled;
-
-    // Establish the handshake with the proxy
-    public static void establishRedisHandshake() {
-        serverUUID = UUID.randomUUID();
-        getInstance().getLogger().log(Level.INFO, "Executing handshake with Proxy server...");
-        final int[] attempts = {0}; // How many attempts to establish communication have been made
-        handshakeTask = Bukkit.getScheduler().runTaskTimerAsynchronously(getInstance(), () -> {
-            if (handshakeCompleted) {
-                handshakeTask.cancel();
-                return;
-            }
-            try {
-                new RedisMessage(RedisMessage.MessageType.CONNECTION_HANDSHAKE,
-                        new RedisMessage.MessageTarget(Settings.ServerType.PROXY, null, Settings.cluster),
-                        serverUUID.toString(),
-                        Boolean.toString(isMySqlPlayerDataBridgeInstalled),
-                        Bukkit.getName(),
-                        getInstance().getDescription().getVersion())
-                        .send();
-                attempts[0]++;
-                if (attempts[0] == 10) {
-                    getInstance().getLogger().log(Level.WARNING, "Failed to complete handshake with the Proxy server; Please make sure your Proxy server is online and has HuskSync installed in its' /plugins/ folder. HuskSync will continue to try and establish a connection.");
-                }
-            } catch (IOException e) {
-                getInstance().getLogger().log(Level.SEVERE, "Failed to serialize Redis message for handshake establishment", e);
-            }
-        }, 0, 60);
-    }
-
-    private void closeRedisHandshake() {
-        if (!handshakeCompleted) return;
-        try {
-            new RedisMessage(RedisMessage.MessageType.TERMINATE_HANDSHAKE,
-                    new RedisMessage.MessageTarget(Settings.ServerType.PROXY, null, Settings.cluster),
-                    serverUUID.toString(),
-                    Bukkit.getName()).send();
-        }  catch (IOException e) {
-            getInstance().getLogger().log(Level.SEVERE, "Failed to serialize Redis message for handshake termination", e);
-        }
-    }
-
-    @Override
-    public void onLoad() {
-        instance = this;
-    }
-
-    @Override
-    public void onEnable() {
-        // Plugin startup logic
-
-        // Load the config file
-        getConfig().options().copyDefaults(true);
-        saveDefaultConfig();
-        saveConfig();
-        reloadConfig();
-        ConfigLoader.loadSettings(getConfig());
-
-        // Do update checker
-        if (Settings.automaticUpdateChecks) {
-            new BukkitUpdateChecker().logToConsole();
-        }
-
-        // Check if MySqlPlayerDataBridge is installed
-        Plugin mySqlPlayerDataBridge = Bukkit.getPluginManager().getPlugin("MySqlPlayerDataBridge");
-        if (mySqlPlayerDataBridge != null) {
-            isMySqlPlayerDataBridgeInstalled = mySqlPlayerDataBridge.isEnabled();
-            MPDBDeserializer.setMySqlPlayerDataBridge();
-            getLogger().info("MySQLPlayerDataBridge detected! Disabled data synchronisation to prevent data loss. To perform a migration, run \"husksync migrate\" in your Proxy (Bungeecord, Waterfall, etc) server console.");
-        }
-
-        // Initialize last data update UUID cache
-        bukkitCache = new BukkitDataCache();
-
-        // Initialize event listener
-        getServer().getPluginManager().registerEvents(new BukkitEventListener(), this);
-
-        // Initialize the redis listener
-        redisListener = new BukkitRedisListener();
-
-        // Ensure redis is connected; establish a handshake
-        establishRedisHandshake();
-
-        // Initialize bStats metrics
-        try {
-            new Metrics(this, METRICS_ID);
-        } catch (Exception e) {
-            getLogger().info("Skipped metrics initialization");
-        }
-
-        // Log to console
-        getLogger().info("Enabled HuskSync (" + getServer().getName() + ") v" + getDescription().getVersion());
-    }
-
-    @Override
-    public void onDisable() {
-        // Update player data for disconnecting players
-        if (HuskSyncBukkit.handshakeCompleted && !HuskSyncBukkit.isMySqlPlayerDataBridgeInstalled && Bukkit.getOnlinePlayers().size() > 0) {
-            getLogger().info("Saving data for remaining online players...");
-            for (Player player : Bukkit.getOnlinePlayers()) {
-                PlayerSetter.updatePlayerData(player, false);
-
-                // Clear player inventory and ender chest
-                player.getInventory().clear();
-                player.getEnderChest().clear();
-            }
-            getLogger().info("Data save complete!");
-        }
-
-
-        // Send termination handshake to proxy
-        closeRedisHandshake();
-
-        // Plugin shutdown logic
-        getLogger().info("Disabled HuskSync (" + getServer().getName() + ") v" + getDescription().getVersion());
-    }
-}

bukkit/src/main/java/net/william278/husksync/api/HuskSyncAPI.java

@@ -0,0 +1,226 @@
+/*
+ * This file is part of HuskSync, licensed under the Apache License 2.0.
+ *
+ *  Copyright (c) William278 <will27528@gmail.com>
+ *  Copyright (c) contributors
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+package net.william278.husksync.api;
+
+import net.william278.husksync.BukkitHuskSync;
+import net.william278.husksync.data.*;
+import net.william278.husksync.player.BukkitPlayer;
+import net.william278.husksync.player.OnlineUser;
+import net.william278.husksync.player.User;
+import org.bukkit.entity.Player;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.potion.PotionEffect;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Optional;
+import java.util.concurrent.CompletableFuture;
+
+/**
+ * The HuskSync API implementation for the Bukkit platform, providing methods to access and modify player {@link UserData} held by {@link User}s.
+ * </p>
+ * Retrieve an instance of the API class via {@link #getInstance()}.
+ */
+@SuppressWarnings("unused")
+public class HuskSyncAPI extends BaseHuskSyncAPI {
+
+    /**
+     * <b>(Internal use only)</b> - Instance of the API class
+     */
+    private static final HuskSyncAPI INSTANCE = new HuskSyncAPI();
+
+    /**
+     * <b>(Internal use only)</b> - Constructor, instantiating the API
+     */
+    private HuskSyncAPI() {
+        super(BukkitHuskSync.getInstance());
+    }
+
+    /**
+     * Entrypoint to the HuskSync API - returns an instance of the API
+     *
+     * @return instance of the HuskSync API
+     */
+    public static @NotNull HuskSyncAPI getInstance() {
+        return INSTANCE;
+    }
+
+    /**
+     * Returns a {@link User} instance for the given bukkit {@link Player}.
+     *
+     * @param player the bukkit player to get the {@link User} instance for
+     * @return the {@link User} instance for the given bukkit {@link Player}
+     * @since 2.0
+     */
+    @NotNull
+    public OnlineUser getUser(@NotNull Player player) {
+        return BukkitPlayer.adapt(player);
+    }
+
+    /**
+     * Set the inventory in the database of the given {@link User} to the given {@link ItemStack} contents
+     *
+     * @param user              the {@link User} to set the inventory of
+     * @param inventoryContents the {@link ItemStack} contents to set the inventory to
+     * @return future returning void when complete
+     * @since 2.0
+     */
+    public CompletableFuture<Void> setInventoryData(@NotNull User user, @NotNull ItemStack[] inventoryContents) {
+        return CompletableFuture.runAsync(() -> getUserData(user).thenAccept(userData ->
+                userData.ifPresent(data -> serializeItemStackArray(inventoryContents)
+                        .thenAccept(serializedInventory -> {
+                            data.getInventory().orElse(ItemData.empty()).serializedItems = serializedInventory;
+                            setUserData(user, data).join();
+                        }))));
+    }
+
+    /**
+     * Set the inventory in the database of the given {@link User} to the given {@link BukkitInventoryMap} contents
+     *
+     * @param user         the {@link User} to set the inventory of
+     * @param inventoryMap the {@link BukkitInventoryMap} contents to set the inventory to
+     * @return future returning void when complete
+     * @since 2.0
+     */
+    public CompletableFuture<Void> setInventoryData(@NotNull User user, @NotNull BukkitInventoryMap inventoryMap) {
+        return setInventoryData(user, inventoryMap.getContents());
+    }
+
+    /**
+     * Set the Ender Chest in the database of the given {@link User} to the given {@link ItemStack} contents
+     *
+     * @param user               the {@link User} to set the Ender Chest of
+     * @param enderChestContents the {@link ItemStack} contents to set the Ender Chest to
+     * @return future returning void when complete
+     * @since 2.0
+     */
+    public CompletableFuture<Void> setEnderChestData(@NotNull User user, @NotNull ItemStack[] enderChestContents) {
+        return CompletableFuture.runAsync(() -> getUserData(user).thenAccept(userData ->
+                userData.ifPresent(data -> serializeItemStackArray(enderChestContents)
+                        .thenAccept(serializedInventory -> {
+                            data.getEnderChest().orElse(ItemData.empty()).serializedItems = serializedInventory;
+                            setUserData(user, data).join();
+                        }))));
+    }
+
+    /**
+     * Returns a {@link BukkitInventoryMap} for the given {@link User}, containing their current inventory item data
+     *
+     * @param user the {@link User} to get the {@link BukkitInventoryMap} for
+     * @return future returning the {@link BukkitInventoryMap} for the given {@link User} if they exist,
+     * otherwise an empty {@link Optional}
+     * @apiNote If the {@link UserData} does not contain an inventory (i.e. inventory synchronisation is disabled), the
+     * returned {@link BukkitInventoryMap} will be equivalent an empty inventory.
+     * @since 2.0
+     */
+    public CompletableFuture<Optional<BukkitInventoryMap>> getPlayerInventory(@NotNull User user) {
+        return CompletableFuture.supplyAsync(() -> getUserData(user).join()
+                .map(userData -> deserializeInventory(userData.getInventory()
+                        .orElse(ItemData.empty()).serializedItems).join()));
+    }
+
+    /**
+     * Returns the {@link ItemStack}s array contents of the given {@link User}'s Ender Chest data
+     *
+     * @param user the {@link User} to get the Ender Chest contents of
+     * @return future returning the {@link ItemStack} array of Ender Chest items for the user if they exist,
+     * otherwise an empty {@link Optional}
+     * @apiNote If the {@link UserData} does not contain an Ender Chest (i.e. Ender Chest synchronisation is disabled),
+     * the returned {@link BukkitInventoryMap} will be equivalent to an empty inventory.
+     * @since 2.0
+     */
+    public CompletableFuture<Optional<ItemStack[]>> getPlayerEnderChest(@NotNull User user) {
+        return CompletableFuture.supplyAsync(() -> getUserData(user).join()
+                .map(userData -> deserializeItemStackArray(userData.getEnderChest()
+                        .orElse(ItemData.empty()).serializedItems).join()));
+    }
+
+    /**
+     * Deserialize a Base-64 encoded inventory array string into a {@link ItemStack} array.
+     *
+     * @param serializedItemStackArray The Base-64 encoded inventory array string.
+     * @return The deserialized {@link ItemStack} array.
+     * @throws DataSerializationException If an error occurs during deserialization.
+     * @since 2.0
+     */
+    public CompletableFuture<ItemStack[]> deserializeItemStackArray(@NotNull String serializedItemStackArray)
+            throws DataSerializationException {
+        return CompletableFuture.supplyAsync(() -> BukkitSerializer
+                .deserializeItemStackArray(serializedItemStackArray).join());
+    }
+
+    /**
+     * Deserialize a serialized {@link ItemStack} array of player inventory contents into a {@link BukkitInventoryMap}
+     *
+     * @param serializedInventory The serialized {@link ItemStack} array of player inventory contents.
+     * @return A {@link BukkitInventoryMap} of the deserialized {@link ItemStack} contents array
+     * @throws DataSerializationException If an error occurs during deserialization.
+     * @since 2.0
+     */
+    public CompletableFuture<BukkitInventoryMap> deserializeInventory(@NotNull String serializedInventory)
+            throws DataSerializationException {
+        return CompletableFuture.supplyAsync(() -> BukkitSerializer
+                .deserializeInventory(serializedInventory).join());
+    }
+
+    /**
+     * Serialize an {@link ItemStack} array into a Base-64 encoded string.
+     *
+     * @param itemStacks The {@link ItemStack} array to serialize.
+     * @return The serialized Base-64 encoded string.
+     * @throws DataSerializationException If an error occurs during serialization.
+     * @see #deserializeItemStackArray(String)
+     * @see ItemData
+     * @since 2.0
+     */
+    public CompletableFuture<String> serializeItemStackArray(@NotNull ItemStack[] itemStacks)
+            throws DataSerializationException {
+        return CompletableFuture.supplyAsync(() -> BukkitSerializer.serializeItemStackArray(itemStacks).join());
+    }
+
+    /**
+     * Deserialize a Base-64 encoded potion effect array string into a {@link PotionEffect} array.
+     *
+     * @param serializedPotionEffectArray The Base-64 encoded potion effect array string.
+     * @return The deserialized {@link PotionEffect} array.
+     * @throws DataSerializationException If an error occurs during deserialization.
+     * @since 2.0
+     */
+    public CompletableFuture<PotionEffect[]> deserializePotionEffectArray(@NotNull String serializedPotionEffectArray)
+            throws DataSerializationException {
+        return CompletableFuture.supplyAsync(() -> BukkitSerializer
+                .deserializePotionEffectArray(serializedPotionEffectArray).join());
+    }
+
+    /**
+     * Serialize a {@link PotionEffect} array into a Base-64 encoded string.
+     *
+     * @param potionEffects The {@link PotionEffect} array to serialize.
+     * @return The serialized Base-64 encoded string.
+     * @throws DataSerializationException If an error occurs during serialization.
+     * @see #deserializePotionEffectArray(String)
+     * @see PotionEffectData
+     * @since 2.0
+     */
+    public CompletableFuture<String> serializePotionEffectArray(@NotNull PotionEffect[] potionEffects)
+            throws DataSerializationException {
+        return CompletableFuture.supplyAsync(() -> BukkitSerializer.serializePotionEffectArray(potionEffects).join());
+    }
+
+}

bukkit/src/main/java/net/william278/husksync/bukkit/config/ConfigLoader.java

@@ -1,34 +0,0 @@
-package net.william278.husksync.bukkit.config;
-
-import net.william278.husksync.Settings;
-import org.bukkit.configuration.file.FileConfiguration;
-
-public class ConfigLoader {
-
-    public static void loadSettings(FileConfiguration config) throws IllegalArgumentException {
-        Settings.serverType = Settings.ServerType.BUKKIT;
-        Settings.automaticUpdateChecks = config.getBoolean("check_for_updates", true);
-        Settings.cluster = config.getString("cluster_id", "main");
-        Settings.redisHost = config.getString("redis_settings.host", "localhost");
-        Settings.redisPort = config.getInt("redis_settings.port", 6379);
-        Settings.redisPassword = config.getString("redis_settings.password", "");
-        Settings.redisSSL = config.getBoolean("redis_settings.use_ssl", false);
-
-        Settings.syncInventories = config.getBoolean("synchronisation_settings.inventories", true);
-        Settings.syncEnderChests = config.getBoolean("synchronisation_settings.ender_chests", true);
-        Settings.syncHealth = config.getBoolean("synchronisation_settings.health", true);
-        Settings.syncHunger = config.getBoolean("synchronisation_settings.hunger", true);
-        Settings.syncExperience = config.getBoolean("synchronisation_settings.experience", true);
-        Settings.syncPotionEffects = config.getBoolean("synchronisation_settings.potion_effects", true);
-        Settings.syncStatistics = config.getBoolean("synchronisation_settings.statistics", true);
-        Settings.syncGameMode = config.getBoolean("synchronisation_settings.game_mode", true);
-        Settings.syncAdvancements = config.getBoolean("synchronisation_settings.advancements", true);
-        Settings.syncLocation = config.getBoolean("synchronisation_settings.location", false);
-        Settings.syncFlight = config.getBoolean("synchronisation_settings.flight", false);
-
-        Settings.useNativeImplementation = config.getBoolean("native_advancement_synchronization", false);
-        Settings.saveOnWorldSave = config.getBoolean("save_on_world_save", true);
-        Settings.synchronizationTimeoutRetryDelay = config.getLong("synchronization_timeout_retry_delay", 15L);
-    }
-
-}

bukkit/src/main/java/net/william278/husksync/bukkit/data/BukkitDataCache.java

@@ -1,74 +0,0 @@
-package net.william278.husksync.bukkit.data;
-
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.UUID;
-
-public class BukkitDataCache {
-
-    /**
-     * Map of Player UUIDs to request on join
-     */
-    private static HashSet<UUID> requestOnJoin;
-
-    public boolean isPlayerRequestingOnJoin(UUID uuid) {
-        return requestOnJoin.contains(uuid);
-    }
-
-    public void setRequestOnJoin(UUID uuid) {
-        requestOnJoin.add(uuid);
-    }
-
-    public void removeRequestOnJoin(UUID uuid) {
-        requestOnJoin.remove(uuid);
-    }
-
-    /**
-     * Map of Player UUIDs whose data has not been set yet
-     */
-    private static HashSet<UUID> awaitingDataFetch;
-
-    public boolean isAwaitingDataFetch(UUID uuid) {
-        return awaitingDataFetch.contains(uuid);
-    }
-
-    public void setAwaitingDataFetch(UUID uuid) {
-        awaitingDataFetch.add(uuid);
-    }
-
-    public void removeAwaitingDataFetch(UUID uuid) {
-        awaitingDataFetch.remove(uuid);
-    }
-
-    public HashSet<UUID> getAwaitingDataFetch() {
-        return awaitingDataFetch;
-    }
-
-    /**
-     * Map of data being viewed by players
-     */
-    private static HashMap<UUID, DataViewer.DataView> viewingPlayerData;
-
-    public void setViewing(UUID uuid, DataViewer.DataView dataView) {
-        viewingPlayerData.put(uuid, dataView);
-    }
-
-    public void removeViewing(UUID uuid) {
-        viewingPlayerData.remove(uuid);
-    }
-
-    public boolean isViewing(UUID uuid) {
-        return viewingPlayerData.containsKey(uuid);
-    }
-
-    public DataViewer.DataView getViewing(UUID uuid) {
-        return viewingPlayerData.get(uuid);
-    }
-
-    // Cache object
-    public BukkitDataCache() {
-        requestOnJoin = new HashSet<>();
-        viewingPlayerData = new HashMap<>();
-        awaitingDataFetch = new HashSet<>();
-    }
-}

bukkit/src/main/java/net/william278/husksync/bukkit/data/DataSerializer.java

@@ -1,327 +0,0 @@
-package net.william278.husksync.bukkit.data;
-
-import net.william278.husksync.redis.RedisMessage;
-import org.bukkit.*;
-import org.bukkit.advancement.Advancement;
-import org.bukkit.advancement.AdvancementProgress;
-import org.bukkit.entity.EntityType;
-import org.bukkit.entity.Player;
-import org.bukkit.inventory.ItemStack;
-import org.bukkit.potion.PotionEffect;
-import org.bukkit.util.io.BukkitObjectInputStream;
-import org.bukkit.util.io.BukkitObjectOutputStream;
-import org.yaml.snakeyaml.external.biz.base64Coder.Base64Coder;
-
-import java.io.ByteArrayInputStream;
-import java.io.ByteArrayOutputStream;
-import java.io.IOException;
-import java.util.*;
-
-/**
- * Class that contains static methods for serializing and deserializing data from {@link net.william278.husksync.PlayerData}
- */
-public class DataSerializer {
-
-    /**
-     * Returns a serialized array of {@link ItemStack}s
-     *
-     * @param inventoryContents The contents of the inventory
-     * @return The serialized inventory contents
-     */
-    public static String serializeInventory(ItemStack[] inventoryContents) {
-        // Return an empty string if there is no inventory item data to serialize
-        if (inventoryContents.length == 0) {
-            return "";
-        }
-
-        // Create an output stream that will be encoded into base 64
-        ByteArrayOutputStream byteOutputStream = new ByteArrayOutputStream();
-
-        try (BukkitObjectOutputStream bukkitOutputStream = new BukkitObjectOutputStream(byteOutputStream)) {
-            // Define the length of the inventory array to serialize
-            bukkitOutputStream.writeInt(inventoryContents.length);
-
-            // Write each serialize each ItemStack to the output stream
-            for (ItemStack inventoryItem : inventoryContents) {
-                bukkitOutputStream.writeObject(serializeItemStack(inventoryItem));
-            }
-
-            // Return encoded data, using the encoder from SnakeYaml to get a ByteArray conversion
-            return Base64Coder.encodeLines(byteOutputStream.toByteArray());
-        } catch (IOException e) {
-            throw new IllegalArgumentException("Failed to serialize item stack data");
-        }
-    }
-
-    /**
-     * Returns an array of ItemStacks from serialized inventory data. Note: empty slots will be represented by {@code null}
-     *
-     * @param inventoryData The serialized {@link ItemStack[]} array
-     * @return The inventory contents as an array of {@link ItemStack}s
-     * @throws IOException            If the deserialization fails reading data from the InputStream
-     * @throws ClassNotFoundException If the deserialization class cannot be found
-     */
-    public static ItemStack[] deserializeInventory(String inventoryData) throws IOException, ClassNotFoundException {
-        // Return empty array if there is no inventory data (set the player as having an empty inventory)
-        if (inventoryData.isEmpty()) {
-            return new ItemStack[0];
-        }
-
-        // Create a byte input stream to read the serialized data
-        try (ByteArrayInputStream byteInputStream = new ByteArrayInputStream(Base64Coder.decodeLines(inventoryData))) {
-            try (BukkitObjectInputStream bukkitInputStream = new BukkitObjectInputStream(byteInputStream)) {
-                // Read the length of the Bukkit input stream and set the length of the array to this value
-                ItemStack[] inventoryContents = new ItemStack[bukkitInputStream.readInt()];
-
-                // Set the ItemStacks in the array from deserialized ItemStack data
-                int slotIndex = 0;
-                for (ItemStack ignored : inventoryContents) {
-                    inventoryContents[slotIndex] = deserializeItemStack(bukkitInputStream.readObject());
-                    slotIndex++;
-                }
-
-                // Return the finished, serialized inventory contents
-                return inventoryContents;
-            }
-        }
-    }
-
-    /**
-     * Returns the serialized version of an {@link ItemStack} as a string to object Map
-     *
-     * @param item The {@link ItemStack} to serialize
-     * @return The serialized {@link ItemStack}
-     */
-    private static Map<String, Object> serializeItemStack(ItemStack item) {
-        return item != null ? item.serialize() : null;
-    }
-
-    /**
-     * Returns the deserialized {@link ItemStack} from the Object read from the {@link BukkitObjectInputStream}
-     *
-     * @param serializedItemStack The serialized item stack; a String-Object map
-     * @return The deserialized {@link ItemStack}
-     */
-    @SuppressWarnings("unchecked") // Ignore the "Unchecked cast" warning
-    private static ItemStack deserializeItemStack(Object serializedItemStack) {
-        return serializedItemStack != null ? ItemStack.deserialize((Map<String, Object>) serializedItemStack) : null;
-    }
-
-    /**
-     * Returns a serialized array of {@link PotionEffect}s
-     *
-     * @param potionEffects The potion effect array
-     * @return The serialized potion effects
-     */
-    public static String serializePotionEffects(PotionEffect[] potionEffects) {
-        // Return an empty string if there are no effects to serialize
-        if (potionEffects.length == 0) {
-            return "";
-        }
-
-        // Create an output stream that will be encoded into base 64
-        ByteArrayOutputStream byteOutputStream = new ByteArrayOutputStream();
-
-        try (BukkitObjectOutputStream bukkitOutputStream = new BukkitObjectOutputStream(byteOutputStream)) {
-            // Define the length of the potion effect array to serialize
-            bukkitOutputStream.writeInt(potionEffects.length);
-
-            // Write each serialize each PotionEffect to the output stream
-            for (PotionEffect potionEffect : potionEffects) {
-                bukkitOutputStream.writeObject(serializePotionEffect(potionEffect));
-            }
-
-            // Return encoded data, using the encoder from SnakeYaml to get a ByteArray conversion
-            return Base64Coder.encodeLines(byteOutputStream.toByteArray());
-        } catch (IOException e) {
-            throw new IllegalArgumentException("Failed to serialize potion effect data");
-        }
-    }
-
-    /**
-     * Returns an array of ItemStacks from serialized potion effect data
-     *
-     * @param potionEffectData The serialized {@link PotionEffect[]} array
-     * @return The {@link PotionEffect}s
-     * @throws IOException            If the deserialization fails reading data from the InputStream
-     * @throws ClassNotFoundException If the deserialization class cannot be found
-     */
-    public static PotionEffect[] deserializePotionEffects(String potionEffectData) throws IOException, ClassNotFoundException {
-        // Return empty array if there is no potion effect data (don't apply any effects to the player)
-        if (potionEffectData.isEmpty()) {
-            return new PotionEffect[0];
-        }
-
-        // Create a byte input stream to read the serialized data
-        try (ByteArrayInputStream byteInputStream = new ByteArrayInputStream(Base64Coder.decodeLines(potionEffectData))) {
-            try (BukkitObjectInputStream bukkitInputStream = new BukkitObjectInputStream(byteInputStream)) {
-                // Read the length of the Bukkit input stream and set the length of the array to this value
-                PotionEffect[] potionEffects = new PotionEffect[bukkitInputStream.readInt()];
-
-                // Set the potion effects in the array from deserialized PotionEffect data
-                int potionIndex = 0;
-                for (PotionEffect ignored : potionEffects) {
-                    potionEffects[potionIndex] = deserializePotionEffect(bukkitInputStream.readObject());
-                    potionIndex++;
-                }
-
-                // Return the finished, serialized potion effect array
-                return potionEffects;
-            }
-        }
-    }
-
-    /**
-     * Returns the serialized version of an {@link ItemStack} as a string to object Map
-     *
-     * @param potionEffect The {@link ItemStack} to serialize
-     * @return The serialized {@link ItemStack}
-     */
-    private static Map<String, Object> serializePotionEffect(PotionEffect potionEffect) {
-        return potionEffect != null ? potionEffect.serialize() : null;
-    }
-
-    /**
-     * Returns the deserialized {@link PotionEffect} from the Object read from the {@link BukkitObjectInputStream}
-     *
-     * @param serializedPotionEffect The serialized potion effect; a String-Object map
-     * @return The deserialized {@link PotionEffect}
-     */
-    @SuppressWarnings("unchecked") // Ignore the "Unchecked cast" warning
-    private static PotionEffect deserializePotionEffect(Object serializedPotionEffect) {
-        return serializedPotionEffect != null ? new PotionEffect((Map<String, Object>) serializedPotionEffect) : null;
-    }
-
-    public static me.william278.husksync.bukkit.data.DataSerializer.PlayerLocation deserializePlayerLocationData(String serializedLocationData) throws IOException {
-        if (serializedLocationData.isEmpty()) {
-            return null;
-        }
-        try {
-            return (me.william278.husksync.bukkit.data.DataSerializer.PlayerLocation) RedisMessage.deserialize(serializedLocationData);
-        } catch (ClassNotFoundException e) {
-            throw new IOException("Unable to decode class type.", e);
-        }
-    }
-
-    public static String getSerializedLocation(Player player) throws IOException {
-        final Location playerLocation = player.getLocation();
-        return RedisMessage.serialize(new me.william278.husksync.bukkit.data.DataSerializer.PlayerLocation(playerLocation.getX(), playerLocation.getY(), playerLocation.getZ(),
-                playerLocation.getYaw(), playerLocation.getPitch(), player.getWorld().getName(), player.getWorld().getEnvironment()));
-    }
-
-    /**
-     * Deserializes a player's advancement data as serialized with {@link #getSerializedAdvancements(Player)} into {@link me.william278.husksync.bukkit.data.DataSerializer.AdvancementRecordDate} data.
-     *
-     * @param serializedAdvancementData The serialized advancement data {@link String}
-     * @return The deserialized {@link me.william278.husksync.bukkit.data.DataSerializer.AdvancementRecordDate} for the player
-     * @throws IOException If the deserialization fails
-     */
-    @SuppressWarnings("unchecked") // Ignore the unchecked cast here
-    public static List<me.william278.husksync.bukkit.data.DataSerializer.AdvancementRecordDate> deserializeAdvancementData(String serializedAdvancementData) throws IOException {
-        if (serializedAdvancementData.isEmpty()) {
-            return new ArrayList<>();
-        }
-        try {
-            List<?> deserialize = (List<?>) RedisMessage.deserialize(serializedAdvancementData);
-
-            // Migrate old AdvancementRecord into date format
-            if (!deserialize.isEmpty() && deserialize.get(0) instanceof me.william278.husksync.bukkit.data.DataSerializer.AdvancementRecord) {
-                deserialize = ((List<me.william278.husksync.bukkit.data.DataSerializer.AdvancementRecord>) deserialize).stream()
-                        .map(o -> new me.william278.husksync.bukkit.data.DataSerializer.AdvancementRecordDate(
-                                o.advancementKey(),
-                                o.awardedAdvancementCriteria()
-                        )).toList();
-            }
-
-            return (List<me.william278.husksync.bukkit.data.DataSerializer.AdvancementRecordDate>) deserialize;
-        } catch (ClassNotFoundException e) {
-            throw new IOException("Unable to decode class type.", e);
-        }
-    }
-
-    /**
-     * Returns a serialized {@link String} of a player's advancements that can be deserialized with {@link #deserializeStatisticData(String)}
-     *
-     * @param player {@link Player} to serialize advancement data of
-     * @return The serialized advancement data as a {@link String}
-     * @throws IOException If the serialization fails
-     */
-    public static String getSerializedAdvancements(Player player) throws IOException {
-        Iterator<Advancement> serverAdvancements = Bukkit.getServer().advancementIterator();
-        ArrayList<me.william278.husksync.bukkit.data.DataSerializer.AdvancementRecordDate> advancementData = new ArrayList<>();
-
-        while (serverAdvancements.hasNext()) {
-            final AdvancementProgress progress = player.getAdvancementProgress(serverAdvancements.next());
-            final NamespacedKey advancementKey = progress.getAdvancement().getKey();
-
-            final Map<String, Date> awardedCriteria = new HashMap<>();
-            progress.getAwardedCriteria().forEach(s -> awardedCriteria.put(s, progress.getDateAwarded(s)));
-
-            advancementData.add(new me.william278.husksync.bukkit.data.DataSerializer.AdvancementRecordDate(advancementKey.getNamespace() + ":" + advancementKey.getKey(), awardedCriteria));
-        }
-
-        return RedisMessage.serialize(advancementData);
-    }
-
-    /**
-     * Deserializes a player's statistic data as serialized with {@link #getSerializedStatisticData(Player)} into {@link me.william278.husksync.bukkit.data.DataSerializer.StatisticData}.
-     *
-     * @param serializedStatisticData The serialized statistic data {@link String}
-     * @return The deserialized {@link me.william278.husksync.bukkit.data.DataSerializer.StatisticData} for the player
-     * @throws IOException If the deserialization fails
-     */
-    public static me.william278.husksync.bukkit.data.DataSerializer.StatisticData deserializeStatisticData(String serializedStatisticData) throws IOException {
-        if (serializedStatisticData.isEmpty()) {
-            return new me.william278.husksync.bukkit.data.DataSerializer.StatisticData(new HashMap<>(), new HashMap<>(), new HashMap<>(), new HashMap<>());
-        }
-        try {
-            return (me.william278.husksync.bukkit.data.DataSerializer.StatisticData) RedisMessage.deserialize(serializedStatisticData);
-        } catch (ClassNotFoundException e) {
-            throw new IOException("Unable to decode class type.", e);
-        }
-    }
-
-    /**
-     * Returns a serialized {@link String} of a player's statistic data that can be deserialized with {@link #deserializeStatisticData(String)}
-     *
-     * @param player {@link Player} to serialize statistic data of
-     * @return The serialized statistic data as a {@link String}
-     * @throws IOException If the serialization fails
-     */
-    public static String getSerializedStatisticData(Player player) throws IOException {
-        HashMap<Statistic, Integer> untypedStatisticValues = new HashMap<>();
-        HashMap<Statistic, HashMap<Material, Integer>> blockStatisticValues = new HashMap<>();
-        HashMap<Statistic, HashMap<Material, Integer>> itemStatisticValues = new HashMap<>();
-        HashMap<Statistic, HashMap<EntityType, Integer>> entityStatisticValues = new HashMap<>();
-        for (Statistic statistic : Statistic.values()) {
-            switch (statistic.getType()) {
-                case ITEM -> {
-                    HashMap<Material, Integer> itemValues = new HashMap<>();
-                    for (Material itemMaterial : Arrays.stream(Material.values()).filter(Material::isItem).toList()) {
-                        itemValues.put(itemMaterial, player.getStatistic(statistic, itemMaterial));
-                    }
-                    itemStatisticValues.put(statistic, itemValues);
-                }
-                case BLOCK -> {
-                    HashMap<Material, Integer> blockValues = new HashMap<>();
-                    for (Material blockMaterial : Arrays.stream(Material.values()).filter(Material::isBlock).toList()) {
-                        blockValues.put(blockMaterial, player.getStatistic(statistic, blockMaterial));
-                    }
-                    blockStatisticValues.put(statistic, blockValues);
-                }
-                case ENTITY -> {
-                    HashMap<EntityType, Integer> entityValues = new HashMap<>();
-                    for (EntityType type : Arrays.stream(EntityType.values()).filter(EntityType::isAlive).toList()) {
-                        entityValues.put(type, player.getStatistic(statistic, type));
-                    }
-                    entityStatisticValues.put(statistic, entityValues);
-                }
-                case UNTYPED -> untypedStatisticValues.put(statistic, player.getStatistic(statistic));
-            }
-        }
-
-        me.william278.husksync.bukkit.data.DataSerializer.StatisticData statisticData = new me.william278.husksync.bukkit.data.DataSerializer.StatisticData(untypedStatisticValues, blockStatisticValues, itemStatisticValues, entityStatisticValues);
-        return RedisMessage.serialize(statisticData);
-    }
-
-}

bukkit/src/main/java/net/william278/husksync/bukkit/data/DataViewer.java

@@ -1,115 +0,0 @@
-package net.william278.husksync.bukkit.data;
-
-import net.william278.husksync.HuskSyncBukkit;
-import net.william278.husksync.PlayerData;
-import net.william278.husksync.Settings;
-import net.william278.husksync.bukkit.util.PlayerSetter;
-import net.william278.husksync.redis.RedisMessage;
-import org.bukkit.Bukkit;
-import org.bukkit.entity.Player;
-import org.bukkit.inventory.Inventory;
-import org.bukkit.inventory.ItemStack;
-
-import java.io.IOException;
-
-/**
- * Class used for managing viewing inventories using inventory-see command
- */
-public class DataViewer {
-
-    /**
-     * Show a viewer's data to a viewer
-     *
-     * @param viewer The viewing {@link Player} who will see the data
-     * @param data   The {@link DataView} to show the viewer
-     * @throws IOException If an exception occurred deserializing item data
-     */
-    public static void showData(Player viewer, DataView data) throws IOException, ClassNotFoundException {
-        // Show an inventory with the viewer's inventory and equipment
-        viewer.closeInventory();
-        viewer.openInventory(createInventory(viewer, data));
-
-        // Set the viewer as viewing
-        HuskSyncBukkit.bukkitCache.setViewing(viewer.getUniqueId(), data);
-    }
-
-    /**
-     * Handles what happens after a data viewer finishes viewing data
-     *
-     * @param viewer    The viewing {@link Player} who was looking at data
-     * @param inventory The {@link Inventory} that was being viewed
-     * @throws IOException If an exception occurred serializing item data
-     */
-    public static void stopShowing(Player viewer, Inventory inventory) throws IOException {
-        // Get the DataView the player was looking at
-        DataView dataView = HuskSyncBukkit.bukkitCache.getViewing(viewer.getUniqueId());
-
-        // Set the player as no longer viewing an inventory
-        HuskSyncBukkit.bukkitCache.removeViewing(viewer.getUniqueId());
-
-        // Get and update the PlayerData with the new item data
-        PlayerData playerData = dataView.playerData();
-        String serializedItemData = DataSerializer.serializeInventory(inventory.getContents());
-        switch (dataView.inventoryType()) {
-            case INVENTORY -> playerData.setSerializedInventory(serializedItemData);
-            case ENDER_CHEST -> playerData.setSerializedEnderChest(serializedItemData);
-        }
-
-        // Send a redis message with the updated data after the viewing
-        new RedisMessage(RedisMessage.MessageType.PLAYER_DATA_UPDATE,
-                new RedisMessage.MessageTarget(Settings.ServerType.PROXY, null, Settings.cluster),
-                RedisMessage.serialize(playerData), Boolean.toString(true))
-                .send();
-    }
-
-    /**
-     * Creates the inventory object that the viewer will see
-     *
-     * @param viewer The {@link Player} who will view the data
-     * @param data   The {@link DataView} data to view
-     * @return The {@link Inventory} that the viewer will see
-     * @throws IOException If an exception occurred deserializing item data
-     */
-    private static Inventory createInventory(Player viewer, DataView data) throws IOException, ClassNotFoundException {
-        Inventory inventory = switch (data.inventoryType) {
-            case INVENTORY -> Bukkit.createInventory(viewer, 45, data.ownerName + "'s Inventory");
-            case ENDER_CHEST -> Bukkit.createInventory(viewer, 27, data.ownerName + "'s Ender Chest");
-        };
-        PlayerSetter.setInventory(inventory, data.getDeserializedData());
-        return inventory;
-    }
-
-    /**
-     * Represents Player Data being viewed by a {@link Player}
-     */
-    public record DataView(PlayerData playerData, String ownerName, InventoryType inventoryType) {
-        /**
-         * What kind of item data is being viewed
-         */
-        public enum InventoryType {
-            /**
-             * A player's inventory
-             */
-            INVENTORY,
-
-            /**
-             * A player's ender chest
-             */
-            ENDER_CHEST
-        }
-
-        /**
-         * Gets the deserialized data currently being viewed
-         *
-         * @return The deserialized item data, as an {@link ItemStack[]} array
-         * @throws IOException If an exception occurred deserializing item data
-         */
-        public ItemStack[] getDeserializedData() throws IOException, ClassNotFoundException {
-            return switch (inventoryType) {
-                case INVENTORY -> DataSerializer.deserializeInventory(playerData.getSerializedInventory());
-                case ENDER_CHEST -> DataSerializer.deserializeInventory(playerData.getSerializedEnderChest());
-            };
-        }
-    }
-
-}

bukkit/src/main/java/net/william278/husksync/bukkit/events/SyncCompleteEvent.java

@@ -1,38 +0,0 @@
-package net.william278.husksync.bukkit.events;
-
-import net.william278.husksync.PlayerData;
-import org.bukkit.entity.Player;
-import org.bukkit.event.HandlerList;
-import org.bukkit.event.player.PlayerEvent;
-import org.jetbrains.annotations.NotNull;
-
-/**
- * Represents an event that will be fired when a {@link Player} has finished being synchronised with the correct {@link PlayerData}.
- */
-public class SyncCompleteEvent extends PlayerEvent {
-
-    private static final HandlerList HANDLER_LIST = new HandlerList();
-    private final PlayerData data;
-
-    public SyncCompleteEvent(Player player, PlayerData data) {
-        super(player);
-        this.data = data;
-    }
-
-    /**
-     * Returns the {@link PlayerData} which has just been set on the {@link Player}
-     * @return The {@link PlayerData} that has been set
-     */
-    public PlayerData getData() {
-        return data;
-    }
-
-    @Override
-    public @NotNull HandlerList getHandlers() {
-        return HANDLER_LIST;
-    }
-
-    public static HandlerList getHandlerList() {
-        return HANDLER_LIST;
-    }
-}

bukkit/src/main/java/net/william278/husksync/bukkit/events/SyncEvent.java

@@ -1,70 +0,0 @@
-package net.william278.husksync.bukkit.events;
-
-import net.william278.husksync.PlayerData;
-import org.bukkit.entity.Player;
-import org.bukkit.event.Cancellable;
-import org.bukkit.event.HandlerList;
-import org.bukkit.event.player.PlayerEvent;
-import org.jetbrains.annotations.NotNull;
-
-/**
- * Represents an event that will be fired before a {@link Player} is about to be synchronised with their {@link PlayerData}.
- */
-public class SyncEvent extends PlayerEvent implements Cancellable {
-
-    private boolean cancelled;
-    private static final HandlerList HANDLER_LIST = new HandlerList();
-    private PlayerData data;
-
-    public SyncEvent(Player player, PlayerData data) {
-        super(player);
-        this.data = data;
-    }
-
-    /**
-     * Returns the {@link PlayerData} which has just been set on the {@link Player}
-     *
-     * @return The {@link PlayerData} that has been set
-     */
-    public PlayerData getData() {
-        return data;
-    }
-
-    /**
-     * Sets the {@link PlayerData} to be synchronised to this player
-     *
-     * @param data The {@link PlayerData} to set to the player
-     */
-    public void setData(PlayerData data) {
-        this.data = data;
-    }
-
-    @Override
-    public @NotNull HandlerList getHandlers() {
-        return HANDLER_LIST;
-    }
-
-    public static HandlerList getHandlerList() {
-        return HANDLER_LIST;
-    }
-
-    /**
-     * Gets the cancellation state of this event. A cancelled event will not be executed in the server, but will still pass to other plugins
-     *
-     * @return true if this event is cancelled
-     */
-    @Override
-    public boolean isCancelled() {
-        return cancelled;
-    }
-
-    /**
-     * Sets the cancellation state of this event. A cancelled event will not be executed in the server, but will still pass to other plugins.
-     *
-     * @param cancel true if you wish to cancel this event
-     */
-    @Override
-    public void setCancelled(boolean cancel) {
-        this.cancelled = cancel;
-    }
-}

bukkit/src/main/java/net/william278/husksync/bukkit/listener/BukkitEventListener.java

@@ -1,166 +0,0 @@
-package net.william278.husksync.bukkit.listener;
-
-import net.william278.husksync.HuskSyncBukkit;
-import net.william278.husksync.Settings;
-import net.william278.husksync.bukkit.data.DataViewer;
-import net.william278.husksync.bukkit.util.PlayerSetter;
-import org.bukkit.Bukkit;
-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.BlockBreakEvent;
-import org.bukkit.event.block.BlockPlaceEvent;
-import org.bukkit.event.entity.EntityPickupItemEvent;
-import org.bukkit.event.inventory.InventoryCloseEvent;
-import org.bukkit.event.inventory.InventoryOpenEvent;
-import org.bukkit.event.player.*;
-import org.bukkit.event.world.WorldSaveEvent;
-
-import java.io.IOException;
-import java.util.logging.Level;
-
-public class BukkitEventListener implements Listener {
-
-    private static final HuskSyncBukkit plugin = HuskSyncBukkit.getInstance();
-
-    @EventHandler(priority = EventPriority.LOWEST)
-    public void onPlayerQuit(PlayerQuitEvent event) {
-        // When a player leaves a Bukkit server
-        final Player player = event.getPlayer();
-
-        // If the player was awaiting data fetch, remove them and prevent data from being overwritten
-        if (HuskSyncBukkit.bukkitCache.isAwaitingDataFetch(player.getUniqueId())) {
-            HuskSyncBukkit.bukkitCache.removeAwaitingDataFetch(player.getUniqueId());
-            return;
-        }
-
-        if (!plugin.isEnabled() || !HuskSyncBukkit.handshakeCompleted || HuskSyncBukkit.isMySqlPlayerDataBridgeInstalled)
-            return; // If the plugin has not been initialized correctly
-
-        // Update the player's data
-        Bukkit.getScheduler().runTaskAsynchronously(plugin, () -> {
-            // Update data to proxy
-            PlayerSetter.updatePlayerData(player, true);
-
-            // Clear player inventory and ender chest
-            player.getInventory().clear();
-            player.getEnderChest().clear();
-        });
-    }
-
-    @EventHandler(priority = EventPriority.LOWEST)
-    public void onPlayerJoin(PlayerJoinEvent event) {
-        if (!plugin.isEnabled()) return; // If the plugin has not been initialized correctly
-
-        // When a player joins a Bukkit server
-        final Player player = event.getPlayer();
-
-        // Mark the player as awaiting data fetch
-        HuskSyncBukkit.bukkitCache.setAwaitingDataFetch(player.getUniqueId());
-
-        if (!HuskSyncBukkit.handshakeCompleted || HuskSyncBukkit.isMySqlPlayerDataBridgeInstalled) {
-            return; // If the data handshake has not been completed yet (or MySqlPlayerDataBridge is installed)
-        }
-
-        // Send a redis message requesting the player data (if they need to)
-        if (HuskSyncBukkit.bukkitCache.isPlayerRequestingOnJoin(player.getUniqueId())) {
-            Bukkit.getScheduler().runTaskAsynchronously(plugin, () -> {
-                try {
-                    PlayerSetter.requestPlayerData(player.getUniqueId());
-                } catch (IOException e) {
-                    plugin.getLogger().log(Level.SEVERE, "Failed to send a PlayerData fetch request", e);
-                }
-            });
-        } else {
-            // If the player's data wasn't set after the synchronization timeout retry delay ticks, ensure it will be
-            Bukkit.getScheduler().runTaskLaterAsynchronously(plugin, () -> {
-                if (player.isOnline()) {
-                    try {
-                        if (HuskSyncBukkit.bukkitCache.isAwaitingDataFetch(player.getUniqueId())) {
-                            PlayerSetter.requestPlayerData(player.getUniqueId());
-                        }
-                    } catch (IOException e) {
-                        plugin.getLogger().log(Level.SEVERE, "Failed to send a PlayerData fetch request", e);
-                    }
-                }
-            }, Settings.synchronizationTimeoutRetryDelay);
-        }
-    }
-
-    @EventHandler
-    public void onInventoryClose(InventoryCloseEvent event) {
-        if (!plugin.isEnabled() || !HuskSyncBukkit.handshakeCompleted || HuskSyncBukkit.bukkitCache.isAwaitingDataFetch(event.getPlayer().getUniqueId()))
-            return; // If the plugin has not been initialized correctly
-
-        // When a player closes an Inventory
-        final Player player = (Player) event.getPlayer();
-
-        // Handle a player who has finished viewing a player's item data
-        if (HuskSyncBukkit.bukkitCache.isViewing(player.getUniqueId())) {
-            try {
-                DataViewer.stopShowing(player, event.getInventory());
-            } catch (IOException e) {
-                plugin.getLogger().log(Level.SEVERE, "Failed to serialize updated item data", e);
-            }
-        }
-    }
-
-    /*
-     * Events to cancel if the player has not been set yet
-     */
-
-    @EventHandler(priority = EventPriority.HIGHEST)
-    public void onDropItem(PlayerDropItemEvent event) {
-        if (!plugin.isEnabled() || !HuskSyncBukkit.handshakeCompleted || HuskSyncBukkit.bukkitCache.isAwaitingDataFetch(event.getPlayer().getUniqueId())) {
-            event.setCancelled(true); // If the plugin / player has not been set
-        }
-    }
-
-    @EventHandler(priority = EventPriority.HIGHEST)
-    public void onPickupItem(EntityPickupItemEvent event) {
-        if (event.getEntity() instanceof Player player) {
-            if (!plugin.isEnabled() || !HuskSyncBukkit.handshakeCompleted || HuskSyncBukkit.bukkitCache.isAwaitingDataFetch(player.getUniqueId())) {
-                event.setCancelled(true); // If the plugin / player has not been set
-            }
-        }
-    }
-
-    @EventHandler(priority = EventPriority.HIGHEST)
-    public void onPlayerInteract(PlayerInteractEvent event) {
-        if (!plugin.isEnabled() || !HuskSyncBukkit.handshakeCompleted || HuskSyncBukkit.bukkitCache.isAwaitingDataFetch(event.getPlayer().getUniqueId())) {
-            event.setCancelled(true); // If the plugin / player has not been set
-        }
-    }
-
-    @EventHandler(priority = EventPriority.HIGHEST)
-    public void onBlockPlace(BlockPlaceEvent event) {
-        if (!plugin.isEnabled() || !HuskSyncBukkit.handshakeCompleted || HuskSyncBukkit.bukkitCache.isAwaitingDataFetch(event.getPlayer().getUniqueId())) {
-            event.setCancelled(true); // If the plugin / player has not been set
-        }
-    }
-
-    @EventHandler(priority = EventPriority.HIGHEST)
-    public void onBlockBreak(BlockBreakEvent event) {
-        if (!plugin.isEnabled() || !HuskSyncBukkit.handshakeCompleted || HuskSyncBukkit.bukkitCache.isAwaitingDataFetch(event.getPlayer().getUniqueId())) {
-            event.setCancelled(true); // If the plugin / player has not been set
-        }
-    }
-
-    @EventHandler(priority = EventPriority.HIGHEST)
-    public void onInventoryOpen(InventoryOpenEvent event) {
-        if (!plugin.isEnabled() || !HuskSyncBukkit.handshakeCompleted || HuskSyncBukkit.bukkitCache.isAwaitingDataFetch(event.getPlayer().getUniqueId())) {
-            event.setCancelled(true); // If the plugin / player has not been set
-        }
-    }
-
-    @EventHandler(priority = EventPriority.NORMAL)
-    public void onWorldSave(WorldSaveEvent event) {
-        if (!plugin.isEnabled() || !HuskSyncBukkit.handshakeCompleted) {
-            return;
-        }
-        for (Player playerInWorld : event.getWorld().getPlayers()) {
-            PlayerSetter.updatePlayerData(playerInWorld, false);
-        }
-    }
-}

bukkit/src/main/java/net/william278/husksync/bukkit/listener/BukkitRedisListener.java

@@ -1,221 +0,0 @@
-package net.william278.husksync.bukkit.listener;
-
-import de.themoep.minedown.MineDown;
-import net.william278.husksync.HuskSyncBukkit;
-import net.william278.husksync.PlayerData;
-import net.william278.husksync.Settings;
-import net.william278.husksync.bukkit.config.ConfigLoader;
-import net.william278.husksync.bukkit.data.DataViewer;
-import net.william278.husksync.bukkit.migrator.MPDBDeserializer;
-import net.william278.husksync.bukkit.util.PlayerSetter;
-import net.william278.husksync.migrator.MPDBPlayerData;
-import net.william278.husksync.redis.RedisListener;
-import net.william278.husksync.redis.RedisMessage;
-import net.william278.husksync.util.MessageManager;
-import org.bukkit.Bukkit;
-import org.bukkit.entity.Player;
-
-import java.io.IOException;
-import java.util.HashMap;
-import java.util.UUID;
-import java.util.concurrent.CompletableFuture;
-import java.util.logging.Level;
-
-public class BukkitRedisListener extends RedisListener {
-
-    private static final HuskSyncBukkit plugin = HuskSyncBukkit.getInstance();
-
-    public static HashMap<UUID, CompletableFuture<PlayerData>> apiRequests = new HashMap<>();
-
-    // Initialize the listener on the bukkit server
-    public BukkitRedisListener() {
-        super();
-        listen();
-    }
-
-    /**
-     * Handle an incoming {@link RedisMessage}
-     *
-     * @param message The {@link RedisMessage} to handle
-     */
-    @Override
-    public void handleMessage(RedisMessage message) {
-        // Ignore messages for proxy servers
-        if (!message.getMessageTarget().targetServerType().equals(Settings.ServerType.BUKKIT)) {
-            return;
-        }
-        // Ignore messages if the plugin is disabled
-        if (!plugin.isEnabled()) {
-            return;
-        }
-        // Ignore messages for other clusters if applicable
-        final String targetClusterId = message.getMessageTarget().targetClusterId();
-        if (targetClusterId != null) {
-            if (!targetClusterId.equalsIgnoreCase(Settings.cluster)) {
-                return;
-            }
-        }
-
-        // Handle the incoming redis message; either for a specific player or the system
-        if (message.getMessageTarget().targetPlayerUUID() == null) {
-            switch (message.getMessageType()) {
-                case REQUEST_DATA_ON_JOIN -> {
-                    UUID playerUUID = UUID.fromString(message.getMessageDataElements()[1]);
-                    switch (RedisMessage.RequestOnJoinUpdateType.valueOf(message.getMessageDataElements()[0])) {
-                        case ADD_REQUESTER -> HuskSyncBukkit.bukkitCache.setRequestOnJoin(playerUUID);
-                        case REMOVE_REQUESTER -> HuskSyncBukkit.bukkitCache.removeRequestOnJoin(playerUUID);
-                    }
-                }
-                case CONNECTION_HANDSHAKE -> {
-                    UUID serverUUID = UUID.fromString(message.getMessageDataElements()[0]);
-                    String proxyBrand = message.getMessageDataElements()[1];
-                    if (serverUUID.equals(HuskSyncBukkit.serverUUID)) {
-                        HuskSyncBukkit.handshakeCompleted = true;
-                        log(Level.INFO, "Completed handshake with " + proxyBrand + " proxy (" + serverUUID + ")");
-
-                        // If there are any players awaiting a data update, request it
-                        for (UUID uuid : HuskSyncBukkit.bukkitCache.getAwaitingDataFetch()) {
-                            try {
-                                PlayerSetter.requestPlayerData(uuid);
-                            } catch (IOException e) {
-                                log(Level.SEVERE, "Failed to serialize handshake message data");
-                            }
-                        }
-                    }
-                }
-                case TERMINATE_HANDSHAKE -> {
-                    UUID serverUUID = UUID.fromString(message.getMessageDataElements()[0]);
-                    String proxyBrand = message.getMessageDataElements()[1];
-                    if (serverUUID.equals(HuskSyncBukkit.serverUUID)) {
-                        HuskSyncBukkit.handshakeCompleted = false;
-                        log(Level.WARNING, proxyBrand + " proxy has terminated communications; attempting to re-establish (" + serverUUID + ")");
-
-                        // Attempt to re-establish communications via another handshake
-                        Bukkit.getScheduler().runTaskLaterAsynchronously(plugin, HuskSyncBukkit::establishRedisHandshake, 20);
-                    }
-                }
-                case DECODE_MPDB_DATA -> {
-                    UUID serverUUID = UUID.fromString(message.getMessageDataElements()[0]);
-                    String encodedData = message.getMessageDataElements()[1];
-                    Bukkit.getScheduler().runTaskAsynchronously(plugin, () -> {
-                        if (serverUUID.equals(HuskSyncBukkit.serverUUID)) {
-                            try {
-                                MPDBPlayerData data = (MPDBPlayerData) RedisMessage.deserialize(encodedData);
-                                new RedisMessage(RedisMessage.MessageType.DECODED_MPDB_DATA_SET,
-                                        new RedisMessage.MessageTarget(Settings.ServerType.PROXY, null, Settings.cluster),
-                                        RedisMessage.serialize(MPDBDeserializer.convertMPDBData(data)),
-                                        data.playerName)
-                                        .send();
-                            } catch (IOException | ClassNotFoundException e) {
-                                log(Level.SEVERE, "Failed to serialize encoded MPDB data");
-                            }
-                        }
-                    });
-                }
-                case API_DATA_RETURN -> {
-                    final UUID requestUUID = UUID.fromString(message.getMessageDataElements()[0]);
-                    if (apiRequests.containsKey(requestUUID)) {
-                        try {
-                            final PlayerData data = (PlayerData) RedisMessage.deserialize(message.getMessageDataElements()[1]);
-                            apiRequests.get(requestUUID).complete(data);
-                        } catch (IOException | ClassNotFoundException e) {
-                            log(Level.SEVERE, "Failed to serialize returned API-requested player data");
-                        }
-                    }
-
-                }
-                case API_DATA_CANCEL -> {
-                    final UUID requestUUID = UUID.fromString(message.getMessageDataElements()[0]);
-                    // Cancel requests if no data could be found on the proxy
-                    if (apiRequests.containsKey(requestUUID)) {
-                        apiRequests.get(requestUUID).cancel(true);
-                    }
-                }
-                case RELOAD_CONFIG -> {
-                    plugin.reloadConfig();
-                    ConfigLoader.loadSettings(plugin.getConfig());
-                }
-            }
-        } else {
-            for (Player player : Bukkit.getOnlinePlayers()) {
-                if (player.getUniqueId().equals(message.getMessageTarget().targetPlayerUUID())) {
-                    switch (message.getMessageType()) {
-                        case PLAYER_DATA_SET -> {
-                            if (HuskSyncBukkit.isMySqlPlayerDataBridgeInstalled) return;
-                            try {
-                                // Deserialize the received PlayerData
-                                PlayerData data = (PlayerData) RedisMessage.deserialize(message.getMessageData());
-
-                                // Set the player's data
-                                PlayerSetter.setPlayerFrom(player, data);
-                            } catch (IOException | ClassNotFoundException e) {
-                                log(Level.SEVERE, "Failed to deserialize PlayerData when handling data from the proxy");
-                                e.printStackTrace();
-                            }
-                        }
-                        case SEND_PLUGIN_INFORMATION -> {
-                            String proxyBrand = message.getMessageDataElements()[0];
-                            String proxyVersion = message.getMessageDataElements()[1];
-                            assert plugin.getDescription().getDescription() != null;
-                            player.spigot().sendMessage(new MineDown(MessageManager.PLUGIN_INFORMATION.toString()
-                                    .replaceAll("%plugin_description%", plugin.getDescription().getDescription())
-                                    .replaceAll("%proxy_brand%", proxyBrand)
-                                    .replaceAll("%proxy_version%", proxyVersion)
-                                    .replaceAll("%bukkit_brand%", Bukkit.getName())
-                                    .replaceAll("%bukkit_version%", plugin.getDescription().getVersion()))
-                                    .toComponent());
-                        }
-                        case OPEN_INVENTORY -> {
-                            // Get the name of the inventory owner
-                            String inventoryOwnerName = message.getMessageDataElements()[0];
-
-                            // Synchronously do inventory setting, etc
-                            Bukkit.getScheduler().runTask(plugin, () -> {
-                                try {
-                                    // Get that player's data
-                                    PlayerData data = (PlayerData) RedisMessage.deserialize(message.getMessageDataElements()[1]);
-
-                                    // Show the data to the player
-                                    DataViewer.showData(player, new DataViewer.DataView(data, inventoryOwnerName, DataViewer.DataView.InventoryType.INVENTORY));
-                                } catch (IOException | ClassNotFoundException e) {
-                                    log(Level.SEVERE, "Failed to deserialize PlayerData when handling inventory-see data from the proxy");
-                                    e.printStackTrace();
-                                }
-                            });
-                        }
-                        case OPEN_ENDER_CHEST -> {
-                            // Get the name of the inventory owner
-                            String enderChestOwnerName = message.getMessageDataElements()[0];
-
-                            // Synchronously do inventory setting, etc
-                            Bukkit.getScheduler().runTask(plugin, () -> {
-                                try {
-                                    // Get that player's data
-                                    PlayerData data = (PlayerData) RedisMessage.deserialize(message.getMessageDataElements()[1]);
-
-                                    // Show the data to the player
-                                    DataViewer.showData(player, new DataViewer.DataView(data, enderChestOwnerName, DataViewer.DataView.InventoryType.ENDER_CHEST));
-                                } catch (IOException | ClassNotFoundException e) {
-                                    log(Level.SEVERE, "Failed to deserialize PlayerData when handling ender chest-see data from the proxy");
-                                    e.printStackTrace();
-                                }
-                            });
-                        }
-                    }
-                    return;
-                }
-            }
-        }
-    }
-
-    /**
-     * Log to console
-     *
-     * @param level   The {@link Level} to log
-     * @param message Message to log
-     */
-    @Override
-    public void log(Level level, String message) {
-        plugin.getLogger().log(level, message);
-    }
-}

bukkit/src/main/java/net/william278/husksync/bukkit/migrator/MPDBDeserializer.java

@@ -1,87 +0,0 @@
-package net.william278.husksync.bukkit.migrator;
-
-import net.william278.husksync.HuskSyncBukkit;
-import net.william278.husksync.PlayerData;
-import net.william278.husksync.bukkit.data.DataSerializer;
-import net.william278.husksync.bukkit.util.PlayerSetter;
-import net.william278.husksync.migrator.MPDBPlayerData;
-import net.william278.mpdbconverter.MPDBConverter;
-import org.bukkit.Bukkit;
-import org.bukkit.event.inventory.InventoryType;
-import org.bukkit.inventory.Inventory;
-import org.bukkit.inventory.ItemStack;
-import org.bukkit.plugin.Plugin;
-
-import java.util.logging.Level;
-
-public class MPDBDeserializer {
-
-    private static final HuskSyncBukkit plugin = HuskSyncBukkit.getInstance();
-
-    // Instance of MySqlPlayerDataBridge
-    private static MPDBConverter mpdbConverter;
-
-    public static void setMySqlPlayerDataBridge() {
-        Plugin mpdbPlugin = Bukkit.getPluginManager().getPlugin("MySqlPlayerDataBridge");
-        assert mpdbPlugin != null;
-        mpdbConverter = MPDBConverter.getInstance(mpdbPlugin);
-    }
-
-    /**
-     * Convert MySqlPlayerDataBridge ({@link MPDBPlayerData}) data to HuskSync's {@link PlayerData}
-     *
-     * @param mpdbPlayerData The {@link MPDBPlayerData} to convert
-     * @return The converted {@link PlayerData}
-     */
-    public static PlayerData convertMPDBData(MPDBPlayerData mpdbPlayerData) {
-        PlayerData playerData = PlayerData.DEFAULT_PLAYER_DATA(mpdbPlayerData.playerUUID);
-        playerData.useDefaultData = false;
-        if (!HuskSyncBukkit.isMySqlPlayerDataBridgeInstalled) {
-            plugin.getLogger().log(Level.SEVERE, "MySqlPlayerDataBridge is not installed, failed to serialize data!");
-            return null;
-        }
-
-        // Convert the data
-        try {
-            // Set inventory contents
-            Inventory inventory = Bukkit.createInventory(null, InventoryType.PLAYER);
-            if (!mpdbPlayerData.inventoryData.isEmpty() && !mpdbPlayerData.inventoryData.equalsIgnoreCase("none")) {
-                PlayerSetter.setInventory(inventory, mpdbConverter.getItemStackFromSerializedData(mpdbPlayerData.inventoryData));
-            }
-
-            // Set armor (if there is data; MPDB stores empty data with literally the word "none". Obviously.)
-            int armorSlot = 36;
-            if (!mpdbPlayerData.armorData.isEmpty() && !mpdbPlayerData.armorData.equalsIgnoreCase("none")) {
-                ItemStack[] armorItems = mpdbConverter.getItemStackFromSerializedData(mpdbPlayerData.armorData);
-                for (ItemStack armorPiece : armorItems) {
-                    if (armorPiece != null) {
-                        inventory.setItem(armorSlot, armorPiece);
-                    }
-                    armorSlot++;
-                }
-
-            }
-
-            // Now apply the contents and clear the temporary inventory variable
-            playerData.setSerializedInventory(DataSerializer.serializeInventory(inventory.getContents()));
-
-            // Set ender chest (again, if there is data)
-            ItemStack[] enderChestData;
-            if (!mpdbPlayerData.enderChestData.isEmpty() && !mpdbPlayerData.enderChestData.equalsIgnoreCase("none")) {
-                enderChestData = mpdbConverter.getItemStackFromSerializedData(mpdbPlayerData.enderChestData);
-            } else {
-                enderChestData = new ItemStack[0];
-            }
-            playerData.setSerializedEnderChest(DataSerializer.serializeInventory(enderChestData));
-
-            // Set experience
-            playerData.setExpLevel(mpdbPlayerData.expLevel);
-            playerData.setExpProgress(mpdbPlayerData.expProgress);
-            playerData.setTotalExperience(mpdbPlayerData.totalExperience);
-        } catch (Exception e) {
-            plugin.getLogger().log(Level.WARNING, "Failed to convert MPDB data to HuskSync's format!");
-            e.printStackTrace();
-        }
-        return playerData;
-    }
-}

bukkit/src/main/java/net/william278/husksync/bukkit/util/BukkitUpdateChecker.java

@@ -1,20 +0,0 @@
-package net.william278.husksync.bukkit.util;
-
-import net.william278.husksync.HuskSyncBukkit;
-import net.william278.husksync.util.UpdateChecker;
-
-import java.util.logging.Level;
-
-public class BukkitUpdateChecker extends UpdateChecker {
-
-    private static final HuskSyncBukkit plugin = HuskSyncBukkit.getInstance();
-
-    public BukkitUpdateChecker() {
-        super(plugin.getDescription().getVersion());
-    }
-
-    @Override
-    public void log(Level level, String message) {
-        plugin.getLogger().log(level, message);
-    }
-}

bukkit/src/main/java/net/william278/husksync/bukkit/util/PlayerSetter.java

@@ -1,488 +0,0 @@
-package net.william278.husksync.bukkit.util;
-
-import net.william278.husksync.HuskSyncBukkit;
-import net.william278.husksync.PlayerData;
-import net.william278.husksync.Settings;
-import net.william278.husksync.bukkit.events.SyncCompleteEvent;
-import net.william278.husksync.bukkit.events.SyncEvent;
-import net.william278.husksync.bukkit.data.DataSerializer;
-import net.william278.husksync.bukkit.util.nms.AdvancementUtils;
-import net.william278.husksync.redis.RedisMessage;
-import org.bukkit.*;
-import org.bukkit.advancement.Advancement;
-import org.bukkit.advancement.AdvancementProgress;
-import org.bukkit.attribute.Attribute;
-import org.bukkit.entity.EntityType;
-import org.bukkit.entity.Player;
-import org.bukkit.inventory.Inventory;
-import org.bukkit.inventory.ItemStack;
-import org.bukkit.potion.PotionEffect;
-import org.bukkit.potion.PotionEffectType;
-
-import java.io.IOException;
-import java.util.*;
-import java.util.logging.Level;
-
-public class PlayerSetter {
-
-    private static final HuskSyncBukkit plugin = HuskSyncBukkit.getInstance();
-
-    /**
-     * Returns the new serialized PlayerData for a player.
-     *
-     * @param player The {@link Player} to get the new serialized PlayerData for
-     * @return The {@link PlayerData}, serialized as a {@link String}
-     * @throws IOException If the serialization fails
-     */
-    private static String getNewSerializedPlayerData(Player player) throws IOException {
-        final double maxHealth = getMaxHealth(player); // Get the player's max health (used to determine health as well)
-        return RedisMessage.serialize(new PlayerData(player.getUniqueId(),
-                DataSerializer.serializeInventory(player.getInventory().getContents()),
-                DataSerializer.serializeInventory(player.getEnderChest().getContents()),
-                Math.min(player.getHealth(), maxHealth),
-                maxHealth,
-                player.isHealthScaled() ? player.getHealthScale() : 0D,
-                player.getFoodLevel(),
-                player.getSaturation(),
-                player.getExhaustion(),
-                player.getInventory().getHeldItemSlot(),
-                DataSerializer.serializePotionEffects(getPlayerPotionEffects(player)),
-                player.getTotalExperience(),
-                player.getLevel(),
-                player.getExp(),
-                player.getGameMode().toString(),
-                DataSerializer.getSerializedStatisticData(player),
-                player.isFlying(),
-                DataSerializer.getSerializedAdvancements(player),
-                DataSerializer.getSerializedLocation(player)));
-    }
-
-    /**
-     * Returns a {@link Player}'s maximum health, minus any health boost effects
-     *
-     * @param player The {@link Player} to get the maximum health of
-     * @return The {@link Player}'s max health
-     */
-    private static double getMaxHealth(Player player) {
-        double maxHealth = Objects.requireNonNull(player.getAttribute(Attribute.GENERIC_MAX_HEALTH)).getBaseValue();
-
-        // If the player has additional health bonuses from synchronised potion effects, subtract these from this number as they are synchronised separately
-        if (player.hasPotionEffect(PotionEffectType.HEALTH_BOOST) && maxHealth > 20D) {
-            PotionEffect healthBoostEffect = player.getPotionEffect(PotionEffectType.HEALTH_BOOST);
-            assert healthBoostEffect != null;
-            double healthBoostBonus = 4 * (healthBoostEffect.getAmplifier() + 1);
-            maxHealth -= healthBoostBonus;
-        }
-        return maxHealth;
-    }
-
-    /**
-     * Returns a {@link Player}'s active potion effects in a {@link PotionEffect} array
-     *
-     * @param player The {@link Player} to get the effects of
-     * @return The {@link PotionEffect} array
-     */
-    private static PotionEffect[] getPlayerPotionEffects(Player player) {
-        PotionEffect[] potionEffects = new PotionEffect[player.getActivePotionEffects().size()];
-        int arrayIndex = 0;
-        for (PotionEffect effect : player.getActivePotionEffects()) {
-            potionEffects[arrayIndex] = effect;
-            arrayIndex++;
-        }
-        return potionEffects;
-    }
-
-    /**
-     * Update a {@link Player}'s data, sending it to the proxy
-     *
-     * @param player     {@link Player} to send data to proxy
-     * @param bounceBack whether the plugin should bounce-back the updated data to the player (used for server switching)
-     */
-    public static void updatePlayerData(Player player, boolean bounceBack) {
-        // Send a redis message with the player's last updated PlayerData version UUID and their new PlayerData
-        try {
-            final String serializedPlayerData = getNewSerializedPlayerData(player);
-            new RedisMessage(RedisMessage.MessageType.PLAYER_DATA_UPDATE,
-                    new RedisMessage.MessageTarget(Settings.ServerType.PROXY, null, Settings.cluster),
-                    serializedPlayerData, Boolean.toString(bounceBack)).send();
-        } catch (IOException e) {
-            plugin.getLogger().log(Level.SEVERE, "Failed to send a PlayerData update to the proxy", e);
-        }
-    }
-
-    /**
-     * Request a {@link Player}'s data from the proxy
-     *
-     * @param playerUUID The {@link UUID} of the {@link Player} to fetch PlayerData from
-     * @throws IOException If the request Redis message data fails to serialize
-     */
-    public static void requestPlayerData(UUID playerUUID) throws IOException {
-        new RedisMessage(RedisMessage.MessageType.PLAYER_DATA_REQUEST,
-                new RedisMessage.MessageTarget(Settings.ServerType.PROXY, null, Settings.cluster),
-                playerUUID.toString()).send();
-    }
-
-    /**
-     * Set a player from their PlayerData, based on settings
-     *
-     * @param player    The {@link Player} to set
-     * @param dataToSet The {@link PlayerData} to assign to the player
-     */
-    public static void setPlayerFrom(Player player, PlayerData dataToSet) {
-        Bukkit.getScheduler().runTask(plugin, () -> {
-            // Handle the SyncEvent
-            SyncEvent syncEvent = new SyncEvent(player, dataToSet);
-            Bukkit.getPluginManager().callEvent(syncEvent);
-            final PlayerData data = syncEvent.getData();
-            if (syncEvent.isCancelled()) {
-                return;
-            }
-
-            // If the data is flagged as being default data, skip setting
-            if (data.useDefaultData) {
-                HuskSyncBukkit.bukkitCache.removeAwaitingDataFetch(player.getUniqueId());
-                return;
-            }
-
-            // Clear player
-            player.getInventory().clear();
-            player.getEnderChest().clear();
-            player.setExp(0);
-            player.setLevel(0);
-
-            HuskSyncBukkit.bukkitCache.removeAwaitingDataFetch(player.getUniqueId());
-
-            // Set the player's data from the PlayerData
-            try {
-                // Don't sync the player if they are dead
-                if (player.isDead() || player.getHealth() <= 0) {
-                    return;
-                }
-                if (Settings.syncAdvancements) {
-                    List<me.william278.husksync.bukkit.data.DataSerializer.AdvancementRecordDate> advancementRecords
-                            = DataSerializer.deserializeAdvancementData(data.getSerializedAdvancements());
-
-                    if (Settings.useNativeImplementation) {
-                        try {
-                            nativeSyncPlayerAdvancements(player, advancementRecords);
-                        } catch (Exception e) {
-                            plugin.getLogger().log(Level.WARNING,
-                                    "Your server does not support a native implementation of achievements synchronization");
-                            plugin.getLogger().log(Level.WARNING,
-                                    "Your server version is {0}. Please disable using native implementation!", Bukkit.getVersion());
-
-                            Settings.useNativeImplementation = false;
-                            setPlayerAdvancements(player, advancementRecords, data);
-                            plugin.getLogger().log(Level.SEVERE, e.getMessage(), e);
-                        }
-                    } else {
-                        setPlayerAdvancements(player, advancementRecords, data);
-                    }
-                }
-                // Don't sync the player if they are dead
-                if (player.isDead() || player.getHealth() <= 0) {
-                    Bukkit.getPluginManager().callEvent(new SyncCompleteEvent(player, data));
-                    return;
-                }
-                if (Settings.syncInventories) {
-                    setPlayerInventory(player, DataSerializer.deserializeInventory(data.getSerializedInventory()));
-                    player.getInventory().setHeldItemSlot(data.getSelectedSlot());
-                }
-                if (Settings.syncEnderChests) {
-                    setPlayerEnderChest(player, DataSerializer.deserializeInventory(data.getSerializedEnderChest()));
-                }
-                if (Settings.syncHealth) {
-                    setPlayerHealth(player, data.getHealth(), data.getMaxHealth(), data.getHealthScale());
-                }
-                if (Settings.syncHunger) {
-                    player.setFoodLevel(data.getHunger());
-                    player.setSaturation(data.getSaturation());
-                    player.setExhaustion(data.getSaturationExhaustion());
-                }
-                if (Settings.syncExperience) {
-                    // This is also handled when syncing advancements to ensure its correct
-                    setPlayerExperience(player, data);
-                }
-                if (Settings.syncPotionEffects) {
-                    setPlayerPotionEffects(player, DataSerializer.deserializePotionEffects(data.getSerializedEffectData()));
-                }
-                if (Settings.syncStatistics) {
-                    setPlayerStatistics(player, DataSerializer.deserializeStatisticData(data.getSerializedStatistics()));
-                }
-                if (Settings.syncGameMode) {
-                    player.setGameMode(GameMode.valueOf(data.getGameMode()));
-                }
-                if (Settings.syncLocation) {
-                    setPlayerLocation(player, DataSerializer.deserializePlayerLocationData(data.getSerializedLocation()));
-                }
-                if (Settings.syncFlight) {
-                    if (data.isFlying()) {
-                        player.setAllowFlight(true);
-                    }
-                    player.setFlying(player.getAllowFlight() && data.isFlying());
-                }
-
-                // Handle the SyncCompleteEvent
-                Bukkit.getPluginManager().callEvent(new SyncCompleteEvent(player, data));
-            } catch (IOException | ClassNotFoundException e) {
-                plugin.getLogger().log(Level.SEVERE, "Failed to deserialize PlayerData", e);
-            }
-        });
-    }
-
-    /**
-     * Sets a player's ender chest from a set of {@link ItemStack}s
-     *
-     * @param player The player to set the inventory of
-     * @param items  The array of {@link ItemStack}s to set
-     */
-    private static void setPlayerEnderChest(Player player, ItemStack[] items) {
-        setInventory(player.getEnderChest(), items);
-    }
-
-    /**
-     * Sets a player's inventory from a set of {@link ItemStack}s
-     *
-     * @param player The player to set the inventory of
-     * @param items  The array of {@link ItemStack}s to set
-     */
-    private static void setPlayerInventory(Player player, ItemStack[] items) {
-        setInventory(player.getInventory(), items);
-    }
-
-    /**
-     * Sets an inventory's contents from an array of {@link ItemStack}s
-     *
-     * @param inventory The inventory to set
-     * @param items     The {@link ItemStack}s to fill it with
-     */
-    public static void setInventory(Inventory inventory, ItemStack[] items) {
-        inventory.clear();
-        int index = 0;
-        for (ItemStack item : items) {
-            if (item != null) {
-                inventory.setItem(index, item);
-            }
-            index++;
-        }
-    }
-
-    /**
-     * Set a player's current potion effects from a set of {@link PotionEffect[]}
-     *
-     * @param player  The player to set the potion effects of
-     * @param effects The array of {@link PotionEffect}s to set
-     */
-    private static void setPlayerPotionEffects(Player player, PotionEffect[] effects) {
-        for (PotionEffect effect : player.getActivePotionEffects()) {
-            player.removePotionEffect(effect.getType());
-        }
-        for (PotionEffect effect : effects) {
-            player.addPotionEffect(effect);
-        }
-    }
-
-    private static void nativeSyncPlayerAdvancements(final Player player, final List<me.william278.husksync.bukkit.data.DataSerializer.AdvancementRecordDate> advancementRecords) {
-        final Object playerAdvancements = AdvancementUtils.getPlayerAdvancements(player);
-
-        // Clear
-        AdvancementUtils.clearPlayerAdvancements(playerAdvancements);
-        AdvancementUtils.clearVisibleAdvancements(playerAdvancements);
-
-        advancementRecords.forEach(advancementRecord -> {
-            NamespacedKey namespacedKey = Objects.requireNonNull(
-                    NamespacedKey.fromString(advancementRecord.key()),
-                    "Invalid Namespaced key of " + advancementRecord.key()
-            );
-
-            Advancement bukkitAdvancement = Bukkit.getAdvancement(namespacedKey);
-            if (bukkitAdvancement == null) {
-                plugin.getLogger().log(Level.WARNING, "Ignored advancement '{0}' - it doesn't exist anymore?", namespacedKey);
-                return;
-            }
-
-            Object advancement = AdvancementUtils.getHandle(bukkitAdvancement);
-            Map<String, Date> criteriaList = advancementRecord.criteriaMap();
-            {
-                Map<String, Object> nativeCriteriaMap = new HashMap<>();
-                criteriaList.forEach((criteria, date) ->
-                        nativeCriteriaMap.put(criteria, AdvancementUtils.newCriterionProgress(date))
-                );
-                Object nativeAdvancementProgress = AdvancementUtils.newAdvancementProgress(nativeCriteriaMap);
-
-                AdvancementUtils.startProgress(playerAdvancements, advancement, nativeAdvancementProgress);
-            }
-        });
-        AdvancementUtils.ensureAllVisible(playerAdvancements); // Set all completed advancement is visible
-        AdvancementUtils.markPlayerAdvancementsFirst(playerAdvancements); // Mark the sending of visible advancement as the first
-    }
-
-    /**
-     * Update a player's advancements and progress to match the advancementData
-     *
-     * @param player          The player to set the advancements of
-     * @param advancementData The ArrayList of {@link me.william278.husksync.bukkit.data.DataSerializer.AdvancementRecordDate}s to set
-     */
-    private static void setPlayerAdvancements(Player player, List<me.william278.husksync.bukkit.data.DataSerializer.AdvancementRecordDate> advancementData, PlayerData data) {
-        // Temporarily disable advancement announcing if needed
-        boolean announceAdvancementUpdate = false;
-        if (Boolean.TRUE.equals(player.getWorld().getGameRuleValue(GameRule.ANNOUNCE_ADVANCEMENTS))) {
-            player.getWorld().setGameRule(GameRule.ANNOUNCE_ADVANCEMENTS, false);
-            announceAdvancementUpdate = true;
-        }
-        final boolean finalAnnounceAdvancementUpdate = announceAdvancementUpdate;
-
-        // Run async because advancement loading is very slow
-        Bukkit.getScheduler().runTaskAsynchronously(plugin, () -> {
-
-            // Apply the advancements to the player
-            final Iterator<Advancement> serverAdvancements = Bukkit.getServer().advancementIterator();
-            while (serverAdvancements.hasNext()) { // Iterate through all advancements
-                boolean correctExperienceCheck = false; // Determines whether the experience might have changed warranting an update
-                Advancement advancement = serverAdvancements.next();
-                AdvancementProgress playerProgress = player.getAdvancementProgress(advancement);
-                for (me.william278.husksync.bukkit.data.DataSerializer.AdvancementRecordDate record : advancementData) {
-                    // If the advancement is one on the data
-                    if (record.key().equals(advancement.getKey().getNamespace() + ":" + advancement.getKey().getKey())) {
-
-                        // Award all criteria that the player does not have that they do on the cache
-                        ArrayList<String> currentlyAwardedCriteria = new ArrayList<>(playerProgress.getAwardedCriteria());
-                        for (String awardCriteria : record.criteriaMap().keySet()) {
-                            if (!playerProgress.getAwardedCriteria().contains(awardCriteria)) {
-                                Bukkit.getScheduler().runTask(plugin, () -> player.getAdvancementProgress(advancement).awardCriteria(awardCriteria));
-                                correctExperienceCheck = true;
-                            }
-                            currentlyAwardedCriteria.remove(awardCriteria);
-                        }
-
-                        // Revoke all criteria that the player does have but should not
-                        for (String awardCriteria : currentlyAwardedCriteria) {
-                            Bukkit.getScheduler().runTask(plugin, () -> player.getAdvancementProgress(advancement).revokeCriteria(awardCriteria));
-                        }
-                        break;
-                    }
-                }
-
-                // Update the player's experience in case the advancement changed that
-                if (correctExperienceCheck) {
-                    if (Settings.syncExperience) {
-                        setPlayerExperience(player, data);
-                    }
-                }
-            }
-
-            // Re-enable announcing advancements (back on main thread again)
-            Bukkit.getScheduler().runTask(plugin, () -> {
-                if (finalAnnounceAdvancementUpdate) {
-                    player.getWorld().setGameRule(GameRule.ANNOUNCE_ADVANCEMENTS, true);
-                }
-            });
-        });
-    }
-
-    /**
-     * Set a player's statistics (in the Statistic menu)
-     *
-     * @param player        The player to set the statistics of
-     * @param statisticData The {@link me.william278.husksync.bukkit.data.DataSerializer.StatisticData} to set
-     */
-    private static void setPlayerStatistics(Player player, me.william278.husksync.bukkit.data.DataSerializer.StatisticData statisticData) {
-        // Set untyped statistics
-        for (Statistic statistic : statisticData.untypedStatisticValues().keySet()) {
-            player.setStatistic(statistic, statisticData.untypedStatisticValues().get(statistic));
-        }
-
-        // Set block statistics
-        for (Statistic statistic : statisticData.blockStatisticValues().keySet()) {
-            for (Material blockMaterial : statisticData.blockStatisticValues().get(statistic).keySet()) {
-                player.setStatistic(statistic, blockMaterial, statisticData.blockStatisticValues().get(statistic).get(blockMaterial));
-            }
-        }
-
-        // Set item statistics
-        for (Statistic statistic : statisticData.itemStatisticValues().keySet()) {
-            for (Material itemMaterial : statisticData.itemStatisticValues().get(statistic).keySet()) {
-                player.setStatistic(statistic, itemMaterial, statisticData.itemStatisticValues().get(statistic).get(itemMaterial));
-            }
-        }
-
-        // Set entity statistics
-        for (Statistic statistic : statisticData.entityStatisticValues().keySet()) {
-            for (EntityType entityType : statisticData.entityStatisticValues().get(statistic).keySet()) {
-                player.setStatistic(statistic, entityType, statisticData.entityStatisticValues().get(statistic).get(entityType));
-            }
-        }
-    }
-
-    /**
-     * Set a player's exp level, exp points & score
-     *
-     * @param player The {@link Player} to set
-     * @param data   The {@link PlayerData} to set them
-     */
-    private static void setPlayerExperience(Player player, PlayerData data) {
-        player.setTotalExperience(data.getTotalExperience());
-        player.setLevel(data.getExpLevel());
-        player.setExp(data.getExpProgress());
-    }
-
-    /**
-     * Set a player's location from {@link me.william278.husksync.bukkit.data.DataSerializer.PlayerLocation} data
-     *
-     * @param player   The {@link Player} to teleport
-     * @param location The {@link me.william278.husksync.bukkit.data.DataSerializer.PlayerLocation}
-     */
-    private static void setPlayerLocation(Player player, me.william278.husksync.bukkit.data.DataSerializer.PlayerLocation location) {
-        // Don't teleport if the location is invalid
-        if (location == null) {
-            return;
-        }
-
-        // Determine the world; if the names match, use that
-        World world = Bukkit.getWorld(location.worldName());
-        if (world == null) {
-
-            // If the names don't match, find the corresponding world with the same dimension environment
-            for (World worldOnServer : Bukkit.getWorlds()) {
-                if (worldOnServer.getEnvironment().equals(location.environment())) {
-                    world = worldOnServer;
-                }
-            }
-
-            // If that still fails, return
-            if (world == null) {
-                return;
-            }
-        }
-
-        // Teleport the player
-        player.teleport(new Location(world, location.x(), location.y(), location.z(), location.yaw(), location.pitch()));
-    }
-
-    /**
-     * Correctly set a {@link Player}'s health data
-     *
-     * @param player      The {@link Player} to set
-     * @param health      Health to set to the player
-     * @param maxHealth   Max health to set to the player
-     * @param healthScale Health scaling to apply to the player
-     */
-    private static void setPlayerHealth(Player player, double health, double maxHealth, double healthScale) {
-        // Set max health
-        if (maxHealth != 0D) {
-            Objects.requireNonNull(player.getAttribute(Attribute.GENERIC_MAX_HEALTH)).setBaseValue(maxHealth);
-        }
-
-        // Set health
-        double currentHealth = player.getHealth();
-        if (health != currentHealth) player.setHealth(currentHealth > maxHealth ? maxHealth : health);
-
-        // Set health scaling if needed
-        if (healthScale != 0D) {
-            player.setHealthScale(healthScale);
-        } else {
-            player.setHealthScale(maxHealth);
-        }
-        player.setHealthScaled(healthScale != 0D);
-    }
-}

bukkit/src/main/java/net/william278/husksync/bukkit/util/nms/AdvancementUtils.java

@@ -1,146 +0,0 @@
-package net.william278.husksync.bukkit.util.nms;
-
-import net.william278.husksync.util.ThrowSupplier;
-import org.bukkit.advancement.Advancement;
-import org.bukkit.entity.Player;
-
-import java.lang.reflect.Field;
-import java.lang.reflect.InvocationTargetException;
-import java.lang.reflect.Method;
-import java.util.Date;
-import java.util.Map;
-import java.util.Set;
-
-public class AdvancementUtils {
-
-    public final static Class<?> PLAYER_ADVANCEMENT;
-    private final static Field PLAYER_ADVANCEMENTS_MAP;
-    private final static Field PLAYER_VISIBLE_SET;
-    private final static Field PLAYER_ADVANCEMENTS;
-    private final static Field CRITERIA_MAP;
-    private final static Field CRITERIA_DATE;
-    private final static Field IS_FIRST_PACKET;
-    private final static Method GET_HANDLE;
-    private final static Method START_PROGRESS;
-    private final static Method ENSURE_ALL_VISIBLE;
-    private final static Class<?> ADVANCEMENT_PROGRESS;
-    private final static Class<?> CRITERION_PROGRESS;
-
-    static {
-        Class<?> SERVER_PLAYER = MinecraftVersionUtils.getMinecraftClass("level.EntityPlayer");
-        PLAYER_ADVANCEMENTS = ThrowSupplier.get(() -> SERVER_PLAYER.getDeclaredField("cs"));
-        PLAYER_ADVANCEMENTS.setAccessible(true);
-
-        Class<?> CRAFT_ADVANCEMENT = MinecraftVersionUtils.getBukkitClass("advancement.CraftAdvancement");
-        GET_HANDLE = ThrowSupplier.get(() -> CRAFT_ADVANCEMENT.getDeclaredMethod("getHandle"));
-
-        ADVANCEMENT_PROGRESS = ThrowSupplier.get(() -> Class.forName("net.minecraft.advancements.AdvancementProgress"));
-        CRITERIA_MAP = ThrowSupplier.get(() -> ADVANCEMENT_PROGRESS.getDeclaredField("a"));
-        CRITERIA_MAP.setAccessible(true);
-
-        CRITERION_PROGRESS = ThrowSupplier.get(() -> Class.forName("net.minecraft.advancements.CriterionProgress"));
-        CRITERIA_DATE = ThrowSupplier.get(() -> CRITERION_PROGRESS.getDeclaredField("b"));
-        CRITERIA_DATE.setAccessible(true);
-
-        Class<?> ADVANCEMENT = ThrowSupplier.get(() -> Class.forName("net.minecraft.advancements.Advancement"));
-
-        PLAYER_ADVANCEMENT = MinecraftVersionUtils.getMinecraftClass("AdvancementDataPlayer");
-        PLAYER_ADVANCEMENTS_MAP = ThrowSupplier.get(() -> PLAYER_ADVANCEMENT.getDeclaredField("h"));
-        PLAYER_ADVANCEMENTS_MAP.setAccessible(true);
-
-        PLAYER_VISIBLE_SET = ThrowSupplier.get(() -> PLAYER_ADVANCEMENT.getDeclaredField("i"));
-        PLAYER_VISIBLE_SET.setAccessible(true);
-
-        START_PROGRESS = ThrowSupplier.get(() -> PLAYER_ADVANCEMENT.getDeclaredMethod("a", ADVANCEMENT, ADVANCEMENT_PROGRESS));
-        START_PROGRESS.setAccessible(true);
-
-        ENSURE_ALL_VISIBLE = ThrowSupplier.get(() -> PLAYER_ADVANCEMENT.getDeclaredMethod("c"));
-        ENSURE_ALL_VISIBLE.setAccessible(true);
-
-        IS_FIRST_PACKET = ThrowSupplier.get(() -> PLAYER_ADVANCEMENT.getDeclaredField("n"));
-        IS_FIRST_PACKET.setAccessible(true);
-    }
-
-    public static void markPlayerAdvancementsFirst(final Object playerAdvancements) {
-        try {
-            IS_FIRST_PACKET.set(playerAdvancements, true);
-        } catch (IllegalAccessException e) {
-            throw new RuntimeException(e.getMessage(), e);
-        }
-    }
-
-    public static Object getPlayerAdvancements(Player player) {
-        Object nativePlayer = EntityUtils.getHandle(player);
-        try {
-            return PLAYER_ADVANCEMENTS.get(nativePlayer);
-        } catch (IllegalAccessException e) {
-            throw new RuntimeException(e.getMessage(), e);
-        }
-    }
-
-    public static void clearPlayerAdvancements(final Object playerAdvancement) {
-        try {
-            ((Map<?, ?>) PLAYER_ADVANCEMENTS_MAP.get(playerAdvancement))
-                    .clear();
-        } catch (IllegalAccessException e) {
-            throw new RuntimeException(e.getMessage(), e);
-        }
-    }
-
-    public static Object getHandle(Advancement advancement) {
-        try {
-            return GET_HANDLE.invoke(advancement);
-        } catch (IllegalAccessException | InvocationTargetException e) {
-            throw new RuntimeException(e.getMessage(), e);
-        }
-    }
-
-    public static Object newCriterionProgress(final Date date) {
-        try {
-            Object nativeCriterionProgress = CRITERION_PROGRESS.getDeclaredConstructor().newInstance();
-            CRITERIA_DATE.set(nativeCriterionProgress, date);
-            return nativeCriterionProgress;
-        } catch (InstantiationException | IllegalAccessException | InvocationTargetException | NoSuchMethodException e) {
-            throw new RuntimeException(e.getMessage(), e);
-        }
-    }
-
-    @SuppressWarnings("unchecked") // Suppress unchecked cast warnings here
-    public static Object newAdvancementProgress(final Map<String, Object> criteria) {
-        try {
-            Object nativeAdvancementProgress = ADVANCEMENT_PROGRESS.getDeclaredConstructor().newInstance();
-
-            final Map<String, Object> criteriaMap = (Map<String, Object>) CRITERIA_MAP.get(nativeAdvancementProgress);
-            criteriaMap.putAll(criteria);
-
-            return nativeAdvancementProgress;
-        } catch (NoSuchMethodException | InvocationTargetException | InstantiationException | IllegalAccessException e) {
-            throw new RuntimeException(e.getMessage(), e);
-        }
-    }
-
-    public static void startProgress(final Object playerAdvancements, final Object advancement, final Object advancementProgress) {
-        try {
-            START_PROGRESS.invoke(playerAdvancements, advancement, advancementProgress);
-        } catch (IllegalAccessException | InvocationTargetException e) {
-            throw new RuntimeException(e.getMessage(), e);
-        }
-    }
-
-    public static void ensureAllVisible(final Object playerAdvancements) {
-        try {
-            ENSURE_ALL_VISIBLE.invoke(playerAdvancements);
-        } catch (IllegalAccessException | InvocationTargetException e) {
-            throw new RuntimeException(e.getMessage(), e);
-        }
-    }
-
-    public static void clearVisibleAdvancements(final Object playerAdvancements) {
-        try {
-            ((Set<?>) PLAYER_VISIBLE_SET.get(playerAdvancements))
-                    .clear();
-        } catch (IllegalAccessException e) {
-            throw new RuntimeException(e.getMessage(), e);
-        }
-    }
-}

bukkit/src/main/java/net/william278/husksync/bukkit/util/nms/EntityUtils.java

@@ -1,26 +0,0 @@
-package net.william278.husksync.bukkit.util.nms;
-
-import net.william278.husksync.util.ThrowSupplier;
-import org.bukkit.entity.LivingEntity;
-
-import java.lang.reflect.InvocationTargetException;
-import java.lang.reflect.Method;
-
-public class EntityUtils {
-
-    private final static Method GET_HANDLE;
-
-    static {
-        final Class<?> CRAFT_ENTITY = MinecraftVersionUtils.getBukkitClass("entity.CraftEntity");
-        GET_HANDLE = ThrowSupplier.get(() -> CRAFT_ENTITY.getDeclaredMethod("getHandle"));
-    }
-
-    public static Object getHandle(LivingEntity livingEntity) throws RuntimeException {
-        try {
-            return GET_HANDLE.invoke(livingEntity);
-        } catch (IllegalAccessException | InvocationTargetException e) {
-            throw new RuntimeException(e.getMessage(), e);
-        }
-    }
-
-}

bukkit/src/main/java/net/william278/husksync/bukkit/util/nms/MinecraftVersionUtils.java

@@ -1,25 +0,0 @@
-package net.william278.husksync.bukkit.util.nms;
-
-import net.william278.husksync.util.ThrowSupplier;
-import net.william278.husksync.util.VersionUtils;
-import org.bukkit.Bukkit;
-
-public class MinecraftVersionUtils {
-
-    public final static String CRAFTBUKKIT_PACKAGE_PATH = Bukkit.getServer().getClass().getPackage().getName();
-
-    public final static String PACKAGE_VERSION = CRAFTBUKKIT_PACKAGE_PATH.split("\\.")[3];
-    public final static VersionUtils.Version SERVER_VERSION
-            = VersionUtils.Version.of(Bukkit.getBukkitVersion().split("-")[0]);
-    public final static String MINECRAFT_PACKAGE = SERVER_VERSION.compareTo(VersionUtils.Version.of("1.17")) < 0 ?
-            "net.minecraft.server.".concat(PACKAGE_VERSION) : "net.minecraft.server";
-
-    public static Class<?> getBukkitClass(String path) {
-        return ThrowSupplier.get(() -> Class.forName(CRAFTBUKKIT_PACKAGE_PATH.concat(".").concat(path)));
-    }
-
-    public static Class<?> getMinecraftClass(String path) {
-        return ThrowSupplier.get(() -> Class.forName(MINECRAFT_PACKAGE.concat(".").concat(path)));
-    }
-
-}

bukkit/src/main/java/net/william278/husksync/command/BrigadierUtil.java

@@ -0,0 +1,50 @@
+/*
+ * This file is part of HuskSync, licensed under the Apache License 2.0.
+ *
+ *  Copyright (c) William278 <will27528@gmail.com>
+ *  Copyright (c) contributors
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+package net.william278.husksync.command;
+
+import me.lucko.commodore.CommodoreProvider;
+import me.lucko.commodore.file.CommodoreFileReader;
+import net.william278.husksync.BukkitHuskSync;
+import org.bukkit.command.PluginCommand;
+import org.jetbrains.annotations.NotNull;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.logging.Level;
+
+/**
+ * Used for registering Brigadier hooks on platforms that support commodore for rich command syntax
+ */
+public class BrigadierUtil {
+
+    protected static void registerCommodore(@NotNull BukkitHuskSync plugin, @NotNull PluginCommand pluginCommand,
+                                            @NotNull CommandBase command) {
+        // Register command descriptions via commodore (brigadier wrapper)
+        try (InputStream pluginFile = plugin.getResource("commodore/" + command.command + ".commodore")) {
+            CommodoreProvider.getCommodore(plugin).register(pluginCommand,
+                    CommodoreFileReader.INSTANCE.parse(pluginFile),
+                    player -> player.hasPermission(command.permission));
+        } catch (IOException e) {
+            plugin.log(Level.SEVERE,
+                    "Failed to load " + command.command + ".commodore command definitions", e);
+        }
+    }
+
+}

bukkit/src/main/java/net/william278/husksync/command/BukkitCommand.java

@@ -0,0 +1,95 @@
+/*
+ * This file is part of HuskSync, licensed under the Apache License 2.0.
+ *
+ *  Copyright (c) William278 <will27528@gmail.com>
+ *  Copyright (c) contributors
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+package net.william278.husksync.command;
+
+import me.lucko.commodore.CommodoreProvider;
+import net.william278.husksync.BukkitHuskSync;
+import net.william278.husksync.player.BukkitPlayer;
+import org.bukkit.command.*;
+import org.bukkit.entity.Player;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.Collections;
+import java.util.List;
+
+/**
+ * Bukkit executor that implements and executes {@link CommandBase}s
+ */
+public class BukkitCommand implements CommandExecutor, TabExecutor {
+
+    /**
+     * The {@link CommandBase} that will be executed
+     */
+    protected final CommandBase command;
+
+    /**
+     * The implementing plugin
+     */
+    private final BukkitHuskSync plugin;
+
+    public BukkitCommand(@NotNull CommandBase command, @NotNull BukkitHuskSync implementor) {
+        this.command = command;
+        this.plugin = implementor;
+    }
+
+    /**
+     * Registers a {@link PluginCommand} to this implementation
+     *
+     * @param pluginCommand {@link PluginCommand} to register
+     */
+    public void register(@NotNull PluginCommand pluginCommand) {
+        pluginCommand.setExecutor(this);
+        pluginCommand.setTabCompleter(this);
+        pluginCommand.setPermission(command.permission);
+        pluginCommand.setDescription(command.getDescription());
+        if (CommodoreProvider.isSupported()) {
+            BrigadierUtil.registerCommodore(plugin, pluginCommand, command);
+        }
+    }
+
+    @Override
+    public boolean onCommand(@NotNull CommandSender sender, @NotNull Command command,
+                             @NotNull String label, @NotNull String[] args) {
+        if (sender instanceof Player player) {
+            this.command.onExecute(BukkitPlayer.adapt(player), args);
+        } else {
+            if (this.command instanceof ConsoleExecutable consoleExecutable) {
+                consoleExecutable.onConsoleExecute(args);
+            } else {
+                plugin.getLocales().getLocale("error_in_game_command_only")
+                        .ifPresent(locale -> plugin.getAudiences().sender(sender)
+                                .sendMessage(locale.toComponent()));
+            }
+        }
+        return true;
+    }
+
+    @Nullable
+    @Override
+    public List<String> onTabComplete(@NotNull CommandSender sender, @NotNull Command command,
+                                      @NotNull String alias, @NotNull String[] args) {
+        if (this.command instanceof TabCompletable tabCompletable) {
+            return tabCompletable.onTabComplete(args);
+        }
+        return Collections.emptyList();
+    }
+
+}

bukkit/src/main/java/net/william278/husksync/command/BukkitCommandType.java

@@ -0,0 +1,40 @@
+/*
+ * This file is part of HuskSync, licensed under the Apache License 2.0.
+ *
+ *  Copyright (c) William278 <will27528@gmail.com>
+ *  Copyright (c) contributors
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+package net.william278.husksync.command;
+
+import net.william278.husksync.BukkitHuskSync;
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * Commands available on the Bukkit HuskSync implementation
+ */
+public enum BukkitCommandType {
+
+    HUSKSYNC_COMMAND(new HuskSyncCommand(BukkitHuskSync.getInstance())),
+    USERDATA_COMMAND(new UserDataCommand(BukkitHuskSync.getInstance())),
+    INVENTORY_COMMAND(new InventoryCommand(BukkitHuskSync.getInstance())),
+    ENDER_CHEST_COMMAND(new EnderChestCommand(BukkitHuskSync.getInstance()));
+
+    public final CommandBase commandBase;
+
+    BukkitCommandType(@NotNull CommandBase commandBase) {
+        this.commandBase = commandBase;
+    }
+}

bukkit/src/main/java/net/william278/husksync/data/BukkitInventoryMap.java

@@ -0,0 +1,147 @@
+/*
+ * This file is part of HuskSync, licensed under the Apache License 2.0.
+ *
+ *  Copyright (c) William278 <will27528@gmail.com>
+ *  Copyright (c) contributors
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+package net.william278.husksync.data;
+
+import org.bukkit.inventory.ItemStack;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Optional;
+
+/**
+ * A mapped player inventory, providing methods to easily access a player's inventory.
+ */
+@SuppressWarnings("unused")
+public class BukkitInventoryMap {
+
+    public static final int INVENTORY_SLOT_COUNT = 41;
+
+    private ItemStack[] contents;
+
+    /**
+     * Creates a new mapped inventory from the given contents.
+     *
+     * @param contents the contents of the inventory
+     */
+    protected BukkitInventoryMap(ItemStack[] contents) {
+        this.contents = contents;
+    }
+
+    /**
+     * Gets the contents of the inventory.
+     *
+     * @return the contents of the inventory
+     */
+    public ItemStack[] getContents() {
+        return contents;
+    }
+
+    /**
+     * Set the contents of the inventory.
+     *
+     * @param contents the contents of the inventory
+     */
+    public void setContents(ItemStack[] contents) {
+        this.contents = contents;
+    }
+
+    /**
+     * Gets the size of the inventory.
+     *
+     * @return the size of the inventory
+     */
+    public int getSize() {
+        return contents.length;
+    }
+
+    /**
+     * Gets the item at the given index.
+     *
+     * @param index the index of the item to get
+     * @return the item at the given index
+     */
+    public Optional<ItemStack> getItemAt(int index) {
+        if (contents.length >= index) {
+            if (contents[index] == null) {
+                return Optional.empty();
+            }
+            return Optional.of(contents[index]);
+        }
+        return Optional.empty();
+    }
+
+    /**
+     * Sets the item at the given index.
+     *
+     * @param itemStack the item to set at the given index
+     * @param index     the index of the item to set
+     * @throws IllegalArgumentException if the index is out of bounds
+     */
+    public void setItemAt(@NotNull ItemStack itemStack, int index) throws IllegalArgumentException {
+        contents[index] = itemStack;
+    }
+
+    /**
+     * Returns the main inventory contents.
+     *
+     * @return the main inventory contents
+     */
+    public ItemStack[] getInventory() {
+        final ItemStack[] inventory = new ItemStack[36];
+        System.arraycopy(contents, 0, inventory, 0, Math.min(contents.length, inventory.length));
+        return inventory;
+    }
+
+    public ItemStack[] getHotbar() {
+        final ItemStack[] armor = new ItemStack[9];
+        for (int i = 0; i <= 9; i++) {
+            armor[i] = getItemAt(i).orElse(null);
+        }
+        return armor;
+    }
+
+    public Optional<ItemStack> getOffHand() {
+        return getItemAt(40);
+    }
+
+    public Optional<ItemStack> getHelmet() {
+        return getItemAt(39);
+    }
+
+    public Optional<ItemStack> getChestplate() {
+        return getItemAt(38);
+    }
+
+    public Optional<ItemStack> getLeggings() {
+        return getItemAt(37);
+    }
+
+    public Optional<ItemStack> getBoots() {
+        return getItemAt(36);
+    }
+
+    public ItemStack[] getArmor() {
+        final ItemStack[] armor = new ItemStack[4];
+        for (int i = 36; i < 40; i++) {
+            armor[i - 36] = getItemAt(i).orElse(null);
+        }
+        return armor;
+    }
+
+}

bukkit/src/main/java/net/william278/husksync/data/BukkitMapHandler.java

@@ -0,0 +1,233 @@
+/*
+ * This file is part of HuskSync, licensed under the Apache License 2.0.
+ *
+ *  Copyright (c) William278 <will27528@gmail.com>
+ *  Copyright (c) contributors
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+package net.william278.husksync.data;
+
+import net.william278.husksync.BukkitHuskSync;
+import net.william278.mapdataapi.MapData;
+import org.bukkit.Bukkit;
+import org.bukkit.Material;
+import org.bukkit.NamespacedKey;
+import org.bukkit.entity.Player;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.inventory.meta.MapMeta;
+import org.bukkit.map.*;
+import org.bukkit.persistence.PersistentDataType;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.awt.*;
+import java.io.IOException;
+import java.util.Objects;
+import java.util.concurrent.ExecutionException;
+import java.util.logging.Level;
+
+/**
+ * Handles the persistence of {@link MapData} into {@link ItemStack}s.
+ */
+public class BukkitMapHandler {
+
+    private static final BukkitHuskSync plugin = BukkitHuskSync.getInstance();
+    private static final NamespacedKey MAP_DATA_KEY = new NamespacedKey(plugin, "map_data");
+
+    /**
+     * Get the {@link MapData} from the given {@link ItemStack} and persist it in its' data container
+     *
+     * @param itemStack the {@link ItemStack} to get the {@link MapData} from
+     */
+    @SuppressWarnings("ConstantConditions")
+    public static void persistMapData(@Nullable ItemStack itemStack) {
+        if (itemStack == null || itemStack.getType() != Material.FILLED_MAP) {
+            return;
+        }
+        final MapMeta mapMeta = (MapMeta) itemStack.getItemMeta();
+        if (mapMeta == null || !mapMeta.hasMapView()) {
+            return;
+        }
+
+        // Get the map view from the map
+        final MapView mapView;
+        try {
+            mapView = Bukkit.getScheduler().callSyncMethod(plugin, mapMeta::getMapView).get();
+            if (mapView == null || !mapView.isLocked() || mapView.isVirtual()) {
+                return;
+            }
+        } catch (InterruptedException | ExecutionException e) {
+            plugin.getLogger().log(Level.WARNING, "Failed to save map data for a player", e);
+            return;
+        }
+
+        // Get the map data
+        plugin.debug("Rendering map view onto canvas for locked map");
+        final LockedMapCanvas canvas = new LockedMapCanvas(mapView);
+        for (MapRenderer renderer : mapView.getRenderers()) {
+            renderer.render(mapView, canvas, Bukkit.getServer()
+                    .getOnlinePlayers().stream()
+                    .findAny()
+                    .orElse(null));
+        }
+
+        // Save the extracted rendered map data
+        plugin.debug("Saving pixel canvas data for locked map");
+        if (!mapMeta.getPersistentDataContainer().has(MAP_DATA_KEY, PersistentDataType.BYTE_ARRAY)) {
+            mapMeta.getPersistentDataContainer().set(MAP_DATA_KEY, PersistentDataType.BYTE_ARRAY,
+                    canvas.extractMapData().toBytes());
+            itemStack.setItemMeta(mapMeta);
+        }
+    }
+
+    /**
+     * Set the map data of the given {@link ItemStack} to the given {@link MapData}, applying a map view to the item stack
+     *
+     * @param itemStack the {@link ItemStack} to set the map data of
+     */
+    public static void setMapRenderer(@Nullable ItemStack itemStack) {
+        if (itemStack == null || itemStack.getType() != Material.FILLED_MAP) {
+            return;
+        }
+
+        final MapMeta mapMeta = (MapMeta) itemStack.getItemMeta();
+        if (mapMeta == null) {
+            return;
+        }
+
+        if (!itemStack.getItemMeta().getPersistentDataContainer().has(MAP_DATA_KEY, PersistentDataType.BYTE_ARRAY)) {
+            return;
+        }
+
+        try {
+            final byte[] serializedData = itemStack.getItemMeta().getPersistentDataContainer()
+                    .get(MAP_DATA_KEY, PersistentDataType.BYTE_ARRAY);
+            final MapData mapData = MapData.fromByteArray(Objects.requireNonNull(serializedData));
+            plugin.debug("Setting deserialized map data for an item stack");
+
+            // Create a new map view renderer with the map data color at each pixel
+            final MapView view = Bukkit.createMap(Bukkit.getWorlds().get(0));
+            view.getRenderers().clear();
+            view.addRenderer(new PersistentMapRenderer(mapData));
+            view.setLocked(true);
+            view.setScale(MapView.Scale.NORMAL);
+            view.setTrackingPosition(false);
+            view.setUnlimitedTracking(false);
+            mapMeta.setMapView(view);
+            itemStack.setItemMeta(mapMeta);
+            plugin.debug("Successfully applied renderer to map item stack");
+        } catch (IOException | NullPointerException e) {
+            plugin.getLogger().log(Level.WARNING, "Failed to deserialize map data for a player", e);
+        }
+    }
+
+    /**
+     * A {@link MapRenderer} that can be used to render persistently serialized {@link MapData} to a {@link MapView}
+     */
+    public static class PersistentMapRenderer extends MapRenderer {
+
+        private final MapData mapData;
+
+        private PersistentMapRenderer(@NotNull MapData mapData) {
+            super(false);
+            this.mapData = mapData;
+        }
+
+        @Override
+        public void render(@NotNull MapView map, @NotNull MapCanvas canvas, @NotNull Player player) {
+            for (int i = 0; i < 128; i++) {
+                for (int j = 0; j < 128; j++) {
+                    // We set the pixels in this order to avoid the map being rendered upside down
+                    canvas.setPixel(j, i, (byte) mapData.getColorAt(i, j));
+                }
+            }
+        }
+    }
+
+    /**
+     * A {@link MapCanvas} implementation used for pre-rendering maps to be converted into {@link MapData}
+     */
+    public static class LockedMapCanvas implements MapCanvas {
+
+        private final MapView mapView;
+        private final int[][] pixels = new int[128][128];
+        private MapCursorCollection cursors;
+
+        private LockedMapCanvas(@NotNull MapView mapView) {
+            this.mapView = mapView;
+        }
+
+        @NotNull
+        @Override
+        public MapView getMapView() {
+            return mapView;
+        }
+
+        @NotNull
+        @Override
+        public MapCursorCollection getCursors() {
+            return cursors == null ? (cursors = new MapCursorCollection()) : cursors;
+        }
+
+        @Override
+        public void setCursors(@NotNull MapCursorCollection cursors) {
+            this.cursors = cursors;
+        }
+
+        @Override
+        public void setPixel(int x, int y, byte color) {
+            pixels[x][y] = color;
+        }
+
+        @Override
+        public byte getPixel(int x, int y) {
+            return (byte) pixels[x][y];
+        }
+
+        @Override
+        public byte getBasePixel(int x, int y) {
+            return getPixel(x, y);
+        }
+
+        @Override
+        public void drawImage(int x, int y, @NotNull Image image) {
+            // Not implemented
+        }
+
+        @Override
+        public void drawText(int x, int y, @NotNull MapFont font, @NotNull String text) {
+            // Not implemented
+        }
+
+        @NotNull
+        private String getDimension() {
+            return mapView.getWorld() == null ? "minecraft:overworld"
+                    : switch (mapView.getWorld().getEnvironment()) {
+                case NETHER -> "minecraft:the_nether";
+                case THE_END -> "minecraft:the_end";
+                default -> "minecraft:overworld";
+            };
+        }
+
+        /**
+         * Extract the map data from the canvas. Must be rendered first
+         * @return the extracted map data
+         */
+        @NotNull
+        private MapData extractMapData() {
+            return MapData.fromPixels(pixels, getDimension(), (byte) 2);
+        }
+    }
+}

bukkit/src/main/java/net/william278/husksync/data/BukkitPersistentTypeMapping.java

@@ -0,0 +1,73 @@
+/*
+ * This file is part of HuskSync, licensed under the Apache License 2.0.
+ *
+ *  Copyright (c) William278 <will27528@gmail.com>
+ *  Copyright (c) contributors
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+package net.william278.husksync.data;
+
+import org.bukkit.NamespacedKey;
+import org.bukkit.entity.Player;
+import org.bukkit.persistence.PersistentDataContainer;
+import org.bukkit.persistence.PersistentDataType;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Objects;
+import java.util.Optional;
+
+public record BukkitPersistentTypeMapping<T, Z>(PersistentDataTagType type, PersistentDataType<T, Z> bukkitType) {
+
+    public static final BukkitPersistentTypeMapping<?, ?>[] PRIMITIVE_TYPE_MAPPINGS = new BukkitPersistentTypeMapping<?, ?>[]{
+            new BukkitPersistentTypeMapping<>(PersistentDataTagType.BYTE, PersistentDataType.BYTE),
+            new BukkitPersistentTypeMapping<>(PersistentDataTagType.SHORT, PersistentDataType.SHORT),
+            new BukkitPersistentTypeMapping<>(PersistentDataTagType.INTEGER, PersistentDataType.INTEGER),
+            new BukkitPersistentTypeMapping<>(PersistentDataTagType.LONG, PersistentDataType.LONG),
+            new BukkitPersistentTypeMapping<>(PersistentDataTagType.FLOAT, PersistentDataType.FLOAT),
+            new BukkitPersistentTypeMapping<>(PersistentDataTagType.DOUBLE, PersistentDataType.DOUBLE),
+            new BukkitPersistentTypeMapping<>(PersistentDataTagType.STRING, PersistentDataType.STRING),
+            new BukkitPersistentTypeMapping<>(PersistentDataTagType.BYTE_ARRAY, PersistentDataType.BYTE_ARRAY),
+            new BukkitPersistentTypeMapping<>(PersistentDataTagType.INTEGER_ARRAY, PersistentDataType.INTEGER_ARRAY),
+            new BukkitPersistentTypeMapping<>(PersistentDataTagType.LONG_ARRAY, PersistentDataType.LONG_ARRAY),
+            new BukkitPersistentTypeMapping<>(PersistentDataTagType.TAG_CONTAINER_ARRAY, PersistentDataType.TAG_CONTAINER_ARRAY),
+            new BukkitPersistentTypeMapping<>(PersistentDataTagType.TAG_CONTAINER, PersistentDataType.TAG_CONTAINER)
+    };
+
+    public BukkitPersistentTypeMapping(@NotNull PersistentDataTagType type, @NotNull PersistentDataType<T, Z> bukkitType) {
+        this.type = type;
+        this.bukkitType = bukkitType;
+    }
+
+    @NotNull
+    public PersistentDataTag<Z> getContainerValue(@NotNull PersistentDataContainer container, @NotNull NamespacedKey key) throws NullPointerException {
+        return new PersistentDataTag<>(type, Objects.requireNonNull(container.get(key, bukkitType)));
+    }
+
+    public void setContainerValue(@NotNull PersistentDataContainerData container, @NotNull Player player, @NotNull NamespacedKey key) throws NullPointerException {
+        container.getTagValue(key.toString(), bukkitType.getComplexType())
+                .ifPresent(value -> player.getPersistentDataContainer().set(key, bukkitType, value));
+    }
+
+    public static Optional<BukkitPersistentTypeMapping<?, ?>> getMapping(@NotNull PersistentDataTagType type) {
+        for (BukkitPersistentTypeMapping<?, ?> mapping : PRIMITIVE_TYPE_MAPPINGS) {
+            if (mapping.type().equals(type)) {
+                return Optional.of(mapping);
+            }
+        }
+        return Optional.empty();
+    }
+
+
+}

bukkit/src/main/java/net/william278/husksync/data/BukkitSerializer.java

@@ -0,0 +1,253 @@
+/*
+ * This file is part of HuskSync, licensed under the Apache License 2.0.
+ *
+ *  Copyright (c) William278 <will27528@gmail.com>
+ *  Copyright (c) contributors
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+package net.william278.husksync.data;
+
+import net.william278.husksync.BukkitHuskSync;
+import net.william278.husksync.config.Settings;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.potion.PotionEffect;
+import org.bukkit.util.io.BukkitObjectInputStream;
+import org.bukkit.util.io.BukkitObjectOutputStream;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.yaml.snakeyaml.external.biz.base64Coder.Base64Coder;
+
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.util.Map;
+import java.util.concurrent.CompletableFuture;
+import java.util.logging.Level;
+
+public class BukkitSerializer {
+
+    /**
+     * Returns a serialized array of {@link ItemStack}s
+     *
+     * @param inventoryContents The contents of the inventory
+     * @return The serialized inventory contents
+     */
+    public static CompletableFuture<String> serializeItemStackArray(@NotNull ItemStack[] inventoryContents)
+            throws DataSerializationException {
+        return CompletableFuture.supplyAsync(() -> {
+            // Return an empty string if there is no inventory item data to serialize
+            if (inventoryContents.length == 0) {
+                return "";
+            }
+
+            // Create an output stream that will be encoded into base 64
+            ByteArrayOutputStream byteOutputStream = new ByteArrayOutputStream();
+
+            try (BukkitObjectOutputStream bukkitOutputStream = new BukkitObjectOutputStream(byteOutputStream)) {
+                // Define the length of the inventory array to serialize
+                bukkitOutputStream.writeInt(inventoryContents.length);
+
+                // Write each serialize each ItemStack to the output stream
+                final boolean persistLockedMaps = BukkitHuskSync.getInstance().getSettings().getSynchronizationFeature(Settings.SynchronizationFeature.LOCKED_MAPS);
+                for (ItemStack inventoryItem : inventoryContents) {
+                    if (persistLockedMaps) {
+                        BukkitMapHandler.persistMapData(inventoryItem);
+                    }
+                    bukkitOutputStream.writeObject(serializeItemStack(inventoryItem));
+                }
+
+                // Return encoded data, using the encoder from SnakeYaml to get a ByteArray conversion
+                return Base64Coder.encodeLines(byteOutputStream.toByteArray());
+            } catch (IOException e) {
+                BukkitHuskSync.getInstance().log(Level.SEVERE, "Failed to serialize item stack data", e);
+                throw new DataSerializationException("Failed to serialize item stack data", e);
+            }
+        });
+    }
+
+    /**
+     * Returns a {@link BukkitInventoryMap} from a serialized array of ItemStacks representing the contents of a player's inventory.
+     *
+     * @param serializedPlayerInventory The serialized {@link ItemStack} inventory array
+     * @return The deserialized ItemStacks, mapped for convenience as a {@link BukkitInventoryMap}
+     * @throws DataSerializationException If the serialized item stack array could not be deserialized
+     */
+    public static CompletableFuture<BukkitInventoryMap> deserializeInventory(@NotNull String serializedPlayerInventory)
+            throws DataSerializationException {
+        return CompletableFuture.supplyAsync(() -> new BukkitInventoryMap(deserializeItemStackArray(serializedPlayerInventory).join()));
+    }
+
+    /**
+     * Returns an array of ItemStacks from serialized inventory data.
+     *
+     * @param serializeItemStackArray The serialized {@link ItemStack} array
+     * @return The deserialized array of {@link ItemStack}s
+     * @throws DataSerializationException If the serialized item stack array could not be deserialized
+     * @implNote Empty slots will be represented by {@code null}
+     */
+    public static CompletableFuture<ItemStack[]> deserializeItemStackArray(@NotNull String serializeItemStackArray)
+            throws DataSerializationException {
+        return CompletableFuture.supplyAsync(() -> {
+            // Return empty array if there is no inventory data (set the player as having an empty inventory)
+            if (serializeItemStackArray.isEmpty()) {
+                return new ItemStack[0];
+            }
+
+            // Create a byte input stream to read the serialized data
+            try (ByteArrayInputStream byteInputStream = new ByteArrayInputStream(Base64Coder.decodeLines(serializeItemStackArray))) {
+                try (BukkitObjectInputStream bukkitInputStream = new BukkitObjectInputStream(byteInputStream)) {
+                    // Read the length of the Bukkit input stream and set the length of the array to this value
+                    ItemStack[] inventoryContents = new ItemStack[bukkitInputStream.readInt()];
+
+                    // Set the ItemStacks in the array from deserialized ItemStack data
+                    int slotIndex = 0;
+                    final boolean persistLockedMaps = BukkitHuskSync.getInstance().getSettings().getSynchronizationFeature(Settings.SynchronizationFeature.LOCKED_MAPS);
+                    for (ItemStack ignored : inventoryContents) {
+                        final ItemStack deserialized = deserializeItemStack(bukkitInputStream.readObject());
+                        if (persistLockedMaps) {
+                            BukkitMapHandler.setMapRenderer(deserialized);
+                        }
+                        inventoryContents[slotIndex] = deserialized;
+                        slotIndex++;
+                    }
+
+                    // Return the finished, serialized inventory contents
+                    return inventoryContents;
+                }
+            } catch (IOException | ClassNotFoundException e) {
+                BukkitHuskSync.getInstance().log(Level.SEVERE, "Failed to deserialize item stack data", e);
+                throw new DataSerializationException("Failed to deserialize item stack data", e);
+            }
+        });
+    }
+
+    /**
+     * Returns the serialized version of an {@link ItemStack} as a string to object Map
+     *
+     * @param item The {@link ItemStack} to serialize
+     * @return The serialized {@link ItemStack}
+     */
+    @Nullable
+    private static Map<String, Object> serializeItemStack(@Nullable ItemStack item) {
+        return item != null ? item.serialize() : null;
+    }
+
+    /**
+     * Returns the deserialized {@link ItemStack} from the Object read from the {@link BukkitObjectInputStream}
+     *
+     * @param serializedItemStack The serialized item stack; a String-Object map
+     * @return The deserialized {@link ItemStack}
+     */
+    @SuppressWarnings("unchecked") // Ignore the "Unchecked cast" warning
+    @Nullable
+    private static ItemStack deserializeItemStack(@Nullable Object serializedItemStack) {
+        return serializedItemStack != null ? ItemStack.deserialize((Map<String, Object>) serializedItemStack) : null;
+    }
+
+    /**
+     * Returns a serialized array of {@link PotionEffect}s
+     *
+     * @param potionEffects The potion effect array
+     * @return The serialized potion effects
+     */
+    public static CompletableFuture<String> serializePotionEffectArray(@NotNull PotionEffect[] potionEffects) throws DataSerializationException {
+        return CompletableFuture.supplyAsync(() -> {
+            // Return an empty string if there are no effects to serialize
+            if (potionEffects.length == 0) {
+                return "";
+            }
+
+            // Create an output stream that will be encoded into base 64
+            ByteArrayOutputStream byteOutputStream = new ByteArrayOutputStream();
+
+            try (BukkitObjectOutputStream bukkitOutputStream = new BukkitObjectOutputStream(byteOutputStream)) {
+                // Define the length of the potion effect array to serialize
+                bukkitOutputStream.writeInt(potionEffects.length);
+
+                // Write each serialize each PotionEffect to the output stream
+                for (PotionEffect potionEffect : potionEffects) {
+                    bukkitOutputStream.writeObject(serializePotionEffect(potionEffect));
+                }
+
+                // Return encoded data, using the encoder from SnakeYaml to get a ByteArray conversion
+                return Base64Coder.encodeLines(byteOutputStream.toByteArray());
+            } catch (IOException e) {
+                BukkitHuskSync.getInstance().log(Level.SEVERE, "Failed to serialize potion effect data", e);
+                throw new DataSerializationException("Failed to serialize potion effect data", e);
+            }
+        });
+    }
+
+    /**
+     * Returns an array of ItemStacks from serialized potion effect data
+     *
+     * @param potionEffectData The serialized {@link PotionEffect} array
+     * @return The {@link PotionEffect}s
+     */
+    public static CompletableFuture<PotionEffect[]> deserializePotionEffectArray(@NotNull String potionEffectData) throws DataSerializationException {
+        return CompletableFuture.supplyAsync(() -> {
+            // Return empty array if there is no potion effect data (don't apply any effects to the player)
+            if (potionEffectData.isEmpty()) {
+                return new PotionEffect[0];
+            }
+
+            // Create a byte input stream to read the serialized data
+            try (ByteArrayInputStream byteInputStream = new ByteArrayInputStream(Base64Coder.decodeLines(potionEffectData))) {
+                try (BukkitObjectInputStream bukkitInputStream = new BukkitObjectInputStream(byteInputStream)) {
+                    // Read the length of the Bukkit input stream and set the length of the array to this value
+                    PotionEffect[] potionEffects = new PotionEffect[bukkitInputStream.readInt()];
+
+                    // Set the potion effects in the array from deserialized PotionEffect data
+                    int potionIndex = 0;
+                    for (PotionEffect ignored : potionEffects) {
+                        potionEffects[potionIndex] = deserializePotionEffect(bukkitInputStream.readObject());
+                        potionIndex++;
+                    }
+
+                    // Return the finished, serialized potion effect array
+                    return potionEffects;
+                }
+            } catch (IOException | ClassNotFoundException e) {
+                BukkitHuskSync.getInstance().log(Level.SEVERE, "Failed to deserialize potion effect data", e);
+                throw new DataSerializationException("Failed to deserialize potion effects", e);
+            }
+        });
+    }
+
+    /**
+     * Returns the serialized version of an {@link ItemStack} as a string to object Map
+     *
+     * @param potionEffect The {@link ItemStack} to serialize
+     * @return The serialized {@link ItemStack}
+     */
+    @Nullable
+    private static Map<String, Object> serializePotionEffect(@Nullable PotionEffect potionEffect) {
+        return potionEffect != null ? potionEffect.serialize() : null;
+    }
+
+    /**
+     * Returns the deserialized {@link PotionEffect} from the Object read from the {@link BukkitObjectInputStream}
+     *
+     * @param serializedPotionEffect The serialized potion effect; a String-Object map
+     * @return The deserialized {@link PotionEffect}
+     */
+    @SuppressWarnings("unchecked") // Ignore the "Unchecked cast" warning
+    @Nullable
+    private static PotionEffect deserializePotionEffect(@Nullable Object serializedPotionEffect) {
+        return serializedPotionEffect != null ? new PotionEffect((Map<String, Object>) serializedPotionEffect) : null;
+    }
+
+
+}

bukkit/src/main/java/net/william278/husksync/event/BukkitDataSaveEvent.java

@@ -0,0 +1,84 @@
+/*
+ * This file is part of HuskSync, licensed under the Apache License 2.0.
+ *
+ *  Copyright (c) William278 <will27528@gmail.com>
+ *  Copyright (c) contributors
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+package net.william278.husksync.event;
+
+import net.william278.husksync.data.DataSaveCause;
+import net.william278.husksync.data.UserData;
+import net.william278.husksync.player.User;
+import org.bukkit.event.Cancellable;
+import org.bukkit.event.HandlerList;
+import org.jetbrains.annotations.NotNull;
+
+@SuppressWarnings("unused")
+public class BukkitDataSaveEvent extends BukkitEvent implements DataSaveEvent, Cancellable {
+    private static final HandlerList HANDLER_LIST = new HandlerList();
+    private boolean cancelled = false;
+    private UserData userData;
+    private final User user;
+    private final DataSaveCause saveCause;
+
+    protected BukkitDataSaveEvent(@NotNull User user, @NotNull UserData userData,
+                                  @NotNull DataSaveCause saveCause) {
+        this.user = user;
+        this.userData = userData;
+        this.saveCause = saveCause;
+    }
+
+    @Override
+    public boolean isCancelled() {
+        return cancelled;
+    }
+
+    @Override
+    public void setCancelled(boolean cancelled) {
+        this.cancelled = cancelled;
+    }
+
+    @NotNull
+    @Override
+    public User getUser() {
+        return user;
+    }
+
+    @Override
+    public @NotNull UserData getUserData() {
+        return userData;
+    }
+
+    @Override
+    public void setUserData(@NotNull UserData userData) {
+        this.userData = userData;
+    }
+
+    @Override
+    public @NotNull DataSaveCause getSaveCause() {
+        return saveCause;
+    }
+
+    @NotNull
+    @Override
+    public HandlerList getHandlers() {
+        return HANDLER_LIST;
+    }
+
+    public static HandlerList getHandlerList() {
+        return HANDLER_LIST;
+    }
+}

bukkit/src/main/java/net/william278/husksync/event/BukkitEvent.java

@@ -0,0 +1,63 @@
+/*
+ * This file is part of HuskSync, licensed under the Apache License 2.0.
+ *
+ *  Copyright (c) William278 <will27528@gmail.com>
+ *  Copyright (c) contributors
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+package net.william278.husksync.event;
+
+import net.william278.husksync.BukkitHuskSync;
+import org.bukkit.Bukkit;
+import org.bukkit.event.Event;
+import org.bukkit.event.HandlerList;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.concurrent.CompletableFuture;
+
+@SuppressWarnings("unused")
+public abstract class BukkitEvent extends Event implements net.william278.husksync.event.Event {
+
+    private static final HandlerList HANDLER_LIST = new HandlerList();
+
+    protected BukkitEvent() {
+    }
+
+    @Override
+    public CompletableFuture<net.william278.husksync.event.Event> fire() {
+        final CompletableFuture<net.william278.husksync.event.Event> eventFireFuture = new CompletableFuture<>();
+        // Don't fire events while the server is shutting down
+        if (!BukkitHuskSync.getInstance().isEnabled()) {
+            eventFireFuture.complete(this);
+        } else {
+            Bukkit.getScheduler().runTask(BukkitHuskSync.getInstance(), () -> {
+                Bukkit.getServer().getPluginManager().callEvent(this);
+                eventFireFuture.complete(this);
+            });
+        }
+        return eventFireFuture;
+    }
+
+    @NotNull
+    @Override
+    public HandlerList getHandlers() {
+        return HANDLER_LIST;
+    }
+
+    public static HandlerList getHandlerList() {
+        return HANDLER_LIST;
+    }
+
+}

bukkit/src/main/java/net/william278/husksync/event/BukkitEventCannon.java

@@ -0,0 +1,52 @@
+/*
+ * This file is part of HuskSync, licensed under the Apache License 2.0.
+ *
+ *  Copyright (c) William278 <will27528@gmail.com>
+ *  Copyright (c) contributors
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+package net.william278.husksync.event;
+
+import net.william278.husksync.data.DataSaveCause;
+import net.william278.husksync.data.UserData;
+import net.william278.husksync.player.BukkitPlayer;
+import net.william278.husksync.player.OnlineUser;
+import net.william278.husksync.player.User;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.concurrent.CompletableFuture;
+
+public class BukkitEventCannon extends EventCannon {
+
+    public BukkitEventCannon() {
+    }
+
+    @Override
+    public CompletableFuture<Event> firePreSyncEvent(@NotNull OnlineUser user, @NotNull UserData userData) {
+        return new BukkitPreSyncEvent(((BukkitPlayer) user).getPlayer(), userData).fire();
+    }
+
+    @Override
+    public CompletableFuture<Event> fireDataSaveEvent(@NotNull User user, @NotNull UserData userData,
+                                                      @NotNull DataSaveCause saveCause) {
+        return new BukkitDataSaveEvent(user, userData, saveCause).fire();
+    }
+
+    @Override
+    public void fireSyncCompleteEvent(@NotNull OnlineUser user) {
+        new BukkitSyncCompleteEvent(((BukkitPlayer) user).getPlayer()).fire();
+    }
+
+}

bukkit/src/main/java/net/william278/husksync/event/BukkitPlayerEvent.java

@@ -0,0 +1,69 @@
+/*
+ * This file is part of HuskSync, licensed under the Apache License 2.0.
+ *
+ *  Copyright (c) William278 <will27528@gmail.com>
+ *  Copyright (c) contributors
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+package net.william278.husksync.event;
+
+import net.william278.husksync.BukkitHuskSync;
+import net.william278.husksync.player.BukkitPlayer;
+import net.william278.husksync.player.OnlineUser;
+import org.bukkit.Bukkit;
+import org.bukkit.entity.Player;
+import org.bukkit.event.HandlerList;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.concurrent.CompletableFuture;
+
+@SuppressWarnings("unused")
+public abstract class BukkitPlayerEvent extends BukkitEvent implements PlayerEvent {
+
+    private static final HandlerList HANDLER_LIST = new HandlerList();
+
+    protected final Player player;
+
+    protected BukkitPlayerEvent(@NotNull Player player) {
+        this.player = player;
+    }
+
+    @Override
+    public OnlineUser getUser() {
+        return BukkitPlayer.adapt(player);
+    }
+
+    @Override
+    public CompletableFuture<Event> fire() {
+        final CompletableFuture<Event> eventFireFuture = new CompletableFuture<>();
+        Bukkit.getScheduler().runTask(BukkitHuskSync.getInstance(), () -> {
+            Bukkit.getServer().getPluginManager().callEvent(this);
+            eventFireFuture.complete(this);
+        });
+        return eventFireFuture;
+    }
+
+    @NotNull
+    @Override
+    public HandlerList getHandlers() {
+        return HANDLER_LIST;
+    }
+
+    public static HandlerList getHandlerList() {
+        return HANDLER_LIST;
+    }
+
+
+}

bukkit/src/main/java/net/william278/husksync/event/BukkitPreSyncEvent.java

@@ -0,0 +1,68 @@
+/*
+ * This file is part of HuskSync, licensed under the Apache License 2.0.
+ *
+ *  Copyright (c) William278 <will27528@gmail.com>
+ *  Copyright (c) contributors
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+package net.william278.husksync.event;
+
+import net.william278.husksync.data.UserData;
+import org.bukkit.entity.Player;
+import org.bukkit.event.Cancellable;
+import org.bukkit.event.HandlerList;
+import org.jetbrains.annotations.NotNull;
+
+@SuppressWarnings("unused")
+public class BukkitPreSyncEvent extends BukkitPlayerEvent implements PreSyncEvent, Cancellable {
+    private static final HandlerList HANDLER_LIST = new HandlerList();
+    private boolean cancelled = false;
+    private UserData userData;
+
+    protected BukkitPreSyncEvent(@NotNull Player player, @NotNull UserData userData) {
+        super(player);
+        this.userData = userData;
+    }
+
+    @Override
+    public boolean isCancelled() {
+        return cancelled;
+    }
+
+    @Override
+    public void setCancelled(boolean cancelled) {
+        this.cancelled = cancelled;
+    }
+
+    @Override
+    public @NotNull UserData getUserData() {
+        return userData;
+    }
+
+    @Override
+    public void setUserData(@NotNull UserData userData) {
+        this.userData = userData;
+    }
+
+    @NotNull
+    @Override
+    public HandlerList getHandlers() {
+        return HANDLER_LIST;
+    }
+
+    public static HandlerList getHandlerList() {
+        return HANDLER_LIST;
+    }
+}

bukkit/src/main/java/net/william278/husksync/event/BukkitSyncCompleteEvent.java

@@ -0,0 +1,43 @@
+/*
+ * This file is part of HuskSync, licensed under the Apache License 2.0.
+ *
+ *  Copyright (c) William278 <will27528@gmail.com>
+ *  Copyright (c) contributors
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+package net.william278.husksync.event;
+
+import org.bukkit.entity.Player;
+import org.bukkit.event.HandlerList;
+import org.jetbrains.annotations.NotNull;
+
+@SuppressWarnings("unused")
+public class BukkitSyncCompleteEvent extends BukkitPlayerEvent implements SyncCompleteEvent {
+    private static final HandlerList HANDLER_LIST = new HandlerList();
+
+    protected BukkitSyncCompleteEvent(@NotNull Player player) {
+        super(player);
+    }
+
+    @NotNull
+    @Override
+    public HandlerList getHandlers() {
+        return HANDLER_LIST;
+    }
+
+    public static HandlerList getHandlerList() {
+        return HANDLER_LIST;
+    }
+}

bukkit/src/main/java/net/william278/husksync/listener/BukkitDeathEventListener.java

@@ -0,0 +1,56 @@
+/*
+ * This file is part of HuskSync, licensed under the Apache License 2.0.
+ *
+ *  Copyright (c) William278 <will27528@gmail.com>
+ *  Copyright (c) contributors
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+package net.william278.husksync.listener;
+
+import net.william278.husksync.config.Settings;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.Listener;
+import org.bukkit.event.entity.PlayerDeathEvent;
+import org.jetbrains.annotations.NotNull;
+
+public interface BukkitDeathEventListener extends Listener {
+
+    boolean handleEvent(@NotNull Settings.EventType type, @NotNull Settings.EventPriority priority);
+
+    @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
+    default void onPlayerDeathHighest(@NotNull PlayerDeathEvent event) {
+        if (handleEvent(Settings.EventType.DEATH_LISTENER, Settings.EventPriority.HIGHEST)) {
+            handlePlayerDeath(event);
+        }
+    }
+
+    @EventHandler(priority = EventPriority.NORMAL, ignoreCancelled = true)
+    default void onPlayerDeath(@NotNull PlayerDeathEvent event) {
+        if (handleEvent(Settings.EventType.DEATH_LISTENER, Settings.EventPriority.NORMAL)) {
+            handlePlayerDeath(event);
+        }
+    }
+
+    @EventHandler(priority = EventPriority.LOWEST, ignoreCancelled = true)
+    default void onPlayerDeathLowest(@NotNull PlayerDeathEvent event) {
+        if (handleEvent(Settings.EventType.DEATH_LISTENER, Settings.EventPriority.LOWEST)) {
+            handlePlayerDeath(event);
+        }
+    }
+
+    void handlePlayerDeath(@NotNull PlayerDeathEvent player);
+
+}

bukkit/src/main/java/net/william278/husksync/listener/BukkitEventListener.java

@@ -0,0 +1,197 @@
+/*
+ * This file is part of HuskSync, licensed under the Apache License 2.0.
+ *
+ *  Copyright (c) William278 <will27528@gmail.com>
+ *  Copyright (c) contributors
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+package net.william278.husksync.listener;
+
+import net.william278.husksync.BukkitHuskSync;
+import net.william278.husksync.config.Settings;
+import net.william278.husksync.data.BukkitInventoryMap;
+import net.william278.husksync.data.BukkitSerializer;
+import net.william278.husksync.data.ItemData;
+import net.william278.husksync.player.BukkitPlayer;
+import net.william278.husksync.player.OnlineUser;
+import org.bukkit.Bukkit;
+import org.bukkit.entity.Player;
+import org.bukkit.entity.Projectile;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.Listener;
+import org.bukkit.event.block.BlockBreakEvent;
+import org.bukkit.event.block.BlockPlaceEvent;
+import org.bukkit.event.entity.EntityDamageEvent;
+import org.bukkit.event.entity.EntityPickupItemEvent;
+import org.bukkit.event.entity.PlayerDeathEvent;
+import org.bukkit.event.entity.ProjectileLaunchEvent;
+import org.bukkit.event.inventory.InventoryClickEvent;
+import org.bukkit.event.inventory.InventoryOpenEvent;
+import org.bukkit.event.inventory.PrepareItemCraftEvent;
+import org.bukkit.event.player.PlayerCommandPreprocessEvent;
+import org.bukkit.event.player.PlayerDropItemEvent;
+import org.bukkit.event.player.PlayerInteractEntityEvent;
+import org.bukkit.event.player.PlayerInteractEvent;
+import org.bukkit.event.world.WorldSaveEvent;
+import org.bukkit.inventory.ItemStack;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.List;
+import java.util.Locale;
+import java.util.concurrent.CompletableFuture;
+import java.util.stream.Collectors;
+
+public class BukkitEventListener extends EventListener implements BukkitJoinEventListener, BukkitQuitEventListener,
+        BukkitDeathEventListener, Listener {
+    protected final List<String> blacklistedCommands;
+
+    public BukkitEventListener(@NotNull BukkitHuskSync huskSync) {
+        super(huskSync);
+        this.blacklistedCommands = huskSync.getSettings().getBlacklistedCommandsWhileLocked();
+        Bukkit.getServer().getPluginManager().registerEvents(this, huskSync);
+    }
+
+    @Override
+    public boolean handleEvent(@NotNull Settings.EventType type, @NotNull Settings.EventPriority priority) {
+        return plugin.getSettings().getEventPriority(type).equals(priority);
+    }
+
+    @Override
+    public void handlePlayerQuit(@NotNull BukkitPlayer bukkitPlayer) {
+        final Player player = bukkitPlayer.getPlayer();
+        if (!bukkitPlayer.isLocked() && !player.getItemOnCursor().getType().isAir()) {
+            player.getWorld().dropItem(player.getLocation(), player.getItemOnCursor());
+            player.setItemOnCursor(null);
+        }
+        super.handlePlayerQuit(bukkitPlayer);
+    }
+
+    @Override
+    public void handlePlayerJoin(@NotNull BukkitPlayer bukkitPlayer) {
+        super.handlePlayerJoin(bukkitPlayer);
+    }
+
+    @Override
+    public void handlePlayerDeath(@NotNull PlayerDeathEvent event) {
+        final OnlineUser user = BukkitPlayer.adapt(event.getEntity());
+
+        // If the player is locked or the plugin disabling, clear their drops
+        if (cancelPlayerEvent(user.uuid)) {
+            event.getDrops().clear();
+            return;
+        }
+
+        // Handle saving player data snapshots on death
+        if (!plugin.getSettings().doSaveOnDeath()) return;
+
+        // Truncate the drops list to the inventory size and save the player's inventory
+        final int maxInventorySize = BukkitInventoryMap.INVENTORY_SLOT_COUNT;
+        if (event.getDrops().size() > maxInventorySize) {
+            event.getDrops().subList(maxInventorySize, event.getDrops().size()).clear();
+        }
+        BukkitSerializer.serializeItemStackArray(event.getDrops().toArray(new ItemStack[0]))
+                .thenAccept(serializedDrops -> super.saveOnPlayerDeath(user, new ItemData(serializedDrops)));
+    }
+
+    @EventHandler(ignoreCancelled = true)
+    public void onWorldSave(@NotNull WorldSaveEvent event) {
+        // Handle saving player data snapshots when the world saves
+        if (!plugin.getSettings().doSaveOnWorldSave()) return;
+
+        CompletableFuture.runAsync(() -> super.saveOnWorldSave(event.getWorld().getPlayers()
+                .stream().map(BukkitPlayer::adapt)
+                .collect(Collectors.toList())));
+    }
+
+
+    /*
+     * Events to cancel if the player has not been set yet
+     */
+
+    @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
+    public void onProjectileLaunch(@NotNull ProjectileLaunchEvent event) {
+        final Projectile projectile = event.getEntity();
+        if (projectile.getShooter() instanceof Player player) {
+            event.setCancelled(cancelPlayerEvent(player.getUniqueId()));
+        }
+    }
+
+    @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
+    public void onDropItem(@NotNull PlayerDropItemEvent event) {
+        event.setCancelled(cancelPlayerEvent(event.getPlayer().getUniqueId()));
+    }
+
+    @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
+    public void onPickupItem(@NotNull EntityPickupItemEvent event) {
+        if (event.getEntity() instanceof Player player) {
+            event.setCancelled(cancelPlayerEvent(player.getUniqueId()));
+        }
+    }
+
+    @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
+    public void onPlayerInteract(@NotNull PlayerInteractEvent event) {
+        event.setCancelled(cancelPlayerEvent(event.getPlayer().getUniqueId()));
+    }
+
+    @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
+    public void onPlayerInteractEntity(@NotNull PlayerInteractEntityEvent event) {
+        event.setCancelled(cancelPlayerEvent(event.getPlayer().getUniqueId()));
+    }
+
+    @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
+    public void onBlockPlace(@NotNull BlockPlaceEvent event) {
+        event.setCancelled(cancelPlayerEvent(event.getPlayer().getUniqueId()));
+    }
+
+    @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
+    public void onBlockBreak(@NotNull BlockBreakEvent event) {
+        event.setCancelled(cancelPlayerEvent(event.getPlayer().getUniqueId()));
+    }
+
+    @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
+    public void onInventoryOpen(@NotNull InventoryOpenEvent event) {
+        if (event.getPlayer() instanceof Player player) {
+            event.setCancelled(cancelPlayerEvent(player.getUniqueId()));
+        }
+    }
+
+    @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
+    public void onInventoryClick(@NotNull InventoryClickEvent event) {
+        event.setCancelled(cancelPlayerEvent(event.getWhoClicked().getUniqueId()));
+    }
+
+    @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
+    public void onCraftItem(@NotNull PrepareItemCraftEvent event) {
+    }
+
+    @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
+    public void onPlayerTakeDamage(@NotNull EntityDamageEvent event) {
+        if (event.getEntity() instanceof Player player) {
+            event.setCancelled(cancelPlayerEvent(player.getUniqueId()));
+        }
+    }
+
+    @EventHandler(priority = EventPriority.LOW, ignoreCancelled = true)
+    public void onPermissionCommand(@NotNull PlayerCommandPreprocessEvent event) {
+        String[] commandArgs = event.getMessage().substring(1).split(" ");
+        String commandLabel = commandArgs[0].toLowerCase(Locale.ENGLISH);
+
+        if (blacklistedCommands.contains("*") || blacklistedCommands.contains(commandLabel)) {
+            event.setCancelled(cancelPlayerEvent(event.getPlayer().getUniqueId()));
+        }
+    }
+
+}

bukkit/src/main/java/net/william278/husksync/listener/BukkitJoinEventListener.java

@@ -0,0 +1,57 @@
+/*
+ * This file is part of HuskSync, licensed under the Apache License 2.0.
+ *
+ *  Copyright (c) William278 <will27528@gmail.com>
+ *  Copyright (c) contributors
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+package net.william278.husksync.listener;
+
+import net.william278.husksync.config.Settings;
+import net.william278.husksync.player.BukkitPlayer;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.Listener;
+import org.bukkit.event.player.PlayerJoinEvent;
+import org.jetbrains.annotations.NotNull;
+
+public interface BukkitJoinEventListener extends Listener {
+
+    boolean handleEvent(@NotNull Settings.EventType type, @NotNull Settings.EventPriority priority);
+
+    @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
+    default void onPlayerJoinHighest(@NotNull PlayerJoinEvent event) {
+        if (handleEvent(Settings.EventType.JOIN_LISTENER, Settings.EventPriority.HIGHEST)) {
+            handlePlayerJoin(BukkitPlayer.adapt(event.getPlayer()));
+        }
+    }
+
+    @EventHandler(priority = EventPriority.NORMAL, ignoreCancelled = true)
+    default void onPlayerJoin(@NotNull PlayerJoinEvent event) {
+        if (handleEvent(Settings.EventType.JOIN_LISTENER, Settings.EventPriority.NORMAL)) {
+            handlePlayerJoin(BukkitPlayer.adapt(event.getPlayer()));
+        }
+    }
+
+    @EventHandler(priority = EventPriority.LOWEST, ignoreCancelled = true)
+    default void onPlayerJoinLowest(@NotNull PlayerJoinEvent event) {
+        if (handleEvent(Settings.EventType.JOIN_LISTENER, Settings.EventPriority.LOWEST)) {
+            handlePlayerJoin(BukkitPlayer.adapt(event.getPlayer()));
+        }
+    }
+
+    void handlePlayerJoin(@NotNull BukkitPlayer player);
+
+}

bukkit/src/main/java/net/william278/husksync/listener/BukkitQuitEventListener.java

@@ -0,0 +1,57 @@
+/*
+ * This file is part of HuskSync, licensed under the Apache License 2.0.
+ *
+ *  Copyright (c) William278 <will27528@gmail.com>
+ *  Copyright (c) contributors
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+package net.william278.husksync.listener;
+
+import net.william278.husksync.config.Settings;
+import net.william278.husksync.player.BukkitPlayer;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.Listener;
+import org.bukkit.event.player.PlayerQuitEvent;
+import org.jetbrains.annotations.NotNull;
+
+public interface BukkitQuitEventListener extends Listener {
+
+    boolean handleEvent(@NotNull Settings.EventType type, @NotNull Settings.EventPriority priority);
+
+    @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
+    default void onPlayerQuitHighest(@NotNull PlayerQuitEvent event) {
+        if (handleEvent(Settings.EventType.QUIT_LISTENER, Settings.EventPriority.HIGHEST)) {
+            handlePlayerQuit(BukkitPlayer.adapt(event.getPlayer()));
+        }
+    }
+
+    @EventHandler(priority = EventPriority.NORMAL, ignoreCancelled = true)
+    default void onPlayerQuit(@NotNull PlayerQuitEvent event) {
+        if (handleEvent(Settings.EventType.QUIT_LISTENER, Settings.EventPriority.NORMAL)) {
+            handlePlayerQuit(BukkitPlayer.adapt(event.getPlayer()));
+        }
+    }
+
+    @EventHandler(priority = EventPriority.LOWEST, ignoreCancelled = true)
+    default void onPlayerQuitLowest(@NotNull PlayerQuitEvent event) {
+        if (handleEvent(Settings.EventType.QUIT_LISTENER, Settings.EventPriority.LOWEST)) {
+            handlePlayerQuit(BukkitPlayer.adapt(event.getPlayer()));
+        }
+    }
+
+    void handlePlayerQuit(@NotNull BukkitPlayer player);
+
+}

bukkit/src/main/java/net/william278/husksync/migrator/LegacyMigrator.java

@@ -0,0 +1,356 @@
+/*
+ * This file is part of HuskSync, licensed under the Apache License 2.0.
+ *
+ *  Copyright (c) William278 <will27528@gmail.com>
+ *  Copyright (c) contributors
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+package net.william278.husksync.migrator;
+
+import com.zaxxer.hikari.HikariDataSource;
+import me.william278.husksync.bukkit.data.DataSerializer;
+import net.william278.hslmigrator.HSLConverter;
+import net.william278.husksync.HuskSync;
+import net.william278.husksync.data.*;
+import net.william278.husksync.player.User;
+import org.bukkit.Material;
+import org.bukkit.Statistic;
+import org.bukkit.entity.EntityType;
+import org.jetbrains.annotations.NotNull;
+
+import java.io.IOException;
+import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.util.*;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.logging.Level;
+import java.util.regex.Pattern;
+
+public class LegacyMigrator extends Migrator {
+
+    private final HSLConverter hslConverter;
+    private String sourceHost;
+    private int sourcePort;
+    private String sourceUsername;
+    private String sourcePassword;
+    private String sourceDatabase;
+    private String sourcePlayersTable;
+    private String sourceDataTable;
+
+    private final String minecraftVersion;
+
+    public LegacyMigrator(@NotNull HuskSync plugin) {
+        super(plugin);
+        this.hslConverter = HSLConverter.getInstance();
+        this.sourceHost = plugin.getSettings().getMySqlHost();
+        this.sourcePort = plugin.getSettings().getMySqlPort();
+        this.sourceUsername = plugin.getSettings().getMySqlUsername();
+        this.sourcePassword = plugin.getSettings().getMySqlPassword();
+        this.sourceDatabase = plugin.getSettings().getMySqlDatabase();
+        this.sourcePlayersTable = "husksync_players";
+        this.sourceDataTable = "husksync_data";
+        this.minecraftVersion = plugin.getMinecraftVersion().toString();
+    }
+
+    @Override
+    public CompletableFuture<Boolean> start() {
+        plugin.log(Level.INFO, "Starting migration of legacy HuskSync v1.x data...");
+        final long startTime = System.currentTimeMillis();
+        return CompletableFuture.supplyAsync(() -> {
+            // Wipe the existing database, preparing it for data import
+            plugin.log(Level.INFO, "Preparing existing database (wiping)...");
+            plugin.getDatabase().wipeDatabase().join();
+            plugin.log(Level.INFO, "Successfully wiped user data database (took " + (System.currentTimeMillis() - startTime) + "ms)");
+
+            // Create jdbc driver connection url
+            final String jdbcUrl = "jdbc:mysql://" + sourceHost + ":" + sourcePort + "/" + sourceDatabase;
+
+            // Create a new data source for the mpdb converter
+            try (final HikariDataSource connectionPool = new HikariDataSource()) {
+                plugin.log(Level.INFO, "Establishing connection to legacy database...");
+                connectionPool.setJdbcUrl(jdbcUrl);
+                connectionPool.setUsername(sourceUsername);
+                connectionPool.setPassword(sourcePassword);
+                connectionPool.setPoolName((getIdentifier() + "_migrator_pool").toUpperCase(Locale.ENGLISH));
+
+                plugin.log(Level.INFO, "Downloading raw data from the legacy database (this might take a while)...");
+                final List<LegacyData> dataToMigrate = new ArrayList<>();
+                try (final Connection connection = connectionPool.getConnection()) {
+                    try (final PreparedStatement statement = connection.prepareStatement("""
+                            SELECT `uuid`, `username`, `inventory`, `ender_chest`, `health`, `max_health`, `health_scale`, `hunger`, `saturation`, `saturation_exhaustion`, `selected_slot`, `status_effects`, `total_experience`, `exp_level`, `exp_progress`, `game_mode`, `statistics`, `is_flying`, `advancements`, `location`
+                            FROM `%source_players_table%`
+                            INNER JOIN `%source_data_table%`
+                            ON `%source_players_table%`.`id` = `%source_data_table%`.`player_id`
+                            WHERE `username` IS NOT NULL;
+                            """.replaceAll(Pattern.quote("%source_players_table%"), sourcePlayersTable)
+                            .replaceAll(Pattern.quote("%source_data_table%"), sourceDataTable))) {
+                        try (final ResultSet resultSet = statement.executeQuery()) {
+                            int playersMigrated = 0;
+                            while (resultSet.next()) {
+                                dataToMigrate.add(new LegacyData(
+                                        new User(UUID.fromString(resultSet.getString("uuid")),
+                                                resultSet.getString("username")),
+                                        resultSet.getString("inventory"),
+                                        resultSet.getString("ender_chest"),
+                                        resultSet.getDouble("health"),
+                                        resultSet.getDouble("max_health"),
+                                        resultSet.getDouble("health_scale"),
+                                        resultSet.getInt("hunger"),
+                                        resultSet.getFloat("saturation"),
+                                        resultSet.getFloat("saturation_exhaustion"),
+                                        resultSet.getInt("selected_slot"),
+                                        resultSet.getString("status_effects"),
+                                        resultSet.getInt("total_experience"),
+                                        resultSet.getInt("exp_level"),
+                                        resultSet.getFloat("exp_progress"),
+                                        resultSet.getString("game_mode"),
+                                        resultSet.getString("statistics"),
+                                        resultSet.getBoolean("is_flying"),
+                                        resultSet.getString("advancements"),
+                                        resultSet.getString("location")
+                                ));
+                                playersMigrated++;
+                                if (playersMigrated % 50 == 0) {
+                                    plugin.log(Level.INFO, "Downloaded legacy data for " + playersMigrated + " players...");
+                                }
+                            }
+                        }
+                    }
+                }
+                plugin.log(Level.INFO, "Completed download of " + dataToMigrate.size() + " entries from the legacy database!");
+                plugin.log(Level.INFO, "Converting HuskSync 1.x data to the new user data format (this might take a while)...");
+
+                final AtomicInteger playersConverted = new AtomicInteger();
+                dataToMigrate.forEach(data -> data.toUserData(hslConverter, minecraftVersion).thenAccept(convertedData -> {
+                    plugin.getDatabase().ensureUser(data.user()).thenRun(() ->
+                            plugin.getDatabase().setUserData(data.user(), convertedData, DataSaveCause.LEGACY_MIGRATION)
+                                    .exceptionally(exception -> {
+                                        plugin.log(Level.SEVERE, "Failed to migrate legacy data for " + data.user().username + ": " + exception.getMessage());
+                                        return null;
+                                    })).join();
+
+                    playersConverted.getAndIncrement();
+                    if (playersConverted.get() % 50 == 0) {
+                        plugin.log(Level.INFO, "Converted legacy data for " + playersConverted + " players...");
+                    }
+                }).join());
+                plugin.log(Level.INFO, "Migration complete for " + dataToMigrate.size() + " users in " + ((System.currentTimeMillis() - startTime) / 1000) + " seconds!");
+                return true;
+            } catch (Exception e) {
+                plugin.log(Level.SEVERE, "Error while migrating legacy data: " + e.getMessage() + " - are your source database credentials correct?");
+                return false;
+            }
+        });
+    }
+
+    @Override
+    public void handleConfigurationCommand(@NotNull String[] args) {
+        if (args.length == 2) {
+            if (switch (args[0].toLowerCase(Locale.ENGLISH)) {
+                case "host" -> {
+                    this.sourceHost = args[1];
+                    yield true;
+                }
+                case "port" -> {
+                    try {
+                        this.sourcePort = Integer.parseInt(args[1]);
+                        yield true;
+                    } catch (NumberFormatException e) {
+                        yield false;
+                    }
+                }
+                case "username" -> {
+                    this.sourceUsername = args[1];
+                    yield true;
+                }
+                case "password" -> {
+                    this.sourcePassword = args[1];
+                    yield true;
+                }
+                case "database" -> {
+                    this.sourceDatabase = args[1];
+                    yield true;
+                }
+                case "players_table" -> {
+                    this.sourcePlayersTable = args[1];
+                    yield true;
+                }
+                case "data_table" -> {
+                    this.sourceDataTable = args[1];
+                    yield true;
+                }
+                default -> false;
+            }) {
+                plugin.log(Level.INFO, getHelpMenu());
+                plugin.log(Level.INFO, "Successfully set " + args[0] + " to " +
+                                                           obfuscateDataString(args[1]));
+            } else {
+                plugin.log(Level.INFO, "Invalid operation, could not set " + args[0] + " to " +
+                                                           obfuscateDataString(args[1]) + " (is it a valid option?)");
+            }
+        } else {
+            plugin.log(Level.INFO, getHelpMenu());
+        }
+    }
+
+    @NotNull
+    @Override
+    public String getIdentifier() {
+        return "legacy";
+    }
+
+    @NotNull
+    @Override
+    public String getName() {
+        return "HuskSync v1.x --> v2.x Migrator";
+    }
+
+    @NotNull
+    @Override
+    public String getHelpMenu() {
+        return """
+                === HuskSync v1.x --> v2.x Migration Wizard =========
+                This will migrate all user data from HuskSync v1.x to
+                HuskSync v2.x's new format. To perform the migration,
+                please follow the steps below carefully.
+                                
+                [!] Existing data in the database will be wiped. [!]
+                                
+                STEP 1] Please ensure no players are on any servers.
+                                
+                STEP 2] HuskSync will need to connect to the database
+                used to hold the existing, legacy HuskSync data.
+                If this is the same database as the one you are
+                currently using, you probably don't need to change
+                anything.
+                Please check that the credentials below are the
+                correct credentials of the source legacy HuskSync
+                database.
+                - host: %source_host%
+                - port: %source_port%
+                - username: %source_username%
+                - password: %source_password%
+                - database: %source_database%
+                - players_table: %source_players_table%
+                - data_table: %source_data_table%
+                If any of these are not correct, please correct them
+                using the command:
+                "husksync migrate legacy set <parameter> <value>"
+                (e.g.: "husksync migrate legacy set host 1.2.3.4")
+                                
+                STEP 3] HuskSync will migrate data into the database
+                tables configures in the config.yml file of this
+                server. Please make sure you're happy with this
+                before proceeding.
+                                
+                STEP 4] To start the migration, please run:
+                "husksync migrate legacy start"
+                """.replaceAll(Pattern.quote("%source_host%"), obfuscateDataString(sourceHost))
+                .replaceAll(Pattern.quote("%source_port%"), Integer.toString(sourcePort))
+                .replaceAll(Pattern.quote("%source_username%"), obfuscateDataString(sourceUsername))
+                .replaceAll(Pattern.quote("%source_password%"), obfuscateDataString(sourcePassword))
+                .replaceAll(Pattern.quote("%source_database%"), sourceDatabase)
+                .replaceAll(Pattern.quote("%source_players_table%"), sourcePlayersTable)
+                .replaceAll(Pattern.quote("%source_data_table%"), sourceDataTable);
+    }
+
+    private record LegacyData(@NotNull User user,
+                              @NotNull String serializedInventory, @NotNull String serializedEnderChest,
+                              double health, double maxHealth, double healthScale, int hunger, float saturation,
+                              float saturationExhaustion, int selectedSlot, @NotNull String serializedPotionEffects,
+                              int totalExp, int expLevel, float expProgress,
+                              @NotNull String gameMode, @NotNull String serializedStatistics, boolean isFlying,
+                              @NotNull String serializedAdvancements, @NotNull String serializedLocation) {
+
+        @NotNull
+        public CompletableFuture<UserData> toUserData(@NotNull HSLConverter converter,
+                                                      @NotNull String minecraftVersion) {
+            return CompletableFuture.supplyAsync(() -> {
+                try {
+                    final DataSerializer.StatisticData legacyStatisticData = converter
+                            .deserializeStatisticData(serializedStatistics);
+                    final StatisticsData convertedStatisticData = new StatisticsData(
+                            convertStatisticMap(legacyStatisticData.untypedStatisticValues()),
+                            convertMaterialStatisticMap(legacyStatisticData.blockStatisticValues()),
+                            convertMaterialStatisticMap(legacyStatisticData.itemStatisticValues()),
+                            convertEntityStatisticMap(legacyStatisticData.entityStatisticValues()));
+
+                    final List<AdvancementData> convertedAdvancements = converter
+                            .deserializeAdvancementData(serializedAdvancements)
+                            .stream().map(data -> new AdvancementData(data.key(), data.criteriaMap())).toList();
+
+                    final DataSerializer.PlayerLocation legacyLocationData = converter
+                            .deserializePlayerLocationData(serializedLocation);
+                    final LocationData convertedLocationData = new LocationData(
+                            legacyLocationData == null ? "world" : legacyLocationData.worldName(),
+                            UUID.randomUUID(),
+                            "NORMAL",
+                            legacyLocationData == null ? 0d : legacyLocationData.x(),
+                            legacyLocationData == null ? 64d : legacyLocationData.y(),
+                            legacyLocationData == null ? 0d : legacyLocationData.z(),
+                            legacyLocationData == null ? 90f : legacyLocationData.yaw(),
+                            legacyLocationData == null ? 180f : legacyLocationData.pitch());
+
+                    return UserData.builder(minecraftVersion)
+                            .setStatus(new StatusData(health, maxHealth, healthScale, hunger, saturation,
+                                    saturationExhaustion, selectedSlot, totalExp, expLevel, expProgress, gameMode, isFlying))
+                            .setInventory(new ItemData(serializedInventory))
+                            .setEnderChest(new ItemData(serializedEnderChest))
+                            .setPotionEffects(new PotionEffectData(serializedPotionEffects))
+                            .setAdvancements(convertedAdvancements)
+                            .setStatistics(convertedStatisticData)
+                            .setLocation(convertedLocationData)
+                            .build();
+                } catch (IOException e) {
+                    throw new RuntimeException(e);
+                }
+            });
+        }
+
+        private Map<String, Integer> convertStatisticMap(@NotNull HashMap<Statistic, Integer> rawMap) {
+            final HashMap<String, Integer> convertedMap = new HashMap<>();
+            for (Map.Entry<Statistic, Integer> entry : rawMap.entrySet()) {
+                convertedMap.put(entry.getKey().toString(), entry.getValue());
+            }
+            return convertedMap;
+        }
+
+        private Map<String, Map<String, Integer>> convertMaterialStatisticMap(@NotNull HashMap<Statistic, HashMap<Material, Integer>> rawMap) {
+            final Map<String, Map<String, Integer>> convertedMap = new HashMap<>();
+            for (Map.Entry<Statistic, HashMap<Material, Integer>> entry : rawMap.entrySet()) {
+                for (Map.Entry<Material, Integer> materialEntry : entry.getValue().entrySet()) {
+                    convertedMap.computeIfAbsent(entry.getKey().toString(), k -> new HashMap<>())
+                            .put(materialEntry.getKey().toString(), materialEntry.getValue());
+                }
+            }
+            return convertedMap;
+        }
+
+        private Map<String, Map<String, Integer>> convertEntityStatisticMap(@NotNull HashMap<Statistic, HashMap<EntityType, Integer>> rawMap) {
+            final Map<String, Map<String, Integer>> convertedMap = new HashMap<>();
+            for (Map.Entry<Statistic, HashMap<EntityType, Integer>> entry : rawMap.entrySet()) {
+                for (Map.Entry<EntityType, Integer> materialEntry : entry.getValue().entrySet()) {
+                    convertedMap.computeIfAbsent(entry.getKey().toString(), k -> new HashMap<>())
+                            .put(materialEntry.getKey().toString(), materialEntry.getValue());
+                }
+            }
+            return convertedMap;
+        }
+
+    }
+
+}

bukkit/src/main/java/net/william278/husksync/migrator/MpdbMigrator.java

@@ -0,0 +1,316 @@
+/*
+ * This file is part of HuskSync, licensed under the Apache License 2.0.
+ *
+ *  Copyright (c) William278 <will27528@gmail.com>
+ *  Copyright (c) contributors
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+package net.william278.husksync.migrator;
+
+import com.zaxxer.hikari.HikariDataSource;
+import net.william278.husksync.BukkitHuskSync;
+import net.william278.husksync.data.*;
+import net.william278.husksync.player.User;
+import net.william278.mpdbconverter.MPDBConverter;
+import org.bukkit.Bukkit;
+import org.bukkit.event.inventory.InventoryType;
+import org.bukkit.inventory.Inventory;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.plugin.Plugin;
+import org.jetbrains.annotations.NotNull;
+
+import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Locale;
+import java.util.UUID;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.logging.Level;
+import java.util.regex.Pattern;
+
+/**
+ * A migrator for migrating MySQLPlayerDataBridge data to HuskSync {@link UserData}
+ */
+public class MpdbMigrator extends Migrator {
+
+    private final MPDBConverter mpdbConverter;
+    private String sourceHost;
+    private int sourcePort;
+    private String sourceUsername;
+    private String sourcePassword;
+    private String sourceDatabase;
+    private String sourceInventoryTable;
+    private String sourceEnderChestTable;
+    private String sourceExperienceTable;
+    private final String minecraftVersion;
+
+    public MpdbMigrator(@NotNull BukkitHuskSync plugin, @NotNull Plugin mySqlPlayerDataBridge) {
+        super(plugin);
+        this.mpdbConverter = MPDBConverter.getInstance(mySqlPlayerDataBridge);
+        this.sourceHost = plugin.getSettings().getMySqlHost();
+        this.sourcePort = plugin.getSettings().getMySqlPort();
+        this.sourceUsername = plugin.getSettings().getMySqlUsername();
+        this.sourcePassword = plugin.getSettings().getMySqlPassword();
+        this.sourceDatabase = plugin.getSettings().getMySqlDatabase();
+        this.sourceInventoryTable = "mpdb_inventory";
+        this.sourceEnderChestTable = "mpdb_enderchest";
+        this.sourceExperienceTable = "mpdb_experience";
+        this.minecraftVersion = plugin.getMinecraftVersion().toString();
+
+    }
+
+    @Override
+    public CompletableFuture<Boolean> start() {
+        plugin.log(Level.INFO, "Starting migration from MySQLPlayerDataBridge to HuskSync...");
+        final long startTime = System.currentTimeMillis();
+        return CompletableFuture.supplyAsync(() -> {
+            // Wipe the existing database, preparing it for data import
+            plugin.log(Level.INFO, "Preparing existing database (wiping)...");
+            plugin.getDatabase().wipeDatabase().join();
+            plugin.log(Level.INFO, "Successfully wiped user data database (took " + (System.currentTimeMillis() - startTime) + "ms)");
+
+            // Create jdbc driver connection url
+            final String jdbcUrl = "jdbc:mysql://" + sourceHost + ":" + sourcePort + "/" + sourceDatabase;
+
+            // Create a new data source for the mpdb converter
+            try (final HikariDataSource connectionPool = new HikariDataSource()) {
+                plugin.log(Level.INFO, "Establishing connection to MySQLPlayerDataBridge database...");
+                connectionPool.setJdbcUrl(jdbcUrl);
+                connectionPool.setUsername(sourceUsername);
+                connectionPool.setPassword(sourcePassword);
+                connectionPool.setPoolName((getIdentifier() + "_migrator_pool").toUpperCase(Locale.ENGLISH));
+
+                plugin.log(Level.INFO, "Downloading raw data from the MySQLPlayerDataBridge database (this might take a while)...");
+                final List<MpdbData> dataToMigrate = new ArrayList<>();
+                try (final Connection connection = connectionPool.getConnection()) {
+                    try (final PreparedStatement statement = connection.prepareStatement("""
+                            SELECT `%source_inventory_table%`.`player_uuid`, `%source_inventory_table%`.`player_name`, `inventory`, `armor`, `enderchest`, `exp_lvl`, `exp`, `total_exp`
+                            FROM `%source_inventory_table%`
+                                INNER JOIN `%source_ender_chest_table%`
+                                    ON `%source_inventory_table%`.`player_uuid` = `%source_ender_chest_table%`.`player_uuid`
+                                INNER JOIN `%source_xp_table%`
+                                    ON `%source_inventory_table%`.`player_uuid` = `%source_xp_table%`.`player_uuid`;
+                            """.replaceAll(Pattern.quote("%source_inventory_table%"), sourceInventoryTable)
+                            .replaceAll(Pattern.quote("%source_ender_chest_table%"), sourceEnderChestTable)
+                            .replaceAll(Pattern.quote("%source_xp_table%"), sourceExperienceTable))) {
+                        try (final ResultSet resultSet = statement.executeQuery()) {
+                            int playersMigrated = 0;
+                            while (resultSet.next()) {
+                                dataToMigrate.add(new MpdbData(
+                                        new User(UUID.fromString(resultSet.getString("player_uuid")),
+                                                resultSet.getString("player_name")),
+                                        resultSet.getString("inventory"),
+                                        resultSet.getString("armor"),
+                                        resultSet.getString("enderchest"),
+                                        resultSet.getInt("exp_lvl"),
+                                        resultSet.getInt("exp"),
+                                        resultSet.getInt("total_exp")
+                                ));
+                                playersMigrated++;
+                                if (playersMigrated % 25 == 0) {
+                                    plugin.log(Level.INFO, "Downloaded MySQLPlayerDataBridge data for " + playersMigrated + " players...");
+                                }
+                            }
+                        }
+                    }
+                }
+                plugin.log(Level.INFO, "Completed download of " + dataToMigrate.size() + " entries from the MySQLPlayerDataBridge database!");
+                plugin.log(Level.INFO, "Converting raw MySQLPlayerDataBridge data to HuskSync user data (this might take a while)...");
+
+                final AtomicInteger playersConverted = new AtomicInteger();
+                dataToMigrate.forEach(data -> data.toUserData(mpdbConverter, minecraftVersion).thenAccept(convertedData -> {
+                    plugin.getDatabase().ensureUser(data.user()).thenRun(() ->
+                                    plugin.getDatabase().setUserData(data.user(), convertedData, DataSaveCause.MPDB_MIGRATION))
+                            .exceptionally(exception -> {
+                                plugin.log(Level.SEVERE, "Failed to migrate MySQLPlayerDataBridge data for " + data.user().username + ": " + exception.getMessage());
+                                return null;
+                            }).join();
+                    playersConverted.getAndIncrement();
+                    if (playersConverted.get() % 50 == 0) {
+                        plugin.log(Level.INFO, "Converted MySQLPlayerDataBridge data for " + playersConverted + " players...");
+                    }
+                }).join());
+                plugin.log(Level.INFO, "Migration complete for " + dataToMigrate.size() + " users in " + ((System.currentTimeMillis() - startTime) / 1000) + " seconds!");
+                return true;
+            } catch (Exception e) {
+                plugin.log(Level.SEVERE, "Error while migrating data: " + e.getMessage() + " - are your source database credentials correct?");
+                return false;
+            }
+        });
+    }
+
+    @Override
+    public void handleConfigurationCommand(@NotNull String[] args) {
+        if (args.length == 2) {
+            if (switch (args[0].toLowerCase(Locale.ENGLISH)) {
+                case "host" -> {
+                    this.sourceHost = args[1];
+                    yield true;
+                }
+                case "port" -> {
+                    try {
+                        this.sourcePort = Integer.parseInt(args[1]);
+                        yield true;
+                    } catch (NumberFormatException e) {
+                        yield false;
+                    }
+                }
+                case "username" -> {
+                    this.sourceUsername = args[1];
+                    yield true;
+                }
+                case "password" -> {
+                    this.sourcePassword = args[1];
+                    yield true;
+                }
+                case "database" -> {
+                    this.sourceDatabase = args[1];
+                    yield true;
+                }
+                case "inventory_table" -> {
+                    this.sourceInventoryTable = args[1];
+                    yield true;
+                }
+                case "ender_chest_table" -> {
+                    this.sourceEnderChestTable = args[1];
+                    yield true;
+                }
+                case "experience_table" -> {
+                    this.sourceExperienceTable = args[1];
+                    yield true;
+                }
+                default -> false;
+            }) {
+                plugin.log(Level.INFO, getHelpMenu());
+                plugin.log(Level.INFO, "Successfully set " + args[0] + " to " +
+                                                           obfuscateDataString(args[1]));
+            } else {
+                plugin.log(Level.INFO, "Invalid operation, could not set " + args[0] + " to " +
+                                                           obfuscateDataString(args[1]) + " (is it a valid option?)");
+            }
+        } else {
+            plugin.log(Level.INFO, getHelpMenu());
+        }
+    }
+
+    @NotNull
+    @Override
+    public String getIdentifier() {
+        return "mpdb";
+    }
+
+    @NotNull
+    @Override
+    public String getName() {
+        return "MySQLPlayerDataBridge Migrator";
+    }
+
+    @NotNull
+    @Override
+    public String getHelpMenu() {
+        return """
+                === MySQLPlayerDataBridge Migration Wizard ==========
+                This will migrate inventories, ender chests and XP
+                from the MySQLPlayerDataBridge plugin to HuskSync.
+                                
+                To prevent excessive migration times, other non-vital
+                data will not be transferred.
+                                
+                [!] Existing data in the database will be wiped. [!]
+                                
+                STEP 1] Please ensure no players are on any servers.
+                                
+                STEP 2] HuskSync will need to connect to the database
+                used to hold the source MySQLPlayerDataBridge data.
+                Please check these database parameters are OK:
+                - host: %source_host%
+                - port: %source_port%
+                - username: %source_username%
+                - password: %source_password%
+                - database: %source_database%
+                - inventory_table: %source_inventory_table%
+                - ender_chest_table: %source_ender_chest_table%
+                - experience_table: %source_xp_table%
+                If any of these are not correct, please correct them
+                using the command:
+                "husksync migrate mpdb set <parameter> <value>"
+                (e.g.: "husksync migrate mpdb set host 1.2.3.4")
+                                
+                STEP 3] HuskSync will migrate data into the database
+                tables configures in the config.yml file of this
+                server. Please make sure you're happy with this
+                before proceeding.
+                                
+                STEP 4] To start the migration, please run:
+                "husksync migrate mpdb start"
+                """.replaceAll(Pattern.quote("%source_host%"), obfuscateDataString(sourceHost))
+                .replaceAll(Pattern.quote("%source_port%"), Integer.toString(sourcePort))
+                .replaceAll(Pattern.quote("%source_username%"), obfuscateDataString(sourceUsername))
+                .replaceAll(Pattern.quote("%source_password%"), obfuscateDataString(sourcePassword))
+                .replaceAll(Pattern.quote("%source_database%"), sourceDatabase)
+                .replaceAll(Pattern.quote("%source_inventory_table%"), sourceInventoryTable)
+                .replaceAll(Pattern.quote("%source_ender_chest_table%"), sourceEnderChestTable)
+                .replaceAll(Pattern.quote("%source_xp_table%"), sourceExperienceTable);
+    }
+
+    /**
+     * Represents data exported from the MySQLPlayerDataBridge source database
+     *
+     * @param user                 The user whose data is being migrated
+     * @param serializedInventory  The serialized inventory data
+     * @param serializedArmor      The serialized armor data
+     * @param serializedEnderChest The serialized ender chest data
+     * @param expLevel             The player's current XP level
+     * @param expProgress          The player's current XP progress
+     * @param totalExp             The player's total XP score
+     */
+    private record MpdbData(@NotNull User user, @NotNull String serializedInventory,
+                            @NotNull String serializedArmor, @NotNull String serializedEnderChest,
+                            int expLevel, float expProgress, int totalExp) {
+        /**
+         * Converts exported MySQLPlayerDataBridge data into HuskSync's {@link UserData} object format
+         *
+         * @param converter The {@link MPDBConverter} to use for converting to {@link ItemStack}s
+         * @return A {@link CompletableFuture} that will resolve to the converted {@link UserData} object
+         */
+        @NotNull
+        public CompletableFuture<UserData> toUserData(@NotNull MPDBConverter converter,
+                                                      @NotNull String minecraftVersion) {
+            return CompletableFuture.supplyAsync(() -> {
+                // Combine inventory and armour
+                final Inventory inventory = Bukkit.createInventory(null, InventoryType.PLAYER);
+                inventory.setContents(converter.getItemStackFromSerializedData(serializedInventory));
+                final ItemStack[] armor = converter.getItemStackFromSerializedData(serializedArmor).clone();
+                for (int i = 36; i < 36 + armor.length; i++) {
+                    inventory.setItem(i, armor[i - 36]);
+                }
+
+                // Create user data record
+                return UserData.builder(minecraftVersion)
+                        .setStatus(new StatusData(20, 20, 0, 20, 10,
+                                1, 0, totalExp, expLevel, expProgress, "SURVIVAL",
+                                false))
+                        .setInventory(new ItemData(BukkitSerializer.serializeItemStackArray(inventory.getContents()).join()))
+                        .setEnderChest(new ItemData(BukkitSerializer.serializeItemStackArray(converter
+                                .getItemStackFromSerializedData(serializedEnderChest)).join()))
+                        .build();
+            });
+        }
+    }
+
+}

bukkit/src/main/java/net/william278/husksync/player/BukkitPlayer.java

@@ -0,0 +1,655 @@
+/*
+ * This file is part of HuskSync, licensed under the Apache License 2.0.
+ *
+ *  Copyright (c) William278 <will27528@gmail.com>
+ *  Copyright (c) contributors
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+package net.william278.husksync.player;
+
+import de.themoep.minedown.adventure.MineDown;
+import dev.triumphteam.gui.builder.gui.StorageBuilder;
+import dev.triumphteam.gui.guis.Gui;
+import dev.triumphteam.gui.guis.StorageGui;
+import net.kyori.adventure.audience.Audience;
+import net.roxeez.advancement.display.FrameType;
+import net.william278.andjam.Toast;
+import net.william278.desertwell.util.Version;
+import net.william278.husksync.BukkitHuskSync;
+import net.william278.husksync.config.Settings;
+import net.william278.husksync.data.*;
+import org.bukkit.*;
+import org.bukkit.advancement.Advancement;
+import org.bukkit.advancement.AdvancementProgress;
+import org.bukkit.attribute.Attribute;
+import org.bukkit.entity.EntityType;
+import org.bukkit.entity.Player;
+import org.bukkit.event.inventory.InventoryType;
+import org.bukkit.event.player.PlayerTeleportEvent;
+import org.bukkit.inventory.Inventory;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.inventory.PlayerInventory;
+import org.bukkit.persistence.PersistentDataContainer;
+import org.bukkit.potion.PotionEffect;
+import org.bukkit.potion.PotionEffectType;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.*;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicReference;
+import java.util.logging.Level;
+
+/**
+ * Bukkit implementation of an {@link OnlineUser}
+ */
+public class BukkitPlayer extends OnlineUser {
+
+    private final BukkitHuskSync plugin;
+    private final Player player;
+
+    private BukkitPlayer(@NotNull Player player) {
+        super(player.getUniqueId(), player.getName());
+        this.plugin = BukkitHuskSync.getInstance();
+        this.player = player;
+    }
+
+    @NotNull
+    public static BukkitPlayer adapt(@NotNull Player player) {
+        return new BukkitPlayer(player);
+    }
+
+    public Player getPlayer() {
+        return player;
+    }
+
+    @Override
+    public CompletableFuture<StatusData> getStatus() {
+        return CompletableFuture.supplyAsync(() -> {
+            final double maxHealth = getMaxHealth(player);
+            return new StatusData(Math.min(player.getHealth(), maxHealth),
+                    maxHealth,
+                    player.isHealthScaled() ? player.getHealthScale() : 0d,
+                    player.getFoodLevel(),
+                    player.getSaturation(),
+                    player.getExhaustion(),
+                    player.getInventory().getHeldItemSlot(),
+                    player.getTotalExperience(),
+                    player.getLevel(),
+                    player.getExp(),
+                    player.getGameMode().name(),
+                    player.getAllowFlight() && player.isFlying());
+        });
+    }
+
+    @Override
+    public CompletableFuture<Void> setStatus(@NotNull StatusData statusData, @NotNull Settings settings) {
+        return CompletableFuture.runAsync(() -> {
+            // Set max health
+            double currentMaxHealth = Objects.requireNonNull(player.getAttribute(Attribute.GENERIC_MAX_HEALTH)).getBaseValue();
+            if (settings.getSynchronizationFeature(Settings.SynchronizationFeature.MAX_HEALTH)) {
+                if (statusData.maxHealth != 0d) {
+                    Objects.requireNonNull(player.getAttribute(Attribute.GENERIC_MAX_HEALTH))
+                            .setBaseValue(statusData.maxHealth);
+                    currentMaxHealth = statusData.maxHealth;
+                }
+            }
+            if (settings.getSynchronizationFeature(Settings.SynchronizationFeature.HEALTH)) {
+                // Set health
+                final double currentHealth = player.getHealth();
+                if (statusData.health != currentHealth) {
+                    final double healthToSet = currentHealth > currentMaxHealth ? currentMaxHealth : statusData.health;
+                    final double maxHealth = currentMaxHealth;
+                    Bukkit.getScheduler().runTask(plugin, () -> {
+                        try {
+                            player.setHealth(Math.min(healthToSet, maxHealth));
+                        } catch (IllegalArgumentException e) {
+                            plugin.getLogger().log(Level.WARNING,
+                                    "Failed to set health of player " + player.getName() + " to " + healthToSet);
+                        }
+                    });
+                }
+
+                // Set health scale
+                try {
+                    if (statusData.healthScale != 0d) {
+                        player.setHealthScale(statusData.healthScale);
+                    } else {
+                        player.setHealthScale(statusData.maxHealth);
+                    }
+                    player.setHealthScaled(statusData.healthScale != 0D);
+                } catch (IllegalArgumentException e) {
+                    plugin.getLogger().log(Level.WARNING,
+                            "Failed to set health scale of player " + player.getName() + " to " + statusData.healthScale);
+                }
+            }
+            if (settings.getSynchronizationFeature(Settings.SynchronizationFeature.HUNGER)) {
+                player.setFoodLevel(statusData.hunger);
+                player.setSaturation(statusData.saturation);
+                player.setExhaustion(statusData.saturationExhaustion);
+            }
+            if (settings.getSynchronizationFeature(Settings.SynchronizationFeature.INVENTORIES)) {
+                player.getInventory().setHeldItemSlot(statusData.selectedItemSlot);
+            }
+            if (settings.getSynchronizationFeature(Settings.SynchronizationFeature.EXPERIENCE)) {
+                player.setTotalExperience(statusData.totalExperience);
+                player.setLevel(statusData.expLevel);
+                player.setExp(statusData.expProgress);
+            }
+            if (settings.getSynchronizationFeature(Settings.SynchronizationFeature.GAME_MODE)) {
+                Bukkit.getScheduler().runTask(plugin, () ->
+                        player.setGameMode(GameMode.valueOf(statusData.gameMode)));
+            }
+            if (settings.getSynchronizationFeature(Settings.SynchronizationFeature.LOCATION)) {
+                Bukkit.getScheduler().runTask(plugin, () -> {
+                    if (statusData.isFlying) {
+                        player.setAllowFlight(true);
+                        player.setFlying(true);
+                    }
+                    player.setFlying(false);
+                });
+            }
+        });
+    }
+
+    @Override
+    public CompletableFuture<ItemData> getInventory() {
+        final PlayerInventory inventory = player.getInventory();
+        if (inventory.isEmpty()) {
+            return CompletableFuture.completedFuture(ItemData.empty());
+        }
+        return BukkitSerializer.serializeItemStackArray(inventory.getContents())
+                .thenApply(ItemData::new);
+    }
+
+    @Override
+    public CompletableFuture<Void> setInventory(@NotNull ItemData itemData) {
+        return BukkitSerializer.deserializeInventory(itemData.serializedItems).thenApplyAsync(contents -> {
+            final CompletableFuture<Void> inventorySetFuture = new CompletableFuture<>();
+            Bukkit.getScheduler().runTask(plugin, () -> {
+                this.clearInventoryCraftingSlots();
+                player.setItemOnCursor(null);
+                player.getInventory().setContents(contents.getContents());
+                player.updateInventory();
+                inventorySetFuture.complete(null);
+            });
+            return inventorySetFuture.join();
+        });
+    }
+
+    // Clears any items the player may have in the crafting slots of their inventory
+    private void clearInventoryCraftingSlots() {
+        final Inventory inventory = player.getOpenInventory().getTopInventory();
+        if (inventory.getType() == InventoryType.CRAFTING) {
+            for (int slot = 0; slot < 5; slot++) {
+                inventory.setItem(slot, null);
+            }
+        }
+    }
+
+    @Override
+    public CompletableFuture<ItemData> getEnderChest() {
+        final Inventory enderChest = player.getEnderChest();
+        if (enderChest.isEmpty()) {
+            return CompletableFuture.completedFuture(ItemData.empty());
+        }
+        return BukkitSerializer.serializeItemStackArray(enderChest.getContents())
+                .thenApply(ItemData::new);
+    }
+
+    @Override
+    public CompletableFuture<Void> setEnderChest(@NotNull ItemData enderChestData) {
+        return BukkitSerializer.deserializeItemStackArray(enderChestData.serializedItems).thenApplyAsync(contents -> {
+            final CompletableFuture<Void> enderChestSetFuture = new CompletableFuture<>();
+            Bukkit.getScheduler().runTask(plugin, () -> {
+                player.getEnderChest().setContents(contents);
+                enderChestSetFuture.complete(null);
+            });
+            return enderChestSetFuture.join();
+        });
+    }
+
+    @Override
+    public CompletableFuture<PotionEffectData> getPotionEffects() {
+        return BukkitSerializer.serializePotionEffectArray(player.getActivePotionEffects()
+                .toArray(new PotionEffect[0])).thenApply(PotionEffectData::new);
+    }
+
+    @Override
+    public CompletableFuture<Void> setPotionEffects(@NotNull PotionEffectData potionEffectData) {
+        return BukkitSerializer.deserializePotionEffectArray(potionEffectData.serializedPotionEffects)
+                .thenApplyAsync(effects -> {
+                    final CompletableFuture<Void> potionEffectsSetFuture = new CompletableFuture<>();
+                    Bukkit.getScheduler().runTask(plugin, () -> {
+                        for (PotionEffect effect : player.getActivePotionEffects()) {
+                            player.removePotionEffect(effect.getType());
+                        }
+                        for (PotionEffect effect : effects) {
+                            player.addPotionEffect(effect);
+                        }
+                        potionEffectsSetFuture.complete(null);
+                    });
+                    return potionEffectsSetFuture.join();
+                });
+    }
+
+    @Override
+    public CompletableFuture<List<AdvancementData>> getAdvancements() {
+        return CompletableFuture.supplyAsync(() -> {
+            final Iterator<Advancement> serverAdvancements = Bukkit.getServer().advancementIterator();
+            final ArrayList<AdvancementData> advancementData = new ArrayList<>();
+
+            // Iterate through the server advancement set and add all advancements to the list
+            serverAdvancements.forEachRemaining(advancement -> {
+                final AdvancementProgress advancementProgress = player.getAdvancementProgress(advancement);
+                final Map<String, Date> awardedCriteria = new HashMap<>();
+
+                advancementProgress.getAwardedCriteria().forEach(criteriaKey -> awardedCriteria.put(criteriaKey,
+                        advancementProgress.getDateAwarded(criteriaKey)));
+
+                // Only save the advancement if criteria has been completed
+                if (!awardedCriteria.isEmpty()) {
+                    advancementData.add(new AdvancementData(advancement.getKey().toString(), awardedCriteria));
+                }
+            });
+            return advancementData;
+        });
+    }
+
+    @Override
+    public CompletableFuture<Void> setAdvancements(@NotNull List<AdvancementData> advancementData) {
+        return CompletableFuture.runAsync(() -> Bukkit.getScheduler().runTask(plugin, () -> {
+
+            // Temporarily disable advancement announcing if needed
+            boolean announceAdvancementUpdate = false;
+            if (Boolean.TRUE.equals(player.getWorld().getGameRuleValue(GameRule.ANNOUNCE_ADVANCEMENTS))) {
+                player.getWorld().setGameRule(GameRule.ANNOUNCE_ADVANCEMENTS, false);
+                announceAdvancementUpdate = true;
+            }
+            final boolean finalAnnounceAdvancementUpdate = announceAdvancementUpdate;
+
+            // Save current experience and level
+            final int experienceLevel = player.getLevel();
+            final float expProgress = player.getExp();
+
+            // Determines whether the experience might have changed warranting an update
+            final AtomicBoolean correctExperience = new AtomicBoolean(false);
+
+            // Run asynchronously as advancement setting is expensive
+            CompletableFuture.runAsync(() -> {
+                // Apply the advancements to the player
+                final Iterator<Advancement> serverAdvancements = Bukkit.getServer().advancementIterator();
+                while (serverAdvancements.hasNext()) {
+                    // Iterate through all advancements
+                    final Advancement advancement = serverAdvancements.next();
+                    final AdvancementProgress playerProgress = player.getAdvancementProgress(advancement);
+
+                    advancementData.stream().filter(record -> record.key.equals(advancement.getKey().toString())).findFirst().ifPresentOrElse(
+                            // Award all criteria that the player does not have that they do on the cache
+                            record -> {
+                                record.completedCriteria.keySet().stream()
+                                        .filter(criterion -> !playerProgress.getAwardedCriteria().contains(criterion))
+                                        .forEach(criterion -> {
+                                            Bukkit.getScheduler().runTask(plugin,
+                                                    () -> player.getAdvancementProgress(advancement).awardCriteria(criterion));
+                                            correctExperience.set(true);
+                                        });
+
+                                // Revoke all criteria that the player does have but should not
+                                new ArrayList<>(playerProgress.getAwardedCriteria()).stream().filter(criterion -> !record.completedCriteria.containsKey(criterion))
+                                        .forEach(criterion -> Bukkit.getScheduler().runTask(plugin,
+                                                () -> player.getAdvancementProgress(advancement).revokeCriteria(criterion)));
+
+                            },
+                            // Revoke the criteria as the player shouldn't have any
+                            () -> new ArrayList<>(playerProgress.getAwardedCriteria()).forEach(criterion ->
+                                    Bukkit.getScheduler().runTask(plugin,
+                                            () -> player.getAdvancementProgress(advancement).revokeCriteria(criterion))));
+
+                    // Update the player's experience in case the advancement changed that
+                    if (correctExperience.get()) {
+                        player.setLevel(experienceLevel);
+                        player.setExp(expProgress);
+                        correctExperience.set(false);
+                    }
+                }
+
+                // Re-enable announcing advancements (back on main thread again)
+                Bukkit.getScheduler().runTask(plugin, () -> {
+                    if (finalAnnounceAdvancementUpdate) {
+                        player.getWorld().setGameRule(GameRule.ANNOUNCE_ADVANCEMENTS, true);
+                    }
+                });
+            });
+        }));
+    }
+
+    @Override
+    public CompletableFuture<StatisticsData> getStatistics() {
+        return CompletableFuture.supplyAsync(() -> {
+            final Map<String, Integer> untypedStatisticValues = new HashMap<>();
+            final Map<String, Map<String, Integer>> blockStatisticValues = new HashMap<>();
+            final Map<String, Map<String, Integer>> itemStatisticValues = new HashMap<>();
+            final Map<String, Map<String, Integer>> entityStatisticValues = new HashMap<>();
+
+            for (Statistic statistic : Statistic.values()) {
+                switch (statistic.getType()) {
+                    case ITEM -> {
+                        final Map<String, Integer> itemValues = new HashMap<>();
+                        Arrays.stream(Material.values()).filter(Material::isItem)
+                                .filter(itemMaterial -> (player.getStatistic(statistic, itemMaterial)) != 0)
+                                .forEach(itemMaterial -> itemValues.put(itemMaterial.name(),
+                                        player.getStatistic(statistic, itemMaterial)));
+                        if (!itemValues.isEmpty()) {
+                            itemStatisticValues.put(statistic.name(), itemValues);
+                        }
+                    }
+                    case BLOCK -> {
+                        final Map<String, Integer> blockValues = new HashMap<>();
+                        Arrays.stream(Material.values()).filter(Material::isBlock)
+                                .filter(blockMaterial -> (player.getStatistic(statistic, blockMaterial)) != 0)
+                                .forEach(blockMaterial -> blockValues.put(blockMaterial.name(),
+                                        player.getStatistic(statistic, blockMaterial)));
+                        if (!blockValues.isEmpty()) {
+                            blockStatisticValues.put(statistic.name(), blockValues);
+                        }
+                    }
+                    case ENTITY -> {
+                        final Map<String, Integer> entityValues = new HashMap<>();
+                        Arrays.stream(EntityType.values()).filter(EntityType::isAlive)
+                                .filter(entityType -> (player.getStatistic(statistic, entityType)) != 0)
+                                .forEach(entityType -> entityValues.put(entityType.name(),
+                                        player.getStatistic(statistic, entityType)));
+                        if (!entityValues.isEmpty()) {
+                            entityStatisticValues.put(statistic.name(), entityValues);
+                        }
+                    }
+                    case UNTYPED -> {
+                        if (player.getStatistic(statistic) != 0) {
+                            untypedStatisticValues.put(statistic.name(), player.getStatistic(statistic));
+                        }
+                    }
+                }
+            }
+
+            return new StatisticsData(untypedStatisticValues, blockStatisticValues,
+                    itemStatisticValues, entityStatisticValues);
+        });
+    }
+
+    @Override
+    public CompletableFuture<Void> setStatistics(@NotNull StatisticsData statisticsData) {
+        return CompletableFuture.runAsync(() -> {
+            // Set generic statistics
+            for (String statistic : statisticsData.untypedStatistics.keySet()) {
+                try {
+                    player.setStatistic(Statistic.valueOf(statistic), statisticsData.untypedStatistics.get(statistic));
+                } catch (IllegalArgumentException e) {
+                    plugin.getLogger().log(Level.WARNING,
+                            "Failed to set generic statistic " + statistic + " for " + username);
+                }
+            }
+
+            // Set block statistics
+            for (String statistic : statisticsData.blockStatistics.keySet()) {
+                for (String blockMaterial : statisticsData.blockStatistics.get(statistic).keySet()) {
+                    try {
+                        player.setStatistic(Statistic.valueOf(statistic), Material.valueOf(blockMaterial),
+                                statisticsData.blockStatistics.get(statistic).get(blockMaterial));
+                    } catch (IllegalArgumentException e) {
+                        plugin.getLogger().log(Level.WARNING,
+                                "Failed to set " + blockMaterial + " statistic " + statistic + " for " + username);
+                    }
+                }
+            }
+
+            // Set item statistics
+            for (String statistic : statisticsData.itemStatistics.keySet()) {
+                for (String itemMaterial : statisticsData.itemStatistics.get(statistic).keySet()) {
+                    try {
+                        player.setStatistic(Statistic.valueOf(statistic), Material.valueOf(itemMaterial),
+                                statisticsData.itemStatistics.get(statistic).get(itemMaterial));
+                    } catch (IllegalArgumentException e) {
+                        plugin.getLogger().log(Level.WARNING,
+                                "Failed to set " + itemMaterial + " statistic " + statistic + " for " + username);
+                    }
+                }
+            }
+
+            // Set entity statistics
+            for (String statistic : statisticsData.entityStatistics.keySet()) {
+                for (String entityType : statisticsData.entityStatistics.get(statistic).keySet()) {
+                    try {
+                        player.setStatistic(Statistic.valueOf(statistic), EntityType.valueOf(entityType),
+                                statisticsData.entityStatistics.get(statistic).get(entityType));
+                    } catch (IllegalArgumentException e) {
+                        plugin.getLogger().log(Level.WARNING,
+                                "Failed to set " + entityType + " statistic " + statistic + " for " + username);
+                    }
+                }
+            }
+        });
+    }
+
+    @Override
+    public CompletableFuture<LocationData> getLocation() {
+        return CompletableFuture.supplyAsync(() ->
+                new LocationData(player.getWorld().getName(), player.getWorld().getUID(), player.getWorld().getEnvironment().name(),
+                        player.getLocation().getX(), player.getLocation().getY(), player.getLocation().getZ(),
+                        player.getLocation().getYaw(), player.getLocation().getPitch()));
+    }
+
+    @Override
+    public CompletableFuture<Void> setLocation(@NotNull LocationData locationData) {
+        final CompletableFuture<Void> teleportFuture = new CompletableFuture<>();
+        AtomicReference<World> bukkitWorld = new AtomicReference<>(Bukkit.getWorld(locationData.worldName));
+        if (bukkitWorld.get() == null) {
+            bukkitWorld.set(Bukkit.getWorld(locationData.worldUuid));
+        }
+        if (bukkitWorld.get() == null) {
+            Bukkit.getWorlds().stream().filter(world -> world.getEnvironment() == World.Environment
+                    .valueOf(locationData.worldEnvironment)).findFirst().ifPresent(bukkitWorld::set);
+        }
+        if (bukkitWorld.get() != null) {
+            Bukkit.getScheduler().runTask(plugin, () -> {
+                player.teleport(new Location(bukkitWorld.get(),
+                        locationData.x, locationData.y, locationData.z,
+                        locationData.yaw, locationData.pitch), PlayerTeleportEvent.TeleportCause.PLUGIN);
+                teleportFuture.complete(null);
+            });
+        }
+        return teleportFuture;
+    }
+
+    @Override
+    public CompletableFuture<PersistentDataContainerData> getPersistentDataContainer() {
+        final Map<String, PersistentDataTag<?>> persistentDataMap = new HashMap<>();
+        final PersistentDataContainer container = player.getPersistentDataContainer();
+        return CompletableFuture.supplyAsync(() -> {
+            container.getKeys().forEach(key -> {
+                BukkitPersistentTypeMapping<?, ?> type = null;
+                for (BukkitPersistentTypeMapping<?, ?> dataType : BukkitPersistentTypeMapping.PRIMITIVE_TYPE_MAPPINGS) {
+                    if (container.has(key, dataType.bukkitType())) {
+                        type = dataType;
+                        break;
+                    }
+                }
+                if (type != null) {
+                    persistentDataMap.put(key.toString(), type.getContainerValue(container, key));
+                }
+            });
+            return new PersistentDataContainerData(persistentDataMap);
+        }).exceptionally(throwable -> {
+            plugin.log(Level.WARNING,
+                    "Could not read " + player.getName() + "'s persistent data map, skipping!");
+            throwable.printStackTrace();
+            return new PersistentDataContainerData(new HashMap<>());
+        });
+    }
+
+    @Override
+    public CompletableFuture<Void> setPersistentDataContainer(@NotNull PersistentDataContainerData container) {
+        return CompletableFuture.runAsync(() -> {
+            player.getPersistentDataContainer().getKeys().forEach(namespacedKey ->
+                    player.getPersistentDataContainer().remove(namespacedKey));
+            container.getTags().forEach(keyString -> {
+                final NamespacedKey key = NamespacedKey.fromString(keyString);
+                if (key != null) {
+                    container.getTagType(keyString)
+                            .flatMap(BukkitPersistentTypeMapping::getMapping)
+                            .ifPresentOrElse(mapping -> mapping.setContainerValue(container, player, key),
+                                    () -> plugin.log(Level.WARNING,
+                                            "Could not set " + player.getName() + "'s persistent data key " + keyString +
+                                                    " as it has an invalid type. Skipping!"));
+                }
+            });
+        }).exceptionally(throwable -> {
+            plugin.log(Level.WARNING,
+                    "Could not write " + player.getName() + "'s persistent data map, skipping!");
+            throwable.printStackTrace();
+            return null;
+        });
+    }
+
+
+    @Override
+    @NotNull
+    public Audience getAudience() {
+        return plugin.getAudiences().player(player);
+    }
+
+    @Override
+    public boolean isOffline() {
+        try {
+            return player == null;
+        } catch (Exception e) {
+            e.printStackTrace();
+            throw e;
+        }
+    }
+
+    @NotNull
+    @Override
+    public Version getMinecraftVersion() {
+        return Version.fromString(Bukkit.getBukkitVersion());
+    }
+
+    @Override
+    public boolean hasPermission(@NotNull String node) {
+        return player.hasPermission(node);
+    }
+
+    @Override
+    public CompletableFuture<Optional<ItemData>> showMenu(@NotNull ItemData itemData, boolean editable,
+                                                          int minimumRows, @NotNull MineDown title) {
+        final CompletableFuture<Optional<ItemData>> updatedData = new CompletableFuture<>();
+
+        // Deserialize the item data to be shown and show it in a triumph GUI
+        BukkitSerializer.deserializeItemStackArray(itemData.serializedItems).thenAccept(items -> {
+            // Build the GUI and populate with items
+            final int itemCount = items.length;
+            final StorageBuilder guiBuilder = Gui.storage()
+                    .title(title.toComponent())
+                    .rows(Math.max(minimumRows, (int) Math.ceil(itemCount / 9.0)))
+                    .disableAllInteractions()
+                    .enableOtherActions();
+            final StorageGui gui = editable ? guiBuilder.enableAllInteractions().create() : guiBuilder.create();
+            for (int i = 0; i < itemCount; i++) {
+                if (items[i] != null) {
+                    gui.getInventory().setItem(i, items[i]);
+                }
+            }
+
+            // Complete the future with updated data (if editable) when the GUI is closed
+            gui.setCloseGuiAction(event -> {
+                if (!editable) {
+                    updatedData.complete(Optional.empty());
+                    return;
+                }
+
+                // Get and save the updated items
+                final ItemStack[] updatedItems = Arrays.copyOf(event.getPlayer().getOpenInventory()
+                        .getTopInventory().getContents().clone(), itemCount);
+                BukkitSerializer.serializeItemStackArray(updatedItems).thenAccept(serializedItems -> {
+                    if (serializedItems.equals(itemData.serializedItems)) {
+                        updatedData.complete(Optional.empty());
+                        return;
+                    }
+                    updatedData.complete(Optional.of(new ItemData(serializedItems)));
+                });
+            });
+
+            // Display the GUI (synchronously; on the main server thread)
+            Bukkit.getScheduler().runTask(plugin, () -> gui.open(player));
+        }).exceptionally(throwable -> {
+            // Handle exceptions
+            updatedData.completeExceptionally(throwable);
+            return null;
+        });
+        return updatedData;
+    }
+
+    @Override
+    public boolean isDead() {
+        return player.getHealth() <= 0;
+    }
+
+    @Override
+    public void sendToast(@NotNull MineDown title, @NotNull MineDown description,
+                          @NotNull String iconMaterial, @NotNull String backgroundType) {
+        try {
+            final Material material = Material.matchMaterial(iconMaterial);
+            Toast.builder(plugin)
+                    .setTitle(title.toComponent())
+                    .setDescription(description.toComponent())
+                    .setIcon(material != null ? material : Material.BARRIER)
+                    .setFrameType(FrameType.valueOf(backgroundType))
+                    .build()
+                    .show(player);
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
+    /**
+     * Returns a {@link Player}'s maximum health, minus any health boost effects
+     *
+     * @param player The {@link Player} to get the maximum health of
+     * @return The {@link Player}'s max health
+     */
+    private static double getMaxHealth(@NotNull Player player) {
+        double maxHealth = Objects.requireNonNull(player.getAttribute(Attribute.GENERIC_MAX_HEALTH)).getBaseValue();
+
+        // If the player has additional health bonuses from synchronised potion effects, subtract these from this number as they are synchronised separately
+        if (player.hasPotionEffect(PotionEffectType.HEALTH_BOOST) && maxHealth > 20D) {
+            PotionEffect healthBoostEffect = player.getPotionEffect(PotionEffectType.HEALTH_BOOST);
+            assert healthBoostEffect != null;
+            double healthBoostBonus = 4 * (healthBoostEffect.getAmplifier() + 1);
+            maxHealth -= healthBoostBonus;
+        }
+        return maxHealth;
+    }
+
+    @Override
+    public boolean isLocked() {
+        return plugin.getLockedPlayers().contains(player.getUniqueId());
+    }
+
+    @Override
+    public boolean isNpc() {
+        return player.hasMetadata("NPC");
+    }
+
+}

bukkit/src/main/resources/commodore/enderchest.commodore

@@ -0,0 +1,3 @@
+inventory {
+  name brigadier:string single_word;
+}

bukkit/src/main/resources/commodore/husksync.commodore

@@ -0,0 +1,5 @@
+husksync {
+  update;
+  about;
+  reload;
+}

bukkit/src/main/resources/commodore/inventory.commodore

@@ -0,0 +1,3 @@
+enderchest {
+  name brigadier:string single_word;
+}

bukkit/src/main/resources/commodore/userdata.commodore

@@ -0,0 +1,35 @@
+userdata {
+  view {
+    name brigadier:string single_word {
+      version brigadier:string single_word;
+    }
+  }
+  list {
+    name brigadier:string single_word {
+      page brigadier:integer;
+    }
+  }
+  delete {
+    name brigadier:string single_word {
+      version brigadier:string single_word;
+    }
+  }
+  restore {
+    name brigadier:string single_word {
+      version brigadier:string single_word;
+    }
+  }
+  pin {
+    name brigadier:string single_word {
+      version brigadier:string single_word;
+    }
+  }
+  dump {
+    name brigadier:string single_word {
+      version brigadier:string single_word {
+        web;
+        file;
+      }
+    }
+  }
+}

bukkit/src/main/resources/config.yml

@@ -1,22 +0,0 @@
-redis_settings:
-  host: 'localhost'
-  port: 6379
-  password: ''
-  use_ssl: false
-synchronisation_settings:
-  inventories: true
-  ender_chests: true
-  health: true
-  hunger: true
-  experience: true
-  potion_effects: true
-  statistics: true
-  game_mode: true
-  advancements: true
-  location: false
-  flight: false
-cluster_id: 'main'
-check_for_updates: true
-synchronization_timeout_retry_delay: 15
-save_on_world_save: true
-native_advancement_synchronization: false

bukkit/src/main/resources/plugin.yml

@@ -1,8 +1,30 @@
-name: HuskSync
+name: 'HuskSync'
-version: ${version}
+version: '${version}'
-main: net.william278.husksync.HuskSyncBukkit
+main: 'net.william278.husksync.BukkitHuskSync'
 api-version: 1.16
-author: William278
+author: 'William278'
-description: 'A modern, cross-server player data synchronization system'
+description: '${description}'
 website: 'https://william278.net'
-softdepend: [MysqlPlayerDataBridge]
+softdepend:
+  - 'MysqlPlayerDataBridge'
+  - 'Plan'
+libraries:
+  - 'redis.clients:jedis:${jedis_version}'
+  - 'com.mysql:mysql-connector-j:${mysql_driver_version}'
+  - 'org.mariadb.jdbc:mariadb-java-client:${mariadb_driver_version}'
+  - 'org.xerial.snappy:snappy-java:${snappy_version}'
+  - 'org.apache.commons:commons-text:${commons_text_version}'
+
+commands:
+  husksync:
+    usage: '/<command> <update/info/reload/migrate>'
+    description: 'Manage the HuskSync plugin'
+  userdata:
+    usage: '/<command> <view/list/delete/restore/pin/dump> <username> [version_uuid]'
+    description: 'View, manage & restore player userdata'
+  inventory:
+    usage: '/<command> <username> [version_uuid]'
+    description: 'View & edit a player''s inventory'
+  enderchest:
+    usage: '/<command> <username> [version_uuid]'
+    description: 'View & edit a player''s Ender Chest'

bungeecord/build.gradle

@@ -1,23 +0,0 @@
-dependencies {
-    implementation project(path: ':common')
-
-    implementation 'com.zaxxer:HikariCP:5.0.1'
-    implementation 'org.bstats:bstats-bungeecord:3.0.0'
-    implementation 'de.themoep:minedown:1.7.1-SNAPSHOT'
-    implementation 'net.byteflux:libby-bungee:1.1.5'
-
-    compileOnly 'net.md-5:bungeecord-api:1.16-R0.5-SNAPSHOT'
-}
-
-shadowJar {
-    relocate 'de.themoep', 'net.william278.husksync.libraries'
-    relocate 'net.byteflux', 'net.william278.husksync.libraries'
-    relocate 'org.bstats', 'net.william278.husksync.libraries.bstats'
-    relocate 'redis.clients', 'net.william278.husksync.libraries'
-    relocate 'org.apache', 'net.william278.husksync.libraries'
-
-    dependencies {
-        //noinspection GroovyAssignabilityCheck
-        exclude dependency(':slf4j-api')
-    }
-}

bungeecord/src/main/java/net/william278/husksync/HuskSyncBungeeCord.java

@@ -1,171 +0,0 @@
-package net.william278.husksync;
-
-import net.byteflux.libby.BungeeLibraryManager;
-import net.byteflux.libby.Library;
-import net.md_5.bungee.api.ProxyServer;
-import net.md_5.bungee.api.plugin.Plugin;
-import net.william278.husksync.bungeecord.command.BungeeCommand;
-import net.william278.husksync.bungeecord.config.ConfigLoader;
-import net.william278.husksync.bungeecord.config.ConfigManager;
-import net.william278.husksync.bungeecord.listener.BungeeEventListener;
-import net.william278.husksync.bungeecord.listener.BungeeRedisListener;
-import net.william278.husksync.bungeecord.util.BungeeLogger;
-import net.william278.husksync.bungeecord.util.BungeeUpdateChecker;
-import net.william278.husksync.migrator.MPDBMigrator;
-import net.william278.husksync.proxy.data.DataManager;
-import net.william278.husksync.redis.RedisMessage;
-import net.william278.husksync.util.Logger;
-import org.bstats.bungeecord.Metrics;
-
-import java.io.IOException;
-import java.util.HashSet;
-import java.util.Objects;
-import java.util.logging.Level;
-
-public final class HuskSyncBungeeCord extends Plugin {
-
-    // BungeeCord bStats ID (different to Bukkit)
-    private static final int METRICS_ID = 13141;
-
-    private static HuskSyncBungeeCord instance;
-
-    public static HuskSyncBungeeCord getInstance() {
-        return instance;
-    }
-
-    // Whether the plugin is ready to accept redis messages
-    public static boolean readyForRedis = false;
-
-    // Whether the plugin is in the process of disabling and should skip responding to handshake confirmations
-    public static boolean isDisabling = false;
-
-    /**
-     * Set of all the {@link Server}s that have completed the synchronisation handshake with HuskSync on the proxy
-     */
-    public static HashSet<Server> synchronisedServers;
-
-    public static DataManager dataManager;
-
-    public static MPDBMigrator mpdbMigrator;
-
-    public static BungeeRedisListener redisListener;
-
-    private Logger logger;
-
-    public Logger getBungeeLogger() {
-        return logger;
-    }
-
-    @Override
-    public void onLoad() {
-        instance = this;
-        logger = new BungeeLogger(getLogger());
-        fetchDependencies();
-    }
-
-    @Override
-    public void onEnable() {
-        // Plugin startup logic
-        synchronisedServers = new HashSet<>();
-
-        // Load config
-        ConfigManager.loadConfig();
-
-        // Load settings from config
-        ConfigLoader.loadSettings(Objects.requireNonNull(ConfigManager.getConfig()));
-
-        // Load messages
-        ConfigManager.loadMessages();
-
-        // Load locales from messages
-        ConfigLoader.loadMessageStrings(Objects.requireNonNull(ConfigManager.getMessages()));
-
-        // Do update checker
-        if (Settings.automaticUpdateChecks) {
-            new BungeeUpdateChecker(getDescription().getVersion()).logToConsole();
-        }
-
-        // Setup data manager
-        dataManager = new DataManager(getBungeeLogger(), getDataFolder());
-
-        // Ensure the data manager initialized correctly
-        if (dataManager.hasFailedInitialization) {
-            getBungeeLogger().severe("Failed to initialize the HuskSync database(s).\n" +
-                    "HuskSync will now abort loading itself (" + getProxy().getName() + ") v" + getDescription().getVersion());
-        }
-
-        // Setup player data cache
-        for (Settings.SynchronisationCluster cluster : Settings.clusters) {
-            dataManager.playerDataCache.put(cluster, new DataManager.PlayerDataCache());
-        }
-
-        // Initialize the redis listener
-        redisListener = new BungeeRedisListener();
-
-        // Register listener
-        getProxy().getPluginManager().registerListener(this, new BungeeEventListener());
-
-        // Register command
-        getProxy().getPluginManager().registerCommand(this, new BungeeCommand());
-
-        // Prepare the migrator for use if needed
-        mpdbMigrator = new MPDBMigrator(getBungeeLogger());
-
-        // Initialize bStats metrics
-        try {
-            new Metrics(this, METRICS_ID);
-        } catch (Exception e) {
-            getBungeeLogger().info("Skipped metrics initialization");
-        }
-
-        // Log to console
-        getBungeeLogger().info("Enabled HuskSync (" + getProxy().getName() + ") v" + getDescription().getVersion());
-
-        // Mark as ready for redis message processing
-        readyForRedis = true;
-    }
-
-    @Override
-    public void onDisable() {
-        // Plugin shutdown logic
-        isDisabling = true;
-
-        // Send terminating handshake message
-        for (Server server : synchronisedServers) {
-            try {
-                new RedisMessage(RedisMessage.MessageType.TERMINATE_HANDSHAKE,
-                        new RedisMessage.MessageTarget(Settings.ServerType.BUKKIT, null, server.clusterId()),
-                        server.serverUUID().toString(),
-                        ProxyServer.getInstance().getName()).send();
-            } catch (IOException e) {
-                getBungeeLogger().log(Level.SEVERE, "Failed to serialize Redis message for handshake termination", e);
-            }
-        }
-
-        dataManager.closeDatabases();
-
-        // Log to console
-        getBungeeLogger().info("Disabled HuskSync (" + getProxy().getName() + ") v" + getDescription().getVersion());
-    }
-
-    // Load dependencies
-    private void fetchDependencies() {
-        BungeeLibraryManager manager = new BungeeLibraryManager(getInstance());
-
-        Library mySqlLib = Library.builder()
-                .groupId("mysql")
-                .artifactId("mysql-connector-java")
-                .version("8.0.29")
-                .build();
-
-        Library sqLiteLib = Library.builder()
-                .groupId("org.xerial")
-                .artifactId("sqlite-jdbc")
-                .version("3.36.0.3")
-                .build();
-
-        manager.addMavenCentral();
-        manager.loadLibrary(mySqlLib);
-        manager.loadLibrary(sqLiteLib);
-    }
-}

bungeecord/src/main/java/net/william278/husksync/bungeecord/command/BungeeCommand.java

@@ -1,424 +0,0 @@
-package net.william278.husksync.bungeecord.command;
-
-import de.themoep.minedown.MineDown;
-import net.william278.husksync.HuskSyncBungeeCord;
-import net.william278.husksync.PlayerData;
-import net.william278.husksync.Server;
-import net.william278.husksync.Settings;
-import net.william278.husksync.bungeecord.config.ConfigLoader;
-import net.william278.husksync.bungeecord.config.ConfigManager;
-import net.william278.husksync.bungeecord.util.BungeeUpdateChecker;
-import net.william278.husksync.migrator.MPDBMigrator;
-import net.william278.husksync.proxy.command.HuskSyncCommand;
-import net.william278.husksync.redis.RedisMessage;
-import net.william278.husksync.util.MessageManager;
-import net.md_5.bungee.api.CommandSender;
-import net.md_5.bungee.api.ProxyServer;
-import net.md_5.bungee.api.connection.ProxiedPlayer;
-import net.md_5.bungee.api.plugin.Command;
-import net.md_5.bungee.api.plugin.TabExecutor;
-
-import java.io.IOException;
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.Locale;
-import java.util.Objects;
-import java.util.logging.Level;
-import java.util.stream.Collectors;
-
-public class BungeeCommand extends Command implements TabExecutor, HuskSyncCommand {
-
-    private final static HuskSyncBungeeCord plugin = HuskSyncBungeeCord.getInstance();
-
-    public BungeeCommand() {
-        super("husksync", null, "hs");
-    }
-
-    @Override
-    public void execute(CommandSender sender, String[] args) {
-        if (sender instanceof ProxiedPlayer player) {
-            if (HuskSyncBungeeCord.synchronisedServers.size() == 0) {
-                player.sendMessage(new MineDown(MessageManager.getMessage("error_no_servers_proxied")).toComponent());
-                return;
-            }
-            if (args.length >= 1) {
-                switch (args[0].toLowerCase(Locale.ROOT)) {
-                    case "about", "info" -> sendAboutInformation(player);
-                    case "update" -> {
-                        if (!player.hasPermission("husksync.command.inventory")) {
-                            sender.sendMessage(new MineDown(MessageManager.getMessage("error_no_permission")).toComponent());
-                            return;
-                        }
-                        sender.sendMessage(new MineDown("[Checking for HuskSync updates...](gray)").toComponent());
-                        ProxyServer.getInstance().getScheduler().runAsync(plugin, () -> {
-                            // Check Bukkit servers needing updates
-                            int updatesNeeded = 0;
-                            String bukkitBrand = "Spigot";
-                            String bukkitVersion = "1.0";
-                            for (Server server : HuskSyncBungeeCord.synchronisedServers) {
-                                BungeeUpdateChecker updateChecker = new BungeeUpdateChecker(server.huskSyncVersion());
-                                if (!updateChecker.isUpToDate()) {
-                                    updatesNeeded++;
-                                    bukkitBrand = server.serverBrand();
-                                    bukkitVersion = server.huskSyncVersion();
-                                }
-                            }
-
-                            // Check Bungee servers needing updates and send message
-                            BungeeUpdateChecker proxyUpdateChecker = new BungeeUpdateChecker(plugin.getDescription().getVersion());
-                            if (proxyUpdateChecker.isUpToDate() && updatesNeeded == 0) {
-                                sender.sendMessage(new MineDown("[HuskSync](#00fb9a bold) [| HuskSync is up-to-date, running Version " + proxyUpdateChecker.getLatestVersion() + "](#00fb9a)").toComponent());
-                            } else {
-                                sender.sendMessage(new MineDown("[HuskSync](#00fb9a bold) [| Your server(s) are not up-to-date:](#00fb9a)").toComponent());
-                                if (!proxyUpdateChecker.isUpToDate()) {
-                                    sender.sendMessage(new MineDown("[•](white) [HuskSync on the " + ProxyServer.getInstance().getName() + " proxy is outdated (Latest: " + proxyUpdateChecker.getLatestVersion() + ", Running: " + proxyUpdateChecker.getCurrentVersion() + ")](#00fb9a)").toComponent());
-                                }
-                                if (updatesNeeded > 0) {
-                                    sender.sendMessage(new MineDown("[•](white) [HuskSync on " + updatesNeeded + " connected " + bukkitBrand + " server(s) are outdated (Latest: " + proxyUpdateChecker.getLatestVersion() + ", Running: " + bukkitVersion + ")](#00fb9a)").toComponent());
-                                }
-                                sender.sendMessage(new MineDown("[•](white) [Download links:](#00fb9a) [[⏩ Spigot]](gray open_url=https://www.spigotmc.org/resources/husktowns.92672/updates) [•](#262626) [[⏩ Polymart]](gray open_url=https://polymart.org/resource/husktowns.1056/updates)").toComponent());
-                            }
-                        });
-                    }
-                    case "invsee", "openinv", "inventory" -> {
-                        if (!player.hasPermission("husksync.command.inventory")) {
-                            sender.sendMessage(new MineDown(MessageManager.getMessage("error_no_permission")).toComponent());
-                            return;
-                        }
-                        String clusterId;
-                        if (Settings.clusters.size() > 1) {
-                            if (args.length == 3) {
-                                clusterId = args[2];
-                            } else {
-                                sender.sendMessage(new MineDown(MessageManager.getMessage("error_invalid_cluster")).toComponent());
-                                return;
-                            }
-                        } else {
-                            clusterId = "main";
-                            for (Settings.SynchronisationCluster cluster : Settings.clusters) {
-                                clusterId = cluster.clusterId();
-                                break;
-                            }
-                        }
-                        if (args.length == 2 || args.length == 3) {
-                            String playerName = args[1];
-                            openInventory(player, playerName, clusterId);
-                        } else {
-                            sender.sendMessage(new MineDown(MessageManager.getMessage("error_invalid_syntax").replaceAll("%1%",
-                                    "/husksync invsee <player>")).toComponent());
-                        }
-                    }
-                    case "echest", "enderchest" -> {
-                        if (!player.hasPermission("husksync.command.ender_chest")) {
-                            sender.sendMessage(new MineDown(MessageManager.getMessage("error_no_permission")).toComponent());
-                            return;
-                        }
-                        String clusterId;
-                        if (Settings.clusters.size() > 1) {
-                            if (args.length == 3) {
-                                clusterId = args[2];
-                            } else {
-                                sender.sendMessage(new MineDown(MessageManager.getMessage("error_invalid_cluster")).toComponent());
-                                return;
-                            }
-                        } else {
-                            clusterId = "main";
-                            for (Settings.SynchronisationCluster cluster : Settings.clusters) {
-                                clusterId = cluster.clusterId();
-                                break;
-                            }
-                        }
-                        if (args.length == 2 || args.length == 3) {
-                            String playerName = args[1];
-                            openEnderChest(player, playerName, clusterId);
-                        } else {
-                            sender.sendMessage(new MineDown(MessageManager.getMessage("error_invalid_syntax")
-                                    .replaceAll("%1%", "/husksync echest <player>")).toComponent());
-                        }
-                    }
-                    case "migrate" -> {
-                        if (!player.hasPermission("husksync.command.admin")) {
-                            sender.sendMessage(new MineDown(MessageManager.getMessage("error_no_permission")).toComponent());
-                            return;
-                        }
-                        sender.sendMessage(new MineDown(MessageManager.getMessage("error_console_command_only")
-                                .replaceAll("%1%", ProxyServer.getInstance().getName())).toComponent());
-                    }
-                    case "status" -> {
-                        if (!player.hasPermission("husksync.command.admin")) {
-                            sender.sendMessage(new MineDown(MessageManager.getMessage("error_no_permission")).toComponent());
-                            return;
-                        }
-                        int playerDataSize = 0;
-                        for (Settings.SynchronisationCluster cluster : Settings.clusters) {
-                            playerDataSize += HuskSyncBungeeCord.dataManager.playerDataCache.get(cluster).playerData.size();
-                        }
-                        sender.sendMessage(new MineDown(MessageManager.PLUGIN_STATUS.toString()
-                                .replaceAll("%1%", String.valueOf(HuskSyncBungeeCord.synchronisedServers.size()))
-                                .replaceAll("%2%", String.valueOf(playerDataSize))).toComponent());
-                    }
-                    case "reload" -> {
-                        if (!player.hasPermission("husksync.command.admin")) {
-                            sender.sendMessage(new MineDown(MessageManager.getMessage("error_no_permission")).toComponent());
-                            return;
-                        }
-                        ConfigManager.loadConfig();
-                        ConfigLoader.loadSettings(Objects.requireNonNull(ConfigManager.getConfig()));
-
-                        ConfigManager.loadMessages();
-                        ConfigLoader.loadMessageStrings(Objects.requireNonNull(ConfigManager.getMessages()));
-
-                        // Send reload request to all bukkit servers
-                        try {
-                            new RedisMessage(RedisMessage.MessageType.RELOAD_CONFIG,
-                                    new RedisMessage.MessageTarget(Settings.ServerType.BUKKIT, null, null),
-                                    "reload")
-                                    .send();
-                        } catch (IOException e) {
-                            plugin.getBungeeLogger().log(Level.WARNING, "Failed to serialize reload notification message data");
-                        }
-
-                        sender.sendMessage(new MineDown(MessageManager.getMessage("reload_complete")).toComponent());
-                    }
-                    default -> sender.sendMessage(new MineDown(MessageManager.getMessage("error_invalid_syntax").replaceAll("%1%",
-                            "/husksync <about/status/invsee/echest>")).toComponent());
-                }
-            } else {
-                sendAboutInformation(player);
-            }
-        } else {
-            // Database migration wizard
-            if (args.length >= 1) {
-                if (args[0].equalsIgnoreCase("migrate")) {
-                    MPDBMigrator migrator = HuskSyncBungeeCord.mpdbMigrator;
-                    if (args.length == 1) {
-                        sender.sendMessage(new MineDown(
-                                """
-                                        === MySQLPlayerDataBridge Migration Wizard ==========
-                                        This will migrate data from the MySQLPlayerDataBridge
-                                        plugin to HuskSync.
-                                                                                
-                                        Data that will be migrated:
-                                        - Inventories
-                                        - Ender Chests
-                                        - Experience points
-                                                                                
-                                        Other non-vital data, such as current health, hunger
-                                        & potion effects will not be migrated to ensure that
-                                        migration does not take an excessive amount of time.
-                                                                                
-                                        To do this, you need to have MySqlPlayerDataBridge
-                                        and HuskSync installed on one Spigot server as well
-                                        as HuskSync installed on the proxy (which you have)
-                                                                                
-                                        >To proceed, type: husksync migrate setup""").toComponent());
-                    } else {
-                        switch (args[1].toLowerCase()) {
-                            case "setup" -> sender.sendMessage(new MineDown(
-                                    """
-                                            === MySQLPlayerDataBridge Migration Wizard ==========
-                                            The following database settings will be used.
-                                            Please make sure they match the correct settings to
-                                            access your MySQLPlayerDataBridge Data
-                                                                                            
-                                            sourceHost: %1%
-                                            sourcePort: %2%
-                                            sourceDatabase: %3%
-                                            sourceUsername: %4%
-                                            sourcePassword: %5%
-                                                                                            
-                                            sourceInventoryTableName: %6%
-                                            sourceEnderChestTableName: %7%
-                                            sourceExperienceTableName: %8%
-                                                                                        
-                                            targetCluster: %9%
-                                                                                            
-                                            To change a setting, type:
-                                            husksync migrate setting <settingName> <value>
-                                                                                            
-                                            Please ensure no players are logged in to the network
-                                            and that at least one Spigot server is online with
-                                            both HuskSync AND MySqlPlayerDataBridge installed AND
-                                            that the server has been configured with the correct
-                                            Redis credentials.
-                                                                                            
-                                            Warning: Data will be saved to your configured data
-                                            source, which is currently a %10% database.
-                                            Please make sure you are happy with this, or stop
-                                            the proxy server and edit this in config.yml
-                                                                                            
-                                            Warning: Migration will overwrite any current data
-                                            saved by HuskSync. It will not, however, delete any
-                                            data from the source MySQLPlayerDataBridge database.
-                                                                                    
-                                            >When done, type: husksync migrate start"""
-                                            .replaceAll("%1%", migrator.migrationSettings.sourceHost)
-                                            .replaceAll("%2%", String.valueOf(migrator.migrationSettings.sourcePort))
-                                            .replaceAll("%3%", migrator.migrationSettings.sourceDatabase)
-                                            .replaceAll("%4%", migrator.migrationSettings.sourceUsername)
-                                            .replaceAll("%5%", migrator.migrationSettings.sourcePassword)
-                                            .replaceAll("%6%", migrator.migrationSettings.inventoryDataTable)
-                                            .replaceAll("%7%", migrator.migrationSettings.enderChestDataTable)
-                                            .replaceAll("%8%", migrator.migrationSettings.expDataTable)
-                                            .replaceAll("%9%", migrator.migrationSettings.targetCluster)
-                                            .replaceAll("%10%", Settings.dataStorageType.toString())
-                            ).toComponent());
-                            case "setting" -> {
-                                if (args.length == 4) {
-                                    String value = args[3];
-                                    switch (args[2]) {
-                                        case "sourceHost", "host" -> migrator.migrationSettings.sourceHost = value;
-                                        case "sourcePort", "port" -> {
-                                            try {
-                                                migrator.migrationSettings.sourcePort = Integer.parseInt(value);
-                                            } catch (NumberFormatException e) {
-                                                sender.sendMessage(new MineDown("Error: Invalid value; port must be a number").toComponent());
-                                                return;
-                                            }
-                                        }
-                                        case "sourceDatabase", "database" -> migrator.migrationSettings.sourceDatabase = value;
-                                        case "sourceUsername", "username" -> migrator.migrationSettings.sourceUsername = value;
-                                        case "sourcePassword", "password" -> migrator.migrationSettings.sourcePassword = value;
-                                        case "sourceInventoryTableName", "inventoryTableName", "inventoryTable" -> migrator.migrationSettings.inventoryDataTable = value;
-                                        case "sourceEnderChestTableName", "enderChestTableName", "enderChestTable" -> migrator.migrationSettings.enderChestDataTable = value;
-                                        case "sourceExperienceTableName", "experienceTableName", "experienceTable" -> migrator.migrationSettings.expDataTable = value;
-                                        case "targetCluster", "cluster" -> migrator.migrationSettings.targetCluster = value;
-                                        default -> {
-                                            sender.sendMessage(new MineDown("Error: Invalid setting; please use \"husksync migrate setup\" to view a list").toComponent());
-                                            return;
-                                        }
-                                    }
-                                    sender.sendMessage(new MineDown("Successfully updated setting: \"" + args[2] + "\" --> \"" + value + "\"").toComponent());
-                                } else {
-                                    sender.sendMessage(new MineDown("Error: Invalid usage. Syntax: husksync migrate setting <settingName> <value>").toComponent());
-                                }
-                            }
-                            case "start" -> {
-                                sender.sendMessage(new MineDown("Starting MySQLPlayerDataBridge migration!...").toComponent());
-
-                                // If the migrator is ready, execute the migration asynchronously
-                                if (HuskSyncBungeeCord.mpdbMigrator.readyToMigrate(ProxyServer.getInstance().getOnlineCount(),
-                                        HuskSyncBungeeCord.synchronisedServers)) {
-                                    ProxyServer.getInstance().getScheduler().runAsync(plugin, () ->
-                                            HuskSyncBungeeCord.mpdbMigrator.executeMigrationOperations(HuskSyncBungeeCord.dataManager,
-                                                    HuskSyncBungeeCord.synchronisedServers, HuskSyncBungeeCord.redisListener));
-                                }
-                            }
-                            default -> sender.sendMessage(new MineDown("Error: Invalid argument for migration. Use \"husksync migrate\" to start the process").toComponent());
-                        }
-                    }
-                    return;
-                }
-            }
-            sender.sendMessage(new MineDown("Error: Invalid syntax. Usage: husksync migrate <args>").toComponent());
-        }
-    }
-
-    // View the inventory of a player specified by their name
-    private void openInventory(ProxiedPlayer viewer, String targetPlayerName, String clusterId) {
-        if (viewer.getName().equalsIgnoreCase(targetPlayerName)) {
-            viewer.sendMessage(new MineDown(MessageManager.getMessage("error_cannot_view_own_inventory")).toComponent());
-            return;
-        }
-        if (ProxyServer.getInstance().getPlayer(targetPlayerName) != null) {
-            viewer.sendMessage(new MineDown(MessageManager.getMessage("error_cannot_view_inventory_online")).toComponent());
-            return;
-        }
-        ProxyServer.getInstance().getScheduler().runAsync(plugin, () -> {
-            for (Settings.SynchronisationCluster cluster : Settings.clusters) {
-                if (!cluster.clusterId().equals(clusterId)) continue;
-                PlayerData playerData = HuskSyncBungeeCord.dataManager.getPlayerDataByName(targetPlayerName, cluster.clusterId());
-                if (playerData == null) {
-                    viewer.sendMessage(new MineDown(MessageManager.getMessage("error_invalid_player")).toComponent());
-                    return;
-                }
-                try {
-                    new RedisMessage(RedisMessage.MessageType.OPEN_INVENTORY,
-                            new RedisMessage.MessageTarget(Settings.ServerType.BUKKIT, viewer.getUniqueId(), null),
-                            targetPlayerName, RedisMessage.serialize(playerData))
-                            .send();
-                    viewer.sendMessage(new MineDown(MessageManager.getMessage("viewing_inventory_of").replaceAll("%1%",
-                            targetPlayerName)).toComponent());
-                } catch (IOException e) {
-                    plugin.getBungeeLogger().log(Level.WARNING, "Failed to serialize inventory-see player data", e);
-                }
-                return;
-            }
-            viewer.sendMessage(new MineDown(MessageManager.getMessage("error_invalid_cluster")).toComponent());
-        });
-    }
-
-    // View the ender chest of a player specified by their name
-    public void openEnderChest(ProxiedPlayer viewer, String targetPlayerName, String clusterId) {
-        if (viewer.getName().equalsIgnoreCase(targetPlayerName)) {
-            viewer.sendMessage(new MineDown(MessageManager.getMessage("error_cannot_view_own_ender_chest")).toComponent());
-            return;
-        }
-        if (ProxyServer.getInstance().getPlayer(targetPlayerName) != null) {
-            viewer.sendMessage(new MineDown(MessageManager.getMessage("error_cannot_view_ender_chest_online")).toComponent());
-            return;
-        }
-        ProxyServer.getInstance().getScheduler().runAsync(plugin, () -> {
-            for (Settings.SynchronisationCluster cluster : Settings.clusters) {
-                if (!cluster.clusterId().equals(clusterId)) continue;
-                PlayerData playerData = HuskSyncBungeeCord.dataManager.getPlayerDataByName(targetPlayerName, cluster.clusterId());
-                if (playerData == null) {
-                    viewer.sendMessage(new MineDown(MessageManager.getMessage("error_invalid_player")).toComponent());
-                    return;
-                }
-                try {
-                    new RedisMessage(RedisMessage.MessageType.OPEN_ENDER_CHEST,
-                            new RedisMessage.MessageTarget(Settings.ServerType.BUKKIT, viewer.getUniqueId(), null),
-                            targetPlayerName, RedisMessage.serialize(playerData))
-                            .send();
-                    viewer.sendMessage(new MineDown(MessageManager.getMessage("viewing_ender_chest_of").replaceAll("%1%",
-                            targetPlayerName)).toComponent());
-                } catch (IOException e) {
-                    plugin.getBungeeLogger().log(Level.WARNING, "Failed to serialize inventory-see player data", e);
-                }
-                return;
-            }
-            viewer.sendMessage(new MineDown(MessageManager.getMessage("error_invalid_cluster")).toComponent());
-        });
-    }
-
-    /**
-     * Send information about the plugin
-     *
-     * @param player The player to send it to
-     */
-    private void sendAboutInformation(ProxiedPlayer player) {
-        try {
-            new RedisMessage(RedisMessage.MessageType.SEND_PLUGIN_INFORMATION,
-                    new RedisMessage.MessageTarget(Settings.ServerType.BUKKIT, player.getUniqueId(), null),
-                    plugin.getProxy().getName(), plugin.getDescription().getVersion()).send();
-        } catch (IOException e) {
-            plugin.getBungeeLogger().log(Level.WARNING, "Failed to serialize plugin information to send", e);
-        }
-    }
-
-    // Tab completion
-    @Override
-    public Iterable<String> onTabComplete(CommandSender sender, String[] args) {
-        if (sender instanceof ProxiedPlayer player) {
-            if (args.length == 1) {
-                final ArrayList<String> subCommands = new ArrayList<>();
-                for (SubCommand subCommand : SUB_COMMANDS) {
-                    if (subCommand.permission() != null) {
-                        if (!player.hasPermission(subCommand.permission())) {
-                            continue;
-                        }
-                    }
-                    subCommands.add(subCommand.command());
-                }
-                // Automatically filter the sub commands' order in tab completion by what the player has typed
-                return subCommands.stream().filter(val -> val.startsWith(args[0]))
-                        .sorted().collect(Collectors.toList());
-            } else {
-                return Collections.emptyList();
-            }
-        }
-        return Collections.emptyList();
-    }
-
-}

bungeecord/src/main/java/net/william278/husksync/bungeecord/config/ConfigLoader.java

@@ -1,84 +0,0 @@
-package net.william278.husksync.bungeecord.config;
-
-import net.william278.husksync.HuskSyncBungeeCord;
-import net.william278.husksync.Settings;
-import net.william278.husksync.util.MessageManager;
-import net.md_5.bungee.config.Configuration;
-
-import java.util.HashMap;
-
-public class ConfigLoader {
-
-    private static final HuskSyncBungeeCord plugin = HuskSyncBungeeCord.getInstance();
-
-    private static Configuration copyDefaults(Configuration config) {
-        // Get the config version and update if needed
-        String configVersion = config.getString("config_file_version", "1.0");
-        if (configVersion.contains("-dev")) {
-            configVersion = configVersion.replaceAll("-dev", "");
-        }
-        if (!configVersion.equals(plugin.getDescription().getVersion())) {
-            if (configVersion.equalsIgnoreCase("1.0")) {
-                config.set("check_for_updates", true);
-            }
-            if (configVersion.equalsIgnoreCase("1.0") || configVersion.equalsIgnoreCase("1.0.1") || configVersion.equalsIgnoreCase("1.0.2") || configVersion.equalsIgnoreCase("1.0.3")) {
-                config.set("clusters.main.player_table", "husksync_players");
-                config.set("clusters.main.data_table", "husksync_data");
-            }
-            config.set("config_file_version", plugin.getDescription().getVersion());
-        }
-        // Save the config back
-        ConfigManager.saveConfig(config);
-        return config;
-    }
-
-    public static void loadSettings(Configuration loadedConfig) throws IllegalArgumentException {
-        Configuration config = copyDefaults(loadedConfig);
-
-        Settings.language = config.getString("language", "en-gb");
-
-        Settings.serverType = Settings.ServerType.PROXY;
-        Settings.automaticUpdateChecks = config.getBoolean("check_for_updates", true);
-        Settings.redisHost = config.getString("redis_settings.host", "localhost");
-        Settings.redisPort = config.getInt("redis_settings.port", 6379);
-        Settings.redisPassword = config.getString("redis_settings.password", "");
-        Settings.redisSSL = config.getBoolean("redis_settings.use_ssl", false);
-
-        Settings.dataStorageType = Settings.DataStorageType.valueOf(config.getString("data_storage_settings.database_type", "sqlite").toUpperCase());
-        if (Settings.dataStorageType == Settings.DataStorageType.MYSQL) {
-            Settings.mySQLHost = config.getString("data_storage_settings.mysql_settings.host", "localhost");
-            Settings.mySQLPort = config.getInt("data_storage_settings.mysql_settings.port", 3306);
-            Settings.mySQLDatabase = config.getString("data_storage_settings.mysql_settings.database", "HuskSync");
-            Settings.mySQLUsername = config.getString("data_storage_settings.mysql_settings.username", "root");
-            Settings.mySQLPassword = config.getString("data_storage_settings.mysql_settings.password", "pa55w0rd");
-            Settings.mySQLParams = config.getString("data_storage_settings.mysql_settings.params", "?autoReconnect=true&useSSL=false");
-        }
-
-        Settings.hikariMaximumPoolSize = config.getInt("data_storage_settings.hikari_pool_settings.maximum_pool_size", 10);
-        Settings.hikariMinimumIdle = config.getInt("data_storage_settings.hikari_pool_settings.minimum_idle", 10);
-        Settings.hikariMaximumLifetime = config.getLong("data_storage_settings.hikari_pool_settings.maximum_lifetime", 1800000);
-        Settings.hikariKeepAliveTime = config.getLong("data_storage_settings.hikari_pool_settings.keepalive_time", 0);
-        Settings.hikariConnectionTimeOut = config.getLong("data_storage_settings.hikari_pool_settings.connection_timeout", 5000);
-
-        Settings.bounceBackSynchronisation = config.getBoolean("bounce_back_synchronization", true);
-
-        // Read cluster data
-        Configuration section = config.getSection("clusters");
-        final String settingDatabaseName = Settings.mySQLDatabase != null ? Settings.mySQLDatabase : "HuskSync";
-        for (String clusterId : section.getKeys()) {
-            final String playerTableName = config.getString("clusters." + clusterId + ".player_table", "husksync_players");
-            final String dataTableName = config.getString("clusters." + clusterId + ".data_table", "husksync_data");
-            final String databaseName = config.getString("clusters." + clusterId + ".database", settingDatabaseName);
-            Settings.clusters.add(new Settings.SynchronisationCluster(clusterId, databaseName, playerTableName, dataTableName));
-        }
-    }
-
-    public static void loadMessageStrings(Configuration config) {
-        final HashMap<String,String> messages = new HashMap<>();
-        for (String messageId : config.getKeys()) {
-            messages.put(messageId, config.getString(messageId));
-        }
-        MessageManager.setMessages(messages);
-    }
-
-}

bungeecord/src/main/java/net/william278/husksync/bungeecord/config/ConfigManager.java

@@ -1,81 +0,0 @@
-package net.william278.husksync.bungeecord.config;
-
-import net.william278.husksync.HuskSyncBungeeCord;
-import net.william278.husksync.Settings;
-import net.md_5.bungee.config.Configuration;
-import net.md_5.bungee.config.ConfigurationProvider;
-import net.md_5.bungee.config.YamlConfiguration;
-
-import java.io.File;
-import java.io.IOException;
-import java.nio.file.Files;
-import java.util.logging.Level;
-
-public class ConfigManager {
-
-    private static final HuskSyncBungeeCord plugin = HuskSyncBungeeCord.getInstance();
-
-    public static void loadConfig() {
-        try {
-            if (!plugin.getDataFolder().exists()) {
-                if (plugin.getDataFolder().mkdir()) {
-                    plugin.getBungeeLogger().info("Created HuskSync data folder");
-                }
-            }
-            File configFile = new File(plugin.getDataFolder(), "config.yml");
-            if (!configFile.exists()) {
-                Files.copy(plugin.getResourceAsStream("proxy-config.yml"), configFile.toPath());
-                plugin.getBungeeLogger().info("Created HuskSync config file");
-            }
-        } catch (Exception e) {
-            plugin.getBungeeLogger().log(Level.CONFIG, "An exception occurred loading the configuration file", e);
-        }
-    }
-
-    public static void saveConfig(Configuration config) {
-        try {
-            ConfigurationProvider.getProvider(YamlConfiguration.class).save(config, new File(plugin.getDataFolder(), "config.yml"));
-        } catch (IOException e) {
-            plugin.getBungeeLogger().log(Level.CONFIG, "An exception occurred loading the configuration file", e);
-        }
-    }
-
-    public static void loadMessages() {
-        try {
-            if (!plugin.getDataFolder().exists()) {
-                if (plugin.getDataFolder().mkdir()) {
-                    plugin.getBungeeLogger().info("Created HuskSync data folder");
-                }
-            }
-            File messagesFile = new File(plugin.getDataFolder(), "messages_" + Settings.language + ".yml");
-            if (!messagesFile.exists()) {
-                Files.copy(plugin.getResourceAsStream("languages/" + Settings.language + ".yml"), messagesFile.toPath());
-                plugin.getBungeeLogger().info("Created HuskSync messages file");
-            }
-        } catch (Exception e) {
-            plugin.getBungeeLogger().log(Level.CONFIG, "An exception occurred loading the messages file", e);
-        }
-    }
-
-    public static Configuration getConfig() {
-        try {
-            File configFile = new File(plugin.getDataFolder(), "config.yml");
-            return ConfigurationProvider.getProvider(YamlConfiguration.class).load(configFile);
-        } catch (IOException e) {
-            plugin.getBungeeLogger().log(Level.CONFIG, "An IOException occurred fetching the configuration file", e);
-            return null;
-        }
-    }
-
-    public static Configuration getMessages() {
-        try {
-            File configFile = new File(plugin.getDataFolder(), "messages_" + Settings.language + ".yml");
-            return ConfigurationProvider.getProvider(YamlConfiguration.class).load(configFile);
-        } catch (IOException e) {
-            plugin.getBungeeLogger().log(Level.CONFIG, "An IOException occurred fetching the messages file", e);
-            return null;
-        }
-    }
-
-}
-

bungeecord/src/main/java/net/william278/husksync/bungeecord/listener/BungeeEventListener.java

@@ -1,50 +0,0 @@
-package net.william278.husksync.bungeecord.listener;
-
-import net.william278.husksync.HuskSyncBungeeCord;
-import net.william278.husksync.PlayerData;
-import net.william278.husksync.Settings;
-import net.william278.husksync.redis.RedisMessage;
-import net.md_5.bungee.api.ProxyServer;
-import net.md_5.bungee.api.connection.ProxiedPlayer;
-import net.md_5.bungee.api.event.PostLoginEvent;
-import net.md_5.bungee.api.plugin.Listener;
-import net.md_5.bungee.event.EventHandler;
-import net.md_5.bungee.event.EventPriority;
-
-import java.io.IOException;
-import java.util.Map;
-import java.util.logging.Level;
-
-public class BungeeEventListener implements Listener {
-
-    private static final HuskSyncBungeeCord plugin = HuskSyncBungeeCord.getInstance();
-
-    @EventHandler(priority = EventPriority.LOWEST)
-    public void onPostLogin(PostLoginEvent event) {
-        final ProxiedPlayer player = event.getPlayer();
-        ProxyServer.getInstance().getScheduler().runAsync(plugin, () -> {
-            // Ensure the player has data on SQL and that it is up-to-date
-            HuskSyncBungeeCord.dataManager.ensurePlayerExists(player.getUniqueId(), player.getName());
-
-            // Get the player's data from SQL
-            final Map<Settings.SynchronisationCluster, PlayerData> data = HuskSyncBungeeCord.dataManager.getPlayerData(player.getUniqueId());
-
-            // Update the player's data from SQL onto the cache
-            assert data != null;
-            for (Settings.SynchronisationCluster cluster : data.keySet()) {
-                HuskSyncBungeeCord.dataManager.playerDataCache.get(cluster).updatePlayer(data.get(cluster));
-            }
-
-            // Send a message asking the bukkit to request data on join
-            try {
-                new RedisMessage(RedisMessage.MessageType.REQUEST_DATA_ON_JOIN,
-                        new RedisMessage.MessageTarget(Settings.ServerType.BUKKIT, null, null),
-                        RedisMessage.RequestOnJoinUpdateType.ADD_REQUESTER.toString(), player.getUniqueId().toString()).send();
-            } catch (IOException e) {
-                plugin.getBungeeLogger().log(Level.SEVERE, "Failed to serialize request data on join message data");
-                e.printStackTrace();
-            }
-        });
-    }
-
-}

bungeecord/src/main/java/net/william278/husksync/bungeecord/listener/BungeeRedisListener.java

@@ -1,234 +0,0 @@
-package net.william278.husksync.bungeecord.listener;
-
-import de.themoep.minedown.MineDown;
-import net.william278.husksync.HuskSyncBungeeCord;
-import net.william278.husksync.Server;
-import net.william278.husksync.util.MessageManager;
-import net.william278.husksync.PlayerData;
-import net.william278.husksync.Settings;
-import net.william278.husksync.migrator.MPDBMigrator;
-import net.william278.husksync.redis.RedisListener;
-import net.william278.husksync.redis.RedisMessage;
-import net.md_5.bungee.api.ChatMessageType;
-import net.md_5.bungee.api.ProxyServer;
-import net.md_5.bungee.api.connection.ProxiedPlayer;
-
-import java.io.IOException;
-import java.util.Objects;
-import java.util.UUID;
-import java.util.logging.Level;
-
-public class BungeeRedisListener extends RedisListener {
-
-    private static final HuskSyncBungeeCord plugin = HuskSyncBungeeCord.getInstance();
-
-    // Initialize the listener on the bungee
-    public BungeeRedisListener() {
-        super();
-        listen();
-    }
-
-    private PlayerData getPlayerCachedData(UUID uuid, String clusterId) {
-        PlayerData data = null;
-        for (Settings.SynchronisationCluster cluster : Settings.clusters) {
-            if (cluster.clusterId().equals(clusterId)) {
-                // Get the player data from the cache
-                PlayerData cachedData = HuskSyncBungeeCord.dataManager.playerDataCache.get(cluster).getPlayer(uuid);
-                if (cachedData != null) {
-                    return cachedData;
-                }
-
-                data = Objects.requireNonNull(HuskSyncBungeeCord.dataManager.getPlayerData(uuid)).get(cluster); // Get their player data from MySQL
-                HuskSyncBungeeCord.dataManager.playerDataCache.get(cluster).updatePlayer(data); // Update the cache
-                break;
-            }
-        }
-        return data; // Return the data
-    }
-
-    /**
-     * Handle an incoming {@link RedisMessage}
-     *
-     * @param message The {@link RedisMessage} to handle
-     */
-    @Override
-    public void handleMessage(RedisMessage message) {
-        // Ignore messages destined for Bukkit servers
-        if (message.getMessageTarget().targetServerType() != Settings.ServerType.PROXY) {
-            return;
-        }
-        // Only process redis messages when ready
-        if (!HuskSyncBungeeCord.readyForRedis) {
-            return;
-        }
-
-        switch (message.getMessageType()) {
-            case PLAYER_DATA_REQUEST -> ProxyServer.getInstance().getScheduler().runAsync(plugin, () -> {
-                // Get the UUID of the requesting player
-                final UUID requestingPlayerUUID = UUID.fromString(message.getMessageData());
-                try {
-                    // Send the reply, serializing the message data
-                    new RedisMessage(RedisMessage.MessageType.PLAYER_DATA_SET,
-                            new RedisMessage.MessageTarget(Settings.ServerType.BUKKIT, requestingPlayerUUID, message.getMessageTarget().targetClusterId()),
-                            RedisMessage.serialize(getPlayerCachedData(requestingPlayerUUID, message.getMessageTarget().targetClusterId())))
-                            .send();
-
-                    // Send an update to all bukkit servers removing the player from the requester cache
-                    new RedisMessage(RedisMessage.MessageType.REQUEST_DATA_ON_JOIN,
-                            new RedisMessage.MessageTarget(Settings.ServerType.BUKKIT, null, message.getMessageTarget().targetClusterId()),
-                            RedisMessage.RequestOnJoinUpdateType.REMOVE_REQUESTER.toString(), requestingPlayerUUID.toString())
-                            .send();
-
-                    // Send synchronisation complete message
-                    ProxiedPlayer player = ProxyServer.getInstance().getPlayer(requestingPlayerUUID);
-                    if (player != null) {
-                        player.sendMessage(ChatMessageType.ACTION_BAR, new MineDown(MessageManager.getMessage("synchronisation_complete")).toComponent());
-                    }
-                } catch (IOException e) {
-                    log(Level.SEVERE, "Failed to serialize data when replying to a data request");
-                    e.printStackTrace();
-                }
-            });
-            case PLAYER_DATA_UPDATE -> ProxyServer.getInstance().getScheduler().runAsync(plugin, () -> {
-                // Deserialize the PlayerData received
-                PlayerData playerData;
-                final String serializedPlayerData = message.getMessageDataElements()[0];
-                final boolean bounceBack = Boolean.parseBoolean(message.getMessageDataElements()[1]);
-                try {
-                    playerData = (PlayerData) RedisMessage.deserialize(serializedPlayerData);
-                } catch (IOException | ClassNotFoundException e) {
-                    log(Level.SEVERE, "Failed to deserialize PlayerData when handling a player update request");
-                    e.printStackTrace();
-                    return;
-                }
-
-                // Update the data in the cache and SQL
-                for (Settings.SynchronisationCluster cluster : Settings.clusters) {
-                    if (cluster.clusterId().equals(message.getMessageTarget().targetClusterId())) {
-                        HuskSyncBungeeCord.dataManager.updatePlayerData(playerData, cluster);
-                        break;
-                    }
-                }
-
-                // Reply with the player data if they are still online (switching server)
-                if (Settings.bounceBackSynchronisation && bounceBack) {
-                    try {
-                        ProxiedPlayer player = ProxyServer.getInstance().getPlayer(playerData.getPlayerUUID());
-                        if (player != null) {
-                            new RedisMessage(RedisMessage.MessageType.PLAYER_DATA_SET,
-                                    new RedisMessage.MessageTarget(Settings.ServerType.BUKKIT, playerData.getPlayerUUID(), message.getMessageTarget().targetClusterId()),
-                                    serializedPlayerData)
-                                    .send();
-
-                            // Send synchronisation complete message
-                            player.sendMessage(ChatMessageType.ACTION_BAR, new MineDown(MessageManager.getMessage("synchronisation_complete")).toComponent());
-                        }
-                    } catch (IOException e) {
-                        log(Level.SEVERE, "Failed to re-serialize PlayerData when handling a player update request");
-                        e.printStackTrace();
-                    }
-                }
-            });
-            case CONNECTION_HANDSHAKE -> {
-                // Reply to a Bukkit server's connection handshake to complete the process
-                if (HuskSyncBungeeCord.isDisabling) return; // Return if the Proxy is disabling
-                final UUID serverUUID = UUID.fromString(message.getMessageDataElements()[0]);
-                final boolean hasMySqlPlayerDataBridge = Boolean.parseBoolean(message.getMessageDataElements()[1]);
-                final String bukkitBrand = message.getMessageDataElements()[2];
-                final String huskSyncVersion = message.getMessageDataElements()[3];
-                try {
-                    new RedisMessage(RedisMessage.MessageType.CONNECTION_HANDSHAKE,
-                            new RedisMessage.MessageTarget(Settings.ServerType.BUKKIT, null, message.getMessageTarget().targetClusterId()),
-                            serverUUID.toString(), plugin.getProxy().getName())
-                            .send();
-                    HuskSyncBungeeCord.synchronisedServers.add(
-                            new Server(serverUUID, hasMySqlPlayerDataBridge,
-                                    huskSyncVersion, bukkitBrand, message.getMessageTarget().targetClusterId()));
-                    log(Level.INFO, "Completed handshake with " + bukkitBrand + " server (" + serverUUID + ")");
-                } catch (IOException e) {
-                    log(Level.SEVERE, "Failed to serialize handshake message data");
-                    e.printStackTrace();
-                }
-            }
-            case TERMINATE_HANDSHAKE -> {
-                // Terminate the handshake with a Bukkit server
-                final UUID serverUUID = UUID.fromString(message.getMessageDataElements()[0]);
-                final String bukkitBrand = message.getMessageDataElements()[1];
-
-                // Remove a server from the synchronised server list
-                Server serverToRemove = null;
-                for (Server server : HuskSyncBungeeCord.synchronisedServers) {
-                    if (server.serverUUID().equals(serverUUID)) {
-                        serverToRemove = server;
-                        break;
-                    }
-                }
-                HuskSyncBungeeCord.synchronisedServers.remove(serverToRemove);
-                log(Level.INFO, "Terminated the handshake with " + bukkitBrand + " server (" + serverUUID + ")");
-            }
-            case DECODED_MPDB_DATA_SET -> {
-                // Deserialize the PlayerData received
-                PlayerData playerData;
-                final String serializedPlayerData = message.getMessageDataElements()[0];
-                final String playerName = message.getMessageDataElements()[1];
-                try {
-                    playerData = (PlayerData) RedisMessage.deserialize(serializedPlayerData);
-                } catch (IOException | ClassNotFoundException e) {
-                    log(Level.SEVERE, "Failed to deserialize PlayerData when handling incoming decoded MPDB data");
-                    e.printStackTrace();
-                    return;
-                }
-
-                // Get the migrator
-                MPDBMigrator migrator = HuskSyncBungeeCord.mpdbMigrator;
-
-                // Add the incoming data to the data to be saved
-                migrator.incomingPlayerData.put(playerData, playerName);
-
-                // Increment players migrated
-                migrator.playersMigrated++;
-                plugin.getBungeeLogger().log(Level.INFO, "Migrated " + migrator.playersMigrated + "/" + migrator.migratedDataSent + " players.");
-
-                // When all the data has been received, save it
-                if (migrator.migratedDataSent == migrator.playersMigrated) {
-                    ProxyServer.getInstance().getScheduler().runAsync(plugin, () -> migrator.loadIncomingData(migrator.incomingPlayerData,
-                            HuskSyncBungeeCord.dataManager));
-                }
-            }
-            case API_DATA_REQUEST -> ProxyServer.getInstance().getScheduler().runAsync(plugin, () -> {
-                final UUID playerUUID = UUID.fromString(message.getMessageDataElements()[0]);
-                final UUID requestUUID = UUID.fromString(message.getMessageDataElements()[1]);
-                try {
-                    final PlayerData data = getPlayerCachedData(playerUUID, message.getMessageTarget().targetClusterId());
-
-                    if (data == null) {
-                        new RedisMessage(RedisMessage.MessageType.API_DATA_CANCEL,
-                                new RedisMessage.MessageTarget(Settings.ServerType.BUKKIT, null, message.getMessageTarget().targetClusterId()),
-                                requestUUID.toString())
-                                .send();
-                    } else {
-                        // Send the reply alongside the request UUID, serializing the requested message data
-                        new RedisMessage(RedisMessage.MessageType.API_DATA_RETURN,
-                                new RedisMessage.MessageTarget(Settings.ServerType.BUKKIT, null, message.getMessageTarget().targetClusterId()),
-                                requestUUID.toString(),
-                                RedisMessage.serialize(data))
-                                .send();
-                    }
-                } catch (IOException e) {
-                    plugin.getBungeeLogger().log(Level.SEVERE, "Failed to serialize PlayerData requested via the API");
-                }
-            });
-        }
-    }
-
-    /**
-     * Log to console
-     *
-     * @param level   The {@link Level} to log
-     * @param message Message to log
-     */
-    @Override
-    public void log(Level level, String message) {
-        plugin.getBungeeLogger().log(level, message);
-    }
-}

bungeecord/src/main/java/net/william278/husksync/bungeecord/util/BungeeLogger.java

@@ -1,33 +0,0 @@
-package net.william278.husksync.bungeecord.util;
-
-import net.william278.husksync.util.Logger;
-
-import java.util.logging.Level;
-
-public record BungeeLogger(java.util.logging.Logger parent) implements Logger {
-
-    @Override
-    public void log(Level level, String message, Exception e) {
-        parent.log(level, message, e);
-    }
-
-    @Override
-    public void log(Level level, String message) {
-        parent.log(level, message);
-    }
-
-    @Override
-    public void info(String message) {
-        parent.info(message);
-    }
-
-    @Override
-    public void severe(String message) {
-        parent.severe(message);
-    }
-
-    @Override
-    public void config(String message) {
-        parent.config(message);
-    }
-}

bungeecord/src/main/java/net/william278/husksync/bungeecord/util/BungeeUpdateChecker.java

@@ -1,20 +0,0 @@
-package net.william278.husksync.bungeecord.util;
-
-import net.william278.husksync.HuskSyncBungeeCord;
-import net.william278.husksync.util.UpdateChecker;
-
-import java.util.logging.Level;
-
-public class BungeeUpdateChecker extends UpdateChecker {
-
-    private static final HuskSyncBungeeCord plugin = HuskSyncBungeeCord.getInstance();
-
-    public BungeeUpdateChecker(String versionToCheck) {
-        super(versionToCheck);
-    }
-
-    @Override
-    public void log(Level level, String message) {
-        plugin.getBungeeLogger().log(level, message);
-    }
-}

bungeecord/src/main/resources/bungee.yml

@@ -1,5 +0,0 @@
-name: HuskSync
-version: ${version}
-main: net.william278.husksync.HuskSyncBungeeCord
-author: William278
-description: 'A modern, cross-server player data synchronization system'

common/build.gradle

@@ -1,11 +1,40 @@
-plugins {
-    id 'java'
-}
-
 dependencies {
-    compileOnly 'com.zaxxer:HikariCP:5.0.1'
+    implementation 'commons-io:commons-io:2.13.0'
+    implementation 'de.themoep:minedown-adventure:1.7.2-SNAPSHOT'
+    implementation 'net.kyori:adventure-api:4.14.0'
+    implementation 'com.google.code.gson:gson:2.10.1'
+    implementation 'dev.dejvokep:boosted-yaml:1.3.1'
+    implementation 'net.william278:Annotaml:2.0.1'
+    implementation 'net.william278:DesertWell:2.0.4'
+    implementation 'net.william278:PagineDown:1.1'
+    implementation('com.zaxxer:HikariCP:5.0.1') {
+        exclude module: 'slf4j-api'
+    }
+
+    compileOnly 'org.jetbrains:annotations:24.0.1'
+    compileOnly 'com.github.plan-player-analytics:Plan:5.5.2272'
+    compileOnly 'redis.clients:jedis:' + jedis_version
+    compileOnly 'org.xerial.snappy:snappy-java:' + snappy_version
+    compileOnly 'org.apache.commons:commons-text:' + commons_text_version
+
+    testImplementation 'com.github.plan-player-analytics:Plan:5.5.2272'
+    testImplementation 'redis.clients:jedis:' + jedis_version
+    testImplementation 'org.xerial.snappy:snappy-java:' + snappy_version
+    testImplementation 'org.apache.commons:commons-text:' + commons_text_version
+    testCompileOnly 'dev.dejvokep:boosted-yaml:1.3.1'
+    testCompileOnly 'org.jetbrains:annotations:24.0.1'
 }
 
 shadowJar {
+    relocate 'org.apache.commons.io', 'net.william278.husksync.libraries.commons.io'
+    relocate 'com.google.gson', 'net.william278.husksync.libraries.gson'
+    relocate 'de.themoep', 'net.william278.husksync.libraries'
+    relocate 'net.kyori', 'net.william278.husksync.libraries'
+    relocate 'org.jetbrains', 'net.william278.husksync.libraries'
+    relocate 'org.intellij', 'net.william278.husksync.libraries'
     relocate 'com.zaxxer', 'net.william278.husksync.libraries'
+    relocate 'dev.dejvokep', 'net.william278.husksync.libraries'
+    relocate 'net.william278.desertwell', 'net.william278.husksync.libraries.desertwell'
+    relocate 'net.william278.paginedown', 'net.william278.husksync.libraries.paginedown'
+    relocate 'net.william278.annotaml', 'net.william278.husksync.libraries.annotaml'
 }

common/src/main/java/net/william278/husksync/HuskSync.java

@@ -0,0 +1,202 @@
+/*
+ * This file is part of HuskSync, licensed under the Apache License 2.0.
+ *
+ *  Copyright (c) William278 <will27528@gmail.com>
+ *  Copyright (c) contributors
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+package net.william278.husksync;
+
+import net.william278.desertwell.util.UpdateChecker;
+import net.william278.desertwell.util.Version;
+import net.william278.husksync.config.Locales;
+import net.william278.husksync.config.Settings;
+import net.william278.husksync.data.DataAdapter;
+import net.william278.husksync.database.Database;
+import net.william278.husksync.event.EventCannon;
+import net.william278.husksync.migrator.Migrator;
+import net.william278.husksync.player.OnlineUser;
+import net.william278.husksync.redis.RedisManager;
+import org.jetbrains.annotations.NotNull;
+
+import java.io.File;
+import java.io.InputStream;
+import java.util.List;
+import java.util.Optional;
+import java.util.Set;
+import java.util.UUID;
+import java.util.concurrent.CompletableFuture;
+import java.util.logging.Level;
+
+/**
+ * Abstract implementation of the HuskSync plugin.
+ */
+public interface HuskSync {
+
+    int SPIGOT_RESOURCE_ID = 97144;
+
+    /**
+     * Returns a set of online players.
+     *
+     * @return a set of online players as {@link OnlineUser}
+     */
+    @NotNull
+    Set<OnlineUser> getOnlineUsers();
+
+    /**
+     * Returns an online user by UUID if they exist
+     *
+     * @param uuid the UUID of the user to get
+     * @return an online user as {@link OnlineUser}
+     */
+    @NotNull
+    Optional<OnlineUser> getOnlineUser(@NotNull UUID uuid);
+
+    /**
+     * Returns the database implementation
+     *
+     * @return the {@link Database} implementation
+     */
+    @NotNull
+    Database getDatabase();
+
+    /**
+     * Returns the redis manager implementation
+     *
+     * @return the {@link RedisManager} implementation
+     */
+
+    @NotNull
+    RedisManager getRedisManager();
+
+    /**
+     * Returns the data adapter implementation
+     *
+     * @return the {@link DataAdapter} implementation
+     */
+    @NotNull
+    DataAdapter getDataAdapter();
+
+    /**
+     * Returns the event firing cannon
+     *
+     * @return the {@link EventCannon} implementation
+     */
+    @NotNull
+    EventCannon getEventCannon();
+
+    /**
+     * Returns a list of available data {@link Migrator}s
+     *
+     * @return a list of {@link Migrator}s
+     */
+    @NotNull
+    List<Migrator> getAvailableMigrators();
+
+    /**
+     * Returns the plugin {@link Settings}
+     *
+     * @return the {@link Settings}
+     */
+    @NotNull
+    Settings getSettings();
+
+    /**
+     * Returns the plugin {@link Locales}
+     *
+     * @return the {@link Locales}
+     */
+    @NotNull
+    Locales getLocales();
+
+    /**
+     * Get a resource as an {@link InputStream} from the plugin jar
+     *
+     * @param name the path to the resource
+     * @return the {@link InputStream} of the resource
+     */
+    InputStream getResource(@NotNull String name);
+
+    /**
+     * Log a message to the console
+     *
+     * @param level     the level of the message
+     * @param message   the message to log
+     * @param throwable a throwable to log
+     */
+    void log(@NotNull Level level, @NotNull String message, @NotNull Throwable... throwable);
+
+    /**
+     * Send a debug message to the console, if debug logging is enabled
+     *
+     * @param message   the message to log
+     * @param throwable a throwable to log
+     */
+    default void debug(@NotNull String message, @NotNull Throwable... throwable) {
+        if (getSettings().doDebugLogging()) {
+            log(Level.INFO, "[DEBUG] " + message, throwable);
+        }
+    }
+
+    /**
+     * Returns the plugin version
+     *
+     * @return the plugin {@link Version}
+     */
+    @NotNull
+    Version getPluginVersion();
+
+    /**
+     * Returns the plugin data folder
+     *
+     * @return the plugin data folder as a {@link File}
+     */
+    @NotNull
+    File getDataFolder();
+
+    /**
+     * Returns a future returning the latest plugin {@link Version} if the plugin is out-of-date
+     *
+     * @return a {@link CompletableFuture} returning the latest {@link Version} if the current one is out-of-date
+     */
+    default CompletableFuture<Optional<Version>> getLatestVersionIfOutdated() {
+        return UpdateChecker.builder()
+                .currentVersion(getPluginVersion())
+                .endpoint(UpdateChecker.Endpoint.SPIGOT)
+                .resource(Integer.toString(SPIGOT_RESOURCE_ID)).build()
+                .check()
+                .thenApply(checked -> checked.isUpToDate()
+                        ? Optional.empty()
+                        : Optional.of(checked.getLatestVersion()));
+    }
+
+    /**
+     * Returns the Minecraft version implementation
+     *
+     * @return the Minecraft {@link Version}
+     */
+    @NotNull
+    Version getMinecraftVersion();
+
+    /**
+     * Reloads the {@link Settings} and {@link Locales} from their respective config files
+     *
+     * @return a {@link CompletableFuture} that will be completed when the plugin reload is complete and if it was successful
+     */
+    CompletableFuture<Boolean> reload();
+
+    Set<UUID> getLockedPlayers();
+
+}

common/src/main/java/net/william278/husksync/HuskSyncInitializationException.java

@@ -0,0 +1,31 @@
+/*
+ * This file is part of HuskSync, licensed under the Apache License 2.0.
+ *
+ *  Copyright (c) William278 <will27528@gmail.com>
+ *  Copyright (c) contributors
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+package net.william278.husksync;
+
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * Indicates an exception occurred while initializing the HuskSync plugin
+ */
+public class HuskSyncInitializationException extends IllegalStateException {
+    public HuskSyncInitializationException(@NotNull String message) {
+        super(message);
+    }
+}

common/src/main/java/net/william278/husksync/PlayerData.java

@@ -1,533 +0,0 @@
-package net.william278.husksync;
-
-import java.io.*;
-import java.time.Instant;
-import java.util.UUID;
-
-/**
- * Cross-platform class used to represent a player's data. Data from this can be deserialized using the DataSerializer class on Bukkit platforms.
- */
-public class PlayerData implements Serializable {
-
-    /**
-     * The UUID of the player who this data belongs to
-     */
-    private final UUID playerUUID;
-
-    /**
-     * The unique version UUID of this data
-     */
-    private final UUID dataVersionUUID;
-
-    /**
-     * Epoch time identifying when the data was last updated or created
-     */
-    private long timestamp;
-
-    /**
-     * A special flag that will be {@code true} if the player is new to the network and should not have their data set when joining the Bukkit
-     */
-    public boolean useDefaultData = false;
-
-    /*
-     * Player data records
-     */
-    private String serializedInventory;
-    private String serializedEnderChest;
-    private double health;
-    private double maxHealth;
-    private double healthScale;
-    private int hunger;
-    private float saturation;
-    private float saturationExhaustion;
-    private int selectedSlot;
-    private String serializedEffectData;
-    private int totalExperience;
-    private int expLevel;
-    private float expProgress;
-    private String gameMode;
-    private String serializedStatistics;
-    private boolean isFlying;
-    private String serializedAdvancements;
-    private String serializedLocation;
-
-    /**
-     * Constructor to create new PlayerData from a bukkit {@code Player}'s data
-     *
-     * @param playerUUID              The Player's UUID
-     * @param serializedInventory     Their serialized inventory
-     * @param serializedEnderChest    Their serialized ender chest
-     * @param health                  Their health
-     * @param maxHealth               Their max health
-     * @param healthScale             Their health scale
-     * @param hunger                  Their hunger
-     * @param saturation              Their saturation
-     * @param saturationExhaustion    Their saturation exhaustion
-     * @param selectedSlot            Their selected hot bar slot
-     * @param serializedStatusEffects Their serialized status effects
-     * @param totalExperience         Their total experience points ("Score")
-     * @param expLevel                Their exp level
-     * @param expProgress             Their exp progress to the next level
-     * @param gameMode                Their game mode ({@code SURVIVAL}, {@code CREATIVE}, etc.)
-     * @param serializedStatistics    Their serialized statistics data (Displayed in Statistics menu in ESC menu)
-     */
-    public PlayerData(UUID playerUUID, String serializedInventory, String serializedEnderChest, double health, double maxHealth,
-                      double healthScale, int hunger, float saturation, float saturationExhaustion, int selectedSlot,
-                      String serializedStatusEffects, int totalExperience, int expLevel, float expProgress, String gameMode,
-                      String serializedStatistics, boolean isFlying, String serializedAdvancements, String serializedLocation) {
-        this.dataVersionUUID = UUID.randomUUID();
-        this.timestamp = Instant.now().getEpochSecond();
-        this.playerUUID = playerUUID;
-        this.serializedInventory = serializedInventory;
-        this.serializedEnderChest = serializedEnderChest;
-        this.health = health;
-        this.maxHealth = maxHealth;
-        this.healthScale = healthScale;
-        this.hunger = hunger;
-        this.saturation = saturation;
-        this.saturationExhaustion = saturationExhaustion;
-        this.selectedSlot = selectedSlot;
-        this.serializedEffectData = serializedStatusEffects;
-        this.totalExperience = totalExperience;
-        this.expLevel = expLevel;
-        this.expProgress = expProgress;
-        this.gameMode = gameMode;
-        this.serializedStatistics = serializedStatistics;
-        this.isFlying = isFlying;
-        this.serializedAdvancements = serializedAdvancements;
-        this.serializedLocation = serializedLocation;
-    }
-
-    /**
-     * Constructor for a PlayerData object from an existing object that was stored in SQL
-     *
-     * @param playerUUID              The player whose data this is' UUID
-     * @param dataVersionUUID         The PlayerData version UUID
-     * @param serializedInventory     Their serialized inventory
-     * @param serializedEnderChest    Their serialized ender chest
-     * @param health                  Their health
-     * @param maxHealth               Their max health
-     * @param healthScale             Their health scale
-     * @param hunger                  Their hunger
-     * @param saturation              Their saturation
-     * @param saturationExhaustion    Their saturation exhaustion
-     * @param selectedSlot            Their selected hot bar slot
-     * @param serializedStatusEffects Their serialized status effects
-     * @param totalExperience         Their total experience points ("Score")
-     * @param expLevel                Their exp level
-     * @param expProgress             Their exp progress to the next level
-     * @param gameMode                Their game mode ({@code SURVIVAL}, {@code CREATIVE}, etc.)
-     * @param serializedStatistics    Their serialized statistics data (Displayed in Statistics menu in ESC menu)
-     */
-    public PlayerData(UUID playerUUID, UUID dataVersionUUID, long timestamp, String serializedInventory, String serializedEnderChest,
-                      double health, double maxHealth, double healthScale, int hunger, float saturation, float saturationExhaustion,
-                      int selectedSlot, String serializedStatusEffects, int totalExperience, int expLevel, float expProgress,
-                      String gameMode, String serializedStatistics, boolean isFlying, String serializedAdvancements,
-                      String serializedLocation) {
-        this.playerUUID = playerUUID;
-        this.dataVersionUUID = dataVersionUUID;
-        this.timestamp = timestamp;
-        this.serializedInventory = serializedInventory;
-        this.serializedEnderChest = serializedEnderChest;
-        this.health = health;
-        this.maxHealth = maxHealth;
-        this.healthScale = healthScale;
-        this.hunger = hunger;
-        this.saturation = saturation;
-        this.saturationExhaustion = saturationExhaustion;
-        this.selectedSlot = selectedSlot;
-        this.serializedEffectData = serializedStatusEffects;
-        this.totalExperience = totalExperience;
-        this.expLevel = expLevel;
-        this.expProgress = expProgress;
-        this.gameMode = gameMode;
-        this.serializedStatistics = serializedStatistics;
-        this.isFlying = isFlying;
-        this.serializedAdvancements = serializedAdvancements;
-        this.serializedLocation = serializedLocation;
-    }
-
-    /**
-     * Get default PlayerData for a new user
-     *
-     * @param playerUUID The bukkit Player's UUID
-     * @return Default {@link PlayerData}
-     */
-    public static PlayerData DEFAULT_PLAYER_DATA(UUID playerUUID) {
-        PlayerData data = new PlayerData(playerUUID, "", "", 20,
-                20, 20, 20, 10, 1, 0,
-                "", 0, 0, 0, "SURVIVAL",
-                "", false, "", "");
-        data.useDefaultData = true;
-        return data;
-    }
-
-    /**
-     * Get the {@link UUID} of the player whose data this is
-     *
-     * @return the player's {@link UUID}
-     */
-    public UUID getPlayerUUID() {
-        return playerUUID;
-    }
-
-    /**
-     * Get the unique version {@link UUID} of the PlayerData
-     *
-     * @return The unique data version
-     */
-    public UUID getDataVersionUUID() {
-        return dataVersionUUID;
-    }
-
-    /**
-     * Get the timestamp when this data was created or last updated
-     *
-     * @return time since epoch of last data update or creation
-     */
-    public long getDataTimestamp() {
-        return timestamp;
-    }
-
-    /**
-     * Returns the serialized player {@code ItemStack[]} inventory
-     *
-     * @return The player's serialized inventory
-     */
-    public String getSerializedInventory() {
-        return serializedInventory;
-    }
-
-    /**
-     * Returns the serialized player {@code ItemStack[]} ender chest
-     *
-     * @return The player's serialized ender chest
-     */
-    public String getSerializedEnderChest() {
-        return serializedEnderChest;
-    }
-
-    /**
-     * Returns the player's health value
-     *
-     * @return the player's health
-     */
-    public double getHealth() {
-        return health;
-    }
-
-    /**
-     * Returns the player's max health value
-     *
-     * @return the player's max health
-     */
-    public double getMaxHealth() {
-        return maxHealth;
-    }
-
-    /**
-     * Returns the player's health scale value {@see https://hub.spigotmc.org/javadocs/bukkit/org/bukkit/entity/Player.html#getHealthScale()}
-     *
-     * @return the player's health scaling value
-     */
-    public double getHealthScale() {
-        return healthScale;
-    }
-
-    /**
-     * Returns the player's hunger points
-     *
-     * @return the player's hunger level
-     */
-    public int getHunger() {
-        return hunger;
-    }
-
-    /**
-     * Returns the player's saturation points
-     *
-     * @return the player's saturation level
-     */
-    public float getSaturation() {
-        return saturation;
-    }
-
-    /**
-     * Returns the player's saturation exhaustion value {@see https://hub.spigotmc.org/javadocs/bukkit/org/bukkit/entity/HumanEntity.html#getExhaustion()}
-     *
-     * @return the player's saturation exhaustion
-     */
-    public float getSaturationExhaustion() {
-        return saturationExhaustion;
-    }
-
-    /**
-     * Returns the number of the player's currently selected hotbar slot
-     *
-     * @return the player's selected hotbar slot
-     */
-    public int getSelectedSlot() {
-        return selectedSlot;
-    }
-
-    /**
-     * Returns a serialized {@link String} of the player's current status effects
-     *
-     * @return the player's serialized status effect data
-     */
-    public String getSerializedEffectData() {
-        return serializedEffectData;
-    }
-
-    /**
-     * Returns the player's total experience score (used for presenting the death screen score value)
-     *
-     * @return the player's total experience score
-     */
-    public int getTotalExperience() {
-        return totalExperience;
-    }
-
-    /**
-     * Returns a serialized {@link String} of the player's statistics
-     *
-     * @return the player's serialized statistic records
-     */
-    public String getSerializedStatistics() {
-        return serializedStatistics;
-    }
-
-    /**
-     * Returns the player's current experience level
-     *
-     * @return the player's exp level
-     */
-    public int getExpLevel() {
-        return expLevel;
-    }
-
-    /**
-     * Returns the player's progress to the next experience level
-     *
-     * @return the player's exp progress
-     */
-    public float getExpProgress() {
-        return expProgress;
-    }
-
-    /**
-     * Returns the player's current game mode as a string ({@code SURVIVAL}, {@code CREATIVE}, etc.)
-     *
-     * @return the player's game mode
-     */
-    public String getGameMode() {
-        return gameMode;
-    }
-
-    /**
-     * Returns if the player is currently flying
-     *
-     * @return {@code true} if the player is in flight; {@code false} otherwise
-     */
-    public boolean isFlying() {
-        return isFlying;
-    }
-
-    /**
-     * Returns a serialized {@link String} of the player's advancements
-     *
-     * @return the player's serialized advancement data
-     */
-    public String getSerializedAdvancements() {
-        return serializedAdvancements;
-    }
-
-    /**
-     * Returns a serialized {@link String} of the player's current location
-     *
-     * @return the player's serialized location
-     */
-    public String getSerializedLocation() {
-        return serializedLocation;
-    }
-
-    /**
-     * Update the player's inventory data
-     *
-     * @param serializedInventory A serialized {@code String}; new inventory data
-     */
-    public void setSerializedInventory(String serializedInventory) {
-        this.serializedInventory = serializedInventory;
-        this.timestamp = Instant.now().getEpochSecond();
-    }
-
-    /**
-     * Update the player's ender chest data
-     *
-     * @param serializedEnderChest A serialized {@code String}; new ender chest inventory data
-     */
-    public void setSerializedEnderChest(String serializedEnderChest) {
-        this.serializedEnderChest = serializedEnderChest;
-        this.timestamp = Instant.now().getEpochSecond();
-    }
-
-    /**
-     * Update the player's health
-     *
-     * @param health new health value
-     */
-    public void setHealth(double health) {
-        this.health = health;
-        this.timestamp = Instant.now().getEpochSecond();
-    }
-
-    /**
-     * Update the player's max health
-     *
-     * @param maxHealth new maximum health value
-     */
-    public void setMaxHealth(double maxHealth) {
-        this.maxHealth = maxHealth;
-        this.timestamp = Instant.now().getEpochSecond();
-    }
-
-    /**
-     * Update the player's health scale
-     *
-     * @param healthScale new health scaling value
-     */
-    public void setHealthScale(double healthScale) {
-        this.healthScale = healthScale;
-        this.timestamp = Instant.now().getEpochSecond();
-    }
-
-    /**
-     * Update the player's hunger meter
-     *
-     * @param hunger new hunger value
-     */
-    public void setHunger(int hunger) {
-        this.hunger = hunger;
-        this.timestamp = Instant.now().getEpochSecond();
-    }
-
-    /**
-     * Update the player's saturation level
-     *
-     * @param saturation new saturation value
-     */
-    public void setSaturation(float saturation) {
-        this.saturation = saturation;
-        this.timestamp = Instant.now().getEpochSecond();
-    }
-
-    /**
-     * Update the player's saturation exhaustion value
-     *
-     * @param saturationExhaustion new exhaustion value
-     */
-    public void setSaturationExhaustion(float saturationExhaustion) {
-        this.saturationExhaustion = saturationExhaustion;
-        this.timestamp = Instant.now().getEpochSecond();
-    }
-
-    /**
-     * Update the player's selected hotbar slot
-     *
-     * @param selectedSlot new hotbar slot number (0-9)
-     */
-    public void setSelectedSlot(int selectedSlot) {
-        this.selectedSlot = selectedSlot;
-        this.timestamp = Instant.now().getEpochSecond();
-    }
-
-    /**
-     * Update the player's status effect data
-     *
-     * @param serializedEffectData A serialized {@code String} of the player's new status effect data
-     */
-    public void setSerializedEffectData(String serializedEffectData) {
-        this.serializedEffectData = serializedEffectData;
-        this.timestamp = Instant.now().getEpochSecond();
-    }
-
-    /**
-     * Set the player's total experience points (used to display score on death screen)
-     *
-     * @param totalExperience the player's new total experience score
-     */
-    public void setTotalExperience(int totalExperience) {
-        this.totalExperience = totalExperience;
-        this.timestamp = Instant.now().getEpochSecond();
-    }
-
-    /**
-     * Set the player's exp level
-     *
-     * @param expLevel the player's new exp level
-     */
-    public void setExpLevel(int expLevel) {
-        this.expLevel = expLevel;
-        this.timestamp = Instant.now().getEpochSecond();
-    }
-
-    /**
-     * Set the player's progress to their next exp level
-     *
-     * @param expProgress the player's new experience progress
-     */
-    public void setExpProgress(float expProgress) {
-        this.expProgress = expProgress;
-        this.timestamp = Instant.now().getEpochSecond();
-    }
-
-    /**
-     * Set the player's game mode
-     *
-     * @param gameMode the player's new game mode ({@code SURVIVAL}, {@code CREATIVE}, etc.)
-     */
-    public void setGameMode(String gameMode) {
-        this.gameMode = gameMode;
-        this.timestamp = Instant.now().getEpochSecond();
-    }
-
-    /**
-     * Update the player's statistics data
-     *
-     * @param serializedStatistics A serialized {@code String}; new statistic data
-     */
-    public void setSerializedStatistics(String serializedStatistics) {
-        this.serializedStatistics = serializedStatistics;
-        this.timestamp = Instant.now().getEpochSecond();
-    }
-
-    /**
-     * Set if the player is flying
-     *
-     * @param flying whether the player is flying
-     */
-    public void setFlying(boolean flying) {
-        isFlying = flying;
-        this.timestamp = Instant.now().getEpochSecond();
-    }
-
-    /**
-     * Update the player's advancement data
-     *
-     * @param serializedAdvancements A serialized {@code String}; new advancement data
-     */
-    public void setSerializedAdvancements(String serializedAdvancements) {
-        this.serializedAdvancements = serializedAdvancements;
-        this.timestamp = Instant.now().getEpochSecond();
-    }
-
-    /**
-     * Update the player's location data
-     *
-     * @param serializedLocation A serialized {@code String}; new location data
-     */
-    public void setSerializedLocation(String serializedLocation) {
-        this.serializedLocation = serializedLocation;
-        this.timestamp = Instant.now().getEpochSecond();
-    }
-}

common/src/main/java/net/william278/husksync/Server.java

@@ -1,10 +0,0 @@
-package net.william278.husksync;
-
-import java.util.UUID;
-
-/**
- * A record representing a server synchronised on the network and whether it has MySqlPlayerDataBridge installed
- */
-public record Server(UUID serverUUID, boolean hasMySqlPlayerDataBridge, String huskSyncVersion, String serverBrand,
-                     String clusterId) {
-}

common/src/main/java/net/william278/husksync/Settings.java

@@ -1,99 +0,0 @@
-package net.william278.husksync;
-
-import java.util.ArrayList;
-
-/**
- * Settings class, holds values loaded from the plugin config (either Bukkit or Bungee)
- */
-public class Settings {
-
-    /*
-     * General settings
-     */
-
-    // Whether to do automatic update checks on startup
-    public static boolean automaticUpdateChecks;
-
-    // The type of THIS server (Bungee or Bukkit)
-    public static ServerType serverType;
-
-    // Redis settings
-    public static String redisHost;
-    public static int redisPort;
-    public static String redisPassword;
-    public static boolean redisSSL;
-
-    /*
-     * Bungee / Proxy server-only settings
-     */
-
-    // Messages language
-    public static String language;
-
-    // Cluster IDs
-    public static ArrayList<SynchronisationCluster> clusters = new ArrayList<>();
-
-    // SQL settings
-    public static DataStorageType dataStorageType;
-
-    // Bounce-back synchronisation (default)
-    public static boolean bounceBackSynchronisation;
-
-    // MySQL specific settings
-    public static String mySQLHost;
-    public static String mySQLDatabase;
-    public static String mySQLUsername;
-    public static String mySQLPassword;
-    public static int mySQLPort;
-    public static String mySQLParams;
-
-    // Hikari connection pooling settings
-    public static int hikariMaximumPoolSize;
-    public static int hikariMinimumIdle;
-    public static long hikariMaximumLifetime;
-    public static long hikariKeepAliveTime;
-    public static long hikariConnectionTimeOut;
-
-    /*
-     * Bukkit server-only settings
-     */
-
-    // Synchronisation options
-    public static boolean syncInventories;
-    public static boolean syncEnderChests;
-    public static boolean syncHealth;
-    public static boolean syncHunger;
-    public static boolean syncExperience;
-    public static boolean syncPotionEffects;
-    public static boolean syncStatistics;
-    public static boolean syncGameMode;
-    public static boolean syncAdvancements;
-    public static boolean syncLocation;
-    public static boolean syncFlight;
-    public static long synchronizationTimeoutRetryDelay;
-    public static boolean saveOnWorldSave;
-    public static boolean useNativeImplementation;
-
-    // This Cluster ID
-    public static String cluster;
-
-    /*
-     * Enum definitions
-     */
-
-    public enum ServerType {
-        BUKKIT,
-        PROXY,
-    }
-
-    public enum DataStorageType {
-        MYSQL,
-        SQLITE
-    }
-
-    /**
-     * Defines information for a synchronisation cluster as listed on the proxy
-     */
-    public record SynchronisationCluster(String clusterId, String databaseName, String playerTableName, String dataTableName) {
-    }
-}

common/src/main/java/net/william278/husksync/api/BaseHuskSyncAPI.java

@@ -0,0 +1,157 @@
+/*
+ * This file is part of HuskSync, licensed under the Apache License 2.0.
+ *
+ *  Copyright (c) William278 <will27528@gmail.com>
+ *  Copyright (c) contributors
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+package net.william278.husksync.api;
+
+import net.william278.husksync.HuskSync;
+import net.william278.husksync.data.DataSaveCause;
+import net.william278.husksync.data.UserData;
+import net.william278.husksync.data.UserDataSnapshot;
+import net.william278.husksync.player.OnlineUser;
+import net.william278.husksync.player.User;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.List;
+import java.util.Optional;
+import java.util.UUID;
+import java.util.concurrent.CompletableFuture;
+
+/**
+ * The base implementation of the HuskSync API, containing cross-platform API calls.
+ * </p>
+ * This class should not be used directly, but rather through platform-specific extending API classes.
+ */
+@SuppressWarnings("unused")
+public abstract class BaseHuskSyncAPI {
+
+    /**
+     * <b>(Internal use only)</b> - Instance of the implementing plugin.
+     */
+    protected final HuskSync plugin;
+
+    protected BaseHuskSyncAPI(@NotNull HuskSync plugin) {
+        this.plugin = plugin;
+    }
+
+    /**
+     * Returns a {@link User} by the given player's account {@link UUID}, if they exist.
+     *
+     * @param uuid the unique id of the player to get the {@link User} instance for
+     * @return future returning the {@link User} instance for the given player's unique id if they exist, otherwise an empty {@link Optional}
+     * @apiNote The player does not have to be online
+     * @since 2.0
+     */
+    public final CompletableFuture<Optional<User>> getUser(@NotNull UUID uuid) {
+        return plugin.getDatabase().getUser(uuid);
+    }
+
+    /**
+     * Returns a {@link User} by the given player's username (case-insensitive), if they exist.
+     *
+     * @param username the username of the {@link User} instance for
+     * @return future returning the {@link User} instance for the given player's username if they exist,
+     * otherwise an empty {@link Optional}
+     * @apiNote The player does not have to be online, though their username has to be the username
+     * they had when they last joined the server.
+     * @since 2.0
+     */
+    public final CompletableFuture<Optional<User>> getUser(@NotNull String username) {
+        return plugin.getDatabase().getUserByName(username);
+    }
+
+    /**
+     * Returns a {@link User}'s current {@link UserData}
+     *
+     * @param user the {@link User} to get the {@link UserData} for
+     * @return future returning the {@link UserData} for the given {@link User} if they exist, otherwise an empty {@link Optional}
+     * @apiNote If the user is not online on the implementing bukkit server,
+     * the {@link UserData} returned will be their last database-saved UserData.
+     * </p>
+     * Because of this, if the user is online on another server on the network,
+     * then the {@link UserData} returned by this method will <i>not necessarily reflective of
+     * their current state</i>
+     * @since 2.0
+     */
+    public final CompletableFuture<Optional<UserData>> getUserData(@NotNull User user) {
+        return CompletableFuture.supplyAsync(() -> {
+            if (user instanceof OnlineUser) {
+                return ((OnlineUser) user).getUserData(plugin).join();
+            } else {
+                return plugin.getDatabase().getCurrentUserData(user).join().map(UserDataSnapshot::userData);
+            }
+        });
+    }
+
+    /**
+     * Sets the {@link UserData} to the database for the given {@link User}.
+     * </p>
+     * If the user is online and on the same cluster, their data will be updated in game.
+     *
+     * @param user     the {@link User} to set the {@link UserData} for
+     * @param userData the {@link UserData} to set for the given {@link User}
+     * @return future returning void when complete
+     * @since 2.0
+     */
+    public final CompletableFuture<Void> setUserData(@NotNull User user, @NotNull UserData userData) {
+        return CompletableFuture.runAsync(() ->
+                plugin.getDatabase().setUserData(user, userData, DataSaveCause.API)
+                        .thenRun(() -> plugin.getRedisManager().sendUserDataUpdate(user, userData).join()));
+    }
+
+    /**
+     * Saves the {@link UserData} of an {@link OnlineUser} to the database
+     *
+     * @param user the {@link OnlineUser} to save the {@link UserData} of
+     * @return future returning void when complete
+     * @since 2.0
+     */
+    public final CompletableFuture<Void> saveUserData(@NotNull OnlineUser user) {
+        return CompletableFuture.runAsync(() -> user.getUserData(plugin)
+                .thenAccept(optionalUserData -> optionalUserData.ifPresent(
+                        userData -> plugin.getDatabase().setUserData(user, userData, DataSaveCause.API).join())));
+    }
+
+    /**
+     * Returns the saved {@link UserDataSnapshot} records for the given {@link User}
+     *
+     * @param user the {@link User} to get the {@link UserDataSnapshot} for
+     * @return future returning a list {@link UserDataSnapshot} for the given {@link User} if they exist,
+     * otherwise an empty {@link Optional}
+     * @apiNote The length of the list of VersionedUserData will correspond to the configured
+     * {@code max_user_data_records} config option
+     * @since 2.0
+     */
+    public final CompletableFuture<List<UserDataSnapshot>> getSavedUserData(@NotNull User user) {
+        return CompletableFuture.supplyAsync(() -> plugin.getDatabase().getUserData(user).join());
+    }
+
+    /**
+     * Returns the JSON string representation of the given {@link UserData}
+     *
+     * @param userData    the {@link UserData} to get the JSON string representation of
+     * @param prettyPrint whether to pretty print the JSON string
+     * @return the JSON string representation of the given {@link UserData}
+     * @since 2.0
+     */
+    @NotNull
+    public final String getUserDataJson(@NotNull UserData userData, boolean prettyPrint) {
+        return plugin.getDataAdapter().toJson(userData, prettyPrint);
+    }
+
+}

common/src/main/java/net/william278/husksync/command/CommandBase.java

@@ -0,0 +1,77 @@
+/*
+ * This file is part of HuskSync, licensed under the Apache License 2.0.
+ *
+ *  Copyright (c) William278 <will27528@gmail.com>
+ *  Copyright (c) contributors
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+package net.william278.husksync.command;
+
+import net.william278.husksync.HuskSync;
+import net.william278.husksync.player.OnlineUser;
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * Represents an abstract cross-platform representation for a plugin command
+ */
+public abstract class CommandBase {
+
+    /**
+     * The input string to match for this command
+     */
+    public final String command;
+
+    /**
+     * The permission node required to use this command
+     */
+    public final String permission;
+
+    /**
+     * Alias input strings for this command
+     */
+    public final String[] aliases;
+
+    /**
+     * Instance of the implementing plugin
+     */
+    public final HuskSync plugin;
+
+
+    public CommandBase(@NotNull String command, @NotNull Permission permission, @NotNull HuskSync implementor, String... aliases) {
+        this.command = command;
+        this.permission = permission.node;
+        this.plugin = implementor;
+        this.aliases = aliases;
+    }
+
+    /**
+     * Fires when the command is executed
+     *
+     * @param player {@link OnlineUser} executing the command
+     * @param args   Command arguments
+     */
+    public abstract void onExecute(@NotNull OnlineUser player, @NotNull String[] args);
+
+    /**
+     * Returns the localised description string of this command
+     *
+     * @return the command description
+     */
+    public String getDescription() {
+        return plugin.getLocales().getRawLocale(command + "_command_description")
+                .orElse("A HuskSync command");
+    }
+
+}

common/src/main/java/net/william278/husksync/command/ConsoleExecutable.java

@@ -0,0 +1,36 @@
+/*
+ * This file is part of HuskSync, licensed under the Apache License 2.0.
+ *
+ *  Copyright (c) William278 <will27528@gmail.com>
+ *  Copyright (c) contributors
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+package net.william278.husksync.command;
+
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * Interface providing console execution of commands
+ */
+public interface ConsoleExecutable {
+
+    /**
+     * What to do when console executes a command
+     *
+     * @param args command argument strings
+     */
+    void onConsoleExecute(@NotNull String[] args);
+
+}

common/src/main/java/net/william278/husksync/command/EnderChestCommand.java

@@ -0,0 +1,132 @@
+/*
+ * This file is part of HuskSync, licensed under the Apache License 2.0.
+ *
+ *  Copyright (c) William278 <will27528@gmail.com>
+ *  Copyright (c) contributors
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+package net.william278.husksync.command;
+
+import de.themoep.minedown.adventure.MineDown;
+import net.william278.husksync.HuskSync;
+import net.william278.husksync.data.DataSaveCause;
+import net.william278.husksync.data.UserData;
+import net.william278.husksync.data.UserDataBuilder;
+import net.william278.husksync.data.UserDataSnapshot;
+import net.william278.husksync.player.OnlineUser;
+import net.william278.husksync.player.User;
+import org.jetbrains.annotations.NotNull;
+
+import java.text.SimpleDateFormat;
+import java.util.List;
+import java.util.Locale;
+import java.util.Optional;
+import java.util.UUID;
+import java.util.concurrent.CompletableFuture;
+import java.util.logging.Level;
+import java.util.stream.Collectors;
+
+public class EnderChestCommand extends CommandBase implements TabCompletable {
+
+    public EnderChestCommand(@NotNull HuskSync implementor) {
+        super("enderchest", Permission.COMMAND_ENDER_CHEST, implementor, "echest", "openechest");
+    }
+
+    @Override
+    public void onExecute(@NotNull OnlineUser player, @NotNull String[] args) {
+        if (args.length == 0 || args.length > 2) {
+            plugin.getLocales().getLocale("error_invalid_syntax", "/enderchest <player>")
+                    .ifPresent(player::sendMessage);
+            return;
+        }
+        plugin.getDatabase().getUserByName(args[0].toLowerCase(Locale.ENGLISH)).thenAccept(optionalUser ->
+                optionalUser.ifPresentOrElse(user -> {
+                    if (args.length == 2) {
+                        // View user data by specified UUID
+                        try {
+                            final UUID versionUuid = UUID.fromString(args[1]);
+                            plugin.getDatabase().getUserData(user, versionUuid).thenAccept(data -> data.ifPresentOrElse(
+                                    userData -> showEnderChestMenu(player, userData, user, false),
+                                    () -> plugin.getLocales().getLocale("error_invalid_version_uuid")
+                                            .ifPresent(player::sendMessage)));
+                        } catch (IllegalArgumentException e) {
+                            plugin.getLocales().getLocale("error_invalid_syntax",
+                                    "/enderchest <player> [version_uuid]").ifPresent(player::sendMessage);
+                        }
+                    } else {
+                        // View (and edit) the latest user data
+                        plugin.getDatabase().getCurrentUserData(user).thenAccept(optionalData -> optionalData.ifPresentOrElse(
+                                versionedUserData -> showEnderChestMenu(player, versionedUserData, user,
+                                        player.hasPermission(Permission.COMMAND_ENDER_CHEST_EDIT.node)),
+                                () -> plugin.getLocales().getLocale("error_no_data_to_display")
+                                        .ifPresent(player::sendMessage)));
+                    }
+                }, () -> plugin.getLocales().getLocale("error_invalid_player")
+                        .ifPresent(player::sendMessage)));
+    }
+
+    private void showEnderChestMenu(@NotNull OnlineUser player, @NotNull UserDataSnapshot userDataSnapshot,
+                                    @NotNull User dataOwner, boolean allowEdit) {
+        CompletableFuture.runAsync(() -> {
+            final UserData data = userDataSnapshot.userData();
+            data.getEnderChest().ifPresent(itemData -> {
+                // Show message
+                plugin.getLocales().getLocale("ender_chest_viewer_opened", dataOwner.username,
+                                new SimpleDateFormat("MMM dd yyyy, HH:mm:ss.sss")
+                                        .format(userDataSnapshot.versionTimestamp()))
+                        .ifPresent(player::sendMessage);
+
+                // Show inventory menu
+                player.showMenu(itemData, allowEdit, 3, plugin.getLocales()
+                                .getLocale("ender_chest_viewer_menu_title", dataOwner.username)
+                                .orElse(new MineDown("Ender Chest Viewer")))
+                        .exceptionally(throwable -> {
+                            plugin.log(Level.WARNING, "Exception displaying inventory menu to " + player.username, throwable);
+                            return Optional.empty();
+                        })
+                        .thenAccept(dataOnClose -> {
+                            if (dataOnClose.isEmpty() || !allowEdit) {
+                                return;
+                            }
+
+                            // Create the updated data
+                            final UserDataBuilder builder = UserData.builder(plugin.getMinecraftVersion());
+                            data.getStatus().ifPresent(builder::setStatus);
+                            data.getAdvancements().ifPresent(builder::setAdvancements);
+                            data.getLocation().ifPresent(builder::setLocation);
+                            data.getPersistentDataContainer().ifPresent(builder::setPersistentDataContainer);
+                            data.getStatistics().ifPresent(builder::setStatistics);
+                            data.getPotionEffects().ifPresent(builder::setPotionEffects);
+                            data.getInventory().ifPresent(builder::setInventory);
+                            builder.setEnderChest(dataOnClose.get());
+
+                            // Set the updated data
+                            final UserData updatedUserData = builder.build();
+                            plugin.getDatabase()
+                                    .setUserData(dataOwner, updatedUserData, DataSaveCause.INVENTORY_COMMAND)
+                                    .thenRun(() -> plugin.getRedisManager().sendUserDataUpdate(dataOwner, updatedUserData));
+                        });
+            });
+        });
+    }
+
+    @Override
+    public List<String> onTabComplete(@NotNull String[] args) {
+        return plugin.getOnlineUsers().stream().map(user -> user.username)
+                .filter(argument -> argument.startsWith(args.length >= 1 ? args[0] : ""))
+                .sorted().collect(Collectors.toList());
+    }
+
+}

common/src/main/java/net/william278/husksync/command/HuskSyncCommand.java

@@ -0,0 +1,190 @@
+/*
+ * This file is part of HuskSync, licensed under the Apache License 2.0.
+ *
+ *  Copyright (c) William278 <will27528@gmail.com>
+ *  Copyright (c) contributors
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+package net.william278.husksync.command;
+
+import de.themoep.minedown.adventure.MineDown;
+import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.format.TextColor;
+import net.william278.desertwell.about.AboutMenu;
+import net.william278.husksync.HuskSync;
+import net.william278.husksync.migrator.Migrator;
+import net.william278.husksync.player.OnlineUser;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.*;
+import java.util.logging.Level;
+import java.util.stream.Collectors;
+
+public class HuskSyncCommand extends CommandBase implements TabCompletable, ConsoleExecutable {
+
+    private final String[] SUB_COMMANDS = {"update", "about", "reload", "migrate"};
+    private final AboutMenu aboutMenu;
+
+    public HuskSyncCommand(@NotNull HuskSync implementor) {
+        super("husksync", Permission.COMMAND_HUSKSYNC, implementor);
+        this.aboutMenu = AboutMenu.builder()
+                .title(Component.text("HuskSync"))
+                .description(Component.text("A modern, cross-server player data synchronization system"))
+                .version(implementor.getPluginVersion())
+                .credits("Author",
+                        AboutMenu.Credit.of("William278").description("Click to visit website").url("https://william278.net"))
+                .credits("Contributors",
+                        AboutMenu.Credit.of("HarvelsX").description("Code"),
+                        AboutMenu.Credit.of("HookWoods").description("Code"))
+                .credits("Translators",
+                        AboutMenu.Credit.of("Namiu").description("Japanese (ja-jp)"),
+                        AboutMenu.Credit.of("anchelthe").description("Spanish (es-es)"),
+                        AboutMenu.Credit.of("Melonzio").description("Spanish (es-es)"),
+                        AboutMenu.Credit.of("Ceddix").description("German (de-de)"),
+                        AboutMenu.Credit.of("Pukejoy_1").description("Bulgarian (bg-bg)"),
+                        AboutMenu.Credit.of("mateusneresrb").description("Brazilian Portuguese (pt-br)"),
+                        AboutMenu.Credit.of("小蔡").description("Traditional Chinese (zh-tw)"),
+                        AboutMenu.Credit.of("Ghost-chu").description("Simplified Chinese (zh-cn)"),
+                        AboutMenu.Credit.of("DJelly4K").description("Simplified Chinese (zh-cn)"),
+                        AboutMenu.Credit.of("Thourgard").description("Ukrainian (uk-ua)"),
+                        AboutMenu.Credit.of("xF3d3").description("Italian (it-it)"))
+                .buttons(
+                        AboutMenu.Link.of("https://william278.net/docs/husksync").text("Documentation").icon("⛏"),
+                        AboutMenu.Link.of("https://github.com/WiIIiam278/HuskSync/issues").text("Issues").icon("❌").color(TextColor.color(0xff9f0f)),
+                        AboutMenu.Link.of("https://discord.gg/tVYhJfyDWG").text("Discord").icon("⭐").color(TextColor.color(0x6773f5)))
+                .build();
+    }
+
+    @Override
+    public void onExecute(@NotNull OnlineUser player, @NotNull String[] args) {
+        if (args.length < 1) {
+            sendAboutMenu(player);
+            return;
+        }
+        switch (args[0].toLowerCase(Locale.ENGLISH)) {
+            case "update", "version" -> {
+                if (!player.hasPermission(Permission.COMMAND_HUSKSYNC_UPDATE.node)) {
+                    plugin.getLocales().getLocale("error_no_permission").ifPresent(player::sendMessage);
+                    return;
+                }
+                plugin.getLatestVersionIfOutdated().thenAccept(newestVersion ->
+                        newestVersion.ifPresentOrElse(
+                                newVersion -> player.sendMessage(
+                                        new MineDown("[HuskSync](#00fb9a bold) [| A new version of HuskSync is available!"
+                                                     + " (v" + newVersion + " (Running: v" + plugin.getPluginVersion() + ")](#00fb9a)")),
+                                () -> player.sendMessage(
+                                        new MineDown("[HuskSync](#00fb9a bold) [| HuskSync is up-to-date."
+                                                     + " (Running: v" + plugin.getPluginVersion() + ")](#00fb9a)"))));
+            }
+            case "about", "info" -> sendAboutMenu(player);
+            case "reload" -> {
+                if (!player.hasPermission(Permission.COMMAND_HUSKSYNC_RELOAD.node)) {
+                    plugin.getLocales().getLocale("error_no_permission").ifPresent(player::sendMessage);
+                    return;
+                }
+                plugin.reload();
+                plugin.getLocales().getLocale("reload_complete").ifPresent(player::sendMessage);
+            }
+            case "migrate" ->
+                    plugin.getLocales().getLocale("error_console_command_only").ifPresent(player::sendMessage);
+            default -> plugin.getLocales().getLocale("error_invalid_syntax",
+                            "/husksync <update/about/reload>")
+                    .ifPresent(player::sendMessage);
+        }
+    }
+
+    @Override
+    public void onConsoleExecute(@NotNull String[] args) {
+        if (args.length < 1) {
+            plugin.log(Level.INFO, "Console usage: \"husksync <update/about/reload/migrate>\"");
+            return;
+        }
+        switch (args[0].toLowerCase(Locale.ENGLISH)) {
+            case "update", "version" -> plugin.getLatestVersionIfOutdated().thenAccept(newestVersion ->
+                    newestVersion.ifPresentOrElse(newVersion -> plugin.log(Level.WARNING,
+                                    "An update is available for HuskSync, v" + newVersion
+                                    + " (Running v" + plugin.getPluginVersion() + ")"),
+                            () -> plugin.log(Level.INFO,
+                                    "HuskSync is up to date" +
+                                    " (Running v" + plugin.getPluginVersion() + ")")));
+            case "about", "info" -> aboutMenu.toString().lines().forEach(line -> plugin.log(Level.INFO, line));
+            case "reload" -> {
+                plugin.reload();
+                plugin.log(Level.INFO, "Reloaded config & message files.");
+            }
+            case "migrate" -> {
+                if (args.length < 2) {
+                    plugin.log(Level.INFO,
+                            "Please choose a migrator, then run \"husksync migrate <migrator>\"");
+                    logMigratorsList();
+                    return;
+                }
+                final Optional<Migrator> selectedMigrator = plugin.getAvailableMigrators().stream().filter(availableMigrator ->
+                        availableMigrator.getIdentifier().equalsIgnoreCase(args[1])).findFirst();
+                selectedMigrator.ifPresentOrElse(migrator -> {
+                    if (args.length < 3) {
+                        plugin.log(Level.INFO, migrator.getHelpMenu());
+                        return;
+                    }
+                    switch (args[2]) {
+                        case "start" -> migrator.start().thenAccept(succeeded -> {
+                            if (succeeded) {
+                                plugin.log(Level.INFO, "Migration completed successfully!");
+                            } else {
+                                plugin.log(Level.WARNING, "Migration failed!");
+                            }
+                        });
+                        case "set" -> migrator.handleConfigurationCommand(Arrays.copyOfRange(args, 3, args.length));
+                        default -> plugin.log(Level.INFO,
+                                "Invalid syntax. Console usage: \"husksync migrate " + args[1] + " <start/set>");
+                    }
+                }, () -> {
+                    plugin.log(Level.INFO,
+                            "Please specify a valid migrator.\n" +
+                            "If a migrator is not available, please verify that you meet the prerequisites to use it.");
+                    logMigratorsList();
+                });
+            }
+            default -> plugin.log(Level.INFO,
+                    "Invalid syntax. Console usage: \"husksync <update/about/reload/migrate>\"");
+        }
+    }
+
+    private void logMigratorsList() {
+        plugin.log(Level.INFO,
+                "List of available migrators:\nMigrator ID / Migrator Name:\n" +
+                plugin.getAvailableMigrators().stream()
+                        .map(migrator -> migrator.getIdentifier() + " - " + migrator.getName())
+                        .collect(Collectors.joining("\n")));
+    }
+
+    @Override
+    public List<String> onTabComplete(@NotNull String[] args) {
+        if (args.length <= 1) {
+            return Arrays.stream(SUB_COMMANDS)
+                    .filter(argument -> argument.startsWith(args.length == 1 ? args[0] : ""))
+                    .sorted().collect(Collectors.toList());
+        }
+        return Collections.emptyList();
+    }
+
+    private void sendAboutMenu(@NotNull OnlineUser player) {
+        if (!player.hasPermission(Permission.COMMAND_HUSKSYNC_ABOUT.node)) {
+            plugin.getLocales().getLocale("error_no_permission").ifPresent(player::sendMessage);
+            return;
+        }
+        player.sendMessage(aboutMenu.toComponent());
+    }
+}

common/src/main/java/net/william278/husksync/command/InventoryCommand.java

@@ -0,0 +1,131 @@
+/*
+ * This file is part of HuskSync, licensed under the Apache License 2.0.
+ *
+ *  Copyright (c) William278 <will27528@gmail.com>
+ *  Copyright (c) contributors
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+package net.william278.husksync.command;
+
+import de.themoep.minedown.adventure.MineDown;
+import net.william278.husksync.HuskSync;
+import net.william278.husksync.data.DataSaveCause;
+import net.william278.husksync.data.UserData;
+import net.william278.husksync.data.UserDataBuilder;
+import net.william278.husksync.data.UserDataSnapshot;
+import net.william278.husksync.player.OnlineUser;
+import net.william278.husksync.player.User;
+import org.jetbrains.annotations.NotNull;
+
+import java.text.SimpleDateFormat;
+import java.util.List;
+import java.util.Locale;
+import java.util.Optional;
+import java.util.UUID;
+import java.util.concurrent.CompletableFuture;
+import java.util.logging.Level;
+import java.util.stream.Collectors;
+
+public class InventoryCommand extends CommandBase implements TabCompletable {
+
+    public InventoryCommand(@NotNull HuskSync implementor) {
+        super("inventory", Permission.COMMAND_INVENTORY, implementor, "invsee", "openinv");
+    }
+
+    @Override
+    public void onExecute(@NotNull OnlineUser player, @NotNull String[] args) {
+        if (args.length == 0 || args.length > 2) {
+            plugin.getLocales().getLocale("error_invalid_syntax", "/inventory <player>")
+                    .ifPresent(player::sendMessage);
+            return;
+        }
+        plugin.getDatabase().getUserByName(args[0].toLowerCase(Locale.ENGLISH)).thenAccept(optionalUser ->
+                optionalUser.ifPresentOrElse(user -> {
+                    if (args.length == 2) {
+                        // View user data by specified UUID
+                        try {
+                            final UUID versionUuid = UUID.fromString(args[1]);
+                            plugin.getDatabase().getUserData(user, versionUuid).thenAccept(data -> data.ifPresentOrElse(
+                                    userData -> showInventoryMenu(player, userData, user, false),
+                                    () -> plugin.getLocales().getLocale("error_invalid_version_uuid")
+                                            .ifPresent(player::sendMessage)));
+                        } catch (IllegalArgumentException e) {
+                            plugin.getLocales().getLocale("error_invalid_syntax",
+                                    "/inventory <player> [version_uuid]").ifPresent(player::sendMessage);
+                        }
+                    } else {
+                        // View (and edit) the latest user data
+                        plugin.getDatabase().getCurrentUserData(user).thenAccept(optionalData -> optionalData.ifPresentOrElse(
+                                versionedUserData -> showInventoryMenu(player, versionedUserData, user,
+                                        player.hasPermission(Permission.COMMAND_INVENTORY_EDIT.node)),
+                                () -> plugin.getLocales().getLocale("error_no_data_to_display")
+                                        .ifPresent(player::sendMessage)));
+                    }
+                }, () -> plugin.getLocales().getLocale("error_invalid_player")
+                        .ifPresent(player::sendMessage)));
+    }
+
+    private void showInventoryMenu(@NotNull OnlineUser player, @NotNull UserDataSnapshot userDataSnapshot,
+                                   @NotNull User dataOwner, boolean allowEdit) {
+        CompletableFuture.runAsync(() -> {
+            final UserData data = userDataSnapshot.userData();
+            data.getInventory().ifPresent(itemData -> {
+                // Show message
+                plugin.getLocales().getLocale("inventory_viewer_opened", dataOwner.username,
+                                new SimpleDateFormat("MMM dd yyyy, HH:mm:ss.sss")
+                                        .format(userDataSnapshot.versionTimestamp()))
+                        .ifPresent(player::sendMessage);
+
+                // Show inventory menu
+                player.showMenu(itemData, allowEdit, 5, plugin.getLocales()
+                                .getLocale("inventory_viewer_menu_title", dataOwner.username)
+                                .orElse(new MineDown("Inventory Viewer")))
+                        .exceptionally(throwable -> {
+                            plugin.log(Level.WARNING, "Exception displaying inventory menu to " + player.username, throwable);
+                            return Optional.empty();
+                        })
+                        .thenAccept(dataOnClose -> {
+                            if (dataOnClose.isEmpty() || !allowEdit) {
+                                return;
+                            }
+
+                            // Create the updated data
+                            final UserDataBuilder builder = UserData.builder(plugin.getMinecraftVersion());
+                            data.getStatus().ifPresent(builder::setStatus);
+                            data.getAdvancements().ifPresent(builder::setAdvancements);
+                            data.getLocation().ifPresent(builder::setLocation);
+                            data.getPersistentDataContainer().ifPresent(builder::setPersistentDataContainer);
+                            data.getStatistics().ifPresent(builder::setStatistics);
+                            data.getPotionEffects().ifPresent(builder::setPotionEffects);
+                            data.getEnderChest().ifPresent(builder::setEnderChest);
+                            builder.setInventory(dataOnClose.get());
+
+                            // Set the updated data
+                            final UserData updatedUserData = builder.build();
+                            plugin.getDatabase()
+                                    .setUserData(dataOwner, updatedUserData, DataSaveCause.INVENTORY_COMMAND)
+                                    .thenRun(() -> plugin.getRedisManager().sendUserDataUpdate(dataOwner, updatedUserData));
+                        });
+            });
+        });
+    }
+
+    @Override
+    public List<String> onTabComplete(@NotNull String[] args) {
+        return plugin.getOnlineUsers().stream().map(user -> user.username)
+                .filter(argument -> argument.startsWith(args.length >= 1 ? args[0] : ""))
+                .sorted().collect(Collectors.toList());
+    }
+}

common/src/main/java/net/william278/husksync/command/Permission.java

@@ -0,0 +1,120 @@
+/*
+ * This file is part of HuskSync, licensed under the Apache License 2.0.
+ *
+ *  Copyright (c) William278 <will27528@gmail.com>
+ *  Copyright (c) contributors
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+package net.william278.husksync.command;
+
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * Static plugin permission nodes required to execute commands
+ */
+public enum Permission {
+
+    /*
+     * /husksync command permissions
+     */
+
+    /**
+     * Lets the user use the {@code /husksync} command (subcommand permissions required)
+     */
+    COMMAND_HUSKSYNC("husksync.command.husksync", DefaultAccess.EVERYONE),
+    /**
+     * Lets the user view plugin info {@code /husksync info}
+     */
+    COMMAND_HUSKSYNC_ABOUT("husksync.command.husksync.info", DefaultAccess.EVERYONE),
+    /**
+     * Lets the user reload the plugin {@code /husksync reload}
+     */
+    COMMAND_HUSKSYNC_RELOAD("husksync.command.husksync.reload", DefaultAccess.OPERATORS),
+    /**
+     * Lets the user view the plugin version and check for updates {@code /husksync update}
+     */
+    COMMAND_HUSKSYNC_UPDATE("husksync.command.husksync.update", DefaultAccess.OPERATORS),
+
+    /*
+     * /userdata command permissions
+     */
+
+    /**
+     * Lets the user view user data {@code /userdata view/list (player) (version_uuid)}
+     */
+    COMMAND_USER_DATA("husksync.command.userdata", DefaultAccess.OPERATORS),
+    /**
+     * Lets the user restore and delete user data {@code /userdata restore/delete (player) (version_uuid)}
+     */
+    COMMAND_USER_DATA_MANAGE("husksync.command.userdata.manage", DefaultAccess.OPERATORS),
+
+    /**
+     * Lets the user dump user data to a file or the web {@code /userdata dump (player) (version_uuid)}
+     */
+    COMMAND_USER_DATA_DUMP("husksync.command.userdata.dump", DefaultAccess.NOBODY),
+
+    /*
+     * /inventory command permissions
+     */
+
+    /**
+     * Lets the user use the {@code /inventory (player)} command and view offline players' inventories
+     */
+    COMMAND_INVENTORY("husksync.command.inventory", DefaultAccess.OPERATORS),
+    /**
+     * Lets the user edit the contents of offline players' inventories
+     */
+    COMMAND_INVENTORY_EDIT("husksync.command.inventory.edit", DefaultAccess.OPERATORS),
+
+    /*
+     * /enderchest command permissions
+     */
+
+    /**
+     * Lets the user use the {@code /enderchest (player)} command and view offline players' ender chests
+     */
+    COMMAND_ENDER_CHEST("husksync.command.enderchest", DefaultAccess.OPERATORS),
+    /**
+     * Lets the user edit the contents of offline players' ender chests
+     */
+    COMMAND_ENDER_CHEST_EDIT("husksync.command.enderchest.edit", DefaultAccess.OPERATORS);
+
+
+    public final String node;
+    public final DefaultAccess defaultAccess;
+
+    Permission(@NotNull String node, @NotNull DefaultAccess defaultAccess) {
+        this.node = node;
+        this.defaultAccess = defaultAccess;
+    }
+
+    /**
+     * Identifies who gets what permissions by default
+     */
+    public enum DefaultAccess {
+        /**
+         * Everyone gets this permission node by default
+         */
+        EVERYONE,
+        /**
+         * Nobody gets this permission node by default
+         */
+        NOBODY,
+        /**
+         * Server operators ({@code /op}) get this permission node by default
+         */
+        OPERATORS
+    }
+}

common/src/main/java/net/william278/husksync/command/TabCompletable.java

@@ -0,0 +1,39 @@
+/*
+ * This file is part of HuskSync, licensed under the Apache License 2.0.
+ *
+ *  Copyright (c) William278 <will27528@gmail.com>
+ *  Copyright (c) contributors
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+package net.william278.husksync.command;
+
+import org.jetbrains.annotations.NotNull;
+
+import java.util.List;
+
+/**
+ * Interface providing tab completions for a command
+ */
+public interface TabCompletable {
+
+    /**
+     * What should be returned when the player or console attempts to TAB-complete a command
+     *
+     * @param args Current command arguments
+     * @return List of String arguments to offer TAB suggestions
+     */
+    List<String> onTabComplete(@NotNull String[] args);
+
+}

common/src/main/java/net/william278/husksync/command/UserDataCommand.java

@@ -0,0 +1,328 @@
+/*
+ * This file is part of HuskSync, licensed under the Apache License 2.0.
+ *
+ *  Copyright (c) William278 <will27528@gmail.com>
+ *  Copyright (c) contributors
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+package net.william278.husksync.command;
+
+import net.william278.husksync.HuskSync;
+import net.william278.husksync.data.DataSaveCause;
+import net.william278.husksync.data.UserData;
+import net.william278.husksync.player.OnlineUser;
+import net.william278.husksync.util.DataDumper;
+import net.william278.husksync.util.DataSnapshotList;
+import org.jetbrains.annotations.NotNull;
+
+import java.io.IOException;
+import java.util.*;
+import java.util.concurrent.CompletableFuture;
+import java.util.logging.Level;
+import java.util.stream.Collectors;
+
+public class UserDataCommand extends CommandBase implements TabCompletable {
+
+    private final String[] COMMAND_ARGUMENTS = {"view", "list", "delete", "restore", "pin", "dump"};
+
+    public UserDataCommand(@NotNull HuskSync implementor) {
+        super("userdata", Permission.COMMAND_USER_DATA, implementor, "playerdata");
+    }
+
+    @Override
+    public void onExecute(@NotNull OnlineUser player, @NotNull String[] args) {
+        if (args.length < 1) {
+            plugin.getLocales().getLocale("error_invalid_syntax",
+                            "/userdata <view/list/delete/restore/pin/dump> <username> [version_uuid]")
+                    .ifPresent(player::sendMessage);
+            return;
+        }
+
+        switch (args[0].toLowerCase(Locale.ENGLISH)) {
+            case "view" -> {
+                if (args.length < 2) {
+                    plugin.getLocales().getLocale("error_invalid_syntax",
+                                    "/userdata view <username> [version_uuid]")
+                            .ifPresent(player::sendMessage);
+                    return;
+                }
+                final String username = args[1];
+                if (args.length >= 3) {
+                    try {
+                        final UUID versionUuid = UUID.fromString(args[2]);
+                        CompletableFuture.runAsync(() -> plugin.getDatabase()
+                                .getUserByName(username.toLowerCase(Locale.ENGLISH))
+                                .thenAccept(optionalUser -> optionalUser
+                                        .ifPresentOrElse(user -> plugin.getDatabase().getUserData(user, versionUuid)
+                                                        .thenAccept(data -> data.ifPresentOrElse(
+                                                                userData -> userData.displayDataOverview(player, user, plugin.getLocales()),
+                                                                () -> plugin.getLocales().getLocale("error_invalid_version_uuid")
+                                                                        .ifPresent(player::sendMessage))),
+                                                () -> plugin.getLocales().getLocale("error_invalid_player")
+                                                        .ifPresent(player::sendMessage))));
+                    } catch (IllegalArgumentException e) {
+                        plugin.getLocales().getLocale("error_invalid_syntax",
+                                        "/userdata view <username> [version_uuid]")
+                                .ifPresent(player::sendMessage);
+                    }
+                } else {
+                    CompletableFuture.runAsync(() -> plugin.getDatabase()
+                            .getUserByName(username.toLowerCase(Locale.ENGLISH))
+                            .thenAccept(optionalUser -> optionalUser
+                                    .ifPresentOrElse(user -> plugin.getDatabase().getCurrentUserData(user)
+                                                    .thenAccept(latestData -> latestData.ifPresentOrElse(
+                                                            userData -> userData.displayDataOverview(player, user, plugin.getLocales()),
+                                                            () -> plugin.getLocales().getLocale("error_no_data_to_display")
+                                                                    .ifPresent(player::sendMessage))),
+                                            () -> plugin.getLocales().getLocale("error_invalid_player")
+                                                    .ifPresent(player::sendMessage))));
+                }
+            }
+            case "list" -> {
+                if (!player.hasPermission(Permission.COMMAND_USER_DATA_MANAGE.node)) {
+                    plugin.getLocales().getLocale("error_no_permission").ifPresent(player::sendMessage);
+                    return;
+                }
+                if (args.length < 2) {
+                    plugin.getLocales().getLocale("error_invalid_syntax",
+                                    "/userdata list <username> [page]")
+                            .ifPresent(player::sendMessage);
+                    return;
+                }
+                final String username = args[1];
+                CompletableFuture.runAsync(() -> plugin.getDatabase()
+                        .getUserByName(username.toLowerCase(Locale.ENGLISH))
+                        .thenAccept(optionalUser -> optionalUser.ifPresentOrElse(
+                                user -> plugin.getDatabase().getUserData(user).thenAccept(dataList -> {
+                                    // Check if there is data to display
+                                    if (dataList.isEmpty()) {
+                                        plugin.getLocales().getLocale("error_no_data_to_display")
+                                                .ifPresent(player::sendMessage);
+                                        return;
+                                    }
+
+                                    // Determine page to display
+                                    int page = 1;
+                                    if (args.length >= 3) {
+                                        try {
+                                            page = Integer.parseInt(args[2]);
+                                        } catch (NumberFormatException e) {
+                                            plugin.getLocales().getLocale("error_invalid_syntax",
+                                                            "/userdata list <username> [page]")
+                                                    .ifPresent(player::sendMessage);
+                                            return;
+                                        }
+                                    }
+
+                                    // Show the list to the player
+                                    DataSnapshotList.create(dataList, user, plugin.getLocales())
+                                            .displayPage(player, page);
+                                }),
+                                () -> plugin.getLocales().getLocale("error_invalid_player")
+                                        .ifPresent(player::sendMessage))));
+            }
+            case "delete" -> {
+                if (!player.hasPermission(Permission.COMMAND_USER_DATA_MANAGE.node)) {
+                    plugin.getLocales().getLocale("error_no_permission").ifPresent(player::sendMessage);
+                    return;
+                }
+                // Delete user data by specified UUID
+                if (args.length < 3) {
+                    plugin.getLocales().getLocale("error_invalid_syntax",
+                                    "/userdata delete <username> <version_uuid>")
+                            .ifPresent(player::sendMessage);
+                    return;
+                }
+                final String username = args[1];
+                try {
+                    final UUID versionUuid = UUID.fromString(args[2]);
+                    CompletableFuture.runAsync(() -> plugin.getDatabase()
+                            .getUserByName(username.toLowerCase(Locale.ENGLISH))
+                            .thenAccept(optionalUser -> optionalUser.ifPresentOrElse(
+                                    user -> plugin.getDatabase().deleteUserData(user, versionUuid).thenAccept(deleted -> {
+                                        if (deleted) {
+                                            plugin.getLocales().getLocale("data_deleted",
+                                                            versionUuid.toString().split("-")[0],
+                                                            versionUuid.toString(),
+                                                            user.username,
+                                                            user.uuid.toString())
+                                                    .ifPresent(player::sendMessage);
+                                        } else {
+                                            plugin.getLocales().getLocale("error_invalid_version_uuid")
+                                                    .ifPresent(player::sendMessage);
+                                        }
+                                    }),
+                                    () -> plugin.getLocales().getLocale("error_invalid_player")
+                                            .ifPresent(player::sendMessage))));
+                } catch (IllegalArgumentException e) {
+                    plugin.getLocales().getLocale("error_invalid_syntax",
+                                    "/userdata delete <username> <version_uuid>")
+                            .ifPresent(player::sendMessage);
+                }
+            }
+            case "restore" -> {
+                if (!player.hasPermission(Permission.COMMAND_USER_DATA_MANAGE.node)) {
+                    plugin.getLocales().getLocale("error_no_permission").ifPresent(player::sendMessage);
+                    return;
+                }
+                // Get user data by specified uuid and username
+                if (args.length < 3) {
+                    plugin.getLocales().getLocale("error_invalid_syntax",
+                                    "/userdata restore <username> <version_uuid>")
+                            .ifPresent(player::sendMessage);
+                    return;
+                }
+                final String username = args[1];
+                try {
+                    final UUID versionUuid = UUID.fromString(args[2]);
+                    CompletableFuture.runAsync(() -> plugin.getDatabase()
+                            .getUserByName(username.toLowerCase(Locale.ENGLISH))
+                            .thenAccept(optionalUser -> optionalUser.ifPresentOrElse(
+                                    user -> plugin.getDatabase().getUserData(user, versionUuid).thenAccept(data -> {
+                                        if (data.isEmpty()) {
+                                            plugin.getLocales().getLocale("error_invalid_version_uuid")
+                                                    .ifPresent(player::sendMessage);
+                                            return;
+                                        }
+
+                                        // Restore users with a minimum of one health (prevent restoring players with <=0 health)
+                                        final UserData userData = data.get().userData();
+                                        userData.getStatus().ifPresent(status -> status.health = Math.max(1, status.health));
+
+                                        // Set the users data and send a message
+                                        plugin.getDatabase().setUserData(user, userData, DataSaveCause.BACKUP_RESTORE);
+                                        plugin.getRedisManager().sendUserDataUpdate(user, data.get().userData()).join();
+                                        plugin.getLocales().getLocale("data_restored",
+                                                        user.username,
+                                                        user.uuid.toString(),
+                                                        versionUuid.toString().split("-")[0],
+                                                        versionUuid.toString())
+                                                .ifPresent(player::sendMessage);
+                                    }),
+                                    () -> plugin.getLocales().getLocale("error_invalid_player")
+                                            .ifPresent(player::sendMessage))));
+                } catch (IllegalArgumentException e) {
+                    plugin.getLocales().getLocale("error_invalid_syntax",
+                                    "/userdata restore <username> <version_uuid>")
+                            .ifPresent(player::sendMessage);
+                }
+            }
+            case "pin" -> {
+                if (!player.hasPermission(Permission.COMMAND_USER_DATA_MANAGE.node)) {
+                    plugin.getLocales().getLocale("error_no_permission").ifPresent(player::sendMessage);
+                    return;
+                }
+                if (args.length < 3) {
+                    plugin.getLocales().getLocale("error_invalid_syntax",
+                                    "/userdata pin <username> <version_uuid>")
+                            .ifPresent(player::sendMessage);
+                    return;
+                }
+
+                final String username = args[1];
+                try {
+                    final UUID versionUuid = UUID.fromString(args[2]);
+                    CompletableFuture.runAsync(() -> plugin.getDatabase()
+                            .getUserByName(username.toLowerCase(Locale.ENGLISH))
+                            .thenAccept(optionalUser -> optionalUser.ifPresentOrElse(
+                                    user -> plugin.getDatabase().getUserData(user, versionUuid).thenAccept(
+                                            optionalUserData -> optionalUserData.ifPresentOrElse(userData -> {
+                                                if (userData.pinned()) {
+                                                    plugin.getDatabase().unpinUserData(user, versionUuid).join();
+                                                    plugin.getLocales().getLocale("data_unpinned",
+                                                                    versionUuid.toString().split("-")[0],
+                                                                    versionUuid.toString(),
+                                                                    user.username,
+                                                                    user.uuid.toString())
+                                                            .ifPresent(player::sendMessage);
+                                                } else {
+                                                    plugin.getDatabase().pinUserData(user, versionUuid).join();
+                                                    plugin.getLocales().getLocale("data_pinned",
+                                                                    versionUuid.toString().split("-")[0],
+                                                                    versionUuid.toString(),
+                                                                    user.username,
+                                                                    user.uuid.toString())
+                                                            .ifPresent(player::sendMessage);
+                                                }
+                                            }, () -> plugin.getLocales().getLocale("error_invalid_version_uuid")
+                                                    .ifPresent(player::sendMessage))),
+                                    () -> plugin.getLocales().getLocale("error_invalid_player")
+                                            .ifPresent(player::sendMessage))));
+                } catch (IllegalArgumentException e) {
+                    plugin.getLocales().getLocale("error_invalid_syntax",
+                                    "/userdata pin <username> <version_uuid>")
+                            .ifPresent(player::sendMessage);
+                }
+            }
+            case "dump" -> {
+                if (!player.hasPermission(Permission.COMMAND_USER_DATA_DUMP.node)) {
+                    plugin.getLocales().getLocale("error_no_permission").ifPresent(player::sendMessage);
+                    return;
+                }
+                if (args.length < 3) {
+                    plugin.getLocales().getLocale("error_invalid_syntax",
+                                    "/userdata dump <username> <version_uuid>")
+                            .ifPresent(player::sendMessage);
+                    return;
+                }
+
+                final boolean toWeb = args.length > 3 && args[3].equalsIgnoreCase("web");
+                final String username = args[1];
+                try {
+                    final UUID versionUuid = UUID.fromString(args[2]);
+                    CompletableFuture.runAsync(() -> plugin.getDatabase()
+                            .getUserByName(username.toLowerCase(Locale.ENGLISH))
+                            .thenAccept(optionalUser -> optionalUser.ifPresentOrElse(
+                                    user -> plugin.getDatabase().getUserData(user, versionUuid).thenAccept(
+                                            optionalUserData -> optionalUserData.ifPresentOrElse(userData -> {
+                                                try {
+                                                    final DataDumper dumper = DataDumper.create(userData, user, plugin);
+                                                    final String result = toWeb ? dumper.toWeb() : dumper.toFile();
+                                                    plugin.getLocales().getLocale("data_dumped", versionUuid.toString()
+                                                                    .split("-")[0], user.username, result)
+                                                            .ifPresent(player::sendMessage);
+                                                } catch (IOException e) {
+                                                    plugin.log(Level.SEVERE, "Failed to dump user data", e);
+                                                }
+                                            }, () -> plugin.getLocales().getLocale("error_invalid_version_uuid")
+                                                    .ifPresent(player::sendMessage))),
+                                    () -> plugin.getLocales().getLocale("error_invalid_player")
+                                            .ifPresent(player::sendMessage))));
+                } catch (IllegalArgumentException e) {
+                    plugin.getLocales().getLocale("error_invalid_syntax",
+                                    "/userdata dump <username> <version_uuid>")
+                            .ifPresent(player::sendMessage);
+                }
+            }
+        }
+    }
+
+    @Override
+    public List<String> onTabComplete(@NotNull String[] args) {
+        switch (args.length) {
+            case 0, 1 -> {
+                return Arrays.stream(COMMAND_ARGUMENTS)
+                        .filter(argument -> argument.startsWith(args.length == 1 ? args[0] : ""))
+                        .sorted().collect(Collectors.toList());
+            }
+            case 2 -> {
+                return plugin.getOnlineUsers().stream().map(user -> user.username)
+                        .filter(argument -> argument.startsWith(args[1]))
+                        .sorted().collect(Collectors.toList());
+            }
+        }
+        return Collections.emptyList();
+    }
+}

common/src/main/java/net/william278/husksync/config/Locales.java

@@ -0,0 +1,192 @@
+/*
+ * This file is part of HuskSync, licensed under the Apache License 2.0.
+ *
+ *  Copyright (c) William278 <will27528@gmail.com>
+ *  Copyright (c) contributors
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+package net.william278.husksync.config;
+
+import de.themoep.minedown.adventure.MineDown;
+import net.william278.annotaml.YamlFile;
+import net.william278.paginedown.ListOptions;
+import org.apache.commons.text.StringEscapeUtils;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Optional;
+
+/**
+ * Loaded locales used by the plugin to display styled messages
+ */
+@YamlFile(rootedMap = true, header = """
+        ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
+        ┃       HuskSync Locales       ┃
+        ┃    Developed by William278   ┃
+        ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
+        ┣╸ See plugin about menu for international locale credits
+        ┣╸ Formatted in MineDown: https://github.com/Phoenix616/MineDown
+        ┗╸ Translate HuskSync: https://william278.net/docs/husksync/Translations""")
+public class Locales {
+
+    /**
+     * The raw set of locales loaded from yaml
+     */
+    @NotNull
+    public Map<String, String> rawLocales = new HashMap<>();
+
+    /**
+     * Returns a raw, un-formatted locale loaded from the locales file
+     *
+     * @param localeId String identifier of the locale, corresponding to a key in the file
+     * @return An {@link Optional} containing the locale corresponding to the id, if it exists
+     */
+    public Optional<String> getRawLocale(@NotNull String localeId) {
+        return Optional.ofNullable(rawLocales.get(localeId)).map(StringEscapeUtils::unescapeJava);
+    }
+
+    /**
+     * Returns a raw, un-formatted locale loaded from the locales file, with replacements applied
+     * <p>
+     * Note that replacements will not be MineDown-escaped; use {@link #escapeMineDown(String)} to escape replacements
+     *
+     * @param localeId     String identifier of the locale, corresponding to a key in the file
+     * @param replacements Ordered array of replacement strings to fill in placeholders with
+     * @return An {@link Optional} containing the replacement-applied locale corresponding to the id, if it exists
+     */
+    public Optional<String> getRawLocale(@NotNull String localeId, @NotNull String... replacements) {
+        return getRawLocale(localeId).map(locale -> applyReplacements(locale, replacements));
+    }
+
+    /**
+     * Returns a MineDown-formatted locale from the locales file
+     *
+     * @param localeId String identifier of the locale, corresponding to a key in the file
+     * @return An {@link Optional} containing the formatted locale corresponding to the id, if it exists
+     */
+    public Optional<MineDown> getLocale(@NotNull String localeId) {
+        return getRawLocale(localeId).map(MineDown::new);
+    }
+
+    /**
+     * Returns a MineDown-formatted locale from the locales file, with replacements applied
+     * <p>
+     * Note that replacements will be MineDown-escaped before application
+     *
+     * @param localeId     String identifier of the locale, corresponding to a key in the file
+     * @param replacements Ordered array of replacement strings to fill in placeholders with
+     * @return An {@link Optional} containing the replacement-applied, formatted locale corresponding to the id, if it exists
+     */
+    public Optional<MineDown> getLocale(@NotNull String localeId, @NotNull String... replacements) {
+        return getRawLocale(localeId, Arrays.stream(replacements).map(Locales::escapeMineDown)
+                .toArray(String[]::new)).map(MineDown::new);
+    }
+
+    /**
+     * Apply placeholder replacements to a raw locale
+     *
+     * @param rawLocale    The raw, unparsed locale
+     * @param replacements Ordered array of replacement strings to fill in placeholders with
+     * @return the raw locale, with inserted placeholders
+     */
+    @NotNull
+    private String applyReplacements(@NotNull String rawLocale, @NotNull String... replacements) {
+        int replacementIndexer = 1;
+        for (String replacement : replacements) {
+            String replacementString = "%" + replacementIndexer + "%";
+            rawLocale = rawLocale.replace(replacementString, replacement);
+            replacementIndexer += 1;
+        }
+        return rawLocale;
+    }
+
+    /**
+     * Escape a string from {@link MineDown} formatting for use in a MineDown-formatted locale
+     * <p>
+     * Although MineDown provides {@link MineDown#escape(String)}, that method fails to escape events
+     * properly when using the escaped string in a replacement, so this is used instead
+     *
+     * @param string The string to escape
+     * @return The escaped string
+     */
+    @NotNull
+    public static String escapeMineDown(@NotNull String string) {
+        final StringBuilder value = new StringBuilder();
+        for (int i = 0; i < string.length(); ++i) {
+            char c = string.charAt(i);
+            boolean isEscape = c == '\\';
+            boolean isColorCode = i + 1 < string.length() && (c == 167 || c == '&');
+            boolean isEvent = c == '[' || c == ']' || c == '(' || c == ')';
+            if (isEscape || isColorCode || isEvent) {
+                value.append('\\');
+            }
+
+            value.append(c);
+        }
+        return value.toString();
+    }
+
+    /**
+     * Truncates a String to a specified length, and appends an ellipsis if it is longer than the specified length
+     *
+     * @param string The string to truncate
+     * @param length The maximum length of the string
+     * @return The truncated string
+     */
+    @NotNull
+    public static String truncate(@NotNull String string, int length) {
+        if (string.length() > length) {
+            return string.substring(0, length) + "…";
+        }
+        return string;
+    }
+
+    /**
+     * Returns the base list options to use for a paginated chat list
+     *
+     * @param itemsPerPage The number of items to display per page
+     * @return The list options
+     */
+    @NotNull
+    public ListOptions.Builder getBaseChatList(int itemsPerPage) {
+        return new ListOptions.Builder()
+                .setFooterFormat(getRawLocale("list_footer",
+                        "%previous_page_button%", "%current_page%",
+                        "%total_pages%", "%next_page_button%", "%page_jumpers%").orElse(""))
+                .setNextButtonFormat(getRawLocale("list_next_page_button",
+                        "%next_page_index%", "%command%").orElse(""))
+                .setPreviousButtonFormat(getRawLocale("list_previous_page_button",
+                        "%previous_page_index%", "%command%").orElse(""))
+                .setPageJumpersFormat(getRawLocale("list_page_jumpers",
+                        "%page_jump_buttons%").orElse(""))
+                .setPageJumperPageFormat(getRawLocale("list_page_jumper_button",
+                        "%target_page_index%", "%command%").orElse(""))
+                .setPageJumperCurrentPageFormat(getRawLocale("list_page_jumper_current_page",
+                        "%current_page%").orElse(""))
+                .setPageJumperPageSeparator(getRawLocale("list_page_jumper_separator").orElse(""))
+                .setPageJumperGroupSeparator(getRawLocale("list_page_jumper_group_separator").orElse(""))
+                .setItemsPerPage(itemsPerPage)
+                .setEscapeItemsMineDown(false)
+                .setSpaceAfterHeader(false)
+                .setSpaceBeforeFooter(false);
+    }
+
+    @SuppressWarnings("unused")
+    public Locales() {
+    }
+
+}

common/src/main/java/net/william278/husksync/config/Settings.java

@@ -0,0 +1,444 @@
+/*
+ * This file is part of HuskSync, licensed under the Apache License 2.0.
+ *
+ *  Copyright (c) William278 <will27528@gmail.com>
+ *  Copyright (c) contributors
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+package net.william278.husksync.config;
+
+import net.william278.annotaml.YamlComment;
+import net.william278.annotaml.YamlFile;
+import net.william278.annotaml.YamlKey;
+import net.william278.husksync.database.Database;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.*;
+
+/**
+ * Plugin settings, read from config.yml
+ */
+@YamlFile(header = """
+        ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
+        ┃        HuskSync Config       ┃
+        ┃    Developed by William278   ┃
+        ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
+        ┣╸ Information: https://william278.net/project/husksync
+        ┗╸ Documentation: https://william278.net/docs/husksync""",
+        versionField = "config_version", versionNumber = 4)
+public class Settings {
+
+    // Top-level settings
+    @YamlKey("language")
+    private String language = "en-gb";
+
+    @YamlKey("check_for_updates")
+    private boolean checkForUpdates = true;
+
+    @YamlKey("cluster_id")
+    private String clusterId = "";
+
+    @YamlKey("debug_logging")
+    private boolean debugLogging = false;
+
+
+    // Database settings
+    @YamlComment("Type of database to use (MYSQL, SQLITE)")
+    @YamlKey("database.type")
+    private Database.Type databaseType = Database.Type.MYSQL;
+    
+    @YamlComment("Database connection settings")
+    @YamlKey("database.credentials.host")
+    private String mySqlHost = "localhost";
+
+    @YamlKey("database.credentials.port")
+    private int mySqlPort = 3306;
+
+    @YamlKey("database.credentials.database")
+    private String mySqlDatabase = "HuskSync";
+
+    @YamlKey("database.credentials.username")
+    private String mySqlUsername = "root";
+
+    @YamlKey("database.credentials.password")
+    private String mySqlPassword = "pa55w0rd";
+
+    @YamlKey("database.credentials.parameters")
+    private String mySqlConnectionParameters = "?autoReconnect=true&useSSL=false";
+
+    @YamlComment("MySQL connection pool properties")
+    @YamlKey("database.connection_pool.maximum_pool_size")
+    private int mySqlConnectionPoolSize = 10;
+
+    @YamlKey("database.connection_pool.minimum_idle")
+    private int mySqlConnectionPoolIdle = 10;
+
+    @YamlKey("database.connection_pool.maximum_lifetime")
+    private long mySqlConnectionPoolLifetime = 1800000;
+
+    @YamlKey("database.connection_pool.keepalive_time")
+    private long mySqlConnectionPoolKeepAlive = 0;
+
+    @YamlKey("database.connection_pool.connection_timeout")
+    private long mySqlConnectionPoolTimeout = 5000;
+
+    @YamlKey("database.table_names")
+    private Map<String, String> tableNames = TableName.getDefaults();
+
+
+    // Redis settings
+    @YamlComment("Redis connection settings")
+    @YamlKey("redis.credentials.host")
+    private String redisHost = "localhost";
+
+    @YamlKey("redis.credentials.port")
+    private int redisPort = 6379;
+
+    @YamlKey("redis.credentials.password")
+    private String redisPassword = "";
+
+    @YamlKey("redis.use_ssl")
+    private boolean redisUseSsl = false;
+
+
+    // Synchronization settings
+    @YamlComment("Synchronization settings")
+    @YamlKey("synchronization.max_user_data_snapshots")
+    private int maxUserDataSnapshots = 5;
+
+    @YamlKey("synchronization.save_on_world_save")
+    private boolean saveOnWorldSave = true;
+
+    @YamlKey("synchronization.save_on_death")
+    private boolean saveOnDeath = false;
+
+    @YamlKey("synchronization.save_empty_drops_on_death")
+    private boolean saveEmptyDropsOnDeath = true;
+
+    @YamlKey("synchronization.compress_data")
+    private boolean compressData = true;
+
+    @YamlKey("synchronization.notification_display_slot")
+    private NotificationDisplaySlot notificationDisplaySlot = NotificationDisplaySlot.ACTION_BAR;
+
+    @YamlKey("synchronization.synchronise_dead_players_changing_server")
+    private boolean synchroniseDeadPlayersChangingServer = true;
+
+    @YamlKey("synchronization.network_latency_milliseconds")
+    private int networkLatencyMilliseconds = 500;
+
+    @YamlKey("synchronization.features")
+    private Map<String, Boolean> synchronizationFeatures = SynchronizationFeature.getDefaults();
+
+    @YamlKey("synchronization.blacklisted_commands_while_locked")
+    private List<String> blacklistedCommandsWhileLocked = new ArrayList<>(List.of("*"));
+
+    @YamlKey("synchronization.event_priorities")
+    private Map<String, String> synchronizationEventPriorities = EventType.getDefaults();
+
+
+    // Zero-args constructor for instantiation via Annotaml
+    public Settings() {
+    }
+
+
+    @NotNull
+    public String getLanguage() {
+        return language;
+    }
+
+    public boolean doCheckForUpdates() {
+        return checkForUpdates;
+    }
+
+    @NotNull
+    public String getClusterId() {
+        return clusterId;
+    }
+
+    public boolean doDebugLogging() {
+        return debugLogging;
+    }
+
+
+    @NotNull
+    public Database.Type getDatabaseType() {
+        return databaseType;
+    }
+
+    @NotNull
+    public String getMySqlHost() {
+        return mySqlHost;
+    }
+
+    public int getMySqlPort() {
+        return mySqlPort;
+    }
+
+    @NotNull
+    public String getMySqlDatabase() {
+        return mySqlDatabase;
+    }
+
+    @NotNull
+    public String getMySqlUsername() {
+        return mySqlUsername;
+    }
+
+    @NotNull
+    public String getMySqlPassword() {
+        return mySqlPassword;
+    }
+
+    @NotNull
+    public String getMySqlConnectionParameters() {
+        return mySqlConnectionParameters;
+    }
+
+    @NotNull
+    public String getTableName(@NotNull TableName tableName) {
+        return tableNames.getOrDefault(tableName.name().toLowerCase(Locale.ENGLISH), tableName.defaultName);
+    }
+
+    public int getMySqlConnectionPoolSize() {
+        return mySqlConnectionPoolSize;
+    }
+
+    public int getMySqlConnectionPoolIdle() {
+        return mySqlConnectionPoolIdle;
+    }
+
+    public long getMySqlConnectionPoolLifetime() {
+        return mySqlConnectionPoolLifetime;
+    }
+
+    public long getMySqlConnectionPoolKeepAlive() {
+        return mySqlConnectionPoolKeepAlive;
+    }
+
+    public long getMySqlConnectionPoolTimeout() {
+        return mySqlConnectionPoolTimeout;
+    }
+
+    @NotNull
+    public String getRedisHost() {
+        return redisHost;
+    }
+
+    public int getRedisPort() {
+        return redisPort;
+    }
+
+    @NotNull
+    public String getRedisPassword() {
+        return redisPassword;
+    }
+
+    public boolean isRedisUseSsl() {
+        return redisUseSsl;
+    }
+
+    public int getMaxUserDataSnapshots() {
+        return maxUserDataSnapshots;
+    }
+
+    public boolean doSaveOnWorldSave() {
+        return saveOnWorldSave;
+    }
+
+    public boolean doSaveOnDeath() {
+        return saveOnDeath;
+    }
+
+    public boolean doSaveEmptyDropsOnDeath() {
+        return saveEmptyDropsOnDeath;
+    }
+
+    public boolean doCompressData() {
+        return compressData;
+    }
+
+    @NotNull
+    public NotificationDisplaySlot getNotificationDisplaySlot() {
+        return notificationDisplaySlot;
+    }
+
+    public boolean isSynchroniseDeadPlayersChangingServer() {
+        return synchroniseDeadPlayersChangingServer;
+    }
+
+    public int getNetworkLatencyMilliseconds() {
+        return networkLatencyMilliseconds;
+    }
+
+    @NotNull
+    public Map<String, Boolean> getSynchronizationFeatures() {
+        return synchronizationFeatures;
+    }
+
+    public boolean getSynchronizationFeature(@NotNull SynchronizationFeature feature) {
+        return getSynchronizationFeatures().getOrDefault(feature.name().toLowerCase(Locale.ENGLISH), feature.enabledByDefault);
+    }
+
+    @NotNull
+    public List<String> getBlacklistedCommandsWhileLocked() {
+        return blacklistedCommandsWhileLocked;
+    }
+
+    @NotNull
+    public EventPriority getEventPriority(@NotNull Settings.EventType eventType) {
+        try {
+            return EventPriority.valueOf(synchronizationEventPriorities.get(eventType.name().toLowerCase(Locale.ENGLISH)));
+        } catch (IllegalArgumentException e) {
+            e.printStackTrace();
+            return EventPriority.NORMAL;
+        }
+    }
+
+    /**
+     * Represents the names of tables in the database
+     */
+    public enum TableName {
+        USERS("husksync_users"),
+        USER_DATA("husksync_user_data");
+
+        private final String defaultName;
+
+        TableName(@NotNull String defaultName) {
+            this.defaultName = defaultName;
+        }
+
+        @NotNull
+        private Map.Entry<String, String> toEntry() {
+            return Map.entry(name().toLowerCase(Locale.ENGLISH), defaultName);
+        }
+
+        @SuppressWarnings("unchecked")
+        @NotNull
+        private static Map<String, String> getDefaults() {
+            return Map.ofEntries(Arrays.stream(values())
+                    .map(TableName::toEntry)
+                    .toArray(Map.Entry[]::new));
+        }
+    }
+
+    /**
+     * Determines the slot a system notification should be displayed in
+     */
+    public enum NotificationDisplaySlot {
+        /**
+         * Displays the notification in the action bar
+         */
+        ACTION_BAR,
+        /**
+         * Displays the notification in the chat
+         */
+        CHAT,
+        /**
+         * Displays the notification in an advancement toast
+         */
+        TOAST,
+        /**
+         * Does not display the notification
+         */
+        NONE
+    }
+
+    /**
+     * Represents enabled synchronisation features
+     */
+    public enum SynchronizationFeature {
+        INVENTORIES(true),
+        ENDER_CHESTS(true),
+        HEALTH(true),
+        MAX_HEALTH(true),
+        HUNGER(true),
+        EXPERIENCE(true),
+        POTION_EFFECTS(true),
+        ADVANCEMENTS(true),
+        GAME_MODE(true),
+        STATISTICS(true),
+        PERSISTENT_DATA_CONTAINER(false),
+        LOCKED_MAPS(false),
+        LOCATION(false);
+
+        private final boolean enabledByDefault;
+
+        SynchronizationFeature(boolean enabledByDefault) {
+            this.enabledByDefault = enabledByDefault;
+        }
+
+        @NotNull
+        private Map.Entry<String, Boolean> toEntry() {
+            return Map.entry(name().toLowerCase(Locale.ENGLISH), enabledByDefault);
+        }
+
+        @SuppressWarnings("unchecked")
+        @NotNull
+        private static Map<String, Boolean> getDefaults() {
+            return Map.ofEntries(Arrays.stream(values())
+                    .map(SynchronizationFeature::toEntry)
+                    .toArray(Map.Entry[]::new));
+        }
+    }
+
+    /**
+     * Represents events that HuskSync listens to, with a configurable priority listener
+     */
+    public enum EventType {
+        JOIN_LISTENER(EventPriority.LOWEST),
+        QUIT_LISTENER(EventPriority.LOWEST),
+        DEATH_LISTENER(EventPriority.NORMAL);
+
+        private final EventPriority defaultPriority;
+
+        EventType(@NotNull EventPriority defaultPriority) {
+            this.defaultPriority = defaultPriority;
+        }
+
+        @NotNull
+        private Map.Entry<String, String> toEntry() {
+            return Map.entry(name().toLowerCase(Locale.ENGLISH), defaultPriority.name());
+        }
+
+
+        @SuppressWarnings("unchecked")
+        @NotNull
+        private static Map<String, String> getDefaults() {
+            return Map.ofEntries(Arrays.stream(values())
+                    .map(EventType::toEntry)
+                    .toArray(Map.Entry[]::new));
+        }
+    }
+
+    /**
+     * Represents priorities for events that HuskSync listens to
+     */
+    public enum EventPriority {
+        /**
+         * Listens and processes the event execution last
+         */
+        HIGHEST,
+        /**
+         * Listens in between {@link #HIGHEST} and {@link #LOWEST} priority marked
+         */
+        NORMAL,
+        /**
+         * Listens and processes the event execution first
+         */
+        LOWEST
+    }
+
+}

common/src/main/java/net/william278/husksync/data/AdvancementData.java

@@ -0,0 +1,53 @@
+/*
+ * This file is part of HuskSync, licensed under the Apache License 2.0.
+ *
+ *  Copyright (c) William278 <will27528@gmail.com>
+ *  Copyright (c) contributors
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+package net.william278.husksync.data;
+
+import com.google.gson.annotations.SerializedName;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Date;
+import java.util.Map;
+
+/**
+ * A mapped piece of advancement data
+ */
+public class AdvancementData {
+
+    /**
+     * The advancement namespaced key
+     */
+    @SerializedName("key")
+    public String key;
+
+    /**
+     * A map of completed advancement criteria to when it was completed
+     */
+    @SerializedName("completed_criteria")
+    public Map<String, Date> completedCriteria;
+
+    public AdvancementData(@NotNull String key, @NotNull Map<String, Date> awardedCriteria) {
+        this.key = key;
+        this.completedCriteria = awardedCriteria;
+    }
+
+    @SuppressWarnings("unused")
+    protected AdvancementData() {
+    }
+}

common/src/main/java/net/william278/husksync/data/CompressedDataAdapter.java

@@ -0,0 +1,46 @@
+/*
+ * This file is part of HuskSync, licensed under the Apache License 2.0.
+ *
+ *  Copyright (c) William278 <will27528@gmail.com>
+ *  Copyright (c) contributors
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+package net.william278.husksync.data;
+
+import org.jetbrains.annotations.NotNull;
+import org.xerial.snappy.Snappy;
+
+import java.io.IOException;
+
+public class CompressedDataAdapter extends JsonDataAdapter {
+
+    @Override
+    public byte[] toBytes(@NotNull UserData data) throws DataAdaptionException {
+        try {
+            return Snappy.compress(super.toBytes(data));
+        } catch (IOException e) {
+            throw new DataAdaptionException("Failed to compress data", e);
+        }
+    }
+
+    @Override
+    public @NotNull UserData fromBytes(byte[] data) throws DataAdaptionException {
+        try {
+            return super.fromBytes(Snappy.uncompress(data));
+        } catch (IOException e) {
+            throw new DataAdaptionException("Failed to decompress data", e);
+        }
+    }
+}

common/src/main/java/net/william278/husksync/data/DataAdapter.java

@@ -0,0 +1,59 @@
+/*
+ * This file is part of HuskSync, licensed under the Apache License 2.0.
+ *
+ *  Copyright (c) William278 <will27528@gmail.com>
+ *  Copyright (c) contributors
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+package net.william278.husksync.data;
+
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * An adapter that adapts {@link UserData} to and from a portable byte array.
+ */
+public interface DataAdapter {
+
+    /**
+     * Converts {@link UserData} to a byte array
+     *
+     * @param data The {@link UserData} to adapt
+     * @return The byte array.
+     * @throws DataAdaptionException If an error occurred during adaptation.
+     */
+    byte[] toBytes(@NotNull UserData data) throws DataAdaptionException;
+
+    /**
+     * Serializes {@link UserData} to a JSON string.
+     *
+     * @param data   The {@link UserData} to serialize
+     * @param pretty Whether to pretty print the JSON.
+     * @return The output json string.
+     * @throws DataAdaptionException If an error occurred during adaptation.
+     */
+    @NotNull
+    String toJson(@NotNull UserData data, boolean pretty) throws DataAdaptionException;
+
+    /**
+     * Converts a byte array to {@link UserData}.
+     *
+     * @param data The byte array to adapt.
+     * @return The {@link UserData}.
+     * @throws DataAdaptionException If an error occurred during adaptation, such as if the byte array is invalid.
+     */
+    @NotNull
+    UserData fromBytes(final byte[] data) throws DataAdaptionException;
+
+}

common/src/main/java/net/william278/husksync/data/DataAdaptionException.java

@@ -0,0 +1,30 @@
+/*
+ * This file is part of HuskSync, licensed under the Apache License 2.0.
+ *
+ *  Copyright (c) William278 <will27528@gmail.com>
+ *  Copyright (c) contributors
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+package net.william278.husksync.data;
+
+/**
+ * Indicates an error occurred during {@link UserData} adaptation to and from (compressed) json.
+ */
+public class DataAdaptionException extends RuntimeException {
+    protected DataAdaptionException(String message, Throwable cause) {
+        super(message, cause);
+    }
+
+}

common/src/main/java/net/william278/husksync/data/DataSaveCause.java

@@ -0,0 +1,130 @@
+/*
+ * This file is part of HuskSync, licensed under the Apache License 2.0.
+ *
+ *  Copyright (c) William278 <will27528@gmail.com>
+ *  Copyright (c) contributors
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+package net.william278.husksync.data;
+
+import net.william278.husksync.api.BaseHuskSyncAPI;
+import net.william278.husksync.config.Locales;
+import net.william278.husksync.player.OnlineUser;
+import net.william278.husksync.player.User;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Locale;
+
+/**
+ * Identifies the cause of a player data save.
+ *
+ * @implNote This enum is saved in the database.
+ * </p>
+ * Cause names have a max length of 32 characters.
+ */
+public enum DataSaveCause {
+
+    /**
+     * Indicates data saved when a player disconnected from the server (either to change servers, or to log off)
+     *
+     * @since 2.0
+     */
+    DISCONNECT,
+    /**
+     * Indicates data saved when the world saved
+     *
+     * @since 2.0
+     */
+    WORLD_SAVE,
+    /**
+     * Indicates data saved when the user died
+     *
+     * @since 2.1
+     */
+    DEATH,
+    /**
+     * Indicates data saved when the server shut down
+     *
+     * @since 2.0
+     */
+    SERVER_SHUTDOWN,
+    /**
+     * Indicates data was saved by editing inventory contents via the {@code /inventory} command
+     *
+     * @since 2.0
+     */
+    INVENTORY_COMMAND,
+    /**
+     * Indicates data was saved by editing Ender Chest contents via the {@code /enderchest} command
+     *
+     * @since 2.0
+     */
+    ENDERCHEST_COMMAND,
+    /**
+     * Indicates data was saved by restoring it from a previous version
+     *
+     * @since 2.0
+     */
+    BACKUP_RESTORE,
+    /**
+     * Indicates data was saved by an API call
+     *
+     * @see BaseHuskSyncAPI#saveUserData(OnlineUser)
+     * @see BaseHuskSyncAPI#setUserData(User, UserData)
+     * @since 2.0
+     */
+    API,
+    /**
+     * Indicates data was saved from being imported from MySQLPlayerDataBridge
+     *
+     * @since 2.0
+     */
+    MPDB_MIGRATION,
+    /**
+     * Indicates data was saved from being imported from a legacy version (v1.x)
+     *
+     * @since 2.0
+     */
+    LEGACY_MIGRATION,
+    /**
+     * Indicates data was saved by an unknown cause.
+     * </p>
+     * This should not be used and is only used for error handling purposes.
+     *
+     * @since 2.0
+     */
+    UNKNOWN;
+
+    /**
+     * Returns a {@link DataSaveCause} by name.
+     *
+     * @return the {@link DataSaveCause} or {@link #UNKNOWN} if the name is not valid.
+     */
+    @NotNull
+    public static DataSaveCause getCauseByName(@NotNull String name) {
+        for (DataSaveCause cause : values()) {
+            if (cause.name().equalsIgnoreCase(name)) {
+                return cause;
+            }
+        }
+        return UNKNOWN;
+    }
+
+    @NotNull
+    public String getDisplayName() {
+        return Locales.truncate(name().toLowerCase(Locale.ENGLISH), 10);
+    }
+
+}

common/src/main/java/net/william278/husksync/data/DataSerializationException.java

@@ -0,0 +1,34 @@
+/*
+ * This file is part of HuskSync, licensed under the Apache License 2.0.
+ *
+ *  Copyright (c) William278 <will27528@gmail.com>
+ *  Copyright (c) contributors
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+package net.william278.husksync.data;
+
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * Indicates an error occurred during Base-64 serialization and deserialization of data.
+ * </p>
+ * For example, an exception deserializing {@link ItemData} item stack or {@link PotionEffectData} potion effect arrays
+ */
+public class DataSerializationException extends RuntimeException {
+    protected DataSerializationException(@NotNull String message, @NotNull Throwable cause) {
+        super(message, cause);
+    }
+
+}

common/src/main/java/net/william278/husksync/data/ItemData.java

@@ -0,0 +1,63 @@
+/*
+ * This file is part of HuskSync, licensed under the Apache License 2.0.
+ *
+ *  Copyright (c) William278 <will27528@gmail.com>
+ *  Copyright (c) contributors
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+package net.william278.husksync.data;
+
+import com.google.gson.annotations.SerializedName;
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * Stores information about the contents of a player's inventory or Ender Chest.
+ */
+public class ItemData {
+
+    /**
+     * A Base-64 string of platform-serialized items
+     */
+    @SerializedName("serialized_items")
+    public String serializedItems;
+
+    /**
+     * Get an empty item data object, representing an empty inventory or Ender Chest
+     *
+     * @return an empty item data object
+     */
+    @NotNull
+    public static ItemData empty() {
+        return new ItemData("");
+    }
+
+    public ItemData(@NotNull final String serializedItems) {
+        this.serializedItems = serializedItems;
+    }
+
+    @SuppressWarnings("unused")
+    protected ItemData() {
+    }
+
+    /**
+     * Check if the item data is empty
+     *
+     * @return {@code true} if the item data is empty; {@code false} otherwise
+     */
+    public boolean isEmpty() {
+        return serializedItems.isEmpty();
+    }
+
+}

common/src/main/java/net/william278/husksync/data/JsonDataAdapter.java

@@ -0,0 +1,48 @@
+/*
+ * This file is part of HuskSync, licensed under the Apache License 2.0.
+ *
+ *  Copyright (c) William278 <will27528@gmail.com>
+ *  Copyright (c) contributors
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+package net.william278.husksync.data;
+
+import com.google.gson.GsonBuilder;
+import com.google.gson.JsonSyntaxException;
+import org.jetbrains.annotations.NotNull;
+
+import java.nio.charset.StandardCharsets;
+
+public class JsonDataAdapter implements DataAdapter {
+
+    @Override
+    public byte[] toBytes(@NotNull UserData data) throws DataAdaptionException {
+        return toJson(data, false).getBytes(StandardCharsets.UTF_8);
+    }
+
+    @Override
+    public @NotNull String toJson(@NotNull UserData data, boolean pretty) throws DataAdaptionException {
+        return (pretty ? new GsonBuilder().setPrettyPrinting() : new GsonBuilder()).create().toJson(data);
+    }
+
+    @Override
+    public @NotNull UserData fromBytes(byte[] data) throws DataAdaptionException {
+        try {
+            return new GsonBuilder().create().fromJson(new String(data, StandardCharsets.UTF_8), UserData.class);
+        } catch (JsonSyntaxException e) {
+            throw new DataAdaptionException("Failed to parse JSON data", e);
+        }
+    }
+}

common/src/main/java/net/william278/husksync/data/LocationData.java

@@ -0,0 +1,92 @@
+/*
+ * This file is part of HuskSync, licensed under the Apache License 2.0.
+ *
+ *  Copyright (c) William278 <will27528@gmail.com>
+ *  Copyright (c) contributors
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+package net.william278.husksync.data;
+
+import com.google.gson.annotations.SerializedName;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.UUID;
+
+/**
+ * Stores information about a player's location
+ */
+public class LocationData {
+
+    /**
+     * Name of the world on the server
+     */
+    @SerializedName("world_name")
+    public String worldName;
+    /**
+     * Unique id of the world
+     */
+    @SerializedName("world_uuid")
+    public UUID worldUuid;
+    /**
+     * The environment type of the world (one of "NORMAL", "NETHER", "THE_END")
+     */
+    @SerializedName("world_environment")
+    public String worldEnvironment;
+
+    /**
+     * The x coordinate of the location
+     */
+    @SerializedName("x")
+    public double x;
+    /**
+     * The y coordinate of the location
+     */
+    @SerializedName("y")
+    public double y;
+    /**
+     * The z coordinate of the location
+     */
+    @SerializedName("z")
+    public double z;
+
+    /**
+     * The location's facing yaw angle
+     */
+    @SerializedName("yaw")
+    public float yaw;
+    /**
+     * The location's facing pitch angle
+     */
+    @SerializedName("pitch")
+    public float pitch;
+
+    public LocationData(@NotNull String worldName, @NotNull UUID worldUuid,
+                        @NotNull String worldEnvironment,
+                        double x, double y, double z,
+                        float yaw, float pitch) {
+        this.worldName = worldName;
+        this.worldUuid = worldUuid;
+        this.worldEnvironment = worldEnvironment;
+        this.x = x;
+        this.y = y;
+        this.z = z;
+        this.yaw = yaw;
+        this.pitch = pitch;
+    }
+
+    @SuppressWarnings("unused")
+    protected LocationData() {
+    }
+}

common/src/main/java/net/william278/husksync/data/PersistentDataContainerData.java

@@ -0,0 +1,73 @@
+/*
+ * This file is part of HuskSync, licensed under the Apache License 2.0.
+ *
+ *  Copyright (c) William278 <will27528@gmail.com>
+ *  Copyright (c) contributors
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+package net.william278.husksync.data;
+
+import com.google.gson.annotations.SerializedName;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Map;
+import java.util.Optional;
+import java.util.Set;
+
+/**
+ * Store's a user's persistent data container, holding a map of plugin-set persistent values
+ */
+public class PersistentDataContainerData {
+
+    /**
+     * Map of namespaced key strings to a byte array representing the persistent data
+     */
+    @SerializedName("persistent_data_map")
+    protected Map<String, PersistentDataTag<?>> persistentDataMap;
+
+    public PersistentDataContainerData(@NotNull Map<String, PersistentDataTag<?>> persistentDataMap) {
+        this.persistentDataMap = persistentDataMap;
+    }
+
+    @SuppressWarnings("unused")
+    protected PersistentDataContainerData() {
+    }
+
+    public <T> Optional<T> getTagValue(@NotNull String tagName, @NotNull Class<T> tagClass) {
+        if (!persistentDataMap.containsKey(tagName)) {
+            return Optional.empty();
+        }
+
+        // If the tag cannot be cast to the specified class, return an empty optional
+        final boolean canCast = tagClass.isAssignableFrom(persistentDataMap.get(tagName).value.getClass());
+        if (!canCast) {
+            return Optional.empty();
+        }
+
+        return Optional.of(tagClass.cast(persistentDataMap.get(tagName).value));
+    }
+
+    public Optional<PersistentDataTagType> getTagType(@NotNull String tagType) {
+        if (persistentDataMap.containsKey(tagType)) {
+            return PersistentDataTagType.getDataType(persistentDataMap.get(tagType).type);
+        }
+        return Optional.empty();
+    }
+
+    public Set<String> getTags() {
+        return persistentDataMap.keySet();
+    }
+
+}

common/src/main/java/net/william278/husksync/data/PersistentDataTag.java

@@ -0,0 +1,54 @@
+/*
+ * This file is part of HuskSync, licensed under the Apache License 2.0.
+ *
+ *  Copyright (c) William278 <will27528@gmail.com>
+ *  Copyright (c) contributors
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+package net.william278.husksync.data;
+
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Optional;
+
+/**
+ * Represents a persistent data tag set by a plugin.
+ */
+public class PersistentDataTag<T> {
+
+    /**
+     * The enumerated primitive data type name value of the tag
+     */
+    protected String type;
+
+    /**
+     * The value of the tag
+     */
+    public T value;
+
+    public PersistentDataTag(@NotNull PersistentDataTagType type, @NotNull T value) {
+        this.type = type.name();
+        this.value = value;
+    }
+
+    @SuppressWarnings("unused")
+    private PersistentDataTag() {
+    }
+
+    public Optional<PersistentDataTagType> getType() {
+        return PersistentDataTagType.getDataType(type);
+    }
+
+}

common/src/main/java/net/william278/husksync/data/PersistentDataTagType.java

@@ -0,0 +1,54 @@
+/*
+ * This file is part of HuskSync, licensed under the Apache License 2.0.
+ *
+ *  Copyright (c) William278 <will27528@gmail.com>
+ *  Copyright (c) contributors
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+package net.william278.husksync.data;
+
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Optional;
+
+/**
+ * Represents the type of a {@link PersistentDataTag}
+ */
+public enum PersistentDataTagType {
+
+    BYTE,
+    SHORT,
+    INTEGER,
+    LONG,
+    FLOAT,
+    DOUBLE,
+    STRING,
+    BYTE_ARRAY,
+    INTEGER_ARRAY,
+    LONG_ARRAY,
+    TAG_CONTAINER_ARRAY,
+    TAG_CONTAINER;
+
+
+    public static Optional<PersistentDataTagType> getDataType(@NotNull String typeName) {
+        for (PersistentDataTagType type : values()) {
+            if (type.name().equalsIgnoreCase(typeName)) {
+                return Optional.of(type);
+            }
+        }
+        return Optional.empty();
+    }
+
+}

common/src/main/java/net/william278/husksync/data/PotionEffectData.java

@@ -0,0 +1,41 @@
+/*
+ * This file is part of HuskSync, licensed under the Apache License 2.0.
+ *
+ *  Copyright (c) William278 <will27528@gmail.com>
+ *  Copyright (c) contributors
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+package net.william278.husksync.data;
+
+import com.google.gson.annotations.SerializedName;
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * Stores potion effect data
+ */
+public class PotionEffectData {
+
+    @SerializedName("serialized_potion_effects")
+    public String serializedPotionEffects;
+
+    public PotionEffectData(@NotNull final String serializedPotionEffects) {
+        this.serializedPotionEffects = serializedPotionEffects;
+    }
+
+    @SuppressWarnings("unused")
+    protected PotionEffectData() {
+    }
+
+}

common/src/main/java/net/william278/husksync/data/StatisticsData.java

@@ -0,0 +1,70 @@
+/*
+ * This file is part of HuskSync, licensed under the Apache License 2.0.
+ *
+ *  Copyright (c) William278 <will27528@gmail.com>
+ *  Copyright (c) contributors
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+package net.william278.husksync.data;
+
+import com.google.gson.annotations.SerializedName;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Map;
+
+/**
+ * Stores information about a player's statistics
+ */
+public class StatisticsData {
+
+    /**
+     * Map of generic statistic names to their values
+     */
+    @SerializedName("untyped_statistics")
+    public Map<String, Integer> untypedStatistics;
+
+    /**
+     * Map of block type statistics to a map of material types to values
+     */
+    @SerializedName("block_statistics")
+    public Map<String, Map<String, Integer>> blockStatistics;
+
+    /**
+     * Map of item type statistics to a map of material types to values
+     */
+    @SerializedName("item_statistics")
+    public Map<String, Map<String, Integer>> itemStatistics;
+
+    /**
+     * Map of entity type statistics to a map of entity types to values
+     */
+    @SerializedName("entity_statistics")
+    public Map<String, Map<String, Integer>> entityStatistics;
+
+    public StatisticsData(@NotNull Map<String, Integer> untypedStatistics,
+                          @NotNull Map<String, Map<String, Integer>> blockStatistics,
+                          @NotNull Map<String, Map<String, Integer>> itemStatistics,
+                          @NotNull Map<String, Map<String, Integer>> entityStatistics) {
+        this.untypedStatistics = untypedStatistics;
+        this.blockStatistics = blockStatistics;
+        this.itemStatistics = itemStatistics;
+        this.entityStatistics = entityStatistics;
+    }
+
+    @SuppressWarnings("unused")
+    protected StatisticsData() {
+    }
+
+}