Honor the configured Discord private-message format (#6644)

### Information

This PR fixes #6641.

### Details

**Proposed fix:**

Read the private-message format from `messages.pms-to-discord`, matching
the shipped config. The settings loader currently reads
`messages.private-chat` instead, so a custom format is ignored and the
default `[SocialSpy]` text is used.

Added settings tests that load real YAML files and check the custom
format, default fallback and reload, including placeholders and
apostrophes. The Discord module now includes the core project on its
test classpath.

**Environments tested:**

OS: Windows
Java version: Temurin 25.0.4.1+1

- [ ] Most recent Paper version
- [ ] CraftBukkit/Spigot/Paper 1.12.2
- [ ] CraftBukkit 1.8.8

The full Gradle build passes, including the new settings tests and
Checkstyle. Live Paper/Discord relay testing was not performed.

**Demonstration:**

The regression loads this configuration:

```yaml
messages:
  pms-to-discord: "[Privado] {sender-displayname} -> {receiver-displayname}: {message}"
```

Before the fix, the actual settings loader produces `[SocialSpy] sender
-> receiver: Hello`. After the fix, it produces `[Privado] Sender ->
Receiver: Hello`. The missing-key control keeps the existing default.

---------

Co-authored-by: Josh Roy <10731363+JRoy@users.noreply.github.com>

.claude/skills/mc-update/SKILL.md

@@ -0,0 +1,270 @@
+---
+name: mc-update
+description: Update EssentialsX for a new Minecraft version. Use when the user asks to update to, bump, or support a new Minecraft or Paper version (for example "update to 26.4", "add 26.3 mobs", "bump supported version"), or asks what must be checked for new mobs, items, wood types, armor, enchantments, potions, or Bukkit API changes.
+---
+
+# Minecraft update
+
+This checklist comes from every Minecraft update PR from 1.14 to 26.3, and from the fix PRs that followed them.
+
+Paths are relative to the repository root. `ESS` means `Essentials/src/main/java/com/earth2me/essentials`.
+
+## Procedure
+
+1. Find the old and new `paper-api` jars in `~/.gradle/caches/modules-2/files-2.1/io.papermc.paper/paper-api/`. If the new jar is not there, set `paperVersion` in `build-logic/src/main/kotlin/essentials.base-conventions.gradle.kts` and run `./gradlew :EssentialsX:compileJava` to download it.
+2. Diff the constants of these classes between the two jars: `org.bukkit.entity.EntityType`, `org.bukkit.Material`, `org.bukkit.enchantments.Enchantment`, `org.bukkit.potion.PotionEffectType`, `org.bukkit.potion.PotionType`, `org.bukkit.TreeType`, and each `*$Variant` class under `org.bukkit.entity`. Use this command for each class:
+
+   ```sh
+   unzip -p <jar> org/bukkit/entity/EntityType.class > /tmp/x.class && javap -p /tmp/x.class | grep 'public static final'
+   ```
+
+3. Sort each added, removed, or renamed constant into a section of part 2 or part 3 below.
+4. Do part 1. Then do each section that applies.
+5. Apply part 4 to every line you write.
+6. Run `./gradlew :EssentialsX:compileJava`. Fix errors.
+7. Do not commit unless the user asks.
+8. Report per section: what changed, and what you skipped and why.
+
+---
+
+## 1. Every update
+
+### 1.1 Version constants
+
+1. Open `ESS/utils/VersionUtil.java`.
+2. Add a constant `vXX_Y_R01 = BukkitVersion.fromString("XX.Y-R0.1-SNAPSHOT")`.
+   - For a patch release, change the string of the existing minor constant. Example: `v26_1_R01` holds `26.1.2`.
+   - For a minor release, add a new constant. Do not rename or delete an old constant. Old constants gate features. Deleting `v1_20_4_R01` caused #6460.
+3. Add the constant to `supportedVersions`. Keep the `ImmutableSet.of(...)` syntax. `build-logic/src/main/kotlin/VersionDataTask.kt` parses it with a regex.
+4. Start a server. Confirm `BukkitVersion.fromString(Bukkit.getBukkitVersion())` parses. Spigot 1.14.3 and Paper 26.1 both changed the string format.
+
+### 1.2 Documentation
+
+1. Update the supported versions sentence in `README.md`.
+2. Regenerate `items.json` with ItemDbGenerator.
+
+---
+
+## 2. New content
+
+### 2.1 New mob
+
+1. Add an entry to `ESS/Mob.java`: `NAME("CamelName", Enemies.X, "ENTITY_TYPE")`.
+   - Use the string constructor. Do not use `EntityType.X`. The constant does not exist on old servers.
+   - Set the plural suffix if it is not `s`. Fish use `""`. Fox uses `es`.
+   - The display name must not contain a space.
+   - Boats and rafts are also `Mob` entries.
+2. Add `EntityType` constant to `ESS/MobCompat.java` only if `MobData` needs it.
+3. Add the mob to `protect.prevent.spawn` in `Essentials/src/main/resources/config.yml`.
+4. Check `entityToDisplayName` in `providers/BaseProviders/.../SpawnerItemProvider.java` if the enum name does not title-case well.
+
+### 2.2 New mob variant or data
+
+1. Add entries to `ESS/MobData.java`. Use the string form `"kind:VARIANT"`. Example: `"wolf:PALE"`.
+2. Add a `case "kind":` to the `setData` switch.
+3. Add `setKindVariant(Entity, String)` to `MobCompat.java`. Gate it with `VersionUtil.getServerBukkitVersion().isLowerThan(vXX_Y_R01)`.
+4. Use `RegistryUtil.valueOf(Variant.class, name)` for registry types. Do not use `Enum.valueOf`.
+5. Do not call `NewClass.Variant.values()` in an enum initializer. Axolotl did this. It threw `NoClassDefFoundError` on 1.16 (#4376).
+6. Catch `Throwable` around reflective lookups. Cow variant threw NPE on old servers (#6121).
+7. For a boolean flag, add a `Data` constant and a branch in `setData`. Example: `GOAT_SCREAMING`.
+
+### 2.3 New rideable or saddle mob
+
+1. Add `SADDLE_<MOB>` to `MobData.java` with a `Data.<MOB>SADDLE` constant.
+2. Add `set<Mob>Saddle(Entity, Player)` to `MobCompat.java`. Tame the mob. Set the owner. Set the saddle.
+3. Check `ESS/craftbukkit/Inventories.java` if the mob adds a player inventory slot. Body and saddle slots (41, 42) broke `/clearinventory` in 1.21.6 (#6218).
+
+### 2.4 New item or block
+
+1. Check each `MaterialUtil` set that lists names by hand. See table.
+2. Check `ESS/utils/LocationUtil.java`:
+   - Add a block that hurts a standing player to `DAMAGING_TYPES`. Magma, campfire, berry bush and wither rose were missed for 2 years (#3537).
+   - `HOLLOW_MATERIALS` comes from `Material.isTransparent()`. Add a passable block that is not transparent. Example: `LIGHT` (#4601). Remove a transparent block that is solid. Examples: `BARRIER`, `DIRT_PATH`, `FARMLAND`.
+3. Check for a new event that reveals player position. Sculk sensor needed vanish handling in `EssentialsPlayerListener` (#5262).
+
+| `ESS/utils/MaterialUtil.java` set | Add when |
+|---|---|
+| `HELMETS`, `CHESTPLATES`, `LEGGINGS`, `BOOTS` | New armor tier |
+| `LEATHER_ARMOR` | New dyeable armor |
+| `BEDS` | New bed. `STRAW_BED` in 26.3. |
+| `BANNERS` | New banner colour |
+| `SIGN_POSTS`, `WALL_SIGNS`, `HANGING_SIGNS`, `HANGING_WALL_SIGNS` | New wood type |
+| `MOB_HEADS` | New head. `PIGLIN_HEAD` in 1.20. |
+| `POTIONS` | New potion container |
+| `EDITABLE_BOOKS` | New book type |
+| `FIREWORKS`, `FIREWORK_CHARGE` | New firework item |
+
+`EnumUtil.getAllMatching` skips a name that does not exist. Adding a name is safe on old servers.
+
+### 2.5 Renamed item, block or entity
+
+1. Grep `ESS` for `Material.OLD_NAME` and `EntityType.OLD_NAME`. Replace with `EnumUtil.getMaterial("NEW", "OLD")` or a `MobCompat` constant. `EntityType.PIG_ZOMBIE` in a static map broke 1.16 (#3412). `EntityType.FIREWORK` broke `/firework` in 1.20.6.
+2. For a renamed `EntityType`, add `getEntityType("NEW", "OLD")` to `MobCompat.java`. Update `Mob.java`, `MobData.java` and `SpawnMob.java`.
+
+### 2.6 New wood type
+
+1. Add `<WOOD>_SIGN`, `<WOOD>_WALL_SIGN`, `<WOOD>_HANGING_SIGN`, `<WOOD>_WALL_HANGING_SIGN` to the four sign sets in `MaterialUtil.java`. Crimson and warped were missed in 1.16 (#3487).
+2. Add `<WOOD>_BOAT` to `Mob.java`. Boats are separate entity types since 1.21.3.
+3. Add `<WOOD>` to `MobCompat.BoatVariant` for servers before 1.21.3.
+4. Add `<WOOD>_BOAT` to `MobData.java`.
+5. Add `<WOOD>_CHEST_BOAT` to `Mob.java`.
+
+### 2.7 New tree type
+
+1. `Commandtree` reads `TreeType.values()`. It needs no code change.
+2. Add the name to `treeCommandUsage` and `treeCommandUsage1` in `messages.properties`.
+3. `Commandbigtree` has four hard-coded types. Add a case if the tree has a big variant.
+4. Bukkit adds `TreeType` late. 26.3-pre-2 has no `POPLAR`.
+
+### 2.8 New armor tier
+
+1. Add the four pieces to `HELMETS`, `CHESTPLATES`, `LEGGINGS`, `BOOTS` in `MaterialUtil.java`.
+2. Add a branch to the armor keyword chain in `ESS/SpawnMob.java`. The chain has `netherite`, `copper`, `diamond`, `gold`, `leather`, `iron`.
+3. For horse armor, add `<TIER>_HORSE_ARMOR` to `MobData.java`. Example: `NETHERITE_HORSE_ARMOR`.
+
+### 2.9 New enchantment
+
+1. Add a `try { // XX.Y }` block to `ESS/Enchantments.java`.
+2. Look up by name: `Enchantment.getByName("NAME")`. Check for null. Do not use `Enchantment.NAME`.
+3. Add `ENCHANTMENTS.put("name", e)` and `ALIASENCHANTMENTS.put("alias", e)`.
+4. Swift sneak (1.19) and lunge (1.21.11) were missed. Contributors added them months later.
+5. Display and permission names come from `Enchantments.getRealName()`. It uses the key on 1.13+.
+
+### 2.10 New potion effect or potion type
+
+1. Add a `try { // XX.Y }` block to `ESS/Potions.java`. Catch `Throwable`.
+2. Add `POTIONS.put("name", PotionEffectType.NAME)` and `ALIASPOTIONS.put(...)`.
+3. `ModernPotionMetaProvider` maps `LONG_` and `STRONG_` prefixes. Check a new potion follows that pattern.
+
+### 2.11 New banner pattern
+
+No code change. `PatternTypeProvider` reads the registry.
+
+### 2.12 New colour family
+
+Check `MaterialUtil.getColorOf` for a colour name that is not a `DyeColor`.
+
+### 2.13 New spawn egg
+
+No code change. `FlatSpawnEggProvider` derives the egg from `EntityType.name() + "_SPAWN_EGG"`.
+
+### 2.14 New command for new content
+
+1. Gate the command with `VersionUtil`. Return `tl("unsupportedFeature")` on old servers. Examples: `/beezooka`, `/ice`.
+2. Add the command to `plugin.yml` and `messages.properties`. Check message parameters. `iceOther` shipped without `{0}`.
+
+---
+
+## 3. API changes
+
+### 3.1 Enum becomes a registry
+
+Enchantment, PotionEffectType, Sound, PatternType, Villager.Profession, Cat.Type, Biome and Boat.Type all changed.
+
+1. Replace `EnumUtil.valueOf` with `RegistryUtil.valueOf(Class, names...)`. Replace `.values()` with `RegistryUtil.values(Class)`.
+2. If a static method moved from an enum to an interface, code compiled against the new API throws `IncompatibleClassChangeError` on old servers. `catch (Exception)` does not catch it. `PatternType.getByIdentifier` did this (#6553).
+3. For such a case, add a provider pair:
+   - Interface in `providers/BaseProviders/src/main/java/net/ess3/provider/`.
+   - `Modern*Provider` in BaseProviders with `@ProviderData(weight = 1)` and a `@ProviderTest`.
+   - `Legacy*Provider` in `providers/1_12Provider` or `providers/1_8Provider`. These compile against the old API.
+   - Register with `providerFactory.registerProvider(Legacy.class, Modern.class)` in `Essentials.java`.
+4. In a `@ProviderTest`, use `getMethod`, not `getDeclaredMethod`. 1.21 moved spawner methods to a super-interface (80bdc5269).
+
+### 3.2 Removed API class
+
+`PotionData`, `Potion`, `BannerMeta.setBaseColor` and `Achievement` were removed.
+
+1. Move code that uses the removed class to a provider in `1_12Provider` or `1_8Provider`.
+2. Add a modern provider in BaseProviders.
+3. Remove the method from `OfflinePlayer`, `FakeWorld` and `FakeServer` if it was an override.
+
+### 3.3 Changed method signature
+
+1. Read the Bukkit diff for changed return types on methods EssentialsX calls.
+2. A changed return type changes the call descriptor. The call throws `NoSuchMethodError` on old servers. `PlayerPickupArrowEvent#getArrow` did this (#3175). `InventoryView` becoming an interface did this (#5851).
+3. Use a provider or reflection for the changed call.
+
+### 3.4 New API methods on Player, World, Server
+
+1. Add stubs to `providers/1_8Provider/.../OfflinePlayer.java` and `providers/1_12Provider/.../FakeWorld.java` if they fail to compile.
+2. Tests use MockBukkit since 1.21.6. `FakeServer` no longer needs updates.
+
+### 3.5 New event
+
+1. Put the handler in a separate `*Listener_XX_Y` class.
+2. Register it behind a `VersionUtil` check or `Class.forName`.
+3. Do not put a new event in a listener that loads on old servers. `EntityTransformEvent` failed on 1.13.1 (#2942).
+
+### 3.6 Spigot NMS obfuscation
+
+1. Add `VXX_Y_RN` to `providers/NMSReflectionProvider/.../ReflUtil.java` if Spigot bumps the NMS revision.
+2. Update the obfuscated `MinecraftServer#isRunning` name table in `ReflServerStateProvider.java`. This broke on 1.18, 1.19, 1.19.3, 1.20.6 and 1.21.10.
+3. Paper uses `PaperServerStateProvider`. Test on Spigot to see this fail.
+
+### 3.7 Paper internal classes
+
+Paper config classes move. `ReflOnlineModeProvider` broke on 1.19 when config moved to `io.papermc.paper.configuration.GlobalConfiguration`. Check every reflective Paper access.
+
+### 3.8 World height
+
+1. Do not hard-code `0`, `-1`, `128` or `256` as a Y bound.
+2. Use `WorldInfoProvider.getMinHeight`, `getMaxHeight` and `getLogicalHeight`.
+3. Grep `LocationUtil`, `RandomTeleport`, `Commandtop`, `Commandsethome`, `Teleport`, `AsyncTeleport` and `SpawnMob`. 1.18 needed three fix PRs (#4657, #4667, #4715).
+
+### 3.9 Item data components
+
+1. Check `MetaItemStack.parseStringMeta`. The `[...]` component branch calls `UnsafeValues#modifyItemStack`. Its argument shape changed in 1.20.5 and again in 26.1 (#6570).
+2. Check `Commandbook`. Writable and written books have separate meta since 1.20.6 (#6064).
+3. Check `Commandskull`. Skull owner needs a resolved profile since 1.20.4 (#6188).
+4. Check `MetaItemStack.canSpawn()`.
+
+### 3.10 Vanilla messages
+
+Check the vanilla changelog for a new client message that duplicates an EssentialsX message. 1.15 added "Respawn point set". `EssentialsPlayerListener` now gates `bedSet` (#2943).
+
+### 3.11 Version string format
+
+1. `BukkitVersion.VERSION_PATTERN` in `VersionUtil.java` must parse the new string.
+2. Supported suffixes: `-snapshot-N`, `-pre-N`, `-rc-N`, `.build.N-channel`, `.local`, `-R0.1-SNAPSHOT`.
+3. `compareDevSpecifier` orders `snapshot < pre < rc < release`.
+4. `isSupportedVersion` compares major, minor and patch. A patch release needs a constant change.
+5. 26.1 needed four fix PRs for this (#6480, #6483, #6500, #6501).
+
+### 3.12 Adventure and Paper native paths
+
+Each Paper API shift produced a gate:
+- `Essentials.initAdventureFacet` gates the Paper facet at `v1_18_2_R01` (#6562).
+- `EssentialsSpawnPlayerListener` gates `getRespawnLocation` at `v1_20_4_R01` (#6460).
+- `EssentialsPlayerListener` gates configuration events at `v1_21_8_R01`.
+
+Check each gate against the new version.
+
+---
+
+## 4. Compatibility rules
+
+EssentialsX runs on 1.8.8 through the current version. Every update PR must keep that.
+
+1. Do not reference a new `Material`, `EntityType`, `Enchantment` or `PotionEffectType` constant in a static field or enum initializer. Use `EnumUtil.getMaterial`, `EnumUtil.getEntityType` or a name lookup.
+2. Catch `Throwable`, not `Exception`, around reflective lookups and provider selection. A swallowed `NoSuchFieldError` selected the wrong provider (7d6195375).
+3. Use only Guava and Gson methods that exist in 1.8.8. `Ints.constrainToRange` and `JsonArray#add(String)` do not (#4708, 576866540).
+4. Compile legacy providers in `1_8Provider` or `1_12Provider`. Code compiled against the new API can carry the wrong bytecode.
+5. Gate with `isLowerThan(<next major>)`, not `isLowerThanOrEqualTo(<patch>)`. Forks use nonstandard revision numbers (43eff69a2).
+6. Do not delete a `VersionUtil` constant.
+7. Test on Paper latest, Spigot latest, 1.12.2 and 1.8.8. Most follow-up fixes in this history came from old servers.
+
+---
+
+## 5. Test
+
+1. Run `./gradlew test`.
+2. Run `./gradlew runServer`.
+3. Run `/ess version`. Confirm the support status is FULL.
+4. Run `/spawnmob <newmob>`, `/spawnmob <mob>:<variant>`.
+5. Run `/give @s <newitem>`, `/give @s minecraft:<newitem>`.
+6. Run `/enchant <newenchant>`, `/potion <neweffect>`.
+7. Place an EssentialsX sign on each new sign type.
+8. Run `/tree <newtree>` if Bukkit has the `TreeType`.
+9. Run `/kit` with the new armor. Confirm auto-equip.
+10. Teleport onto each new damaging block. Confirm `/tp` refuses.
+11. Repeat on Spigot for `ReflServerStateProvider`.

.github/ISSUE_TEMPLATE/config.yml

@@ -7,14 +7,11 @@ contact_links:
     url: https://github.com/EssentialsX/Essentials/discussions/categories/q-a
     about: Visit the Q&A forum to search for previous help requests.
   - name: Check past feature suggestions
-    url: https://github.com/EssentialsX/Essentials/discussions/categories/ideas-and-feature-suggestions
+    url: https://github.com/EssentialsX/Essentials/issues?q=is%3Aissue+label%3A%22type%3A+enhancement%22
     about: Visit the Feature Suggestions forum to view and discuss existing feature suggestions.
   - name: Create help request
     url: https://github.com/EssentialsX/Essentials/discussions/new?category=q-a
     about: Create a support ticket to get help from developers.
-  - name: Suggest a feature
-    url: https://github.com/EssentialsX/Essentials/discussions/new?category=ideas-and-feature-suggestions
-    about: Suggest new features for EssentialsX!
   - name: Get help from the community on Discord
     url: https://discord.gg/casfFyh
     about: Join the MOSS Discord for community-powered EssentialsX support!

.github/ISSUE_TEMPLATE/report-a-bug.yml

@@ -1,6 +1,7 @@
 name: Report bug
 description: Report a bug in EssentialsX.
 labels: 'bug: unconfirmed'
+type: Bug
 body:
 - type: markdown
   attributes:
@@ -31,8 +32,8 @@ body:
 - type: input
   attributes:
     label: Error log (if applicable)
-    description: If you are reporting a console error, upload any relevant log excerpts to either https://paste.gg or https://gist.github.com, save and the paste the link in this box. If you included those files in the same paste as your startup log, paste the same link here.
-    placeholder: "Example: https://paste.gg/p/anonymous/109dd6a10a734a3aa430d5a351ea5210"
+    description: If you are reporting a console error, upload any relevant log excerpts to either https://pastes.dev or https://gist.github.com, save and the paste the link in this box. If you included those files in the same paste as your startup log, paste the same link here.
+    placeholder: "Example: https://pastes.dev/UYL3ASLsee"
 
 - type: textarea
   attributes:
@@ -70,10 +71,13 @@ body:
   validations:
     required: true
 
-- type: markdown
+- type: textarea
   attributes:
-    value: |
-      In the text box below, you can attach any relevant screenshots, files and links to Timings/spark profiler reports.
+    label: Additional Information
+    description: |
+      In this box, you can attach any relevant screenshots, files and links to Timings/spark profiler reports.
       You can also include a link to a heapdump if necessary, but please make sure you don't include any private player data in the heapdump.
       If you suspect this issue is related to a prior issue/PR/commit, please mention it here.
-
+  validations:
+    required: false
+    

.github/ISSUE_TEMPLATE/request-a-feature.yml

@@ -0,0 +1,41 @@
+name: Request a feature
+description: Suggest a feature you want to see in EssentialsX!
+labels: 'type: enhancement'
+type: Feature
+body:
+- type: markdown
+  attributes:
+    value: |
+      If you have a feature suggestion for EssentialsX, read the following tips:
+      1.  Fill out the template.
+            This will help us understand what you're requesting and why you want us
+            to add it.
+      2.  Keep it simple.
+            Make sure it's easy to understand what you're requesting. A good way is
+            to keep it to one request per GitHub issue, as we can then easily track
+            feature requests.
+      3.  Check whether it has already been asked or added.
+            You can search the issue tracker to see if your feature has already been
+            requested at https://github.com/EssentialsX/Essentials/issues. You can
+            also check the changelogs to see if the feature was recently added:
+            https://github.com/EssentialsX/Essentials/releases
+      4.  Ask yourself: "Does this belong in EssentialsX?"
+            There are lots of features that we reject because most servers won't
+            need or use them. If your feature is very specific or already exists in
+            another plugin, it might not be a good fit for EssentialsX.
+- type: textarea
+  attributes:
+    label: Feature description
+    description: Explain what you should expect to happen.
+    placeholder: |
+      What feature are you suggesting?
+  validations:
+    required: true
+- type: textarea
+  attributes:
+    label: How the feature is useful
+    description: Explain what actually happens.
+    placeholder: |
+      How is the feature useful to players, server owners and/or developers?
+  validations:
+    required: true

.github/PULL_REQUEST_TEMPLATE/bug-fix.md

@@ -80,7 +80,7 @@ Java version:
     bug fix on. If this feature does not apply to a server, strike through the server software using ~~strikethrough~~. If you have tested on other
     environments, add a new line with relevant details.
 -->
-- [ ] Most recent Paper version (1.XX.Y, git-Paper-BUILD)
+- [ ] Most recent Paper version (XX.YY.Z, git-Paper-BUILD)
 - [ ] CraftBukkit/Spigot/Paper 1.12.2
 - [ ] CraftBukkit 1.8.8
 

.github/PULL_REQUEST_TEMPLATE/new-feature.md

@@ -80,7 +80,7 @@ Java version:
     bug fix on. If this feature does not apply to a server, strike through the server software using ~~strikethrough~~. If you have tested on other
     environments, add a new line with relevant details.
 -->
-- [ ] Most recent Paper version (1.XX.Y, git-Paper-BUILD)
+- [ ] Most recent Paper version (XX.YY.Z, git-Paper-BUILD)
 - [ ] CraftBukkit/Spigot/Paper 1.12.2
 - [ ] CraftBukkit 1.8.8
 

.github/workflows/build-master.yml

@@ -4,6 +4,10 @@ on:
   push:
     branches:
     - 2.x
+    - dev/*
+  release:
+    types:
+    - published
 
 jobs:
   build:
@@ -12,38 +16,90 @@ jobs:
 
     steps:
     - name: Checkout Git repo
-      uses: actions/checkout@v2
+      uses: actions/checkout@v4
       with:
         fetch-depth: 0
 
-    - name: Restore Gradle cache
-      uses: actions/cache@v2
+    - name: Set up JDK 25
+      uses: actions/setup-java@v4
       with:
-        path: ~/.gradle/caches
-        key: ${{ runner.os }}-gradle-${{ hashFiles('**/*.gradle*') }}
-        restore-keys: |
-          ${{ runner.os }}-gradle-
+        distribution: 'temurin'
+        java-version: 25
 
-    - name: Set up JDK 16
-      uses: actions/setup-java@v2
-      with:
-        distribution: 'adopt'
-        java-version: 16
-
-    - name: Validate Gradle Wrapper
-      uses: gradle/wrapper-validation-action@v1
+    - name: Setup Gradle
+      uses: gradle/actions/setup-gradle@v4
 
     - name: Build with Gradle
       run: |
         chmod +x gradlew
         ./gradlew build --stacktrace
 
+    - name: Publish JUnit report
+      uses: mikepenz/action-junit-report@v5
+      if: success() || failure() # Run even if the previous step fails
+      with:
+        report_paths: '**/build/test-results/test*/TEST-*.xml'
+
     - name: Archive plugin jars on GitHub
-      uses: actions/upload-artifact@master
+      uses: actions/upload-artifact@v7
       with:
         name: EssentialsX plugin jars
         path: jars/
 
+    - name: Upload EssentialsX jar
+      uses: actions/upload-artifact@v7
+      with:
+        path: jars/EssentialsX-*.jar
+        archive: false
+
+    - name: Upload EssentialsXAntiBuild jar
+      uses: actions/upload-artifact@v7
+      with:
+        path: jars/EssentialsXAntiBuild-*.jar
+        archive: false
+
+    - name: Upload EssentialsXChat jar
+      uses: actions/upload-artifact@v7
+      with:
+        path: jars/EssentialsXChat-*.jar
+        archive: false
+
+    - name: Upload EssentialsXDiscord jar
+      uses: actions/upload-artifact@v7
+      with:
+        path: jars/EssentialsXDiscord-*.jar
+        archive: false
+
+    - name: Upload EssentialsXDiscordLink jar
+      uses: actions/upload-artifact@v7
+      with:
+        path: jars/EssentialsXDiscordLink-*.jar
+        archive: false
+
+    - name: Upload EssentialsXGeoIP jar
+      uses: actions/upload-artifact@v7
+      with:
+        path: jars/EssentialsXGeoIP-*.jar
+        archive: false
+
+    - name: Upload EssentialsXProtect jar
+      uses: actions/upload-artifact@v7
+      with:
+        path: jars/EssentialsXProtect-*.jar
+        archive: false
+
+    - name: Upload EssentialsXSpawn jar
+      uses: actions/upload-artifact@v7
+      with:
+        path: jars/EssentialsXSpawn-*.jar
+        archive: false
+
+    - name: Upload EssentialsXXMPP jar
+      uses: actions/upload-artifact@v7
+      with:
+        path: jars/EssentialsXXMPP-*.jar
+        archive: false
+
     - name: Deploy to Maven repo
       if: ${{ success() && github.event_name == 'push' && github.repository == 'EssentialsX/Essentials' && github.ref == 'refs/heads/2.x' }}
       env:
@@ -53,22 +109,43 @@ jobs:
         ./gradlew publish
 
     - name: Prepare Javadocs
-      if: ${{ success() && github.event_name == 'push' && github.repository == 'EssentialsX/Essentials' && github.ref == 'refs/heads/2.x' }}
       run: |
         mv Essentials/build/docs/javadoc/ javadocs/
         cp -r EssentialsAntiBuild/build/docs/javadoc/ javadocs/EssentialsAntiBuild/
         cp -r EssentialsChat/build/docs/javadoc/ javadocs/EssentialsChat/
         cp -r EssentialsDiscord/build/docs/javadoc/ javadocs/EssentialsDiscord/
+        cp -r EssentialsDiscordLink/build/docs/javadoc/ javadocs/EssentialsDiscordLink/
         cp -r EssentialsGeoIP/build/docs/javadoc/ javadocs/EssentialsGeoIP/
         cp -r EssentialsProtect/build/docs/javadoc/ javadocs/EssentialsProtect/
         cp -r EssentialsSpawn/build/docs/javadoc/ javadocs/EssentialsSpawn/
         cp -r EssentialsXMPP/build/docs/javadoc/ javadocs/EssentialsXMPP/
 
-    - name: Deploy Javadocs
-      if: ${{ success() && github.event_name == 'push' && github.repository == 'EssentialsX/Essentials' && github.ref == 'refs/heads/2.x' }}
-      uses: netlify/actions/cli@master
+    - name: Archive Javadocs
+      uses: actions/upload-artifact@v7
       with:
-        args: deploy --dir=javadocs/ --prod --message="GitHubActionsDeploy"
+        name: javadocs
+        path: javadocs/
+
+  publish-jd:
+    name: Publish Javadocs
+    needs: build
+    if: ${{ github.event_name == 'push' && github.repository == 'EssentialsX/Essentials' && github.ref == 'refs/heads/2.x' }}
+    runs-on: ubuntu-latest
+
+    steps:
+    - name: Setup Node
+      uses: actions/setup-node@v4
+      with:
+        node-version: 22
+
+    - name: Download Javadocs
+      uses: actions/download-artifact@v8
+      with:
+        name: javadocs
+        path: javadocs/
+
+    - name: Deploy Javadocs
+      run: npx netlify-cli deploy --dir=javadocs/ --prod --message="GitHubActionsDeploy"
       env:
         NETLIFY_AUTH_TOKEN: ${{ secrets.NETLIFY_JD_AUTH_TOKEN }}
         NETLIFY_SITE_ID: ${{ secrets.NETLIFY_JD_2X_SITE_ID }}

.github/workflows/build-pr.yml

@@ -9,6 +9,12 @@ on:
     branches:
     - 2.x
     - mc/*
+    - dev/*
+  merge_group:
+    types: [checks_requested]
+
+permissions:
+  checks: write
 
 jobs:
   build:
@@ -17,34 +23,86 @@ jobs:
 
     steps:
     - name: Checkout Git repo
-      uses: actions/checkout@v2
+      uses: actions/checkout@v4
       with:
         fetch-depth: 0
 
-    - name: Restore Gradle cache
-      uses: actions/cache@v2
+    - name: Set up JDK 25
+      uses: actions/setup-java@v4
       with:
-        path: ~/.gradle/caches
-        key: ${{ runner.os }}-gradle-${{ hashFiles('**/*.gradle*') }}
-        restore-keys: |
-          ${{ runner.os }}-gradle-
+        distribution: 'temurin'
+        java-version: 25
 
-    - name: Set up JDK 16
-      uses: actions/setup-java@v2
-      with:
-        distribution: 'adopt'
-        java-version: 16
-
-    - name: Validate Gradle Wrapper
-      uses: gradle/wrapper-validation-action@v1
+    - name: Setup Gradle
+      uses: gradle/actions/setup-gradle@v4
 
     - name: Build with Gradle
       run: |
         chmod +x gradlew
         ./gradlew build --stacktrace
 
+    - name: Publish JUnit report
+      uses: mikepenz/action-junit-report@v4
+      if: success() || failure() # Run even if the previous step fails
+      with:
+        report_paths: '**/build/test-results/test*/TEST-*.xml'
+
     - name: Archive plugin jars on GitHub
-      uses: actions/upload-artifact@master
+      uses: actions/upload-artifact@v7
       with:
         name: EssentialsX plugin jars
         path: jars/
+
+    - name: Upload EssentialsX jar
+      uses: actions/upload-artifact@v7
+      with:
+        path: jars/EssentialsX-*.jar
+        archive: false
+
+    - name: Upload EssentialsXAntiBuild jar
+      uses: actions/upload-artifact@v7
+      with:
+        path: jars/EssentialsXAntiBuild-*.jar
+        archive: false
+
+    - name: Upload EssentialsXChat jar
+      uses: actions/upload-artifact@v7
+      with:
+        path: jars/EssentialsXChat-*.jar
+        archive: false
+
+    - name: Upload EssentialsXDiscord jar
+      uses: actions/upload-artifact@v7
+      with:
+        path: jars/EssentialsXDiscord-*.jar
+        archive: false
+
+    - name: Upload EssentialsXDiscordLink jar
+      uses: actions/upload-artifact@v7
+      with:
+        path: jars/EssentialsXDiscordLink-*.jar
+        archive: false
+
+    - name: Upload EssentialsXGeoIP jar
+      uses: actions/upload-artifact@v7
+      with:
+        path: jars/EssentialsXGeoIP-*.jar
+        archive: false
+
+    - name: Upload EssentialsXProtect jar
+      uses: actions/upload-artifact@v7
+      with:
+        path: jars/EssentialsXProtect-*.jar
+        archive: false
+
+    - name: Upload EssentialsXSpawn jar
+      uses: actions/upload-artifact@v7
+      with:
+        path: jars/EssentialsXSpawn-*.jar
+        archive: false
+
+    - name: Upload EssentialsXXMPP jar
+      uses: actions/upload-artifact@v7
+      with:
+        path: jars/EssentialsXXMPP-*.jar
+        archive: false

.github/workflows/mirror-dump.yml

@@ -0,0 +1,112 @@
+name: Mirror EssentialsX dumps to Gist
+
+on:
+  issues:
+    types: [opened, edited, closed]
+  issue_comment:
+    types: [created]
+
+permissions:
+  issues: write
+  contents: read
+
+env:
+  DUMP_REGEX: 'https?://essentialsx\.net/dump\?bytebin=([A-Za-z0-9_-]+)'
+  GIST_LINK_FMT: 'https://essentialsx.net/dump?gist='
+
+jobs:
+  handle-dump:
+    if: github.event.action != 'closed'
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Mirror dump to a private Gist
+        id: mirror
+        uses: actions/github-script@v7
+        with:
+          github-token: ${{ secrets.GIST_TOKEN }}
+          script: |
+            const issue   = context.payload.issue ?? context.payload.comment.issue;
+            const bodySrc = context.payload.comment ? context.payload.comment.body : issue.body || '';
+
+            const regex = new RegExp(process.env.DUMP_REGEX);
+            const m = bodySrc.match(regex);
+            if (!m) {
+              core.info('No EssentialsX dump link found – abort.');
+              return;
+            }
+
+            const key = m[1];
+            const dump = await fetch(`https://api.pastes.dev/${key}`);
+            if (!dump.ok) throw new Error(`pastes.dev fetch failed (${dump.status})`);
+            const text = await dump.text();
+
+            const { data: gist } = await github.rest.gists.create({
+              files: { [`${key}.txt`]: { content: text } },
+              description: `EssentialsX dump for issue #${issue.number}`,
+              public: false
+            });
+
+            core.setOutput('link', `${process.env.GIST_LINK_FMT}${gist.id}`);
+            core.setOutput('issue_number', issue.number);
+
+      - name: Comment gist link on issue
+        if: steps.mirror.outputs.link != ''
+        uses: actions/github-script@v7
+        with:
+          script: |
+            await github.rest.issues.createComment({
+              owner: context.repo.owner,
+              repo:  context.repo.repo,
+              issue_number: ${{ steps.mirror.outputs.issue_number }},
+              body: `📋 Essentials Dump Backup → ${{ steps.mirror.outputs.link }}`
+            });
+
+  cleanup-gist:
+    if: github.event_name == 'issues' && github.event.action == 'closed'
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Delete gist and hide bot comment
+        uses: actions/github-script@v7
+        with:
+          github-token: ${{ secrets.GIST_TOKEN }}
+          script: |
+            const issue = context.payload.issue;
+
+            const comments = await github.paginate(
+              github.rest.issues.listComments,
+              { owner: context.repo.owner, repo: context.repo.repo, issue_number: issue.number, per_page: 100 }
+            );
+            
+            const re = /https?:\/\/essentialsx\.net\/dump\?gist=([A-Za-z0-9]+)/;
+            const hit = comments.reverse().find(c => re.test(c.body || ''));
+            
+            if (!hit) {
+              core.info('No gist link comment found – nothing to clean up.');
+              return;
+            }
+            
+            const gistId   = (hit.body.match(re))[1];
+            const commentNodeId = hit.node_id;
+
+            try {
+              await github.request('DELETE /gists/{gist_id}', { gist_id: gistId });
+              core.info(`Deleted Gist ${gistId}`);
+            } catch (err) {
+              core.warning(`Could not delete Gist ${gistId}: ${err.message}`);
+            }
+
+            try {
+              await github.graphql(
+                `mutation($id:ID!){
+                   minimizeComment(input:{subjectId:$id, classifier:OUTDATED}) {
+                     minimizedComment { id }
+                   }
+                 }`,
+                { id: commentNodeId }
+              );
+              core.info(`Minimised comment ${hit.id} as OUTDATED`);
+            } catch (err) {
+              core.warning(`Could not minimise comment: ${err.message}`);
+            }

.github/workflows/upload-plugin-data.yml

@@ -0,0 +1,43 @@
+name: Command and Permissions Data
+on:
+  push:
+    branches:
+      - 2.x
+
+jobs:
+  data:
+    name: Generate and Upload
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout Git Repo
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 1
+
+      - name: Set up JDK 17
+        uses: actions/setup-java@v4
+        with:
+          distribution: 'temurin'
+          java-version: 17
+
+      - name: Set up Gradle
+        uses: gradle/actions/setup-gradle@v4
+
+      - name: Generate Data
+        run: |
+          chmod +x gradlew
+          ./gradlew commandData
+          ./gradlew versionData
+
+      - name: Upload Data
+        uses: ryand56/r2-upload-action@v1
+        with:
+          r2-account-id: ${{ secrets.R2_ACCOUNT_ID }}
+          r2-access-key-id: ${{ secrets.R2_ACCESS_KEY_ID }}
+          r2-secret-access-key: ${{ secrets.R2_SECRET_ACCESS_KEY }}
+          r2-bucket: ${{ secrets.R2_BUCKET }}
+          source-dir: generated
+          destination-dir: ./
+
+

.gitignore

@@ -15,14 +15,21 @@
 /Essentials/kits.yml
 /Essentials/userdata/testplayer1.yml
 /Essentials/usermap.csv
+/Essentials/usermap.bin
+/Essentials/uuids.bin
 
 # Build files
 .gradle/
 /jars/
+generated/
 out/
 build/
 target/
 *.class
+build-logic/.kotlin/
+build-logic/bin/
+bin/
+test-tmp/
 
 # Run directory
 /run/

.idea/checkstyle-idea.xml

@@ -1,19 +1,27 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <project version="4">
-  <component name="CheckStyle-IDEA">
-    <option name="configuration">
-      <map>
-        <entry key="active-configuration" value="PROJECT_RELATIVE:$PROJECT_DIR$/.checkstyle/checkstyle.xml:EssentialsX" />
-        <entry key="checkstyle-version" value="8.36.2" />
-        <entry key="copy-libs" value="true" />
-        <entry key="location-0" value="BUNDLED:(bundled):Sun Checks" />
-        <entry key="location-1" value="BUNDLED:(bundled):Google Checks" />
-        <entry key="location-2" value="PROJECT_RELATIVE:$PROJECT_DIR$/.checkstyle/checkstyle.xml:EssentialsX" />
-        <entry key="property-2.configDirectory" value=".checkstyle/" />
-        <entry key="scan-before-checkin" value="true" />
-        <entry key="scanscope" value="JavaOnly" />
-        <entry key="suppress-errors" value="false" />
-      </map>
+  <component name="CheckStyle-IDEA" serialisationVersion="2">
+    <checkstyleVersion>8.36.2</checkstyleVersion>
+    <scanScope>JavaOnly</scanScope>
+    <copyLibs>true</copyLibs>
+    <scanBeforeCheckin>true</scanBeforeCheckin>
+    <option name="thirdPartyClasspath" />
+    <option name="activeLocationIds">
+      <option value="321e5753-4201-4d2c-bf31-6232011122fd" />
+    </option>
+    <option name="locations">
+      <list>
+        <ConfigurationLocation id="bundled-sun-checks" type="BUNDLED" scope="All" description="Sun Checks">bundled-sun-checks</ConfigurationLocation>
+        <ConfigurationLocation id="bundled-google-checks" type="BUNDLED" scope="All" description="Google Checks">bundled-google-checks</ConfigurationLocation>
+        <ConfigurationLocation id="321e5753-4201-4d2c-bf31-6232011122fd" type="PROJECT_RELATIVE" scope="All" description="EssentialsX">
+          $PROJECT_DIR$/.checkstyle/checkstyle.xml
+          <option name="properties">
+            <map>
+              <entry key="configDirectory" value=".checkstyle/" />
+            </map>
+          </option>
+        </ConfigurationLocation>
+      </list>
     </option>
   </component>
 </project>

CONTRIBUTING.md

@@ -1,31 +1,102 @@
-Contributing to EssentialsX
-===========================
+# Contributing to EssentialsX
 
-Want to help improve EssentialsX? There are several ways you can support and contribute to the project.
+*By contributing to EssentialsX, you agree to license your changes under the [GNU General Public License version 3](https://github.com/EssentialsX/Essentials/blob/2.x/LICENSE).*
 
-If you'd like to make a financial contribution to the project, you can join our [Patreon](https://www.patreon.com/essentialsx/),
-or to make a one-off donation you can visit our [Ko-fi page](https://ko-fi.com/essentialsx). If you can't make a
-donation, don't worry! There are lots of other ways to contribute:
+## Submitting code changes to EssentialsX
 
-* Do you run a server? Take a look at our ["help wanted"](https://github.com/EssentialsX/Essentials/issues?q=is%3Aissue+is%3Aopen+sort%3Aupdated-desc+label%3A%22help+wanted%22)
-  and ["bug: unconfirmed"](https://github.com/EssentialsX/Essentials/issues?q=is%3Aissue+is%3Aopen+sort%3Aupdated-desc+label%3A%22bug%3A+unconfirmed%22)
-  issues, where you can find issues that need extra testing and investigation.
-* Do you speak multiple languages? If so, we always welcome contributions to our [Crowdin project](https://crowdin.com/project/essentialsx-official).
-* Do you enjoy helping others? If so, why not contribute to the [EssentialsX documentation](https://github.com/EssentialsX/wiki)?
-  You can also join the [MOSS Discord community](https://discord.gg/casfFyh) and provide direct community support to
-  other EssentialsX users.
-* If you're a developer, you could look through our ["open to PR"](https://github.com/EssentialsX/Essentials/issues?q=is%3Aissue+is%3Aopen+sort%3Aupdated-desc+label%3A%22status%3A+open+to+PR%22)
-  issues. We're always happy to receive bug fixes and feature additions as pull requests.
+If you're interested in submitting new code to EssentialsX, we accept changes via GitHub pull requests.
 
-Submitting a PR
----------------
+### Adding features
 
-EssentialsX has extensive templates for PRs that detail how to submit your PR. To find out more, see the PR templates for:
-* [Bug fixes](https://github.com/EssentialsX/Essentials/blob/2.x/.github/PULL_REQUEST_TEMPLATE/bug-fix.md) 
-* [New features](https://github.com/EssentialsX/Essentials/blob/2.x/.github/PULL_REQUEST_TEMPLATE/new-feature.md)
+In general, we will only consider PRs for features if they have already been discussed with the team through
+GitHub issues and discussions. Check the list of
+["open to PR" issues](https://github.com/EssentialsX/Essentials/issues?q=is%3Aissue+is%3Aopen+sort%3Aupdated-desc+label%3A%22status%3A+open+to+PR%22)
+and [feature request discussions](https://github.com/EssentialsX/Essentials/discussions/categories/ideas-and-feature-suggestions)
+before you start working on your changes. If you don't see your desired feature listed,
+[open a feature request](https://github.com/EssentialsX/Essentials/issues/new/choose) and wait for a response, otherwise
+you may end up wasting your time on a feature that we aren't in a position to accept.
 
-Want to discuss a feature before opening a PR? Join the [EssentialsX Development Discord server](https://discord.gg/CUN7qVb). Note that this server is **not for end-users** - if you need support with EssentialsX, you should join [MOSS](https://discord.gg/casfFyh) instead.
+#### Keep it focused
 
-By contributing to EssentialsX, you agree to license your code under the [GNU General Public License version 3](https://github.com/EssentialsX/Essentials/blob/2.x/LICENSE).
+Please try to keep feature PRs focused around one feature. Your PR should ideally contain
+one feature, or a few closely-linked features. If you submit several unrelated features 
+in one PR, the PR will not be accepted.
+
+### Fixing bugs
+
+If you're opening a PR to fix a bug, please ensure a bug report has been filed - search the
+[issue tracker](https://github.com/EssentialsX/Essentials/issues?q=is%3Aissue+is%3Aopen+sort%3Aupdated-desc+label%3A%22bug%3A+confirmed%22%2C%22bug%3A+unconfirmed%22%2C%22bug%3A+upstream%22)
+for an existing report, and if you can't find a bug report,
+[create one](https://github.com/EssentialsX/Essentials/issues/new/choose) before you submit your PR.
+
+#### Unconfirmed bugs
+
+You may find a bug report with the label `bug: unconfirmed`. This means the EssentialsX team hasn't had the time
+to review the bug report yet or hasn't been able to confirm
+whether the reported issue is actually a bug in EssentialsX. You can help us by following the steps in the report and
+posting whether you are able to replicate this issue, ideally on the latest versions of EssentialsX and Paper. This will
+help us confirm issues and prioritise PRs accordingly.
+
+#### Upstream bugs
+
+You may also find bug reports with the `bug: upstream` label. This label means the issue is caused by a bug in *another
+project*, not EssentialsX. This includes bugs in CraftBukkit/Spigot and bugs in other plugins. It may be appropriate to
+mitigate an issue in EssentialsX, but please check with us in the [EssentialsX Development Discord server](https://discord.gg/CUN7qVb) before you submit a PR.
+
+### Making your changes
+
+You'll need the following to make your changes to EssentialsX:
+
+* A GitHub account
+* [`git`](https://git-scm.com/downloads): the Git command-line tool, used to track and save your changes
+* [`gh`](https://cli.github.com/): the GitHub command-line tool, used to submit your changes to EssentialsX
+* Your IDE of choice - we recommend [IntelliJ IDEA Community Edition](https://www.jetbrains.com/idea/download)
+
+If you're already familiar with Git, you can skip this next section.
+
+You'll need to clone the EssentialsX repository
+(`gh repo clone EssentialsX/Essentials`), then create a new branch for your work
+(`cd Essentials` then `git switch -c my-cool-pr`).
+
+You can then make changes using your IDE of choice. Follow the instructions in `README.md` to build and test your
+changes.
+
+Once you've finished, you should commit your changes (`git commit -am "My cool commit name!"`).
+
+### Submitting your PR
+
+*Even if you're already familiar with GitHub, you will need to follow these steps in order to submit a PR to
+EssentialsX. This ensures we have the information we need to test and review your changes.*
+
+Next, you'll need to fork EssentialsX on GitHub and push your changes to a branch on that fork. We strongly recommend
+using the `gh` command-line tool for this:
+
+* In your terminal, run `gh pr create`.
+* Select either the bug fix or feature template, depending on what your PR is for.
+* If you get asked `Where should we push the '...' branch?`, select `Create a fork of EssentialsX/Essentials`.
+* For the title, choose a title that describes what your PR does. For example, `Add more ducks to /spawnmob`.
+* For the body, press E. You will then need to fill in the PR template in your text editor.
+  - Follow the instructions in the template and fill out the sections as required.
+  - This step is important! Without it, we won't know why you've made your changes or how to test them.
+* Save the file in your text editor and close it, then return to the terminal.
+* Select `Submit` to open your PR.
+
+If you follow these steps correctly, GitHub will create a fork (if necessary) and then open a PR with your changes. You
+can now sit back while we review your changes. If we need to ask questions or request further changes to your code,
+we will review your PR and post a comment on GitHub. You can respond to our reviews and comments on the GitHub website,
+and you can push new changes using `git commit` and `git push`.
 
 
+## Submitting community translations to EssentialsX
+
+EssentialsX relies on community translations for its messages in other languages. You can help translate EssentialsX on
+[Crowdin](https://translate.essentialsx.net/). You'll need a Crowdin account to translate and improve messages.
+
+If your language isn't listed or doesn't have an active proofreader, please let us know on Discord (see below).
+
+
+## Discussing EssentialsX contributions 
+
+Want to discuss something before opening a PR or translating messages? Join the
+[EssentialsX Development Discord server](https://discord.gg/CUN7qVb). Note that this server is **not for end-users** -
+if you need support with EssentialsX, you should join [MOSS](https://discord.gg/casfFyh) instead.

Essentials/build.gradle

@@ -3,32 +3,47 @@ plugins {
 }
 
 dependencies {
-    compileOnly('com.github.milkbowl:VaultAPI:1.7') {
+    compileOnly('net.essentialsx.deps:VaultAPI:1.7') {
         exclude group: "org.bukkit", module: "bukkit"
     }
-    compileOnly 'net.luckperms:api:5.0'
+    compileOnly 'net.luckperms:api:5.3'
 
     api 'io.papermc:paperlib:1.0.6'
 
-    api 'org.bstats:bstats-bukkit:2.2.1'
+    implementation 'org.spongepowered:configurate-yaml:4.2.0'
+    implementation 'org.checkerframework:checker-qual:3.49.0'
+    implementation 'nu.studer:java-ordered-properties:1.0.4'
 
-    implementation 'org.spongepowered:configurate-yaml:4.1.2'
-    implementation 'org.checkerframework:checker-qual:3.14.0'
+    implementation 'net.kyori:adventure-api:4.25.0'
+    implementation 'net.kyori:adventure-text-minimessage:4.25.0'
+    implementation 'net.kyori:adventure-platform-bukkit:4.4.1'
 
     // Providers
-    api project(':providers:BaseProviders')
-    api project(':providers:PaperProvider')
+    api(project(':providers:BaseProviders')) {
+        exclude(module: 'spigot-api')
+    }
+    api(project(path: ':providers:PaperProvider', configuration: 'shadow')){
+        exclude(module: 'paper-api')
+    }
     api(project(':providers:NMSReflectionProvider')) {
-        exclude group: "org.bukkit", module: "bukkit"
+        exclude(module: 'bukkit')
     }
     api(project(':providers:1_8Provider')) {
-        exclude group: "org.spigotmc", module: "spigot"
+        exclude(module: 'spigot-api')
     }
     api(project(':providers:1_12Provider')) {
-        exclude group: "org.bukkit", module: "bukkit"
+        exclude(module: 'bukkit')
     }
 }
 
+test {
+    testLogging.showStandardStreams = true
+}
+
+tasks.register('versionData', VersionDataTask) {
+    destination.set(rootProject.layout.projectDirectory.dir("generated").file("version-data.json"))
+}
+
 shadowJar {
     dependencies {
         include (dependency('io.papermc:paperlib'))
@@ -39,11 +54,39 @@ shadowJar {
         include (dependency('org.yaml:snakeyaml'))
         include (dependency('io.leangen.geantyref:geantyref'))
         include (dependency('org.checkerframework:checker-qual'))
+        include (dependency('nu.studer:java-ordered-properties'))
+        include (dependency('net.kyori:adventure-api'))
+        include (dependency('net.kyori:adventure-key'))
+        include (dependency('net.kyori:examination-api'))
+        include (dependency('net.kyori:examination-string'))
+        include (dependency('net.kyori:option'))
+        include (dependency('net.kyori:adventure-platform-bukkit'))
+        include (dependency('net.kyori:adventure-platform-api'))
+        include (dependency('net.kyori:adventure-platform-facet'))
+        include (dependency('net.kyori:adventure-nbt'))
+        include (dependency('net.kyori:adventure-text-serializer-bungeecord'))
+        include (dependency('net.kyori:adventure-text-serializer-gson'))
+        include (dependency('net.kyori:adventure-text-serializer-gson-legacy-impl'))
+        include (dependency('net.kyori:adventure-text-serializer-json'))
+        include (dependency('net.kyori:adventure-text-serializer-json-legacy-impl'))
+        include (dependency('net.kyori:adventure-text-serializer-legacy'))
+        include (dependency('net.kyori:adventure-text-minimessage'))
         include (project(':providers:BaseProviders'))
-        include (project(':providers:PaperProvider'))
+        include (project(path: ':providers:PaperProvider', configuration: 'shadow'))
         include (project(':providers:NMSReflectionProvider'))
         include (project(':providers:1_8Provider'))
         include (project(':providers:1_12Provider'))
+
+        // Paper in-dev adventure versions (for snapshot/pre-releases)
+        include (dependency('io.papermc.adventure:adventure-api'))
+        include (dependency('io.papermc.adventure:adventure-key'))
+        include (dependency('io.papermc.adventure:adventure-nbt'))
+        include (dependency('io.papermc.adventure:adventure-text-serializer-gson'))
+        include (dependency('io.papermc.adventure:adventure-text-serializer-gson-legacy-impl'))
+        include (dependency('io.papermc.adventure:adventure-text-serializer-json'))
+        include (dependency('io.papermc.adventure:adventure-text-serializer-json-legacy-impl'))
+        include (dependency('io.papermc.adventure:adventure-text-serializer-legacy'))
+        include (dependency('io.papermc.adventure:adventure-text-minimessage'))
     }
     relocate 'io.papermc.lib', 'com.earth2me.essentials.paperlib'
     relocate 'org.bstats', 'com.earth2me.essentials.libs.bstats'
@@ -51,8 +94,13 @@ shadowJar {
     relocate 'org.yaml.snakeyaml', 'com.earth2me.essentials.libs.snakeyaml'
     relocate 'io.leangen.geantyref', 'com.earth2me.essentials.libs.geantyref'
     relocate 'org.checkerframework', 'com.earth2me.essentials.libs.checkerframework'
+    relocate 'net.kyori', 'com.earth2me.essentials.libs.kyori'
+    relocate 'net.essentialsx.temp.adventure', 'net.kyori.adventure' // Undo temporary relocation for Paper Provider
 
     minimize {
         include(dependency('org.checkerframework:checker-qual'))
+        include(dependency('net.kyori:adventure-api'))
+        include(dependency('net.kyori:adventure-platform-bukkit'))
+        include(dependency('net.kyori:adventure-text-minimessage'))
     }
 }

Essentials/src/main/java/com/earth2me/essentials/AlternativeCommandsHandler.java

@@ -1,9 +1,12 @@
 package com.earth2me.essentials;
 
+import java.util.stream.Collectors;
+import net.ess3.provider.KnownCommandsProvider;
 import org.bukkit.command.Command;
 import org.bukkit.command.PluginIdentifiableCommand;
 import org.bukkit.plugin.Plugin;
 
+import java.lang.ref.WeakReference;
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.Iterator;
@@ -11,11 +14,9 @@ import java.util.List;
 import java.util.Locale;
 import java.util.Map;
 import java.util.logging.Level;
-import java.util.logging.Logger;
 
 public class AlternativeCommandsHandler {
-    private static final Logger LOGGER = Logger.getLogger("Essentials");
-    private final transient Map<String, List<Command>> altcommands = new HashMap<>();
+    private final transient Map<String, List<WeakReference<Command>>> altCommands = new HashMap<>();
     private final transient Map<String, String> disabledList = new HashMap<>();
     private final transient IEssentials ess;
 
@@ -32,41 +33,72 @@ public class AlternativeCommandsHandler {
         if (plugin.getDescription().getMain().contains("com.earth2me.essentials") || plugin.getDescription().getMain().contains("net.essentialsx")) {
             return;
         }
-        for (final Map.Entry<String, Command> entry : getPluginCommands(plugin).entrySet()) {
+        for (final Map.Entry<String, Command> entry : getPluginCommands(plugin)) {
             final String[] commandSplit = entry.getKey().split(":", 2);
             final String commandName = commandSplit.length > 1 ? commandSplit[1] : entry.getKey();
             final Command command = entry.getValue();
 
-            final List<Command> pluginCommands = altcommands.computeIfAbsent(commandName.toLowerCase(Locale.ENGLISH), k -> new ArrayList<>());
+            final List<WeakReference<Command>> pluginCommands = altCommands.computeIfAbsent(commandName.toLowerCase(Locale.ENGLISH), k -> new ArrayList<>());
             boolean found = false;
-            for (final Command pc2 : pluginCommands) {
+
+            final Iterator<WeakReference<Command>> pluginCmdIterator = pluginCommands.iterator();
+            while (pluginCmdIterator.hasNext()) {
+                final Command cmd = pluginCmdIterator.next().get();
+                if (cmd == null) {
+                    if (ess.getSettings().isDebug()) {
+                        ess.getLogger().log(Level.INFO, "Essentials: Alternative command for " + commandName + " removed due to garbage collection");
+                    }
+
+                    pluginCmdIterator.remove();
+                    continue;
+                }
+
                 // Safe cast, everything that's added comes from getPluginCommands which already performs the cast check.
-                if (((PluginIdentifiableCommand) pc2).getPlugin().equals(plugin)) {
+                if (((PluginIdentifiableCommand) cmd).getPlugin().equals(plugin)) {
                     found = true;
                     break;
                 }
             }
+
             if (!found) {
-                pluginCommands.add(command);
+                pluginCommands.add(new WeakReference<>(command));
             }
         }
     }
 
-    private Map<String, Command> getPluginCommands(Plugin plugin) {
+    private List<Map.Entry<String, Command>> getPluginCommands(Plugin plugin) {
         final Map<String, Command> commands = new HashMap<>();
-        for (final Map.Entry<String, Command> entry : ess.getKnownCommandsProvider().getKnownCommands().entrySet()) {
+        for (final Map.Entry<String, Command> entry : ess.provider(KnownCommandsProvider.class).getKnownCommands().entrySet()) {
             if (entry.getValue() instanceof PluginIdentifiableCommand && ((PluginIdentifiableCommand) entry.getValue()).getPlugin().equals(plugin)) {
                 commands.put(entry.getKey(), entry.getValue());
             }
         }
-        return commands;
+        // Try to use non-namespaced commands first if we can, some Commands may not like being registered under a
+        // different label than their getName() returns, so avoid doing that when we can
+        return commands.entrySet().stream().sorted((o1, o2) -> {
+            if (o1.getKey().contains(":") && !o2.getKey().contains(":")) {
+                return 1;
+            } else if (!o1.getKey().contains(":") && o2.getKey().contains(":")) {
+                return -1;
+            }
+            return 0;
+        }).collect(Collectors.toList());
     }
 
     public void removePlugin(final Plugin plugin) {
-        final Iterator<Map.Entry<String, List<Command>>> iterator = altcommands.entrySet().iterator();
+        final Iterator<Map.Entry<String, List<WeakReference<Command>>>> iterator = altCommands.entrySet().iterator();
         while (iterator.hasNext()) {
-            final Map.Entry<String, List<Command>> entry = iterator.next();
-            entry.getValue().removeIf(pc -> !(pc instanceof PluginIdentifiableCommand) || ((PluginIdentifiableCommand) pc).getPlugin().equals(plugin));
+            final Map.Entry<String, List<WeakReference<Command>>> entry = iterator.next();
+
+            final Iterator<WeakReference<Command>> commands = entry.getValue().iterator();
+            while (commands.hasNext()) {
+                final Command pc = commands.next().get();
+                if (pc instanceof PluginIdentifiableCommand && !((PluginIdentifiableCommand) pc).getPlugin().equals(plugin)) {
+                    continue;
+                }
+                commands.remove();
+            }
+
             if (entry.getValue().isEmpty()) {
                 iterator.remove();
             }
@@ -74,28 +106,44 @@ public class AlternativeCommandsHandler {
     }
 
     public Command getAlternative(final String label) {
-        final List<Command> commands = altcommands.get(label);
+        final List<WeakReference<Command>> commands = altCommands.get(label);
         if (commands == null || commands.isEmpty()) {
             return null;
         }
+
         if (commands.size() == 1) {
-            return commands.get(0);
+            return commands.get(0).get();
         }
+
         // return the first command that is not an alias
-        for (final Command command : commands) {
-            if (command.getName().equalsIgnoreCase(label)) {
-                return command;
+        Command firstAlias = null;
+
+        final Iterator<WeakReference<Command>> iterator = commands.iterator();
+        while (iterator.hasNext()) {
+            final Command cmd = iterator.next().get();
+            if (cmd == null) {
+                iterator.remove();
+                continue;
+            }
+
+            if (cmd.getName().equalsIgnoreCase(label)) {
+                return cmd;
+            }
+
+            if (firstAlias == null) {
+                firstAlias = cmd;
             }
         }
-        // return the first alias
-        return commands.get(0);
+
+        // return the first alias, or null if every reference in this bucket has been collected
+        return firstAlias;
     }
 
     public void executed(final String label, final Command pc) {
         if (pc instanceof PluginIdentifiableCommand) {
             final String altString = ((PluginIdentifiableCommand) pc).getPlugin().getName() + ":" + pc.getName();
             if (ess.getSettings().isDebug()) {
-                LOGGER.log(Level.INFO, "Essentials: Alternative command " + label + " found, using " + altString);
+                ess.getLogger().log(Level.INFO, "Essentials: Alternative command " + label + " found, using " + altString);
             }
             disabledList.put(label, altString);
         }

Essentials/src/main/java/com/earth2me/essentials/AsyncTeleport.java

@@ -7,7 +7,7 @@ import com.earth2me.essentials.utils.LocationUtil;
 import io.papermc.lib.PaperLib;
 import net.ess3.api.IEssentials;
 import net.ess3.api.IUser;
-import net.ess3.api.InvalidWorldException;
+import net.ess3.api.TranslatableException;
 import net.ess3.api.events.UserWarpEvent;
 import net.ess3.api.events.teleport.PreTeleportEvent;
 import net.ess3.api.events.teleport.TeleportWarmupEvent;
@@ -23,8 +23,6 @@ import java.util.GregorianCalendar;
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.ExecutionException;
 
-import static com.earth2me.essentials.I18n.tl;
-
 public class AsyncTeleport implements IAsyncTeleport {
     private final IUser teleportOwner;
     private final IEssentials ess;
@@ -73,7 +71,7 @@ public class AsyncTeleport implements IAsyncTeleport {
                 time.setTimeInMillis(lastTime);
                 time.add(Calendar.SECOND, (int) cooldown);
                 time.add(Calendar.MILLISECOND, (int) ((cooldown * 1000.0) % 1000.0));
-                future.completeExceptionally(new Exception(tl("timeBeforeTeleport", DateUtil.formatDateDiff(time.getTimeInMillis()))));
+                future.completeExceptionally(new TranslatableException("timeBeforeTeleport", DateUtil.formatDateDiff(time.getTimeInMillis())));
                 return true;
             }
         }
@@ -107,7 +105,7 @@ public class AsyncTeleport implements IAsyncTeleport {
         final Calendar c = new GregorianCalendar();
         c.add(Calendar.SECOND, (int) delay);
         c.add(Calendar.MILLISECOND, (int) ((delay * 1000.0) % 1000.0));
-        user.sendMessage(tl("dontMoveMessage", DateUtil.formatDateDiff(c.getTimeInMillis())));
+        user.sendTl("dontMoveMessage", DateUtil.formatDateDiff(c.getTimeInMillis()));
     }
 
     @Override
@@ -129,7 +127,7 @@ public class AsyncTeleport implements IAsyncTeleport {
         nowAsync(teleportOwner, target, cause, future);
         future.thenAccept(success -> {
             if (success) {
-                teleportOwner.sendMessage(tl("teleporting", target.getLocation().getWorld().getName(), target.getLocation().getBlockX(), target.getLocation().getBlockY(), target.getLocation().getBlockZ()));
+                teleportOwner.sendTl("teleporting", target.getLocation().getWorld().getName(), target.getLocation().getBlockX(), target.getLocation().getBlockY(), target.getLocation().getBlockZ());
             }
         });
     }
@@ -166,7 +164,7 @@ public class AsyncTeleport implements IAsyncTeleport {
 
         if (!ess.getSettings().isForcePassengerTeleport() && !teleportee.getBase().isEmpty()) {
             if (!ess.getSettings().isTeleportPassengerDismount()) {
-                future.completeExceptionally(new Exception(tl("passengerTeleportFail")));
+                future.completeExceptionally(new TranslatableException("passengerTeleportFail"));
                 return;
             }
 
@@ -204,7 +202,7 @@ public class AsyncTeleport implements IAsyncTeleport {
                         }
                     }
                 } else {
-                    future.completeExceptionally(new Exception(tl("unsafeTeleportDestination", loc.getWorld().getName(), loc.getBlockX(), loc.getBlockY(), loc.getBlockZ())));
+                    future.completeExceptionally(new TranslatableException("unsafeTeleportDestination", loc.getWorld().getName(), loc.getBlockX(), loc.getBlockY(), loc.getBlockZ()));
                     return;
                 }
             } else {
@@ -233,7 +231,7 @@ public class AsyncTeleport implements IAsyncTeleport {
 
     @Override
     public void teleport(final Player entity, final Trade chargeFor, final TeleportCause cause, final CompletableFuture<Boolean> future) {
-        teleportOwner.sendMessage(tl("teleportToPlayer", entity.getDisplayName()));
+        teleportOwner.sendTl("teleportToPlayer", entity.getDisplayName());
         teleport(teleportOwner, new PlayerTarget(entity), chargeFor, cause, future);
     }
 
@@ -248,8 +246,8 @@ public class AsyncTeleport implements IAsyncTeleport {
         teleport(otherUser, target, chargeFor, cause, future);
         future.thenAccept(success -> {
             if (success) {
-                otherUser.sendMessage(tl("teleporting", target.getLocation().getWorld().getName(), target.getLocation().getBlockX(), target.getLocation().getBlockY(), target.getLocation().getBlockZ()));
-                teleportOwner.sendMessage(tl("teleporting", target.getLocation().getWorld().getName(), target.getLocation().getBlockX(), target.getLocation().getBlockY(), target.getLocation().getBlockZ()));
+                otherUser.sendTl("teleporting", target.getLocation().getWorld().getName(), target.getLocation().getBlockX(), target.getLocation().getBlockY(), target.getLocation().getBlockZ());
+                teleportOwner.sendTl("teleporting", target.getLocation().getWorld().getName(), target.getLocation().getBlockX(), target.getLocation().getBlockY(), target.getLocation().getBlockZ());
             }
         });
     }
@@ -308,7 +306,7 @@ public class AsyncTeleport implements IAsyncTeleport {
     private void teleportOther(final IUser teleporter, final IUser teleportee, final ITarget target, final Trade chargeFor, final TeleportCause cause, final CompletableFuture<Boolean> future) {
         double delay = ess.getSettings().getTeleportDelay();
 
-        final TeleportWarmupEvent event = new TeleportWarmupEvent(teleportee, cause, target, delay);
+        final TeleportWarmupEvent event = new TeleportWarmupEvent(teleporter, teleportee, cause, target, delay);
         Bukkit.getServer().getPluginManager().callEvent(event);
         if (event.isCancelled()) {
             return;
@@ -425,16 +423,16 @@ public class AsyncTeleport implements IAsyncTeleport {
         final Location loc;
         try {
             loc = ess.getWarps().getWarp(warp);
-        } catch (final WarpNotFoundException | InvalidWorldException e) {
+        } catch (final WarpNotFoundException e) {
             future.completeExceptionally(e);
             return;
         }
         final String finalWarp = warp;
         future.thenAccept(success -> {
             if (success) {
-                otherUser.sendMessage(tl("warpingTo", finalWarp, loc.getWorld().getName(), loc.getBlockX(), loc.getBlockY(), loc.getBlockZ()));
+                otherUser.sendTl("warpingTo", finalWarp, loc.getWorld().getName(), loc.getBlockX(), loc.getBlockY(), loc.getBlockZ());
                 if (!otherUser.equals(teleportOwner)) {
-                    teleportOwner.sendMessage(tl("warpingTo", finalWarp, loc.getWorld().getName(), loc.getBlockX(), loc.getBlockY(), loc.getBlockZ()));
+                    teleportOwner.sendTl("warpingTo", finalWarp, loc.getWorld().getName(), loc.getBlockX(), loc.getBlockY(), loc.getBlockZ());
                 }
             }
         });
@@ -450,7 +448,7 @@ public class AsyncTeleport implements IAsyncTeleport {
     public void back(final IUser teleporter, final Trade chargeFor, final CompletableFuture<Boolean> future) {
         tpType = TeleportType.BACK;
         final Location loc = teleportOwner.getLastLocation();
-        teleportOwner.sendMessage(tl("backUsageMsg", loc.getWorld().getName(), loc.getBlockX(), loc.getBlockY(), loc.getBlockZ()));
+        teleportOwner.sendTl("backUsageMsg", loc.getWorld().getName(), loc.getBlockX(), loc.getBlockY(), loc.getBlockZ());
         teleportOther(teleporter, teleportOwner, new LocationTarget(loc), chargeFor, TeleportCause.COMMAND, future);
     }
 
@@ -459,6 +457,10 @@ public class AsyncTeleport implements IAsyncTeleport {
         nowAsync(teleportOwner, new LocationTarget(teleportOwner.getLastLocation()), TeleportCause.COMMAND, future);
     }
 
+    public TeleportType getTpType() {
+        return this.tpType;
+    }
+
     public void setTpType(final TeleportType tpType) {
         this.tpType = tpType;
     }

Essentials/src/main/java/com/earth2me/essentials/AsyncTimedTeleport.java

@@ -1,14 +1,15 @@
 package com.earth2me.essentials;
 
-import net.ess3.api.IEssentials;
-import net.ess3.api.IUser;
-import org.bukkit.Location;
-import org.bukkit.event.player.PlayerTeleportEvent.TeleportCause;
-
 import java.util.UUID;
 import java.util.concurrent.CompletableFuture;
 
-import static com.earth2me.essentials.I18n.tl;
+import org.bukkit.Location;
+import org.bukkit.event.player.PlayerTeleportEvent.TeleportCause;
+
+import net.ess3.api.IEssentials;
+import net.ess3.api.IUser;
+import net.essentialsx.api.v2.events.TeleportWarmupCancelledEvent;
+import net.essentialsx.api.v2.events.TeleportWarmupCancelledEvent.CancelReason;
 
 public class AsyncTimedTeleport implements Runnable {
     private static final double MOVE_CONSTANT = 0.3;
@@ -106,14 +107,14 @@ public class AsyncTimedTeleport implements Runnable {
                     try {
                         teleport.cooldown(false);
                     } catch (final Throwable ex) {
-                        teleportOwner.sendMessage(tl("cooldownWithMessage", ex.getMessage()));
+                        teleportOwner.sendTl("cooldownWithMessage", ex.getMessage());
                         if (teleportOwner != teleportUser) {
-                            teleportUser.sendMessage(tl("cooldownWithMessage", ex.getMessage()));
+                            teleportUser.sendTl("cooldownWithMessage", ex.getMessage());
                         }
                     }
                     try {
                         cancelTimer(false);
-                        teleportUser.sendMessage(tl("teleportationCommencing"));
+                        teleportUser.sendTl("teleportationCommencing");
 
                         if (timer_chargeFor != null) {
                             timer_chargeFor.isAffordableFor(teleportOwner);
@@ -151,10 +152,18 @@ public class AsyncTimedTeleport implements Runnable {
         }
         try {
             ess.getServer().getScheduler().cancelTask(timer_task);
+
+            final IUser teleportUser = ess.getUser(this.timer_teleportee);
+            if (teleportUser != null && teleportUser.getBase() != null) {
+                final TeleportWarmupCancelledEvent.CancelReason cancelReason = teleportUser.getBase().isOnline() ? CancelReason.MOVE : CancelReason.LEAVE;
+                final TeleportWarmupCancelledEvent event = new TeleportWarmupCancelledEvent(teleportUser.getBase(), this.teleport.getTpType(), cancelReason, notifyUser);
+                ess.getServer().getPluginManager().callEvent(event);
+            }
+
             if (notifyUser) {
-                teleportOwner.sendMessage(tl("pendingTeleportCancelled"));
+                teleportOwner.sendTl("pendingTeleportCancelled");
                 if (timer_teleportee != null && !timer_teleportee.equals(teleportOwner.getBase().getUniqueId())) {
-                    ess.getUser(timer_teleportee).sendMessage(tl("pendingTeleportCancelled"));
+                    ess.getUser(timer_teleportee).sendTl("pendingTeleportCancelled");
                 }
             }
         } finally {

Essentials/src/main/java/com/earth2me/essentials/Backup.java

@@ -10,12 +10,10 @@ import java.io.InputStreamReader;
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.logging.Level;
-import java.util.logging.Logger;
 
-import static com.earth2me.essentials.I18n.tl;
+import static com.earth2me.essentials.I18n.tlLiteral;
 
 public class Backup implements Runnable {
-    private static final Logger LOGGER = Logger.getLogger("Essentials");
     private transient final Server server;
     private transient final IEssentials ess;
     private final AtomicBoolean pendingShutdown = new AtomicBoolean(false);
@@ -81,7 +79,7 @@ public class Backup implements Runnable {
             taskLock.complete(new Object());
             return;
         }
-        LOGGER.log(Level.INFO, tl("backupStarted"));
+        ess.getLogger().log(Level.INFO, ess.getAdventureFacet().miniToLegacy(tlLiteral("backupStarted")));
         final CommandSender cs = server.getConsoleSender();
         server.dispatchCommand(cs, "save-all");
         server.dispatchCommand(cs, "save-off");
@@ -99,17 +97,17 @@ public class Backup implements Runnable {
                             do {
                                 line = reader.readLine();
                                 if (line != null) {
-                                    LOGGER.log(Level.INFO, line);
+                                    ess.getLogger().log(Level.INFO, line);
                                 }
                             } while (line != null);
                         }
                     } catch (final IOException ex) {
-                        LOGGER.log(Level.SEVERE, null, ex);
+                        ess.getLogger().log(Level.SEVERE, "An error occurred while reading backup child process", ex);
                     }
                 });
                 child.waitFor();
             } catch (final InterruptedException | IOException ex) {
-                LOGGER.log(Level.SEVERE, null, ex);
+                ess.getLogger().log(Level.SEVERE, "An error occurred while building the backup child process", ex);
             } finally {
                 class BackupEnableSaveTask implements Runnable {
                     @Override
@@ -120,7 +118,7 @@ public class Backup implements Runnable {
                         }
                         active = false;
                         taskLock.complete(new Object());
-                        LOGGER.log(Level.INFO, tl("backupFinished"));
+                        ess.getLogger().log(Level.INFO, ess.getAdventureFacet().miniToLegacy(tlLiteral("backupFinished")));
                     }
                 }
 

Essentials/src/main/java/com/earth2me/essentials/BalanceTopImpl.java

@@ -28,8 +28,8 @@ public class BalanceTopImpl implements BalanceTop {
     private void calculateBalanceTopMap() {
         final List<Entry> entries = new LinkedList<>();
         BigDecimal newTotal = BigDecimal.ZERO;
-        for (UUID u : ess.getUserMap().getAllUniqueUsers()) {
-            final User user = ess.getUserMap().getUser(u);
+        for (UUID u : ess.getUsers().getAllUserUUIDs()) {
+            final User user = ess.getUsers().loadUncachedUser(u);
             if (user != null) {
                 if (!ess.getSettings().isNpcsInBalanceRanking() && user.isNPC()) {
                     // Don't list NPCs in output
@@ -40,7 +40,7 @@ public class BalanceTopImpl implements BalanceTop {
                     user.updateMoneyCache(userMoney);
                     newTotal = newTotal.add(userMoney);
                     final String name;
-                    if (user.getBase() instanceof OfflinePlayer) {
+                    if (user.getBase() instanceof OfflinePlayerStub) {
                         name = user.getLastAccountName();
                     } else if (user.isHidden()) {
                         name = user.getName();
@@ -53,7 +53,10 @@ public class BalanceTopImpl implements BalanceTop {
         }
         final LinkedHashMap<UUID, Entry> sortedMap = new LinkedHashMap<>();
         entries.sort((entry1, entry2) -> entry2.getBalance().compareTo(entry1.getBalance()));
-        for (Entry entry : entries) {
+        final int entryLimit = ess.getSettings().getBaltopEntryLimit();
+        final int limit = entryLimit == -1 ? entries.size() : Math.min(entryLimit, entries.size());
+        for (int i = 0; i < limit; i++) {
+            final Entry entry = entries.get(i);
             sortedMap.put(entry.getUuid(), entry);
         }
         topCache = sortedMap;

Essentials/src/main/java/com/earth2me/essentials/ChargeException.java

@@ -1,11 +1,9 @@
 package com.earth2me.essentials;
 
-public class ChargeException extends Exception {
-    public ChargeException(final String message) {
-        super(message);
-    }
+import net.ess3.api.TranslatableException;
 
-    public ChargeException(final String message, final Throwable throwable) {
-        super(message, throwable);
+public class ChargeException extends TranslatableException {
+    public ChargeException(String tlKey, Object... args) {
+        super(tlKey, args);
     }
 }

Essentials/src/main/java/com/earth2me/essentials/CommandSource.java

@@ -1,12 +1,17 @@
 package com.earth2me.essentials;
 
+import com.earth2me.essentials.adventure.ComponentHolder;
 import org.bukkit.command.CommandSender;
 import org.bukkit.entity.Player;
 
+import static com.earth2me.essentials.I18n.tlLiteral;
+
 public class CommandSource {
+    protected Essentials ess;
     protected CommandSender sender;
 
-    public CommandSource(final CommandSender base) {
+    public CommandSource(final Essentials ess, final CommandSender base) {
+        this.ess = ess;
         this.sender = base;
     }
 
@@ -21,7 +26,41 @@ public class CommandSource {
         return null;
     }
 
-    public final net.ess3.api.IUser getUser(final IEssentials ess) {
+    public void sendTl(final String tlKey, final Object... args) {
+        if (isPlayer()) {
+            //noinspection ConstantConditions
+            getUser().sendTl(tlKey, args);
+            return;
+        }
+
+        final String translation = tlLiteral(tlKey, args);
+        if (!translation.isEmpty()) {
+            sendComponent(ess.getAdventureFacet().deserializeMiniMessage(translation));
+        }
+    }
+
+    public String tl(final String tlKey, final Object... args) {
+        if (isPlayer()) {
+            //noinspection ConstantConditions
+            return getUser().playerTl(tlKey, args);
+        }
+        return tlLiteral(tlKey, args);
+    }
+
+    public ComponentHolder tlComponent(final String tlKey, final Object... args) {
+        if (isPlayer()) {
+            //noinspection ConstantConditions
+            return getUser().tlComponent(tlKey, args);
+        }
+        final String translation = tlLiteral(tlKey, args);
+        return ess.getAdventureFacet().deserializeMiniMessage(translation);
+    }
+
+    public void sendComponent(final ComponentHolder component) {
+        ess.getAdventureFacet().send(sender, component);
+    }
+
+    public final net.ess3.api.IUser getUser() {
         if (sender instanceof Player) {
             return ess.getUser((Player) sender);
         }
@@ -42,15 +81,18 @@ public class CommandSource {
         }
     }
 
-    public boolean isAuthorized(final String permission, final IEssentials ess) {
-        return !(sender instanceof Player) || getUser(ess).isAuthorized(permission);
+    public boolean isAuthorized(final String permission) {
+        //noinspection ConstantConditions
+        return !(sender instanceof Player) || getUser().isAuthorized(permission);
     }
 
     public String getSelfSelector() {
+        //noinspection ConstantConditions
         return sender instanceof Player ? getPlayer().getName() : "*";
     }
 
     public String getDisplayName() {
+        //noinspection ConstantConditions
         return sender instanceof Player ? getPlayer().getDisplayName() : getSender().getName();
     }
 }

Essentials/src/main/java/com/earth2me/essentials/Console.java

@@ -1,5 +1,6 @@
 package com.earth2me.essentials;
 
+import com.earth2me.essentials.adventure.AdventureFacet;
 import com.earth2me.essentials.messaging.IMessageRecipient;
 import com.earth2me.essentials.messaging.SimpleMessageRecipient;
 import org.bukkit.Server;
@@ -8,11 +9,15 @@ import org.bukkit.entity.Player;
 
 import java.util.UUID;
 
-import static com.earth2me.essentials.I18n.tl;
+import static com.earth2me.essentials.I18n.tlLiteral;
 
 public final class Console implements IMessageRecipient {
     public static final String NAME = "Console";
-    public static final String DISPLAY_NAME = tl("consoleName");
+
+    public static String displayName() {
+        return tlLiteral("consoleName");
+    }
+
     private static Console instance; // Set in essentials
 
     private final IEssentials ess;
@@ -55,7 +60,7 @@ public final class Console implements IMessageRecipient {
 
     @Override
     public String getDisplayName() {
-        return Console.DISPLAY_NAME;
+        return displayName();
     }
 
     @Override
@@ -63,6 +68,22 @@ public final class Console implements IMessageRecipient {
         getCommandSender().sendMessage(message);
     }
 
+    @Override
+    public void sendTl(String tlKey, Object... args) {
+        final String translation = tlLiteral(tlKey, args);
+        if (translation.isEmpty()) {
+            return;
+        }
+
+        final AdventureFacet adventureFacet = ess.getAdventureFacet();
+        adventureFacet.send(getCommandSender(), adventureFacet.deserializeMiniMessage(translation));
+    }
+
+    @Override
+    public String tlSender(String tlKey, Object... args) {
+        return tlLiteral(tlKey, args);
+    }
+
     @Override
     public boolean isReachable() {
         return true;

Essentials/src/main/java/com/earth2me/essentials/Enchantments.java

@@ -1,5 +1,6 @@
 package com.earth2me.essentials;
 
+import com.earth2me.essentials.utils.RegistryUtil;
 import org.bukkit.NamespacedKey;
 import org.bukkit.enchantments.Enchantment;
 
@@ -15,33 +16,43 @@ public final class Enchantments {
     private static boolean isFlat;
 
     static {
-        ENCHANTMENTS.put("alldamage", Enchantment.DAMAGE_ALL);
-        ALIASENCHANTMENTS.put("alldmg", Enchantment.DAMAGE_ALL);
-        ENCHANTMENTS.put("sharpness", Enchantment.DAMAGE_ALL);
-        ALIASENCHANTMENTS.put("sharp", Enchantment.DAMAGE_ALL);
-        ALIASENCHANTMENTS.put("dal", Enchantment.DAMAGE_ALL);
+        final Enchantment SHARPNESS = RegistryUtil.valueOf(Enchantment.class, "DAMAGE_ALL", "SHARPNESS");
 
-        ENCHANTMENTS.put("ardmg", Enchantment.DAMAGE_ARTHROPODS);
-        ENCHANTMENTS.put("baneofarthropods", Enchantment.DAMAGE_ARTHROPODS);
-        ALIASENCHANTMENTS.put("baneofarthropod", Enchantment.DAMAGE_ARTHROPODS);
-        ALIASENCHANTMENTS.put("arthropod", Enchantment.DAMAGE_ARTHROPODS);
-        ALIASENCHANTMENTS.put("dar", Enchantment.DAMAGE_ARTHROPODS);
+        ENCHANTMENTS.put("alldamage", SHARPNESS);
+        ALIASENCHANTMENTS.put("alldmg", SHARPNESS);
+        ENCHANTMENTS.put("sharpness", SHARPNESS);
+        ALIASENCHANTMENTS.put("sharp", SHARPNESS);
+        ALIASENCHANTMENTS.put("dal", SHARPNESS);
 
-        ENCHANTMENTS.put("undeaddamage", Enchantment.DAMAGE_UNDEAD);
-        ENCHANTMENTS.put("smite", Enchantment.DAMAGE_UNDEAD);
-        ALIASENCHANTMENTS.put("du", Enchantment.DAMAGE_UNDEAD);
+        final Enchantment BANE_OF_ARTHROPODS = RegistryUtil.valueOf(Enchantment.class, "DAMAGE_ARTHROPODS", "BANE_OF_ARTHROPODS");
 
-        ENCHANTMENTS.put("digspeed", Enchantment.DIG_SPEED);
-        ENCHANTMENTS.put("efficiency", Enchantment.DIG_SPEED);
-        ALIASENCHANTMENTS.put("minespeed", Enchantment.DIG_SPEED);
-        ALIASENCHANTMENTS.put("cutspeed", Enchantment.DIG_SPEED);
-        ALIASENCHANTMENTS.put("ds", Enchantment.DIG_SPEED);
-        ALIASENCHANTMENTS.put("eff", Enchantment.DIG_SPEED);
+        ENCHANTMENTS.put("ardmg", BANE_OF_ARTHROPODS);
+        ENCHANTMENTS.put("baneofarthropods", BANE_OF_ARTHROPODS);
+        ALIASENCHANTMENTS.put("baneofarthropod", BANE_OF_ARTHROPODS);
+        ALIASENCHANTMENTS.put("arthropod", BANE_OF_ARTHROPODS);
+        ALIASENCHANTMENTS.put("dar", BANE_OF_ARTHROPODS);
 
-        ENCHANTMENTS.put("durability", Enchantment.DURABILITY);
-        ALIASENCHANTMENTS.put("dura", Enchantment.DURABILITY);
-        ENCHANTMENTS.put("unbreaking", Enchantment.DURABILITY);
-        ALIASENCHANTMENTS.put("d", Enchantment.DURABILITY);
+        final Enchantment SMITE = RegistryUtil.valueOf(Enchantment.class, "DAMAGE_UNDEAD", "SMITE");
+
+        ENCHANTMENTS.put("undeaddamage", SMITE);
+        ENCHANTMENTS.put("smite", SMITE);
+        ALIASENCHANTMENTS.put("du", SMITE);
+
+        final Enchantment EFFICIENCY = RegistryUtil.valueOf(Enchantment.class, "DIG_SPEED", "EFFICIENCY");
+
+        ENCHANTMENTS.put("digspeed", EFFICIENCY);
+        ENCHANTMENTS.put("efficiency", EFFICIENCY);
+        ALIASENCHANTMENTS.put("minespeed", EFFICIENCY);
+        ALIASENCHANTMENTS.put("cutspeed", EFFICIENCY);
+        ALIASENCHANTMENTS.put("ds", EFFICIENCY);
+        ALIASENCHANTMENTS.put("eff", EFFICIENCY);
+
+        final Enchantment UNBREAKING = RegistryUtil.valueOf(Enchantment.class, "DURABILITY", "UNBREAKING");
+
+        ENCHANTMENTS.put("durability", UNBREAKING);
+        ALIASENCHANTMENTS.put("dura", UNBREAKING);
+        ENCHANTMENTS.put("unbreaking", UNBREAKING);
+        ALIASENCHANTMENTS.put("d", UNBREAKING);
 
         ENCHANTMENTS.put("thorns", Enchantment.THORNS);
         ENCHANTMENTS.put("highcrit", Enchantment.THORNS);
@@ -60,105 +71,126 @@ public final class Enchantments {
         ALIASENCHANTMENTS.put("kb", Enchantment.KNOCKBACK);
         ALIASENCHANTMENTS.put("k", Enchantment.KNOCKBACK);
 
-        ALIASENCHANTMENTS.put("blockslootbonus", Enchantment.LOOT_BONUS_BLOCKS);
-        ENCHANTMENTS.put("fortune", Enchantment.LOOT_BONUS_BLOCKS);
-        ALIASENCHANTMENTS.put("fort", Enchantment.LOOT_BONUS_BLOCKS);
-        ALIASENCHANTMENTS.put("lbb", Enchantment.LOOT_BONUS_BLOCKS);
+        final Enchantment FORTUNE = RegistryUtil.valueOf(Enchantment.class, "LOOT_BONUS_BLOCKS", "FORTUNE");
 
-        ALIASENCHANTMENTS.put("mobslootbonus", Enchantment.LOOT_BONUS_MOBS);
-        ENCHANTMENTS.put("mobloot", Enchantment.LOOT_BONUS_MOBS);
-        ENCHANTMENTS.put("looting", Enchantment.LOOT_BONUS_MOBS);
-        ALIASENCHANTMENTS.put("lbm", Enchantment.LOOT_BONUS_MOBS);
+        ALIASENCHANTMENTS.put("blockslootbonus", FORTUNE);
+        ENCHANTMENTS.put("fortune", FORTUNE);
+        ALIASENCHANTMENTS.put("fort", FORTUNE);
+        ALIASENCHANTMENTS.put("lbb", FORTUNE);
 
-        ALIASENCHANTMENTS.put("oxygen", Enchantment.OXYGEN);
-        ENCHANTMENTS.put("respiration", Enchantment.OXYGEN);
-        ALIASENCHANTMENTS.put("breathing", Enchantment.OXYGEN);
-        ENCHANTMENTS.put("breath", Enchantment.OXYGEN);
-        ALIASENCHANTMENTS.put("o", Enchantment.OXYGEN);
+        final Enchantment LOOTING = RegistryUtil.valueOf(Enchantment.class, "LOOT_BONUS_MOBS", "LOOTING");
 
-        ENCHANTMENTS.put("protection", Enchantment.PROTECTION_ENVIRONMENTAL);
-        ALIASENCHANTMENTS.put("prot", Enchantment.PROTECTION_ENVIRONMENTAL);
-        ENCHANTMENTS.put("protect", Enchantment.PROTECTION_ENVIRONMENTAL);
-        ALIASENCHANTMENTS.put("p", Enchantment.PROTECTION_ENVIRONMENTAL);
+        ALIASENCHANTMENTS.put("mobslootbonus", LOOTING);
+        ENCHANTMENTS.put("mobloot", LOOTING);
+        ENCHANTMENTS.put("looting", LOOTING);
+        ALIASENCHANTMENTS.put("lbm", LOOTING);
 
-        ALIASENCHANTMENTS.put("explosionsprotection", Enchantment.PROTECTION_EXPLOSIONS);
-        ALIASENCHANTMENTS.put("explosionprotection", Enchantment.PROTECTION_EXPLOSIONS);
-        ALIASENCHANTMENTS.put("expprot", Enchantment.PROTECTION_EXPLOSIONS);
-        ALIASENCHANTMENTS.put("blastprotection", Enchantment.PROTECTION_EXPLOSIONS);
-        ALIASENCHANTMENTS.put("bprotection", Enchantment.PROTECTION_EXPLOSIONS);
-        ALIASENCHANTMENTS.put("bprotect", Enchantment.PROTECTION_EXPLOSIONS);
-        ENCHANTMENTS.put("blastprotect", Enchantment.PROTECTION_EXPLOSIONS);
-        ALIASENCHANTMENTS.put("pe", Enchantment.PROTECTION_EXPLOSIONS);
+        final Enchantment RESPIRATION = RegistryUtil.valueOf(Enchantment.class, "OXYGEN", "RESPIRATION");
 
-        ALIASENCHANTMENTS.put("fallprotection", Enchantment.PROTECTION_FALL);
-        ENCHANTMENTS.put("fallprot", Enchantment.PROTECTION_FALL);
-        ENCHANTMENTS.put("featherfall", Enchantment.PROTECTION_FALL);
-        ALIASENCHANTMENTS.put("featherfalling", Enchantment.PROTECTION_FALL);
-        ALIASENCHANTMENTS.put("pfa", Enchantment.PROTECTION_FALL);
+        ALIASENCHANTMENTS.put("oxygen", RESPIRATION);
+        ENCHANTMENTS.put("respiration", RESPIRATION);
+        ALIASENCHANTMENTS.put("breathing", RESPIRATION);
+        ENCHANTMENTS.put("breath", RESPIRATION);
+        ALIASENCHANTMENTS.put("o", RESPIRATION);
 
-        ALIASENCHANTMENTS.put("fireprotection", Enchantment.PROTECTION_FIRE);
-        ALIASENCHANTMENTS.put("flameprotection", Enchantment.PROTECTION_FIRE);
-        ENCHANTMENTS.put("fireprotect", Enchantment.PROTECTION_FIRE);
-        ALIASENCHANTMENTS.put("flameprotect", Enchantment.PROTECTION_FIRE);
-        ENCHANTMENTS.put("fireprot", Enchantment.PROTECTION_FIRE);
-        ALIASENCHANTMENTS.put("flameprot", Enchantment.PROTECTION_FIRE);
-        ALIASENCHANTMENTS.put("pf", Enchantment.PROTECTION_FIRE);
+        final Enchantment PROTECTION = RegistryUtil.valueOf(Enchantment.class, "PROTECTION_ENVIRONMENTAL", "PROTECTION");
 
-        ENCHANTMENTS.put("projectileprotection", Enchantment.PROTECTION_PROJECTILE);
-        ENCHANTMENTS.put("projprot", Enchantment.PROTECTION_PROJECTILE);
-        ALIASENCHANTMENTS.put("pp", Enchantment.PROTECTION_PROJECTILE);
+        ENCHANTMENTS.put("protection", PROTECTION);
+        ALIASENCHANTMENTS.put("prot", PROTECTION);
+        ENCHANTMENTS.put("protect", PROTECTION);
+        ALIASENCHANTMENTS.put("p", PROTECTION);
+
+        final Enchantment BLAST_PROTECTION = RegistryUtil.valueOf(Enchantment.class, "PROTECTION_EXPLOSIONS", "BLAST_PROTECTION");
+
+        ALIASENCHANTMENTS.put("explosionsprotection", BLAST_PROTECTION);
+        ALIASENCHANTMENTS.put("explosionprotection", BLAST_PROTECTION);
+        ALIASENCHANTMENTS.put("expprot", BLAST_PROTECTION);
+        ALIASENCHANTMENTS.put("blastprotection", BLAST_PROTECTION);
+        ALIASENCHANTMENTS.put("bprotection", BLAST_PROTECTION);
+        ALIASENCHANTMENTS.put("bprotect", BLAST_PROTECTION);
+        ENCHANTMENTS.put("blastprotect", BLAST_PROTECTION);
+        ALIASENCHANTMENTS.put("pe", BLAST_PROTECTION);
+
+        final Enchantment FEATHER_FALLING = RegistryUtil.valueOf(Enchantment.class, "PROTECTION_FALL", "FEATHER_FALLING");
+
+        ALIASENCHANTMENTS.put("fallprotection", FEATHER_FALLING);
+        ENCHANTMENTS.put("fallprot", FEATHER_FALLING);
+        ENCHANTMENTS.put("featherfall", FEATHER_FALLING);
+        ALIASENCHANTMENTS.put("featherfalling", FEATHER_FALLING);
+        ALIASENCHANTMENTS.put("pfa", FEATHER_FALLING);
+
+        final Enchantment FIRE_PROTECTION = RegistryUtil.valueOf(Enchantment.class, "PROTECTION_FIRE", "FIRE_PROTECTION");
+
+        ALIASENCHANTMENTS.put("fireprotection", FIRE_PROTECTION);
+        ALIASENCHANTMENTS.put("flameprotection", FIRE_PROTECTION);
+        ENCHANTMENTS.put("fireprotect", FIRE_PROTECTION);
+        ALIASENCHANTMENTS.put("flameprotect", FIRE_PROTECTION);
+        ENCHANTMENTS.put("fireprot", FIRE_PROTECTION);
+        ALIASENCHANTMENTS.put("flameprot", FIRE_PROTECTION);
+        ALIASENCHANTMENTS.put("pf", FIRE_PROTECTION);
+
+        final Enchantment PROJECTILE_PROTECTION = RegistryUtil.valueOf(Enchantment.class, "PROTECTION_PROJECTILE", "PROJECTILE_PROTECTION");
+
+        ENCHANTMENTS.put("projectileprotection", PROJECTILE_PROTECTION);
+        ENCHANTMENTS.put("projprot", PROJECTILE_PROTECTION);
+        ALIASENCHANTMENTS.put("pp", PROJECTILE_PROTECTION);
 
         ENCHANTMENTS.put("silktouch", Enchantment.SILK_TOUCH);
         ALIASENCHANTMENTS.put("softtouch", Enchantment.SILK_TOUCH);
         ALIASENCHANTMENTS.put("st", Enchantment.SILK_TOUCH);
 
-        ENCHANTMENTS.put("waterworker", Enchantment.WATER_WORKER);
-        ENCHANTMENTS.put("aquaaffinity", Enchantment.WATER_WORKER);
-        ALIASENCHANTMENTS.put("watermine", Enchantment.WATER_WORKER);
-        ALIASENCHANTMENTS.put("ww", Enchantment.WATER_WORKER);
+        final Enchantment AQUA_AFFINITY = RegistryUtil.valueOf(Enchantment.class, "WATER_WORKER", "AQUA_AFFINITY");
 
-        ALIASENCHANTMENTS.put("firearrow", Enchantment.ARROW_FIRE);
-        ENCHANTMENTS.put("flame", Enchantment.ARROW_FIRE);
-        ENCHANTMENTS.put("flamearrow", Enchantment.ARROW_FIRE);
-        ALIASENCHANTMENTS.put("af", Enchantment.ARROW_FIRE);
+        ENCHANTMENTS.put("waterworker", AQUA_AFFINITY);
+        ENCHANTMENTS.put("aquaaffinity", AQUA_AFFINITY);
+        ALIASENCHANTMENTS.put("watermine", AQUA_AFFINITY);
+        ALIASENCHANTMENTS.put("ww", AQUA_AFFINITY);
 
-        ENCHANTMENTS.put("arrowdamage", Enchantment.ARROW_DAMAGE);
-        ENCHANTMENTS.put("power", Enchantment.ARROW_DAMAGE);
-        ALIASENCHANTMENTS.put("arrowpower", Enchantment.ARROW_DAMAGE);
-        ALIASENCHANTMENTS.put("ad", Enchantment.ARROW_DAMAGE);
+        final Enchantment FLAME = RegistryUtil.valueOf(Enchantment.class, "ARROW_FIRE", "FLAME");
 
-        ENCHANTMENTS.put("arrowknockback", Enchantment.ARROW_KNOCKBACK);
-        ALIASENCHANTMENTS.put("arrowkb", Enchantment.ARROW_KNOCKBACK);
-        ENCHANTMENTS.put("punch", Enchantment.ARROW_KNOCKBACK);
-        ALIASENCHANTMENTS.put("arrowpunch", Enchantment.ARROW_KNOCKBACK);
-        ALIASENCHANTMENTS.put("ak", Enchantment.ARROW_KNOCKBACK);
+        ALIASENCHANTMENTS.put("firearrow", FLAME);
+        ENCHANTMENTS.put("flame", FLAME);
+        ENCHANTMENTS.put("flamearrow", FLAME);
+        ALIASENCHANTMENTS.put("af", FLAME);
 
-        ALIASENCHANTMENTS.put("infinitearrows", Enchantment.ARROW_INFINITE);
-        ENCHANTMENTS.put("infarrows", Enchantment.ARROW_INFINITE);
-        ENCHANTMENTS.put("infinity", Enchantment.ARROW_INFINITE);
-        ALIASENCHANTMENTS.put("infinite", Enchantment.ARROW_INFINITE);
-        ALIASENCHANTMENTS.put("unlimited", Enchantment.ARROW_INFINITE);
-        ALIASENCHANTMENTS.put("unlimitedarrows", Enchantment.ARROW_INFINITE);
-        ALIASENCHANTMENTS.put("ai", Enchantment.ARROW_INFINITE);
+        final Enchantment POWER = RegistryUtil.valueOf(Enchantment.class, "ARROW_DAMAGE", "POWER");
 
-        ENCHANTMENTS.put("luck", Enchantment.LUCK);
-        ALIASENCHANTMENTS.put("luckofsea", Enchantment.LUCK);
-        ALIASENCHANTMENTS.put("luckofseas", Enchantment.LUCK);
-        ALIASENCHANTMENTS.put("rodluck", Enchantment.LUCK);
+        ENCHANTMENTS.put("arrowdamage", POWER);
+        ENCHANTMENTS.put("power", POWER);
+        ALIASENCHANTMENTS.put("arrowpower", POWER);
+        ALIASENCHANTMENTS.put("ad", POWER);
+
+        final Enchantment PUNCH = RegistryUtil.valueOf(Enchantment.class, "ARROW_KNOCKBACK", "PUNCH");
+
+        ENCHANTMENTS.put("arrowknockback", PUNCH);
+        ALIASENCHANTMENTS.put("arrowkb", PUNCH);
+        ENCHANTMENTS.put("punch", PUNCH);
+        ALIASENCHANTMENTS.put("arrowpunch", PUNCH);
+        ALIASENCHANTMENTS.put("ak", PUNCH);
+
+        final Enchantment INFINITY = RegistryUtil.valueOf(Enchantment.class, "ARROW_INFINITE", "INFINITY");
+
+        ALIASENCHANTMENTS.put("infinitearrows", INFINITY);
+        ENCHANTMENTS.put("infarrows", INFINITY);
+        ENCHANTMENTS.put("infinity", INFINITY);
+        ALIASENCHANTMENTS.put("infinite", INFINITY);
+        ALIASENCHANTMENTS.put("unlimited", INFINITY);
+        ALIASENCHANTMENTS.put("unlimitedarrows", INFINITY);
+        ALIASENCHANTMENTS.put("ai", INFINITY);
+
+        final Enchantment LUCK_OF_THE_SEA = RegistryUtil.valueOf(Enchantment.class, "LUCK", "LUCK_OF_THE_SEA");
+
+        ENCHANTMENTS.put("luck", LUCK_OF_THE_SEA);
+        ALIASENCHANTMENTS.put("luckofsea", LUCK_OF_THE_SEA);
+        ALIASENCHANTMENTS.put("luckofseas", LUCK_OF_THE_SEA);
+        ALIASENCHANTMENTS.put("rodluck", LUCK_OF_THE_SEA);
 
         ENCHANTMENTS.put("lure", Enchantment.LURE);
         ALIASENCHANTMENTS.put("rodlure", Enchantment.LURE);
 
-        // 1.8
-        try {
-            final Enchantment depthStrider = Enchantment.getByName("DEPTH_STRIDER");
-            if (depthStrider != null) {
-                ENCHANTMENTS.put("depthstrider", depthStrider);
-                ALIASENCHANTMENTS.put("depth", depthStrider);
-                ALIASENCHANTMENTS.put("strider", depthStrider);
-            }
-        } catch (final IllegalArgumentException ignored) {
-        }
+        ENCHANTMENTS.put("depthstrider", Enchantment.DEPTH_STRIDER);
+        ALIASENCHANTMENTS.put("depth", Enchantment.DEPTH_STRIDER);
+        ALIASENCHANTMENTS.put("strider", Enchantment.DEPTH_STRIDER);
 
         // 1.9
         try {
@@ -263,6 +295,40 @@ public final class Enchantments {
         } catch (final IllegalArgumentException ignored) {
         }
 
+        try { // 1.19
+            final Enchantment swiftSneak = Enchantment.getByName("SWIFT_SNEAK");
+            if (swiftSneak != null) {
+                ENCHANTMENTS.put("swiftsneak", swiftSneak);
+            }
+        } catch (final IllegalArgumentException ignored) {
+        }
+
+        try { // 1.21
+            final Enchantment breach = Enchantment.getByName("BREACH");
+            if (breach != null) {
+                ENCHANTMENTS.put("breach", breach);
+            }
+            final Enchantment density = Enchantment.getByName("DENSITY");
+            if (density != null) {
+                ENCHANTMENTS.put("density", density);
+            }
+            final Enchantment windBurst = Enchantment.getByName("WIND_BURST");
+            if (windBurst != null) {
+                ENCHANTMENTS.put("windburst", windBurst);
+                ALIASENCHANTMENTS.put("wind", windBurst);
+                ALIASENCHANTMENTS.put("burst", windBurst);
+            }
+        } catch (final IllegalArgumentException ignored) {
+        }
+
+        try { // 1.21.11
+            final Enchantment lunge = Enchantment.getByName("LUNGE");
+            if (lunge != null) {
+                ENCHANTMENTS.put("lunge", lunge);
+            }
+        } catch (final IllegalArgumentException ignored) {
+        }
+
         try {
             final Class<?> namespacedKeyClass = Class.forName("org.bukkit.NamespacedKey");
             final Class<?> enchantmentClass = Class.forName("org.bukkit.enchantments.Enchantment");
@@ -276,6 +342,17 @@ public final class Enchantments {
     private Enchantments() {
     }
 
+    public static String getRealName(final Enchantment enchantment) {
+        if (enchantment == null) {
+            return null;
+        }
+
+        if (isFlat) { // 1.13+ only
+            return enchantment.getKey().getKey();
+        }
+        return enchantment.getName().toLowerCase(Locale.ENGLISH);
+    }
+
     public static Enchantment getByName(final String name) {
         if (name == null || name.isEmpty()) {
             return null;

Essentials/src/main/java/com/earth2me/essentials/EssentialsBlockListener.java

@@ -1,7 +1,10 @@
 package com.earth2me.essentials;
 
+import com.earth2me.essentials.craftbukkit.Inventories;
 import com.earth2me.essentials.utils.MaterialUtil;
 import net.ess3.api.IEssentials;
+import net.ess3.provider.PersistentDataProvider;
+import net.ess3.provider.SpawnerItemProvider;
 import org.bukkit.GameMode;
 import org.bukkit.block.BlockState;
 import org.bukkit.block.CreatureSpawner;
@@ -25,11 +28,11 @@ public class EssentialsBlockListener implements Listener {
     public void onBlockPlace(final BlockPlaceEvent event) {
         final ItemStack is = event.getItemInHand();
 
-        if (is.getType() == MaterialUtil.SPAWNER && ess.getPersistentDataProvider().getString(is, "convert") != null) {
+        if (is.getType() == MaterialUtil.SPAWNER && ess.provider(PersistentDataProvider.class).getString(is, "convert") != null) {
             final BlockState blockState = event.getBlockPlaced().getState();
             if (blockState instanceof CreatureSpawner) {
                 final CreatureSpawner spawner = (CreatureSpawner) blockState;
-                final EntityType type = ess.getSpawnerItemProvider().getEntityType(event.getItemInHand());
+                final EntityType type = ess.provider(SpawnerItemProvider.class).getEntityType(event.getItemInHand());
                 if (type != null && Mob.fromBukkitType(type) != null) {
                     if (ess.getUser(event.getPlayer()).isAuthorized("essentials.spawnerconvert." + Mob.fromBukkitType(type).name().toLowerCase(Locale.ENGLISH))) {
                         spawner.setSpawnedType(type);
@@ -42,8 +45,12 @@ public class EssentialsBlockListener implements Listener {
         final User user = ess.getUser(event.getPlayer());
         if (user.hasUnlimited(is) && user.getBase().getGameMode() == GameMode.SURVIVAL) {
             ess.scheduleSyncDelayedTask(() -> {
-                user.getBase().getInventory().addItem(is);
-                user.getBase().updateInventory();
+                if (is != null && is.getType() != null && !MaterialUtil.isAir(is.getType())) {
+                    final ItemStack cloneIs = is.clone();
+                    cloneIs.setAmount(1);
+                    Inventories.addItem(user.getBase(), cloneIs);
+                    user.getBase().updateInventory();
+                }
             });
         }
     }

Essentials/src/main/java/com/earth2me/essentials/EssentialsConf.java

@@ -1,674 +0,0 @@
-package com.earth2me.essentials;
-
-import com.google.common.io.Files;
-import net.ess3.api.InvalidWorldException;
-import org.bukkit.Location;
-import org.bukkit.Material;
-import org.bukkit.OfflinePlayer;
-import org.bukkit.Server;
-import org.bukkit.World;
-import org.bukkit.configuration.ConfigurationSection;
-import org.bukkit.configuration.InvalidConfigurationException;
-import org.bukkit.configuration.file.YamlConfiguration;
-import org.bukkit.enchantments.Enchantment;
-import org.bukkit.inventory.ItemStack;
-import org.bukkit.util.Vector;
-
-import java.io.File;
-import java.io.FileInputStream;
-import java.io.FileNotFoundException;
-import java.io.FileOutputStream;
-import java.io.IOException;
-import java.io.InputStream;
-import java.io.OutputStream;
-import java.io.OutputStreamWriter;
-import java.math.BigDecimal;
-import java.math.MathContext;
-import java.nio.Buffer;
-import java.nio.ByteBuffer;
-import java.nio.CharBuffer;
-import java.nio.charset.Charset;
-import java.nio.charset.CharsetDecoder;
-import java.nio.charset.CoderResult;
-import java.nio.charset.StandardCharsets;
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.LinkedHashMap;
-import java.util.List;
-import java.util.Locale;
-import java.util.Map;
-import java.util.Set;
-import java.util.concurrent.ExecutionException;
-import java.util.concurrent.ExecutorService;
-import java.util.concurrent.Executors;
-import java.util.concurrent.Future;
-import java.util.concurrent.atomic.AtomicBoolean;
-import java.util.concurrent.atomic.AtomicInteger;
-import java.util.logging.Level;
-import java.util.logging.Logger;
-
-import static com.earth2me.essentials.I18n.tl;
-
-public class EssentialsConf extends YamlConfiguration {
-    protected static final Logger LOGGER = Logger.getLogger("Essentials");
-    protected static final Charset UTF8 = StandardCharsets.UTF_8;
-    private static final ExecutorService EXECUTOR_SERVICE = Executors.newSingleThreadExecutor();
-    protected final File configFile;
-    private final AtomicInteger pendingDiskWrites = new AtomicInteger(0);
-    private final AtomicBoolean transaction = new AtomicBoolean(false);
-    private final byte[] bytebuffer = new byte[1024];
-    protected String templateName = null;
-    private Class<?> resourceClass = EssentialsConf.class;
-
-    public EssentialsConf(final File configFile) {
-        super();
-        this.configFile = configFile.getAbsoluteFile();
-    }
-
-    public static BigDecimal toBigDecimal(final String input, final BigDecimal def) {
-        if (input == null || input.isEmpty()) {
-            return def;
-        } else {
-            try {
-                return new BigDecimal(input, MathContext.DECIMAL128);
-            } catch (final NumberFormatException | ArithmeticException e) {
-                return def;
-            }
-        }
-    }
-
-    public synchronized void load() {
-        if (pendingDiskWrites.get() != 0) {
-            LOGGER.log(Level.INFO, "File {0} not read, because it''s not yet written to disk.", configFile);
-            return;
-        }
-        if (!configFile.getParentFile().exists()) {
-            if (!configFile.getParentFile().mkdirs()) {
-                LOGGER.log(Level.SEVERE, tl("failedToCreateConfig", configFile.toString()));
-            }
-        }
-        // This will delete files where the first character is 0. In most cases they are broken.
-        if (configFile.exists() && configFile.length() != 0) {
-            try {
-                final InputStream input = new FileInputStream(configFile);
-                try {
-                    if (input.read() == 0) {
-                        input.close();
-                        configFile.delete();
-                    }
-                } catch (final IOException ex) {
-                    LOGGER.log(Level.SEVERE, null, ex);
-                } finally {
-                    try {
-                        input.close();
-                    } catch (final IOException ex) {
-                        LOGGER.log(Level.SEVERE, null, ex);
-                    }
-                }
-            } catch (final FileNotFoundException ex) {
-                LOGGER.log(Level.SEVERE, null, ex);
-            }
-        }
-
-        if (!configFile.exists()) {
-            if (legacyFileExists()) {
-                convertLegacyFile();
-            } else if (altFileExists()) {
-                convertAltFile();
-            } else if (templateName != null) {
-                LOGGER.log(Level.INFO, tl("creatingConfigFromTemplate", configFile.toString()));
-                createFromTemplate();
-            } else {
-                return;
-            }
-        }
-
-        try {
-            try (final FileInputStream inputStream = new FileInputStream(configFile)) {
-                final long startSize = configFile.length();
-                if (startSize > Integer.MAX_VALUE) {
-                    throw new InvalidConfigurationException("File too big");
-                }
-                ByteBuffer buffer = ByteBuffer.allocate((int) startSize);
-                int length;
-                while ((length = inputStream.read(bytebuffer)) != -1) {
-                    if (length > buffer.remaining()) {
-                        final ByteBuffer resize = ByteBuffer.allocate(buffer.capacity() + length - buffer.remaining());
-                        final int resizePosition = buffer.position();
-                        // Fix builds compiled against Java 9+ breaking on Java 8
-                        ((Buffer) buffer).rewind();
-                        resize.put(buffer);
-                        resize.position(resizePosition);
-                        buffer = resize;
-                    }
-                    buffer.put(bytebuffer, 0, length);
-                }
-                ((Buffer) buffer).rewind();
-                final CharBuffer data = CharBuffer.allocate(buffer.capacity());
-                CharsetDecoder decoder = UTF8.newDecoder();
-                CoderResult result = decoder.decode(buffer, data, true);
-                if (result.isError()) {
-                    ((Buffer) buffer).rewind();
-                    ((Buffer) data).clear();
-                    LOGGER.log(Level.INFO, "File " + configFile.getAbsolutePath() + " is not utf-8 encoded, trying " + Charset.defaultCharset().displayName());
-                    decoder = Charset.defaultCharset().newDecoder();
-                    result = decoder.decode(buffer, data, true);
-                    if (result.isError()) {
-                        throw new InvalidConfigurationException("Invalid Characters in file " + configFile.getAbsolutePath());
-                    } else {
-                        decoder.flush(data);
-                    }
-                } else {
-                    decoder.flush(data);
-                }
-                final int end = data.position();
-                ((Buffer) data).rewind();
-                super.loadFromString(data.subSequence(0, end).toString());
-            }
-        } catch (final IOException ex) {
-            LOGGER.log(Level.SEVERE, ex.getMessage(), ex);
-        } catch (final InvalidConfigurationException ex) {
-            final File broken = new File(configFile.getAbsolutePath() + ".broken." + System.currentTimeMillis());
-            configFile.renameTo(broken);
-            LOGGER.log(Level.SEVERE, "The file " + configFile.toString() + " is broken, it has been renamed to " + broken.toString(), ex.getCause());
-        }
-    }
-
-    public boolean legacyFileExists() {
-        return false;
-    }
-
-    public void convertLegacyFile() {
-        LOGGER.log(Level.SEVERE, "Unable to import legacy config file.");
-    }
-
-    public boolean altFileExists() {
-        return false;
-    }
-
-    public void convertAltFile() {
-        LOGGER.log(Level.SEVERE, "Unable to import alt config file.");
-    }
-
-    private void createFromTemplate() {
-        InputStream istr = null;
-        OutputStream ostr = null;
-        try {
-            istr = resourceClass.getResourceAsStream(templateName);
-            if (istr == null) {
-                LOGGER.log(Level.SEVERE, tl("couldNotFindTemplate", templateName));
-                return;
-            }
-            ostr = new FileOutputStream(configFile);
-            final byte[] buffer = new byte[1024];
-            int length = 0;
-            length = istr.read(buffer);
-            while (length > 0) {
-                ostr.write(buffer, 0, length);
-                length = istr.read(buffer);
-            }
-        } catch (final IOException ex) {
-            LOGGER.log(Level.SEVERE, tl("failedToWriteConfig", configFile.toString()), ex);
-        } finally {
-            try {
-                if (istr != null) {
-                    istr.close();
-                }
-            } catch (final IOException ex) {
-                Logger.getLogger(EssentialsConf.class.getName()).log(Level.SEVERE, null, ex);
-            }
-            try {
-                if (ostr != null) {
-                    ostr.close();
-                }
-            } catch (final IOException ex) {
-                LOGGER.log(Level.SEVERE, tl("failedToCloseConfig", configFile.toString()), ex);
-            }
-        }
-    }
-
-    public void setTemplateName(final String templateName) {
-        this.templateName = templateName;
-    }
-
-    public File getFile() {
-        return configFile;
-    }
-
-    public void setTemplateName(final String templateName, final Class<?> resClass) {
-        this.templateName = templateName;
-        this.resourceClass = resClass;
-    }
-
-    public void startTransaction() {
-        transaction.set(true);
-    }
-
-    public void stopTransaction() {
-        transaction.set(false);
-        save();
-    }
-
-    public void save() {
-        try {
-            save(configFile);
-        } catch (final IOException ex) {
-            LOGGER.log(Level.SEVERE, ex.getMessage(), ex);
-        }
-    }
-
-    public void saveWithError() throws IOException {
-        save(configFile);
-    }
-
-    @Override
-    public synchronized void save(final File file) throws IOException {
-        if (!transaction.get()) {
-            delayedSave(file);
-        }
-    }
-
-    //This may be aborted if there are stagnant requests sitting in queue.
-    //This needs fixed to discard outstanding save requests.
-    public synchronized void forceSave() {
-        try {
-            final Future<?> future = delayedSave(configFile);
-            if (future != null) {
-                future.get();
-            }
-        } catch (final InterruptedException | ExecutionException ex) {
-            LOGGER.log(Level.SEVERE, ex.getMessage(), ex);
-        }
-    }
-
-    public synchronized void cleanup() {
-        forceSave();
-    }
-
-    private Future<?> delayedSave(final File file) {
-        if (file == null) {
-            throw new IllegalArgumentException("File cannot be null");
-        }
-
-        final String data = saveToString();
-
-        if (data.length() == 0) {
-            return null;
-        }
-
-        pendingDiskWrites.incrementAndGet();
-
-        return EXECUTOR_SERVICE.submit(new WriteRunner(configFile, data, pendingDiskWrites));
-    }
-
-    public boolean hasProperty(final String path) {
-        return isSet(path);
-    }
-
-    public Location getLocation(final String path, final Server server) throws InvalidWorldException {
-        final String worldString = (path == null ? "" : path + ".") + "world";
-        final String worldName = getString(worldString);
-        if (worldName == null || worldName.isEmpty()) {
-            return null;
-        }
-        final World world = server.getWorld(worldName);
-        if (world == null) {
-            throw new InvalidWorldException(worldName);
-        }
-        return new Location(world, getDouble((path == null ? "" : path + ".") + "x", 0), getDouble((path == null ? "" : path + ".") + "y", 0), getDouble((path == null ? "" : path + ".") + "z", 0), (float) getDouble((path == null ? "" : path + ".") + "yaw", 0), (float) getDouble((path == null ? "" : path + ".") + "pitch", 0));
-    }
-
-    public void setProperty(final String path, final Location loc) {
-        set((path == null ? "" : path + ".") + "world", loc.getWorld().getName());
-        set((path == null ? "" : path + ".") + "x", loc.getX());
-        set((path == null ? "" : path + ".") + "y", loc.getY());
-        set((path == null ? "" : path + ".") + "z", loc.getZ());
-        set((path == null ? "" : path + ".") + "yaw", loc.getYaw());
-        set((path == null ? "" : path + ".") + "pitch", loc.getPitch());
-    }
-
-    @Override
-    public ItemStack getItemStack(final String path) {
-        final ItemStack stack = new ItemStack(Material.valueOf(getString(path + ".type", "AIR")), getInt(path + ".amount", 1), (short) getInt(path + ".damage", 0));
-        final ConfigurationSection enchants = getConfigurationSection(path + ".enchant");
-        if (enchants != null) {
-            for (final String enchant : enchants.getKeys(false)) {
-                final Enchantment enchantment = Enchantment.getByName(enchant.toUpperCase(Locale.ENGLISH));
-                if (enchantment == null) {
-                    continue;
-                }
-                final int level = getInt(path + ".enchant." + enchant, enchantment.getStartLevel());
-                stack.addUnsafeEnchantment(enchantment, level);
-            }
-        }
-        return stack;
-        /*
-         * ,
-         * (byte)getInt(path + ".data", 0)
-         */
-    }
-
-    public void setProperty(final String path, final ItemStack stack) {
-        final Map<String, Object> map = new HashMap<>();
-        map.put("type", stack.getType().toString());
-        map.put("amount", stack.getAmount());
-        map.put("damage", stack.getDurability());
-        final Map<Enchantment, Integer> enchantments = stack.getEnchantments();
-        if (!enchantments.isEmpty()) {
-            final Map<String, Integer> enchant = new HashMap<>();
-            for (final Map.Entry<Enchantment, Integer> entry : enchantments.entrySet()) {
-                enchant.put(entry.getKey().getName().toLowerCase(Locale.ENGLISH), entry.getValue());
-            }
-            map.put("enchant", enchant);
-        }
-        // getData().getData() is broken
-        //map.put("data", stack.getDurability());
-        set(path, map);
-    }
-
-    public void setProperty(final String path, final List object) {
-        set(path, new ArrayList(object));
-    }
-
-    public void setProperty(final String path, final Map object) {
-        set(path, new LinkedHashMap(object));
-    }
-
-    public Object getProperty(final String path) {
-        return get(path);
-    }
-
-    public void setProperty(final String path, final BigDecimal bigDecimal) {
-        set(path, bigDecimal.toString());
-    }
-
-    public void setProperty(final String path, final Object object) {
-        set(path, object);
-    }
-
-    public void removeProperty(final String path) {
-        set(path, null);
-    }
-
-    @Override
-    public synchronized Object get(final String path) {
-        return super.get(path);
-    }
-
-    @Override
-    public synchronized Object get(final String path, final Object def) {
-        return super.get(path, def);
-    }
-
-    public synchronized BigDecimal getBigDecimal(final String path, final BigDecimal def) {
-        final String input = super.getString(path);
-        return toBigDecimal(input, def);
-    }
-
-    @Override
-    public synchronized boolean getBoolean(final String path) {
-        return super.getBoolean(path);
-    }
-
-    @Override
-    public synchronized boolean getBoolean(final String path, final boolean def) {
-        return super.getBoolean(path, def);
-    }
-
-    @Override
-    public synchronized List<Boolean> getBooleanList(final String path) {
-        return super.getBooleanList(path);
-    }
-
-    @Override
-    public synchronized List<Byte> getByteList(final String path) {
-        return super.getByteList(path);
-    }
-
-    @Override
-    public synchronized List<Character> getCharacterList(final String path) {
-        return super.getCharacterList(path);
-    }
-
-    @Override
-    public synchronized ConfigurationSection getConfigurationSection(final String path) {
-        return super.getConfigurationSection(path);
-    }
-
-    @Override
-    public synchronized double getDouble(final String path) {
-        return super.getDouble(path);
-    }
-
-    @Override
-    public synchronized double getDouble(final String path, final double def) {
-        return super.getDouble(path, def);
-    }
-
-    @Override
-    public synchronized List<Double> getDoubleList(final String path) {
-        return super.getDoubleList(path);
-    }
-
-    @Override
-    public synchronized List<Float> getFloatList(final String path) {
-        return super.getFloatList(path);
-    }
-
-    @Override
-    public synchronized int getInt(final String path) {
-        return super.getInt(path);
-    }
-
-    @Override
-    public synchronized int getInt(final String path, final int def) {
-        return super.getInt(path, def);
-    }
-
-    @Override
-    public synchronized List<Integer> getIntegerList(final String path) {
-        return super.getIntegerList(path);
-    }
-
-    @Override
-    public synchronized ItemStack getItemStack(final String path, final ItemStack def) {
-        return super.getItemStack(path, def);
-    }
-
-    @Override
-    public synchronized Set<String> getKeys(final boolean deep) {
-        return super.getKeys(deep);
-    }
-
-    @Override
-    public synchronized List<?> getList(final String path) {
-        return super.getList(path);
-    }
-
-    @Override
-    public synchronized List<?> getList(final String path, final List<?> def) {
-        return super.getList(path, def);
-    }
-
-    @Override
-    public synchronized long getLong(final String path) {
-        return super.getLong(path);
-    }
-
-    @Override
-    public synchronized long getLong(final String path, final long def) {
-        return super.getLong(path, def);
-    }
-
-    @Override
-    public synchronized List<Long> getLongList(final String path) {
-        return super.getLongList(path);
-    }
-
-    public synchronized Map<String, Object> getMap() {
-        return map;
-    }
-
-    @Override
-    public synchronized List<Map<?, ?>> getMapList(final String path) {
-        return super.getMapList(path);
-    }
-
-    @Override
-    public synchronized OfflinePlayer getOfflinePlayer(final String path) {
-        return super.getOfflinePlayer(path);
-    }
-
-    @Override
-    public synchronized OfflinePlayer getOfflinePlayer(final String path, final OfflinePlayer def) {
-        return super.getOfflinePlayer(path, def);
-    }
-
-    @Override
-    public synchronized List<Short> getShortList(final String path) {
-        return super.getShortList(path);
-    }
-
-    @Override
-    public synchronized String getString(final String path) {
-        return super.getString(path);
-    }
-
-    @Override
-    public synchronized String getString(final String path, final String def) {
-        return super.getString(path, def);
-    }
-
-    @Override
-    public synchronized List<String> getStringList(final String path) {
-        return super.getStringList(path);
-    }
-
-    @Override
-    public synchronized Map<String, Object> getValues(final boolean deep) {
-        return super.getValues(deep);
-    }
-
-    @Override
-    public synchronized Vector getVector(final String path) {
-        return super.getVector(path);
-    }
-
-    @Override
-    public synchronized Vector getVector(final String path, final Vector def) {
-        return super.getVector(path, def);
-    }
-
-    @Override
-    public synchronized boolean isBoolean(final String path) {
-        return super.isBoolean(path);
-    }
-
-    @Override
-    public synchronized boolean isConfigurationSection(final String path) {
-        return super.isConfigurationSection(path);
-    }
-
-    @Override
-    public synchronized boolean isDouble(final String path) {
-        return super.isDouble(path);
-    }
-
-    @Override
-    public synchronized boolean isInt(final String path) {
-        return super.isInt(path);
-    }
-
-    @Override
-    public synchronized boolean isItemStack(final String path) {
-        return super.isItemStack(path);
-    }
-
-    @Override
-    public synchronized boolean isList(final String path) {
-        return super.isList(path);
-    }
-
-    @Override
-    public synchronized boolean isLong(final String path) {
-        return super.isLong(path);
-    }
-
-    @Override
-    public synchronized boolean isOfflinePlayer(final String path) {
-        return super.isOfflinePlayer(path);
-    }
-
-    @Override
-    public synchronized boolean isSet(final String path) {
-        return super.isSet(path);
-    }
-
-    @Override
-    public synchronized boolean isString(final String path) {
-        return super.isString(path);
-    }
-
-    @Override
-    public synchronized boolean isVector(final String path) {
-        return super.isVector(path);
-    }
-
-    @Override
-    public synchronized void set(final String path, final Object value) {
-        super.set(path, value);
-    }
-
-    private static final class WriteRunner implements Runnable {
-        private final File configFile;
-        private final String data;
-        private final AtomicInteger pendingDiskWrites;
-
-        private WriteRunner(final File configFile, final String data, final AtomicInteger pendingDiskWrites) {
-            this.configFile = configFile;
-            this.data = data;
-            this.pendingDiskWrites = pendingDiskWrites;
-        }
-
-        @Override
-        public void run() {
-            //long startTime = System.nanoTime();
-            synchronized (configFile) {
-                if (pendingDiskWrites.get() > 1) {
-                    // Writes can be skipped, because they are stored in a queue (in the executor).
-                    // Only the last is actually written.
-                    pendingDiskWrites.decrementAndGet();
-                    //LOGGER.log(Level.INFO, configFile + " skipped writing in " + (System.nanoTime() - startTime) + " nsec.");
-                    return;
-                }
-                try {
-                    Files.createParentDirs(configFile);
-
-                    if (!configFile.exists()) {
-                        try {
-                            LOGGER.log(Level.INFO, tl("creatingEmptyConfig", configFile.toString()));
-                            if (!configFile.createNewFile()) {
-                                LOGGER.log(Level.SEVERE, tl("failedToCreateConfig", configFile.toString()));
-                                return;
-                            }
-                        } catch (final IOException ex) {
-                            LOGGER.log(Level.SEVERE, tl("failedToCreateConfig", configFile.toString()), ex);
-                            return;
-                        }
-                    }
-
-                    try (final FileOutputStream fos = new FileOutputStream(configFile)) {
-                        try (final OutputStreamWriter writer = new OutputStreamWriter(fos, UTF8)) {
-                            writer.write(data);
-                        }
-                    }
-                } catch (final IOException e) {
-                    LOGGER.log(Level.SEVERE, e.getMessage(), e);
-                } finally {
-                    //LOGGER.log(Level.INFO, configFile + " written to disk in " + (System.nanoTime() - startTime) + " nsec.");
-                    pendingDiskWrites.decrementAndGet();
-                }
-            }
-        }
-    }
-}

Essentials/src/main/java/com/earth2me/essentials/EssentialsEntityListener.java

@@ -1,5 +1,6 @@
 package com.earth2me.essentials;
 
+import com.earth2me.essentials.craftbukkit.Inventories;
 import com.earth2me.essentials.utils.VersionUtil;
 import net.ess3.api.IEssentials;
 import org.bukkit.Location;
@@ -29,13 +30,9 @@ import org.bukkit.inventory.ItemStack;
 
 import java.util.List;
 import java.util.logging.Level;
-import java.util.logging.Logger;
 import java.util.regex.Pattern;
 
-import static com.earth2me.essentials.I18n.tl;
-
 public class EssentialsEntityListener implements Listener {
-    private static final Logger LOGGER = Logger.getLogger("Essentials");
     private static final transient Pattern powertoolPlayer = Pattern.compile("\\{player\\}");
     private final IEssentials ess;
 
@@ -53,12 +50,12 @@ public class EssentialsEntityListener implements Listener {
             if (eDefend instanceof Player) {
                 onPlayerVsPlayerDamage(event, (Player) eDefend, attacker);
             } else if (eDefend instanceof Ageable) {
-                final ItemStack hand = attacker.getBase().getItemInHand();
+                final ItemStack hand = Inventories.getItemInMainHand(attacker.getBase());
                 if (ess.getSettings().isMilkBucketEasterEggEnabled()
                     && hand != null && hand.getType() == Material.MILK_BUCKET) {
                     ((Ageable) eDefend).setBaby();
                     hand.setType(Material.BUCKET);
-                    attacker.getBase().setItemInHand(hand);
+                    Inventories.setItemInMainHand(attacker.getBase(), hand);
                     attacker.getBase().updateInventory();
                     event.setCancelled(true);
                 }
@@ -99,7 +96,7 @@ public class EssentialsEntityListener implements Listener {
     }
 
     private void onPlayerVsPlayerPowertool(final EntityDamageByEntityEvent event, final Player defender, final User attacker) {
-        final List<String> commandList = attacker.getPowertool(attacker.getBase().getItemInHand());
+        final List<String> commandList = attacker.getPowertool(Inventories.getItemInHand(attacker.getBase()));
         if (commandList != null && !commandList.isEmpty()) {
             for (final String tempCommand : commandList) {
                 final String command = powertoolPlayer.matcher(tempCommand).replaceAll(defender.getName());
@@ -109,7 +106,7 @@ public class EssentialsEntityListener implements Listener {
                         @Override
                         public void run() {
                             attacker.getBase().chat("/" + command);
-                            LOGGER.log(Level.INFO, String.format("[PT] %s issued server command: /%s", attacker.getName(), command));
+                            ess.getLogger().log(Level.INFO, String.format("[PT] %s issued server command: /%s", attacker.getName(), command));
                         }
                     }
 
@@ -159,7 +156,7 @@ public class EssentialsEntityListener implements Listener {
         }
     }
 
-    @EventHandler(priority = EventPriority.LOWEST)
+    @EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
     public void onPlayerDeathEvent(final PlayerDeathEvent event) {
         final Entity entity = event.getEntity();
         if (entity.hasMetadata("NPC")) {
@@ -168,11 +165,11 @@ public class EssentialsEntityListener implements Listener {
         final User user = ess.getUser(event.getEntity());
         if (ess.getSettings().infoAfterDeath()) {
             final Location loc = user.getLocation();
-            user.sendMessage(tl("infoAfterDeath", loc.getWorld().getName(), loc.getBlockX(), loc.getBlockY(), loc.getBlockZ()));
+            user.sendTl("infoAfterDeath", loc.getWorld().getName(), loc.getBlockX(), loc.getBlockY(), loc.getBlockZ());
         }
         if (user.isAuthorized("essentials.back.ondeath") && !ess.getSettings().isCommandDisabled("back")) {
             user.setLastLocation();
-            user.sendMessage(tl("backAfterDeath"));
+            user.sendTl("backAfterDeath");
         }
         if (!ess.getSettings().areDeathMessagesEnabled()) {
             event.setDeathMessage("");
@@ -193,57 +190,35 @@ public class EssentialsEntityListener implements Listener {
         final User user = ess.getUser(event.getEntity());
         if (user.isAuthorized("essentials.keepinv")) {
             event.setKeepInventory(true);
-            event.getDrops().clear();
+            // We don't do getDrops().clear() here because it would remove any loot tables that were added by other plugins/datapacks.
+            // Instead, we remove the items from the drops that are in the player's inventory. This way, the loot tables can still drop items.
+            // This is the same behavior as the vanilla /gamerule keepInventory.
+            final ItemStack[] inventory = Inventories.getInventory(event.getEntity(), true);
+            for (final ItemStack item : inventory) {
+                if (item != null) {
+                    event.getDrops().remove(item);
+                }
+            }
             final ISettings.KeepInvPolicy vanish = ess.getSettings().getVanishingItemsPolicy();
             final ISettings.KeepInvPolicy bind = ess.getSettings().getBindingItemsPolicy();
             if (VersionUtil.getServerBukkitVersion().isHigherThanOrEqualTo(VersionUtil.v1_11_2_R01) && (vanish != ISettings.KeepInvPolicy.KEEP || bind != ISettings.KeepInvPolicy.KEEP)) {
-                for (final ItemStack stack : event.getEntity().getInventory()) {
-                    if (stack != null) {
-                        if (stack.getEnchantments().containsKey(Enchantment.VANISHING_CURSE)) {
-                            if (vanish == ISettings.KeepInvPolicy.DELETE) {
-                                event.getEntity().getInventory().remove(stack);
-                            } else if (vanish == ISettings.KeepInvPolicy.DROP) {
-                                event.getDrops().add(stack);
-                                event.getEntity().getInventory().remove(stack);
-                            }
-                        }
-                        if (stack.getEnchantments().containsKey(Enchantment.BINDING_CURSE)) {
-                            if (bind == ISettings.KeepInvPolicy.DELETE) {
-                                event.getEntity().getInventory().remove(stack);
-                            } else if (bind == ISettings.KeepInvPolicy.DROP) {
-                                event.getEntity().getInventory().remove(stack);
-                                event.getDrops().add(stack);
-                            }
+                Inventories.removeItems(user.getBase(), stack -> {
+                    if (vanish != ISettings.KeepInvPolicy.KEEP && stack.getEnchantments().containsKey(Enchantment.VANISHING_CURSE)) {
+                        if (vanish == ISettings.KeepInvPolicy.DROP) {
+                            event.getDrops().add(stack.clone());
                         }
+                        return true;
                     }
-                }
-                final ItemStack[] armor = event.getEntity().getInventory().getArmorContents();
-                for (int i = 0; i < armor.length; i++) {
-                    final ItemStack stack = armor[i];
-                    if (stack != null) {
-                        if (stack.getEnchantments().containsKey(Enchantment.VANISHING_CURSE)) {
-                            if (vanish == ISettings.KeepInvPolicy.DELETE) {
-                                armor[i] = null;
-                            } else if (vanish == ISettings.KeepInvPolicy.DROP) {
-                                if (!event.getDrops().contains(stack)) {
-                                    event.getDrops().add(stack);
-                                }
-                                armor[i] = null;
-                            }
-                        }
-                        if (stack.getEnchantments().containsKey(Enchantment.BINDING_CURSE)) {
-                            if (bind == ISettings.KeepInvPolicy.DELETE) {
-                                armor[i] = null;
-                            } else if (bind == ISettings.KeepInvPolicy.DROP) {
-                                if (!event.getDrops().contains(stack)) {
-                                    event.getDrops().add(stack);
-                                }
-                                armor[i] = null;
-                            }
+
+                    if (bind != ISettings.KeepInvPolicy.KEEP && stack.getEnchantments().containsKey(Enchantment.BINDING_CURSE)) {
+                        if (bind == ISettings.KeepInvPolicy.DROP) {
+                            event.getDrops().add(stack.clone());
                         }
+                        return true;
                     }
-                }
-                event.getEntity().getInventory().setArmorContents(armor);
+
+                    return false;
+                }, true);
             }
         }
     }

Essentials/src/main/java/com/earth2me/essentials/EssentialsLogger.java

@@ -0,0 +1,74 @@
+package com.earth2me.essentials;
+
+import net.ess3.nms.refl.ReflUtil;
+import net.ess3.provider.LoggerProvider;
+import net.ess3.provider.providers.BaseLoggerProvider;
+import net.ess3.provider.providers.PaperLoggerProvider;
+import org.bukkit.Bukkit;
+import org.bukkit.plugin.Plugin;
+import org.bukkit.plugin.java.JavaPlugin;
+
+import java.lang.invoke.MethodHandle;
+import java.lang.invoke.MethodHandles;
+import java.lang.reflect.Field;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+public final class EssentialsLogger {
+    private final static Map<String, LoggerProvider> loggerProviders = new HashMap<>();
+    private final static MethodHandle loggerFieldHandle;
+
+    static {
+        try {
+            final Field loggerField = ReflUtil.getFieldCached(JavaPlugin.class, "logger");
+            //noinspection ConstantConditions
+            loggerFieldHandle = MethodHandles.lookup().unreflectSetter(loggerField);
+        } catch (Throwable t) {
+            throw new RuntimeException("Failed to get logger field handle", t);
+        }
+    }
+
+    private EssentialsLogger() {
+    }
+
+    public static LoggerProvider getLoggerProvider(final Plugin plugin) {
+        if (loggerProviders.containsKey(plugin.getName())) {
+            return loggerProviders.get(plugin.getName());
+        }
+
+        final Logger parentLogger = Logger.getLogger(plugin.getName());
+        final LoggerProvider provider;
+        if (ReflUtil.getClassCached("io.papermc.paper.adventure.providers.ComponentLoggerProviderImpl") != null) {
+            provider = new PaperLoggerProvider(plugin);
+            provider.setParent(parentLogger);
+        } else {
+            provider = new BaseLoggerProvider(plugin, parentLogger);
+            provider.setParent(parentLogger);
+        }
+        loggerProviders.put(plugin.getName(), provider);
+        return provider;
+    }
+
+    public static void updatePluginLogger(final Plugin plugin) {
+        final LoggerProvider provider = getLoggerProvider(plugin);
+        try {
+            loggerFieldHandle.invoke(plugin, provider);
+        } catch (Throwable e) {
+            provider.log(Level.SEVERE, "Failed to update " + plugin.getName() + " logger", e);
+        }
+    }
+
+    public static LoggerProvider getLoggerProvider(final String pluginName) {
+        if (loggerProviders.containsKey(pluginName)) {
+            return loggerProviders.get(pluginName);
+        }
+
+        final Plugin plugin = Bukkit.getPluginManager().getPlugin(pluginName);
+        if (plugin == null) {
+            throw new IllegalArgumentException("Plugin not found: " + pluginName);
+        }
+        return getLoggerProvider(plugin);
+    }
+}

Essentials/src/main/java/com/earth2me/essentials/EssentialsUpgrade.java

@@ -3,14 +3,16 @@ package com.earth2me.essentials;
 import com.earth2me.essentials.config.ConfigurateUtil;
 import com.earth2me.essentials.config.EssentialsConfiguration;
 import com.earth2me.essentials.config.EssentialsUserConfiguration;
+import com.earth2me.essentials.config.entities.LazyLocation;
 import com.earth2me.essentials.craftbukkit.BanLookup;
+import com.earth2me.essentials.userstorage.ModernUUIDCache;
 import com.earth2me.essentials.utils.StringUtil;
 import com.google.common.base.Charsets;
-import com.google.common.collect.Maps;
 import com.google.common.io.Files;
 import com.google.gson.reflect.TypeToken;
 import net.ess3.api.IEssentials;
 import net.essentialsx.api.v2.services.mail.MailMessage;
+import nu.studer.java.util.OrderedProperties;
 import org.bukkit.BanList;
 import org.bukkit.Bukkit;
 import org.bukkit.Location;
@@ -31,10 +33,10 @@ import java.math.BigDecimal;
 import java.math.BigInteger;
 import java.security.DigestInputStream;
 import java.security.MessageDigest;
-import java.text.DecimalFormat;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.Date;
+import java.util.HashMap;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Locale;
@@ -47,15 +49,12 @@ import java.util.concurrent.ScheduledFuture;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicInteger;
 import java.util.logging.Level;
-import java.util.logging.Logger;
-import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 
-import static com.earth2me.essentials.I18n.tl;
+import static com.earth2me.essentials.I18n.tlLiteral;
 
 public class EssentialsUpgrade {
-    private final static Logger LOGGER = Logger.getLogger("Essentials");
-    private static final FileFilter YML_FILTER = pathname -> pathname.isFile() && pathname.getName().endsWith(".yml");
+    public static final FileFilter YML_FILTER = pathname -> pathname.isFile() && pathname.getName().endsWith(".yml");
     private static final String PATTERN_CONFIG_UUID_REGEX = "(?mi)^uuid:\\s*([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})\\s*$";
     private static final Pattern PATTERN_CONFIG_UUID = Pattern.compile(PATTERN_CONFIG_UUID_REGEX);
     private static final String PATTERN_CONFIG_NAME_REGEX = "(?mi)^lastAccountName:\\s*[\"\']?(\\w+)[\"\']?\\s*$";
@@ -72,7 +71,7 @@ public class EssentialsUpgrade {
         doneFile.load();
     }
 
-    public static void uuidFileConvert(final IEssentials ess, final Boolean ignoreUFCache) {
+    private static void uuidFileConvert(final IEssentials ess, final Boolean ignoreUFCache) {
         ess.getLogger().info("Starting Essentials UUID userdata conversion");
 
         final File userdir = new File(ess.getDataFolder(), "userdata");
@@ -95,7 +94,6 @@ public class EssentialsUpgrade {
             final int showProgress = countFiles % 250;
 
             if (showProgress == 0) {
-                ess.getUserMap().getUUIDMap().forceWriteUUIDMap();
                 ess.getLogger().info("Converted " + countFiles + "/" + userdir.list().length);
             }
 
@@ -105,7 +103,8 @@ public class EssentialsUpgrade {
             final EssentialsUserConfiguration config;
             UUID uuid = null;
             try {
-                uuid = UUID.fromString(name);
+                //noinspection ResultOfMethodCallIgnored
+                UUID.fromString(name);
             } catch (final IllegalArgumentException ex) {
                 final File file = new File(userdir, string);
                 final EssentialsConfiguration conf = new EssentialsConfiguration(file);
@@ -117,6 +116,7 @@ public class EssentialsUpgrade {
 
                 final String uuidString = conf.getString(uuidConf, null);
 
+                //noinspection ConstantConditions
                 for (int i = 0; i < 4; i++) {
                     try {
                         uuid = UUID.fromString(uuidString);
@@ -124,7 +124,7 @@ public class EssentialsUpgrade {
                         break;
                     } catch (final Exception ex2) {
                         if (conf.getBoolean("npc", false)) {
-                            uuid = UUID.nameUUIDFromBytes(("NPC:" + name).getBytes(Charsets.UTF_8));
+                            uuid = UUID.nameUUIDFromBytes(("NPC:" + (ess.getSettings().isSafeUsermap() ? StringUtil.safeString(name) : name)).getBytes(Charsets.UTF_8));
                             break;
                         }
 
@@ -132,30 +132,66 @@ public class EssentialsUpgrade {
                         uuid = player.getUniqueId();
                     }
 
+                    //noinspection ConstantConditions
                     if (uuid != null) {
                         countBukkit++;
                         break;
                     }
                 }
 
+                //noinspection ConstantConditions
                 if (uuid != null) {
                     conf.blockingSave();
                     config = new EssentialsUserConfiguration(name, uuid, new File(userdir, uuid + ".yml"));
                     config.convertLegacyFile();
-                    ess.getUserMap().trackUUID(uuid, name, false);
+                    ess.getUsers().loadUncachedUser(uuid);
                     continue;
                 }
                 countFails++;
             }
         }
-        ess.getUserMap().getUUIDMap().forceWriteUUIDMap();
 
         ess.getLogger().info("Converted " + countFiles + "/" + countFiles + ".  Conversion complete.");
         ess.getLogger().info("Converted via cache: " + countEssCache + " :: Converted via lookup: " + countBukkit + " :: Failed to convert: " + countFails);
         ess.getLogger().info("To rerun the conversion type /essentials uuidconvert");
     }
 
-    public void convertMailList() {
+    private void updateRandomTeleport() {
+        if (doneFile.getBoolean("updateRandomTeleport", false)) {
+            return;
+        }
+
+        final EssentialsConfiguration config = ess.getRandomTeleport().getConfig();
+
+        if (config.getRootNode() != null) {
+            final LazyLocation center = config.getLocation("center");
+            final Location centerLoc = center != null ? center.location() : null;
+            if (center != null && centerLoc != null) {
+                final double minRange = config.getDouble("min-range", Double.MIN_VALUE);
+                final double maxRange = config.getDouble("max-range", Double.MIN_VALUE);
+                for (final World world : ess.getServer().getWorlds()) {
+                    final String propPrefix = "locations." + world.getName() + ".";
+                    config.setProperty(propPrefix + "center", centerLoc);
+
+                    if (minRange != Double.MIN_VALUE) {
+                        config.setProperty(propPrefix + "min-range", minRange);
+                    }
+                    if (maxRange != Double.MIN_VALUE) {
+                        config.setProperty(propPrefix + "max-range", maxRange);
+                    }
+                }
+            }
+            config.removeProperty("center");
+
+            config.blockingSave();
+        }
+
+        doneFile.setProperty("updateRandomTeleport", true);
+        doneFile.save();
+        ess.getLogger().info("Done converting random teleport config.");
+    }
+
+    private void convertMailList() {
         if (doneFile.getBoolean("updateUsersMailList", false)) {
             return;
         }
@@ -186,21 +222,21 @@ public class EssentialsUpgrade {
                     config.blockingSave();
                 }
             } catch (RuntimeException ex) {
-                LOGGER.log(Level.INFO, "File: " + file);
+                ess.getLogger().log(Level.INFO, "File: " + file);
                 throw ex;
             }
         }
         doneFile.setProperty("updateUsersMailList", true);
         doneFile.save();
-        LOGGER.info("Done converting mail list.");
+        ess.getLogger().info("Done converting mail list.");
     }
 
-    public void convertStupidCamelCaseUserdataKeys() {
+    private void convertStupidCamelCaseUserdataKeys() {
         if (doneFile.getBoolean("updateUsersStupidLegacyPathNames", false)) {
             return;
         }
 
-        LOGGER.info("Attempting to migrate legacy userdata keys to Configurate");
+        ess.getLogger().info("Attempting to migrate legacy userdata keys to Configurate");
 
         final File userdataFolder = new File(ess.getDataFolder(), "userdata");
         if (!userdataFolder.exists() || !userdataFolder.isDirectory()) {
@@ -241,13 +277,13 @@ public class EssentialsUpgrade {
                 }
                 config.blockingSave();
             } catch (final RuntimeException ex) {
-                LOGGER.log(Level.INFO, "File: " + file);
+                ess.getLogger().log(Level.INFO, "File: " + file);
                 throw ex;
             }
         }
         doneFile.setProperty("updateUsersStupidLegacyPathNames", true);
         doneFile.save();
-        LOGGER.info("Done converting legacy userdata keys to Configurate.");
+        ess.getLogger().info("Done converting legacy userdata keys to Configurate.");
     }
 
     /**
@@ -275,7 +311,7 @@ public class EssentialsUpgrade {
      * horrible economy code, as any operation which loads all user data into memory will load all these NPC accounts
      * and spam the console with warnings."
      */
-    public void purgeBrokenNpcAccounts() {
+    private void purgeBrokenNpcAccounts() {
         if (doneFile.getBoolean("updatePurgeBrokenNpcAccounts", false)) {
             return;
         }
@@ -290,31 +326,31 @@ public class EssentialsUpgrade {
         }
         final File backupFolder = new File(ess.getDataFolder(), "userdata-npc-backup");
         if (backupFolder.exists()) {
-            LOGGER.info("NPC backup folder already exists; skipping NPC purge.");
-            LOGGER.info("To finish purging broken NPC accounts, rename the \"plugins/Essentials/userdata-npc-backup\" folder and restart your server.");
+            ess.getLogger().info("NPC backup folder already exists; skipping NPC purge.");
+            ess.getLogger().info("To finish purging broken NPC accounts, rename the \"plugins/Essentials/userdata-npc-backup\" folder and restart your server.");
             return;
         } else if (!backupFolder.mkdir()) {
-            LOGGER.info("Skipping NPC purge due to error creating backup folder.");
+            ess.getLogger().info("Skipping NPC purge due to error creating backup folder.");
             return;
         }
 
-        LOGGER.info("#===========================================================================#");
-        LOGGER.info(" EssentialsX will now purge any NPC accounts which were incorrectly created.");
-        LOGGER.info(" Only NPC accounts with the default starting balance will be deleted. If");
-        LOGGER.info(" they turn out to be valid NPC accounts, they will be re-created as needed.");
-        LOGGER.info(" Any files deleted here will be backed up to the ");
-        LOGGER.info(" \"plugins/Essentials/userdata-npc-backup\" folder. If you notice any files");
-        LOGGER.info(" have been purged incorrectly, you should restore it from the backup and");
-        LOGGER.info(" report it to us on GitHub:");
-        LOGGER.info(" https://github.com/EssentialsX/Essentials/issues/new/choose");
-        LOGGER.info("");
-        LOGGER.info(" NOTE: This is a one-time process and will take several minutes if you have");
-        LOGGER.info(" a lot of userdata files! If you interrupt this process, EssentialsX will");
-        LOGGER.info(" skip the process until you rename or remove the backup folder.");
-        LOGGER.info("#===========================================================================#");
+        ess.getLogger().info("#===========================================================================#");
+        ess.getLogger().info(" EssentialsX will now purge any NPC accounts which were incorrectly created.");
+        ess.getLogger().info(" Only NPC accounts with the default starting balance will be deleted. If");
+        ess.getLogger().info(" they turn out to be valid NPC accounts, they will be re-created as needed.");
+        ess.getLogger().info(" Any files deleted here will be backed up to the ");
+        ess.getLogger().info(" \"plugins/Essentials/userdata-npc-backup\" folder. If you notice any files");
+        ess.getLogger().info(" have been purged incorrectly, you should restore it from the backup and");
+        ess.getLogger().info(" report it to us on GitHub:");
+        ess.getLogger().info(" https://github.com/EssentialsX/Essentials/issues/new/choose");
+        ess.getLogger().info("");
+        ess.getLogger().info(" NOTE: This is a one-time process and will take several minutes if you have");
+        ess.getLogger().info(" a lot of userdata files! If you interrupt this process, EssentialsX will");
+        ess.getLogger().info(" skip the process until you rename or remove the backup folder.");
+        ess.getLogger().info("#===========================================================================#");
 
         final int totalUserFiles = userFiles.length;
-        LOGGER.info("Found ~" + totalUserFiles + " files under \"plugins/Essentials/userdata\"...");
+        ess.getLogger().info("Found ~" + totalUserFiles + " files under \"plugins/Essentials/userdata\"...");
 
         final AtomicInteger movedAccounts = new AtomicInteger(0);
         final AtomicInteger totalAccounts = new AtomicInteger(0);
@@ -324,7 +360,7 @@ public class EssentialsUpgrade {
 
         final ScheduledExecutorService executor = Executors.newSingleThreadScheduledExecutor();
         final ScheduledFuture<?> feedbackTask = executor.scheduleWithFixedDelay(
-                () -> LOGGER.info("Scanned " + totalAccounts.get() + "/" + totalUserFiles + " accounts; moved " + movedAccounts.get() + " accounts"),
+                () -> ess.getLogger().info("Scanned " + totalAccounts.get() + "/" + totalUserFiles + " accounts; moved " + movedAccounts.get() + " accounts"),
                 5, feedbackInterval, TimeUnit.SECONDS);
 
         for (final File file : userFiles) {
@@ -358,10 +394,10 @@ public class EssentialsUpgrade {
                     Files.move(file, new File(backupFolder, file.getName()));
                     movedAccounts.incrementAndGet();
                 } catch (IOException e) {
-                    LOGGER.log(Level.SEVERE, "Error while moving NPC file", e);
+                    ess.getLogger().log(Level.SEVERE, "Error while moving NPC file", e);
                 }
             } catch (final RuntimeException ex) {
-                LOGGER.log(Level.INFO, "File: " + file);
+                ess.getLogger().log(Level.INFO, "File: " + file);
                 feedbackTask.cancel(false);
                 executor.shutdown();
                 throw ex;
@@ -372,27 +408,27 @@ public class EssentialsUpgrade {
         doneFile.setProperty("updatePurgeBrokenNpcAccounts", true);
         doneFile.save();
 
-        LOGGER.info("#===========================================================================#");
-        LOGGER.info(" EssentialsX has finished purging NPC accounts.");
-        LOGGER.info("");
-        LOGGER.info(" Deleted accounts: " + movedAccounts);
-        LOGGER.info(" Total accounts processed: " + totalAccounts);
-        LOGGER.info("");
-        LOGGER.info(" Purged accounts have been backed up to");
-        LOGGER.info(" \"plugins/Essentials/userdata-npc-backup\", and can be restored from there");
-        LOGGER.info(" if needed. Please report any files which have been incorrectly deleted");
-        LOGGER.info(" to us on GitHub:");
-        LOGGER.info(" https://github.com/EssentialsX/Essentials/issues/new/choose");
-        LOGGER.info("#===========================================================================#");
+        ess.getLogger().info("#===========================================================================#");
+        ess.getLogger().info(" EssentialsX has finished purging NPC accounts.");
+        ess.getLogger().info("");
+        ess.getLogger().info(" Deleted accounts: " + movedAccounts);
+        ess.getLogger().info(" Total accounts processed: " + totalAccounts);
+        ess.getLogger().info("");
+        ess.getLogger().info(" Purged accounts have been backed up to");
+        ess.getLogger().info(" \"plugins/Essentials/userdata-npc-backup\", and can be restored from there");
+        ess.getLogger().info(" if needed. Please report any files which have been incorrectly deleted");
+        ess.getLogger().info(" to us on GitHub:");
+        ess.getLogger().info(" https://github.com/EssentialsX/Essentials/issues/new/choose");
+        ess.getLogger().info("#===========================================================================#");
     }
 
-    public void convertIgnoreList() {
+    private void convertIgnoreList() {
         final Pattern pattern = Pattern.compile("^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$");
         if (doneFile.getBoolean("updateUsersIgnoreListUUID", false)) {
             return;
         }
 
-        LOGGER.info("Attempting to migrate ignore list to UUIDs");
+        ess.getLogger().info("Attempting to migrate ignore list to UUIDs");
 
         final File userdataFolder = new File(ess.getDataFolder(), "userdata");
         if (!userdataFolder.exists() || !userdataFolder.isDirectory()) {
@@ -414,7 +450,7 @@ public class EssentialsUpgrade {
                             continue;
                         }
                         if (pattern.matcher(name.trim()).matches()) {
-                            LOGGER.info("Detected already migrated ignore list!");
+                            ess.getLogger().info("Detected already migrated ignore list!");
                             return;
                         }
                         final User user = ess.getOfflineUser(name);
@@ -427,41 +463,45 @@ public class EssentialsUpgrade {
                     config.blockingSave();
                 }
             } catch (final RuntimeException ex) {
-                LOGGER.log(Level.INFO, "File: " + file);
+                ess.getLogger().log(Level.INFO, "File: " + file);
                 throw ex;
             }
         }
         doneFile.setProperty("updateUsersIgnoreListUUID", true);
         doneFile.save();
-        LOGGER.info("Done converting ignore list.");
+        ess.getLogger().info("Done converting ignore list.");
     }
 
     public void convertKits() {
+        if (Essentials.TESTING) {
+            return;
+        }
+
         final Kits kits = ess.getKits();
         final EssentialsConfiguration config = kits.getRootConfig();
         if (doneFile.getBoolean("kitsyml", false)) {
             return;
         }
 
-        LOGGER.info("Attempting to convert old kits in config.yml to new kits.yml");
+        ess.getLogger().info("Attempting to convert old kits in config.yml to new kits.yml");
 
         final CommentedConfigurationNode section = ess.getSettings().getKitSection();
         if (section == null) {
-            LOGGER.info("No kits found to migrate.");
+            ess.getLogger().info("No kits found to migrate.");
             return;
         }
 
         final Map<String, Object> legacyKits = ConfigurateUtil.getRawMap(section);
 
         for (final Map.Entry<String, Object> entry : legacyKits.entrySet()) {
-            LOGGER.info("Converting " + entry.getKey());
+            ess.getLogger().info("Converting " + entry.getKey());
             config.setRaw("kits." + entry.getKey(), entry.getValue());
         }
 
         config.save();
         doneFile.setProperty("kitsyml", true);
         doneFile.save();
-        LOGGER.info("Done converting kits.");
+        ess.getLogger().info("Done converting kits.");
     }
 
     private void moveMotdRulesToFile(final String name) {
@@ -494,7 +534,7 @@ public class EssentialsUpgrade {
             doneFile.setProperty("move" + name + "ToFile", true);
             doneFile.save();
         } catch (final IOException e) {
-            LOGGER.log(Level.SEVERE, tl("upgradingFilesError"), e);
+            ess.getLogger().log(Level.SEVERE, ess.getAdventureFacet().miniToLegacy(tlLiteral("upgradingFilesError")), e);
         }
     }
 
@@ -529,10 +569,10 @@ public class EssentialsUpgrade {
         bWriter.close();
         if (needUpdate) {
             if (!file.renameTo(new File(file.getParentFile(), file.getName().concat("." + System.currentTimeMillis() + ".upgradebackup")))) {
-                throw new Exception(tl("configFileMoveError"));
+                throw new Exception(tlLiteral("configFileMoveError"));
             }
             if (!tempFile.renameTo(file)) {
-                throw new Exception(tl("configFileRenameError"));
+                throw new Exception(tlLiteral("configFileRenameError"));
             }
         } else {
             tempFile.delete();
@@ -572,7 +612,7 @@ public class EssentialsUpgrade {
                     config.blockingSave();
                 }
             } catch (final RuntimeException ex) {
-                LOGGER.log(Level.INFO, "File: " + file);
+                ess.getLogger().log(Level.INFO, "File: " + file);
                 throw ex;
             }
         }
@@ -628,7 +668,7 @@ public class EssentialsUpgrade {
                 }
 
             } catch (final RuntimeException ex) {
-                LOGGER.log(Level.INFO, "File: " + file);
+                ess.getLogger().log(Level.INFO, "File: " + file);
                 throw ex;
             }
         }
@@ -657,15 +697,15 @@ public class EssentialsUpgrade {
             final File tmpFile = new File(listOfFile.getParentFile(), sanitizedFilename + ".tmp");
             final File newFile = new File(listOfFile.getParentFile(), sanitizedFilename);
             if (!listOfFile.renameTo(tmpFile)) {
-                LOGGER.log(Level.WARNING, tl("userdataMoveError", filename, sanitizedFilename));
+                ess.getLogger().log(Level.WARNING, ess.getAdventureFacet().miniToLegacy(tlLiteral("userdataMoveError", filename, sanitizedFilename)));
                 continue;
             }
             if (newFile.exists()) {
-                LOGGER.log(Level.WARNING, tl("duplicatedUserdata", filename, sanitizedFilename));
+                ess.getLogger().log(Level.WARNING, ess.getAdventureFacet().miniToLegacy(tlLiteral("duplicatedUserdata", filename, sanitizedFilename)));
                 continue;
             }
             if (!tmpFile.renameTo(newFile)) {
-                LOGGER.log(Level.WARNING, tl("userdataMoveBackError", sanitizedFilename, sanitizedFilename));
+                ess.getLogger().log(Level.WARNING, ess.getAdventureFacet().miniToLegacy(tlLiteral("userdataMoveBackError", sanitizedFilename, sanitizedFilename)));
             }
         }
         doneFile.setProperty("sanitizeAllUserFilenames", true);
@@ -681,7 +721,7 @@ public class EssentialsUpgrade {
         return null;
     }
 
-    public Location getFakeLocation(final CommentedConfigurationNode config, final String path) {
+    private Location getFakeLocation(final CommentedConfigurationNode config, final String path) {
         final String worldName = config.getString((path != null ? path + "." : "") + "world");
         if (worldName == null || worldName.isEmpty()) {
             return null;
@@ -722,7 +762,7 @@ public class EssentialsUpgrade {
                 doneFile.setProperty("deleteOldItemsCsv", true);
                 doneFile.save();
             } catch (final IOException ex) {
-                Bukkit.getLogger().log(Level.SEVERE, ex.getMessage(), ex);
+                ess.getLogger().log(Level.SEVERE, ex.getMessage(), ex);
             }
         }
     }
@@ -743,12 +783,12 @@ public class EssentialsUpgrade {
                         config.setProperty(entry.getKey(), loc);
                     }
                     if (!configFile.renameTo(new File(ess.getDataFolder(), "spawn.yml.old"))) {
-                        throw new Exception(tl("fileRenameError", "spawn.yml"));
+                        throw new Exception(tlLiteral("fileRenameError", "spawn.yml"));
                     }
                     config.blockingSave();
                 }
             } catch (final Exception ex) {
-                Bukkit.getLogger().log(Level.SEVERE, ex.getMessage(), ex);
+                ess.getLogger().log(Level.SEVERE, ex.getMessage(), ex);
             }
         }
         doneFile.setProperty("updateSpawnsToNewSpawnsConfig", true);
@@ -771,12 +811,12 @@ public class EssentialsUpgrade {
                         config.setProperty(entry.getKey(), loc);
                     }
                     if (!configFile.renameTo(new File(ess.getDataFolder(), "jail.yml.old"))) {
-                        throw new Exception(tl("fileRenameError", "jail.yml"));
+                        throw new Exception(tlLiteral("fileRenameError", "jail.yml"));
                     }
                     config.blockingSave();
                 }
             } catch (final Exception ex) {
-                Bukkit.getLogger().log(Level.SEVERE, ex.getMessage(), ex);
+                ess.getLogger().log(Level.SEVERE, ex.getMessage(), ex);
             }
         }
         doneFile.setProperty("updateJailsToNewJailsConfig", true);
@@ -845,7 +885,7 @@ public class EssentialsUpgrade {
         doneFile.save();
     }
 
-    public void banFormatChange() {
+    private void banFormatChange() {
         if (doneFile.getBoolean("banFormatChange", false)) {
             return;
         }
@@ -915,77 +955,137 @@ public class EssentialsUpgrade {
         Bukkit.getBanList(BanList.Type.NAME).addBan(playerName, banReason, banTimeout == 0 ? null : new Date(banTimeout), Console.NAME);
     }
 
-    private void repairUserMap() {
-        if (doneFile.getBoolean("userMapRepaired", false)) {
+    private void generateUidCache() {
+        if (doneFile.getBoolean("newUidCacheBuilt", false)) {
             return;
         }
-        ess.getLogger().info("Starting usermap repair");
 
+        final File usermapFile = new File(ess.getDataFolder(), "usermap.bin");
+        final File uidsFile = new File(ess.getDataFolder(), "uuids.bin");
         final File userdataFolder = new File(ess.getDataFolder(), "userdata");
-        if (!userdataFolder.isDirectory()) {
+
+        if (!userdataFolder.isDirectory() || usermapFile.exists() || uidsFile.exists()) {
             ess.getLogger().warning("Missing userdata folder, aborting");
+            doneFile.setProperty("newUidCacheBuilt", true);
+            doneFile.save();
             return;
         }
-        final File[] files = userdataFolder.listFiles(YML_FILTER);
 
-        final DecimalFormat format = new DecimalFormat("#0.00");
-        final Map<String, UUID> names = Maps.newHashMap();
-
-        for (int index = 0; index < files.length; index++) {
-            final File file = files[index];
-            try {
-                UUID uuid = null;
-                final String filename = file.getName();
-                final String configData = new String(java.nio.file.Files.readAllBytes(file.toPath()), Charsets.UTF_8);
-
-                if (filename.length() > 36) {
-                    try {
-                        // ".yml" ending has 4 chars...
-                        uuid = UUID.fromString(filename.substring(0, filename.length() - 4));
-                    } catch (final IllegalArgumentException ignored) {
-                    }
-                }
-
-                final Matcher uuidMatcher = PATTERN_CONFIG_UUID.matcher(configData);
-                if (uuidMatcher.find()) {
-                    try {
-                        uuid = UUID.fromString(uuidMatcher.group(1));
-                    } catch (final IllegalArgumentException ignored) {
-                    }
-                }
-
-                if (uuid == null) {
-                    // Don't import
-                    continue;
-                }
-
-                final Matcher nameMatcher = PATTERN_CONFIG_NAME.matcher(configData);
-                if (nameMatcher.find()) {
-                    final String username = nameMatcher.group(1);
-                    if (username != null && username.length() > 0) {
-                        names.put(StringUtil.safeString(username), uuid);
-                    }
-                }
-
-                if (index % 1000 == 0) {
-                    ess.getLogger().info("Reading: " + format.format((100d * (double) index) / files.length)
-                        + "%");
-                }
-            } catch (final IOException e) {
-                ess.getLogger().log(Level.SEVERE, "Error while reading file: ", e);
+        try {
+            if (!usermapFile.createNewFile() || !uidsFile.createNewFile()) {
+                ess.getLogger().warning("Couldn't create usermap.bin or uuids.bin, aborting");
                 return;
             }
+
+            final Map<UUID, Long> uuids = new HashMap<>();
+            final Map<String, UUID> nameToUuidMap = new HashMap<>();
+
+            final File[] files = userdataFolder.listFiles(YML_FILTER);
+            if (files != null) {
+                for (final File file : files) {
+                    try {
+                        final String fileName = file.getName();
+                        final UUID uuid = UUID.fromString(fileName.substring(0, fileName.length() - 4));
+                        final EssentialsConfiguration config = new EssentialsConfiguration(file);
+                        config.load();
+                        String name = config.getString("last-account-name", null);
+                        name = ess.getSettings().isSafeUsermap() ? StringUtil.safeString(name) : name;
+                        final long time = config.getLong("timestamps.logout", 0L);
+
+                        if (name != null) {
+                            if (nameToUuidMap.containsKey(name)) {
+                                final UUID oldUuid = nameToUuidMap.get(name);
+                                if (oldUuid.version() < uuid.version() || oldUuid.version() == uuid.version() && uuids.get(oldUuid) < time) {
+                                    ess.getLogger().warning("New UUID found for " + name + ": " + uuid + " (old: " + oldUuid + "). Replacing.");
+                                    uuids.remove(oldUuid);
+                                } else {
+                                    ess.getLogger().warning("Found UUID for " + name + ": " + uuid + " (old: " + oldUuid + "). Skipping.");
+                                    continue;
+                                }
+                            }
+
+                            uuids.put(uuid, time);
+                            nameToUuidMap.put(name, uuid);
+                        }
+                    } catch (IllegalArgumentException | IndexOutOfBoundsException ignored) {
+                    }
+                }
+            }
+
+            if (!nameToUuidMap.isEmpty()) {
+                ModernUUIDCache.writeNameUuidMap(usermapFile, nameToUuidMap);
+            }
+
+            if (!uuids.isEmpty()) {
+                ModernUUIDCache.writeUuidCache(uidsFile, uuids.keySet());
+            }
+
+            doneFile.setProperty("newUidCacheBuilt", true);
+            doneFile.save();
+        } catch (final IOException e) {
+            ess.getLogger().log(Level.SEVERE, "Error while generating initial uuids/names cache", e);
+        }
+    }
+
+    public void upgradeLang() {
+        if (doneFile.getBoolean("updateLegacyToAdventure", false)) {
+            return;
         }
 
-        ess.getUserMap().getNames().putAll(names);
-        ess.getUserMap().reloadConfig();
+        ess.getLogger().log(Level.WARNING, "Beginning Adventure locale file conversion.");
 
-        doneFile.setProperty("userMapRepaired", true);
-        doneFile.save();
-        ess.getLogger().info("Completed usermap repair.");
+        try {
+            final File dataFolder = ess.getDataFolder();
+            if (!dataFolder.exists() || !dataFolder.isDirectory()) {
+                return;
+            }
+
+            final File backDir = new File(dataFolder, "msg-backups-" + System.currentTimeMillis());
+            if (backDir.exists() || !backDir.mkdir()) {
+                ess.getLogger().log(Level.SEVERE, "Unable to make msg-backups dir?!");
+                return;
+            }
+
+            final File messagesDir = new File(dataFolder, "messages");
+            //noinspection ResultOfMethodCallIgnored
+            messagesDir.mkdir();
+
+            final File[] files = dataFolder.listFiles();
+            boolean isThereAtLeastOneBackup = false;
+            if (files != null) {
+                for (final File file : files) {
+                    if (file.getName().endsWith(".properties")) {
+                        final File newFile = new File(messagesDir, file.getName());
+                        final File backup = new File(backDir, file.getName());
+                        Files.move(file, backup);
+                        isThereAtLeastOneBackup = true;
+                        final OrderedProperties properties = new OrderedProperties();
+                        properties.load(Files.newReader(backup, Charsets.UTF_8));
+                        for (final String key : properties.stringPropertyNames()) {
+                            final String value = properties.getProperty(key);
+                            properties.setProperty(key, ess.getAdventureFacet().legacyToMini(ess.getAdventureFacet().escapeTags(value), true));
+                        }
+                        properties.store(Files.newWriter(newFile, Charsets.UTF_8), null);
+                    }
+                }
+            }
+
+            if (!isThereAtLeastOneBackup) {
+                backDir.delete();
+            }
+
+            doneFile.setProperty("updateLegacyToAdventure", true);
+            doneFile.save();
+        } catch (final Throwable e) {
+            ess.getLogger().log(Level.SEVERE, "Error while upgrading custom locales", e);
+        }
     }
 
     public void beforeSettings() {
+        if (Essentials.TESTING) {
+            return;
+        }
+
         if (!ess.getDataFolder().exists()) {
             ess.getDataFolder().mkdirs();
         }
@@ -993,7 +1093,18 @@ public class EssentialsUpgrade {
         moveMotdRulesToFile("rules");
     }
 
+    public void preModules() {
+        if (Essentials.TESTING) {
+            return;
+        }
+        generateUidCache();
+    }
+
     public void afterSettings() {
+        if (Essentials.TESTING) {
+            return;
+        }
+
         sanitizeAllUserFilenames();
         updateUsersPowerToolsFormat();
         updateUsersHomesFormat();
@@ -1003,10 +1114,10 @@ public class EssentialsUpgrade {
         uuidFileChange();
         banFormatChange();
         warnMetrics();
-        repairUserMap();
         convertIgnoreList();
         convertStupidCamelCaseUserdataKeys();
         convertMailList();
         purgeBrokenNpcAccounts();
+        updateRandomTeleport();
     }
 }

Essentials/src/main/java/com/earth2me/essentials/EssentialsUserConf.java

@@ -1,66 +0,0 @@
-package com.earth2me.essentials;
-
-import com.google.common.base.Charsets;
-import com.google.common.io.Files;
-import org.bukkit.Bukkit;
-
-import java.io.File;
-import java.io.IOException;
-import java.util.Locale;
-import java.util.UUID;
-import java.util.logging.Level;
-
-public class EssentialsUserConf extends EssentialsConf {
-    public String username;
-    public final UUID uuid;
-
-    public EssentialsUserConf(final String username, final UUID uuid, final File configFile) {
-        super(configFile);
-        this.username = username;
-        this.uuid = uuid;
-    }
-
-    public void setUsername(String username) {
-        this.username = username;
-    }
-
-    @Override
-    public boolean legacyFileExists() {
-        final File file = new File(configFile.getParentFile(), username + ".yml");
-        return file.exists();
-    }
-
-    @Override
-    public void convertLegacyFile() {
-        final File file = new File(configFile.getParentFile(), username + ".yml");
-        try {
-            Files.move(file, new File(configFile.getParentFile(), uuid + ".yml"));
-        } catch (final IOException ex) {
-            Bukkit.getLogger().log(Level.WARNING, "Failed to migrate user: " + username, ex);
-        }
-
-        setProperty("lastAccountName", username);
-    }
-
-    private File getAltFile() {
-        final UUID fn = UUID.nameUUIDFromBytes(("OfflinePlayer:" + username.toLowerCase(Locale.ENGLISH)).getBytes(Charsets.UTF_8));
-        return new File(configFile.getParentFile(), fn.toString() + ".yml");
-    }
-
-    @Override
-    public boolean altFileExists() {
-        if (username.equals(username.toLowerCase())) {
-            return false;
-        }
-        return getAltFile().exists();
-    }
-
-    @Override
-    public void convertAltFile() {
-        try {
-            Files.move(getAltFile(), new File(configFile.getParentFile(), uuid + ".yml"));
-        } catch (final IOException ex) {
-            Bukkit.getLogger().log(Level.WARNING, "Failed to migrate user: " + username, ex);
-        }
-    }
-}

Essentials/src/main/java/com/earth2me/essentials/I18n.java

@@ -1,6 +1,8 @@
 package com.earth2me.essentials;
 
+import com.earth2me.essentials.adventure.AdventureUtil;
 import net.ess3.api.IEssentials;
+import org.jetbrains.annotations.NotNull;
 
 import java.io.File;
 import java.io.FileInputStream;
@@ -13,26 +15,35 @@ import java.net.URL;
 import java.net.URLConnection;
 import java.nio.charset.StandardCharsets;
 import java.text.MessageFormat;
+import java.util.ArrayList;
+import java.util.Date;
 import java.util.Enumeration;
 import java.util.HashMap;
+import java.util.List;
 import java.util.Locale;
 import java.util.Map;
 import java.util.MissingResourceException;
 import java.util.PropertyResourceBundle;
 import java.util.ResourceBundle;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.TimeUnit;
+import java.util.function.Function;
 import java.util.logging.Level;
-import java.util.logging.Logger;
 import java.util.regex.Pattern;
 
 public class I18n implements net.ess3.api.II18n {
     private static final String MESSAGES = "messages";
     private static final Pattern NODOUBLEMARK = Pattern.compile("''");
+    private static volatile ExecutorService BUNDLE_LOADER_EXECUTOR = Executors.newFixedThreadPool(2);
     private static final ResourceBundle NULL_BUNDLE = new ResourceBundle() {
+        @SuppressWarnings("NullableProblems")
         public Enumeration<String> getKeys() {
             return null;
         }
 
-        protected Object handleGetObject(final String key) {
+        protected Object handleGetObject(final @NotNull String key) {
             return null;
         }
     };
@@ -41,30 +52,53 @@ public class I18n implements net.ess3.api.II18n {
     private final transient ResourceBundle defaultBundle;
     private final transient IEssentials ess;
     private transient Locale currentLocale = defaultLocale;
-    private transient ResourceBundle customBundle;
+    private final transient Map<Locale, ResourceBundle> loadedBundles = new ConcurrentHashMap<>();
+    private final transient List<Locale> loadingBundles = new ArrayList<>();
     private transient ResourceBundle localeBundle;
-    private transient Map<String, MessageFormat> messageFormatCache = new HashMap<>();
+    private final transient Map<Locale, Map<String, MessageFormat>> messageFormatCache = new HashMap<>();
 
     public I18n(final IEssentials ess) {
         this.ess = ess;
         defaultBundle = ResourceBundle.getBundle(MESSAGES, Locale.ENGLISH, new UTF8PropertiesControl());
         localeBundle = defaultBundle;
-        customBundle = NULL_BUNDLE;
     }
 
-    public static String tl(final String string, final Object... objects) {
+    /**
+     * Translates a message using the server's configured locale.
+     * @param tlKey The translation key.
+     * @param objects Translation parameters, if applicable. Note: by default, these will not be parsed for MiniMessage.
+     * @return The translated message.
+     * @see AdventureUtil#parsed(String)
+     */
+    public static String tlLiteral(final String tlKey, final Object... objects) {
+        if (instance == null) {
+            return "";
+        }
+
+        return tlLocale(instance.currentLocale, tlKey, objects);
+    }
+
+    /**
+     * Translates a message using the provided locale.
+     * @param locale The locale to translate the key to.
+     * @param tlKey The translation key.
+     * @param objects Translation parameters, if applicable. Note: by default, these will not be parsed for MiniMessage.
+     * @return The translated message.
+     * @see AdventureUtil#parsed(String)
+     */
+    public static String tlLocale(final Locale locale, final String tlKey, final Object... objects) {
         if (instance == null) {
             return "";
         }
         if (objects.length == 0) {
-            return NODOUBLEMARK.matcher(instance.translate(string)).replaceAll("'");
+            return NODOUBLEMARK.matcher(instance.translate(locale, tlKey)).replaceAll("'");
         } else {
-            return instance.format(string, objects);
+            return instance.format(locale, tlKey, objects);
         }
     }
 
     public static String capitalCase(final String input) {
-        return input == null || input.length() == 0 ? input : input.toUpperCase(Locale.ENGLISH).charAt(0) + input.toLowerCase(Locale.ENGLISH).substring(1);
+        return input == null || input.isEmpty() ? input : input.toUpperCase(Locale.ENGLISH).charAt(0) + input.toLowerCase(Locale.ENGLISH).substring(1);
     }
 
     public void onEnable() {
@@ -73,6 +107,29 @@ public class I18n implements net.ess3.api.II18n {
 
     public void onDisable() {
         instance = null;
+        shutdownExecutor();
+    }
+
+    private static synchronized ExecutorService getExecutor() {
+        if (BUNDLE_LOADER_EXECUTOR == null || BUNDLE_LOADER_EXECUTOR.isShutdown() || BUNDLE_LOADER_EXECUTOR.isTerminated()) {
+            BUNDLE_LOADER_EXECUTOR = Executors.newFixedThreadPool(2);
+        }
+        return BUNDLE_LOADER_EXECUTOR;
+    }
+
+    private static synchronized void shutdownExecutor() {
+        final ExecutorService exec = BUNDLE_LOADER_EXECUTOR;
+        if (exec == null) {
+            return;
+        }
+        exec.shutdown();
+        try {
+            if (!exec.awaitTermination(5, TimeUnit.SECONDS)) {
+                exec.shutdownNow();
+            }
+        } catch (final InterruptedException ignored) {
+            exec.shutdownNow();
+        }
     }
 
     @Override
@@ -80,81 +137,150 @@ public class I18n implements net.ess3.api.II18n {
         return currentLocale;
     }
 
-    private String translate(final String string) {
+    /**
+     * Returns the {@link ResourceBundle} for the given {@link Locale}, if loaded. If a bundle is requested which is
+     * not loaded, it will be loaded asynchronously and the default bundle will be returned in the meantime.
+     */
+    private ResourceBundle getBundle(final Locale locale) {
+        if (loadedBundles.containsKey(locale)) {
+            return loadedBundles.get(locale);
+        } else {
+            synchronized (loadingBundles) {
+                if (!loadingBundles.contains(locale)) {
+                    loadingBundles.add(locale);
+                    getExecutor().submit(() -> {
+                        blockingLoadBundle(locale);
+                        synchronized (loadingBundles) {
+                            loadingBundles.remove(locale);
+                        }
+                    });
+                }
+            }
+            return defaultBundle;
+        }
+    }
+
+    public void blockingLoadBundle(final Locale locale) {
+        if (!loadedBundles.containsKey(locale)) {
+            ResourceBundle bundle;
+            try {
+                bundle = ResourceBundle.getBundle(MESSAGES, locale, new FileResClassLoader(I18n.class.getClassLoader(), ess), new UTF8PropertiesControl());
+            } catch (MissingResourceException ex) {
+                try {
+                    bundle = ResourceBundle.getBundle(MESSAGES, locale, new UTF8PropertiesControl());
+                } catch (MissingResourceException ex2) {
+                    bundle = NULL_BUNDLE;
+                }
+            }
+
+            loadedBundles.put(locale, bundle);
+        }
+    }
+
+    private String translate(final Locale locale, final String string) {
         try {
             try {
-                return customBundle.getString(string);
+                return getBundle(locale).getString(string);
             } catch (final MissingResourceException ex) {
                 return localeBundle.getString(string);
             }
         } catch (final MissingResourceException ex) {
-            if (ess == null || ess.getSettings().isDebug()) {
-                Logger.getLogger("Essentials").log(Level.WARNING, String.format("Missing translation key \"%s\" in translation file %s", ex.getKey(), localeBundle.getLocale().toString()), ex);
+            if (ess != null && ess.getSettings().isDebug()) {
+                ess.getLogger().log(Level.WARNING, String.format("Missing translation key \"%s\" in translation file %s", ex.getKey(), localeBundle.getLocale().toString()), ex);
             }
             return defaultBundle.getString(string);
         }
     }
 
-    public String format(final String string, final Object... objects) {
-        String format = translate(string);
-        MessageFormat messageFormat = messageFormatCache.get(format);
+    private String format(final Locale locale, final String string, final Object... objects) {
+        String format = translate(locale, string);
+
+        MessageFormat messageFormat = messageFormatCache.computeIfAbsent(locale, l -> new HashMap<>()).get(format);
         if (messageFormat == null) {
             try {
                 messageFormat = new MessageFormat(format);
             } catch (final IllegalArgumentException e) {
                 ess.getLogger().log(Level.SEVERE, "Invalid Translation key for '" + string + "': " + e.getMessage());
-                format = format.replaceAll("\\{(\\D*?)\\}", "\\[$1\\]");
+                format = format.replaceAll("\\{(\\D*?)}", "\\[$1\\]");
                 messageFormat = new MessageFormat(format);
             }
-            messageFormatCache.put(format, messageFormat);
+            messageFormatCache.get(locale).put(format, messageFormat);
         }
-        return messageFormat.format(objects).replace(' ', ' '); // replace nbsp with a space
+
+        final Object[] processedArgs = mutateArgs(objects, arg -> {
+            if (arg instanceof AdventureUtil.ParsedPlaceholder) {
+                return arg.toString();
+            }
+            return ess.getAdventureFacet().legacyToMini(ess.getAdventureFacet().escapeTags(arg.toString()));
+        });
+
+        return messageFormat.format(processedArgs).replace(' ', ' '); // replace nbsp with a space
+    }
+
+    public static Object[] mutateArgs(final Object[] objects, final Function<Object, String> mutator) {
+        final Object[] args = new Object[objects.length];
+        for (int i = 0; i < objects.length; i++) {
+            final Object object = objects[i];
+            // MessageFormat will format these itself, troll face.
+            if (object instanceof Number || object instanceof Date || object == null) {
+                args[i] = object;
+                continue;
+            }
+
+            args[i] = mutator.apply(object);
+        }
+        return args;
     }
 
     public void updateLocale(final String loc) {
         if (loc != null && !loc.isEmpty()) {
-            final String[] parts = loc.split("[_\\.]");
-            if (parts.length == 1) {
-                currentLocale = new Locale(parts[0]);
-            }
-            if (parts.length == 2) {
-                currentLocale = new Locale(parts[0], parts[1]);
-            }
-            if (parts.length == 3) {
-                currentLocale = new Locale(parts[0], parts[1], parts[2]);
-            }
+            currentLocale = getLocale(loc);
         }
         ResourceBundle.clearCache();
-        messageFormatCache = new HashMap<>();
-        Logger.getLogger("Essentials").log(Level.INFO, String.format("Using locale %s", currentLocale.toString()));
+        loadedBundles.clear();
+        messageFormatCache.clear();
+        ess.getLogger().log(Level.INFO, String.format("Using locale %s", currentLocale.toString()));
 
         try {
             localeBundle = ResourceBundle.getBundle(MESSAGES, currentLocale, new UTF8PropertiesControl());
         } catch (final MissingResourceException ex) {
             localeBundle = NULL_BUNDLE;
         }
+    }
 
-        try {
-            customBundle = ResourceBundle.getBundle(MESSAGES, currentLocale, new FileResClassLoader(I18n.class.getClassLoader(), ess), new UTF8PropertiesControl());
-        } catch (final MissingResourceException ex) {
-            customBundle = NULL_BUNDLE;
+    public static Locale getLocale(final String loc) {
+        if (loc == null || loc.isEmpty()) {
+            return instance.currentLocale;
         }
+        final String[] parts = loc.split("[_.]");
+        if (parts.length == 1) {
+            return new Locale(parts[0]);
+        }
+        if (parts.length == 2) {
+            return new Locale(parts[0], parts[1]);
+        }
+        if (parts.length == 3) {
+            return new Locale(parts[0], parts[1], parts[2]);
+        }
+        return instance.currentLocale;
     }
 
     /**
      * Attempts to load properties files from the plugin directory before falling back to the jar.
      */
     private static class FileResClassLoader extends ClassLoader {
-        private final transient File dataFolder;
+        private final transient File messagesFolder;
 
         FileResClassLoader(final ClassLoader classLoader, final IEssentials ess) {
             super(classLoader);
-            this.dataFolder = ess.getDataFolder();
+            this.messagesFolder = new File(ess.getDataFolder(), "messages");
+            //noinspection ResultOfMethodCallIgnored
+            this.messagesFolder.mkdirs();
         }
 
         @Override
         public URL getResource(final String string) {
-            final File file = new File(dataFolder, string);
+            final File file = new File(messagesFolder, string);
             if (file.exists()) {
                 try {
                     return file.toURI().toURL();
@@ -166,7 +292,7 @@ public class I18n implements net.ess3.api.II18n {
 
         @Override
         public InputStream getResourceAsStream(final String string) {
-            final File file = new File(dataFolder, string);
+            final File file = new File(messagesFolder, string);
             if (file.exists()) {
                 try {
                     return new FileInputStream(file);
@@ -181,7 +307,7 @@ public class I18n implements net.ess3.api.II18n {
      * Reads .properties files as UTF-8 instead of ISO-8859-1, which is the default on Java 8/below.
      * Java 9 fixes this by defaulting to UTF-8 for .properties files.
      */
-    private static class UTF8PropertiesControl extends ResourceBundle.Control {
+    private static final class UTF8PropertiesControl extends ResourceBundle.Control {
         public ResourceBundle newBundle(final String baseName, final Locale locale, final String format, final ClassLoader loader, final boolean reload) throws IOException {
             final String resourceName = toResourceName(toBundleName(baseName, locale), "properties");
             ResourceBundle bundle = null;
@@ -208,5 +334,13 @@ public class I18n implements net.ess3.api.II18n {
             }
             return bundle;
         }
+
+        @Override
+        public Locale getFallbackLocale(String baseName, Locale locale) {
+            if (baseName == null || locale == null) {
+                throw new NullPointerException();
+            }
+            return null;
+        }
     }
 }

Essentials/src/main/java/com/earth2me/essentials/IEssentials.java

@@ -1,5 +1,6 @@
 package com.earth2me.essentials;
 
+import com.earth2me.essentials.adventure.AdventureFacet;
 import com.earth2me.essentials.api.IItemDb;
 import com.earth2me.essentials.api.IJails;
 import com.earth2me.essentials.api.IWarps;
@@ -7,19 +8,8 @@ import com.earth2me.essentials.commands.IEssentialsCommand;
 import com.earth2me.essentials.commands.PlayerNotFoundException;
 import com.earth2me.essentials.perm.PermissionsHandler;
 import com.earth2me.essentials.updatecheck.UpdateChecker;
-import net.ess3.nms.refl.providers.ReflOnlineModeProvider;
-import net.ess3.provider.ContainerProvider;
-import net.ess3.provider.FormattedCommandAliasProvider;
-import net.ess3.provider.ItemUnbreakableProvider;
-import net.ess3.provider.KnownCommandsProvider;
-import net.ess3.provider.MaterialTagProvider;
-import net.ess3.provider.PersistentDataProvider;
-import net.ess3.provider.ServerStateProvider;
-import net.ess3.provider.SerializationProvider;
-import net.ess3.provider.SpawnerBlockProvider;
-import net.ess3.provider.SpawnerItemProvider;
-import net.ess3.provider.SyncCommandsProvider;
-import net.ess3.provider.WorldInfoProvider;
+import com.earth2me.essentials.userstorage.IUserMap;
+import net.ess3.provider.Provider;
 import net.essentialsx.api.v2.services.BalanceTop;
 import net.essentialsx.api.v2.services.mail.MailService;
 import org.bukkit.Server;
@@ -78,10 +68,22 @@ public interface IEssentials extends Plugin {
 
     int broadcastMessage(String permission, String message);
 
+    void broadcastTl(String tlKey, Object... args);
+
+    void broadcastTl(IUser sender, String tlKey, Object... args);
+
+    void broadcastTl(IUser sender, String permission, String tlKey, Object... args);
+
+    void broadcastTl(IUser sender, Predicate<IUser> shouldExclude, String tlKey, Object... args);
+
+    void broadcastTl(IUser sender, Predicate<IUser> shouldExclude, boolean parseKeywords, String tlKey, Object... args);
+
     ISettings getSettings();
 
     BukkitScheduler getScheduler();
 
+    List<Player> getJailedPlayers();
+
     IJails getJails();
 
     IWarps getWarps();
@@ -108,8 +110,6 @@ public interface IEssentials extends Plugin {
 
     int scheduleSyncRepeatingTask(Runnable run, long delay, long period);
 
-    TNTExplodeListener getTNTListener();
-
     PermissionsHandler getPermissionsHandler();
 
     AlternativeCommandsHandler getAlternativeCommandsHandler();
@@ -118,6 +118,9 @@ public interface IEssentials extends Plugin {
 
     IItemDb getItemDb();
 
+    IUserMap getUsers();
+
+    @Deprecated
     UserMap getUserMap();
 
     BalanceTop getBalanceTop();
@@ -139,31 +142,13 @@ public interface IEssentials extends Plugin {
 
     Iterable<User> getOnlineUsers();
 
-    SpawnerItemProvider getSpawnerItemProvider();
-
-    SpawnerBlockProvider getSpawnerBlockProvider();
-
-    ServerStateProvider getServerStateProvider();
-
-    MaterialTagProvider getMaterialTagProvider();
-
-    ContainerProvider getContainerProvider();
-
-    KnownCommandsProvider getKnownCommandsProvider();
-
-    SerializationProvider getSerializationProvider();
-
-    FormattedCommandAliasProvider getFormattedCommandAliasProvider();
-
-    SyncCommandsProvider getSyncCommandsProvider();
-
-    PersistentDataProvider getPersistentDataProvider();
-
-    ReflOnlineModeProvider getOnlineModeProvider();
-
-    ItemUnbreakableProvider getItemUnbreakableProvider();
-
-    WorldInfoProvider getWorldInfoProvider();
-
     PluginCommand getPluginCommand(String cmd);
+
+    ProviderFactory getProviders();
+
+    default <P extends Provider> P provider(final Class<P> providerClass) {
+        return getProviders().get(providerClass);
+    }
+
+    AdventureFacet getAdventureFacet();
 }

Essentials/src/main/java/com/earth2me/essentials/ISettings.java

@@ -3,6 +3,7 @@ package com.earth2me.essentials;
 import com.earth2me.essentials.commands.IEssentialsCommand;
 import com.earth2me.essentials.signs.EssentialsSign;
 import com.earth2me.essentials.textreader.IText;
+import net.essentialsx.api.v2.ChatType;
 import org.bukkit.Material;
 import org.bukkit.event.EventPriority;
 import org.spongepowered.configurate.CommentedConfigurationNode;
@@ -36,6 +37,8 @@ public interface ISettings extends IConf {
 
     String getChatFormat(String group);
 
+    String getChatFormat(String group, ChatType chatType);
+
     String getWorldAlias(String world);
 
     int getChatRadius();
@@ -46,6 +49,14 @@ public interface ISettings extends IConf {
 
     char getChatQuestion();
 
+    boolean isShoutDefault();
+
+    boolean isPersistShout();
+
+    boolean isChatQuestionEnabled();
+
+    boolean isUsePaperChatEvent();
+
     BigDecimal getCommandCost(IEssentialsCommand cmd);
 
     BigDecimal getCommandCost(String label);
@@ -66,6 +77,8 @@ public interface ISettings extends IConf {
 
     boolean isSocialSpyMessages();
 
+    boolean isSocialSpyDisplayNames();
+
     Set<String> getMuteCommands();
 
     @Deprecated
@@ -75,10 +88,14 @@ public interface ISettings extends IConf {
 
     String getLocale();
 
+    boolean isPerPlayerLocale();
+
     String getNewbieSpawn();
 
     String getNicknamePrefix();
 
+    boolean isResetNickOnNameChange();
+
     String getOperatorColor() throws Exception;
 
     boolean getPerWarpPermission();
@@ -89,12 +106,18 @@ public interface ISettings extends IConf {
 
     List<Material> getProtectList(final String configName);
 
+    List<String> getProtectListRaw(final String configName);
+
     boolean getProtectPreventSpawn(final String creatureName);
 
     String getProtectString(final String configName);
 
     boolean getRespawnAtHome();
 
+    String getRandomSpawnLocation();
+
+    String getRandomRespawnLocation();
+
     boolean isRespawnAtAnchor();
 
     Set getMultipleHomes();
@@ -113,6 +136,8 @@ public interface ISettings extends IConf {
 
     boolean isAlwaysTeleportSafety();
 
+    boolean isConsiderWorldHeightForTeleportSafety();
+
     boolean isTeleportPassengerDismount();
 
     boolean isForcePassengerTeleport();
@@ -162,6 +187,8 @@ public interface ISettings extends IConf {
 
     boolean isEcoLogEnabled();
 
+    boolean isEcoLogUUIDEnabled();
+
     boolean isEcoLogUpdateEnabled();
 
     boolean realNamesOnList();
@@ -186,7 +213,9 @@ public interface ISettings extends IConf {
 
     long getAutoAfk();
 
-    long getAutoAfkKick();
+    long getAutoAfkTimeout();
+
+    List<String> getAfkTimeoutCommands();
 
     boolean getFreezeAfkPlayers();
 
@@ -196,6 +225,8 @@ public interface ISettings extends IConf {
 
     boolean cancelAfkOnChat();
 
+    boolean cancelAfkOnFish();
+
     boolean sleepIgnoresAfkPlayers();
 
     boolean sleepIgnoresVanishedPlayers();
@@ -228,6 +259,8 @@ public interface ISettings extends IConf {
 
     boolean isWorldHomePermissions();
 
+    int getMaxTreeCommandRange();
+
     boolean registerBackInListener();
 
     boolean getDisableItemPickupWhileAfk();
@@ -274,6 +307,8 @@ public interface ISettings extends IConf {
 
     int getMaxUserCacheCount();
 
+    long getMaxUserCacheValueExpiry();
+
     boolean allowSilentJoinQuit();
 
     boolean isCustomJoinMessage();
@@ -290,6 +325,8 @@ public interface ISettings extends IConf {
 
     boolean isCustomServerFullMessage();
 
+    boolean isCustomWhitelistMessage();
+
     boolean isNotifyNoNewMail();
 
     boolean isDropItemsIfFull();
@@ -322,6 +359,10 @@ public interface ISettings extends IConf {
 
     boolean isWorldChangeFlyResetEnabled();
 
+    boolean isWorldChangePreserveFlying();
+
+    boolean isGamemodeChangePreserveFlying();
+
     boolean isWorldChangeSpeedResetEnabled();
 
     long getCommandCooldownMs(String label);
@@ -378,6 +419,8 @@ public interface ISettings extends IConf {
 
     boolean logCommandBlockCommands();
 
+    boolean logConsoleCommands();
+
     Set<Predicate<String>> getNickBlacklist();
 
     double getMaxProjectileSpeed();
@@ -396,6 +439,22 @@ public interface ISettings extends IConf {
 
     boolean showZeroBaltop();
 
+    String getNickRegex();
+
+    BigDecimal getMultiplier(final User user);
+
+    int getMaxItemLore();
+
+    String getPrimaryColor();
+
+    String getSecondaryColor();
+
+    BigDecimal getBaltopMinBalance();
+
+    long getBaltopMinPlaytime();
+
+    int getBaltopEntryLimit();
+
     enum KeepInvPolicy {
         KEEP,
         DELETE,

Essentials/src/main/java/com/earth2me/essentials/IUser.java

@@ -1,9 +1,9 @@
 package com.earth2me.essentials;
 
+import com.earth2me.essentials.adventure.ComponentHolder;
 import com.earth2me.essentials.api.IAsyncTeleport;
 import com.earth2me.essentials.commands.IEssentialsCommand;
 import com.earth2me.essentials.config.entities.CommandCooldown;
-import net.ess3.api.ITeleport;
 import net.ess3.api.MaxMoneyException;
 import net.ess3.api.events.AfkStatusChangeEvent;
 import net.essentialsx.api.v2.services.mail.MailMessage;
@@ -15,7 +15,6 @@ import org.bukkit.entity.Player;
 import org.checkerframework.checker.nullness.qual.Nullable;
 
 import java.math.BigDecimal;
-
 import java.util.ArrayList;
 import java.util.Date;
 import java.util.List;
@@ -33,6 +32,8 @@ import java.util.regex.Pattern;
 public interface IUser {
     boolean isAuthorized(String node);
 
+    boolean isAuthorizedCached(String node);
+
     boolean isAuthorized(IEssentialsCommand cmd);
 
     boolean isAuthorized(IEssentialsCommand cmd, String permissionPrefix);
@@ -69,13 +70,9 @@ public interface IUser {
      * @return whether there is a teleport request
      */
     @Deprecated
-    boolean hasOutstandingTeleportRequest();
-
-    /**
-     * @deprecated This API is not asynchronous. Use {@link com.earth2me.essentials.api.IAsyncTeleport IAsyncTeleport} with {@link IUser#getAsyncTeleport()}
-     */
-    @Deprecated
-    ITeleport getTeleport();
+    default boolean hasOutstandingTeleportRequest() {
+        return getNextTpaRequest(false, false, false) != null;
+    }
 
     IAsyncTeleport getAsyncTeleport();
 
@@ -94,6 +91,15 @@ public interface IUser {
      */
     boolean isHidden();
 
+    /**
+     * Whether the user was hidden before leaving the server.
+     *
+     * @return true if the user was hidden.
+     */
+    boolean isLeavingHidden();
+
+    void setLeavingHidden(boolean leavingHidden);
+
     void setHidden(boolean vanish);
 
     boolean isGodModeEnabled();
@@ -133,6 +139,14 @@ public interface IUser {
 
     void sendMessage(String message);
 
+    void sendComponent(ComponentHolder component);
+
+    ComponentHolder tlComponent(String tlKey, Object... args);
+
+    String playerTl(String tlKey, Object... args);
+
+    void sendTl(String tlKey, Object... args);
+
     /*
      * UserData
      */
@@ -146,6 +160,8 @@ public interface IUser {
 
     void delHome(String name) throws Exception;
 
+    void renameHome(String name, String newName) throws Exception;
+
     boolean hasHome();
 
     Location getLastLocation();
@@ -162,6 +178,17 @@ public interface IUser {
 
     String getFormattedJailTime();
 
+    /**
+     * Returns last activity time.
+     * <p>
+     * It is used internally to determine if user's afk status should be set to
+     * true because of ACTIVITY {@link AfkStatusChangeEvent.Cause}, or the player
+     * should be kicked for being afk too long.
+     *
+     * @return Last activity time (Epoch Milliseconds)
+     */
+    long getLastActivityTime();
+
     @Deprecated
     List<String> getMails();
 
@@ -261,12 +288,12 @@ public interface IUser {
      * period are removed from queue and therefore not returned here. The maximum size of this
      * queue is determined by {@link ISettings#getTpaMaxRequests()}.
      *
-     * @param inform             true if the underlying {@link IUser} should be informed if a request expires during iteration.
-     * @param performExpirations true if this method should not spend time validating time for all items in the queue and just return the first item in the queue.
-     * @param excludeHere        true if /tphere requests should be ignored in fetching the next tpa request.
+     * @param inform            true if the underlying {@link IUser} should be informed if a request expires during iteration.
+     * @param ignoreExpirations true if this method should not process expirations for the entire queue and stop execution on the first unexpired request.
+     * @param excludeHere       true if /tphere requests should be ignored in fetching the next tpa request.
      * @return A {@link TpaRequest} corresponding to the next available request or null if no valid request is present.
      */
-    @Nullable TpaRequest getNextTpaRequest(boolean inform, boolean performExpirations, boolean excludeHere);
+    @Nullable TpaRequest getNextTpaRequest(boolean inform, boolean ignoreExpirations, boolean excludeHere);
 
     /**
      * Whether or not this {@link IUser} has any valid TPA requests in queue.
@@ -321,4 +348,12 @@ public interface IUser {
             this.time = time;
         }
     }
+
+    List<String> getPastUsernames();
+
+    void addPastUsername(String username);
+
+    boolean isFreeze();
+
+    void setFreeze(boolean freeze);
 }

Essentials/src/main/java/com/earth2me/essentials/Jails.java

@@ -5,6 +5,7 @@ import com.earth2me.essentials.config.EssentialsConfiguration;
 import com.earth2me.essentials.config.entities.LazyLocation;
 import net.ess3.api.IEssentials;
 import net.ess3.api.IUser;
+import net.ess3.api.TranslatableException;
 import org.bukkit.Location;
 import org.bukkit.entity.Entity;
 import org.bukkit.entity.EntityType;
@@ -34,13 +35,11 @@ import java.util.Locale;
 import java.util.Map;
 import java.util.concurrent.CompletableFuture;
 import java.util.logging.Level;
-import java.util.logging.Logger;
 
-import static com.earth2me.essentials.I18n.tl;
+import static com.earth2me.essentials.I18n.tlLiteral;
 
 public class Jails implements net.ess3.api.IJails {
-    private static final transient Logger LOGGER = Logger.getLogger("Essentials");
-    private static transient boolean enabled = false;
+    private static boolean enabled = false;
     private final IEssentials ess;
     private final EssentialsConfiguration config;
     private final Map<String, LazyLocation> jails = new HashMap<>();
@@ -76,7 +75,7 @@ public class Jails implements net.ess3.api.IJails {
         final JailListener blockListener = new JailListener();
         pluginManager.registerEvents(blockListener, ess);
         if (ess.getSettings().isDebug()) {
-            LOGGER.log(Level.INFO, "Registering Jail listener");
+            ess.getLogger().log(Level.INFO, "Registering Jail listener");
         }
     }
 
@@ -104,17 +103,17 @@ public class Jails implements net.ess3.api.IJails {
     @Override
     public Location getJail(String jailName) throws Exception {
         if (jailName == null) {
-            throw new Exception(tl("jailNotExist"));
+            throw new TranslatableException("jailNotExist");
         }
 
         jailName = jailName.toLowerCase(Locale.ENGLISH);
         synchronized (jails) {
             if (!jails.containsKey(jailName)) {
-                throw new Exception(tl("jailNotExist"));
+                throw new TranslatableException("jailNotExist");
             }
             final Location location = jails.get(jailName).location();
             if (location == null) {
-                throw new Exception(tl("jailWorldNotExist"));
+                throw new TranslatableException("jailWorldNotExist");
             }
             return location;
         }
@@ -142,28 +141,6 @@ public class Jails implements net.ess3.api.IJails {
         }
     }
 
-    /**
-     * @deprecated This method does not use asynchronous teleportation. Use {@link Jails#sendToJail(IUser, String, CompletableFuture)}
-     */
-    @SuppressWarnings("deprecation")
-    @Override
-    @Deprecated
-    public void sendToJail(final IUser user, String jail) throws Exception {
-        if (jail == null || jail.isEmpty()) {
-            return;
-        }
-
-        jail = jail.toLowerCase(Locale.ENGLISH);
-        synchronized (jails) {
-            if (jails.containsKey(jail)) {
-                if (user.getBase().isOnline()) {
-                    user.getTeleport().now(getJail(jail), false, TeleportCause.COMMAND);
-                }
-                user.setJail(jail);
-            }
-        }
-    }
-
     @Override
     public void sendToJail(final IUser user, final String jailName, final CompletableFuture<Boolean> future) throws Exception {
         if (jailName == null || jailName.isEmpty()) {
@@ -205,6 +182,10 @@ public class Jails implements net.ess3.api.IJails {
     private class JailListener implements Listener {
         @EventHandler(priority = EventPriority.LOW, ignoreCancelled = true)
         public void onJailBlockBreak(final BlockBreakEvent event) {
+            if (shouldIgnore(event.getPlayer())) {
+                return;
+            }
+
             final User user = ess.getUser(event.getPlayer());
             if (user.isJailed() && !user.isAuthorized("essentials.jail.allow-break")) {
                 event.setCancelled(true);
@@ -213,6 +194,10 @@ public class Jails implements net.ess3.api.IJails {
 
         @EventHandler(priority = EventPriority.LOW, ignoreCancelled = true)
         public void onJailBlockPlace(final BlockPlaceEvent event) {
+            if (shouldIgnore(event.getPlayer())) {
+                return;
+            }
+
             final User user = ess.getUser(event.getPlayer());
             if (user.isJailed() && !user.isAuthorized("essentials.jail.allow-place")) {
                 event.setCancelled(true);
@@ -221,6 +206,10 @@ public class Jails implements net.ess3.api.IJails {
 
         @EventHandler(priority = EventPriority.LOW, ignoreCancelled = true)
         public void onJailBlockDamage(final BlockDamageEvent event) {
+            if (shouldIgnore(event.getPlayer())) {
+                return;
+            }
+
             final User user = ess.getUser(event.getPlayer());
             if (user.isJailed() && !user.isAuthorized("essentials.jail.allow-block-damage")) {
                 event.setCancelled(true);
@@ -234,6 +223,9 @@ public class Jails implements net.ess3.api.IJails {
             }
             final Entity damager = event.getDamager();
             if (damager.getType() == EntityType.PLAYER) {
+                if (shouldIgnore((Player) damager)) {
+                    return;
+                }
                 final User user = ess.getUser((Player) damager);
                 if (user != null && user.isJailed()) {
                     event.setCancelled(true);
@@ -243,6 +235,10 @@ public class Jails implements net.ess3.api.IJails {
 
         @EventHandler(priority = EventPriority.LOW, ignoreCancelled = true)
         public void onJailPlayerInteract(final PlayerInteractEvent event) {
+            if (shouldIgnore(event.getPlayer())) {
+                return;
+            }
+
             final User user = ess.getUser(event.getPlayer());
             if (user.isJailed() && !user.isAuthorized("essentials.jail.allow-interact")) {
                 event.setCancelled(true);
@@ -251,6 +247,10 @@ public class Jails implements net.ess3.api.IJails {
 
         @EventHandler(priority = EventPriority.LOW, ignoreCancelled = true)
         public void onJailPlayerGameModeChange(final PlayerGameModeChangeEvent event) {
+            if (shouldIgnore(event.getPlayer())) {
+                return;
+            }
+
             final User user = ess.getUser(event.getPlayer());
             if (user.isJailed()) {
                 event.setCancelled(true);
@@ -259,6 +259,10 @@ public class Jails implements net.ess3.api.IJails {
 
         @EventHandler(priority = EventPriority.HIGHEST)
         public void onJailPlayerRespawn(final PlayerRespawnEvent event) {
+            if (shouldIgnore(event.getPlayer())) {
+                return;
+            }
+
             final User user = ess.getUser(event.getPlayer());
             if (!user.isJailed() || user.getJail() == null || user.getJail().isEmpty()) {
                 return;
@@ -268,15 +272,19 @@ public class Jails implements net.ess3.api.IJails {
                 event.setRespawnLocation(getJail(user.getJail()));
             } catch (final Exception ex) {
                 if (ess.getSettings().isDebug()) {
-                    LOGGER.log(Level.INFO, tl("returnPlayerToJailError", user.getName(), ex.getLocalizedMessage()), ex);
+                    ess.getLogger().log(Level.INFO, ess.getAdventureFacet().miniToLegacy(tlLiteral("returnPlayerToJailError", user.getName(), ex.getLocalizedMessage())), ex);
                 } else {
-                    LOGGER.log(Level.INFO, tl("returnPlayerToJailError", user.getName(), ex.getLocalizedMessage()));
+                    ess.getLogger().log(Level.INFO, ess.getAdventureFacet().miniToLegacy(tlLiteral("returnPlayerToJailError", user.getName(), ex.getLocalizedMessage())));
                 }
             }
         }
 
         @EventHandler(priority = EventPriority.HIGH)
         public void onJailPlayerTeleport(final PlayerTeleportEvent event) {
+            if (shouldIgnore(event.getPlayer())) {
+                return;
+            }
+
             final User user = ess.getUser(event.getPlayer());
             if (!user.isJailed() || user.getJail() == null || user.getJail().isEmpty()) {
                 return;
@@ -286,16 +294,20 @@ public class Jails implements net.ess3.api.IJails {
                 event.setTo(getJail(user.getJail()));
             } catch (final Exception ex) {
                 if (ess.getSettings().isDebug()) {
-                    LOGGER.log(Level.INFO, tl("returnPlayerToJailError", user.getName(), ex.getLocalizedMessage()), ex);
+                    ess.getLogger().log(Level.INFO, ess.getAdventureFacet().miniToLegacy(tlLiteral("returnPlayerToJailError", user.getName(), ex.getLocalizedMessage())), ex);
                 } else {
-                    LOGGER.log(Level.INFO, tl("returnPlayerToJailError", user.getName(), ex.getLocalizedMessage()));
+                    ess.getLogger().log(Level.INFO, ess.getAdventureFacet().miniToLegacy(tlLiteral("returnPlayerToJailError", user.getName(), ex.getLocalizedMessage())));
                 }
             }
-            user.sendMessage(tl("jailMessage"));
+            user.sendTl("jailMessage");
         }
 
         @EventHandler(priority = EventPriority.HIGHEST)
         public void onJailPlayerJoin(final PlayerJoinEvent event) {
+            if (shouldIgnore(event.getPlayer())) {
+                return;
+            }
+
             final User user = ess.getUser(event.getPlayer());
             final long currentTime = System.currentTimeMillis();
             user.checkJailTimeout(currentTime);
@@ -306,13 +318,13 @@ public class Jails implements net.ess3.api.IJails {
             final CompletableFuture<Boolean> future = new CompletableFuture<>();
             future.exceptionally(ex -> {
                 if (ess.getSettings().isDebug()) {
-                    LOGGER.log(Level.INFO, tl("returnPlayerToJailError", user.getName(), ex.getLocalizedMessage()), ex);
+                    ess.getLogger().log(Level.INFO, ess.getAdventureFacet().miniToLegacy(tlLiteral("returnPlayerToJailError", user.getName(), ex.getLocalizedMessage())), ex);
                 } else {
-                    LOGGER.log(Level.INFO, tl("returnPlayerToJailError", user.getName(), ex.getLocalizedMessage()));
+                    ess.getLogger().log(Level.INFO, ess.getAdventureFacet().miniToLegacy(tlLiteral("returnPlayerToJailError", user.getName(), ex.getLocalizedMessage())));
                 }
                 return false;
             });
-            future.thenAccept(success -> user.sendMessage(tl("jailMessage")));
+            future.thenAccept(success -> user.sendTl("jailMessage"));
 
             try {
                 sendToJail(user, user.getJail(), future);
@@ -320,5 +332,10 @@ public class Jails implements net.ess3.api.IJails {
                 future.completeExceptionally(ex);
             }
         }
+
+        private boolean shouldIgnore(final Player base) {
+            // Ignore Citizens NPCs
+            return base.getUniqueId().version() == 2 || base.hasMetadata("NPC");
+        }
     }
 }

Essentials/src/main/java/com/earth2me/essentials/Kit.java

@@ -2,30 +2,33 @@ package com.earth2me.essentials;
 
 import com.earth2me.essentials.Trade.OverflowType;
 import com.earth2me.essentials.commands.NoChargeException;
-import com.earth2me.essentials.craftbukkit.InventoryWorkaround;
+import com.earth2me.essentials.craftbukkit.Inventories;
 import com.earth2me.essentials.textreader.IText;
 import com.earth2me.essentials.textreader.KeywordReplacer;
 import com.earth2me.essentials.textreader.SimpleTextInput;
 import com.earth2me.essentials.utils.DateUtil;
-import com.earth2me.essentials.utils.MaterialUtil;
 import com.earth2me.essentials.utils.NumberUtil;
 import net.ess3.api.IEssentials;
+import net.ess3.api.TranslatableException;
 import net.ess3.api.events.KitClaimEvent;
+import net.ess3.provider.SerializationProvider;
+import net.essentialsx.api.v2.events.KitPreExpandItemsEvent;
 import org.bukkit.Bukkit;
 import org.bukkit.Material;
 import org.bukkit.inventory.ItemStack;
-import org.bukkit.inventory.PlayerInventory;
 import org.yaml.snakeyaml.external.biz.base64Coder.Base64Coder;
 
 import java.math.BigDecimal;
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.Calendar;
 import java.util.GregorianCalendar;
 import java.util.List;
 import java.util.Map;
+import java.util.HashMap;
 import java.util.logging.Level;
 
-import static com.earth2me.essentials.I18n.tl;
+import static com.earth2me.essentials.I18n.tlLiteral;
 
 public class Kit {
     final IEssentials ess;
@@ -40,7 +43,7 @@ public class Kit {
         this.charge = new Trade("kit-" + kitName, new Trade("kit-kit", ess), ess);
 
         if (kit == null) {
-            throw new Exception(tl("kitNotFound"));
+            throw new TranslatableException("kitNotFound");
         }
     }
 
@@ -50,7 +53,7 @@ public class Kit {
 
     public void checkPerms(final User user) throws Exception {
         if (!user.isAuthorized("essentials.kits." + kitName)) {
-            throw new Exception(tl("noKitPermission", "essentials.kits." + kitName));
+            throw new TranslatableException("noKitPermission", "essentials.kits." + kitName);
         }
     }
 
@@ -59,10 +62,10 @@ public class Kit {
 
         if (nextUse == 0L) {
         } else if (nextUse < 0L) {
-            user.sendMessage(tl("kitOnce"));
+            user.sendTl("kitOnce");
             throw new NoChargeException();
         } else {
-            user.sendMessage(tl("kitTimed", DateUtil.formatDateDiff(nextUse)));
+            user.sendTl("kitTimed", DateUtil.formatDateDiff(nextUse));
             throw new NoChargeException();
         }
     }
@@ -96,7 +99,7 @@ public class Kit {
             // Make sure delay is valid
             delay = kit.containsKey("delay") ? ((Number) kit.get("delay")).doubleValue() : 0.0d;
         } catch (final Exception e) {
-            throw new Exception(tl("kitError2"));
+            throw new TranslatableException("kitError2");
         }
 
         // When was the last kit used?
@@ -130,7 +133,7 @@ public class Kit {
 
     public List<String> getItems() throws Exception {
         if (kit == null) {
-            throw new Exception(tl("kitNotFound"));
+            throw new TranslatableException("kitNotFound");
         }
         try {
             final List<String> itemList = new ArrayList<>();
@@ -148,7 +151,7 @@ public class Kit {
             throw new Exception("Invalid item list");
         } catch (final Exception e) {
             ess.getLogger().log(Level.WARNING, "Error parsing kit " + kitName + ": " + e.getMessage());
-            throw new Exception(tl("kitError2"), e);
+            throw new TranslatableException(e,"kitError2");
         }
     }
 
@@ -171,10 +174,11 @@ public class Kit {
             final boolean allowUnsafe = ess.getSettings().allowUnsafeEnchantments();
             final boolean autoEquip = ess.getSettings().isKitAutoEquip();
             final List<ItemStack> itemList = new ArrayList<>();
+            final Map<Integer, ItemStack> itemsWithSlot = new HashMap<>();
             final List<String> commandQueue = new ArrayList<>();
             final List<String> moneyQueue = new ArrayList<>();
             final String currencySymbol = ess.getSettings().getCurrencySymbol().isEmpty() ? "$" : ess.getSettings().getCurrencySymbol();
-            for (final String kitItem : output.getLines()) {
+            for (String kitItem : output.getLines()) {
                 if (kitItem.startsWith("$") || kitItem.startsWith(currencySymbol)) {
                     moneyQueue.add(NumberUtil.sanitizeCurrencyString(kitItem, ess));
                     continue;
@@ -188,14 +192,25 @@ public class Kit {
                     continue;
                 }
 
+                int itemSlot = -1;
+                if (kitItem.startsWith("slot:")) {
+                    final int spaceIndex = kitItem.indexOf(" ");
+                    if (spaceIndex != -1) {
+                        final String slotStr = kitItem.substring("slot:".length(), spaceIndex);
+                        itemSlot = NumberUtil.isInt(slotStr) ? Integer.parseInt(slotStr) : -1;
+                        kitItem = kitItem.substring(spaceIndex + 1);
+                    }
+                }
+
                 final ItemStack stack;
+                final SerializationProvider serializationProvider = ess.provider(SerializationProvider.class);
 
                 if (kitItem.startsWith("@")) {
-                    if (ess.getSerializationProvider() == null) {
-                        ess.getLogger().log(Level.WARNING, tl("kitError3", kitName, user.getName()));
+                    if (serializationProvider == null) {
+                        ess.getLogger().log(Level.WARNING, ess.getAdventureFacet().miniToLegacy(tlLiteral("kitError3", kitName, user.getName())));
                         continue;
                     }
-                    stack = ess.getSerializationProvider().deserializeItem(Base64Coder.decodeLines(kitItem.substring(1)));
+                    stack = serializationProvider.deserializeItem(Base64Coder.decodeLines(kitItem.substring(1)));
                 } else {
                     final String[] parts = kitItem.split(" +");
                     final ItemStack parseStack = ess.getItemDb().get(parts[0], parts.length > 1 ? Integer.parseInt(parts[1]) : 1);
@@ -214,57 +229,51 @@ public class Kit {
                     stack = metaStack.getItemStack();
                 }
 
-                if (autoEquip) {
-                    final Material material = stack.getType();
-                    final PlayerInventory inventory = user.getBase().getInventory();
-                    if (MaterialUtil.isHelmet(material) && isEmptyStack(inventory.getHelmet())) {
-                        inventory.setHelmet(stack);
-                        continue;
-                    } else if (MaterialUtil.isChestplate(material) && isEmptyStack(inventory.getChestplate())) {
-                        inventory.setChestplate(stack);
-                        continue;
-                    } else if (MaterialUtil.isLeggings(material) && isEmptyStack(inventory.getLeggings())) {
-                        inventory.setLeggings(stack);
-                        continue;
-                    } else if (MaterialUtil.isBoots(material) && isEmptyStack(inventory.getBoots())) {
-                        inventory.setBoots(stack);
-                        continue;
-                    }
+                if (itemSlot == -1 || itemsWithSlot.containsKey(itemSlot)) {
+                    itemList.add(stack);
+                } else {
+                    itemsWithSlot.put(itemSlot, stack);
                 }
-
-                itemList.add(stack);
             }
 
-            final Map<Integer, ItemStack> overfilled;
-            final boolean allowOversizedStacks = user.isAuthorized("essentials.oversizedstacks");
+            final int maxStackSize = user.isAuthorized("essentials.oversizedstacks") ? ess.getSettings().getOversizedStackSize() : 0;
             final boolean isDropItemsIfFull = ess.getSettings().isDropItemsIfFull();
-            if (isDropItemsIfFull) {
-                if (allowOversizedStacks) {
-                    overfilled = InventoryWorkaround.addOversizedItems(user.getBase().getInventory(), ess.getSettings().getOversizedStackSize(), itemList.toArray(new ItemStack[0]));
-                } else {
-                    overfilled = InventoryWorkaround.addItems(user.getBase().getInventory(), itemList.toArray(new ItemStack[0]));
+
+            final List<ItemStack> totalItems = new ArrayList<>(itemList);
+            totalItems.addAll(itemsWithSlot.values());
+
+            final KitPreExpandItemsEvent itemsEvent = new KitPreExpandItemsEvent(user, kitName, totalItems);
+            Bukkit.getPluginManager().callEvent(itemsEvent);
+            final ItemStack[] totalItemsArray = totalItems.toArray(new ItemStack[0]);
+            if (!isDropItemsIfFull && !Inventories.hasSpace(user.getBase(), maxStackSize, autoEquip, totalItemsArray)) {
+                user.sendTl("kitInvFullNoDrop");
+                return false;
+            }
+
+            for (Map.Entry<Integer, ItemStack> itemWithSlot : itemsWithSlot.entrySet()) {
+                final ItemStack leftover = Inventories.addItem(user.getBase(), maxStackSize, itemWithSlot.getValue(), itemWithSlot.getKey());
+                if (leftover != null) {
+                    itemList.add(leftover);
                 }
-                for (final ItemStack itemStack : overfilled.values()) {
-                    int spillAmount = itemStack.getAmount();
-                    if (!allowOversizedStacks) {
+            }
+
+            final ItemStack[] itemArray = itemList.toArray(new ItemStack[0]);
+            final Map<Integer, ItemStack> leftover = Inventories.addItem(user.getBase(), maxStackSize, autoEquip, itemArray);
+            if (!isDropItemsIfFull && !leftover.isEmpty()) {
+                // Inventories#hasSpace should prevent this state from EVER being reached; If it does, something has gone terribly wrong, and we should just give up and hope people report it :(
+                throw new IllegalStateException("Something has gone terribly wrong while adding items to the user's inventory. Please report this to the EssentialsX developers. Items left over: " + leftover + ". Original items: " + Arrays.toString(itemArray));
+            }
+
+            for (final ItemStack itemStack : leftover.values()) {
+                int spillAmount = itemStack.getAmount();
+                while (spillAmount > 0) {
+                    if (maxStackSize != 0) {
                         itemStack.setAmount(Math.min(spillAmount, itemStack.getMaxStackSize()));
                     }
-                    while (spillAmount > 0) {
-                        user.getWorld().dropItemNaturally(user.getLocation(), itemStack);
-                        spillAmount -= itemStack.getAmount();
-                    }
-                    spew = true;
-                }
-            } else {
-                if (allowOversizedStacks) {
-                    overfilled = InventoryWorkaround.addAllOversizedItems(user.getBase().getInventory(), ess.getSettings().getOversizedStackSize(), itemList.toArray(new ItemStack[0]));
-                } else {
-                    overfilled = InventoryWorkaround.addAllItems(user.getBase().getInventory(), itemList.toArray(new ItemStack[0]));
-                }
-                if (overfilled != null) {
-                    user.sendMessage(tl("kitInvFullNoDrop"));
-                    return false;
+                    user.getWorld().dropItemNaturally(user.getLocation(), itemStack);
+                    spillAmount -= itemStack.getAmount();
                 }
+                spew = true;
             }
             user.getBase().updateInventory();
 
@@ -282,17 +291,13 @@ public class Kit {
             }
 
             if (spew) {
-                user.sendMessage(tl("kitInvFull"));
+                user.sendTl("kitInvFull");
             }
         } catch (final Exception e) {
             user.getBase().updateInventory();
             ess.getLogger().log(Level.WARNING, e.getMessage());
-            throw new Exception(tl("kitError2"), e);
+            throw new TranslatableException(e, "kitError2");
         }
         return true;
     }
-
-    private boolean isEmptyStack(ItemStack stack) {
-        return stack == null || MaterialUtil.isAir(stack.getType());
-    }
 }

Essentials/src/main/java/com/earth2me/essentials/Kits.java

@@ -3,6 +3,7 @@ package com.earth2me.essentials;
 import com.earth2me.essentials.config.ConfigurateUtil;
 import com.earth2me.essentials.config.EssentialsConfiguration;
 import com.earth2me.essentials.utils.NumberUtil;
+import net.ess3.api.TranslatableException;
 import org.spongepowered.configurate.CommentedConfigurationNode;
 
 import java.io.File;
@@ -14,7 +15,6 @@ import java.util.Map;
 import java.util.Set;
 
 import static com.earth2me.essentials.I18n.capitalCase;
-import static com.earth2me.essentials.I18n.tl;
 
 public class Kits implements IConf {
     private final IEssentials ess;
@@ -145,7 +145,7 @@ public class Kits implements IConf {
                     String name = capitalCase(kitItem);
                     final BigDecimal costPrice = new Trade("kit-" + kitItem.toLowerCase(Locale.ENGLISH), ess).getCommandCost(user);
                     if (costPrice.signum() > 0) {
-                        cost = tl("kitCost", NumberUtil.displayCurrency(costPrice, ess));
+                        cost = user.playerTl("kitCost", NumberUtil.displayCurrency(costPrice, ess));
                     }
 
                     final Kit kit = new Kit(kitItem, ess);
@@ -153,7 +153,7 @@ public class Kits implements IConf {
                     if (nextUse == -1 && ess.getSettings().isSkippingUsedOneTimeKitsFromKitList()) {
                         continue;
                     } else if (nextUse != 0) {
-                        name = tl("kitDelay", name);
+                        name = user.playerTl("kitDelay", name);
                     }
 
                     list.append(" ").append(name).append(cost);
@@ -161,7 +161,7 @@ public class Kits implements IConf {
             }
             return list.toString().trim();
         } catch (final Exception ex) {
-            throw new Exception(tl("kitError"), ex);
+            throw new TranslatableException(ex, "kitError");
         }
 
     }

Essentials/src/main/java/com/earth2me/essentials/MailServiceImpl.java

@@ -1,16 +1,18 @@
 package com.earth2me.essentials;
 
 import net.ess3.api.IUser;
-import net.essentialsx.api.v2.services.mail.MailService;
+import net.essentialsx.api.v2.events.UserMailEvent;
 import net.essentialsx.api.v2.services.mail.MailMessage;
 import net.essentialsx.api.v2.services.mail.MailSender;
+import net.essentialsx.api.v2.services.mail.MailService;
+import org.bukkit.Bukkit;
 import org.bukkit.plugin.ServicePriority;
 
 import java.text.SimpleDateFormat;
 import java.util.ArrayList;
 import java.util.Date;
 
-import static com.earth2me.essentials.I18n.tl;
+import static com.earth2me.essentials.I18n.tlLiteral;
 
 public class MailServiceImpl implements MailService {
     private final transient ThreadLocal<SimpleDateFormat> df = ThreadLocal.withInitial(() -> new SimpleDateFormat("yyyy/MM/dd HH:mm"));
@@ -35,6 +37,12 @@ public class MailServiceImpl implements MailService {
     }
 
     private void sendMail(IUser recipient, MailMessage message) {
+        final UserMailEvent event = new UserMailEvent(recipient, message);
+        Bukkit.getPluginManager().callEvent(event);
+        if (event.isCancelled()) {
+            return;
+        }
+
         final ArrayList<MailMessage> messages = recipient.getMailMessages();
         messages.add(0, message);
         recipient.setMailList(messages);
@@ -44,10 +52,28 @@ public class MailServiceImpl implements MailService {
     public String getMailLine(MailMessage mail) {
         final String message = mail.getMessage();
         if (mail.isLegacy()) {
-            return tl("mailMessage", message);
+            return tlLiteral("mailMessage", message);
         }
 
         final String expire = mail.getTimeExpire() != 0 ? "Timed" : "";
-        return tl((mail.isRead() ? "mailFormatNewRead" : "mailFormatNew") + expire, df.get().format(new Date(mail.getTimeSent())), mail.getSenderUsername(), message);
+        return tlLiteral((mail.isRead() ? "mailFormatNewRead" : "mailFormatNew") + expire, df.get().format(new Date(mail.getTimeSent())), mail.getSenderUsername(), message);
+    }
+
+    @Override
+    public String getMailTlKey(MailMessage message) {
+        if (message.isLegacy()) {
+            return "mailMessage";
+        }
+
+        final String expire = message.getTimeExpire() != 0 ? "Timed" : "";
+        return (message.isRead() ? "mailFormatNewRead" : "mailFormatNew") + expire;
+    }
+
+    @Override
+    public Object[] getMailTlArgs(MailMessage message) {
+        if (message.isLegacy()) {
+            return new Object[] {message.getMessage()};
+        }
+        return new Object[] {df.get().format(new Date(message.getTimeSent())), message.getSenderUsername(), message.getMessage()};
     }
 }

Essentials/src/main/java/com/earth2me/essentials/ManagedFile.java

@@ -1,7 +1,6 @@
 package com.earth2me.essentials;
 
 import net.ess3.api.IEssentials;
-import org.bukkit.Bukkit;
 
 import java.io.BufferedInputStream;
 import java.io.BufferedReader;
@@ -23,7 +22,7 @@ import java.util.Collections;
 import java.util.List;
 import java.util.logging.Level;
 
-import static com.earth2me.essentials.I18n.tl;
+import static com.earth2me.essentials.I18n.tlLiteral;
 
 public class ManagedFile {
     private static final int BUFFERSIZE = 1024 * 8;
@@ -38,7 +37,7 @@ public class ManagedFile {
                     throw new IOException("Could not delete file " + file.toString());
                 }
             } catch (final IOException ex) {
-                Bukkit.getLogger().log(Level.SEVERE, ex.getMessage(), ex);
+                Essentials.getWrappedLogger().log(Level.SEVERE, ex.getMessage(), ex);
             }
         }
 
@@ -46,7 +45,7 @@ public class ManagedFile {
             try {
                 copyResourceAscii("/" + filename, file);
             } catch (final IOException ex) {
-                Bukkit.getLogger().log(Level.SEVERE, tl("itemsCsvNotLoaded", filename), ex);
+                Essentials.getWrappedLogger().log(Level.SEVERE, ess.getAdventureFacet().miniToLegacy(tlLiteral("itemsCsvNotLoaded", filename)), ex);
             }
         }
     }
@@ -113,7 +112,7 @@ public class ManagedFile {
                                 if (correct.equals(test)) {
                                     return true;
                                 } else {
-                                    Bukkit.getLogger().warning("File " + file.toString() + " has been modified by user and file version differs, please update the file manually.");
+                                    Essentials.getWrappedLogger().warning("File " + file.toString() + " has been modified by user and file version differs, please update the file manually.");
                                 }
                             }
                         }
@@ -147,7 +146,7 @@ public class ManagedFile {
                 return lines;
             }
         } catch (final IOException ex) {
-            Bukkit.getLogger().log(Level.SEVERE, ex.getMessage(), ex);
+            Essentials.getWrappedLogger().log(Level.SEVERE, ex.getMessage(), ex);
             return Collections.emptyList();
         }
     }

Essentials/src/main/java/com/earth2me/essentials/MetaItemStack.java

@@ -1,15 +1,20 @@
 package com.earth2me.essentials;
 
+import com.earth2me.essentials.items.transform.PluginItemTransformer;
 import com.earth2me.essentials.textreader.BookInput;
 import com.earth2me.essentials.textreader.BookPager;
 import com.earth2me.essentials.textreader.IText;
-import com.earth2me.essentials.utils.EnumUtil;
 import com.earth2me.essentials.utils.FormatUtil;
 import com.earth2me.essentials.utils.MaterialUtil;
 import com.earth2me.essentials.utils.NumberUtil;
 import com.earth2me.essentials.utils.VersionUtil;
 import com.google.common.base.Joiner;
 import net.ess3.api.IEssentials;
+import net.ess3.api.TranslatableException;
+import net.ess3.provider.BannerDataProvider;
+import net.ess3.provider.ItemUnbreakableProvider;
+import net.ess3.provider.PatternTypeProvider;
+import net.ess3.provider.PotionMetaProvider;
 import org.bukkit.Color;
 import org.bukkit.DyeColor;
 import org.bukkit.FireworkEffect;
@@ -17,6 +22,8 @@ import org.bukkit.Material;
 import org.bukkit.block.Banner;
 import org.bukkit.block.banner.PatternType;
 import org.bukkit.enchantments.Enchantment;
+import org.bukkit.Registry;
+import org.bukkit.NamespacedKey;
 import org.bukkit.inventory.ItemFlag;
 import org.bukkit.inventory.ItemStack;
 import org.bukkit.inventory.meta.BannerMeta;
@@ -29,7 +36,10 @@ import org.bukkit.inventory.meta.ItemMeta;
 import org.bukkit.inventory.meta.LeatherArmorMeta;
 import org.bukkit.inventory.meta.PotionMeta;
 import org.bukkit.inventory.meta.SkullMeta;
-import org.bukkit.potion.Potion;
+import org.bukkit.inventory.meta.ArmorMeta;
+import org.bukkit.inventory.meta.trim.ArmorTrim;
+import org.bukkit.inventory.meta.trim.TrimMaterial;
+import org.bukkit.inventory.meta.trim.TrimPattern;
 import org.bukkit.potion.PotionEffect;
 import org.bukkit.potion.PotionEffectType;
 
@@ -42,11 +52,10 @@ import java.util.Map;
 import java.util.logging.Level;
 import java.util.regex.Pattern;
 
-import static com.earth2me.essentials.I18n.tl;
-
 public class MetaItemStack {
     private static final Map<String, DyeColor> colorMap = new HashMap<>();
     private static final Map<String, FireworkEffect.Type> fireworkShape = new HashMap<>();
+    private static final transient Map<String, PluginItemTransformer> itemTransformers = new HashMap<>();
     private static boolean useNewSkullMethod = true;
 
     static {
@@ -78,6 +87,32 @@ public class MetaItemStack {
         this.stack = stack.clone();
     }
 
+    /**
+     * Registers an item transformer, belonging to a plugin, that can manipulate certain item metadata.
+     * @param key the key for the transformer.
+     * @param itemTransformer the actual transformer.
+     */
+    public static void registerItemTransformer(final String key, final PluginItemTransformer itemTransformer) {
+        //Warn people if they're trying to register over top of someone else.
+        if (itemTransformers.containsKey(key)) {
+            Essentials.getWrappedLogger().log(Level.WARNING, String.format("Plugin transformer registered to \"%s\" attempted to register already existing item transformer \"%s\" belonging to \"%s\"!",
+                    itemTransformer.getPlugin().getName(),
+                    key,
+                    itemTransformers.get(key).getPlugin().getName()));
+            return;
+        }
+
+        itemTransformers.put(key, itemTransformer);
+    }
+
+    /**
+     * Unregisters a certain item transformer under key "key".
+     * @param key the transformer key.
+     */
+    public static void unregisterItemTransformer(final String key) {
+        itemTransformers.remove(key);
+    }
+
     private static void setSkullOwner(final IEssentials ess, final ItemStack stack, final String owner) {
         if (!(stack.getItemMeta() instanceof SkullMeta)) return;
 
@@ -131,21 +166,30 @@ public class MetaItemStack {
     }
 
     public boolean canSpawn(final IEssentials ess) {
-        try {
-            ess.getServer().getUnsafe().modifyItemStack(stack.clone(), "{}");
-            return true;
-        } catch (final NoSuchMethodError nsme) {
-            return true;
-        } catch (final Throwable npe) {
-            if (ess.getSettings().isDebug()) {
-                ess.getLogger().log(Level.INFO, "Itemstack is invalid", npe);
+        if (VersionUtil.PRE_FLATTENING) {
+            try {
+                ess.getServer().getUnsafe().modifyItemStack(stack.clone(), "{}");
+                return true;
+            } catch (final NoSuchMethodError nsme) {
+                return true;
+            } catch (final Throwable npe) {
+                if (ess.getSettings().isDebug()) {
+                    ess.getLogger().log(Level.INFO, "Itemstack is invalid", npe);
+                }
+                return false;
             }
-            return false;
         }
+        return stack.getType().isItem();
     }
 
     public void parseStringMeta(final CommandSource sender, final boolean allowUnsafe, final String[] string, final int fromArg, final IEssentials ess) throws Exception {
+        final boolean nbtIsKill = VersionUtil.getServerBukkitVersion().isHigherThanOrEqualTo(VersionUtil.v1_20_6_R01);
+
         if (string[fromArg].startsWith("{") && hasMetaPermission(sender, "vanilla", false, true, ess)) {
+            if (nbtIsKill) {
+                throw new TranslatableException("noMetaNbtKill");
+            }
+
             try {
                 stack = ess.getServer().getUnsafe().modifyItemStack(stack, Joiner.on(' ').join(Arrays.asList(string).subList(fromArg, string.length)));
             } catch (final NullPointerException npe) {
@@ -153,7 +197,28 @@ public class MetaItemStack {
                     ess.getLogger().log(Level.INFO, "Itemstack is invalid", npe);
                 }
             } catch (final NoSuchMethodError nsme) {
-                throw new Exception(tl("noMetaJson"), nsme);
+                throw new TranslatableException(nsme, "noMetaJson");
+            } catch (final Throwable throwable) {
+                throw new Exception(throwable.getMessage(), throwable);
+            }
+        } else if (string[fromArg].startsWith("[") && hasMetaPermission(sender, "vanilla", false, true, ess)) {
+            if (!nbtIsKill) {
+                throw new TranslatableException("noMetaComponents");
+            }
+
+            try {
+                final String components = Joiner.on(' ').join(Arrays.asList(string).subList(fromArg, string.length));
+                // From 1.20.6 through 1.21.11, modifyItemStack parses its argument as a full item string, so the item's
+                // namespaced key must be prepended to the components. As of 26.1, the implementation prepends the item
+                // key itself, so prepending it here would produce a malformed (double-namespaced) item string.
+                final String itemString = VersionUtil.getServerBukkitVersion().isHigherThanOrEqualTo(VersionUtil.v26_1_R01)
+                        ? components
+                        : stack.getType().getKey() + components;
+                stack = ess.getServer().getUnsafe().modifyItemStack(stack, itemString);
+            } catch (final NullPointerException npe) {
+                if (ess.getSettings().isDebug()) {
+                    ess.getLogger().log(Level.INFO, "Itemstack is invalid", npe);
+                }
             } catch (final Throwable throwable) {
                 throw new Exception(throwable.getMessage(), throwable);
             }
@@ -163,19 +228,19 @@ public class MetaItemStack {
             }
             if (validFirework) {
                 if (!hasMetaPermission(sender, "firework", true, true, ess)) {
-                    throw new Exception(tl("noMetaFirework"));
+                    throw new TranslatableException("noMetaFirework");
                 }
                 final FireworkEffect effect = builder.build();
                 final FireworkMeta fmeta = (FireworkMeta) stack.getItemMeta();
                 fmeta.addEffect(effect);
                 if (fmeta.getEffects().size() > 1 && !hasMetaPermission(sender, "firework-multiple", true, true, ess)) {
-                    throw new Exception(tl("multipleCharges"));
+                    throw new TranslatableException("multipleCharges");
                 }
                 stack.setItemMeta(fmeta);
             }
             if (validFireworkCharge) {
                 if (!hasMetaPermission(sender, "firework", true, true, ess)) {
-                    throw new Exception(tl("noMetaFirework"));
+                    throw new TranslatableException("noMetaFirework");
                 }
                 final FireworkEffect effect = builder.build();
                 final FireworkEffectMeta meta = (FireworkEffectMeta) stack.getItemMeta();
@@ -191,56 +256,77 @@ public class MetaItemStack {
             return;
         }
 
-        final Material WRITTEN_BOOK = EnumUtil.getMaterial("WRITTEN_BOOK");
-
         if (split.length > 1 && split[0].equalsIgnoreCase("name") && hasMetaPermission(sender, "name", false, true, ess)) {
-            final String displayName = FormatUtil.replaceFormat(split[1].replace('_', ' '));
+            final String displayName = FormatUtil.replaceFormat(split[1].replaceAll("(?<!\\\\)_", " ").replace("\\_", "_"));
             final ItemMeta meta = stack.getItemMeta();
             meta.setDisplayName(displayName);
             stack.setItemMeta(meta);
         } else if (split.length > 1 && (split[0].equalsIgnoreCase("lore") || split[0].equalsIgnoreCase("desc")) && hasMetaPermission(sender, "lore", false, true, ess)) {
             final List<String> lore = new ArrayList<>();
             for (final String line : split[1].split("(?<!\\\\)\\|")) {
-                lore.add(FormatUtil.replaceFormat(line.replace('_', ' ').replace("\\|", "|")));
+                lore.add(FormatUtil.replaceFormat(line.replaceAll("(?<!\\\\)_", " ").replace("\\_", "_").replace("\\|", "|")));
             }
             final ItemMeta meta = stack.getItemMeta();
             meta.setLore(lore);
             stack.setItemMeta(meta);
+        } else if ((split[0].equalsIgnoreCase("custom-model-data") || split[0].equalsIgnoreCase("cmd")) && hasMetaPermission(sender, "custom-model-data", false, true, ess)) {
+            if (VersionUtil.getServerBukkitVersion().isHigherThanOrEqualTo(VersionUtil.v1_14_R01)) {
+                final int value = split.length <= 1 ? 0 : Integer.parseInt(split[1]);
+                final ItemMeta meta = stack.getItemMeta();
+                meta.setCustomModelData(value);
+                stack.setItemMeta(meta);
+            }
         } else if (split[0].equalsIgnoreCase("unbreakable") && hasMetaPermission(sender, "unbreakable", false, true, ess)) {
             final boolean value = split.length <= 1 || Boolean.parseBoolean(split[1]);
             setUnbreakable(ess, stack, value);
         } else if (split.length > 1 && (split[0].equalsIgnoreCase("player") || split[0].equalsIgnoreCase("owner")) && hasMetaPermission(sender, "head", false, true, ess)) {
-            if (MaterialUtil.isPlayerHead(stack.getType(), stack.getDurability())) {
+            if (MaterialUtil.isPlayerHead(stack)) {
                 final String owner = split[1];
                 setSkullOwner(ess, stack, owner);
             } else {
-                throw new Exception(tl("onlyPlayerSkulls"));
+                throw new TranslatableException("onlyPlayerSkulls");
             }
-        } else if (split.length > 1 && split[0].equalsIgnoreCase("book") && MaterialUtil.isEditableBook(stack.getType()) && (hasMetaPermission(sender, "book",true, true, ess) || hasMetaPermission(sender, "chapter-" + split[1].toLowerCase(Locale.ENGLISH), true, true, ess))) {
+        } else if (split.length > 1 && split[0].equalsIgnoreCase("book") && MaterialUtil.isEditableBook(stack.getType()) && (hasMetaPermission(sender, "book", true, true, ess) || hasMetaPermission(sender, "chapter-" + split[1].toLowerCase(Locale.ENGLISH), true, true, ess))) {
             final BookMeta meta = (BookMeta) stack.getItemMeta();
             final IText input = new BookInput("book", true, ess);
             final BookPager pager = new BookPager(input);
-
+            // This fix only applies to written books - which require an author and a title. https://bugs.mojang.com/browse/MC-59153
+            if (stack.getType() == Material.WRITTEN_BOOK) {
+                if (!meta.hasAuthor()) {
+                    // The sender can be null when this method is called from {@link  com.earth2me.essentials.signs.EssentialsSign#getItemMeta(ItemStack, String, IEssentials)}
+                    meta.setAuthor(sender == null ? Console.getInstance().getDisplayName() : sender.getPlayer().getName());
+                }
+                if (!meta.hasTitle()) {
+                    final String title = FormatUtil.replaceFormat(split[1].replace('_', ' '));
+                    meta.setTitle(title.length() > 32 ? title.substring(0, 32) : title);
+                }
+            }
             final List<String> pages = pager.getPages(split[1]);
             meta.setPages(pages);
             stack.setItemMeta(meta);
-        } else if (split.length > 1 && split[0].equalsIgnoreCase("author") && stack.getType() == WRITTEN_BOOK && hasMetaPermission(sender, "author", false, true, ess)) {
+        } else if (split.length > 1 && split[0].equalsIgnoreCase("author") && stack.getType() == Material.WRITTEN_BOOK && hasMetaPermission(sender, "author", false, true, ess)) {
             final String author = FormatUtil.replaceFormat(split[1]);
             final BookMeta meta = (BookMeta) stack.getItemMeta();
             meta.setAuthor(author);
             stack.setItemMeta(meta);
-        } else if (split.length > 1 && split[0].equalsIgnoreCase("title") && stack.getType() == WRITTEN_BOOK && hasMetaPermission(sender, "title", false, true, ess)) {
-            final String title = FormatUtil.replaceFormat(split[1].replace('_', ' '));
+        } else if (split.length > 1 && split[0].equalsIgnoreCase("title") && stack.getType() == Material.WRITTEN_BOOK && hasMetaPermission(sender, "title", false, true, ess)) {
+            final String title = FormatUtil.replaceFormat(split[1].replaceAll("(?<!\\\\)_", " ").replace("\\_", "_"));
             final BookMeta meta = (BookMeta) stack.getItemMeta();
             meta.setTitle(title);
             stack.setItemMeta(meta);
-        } else if (split.length > 1 && split[0].startsWith("page") && split[0].length() > 4 && MaterialUtil.isEditableBook(stack.getType()) && hasMetaPermission(sender, "page", false, true, ess)) {
-            final int page = NumberUtil.isInt(split[0].substring(4)) ? (Integer.parseInt(split[0].substring(4)) - 1) : 0;
+        } else if (split.length > 1 && split[0].startsWith("page") && split[0].length() > 4
+                && MaterialUtil.isEditableBook(stack.getType())
+                && hasMetaPermission(sender, "page", false, true, ess)) {
+            final int page = NumberUtil.isInt(split[0].substring(4)) ? (Integer.parseInt(split[0].substring(4)) - 1)
+                    : 0;
+            if (page > 100) {
+                throw new TranslatableException("pageLimitExceeded");
+            }
             final BookMeta meta = (BookMeta) stack.getItemMeta();
             final List<String> pages = meta.hasPages() ? new ArrayList<>(meta.getPages()) : new ArrayList<>();
             final List<String> lines = new ArrayList<>();
             for (final String line : split[1].split("(?<!\\\\)\\|")) {
-                lines.add(FormatUtil.replaceFormat(line.replace('_', ' ').replace("\\|", "|")));
+                lines.add(FormatUtil.replaceFormat(line.replaceAll("(?<!\\\\)_", " ").replace("\\_", "_").replace("\\|", "|")));
             }
             final String content = String.join("\n", lines);
             if (page >= pages.size()) {
@@ -301,17 +387,43 @@ public class MetaItemStack {
                 meta.setColor(Color.fromRGB(red, green, blue));
                 stack.setItemMeta(meta);
             } else {
-                throw new Exception(tl("leatherSyntax"));
+                throw new TranslatableException("leatherSyntax");
             }
+        } else if (MaterialUtil.isArmor(stack.getType()) && split.length > 1 && split[0].equalsIgnoreCase("trim")) {
+            final ArmorMeta armorMeta = (ArmorMeta) stack.getItemMeta();
+            final String[] trimData = split[1].split("\\|");
+            final TrimPattern pattern = Registry.TRIM_PATTERN.getOrThrow(NamespacedKey.minecraft(trimData[0].toLowerCase()));
+            final TrimMaterial material = Registry.TRIM_MATERIAL.getOrThrow(NamespacedKey.minecraft(trimData[1].toLowerCase()));
+
+            armorMeta.setTrim(new ArmorTrim(material, pattern));
+
+            stack.setItemMeta(armorMeta);
+        } else if (split.length > 1 && itemTransformers.containsKey(split[0])) {
+            transformItem(split[0], split[1]);
         } else {
             parseEnchantmentStrings(sender, allowUnsafe, split, ess);
         }
     }
 
+    private void transformItem(final String key, final String data){
+        final PluginItemTransformer transformer = itemTransformers.get(key);
+
+        //Ignore, the plugin is disabled.
+        if (!transformer.getPlugin().isEnabled()) {
+            return;
+        }
+
+        try {
+            stack = transformer.apply(data, stack);
+        } catch(final Throwable thr) {
+            Essentials.getWrappedLogger().log(Level.SEVERE, String.format("Error applying data \"%s\" to itemstack! Plugin: %s, Key: %s", data, transformer.getPlugin().getName(), key), thr);
+        }
+    }
+
     public void addItemFlags(final String string) throws Exception {
         final String[] separate = splitPattern.split(string, 2);
         if (separate.length != 2) {
-            throw new Exception(tl("invalidItemFlagMeta", string));
+            throw new TranslatableException("invalidItemFlagMeta", string);
         }
 
         final String[] split = separate[1].split(",");
@@ -326,7 +438,7 @@ public class MetaItemStack {
         }
 
         if (meta.getItemFlags().isEmpty()) {
-            throw new Exception(tl("invalidItemFlagMeta", string));
+            throw new TranslatableException("invalidItemFlagMeta", string);
         }
 
         stack.setItemMeta(meta);
@@ -349,7 +461,7 @@ public class MetaItemStack {
                     validFireworkCharge = true;
                     primaryColors.add(Color.fromRGB(Integer.decode(color)));
                 } else {
-                    throw new Exception(tl("invalidFireworkFormat", split[1], split[0]));
+                    throw new TranslatableException("invalidFireworkFormat", split[1], split[0]);
                 }
             }
             builder.withColor(primaryColors);
@@ -359,7 +471,7 @@ public class MetaItemStack {
             if (fireworkShape.containsKey(split[1].toUpperCase())) {
                 finalEffect = fireworkShape.get(split[1].toUpperCase());
             } else {
-                throw new Exception(tl("invalidFireworkFormat", split[1], split[0]));
+                throw new TranslatableException("invalidFireworkFormat", split[1], split[0]);
             }
             if (finalEffect != null) {
                 builder.with(finalEffect);
@@ -373,7 +485,7 @@ public class MetaItemStack {
                 } else if (hexPattern.matcher(color).matches()) {
                     fadeColors.add(Color.fromRGB(Integer.decode(color)));
                 } else {
-                    throw new Exception(tl("invalidFireworkFormat", split[1], split[0]));
+                    throw new TranslatableException("invalidFireworkFormat", split[1], split[0]);
                 }
             }
             if (!fadeColors.isEmpty()) {
@@ -387,7 +499,7 @@ public class MetaItemStack {
                 } else if (effect.equalsIgnoreCase("trail")) {
                     builder.trail(true);
                 } else {
-                    throw new Exception(tl("invalidFireworkFormat", split[1], split[0]));
+                    throw new TranslatableException("invalidFireworkFormat", split[1], split[0]);
                 }
             }
         }
@@ -403,13 +515,13 @@ public class MetaItemStack {
             if (split[0].equalsIgnoreCase("color") || split[0].equalsIgnoreCase("colour") || (allowShortName && split[0].equalsIgnoreCase("c"))) {
                 if (validFirework) {
                     if (!hasMetaPermission(sender, "firework", true, true, ess)) {
-                        throw new Exception(tl("noMetaFirework"));
+                        throw new TranslatableException("noMetaFirework");
                     }
                     final FireworkEffect effect = builder.build();
                     final FireworkMeta fmeta = (FireworkMeta) stack.getItemMeta();
                     fmeta.addEffect(effect);
                     if (fmeta.getEffects().size() > 1 && !hasMetaPermission(sender, "firework-multiple", true, true, ess)) {
-                        throw new Exception(tl("multipleCharges"));
+                        throw new TranslatableException("multipleCharges");
                     }
                     stack.setItemMeta(fmeta);
                     builder = FireworkEffect.builder();
@@ -425,7 +537,7 @@ public class MetaItemStack {
                         validFirework = true;
                         primaryColors.add(Color.fromRGB(Integer.decode(color)));
                     } else {
-                        throw new Exception(tl("invalidFireworkFormat", split[1], split[0]));
+                        throw new TranslatableException("invalidFireworkFormat", split[1], split[0]);
                     }
                 }
                 builder.withColor(primaryColors);
@@ -435,7 +547,7 @@ public class MetaItemStack {
                 if (fireworkShape.containsKey(split[1].toUpperCase())) {
                     finalEffect = fireworkShape.get(split[1].toUpperCase());
                 } else {
-                    throw new Exception(tl("invalidFireworkFormat", split[1], split[0]));
+                    throw new TranslatableException("invalidFireworkFormat", split[1], split[0]);
                 }
                 if (finalEffect != null) {
                     builder.with(finalEffect);
@@ -449,7 +561,7 @@ public class MetaItemStack {
                     } else if (hexPattern.matcher(color).matches()) {
                         fadeColors.add(Color.fromRGB(Integer.decode(color)));
                     } else {
-                        throw new Exception(tl("invalidFireworkFormat", split[1], split[0]));
+                        throw new TranslatableException("invalidFireworkFormat", split[1], split[0]);
                     }
                 }
                 if (!fadeColors.isEmpty()) {
@@ -463,7 +575,7 @@ public class MetaItemStack {
                     } else if (effect.equalsIgnoreCase("trail")) {
                         builder.trail(true);
                     } else {
-                        throw new Exception(tl("invalidFireworkFormat", split[1], split[0]));
+                        throw new TranslatableException("invalidFireworkFormat", split[1], split[0]);
                     }
                 }
             }
@@ -484,10 +596,10 @@ public class MetaItemStack {
                     if (hasMetaPermission(sender, "potions." + pEffectType.getName().toLowerCase(Locale.ENGLISH), true, false, ess)) {
                         validPotionEffect = true;
                     } else {
-                        throw new Exception(tl("noPotionEffectPerm", pEffectType.getName().toLowerCase(Locale.ENGLISH)));
+                        throw new TranslatableException("noPotionEffectPerm", pEffectType.getName().toLowerCase(Locale.ENGLISH));
                     }
                 } else {
-                    throw new Exception(tl("invalidPotionMeta", split[1]));
+                    throw new TranslatableException("invalidPotionMeta", split[1]);
                 }
             } else if (split[0].equalsIgnoreCase("power") || (allowShortName && split[0].equalsIgnoreCase("p"))) {
                 if (NumberUtil.isInt(split[1])) {
@@ -497,21 +609,22 @@ public class MetaItemStack {
                         power -= 1;
                     }
                 } else {
-                    throw new Exception(tl("invalidPotionMeta", split[1]));
+                    throw new TranslatableException("invalidPotionMeta", split[1]);
                 }
             } else if (split[0].equalsIgnoreCase("amplifier") || (allowShortName && split[0].equalsIgnoreCase("a"))) {
                 if (NumberUtil.isInt(split[1])) {
                     validPotionPower = true;
                     power = Integer.parseInt(split[1]);
                 } else {
-                    throw new Exception(tl("invalidPotionMeta", split[1]));
+                    throw new TranslatableException("invalidPotionMeta", split[1]);
                 }
             } else if (split[0].equalsIgnoreCase("duration") || (allowShortName && split[0].equalsIgnoreCase("d"))) {
                 if (NumberUtil.isInt(split[1])) {
                     validPotionDuration = true;
-                    duration = Integer.parseInt(split[1]) * 20; //Duration is in ticks by default, converted to seconds
+                    final int parsed = Integer.parseInt(split[1]);
+                    duration = parsed == -1 ? -1 : parsed * 20; //Duration is in ticks by default, converted to seconds
                 } else {
-                    throw new Exception(tl("invalidPotionMeta", split[1]));
+                    throw new TranslatableException("invalidPotionMeta", split[1]);
                 }
             } else if (split[0].equalsIgnoreCase("splash") || (allowShortName && split[0].equalsIgnoreCase("s"))) {
                 isSplashPotion = Boolean.parseBoolean(split[1]);
@@ -521,21 +634,11 @@ public class MetaItemStack {
                 final PotionMeta pmeta = (PotionMeta) stack.getItemMeta();
                 pEffect = pEffectType.createEffect(duration, power);
                 if (pmeta.getCustomEffects().size() > 1 && !hasMetaPermission(sender, "potions.multiple", true, false, ess)) {
-                    throw new Exception(tl("multiplePotionEffects"));
+                    throw new TranslatableException("multiplePotionEffects");
                 }
                 pmeta.addCustomEffect(pEffect, true);
                 stack.setItemMeta(pmeta);
-                if (VersionUtil.getServerBukkitVersion().isHigherThanOrEqualTo(VersionUtil.v1_9_R01)) {
-                    if (isSplashPotion && stack.getType() != Material.SPLASH_POTION) {
-                        stack.setType(Material.SPLASH_POTION);
-                    } else if (!isSplashPotion && stack.getType() != Material.POTION) {
-                        stack.setType(Material.POTION);
-                    }
-                } else {
-                    final Potion potion = Potion.fromDamage(stack.getDurability());
-                    potion.setSplash(isSplashPotion);
-                    potion.apply(stack);
-                }
+                ess.provider(PotionMetaProvider.class).setSplashPotion(stack, isSplashPotion);
                 resetPotionMeta();
             }
         }
@@ -546,7 +649,7 @@ public class MetaItemStack {
         if (enchantment == null) {
             return false;
         }
-        if (hasMetaPermission(sender, "enchantments." + enchantment.getName().toLowerCase(Locale.ENGLISH), false, false, ess)) {
+        if (hasMetaPermission(sender, "enchantments." + Enchantments.getRealName(enchantment), false, false, ess)) {
             int level = -1;
             if (split.length > 1) {
                 try {
@@ -566,7 +669,7 @@ public class MetaItemStack {
 
     public void addEnchantment(final CommandSource sender, final boolean allowUnsafe, final Enchantment enchantment, final int level) throws Exception {
         if (enchantment == null) {
-            throw new Exception(tl("enchantmentNotFound"));
+            throw new TranslatableException("enchantmentNotFound");
         }
         try {
             if (stack.getType().equals(Material.ENCHANTED_BOOK)) {
@@ -589,7 +692,7 @@ public class MetaItemStack {
                 }
             }
         } catch (final Exception ex) {
-            throw new Exception("Enchantment " + enchantment.getName() + ": " + ex.getMessage(), ex);
+            throw new Exception("Enchantment " + Enchantments.getRealName(enchantment) + ": " + ex.getMessage(), ex);
         }
     }
 
@@ -599,10 +702,10 @@ public class MetaItemStack {
             return null;
         }
 
-        final String enchantmentName = enchantment.getName().toLowerCase(Locale.ENGLISH);
+        final String enchantmentName = Enchantments.getRealName(enchantment);
 
         if (!hasMetaPermission(user, "enchantments." + enchantmentName, true, false)) {
-            throw new Exception(tl("enchantmentPerm", enchantmentName));
+            throw new TranslatableException("enchantmentPerm", enchantmentName);
         }
         return enchantment;
     }
@@ -612,23 +715,18 @@ public class MetaItemStack {
             final String[] split = splitPattern.split(string, 2);
 
             if (split.length < 2) {
-                throw new Exception(tl("invalidBanner", split[1]));
+                throw new TranslatableException("invalidBanner", split[1]);
             }
 
-            PatternType patternType = null;
-            try {
-                patternType = PatternType.valueOf(split[0]);
-            } catch (final Exception ignored) {
-            }
+            final PatternType patternType = ess.provider(PatternTypeProvider.class).getPatternTypeByIdentifier(split[0]);
 
             final BannerMeta meta = (BannerMeta) stack.getItemMeta();
             if (split[0].equalsIgnoreCase("basecolor")) {
                 final Color color = Color.fromRGB(Integer.parseInt(split[1]));
-                meta.setBaseColor(DyeColor.getByColor(color));
+                ess.provider(BannerDataProvider.class).setBaseColor(stack, DyeColor.getByColor(color));
             } else if (patternType != null) {
-                final PatternType type = PatternType.valueOf(split[0]);
                 final DyeColor color = DyeColor.getByColor(Color.fromRGB(Integer.parseInt(split[1])));
-                final org.bukkit.block.banner.Pattern pattern = new org.bukkit.block.banner.Pattern(color, type);
+                final org.bukkit.block.banner.Pattern pattern = new org.bukkit.block.banner.Pattern(color, patternType);
                 meta.addPattern(pattern);
             }
 
@@ -637,14 +735,10 @@ public class MetaItemStack {
             final String[] split = splitPattern.split(string, 2);
 
             if (split.length < 2) {
-                throw new Exception(tl("invalidBanner", split[1]));
+                throw new TranslatableException("invalidBanner", split[1]);
             }
 
-            PatternType patternType = null;
-            try {
-                patternType = PatternType.valueOf(split[0]);
-            } catch (final Exception ignored) {
-            }
+            final PatternType patternType = ess.provider(PatternTypeProvider.class).getPatternTypeByIdentifier(split[0]);
 
             // Hacky fix for accessing Shield meta - https://github.com/drtshock/Essentials/pull/745#issuecomment-234843795
             final BlockStateMeta meta = (BlockStateMeta) stack.getItemMeta();
@@ -653,9 +747,8 @@ public class MetaItemStack {
                 final Color color = Color.fromRGB(Integer.parseInt(split[1]));
                 banner.setBaseColor(DyeColor.getByColor(color));
             } else if (patternType != null) {
-                final PatternType type = PatternType.valueOf(split[0]);
                 final DyeColor color = DyeColor.getByColor(Color.fromRGB(Integer.parseInt(split[1])));
-                final org.bukkit.block.banner.Pattern pattern = new org.bukkit.block.banner.Pattern(color, type);
+                final org.bukkit.block.banner.Pattern pattern = new org.bukkit.block.banner.Pattern(color, patternType);
                 banner.addPattern(pattern);
             }
             banner.update();
@@ -678,13 +771,13 @@ public class MetaItemStack {
         if (graceful) {
             return false;
         } else {
-            throw new Exception(tl("noMetaPerm", metaPerm));
+            throw new TranslatableException("noMetaPerm", metaPerm);
         }
     }
 
     private void setUnbreakable(final IEssentials ess, final ItemStack is, final boolean unbreakable) {
         final ItemMeta meta = is.getItemMeta();
-        ess.getItemUnbreakableProvider().setUnbreakable(meta, unbreakable);
+        ess.provider(ItemUnbreakableProvider.class).setUnbreakable(meta, unbreakable);
         is.setItemMeta(meta);
     }
 }

Essentials/src/main/java/com/earth2me/essentials/Mob.java

@@ -1,5 +1,6 @@
 package com.earth2me.essentials;
 
+import com.earth2me.essentials.adventure.AdventureUtil;
 import com.earth2me.essentials.utils.EnumUtil;
 import org.bukkit.Location;
 import org.bukkit.Server;
@@ -13,9 +14,8 @@ import java.util.Locale;
 import java.util.Map;
 import java.util.Set;
 import java.util.logging.Level;
-import java.util.logging.Logger;
 
-import static com.earth2me.essentials.I18n.tl;
+import static com.earth2me.essentials.I18n.tlLiteral;
 
 // Suffixes can be appended on the end of a mob name to make it plural
 // Entities without a suffix, will default to 's'
@@ -42,22 +42,32 @@ public enum Mob {
     ENDERDRAGON("EnderDragon", Enemies.ENEMY, EntityType.ENDER_DRAGON),
     VILLAGER("Villager", Enemies.FRIENDLY, EntityType.VILLAGER),
     BLAZE("Blaze", Enemies.ENEMY, EntityType.BLAZE),
-    MUSHROOMCOW("MushroomCow", Enemies.FRIENDLY, EntityType.MUSHROOM_COW),
+    MUSHROOMCOW("MushroomCow", Enemies.FRIENDLY, MobCompat.MOOSHROOM),
     MAGMACUBE("MagmaCube", Enemies.ENEMY, EntityType.MAGMA_CUBE),
-    SNOWMAN("Snowman", Enemies.FRIENDLY, "", EntityType.SNOWMAN),
+    SNOWMAN("Snowman", Enemies.FRIENDLY, "", MobCompat.SNOW_GOLEM),
     OCELOT("Ocelot", Enemies.NEUTRAL, EntityType.OCELOT),
     IRONGOLEM("IronGolem", Enemies.NEUTRAL, EntityType.IRON_GOLEM),
     WITHER("Wither", Enemies.ENEMY, EntityType.WITHER),
     BAT("Bat", Enemies.FRIENDLY, EntityType.BAT),
     WITCH("Witch", Enemies.ENEMY, EntityType.WITCH),
-    BOAT("Boat", Enemies.NEUTRAL, EntityType.BOAT),
+    BOAT("Boat", Enemies.NEUTRAL, MobCompat.OAK_BOAT),
+    ACACIA_BOAT("AcaciaBoat", Enemies.NEUTRAL, "ACACIA_BOAT"),
+    DARK_OAK_BOAT("DarkOakBoat", Enemies.NEUTRAL, "DARK_OAK_BOAT"),
+    BIRCH_BOAT("BirchBoat", Enemies.NEUTRAL, "BIRCH_BOAT"),
+    JUNGLE_BOAT("JungleBoat", Enemies.NEUTRAL, "JUNGLE_BOAT"),
+    SPRUCE_BOAT("SpruceBoat", Enemies.NEUTRAL, "SPRUCE_BOAT"),
+    MANGROVE_BOAT("MangroveBoat", Enemies.NEUTRAL, "MANGROVE_BOAT"),
+    CHERRY_BOAT("CherryBoat", Enemies.NEUTRAL, "CHERRY_BOAT"),
+    BAMBOO_RAFT("BambooRaft", Enemies.NEUTRAL, "BAMBOO_RAFT"),
+    PALE_OAK_BOAT("PaleOakBoat", Enemies.NEUTRAL, "PALE_OAK_BOAT"),
+    POPLAR_BOAT("PoplarBoat", Enemies.NEUTRAL, "POPLAR_BOAT"),
     MINECART("Minecart", Enemies.NEUTRAL, EntityType.MINECART),
-    MINECART_CHEST("ChestMinecart", Enemies.NEUTRAL, EntityType.MINECART_CHEST),
-    MINECART_FURNACE("FurnaceMinecart", Enemies.NEUTRAL, EntityType.MINECART_FURNACE),
-    MINECART_TNT("TNTMinecart", Enemies.NEUTRAL, EntityType.MINECART_TNT),
-    MINECART_HOPPER("HopperMinecart", Enemies.NEUTRAL, EntityType.MINECART_HOPPER),
-    MINECART_MOB_SPAWNER("SpawnerMinecart", Enemies.NEUTRAL, EntityType.MINECART_MOB_SPAWNER),
-    ENDERCRYSTAL("EnderCrystal", Enemies.NEUTRAL, EntityType.ENDER_CRYSTAL),
+    MINECART_CHEST("ChestMinecart", Enemies.NEUTRAL, MobCompat.CHEST_MINECART),
+    MINECART_FURNACE("FurnaceMinecart", Enemies.NEUTRAL, MobCompat.FURNACE_MINECART),
+    MINECART_TNT("TNTMinecart", Enemies.NEUTRAL, MobCompat.TNT_MINECART),
+    MINECART_HOPPER("HopperMinecart", Enemies.NEUTRAL, MobCompat.HOPPER_MINECART),
+    MINECART_MOB_SPAWNER("SpawnerMinecart", Enemies.NEUTRAL, MobCompat.SPAWNER_MINECART),
+    ENDERCRYSTAL("EnderCrystal", Enemies.NEUTRAL, MobCompat.END_CRYSTAL),
     EXPERIENCEORB("ExperienceOrb", Enemies.NEUTRAL, "EXPERIENCE_ORB"),
     ARMOR_STAND("ArmorStand", Enemies.NEUTRAL, "ARMOR_STAND"),
     ENDERMITE("Endermite", Enemies.ENEMY, "ENDERMITE"),
@@ -105,9 +115,37 @@ public enum Mob {
     AXOLOTL("Axolotl", Enemies.FRIENDLY, "AXOLOTL"),
     GOAT("Goat", Enemies.NEUTRAL, "GOAT"),
     GLOW_SQUID("GlowSquid", Enemies.FRIENDLY, "GLOW_SQUID"),
+    ALLAY("Allay", Enemies.FRIENDLY, "ALLAY"),
+    FROG("Frog", Enemies.FRIENDLY, "FROG"),
+    TADPOLE("Tadpole", Enemies.FRIENDLY, "TADPOLE"),
+    WARDEN("Warden", Enemies.ENEMY, "WARDEN"),
+    CHEST_BOAT("ChestBoat", Enemies.NEUTRAL, MobCompat.OAK_CHEST_BOAT),
+    ACACIA_CHEST_BOAT("AcaciaChestBoat", Enemies.NEUTRAL, "ACACIA_CHEST_BOAT"),
+    DARK_OAK_CHEST_BOAT("DarkOakChestBoat", Enemies.NEUTRAL, "DARK_OAK_CHEST_BOAT"),
+    BIRCH_CHEST_BOAT("BirchChestBoat", Enemies.NEUTRAL, "BIRCH_CHEST_BOAT"),
+    JUNGLE_CHEST_BOAT("JungleChestBoat", Enemies.NEUTRAL, "JUNGLE_CHEST_BOAT"),
+    SPRUCE_CHEST_BOAT("SpruceChestBoat", Enemies.NEUTRAL, "SPRUCE_CHEST_BOAT"),
+    MANGROVE_CHEST_BOAT("MangroveChestBoat", Enemies.NEUTRAL, "MANGROVE_CHEST_BOAT"),
+    CHERRY_CHEST_BOAT("CherryChestBoat", Enemies.NEUTRAL, "CHERRY_CHEST_BOAT"),
+    BAMBOO_CHEST_RAFT("BambooChestRaft", Enemies.NEUTRAL, "BAMBOO_CHEST_RAFT"),
+    PALE_OAK_CHEST_BOAT("PaleOakChestBoat", Enemies.NEUTRAL, "PALE_OAK_CHEST_BOAT"),
+    POPLAR_CHEST_BOAT("PoplarChestBoat", Enemies.NEUTRAL, "POPLAR_CHEST_BOAT"),
+    CAMEL("Camel", Enemies.FRIENDLY, "CAMEL"),
+    SNIFFER("Sniffer", Enemies.FRIENDLY, "SNIFFER"),
+    ARMADILLO("Armadillo", Enemies.FRIENDLY, "ARMADILLO"),
+    BREEZE("Breeze", Enemies.ENEMY, "BREEZE"),
+    BOGGED("Bogged", Enemies.ENEMY, "BOGGED"),
+    CREAKING("Creaking", Enemies.ENEMY, "CREAKING"),
+    HAPPY_GHAST("HappyGhast", Enemies.FRIENDLY, "HAPPY_GHAST"),
+    COPPER_GOLEM("CopperGolem", Enemies.FRIENDLY, "COPPER_GOLEM"),
+    CAMEL_HUSK("CamelHusk", Enemies.NEUTRAL, "CAMEL_HUSK"),
+    NAUTILUS("Nautilus", Enemies.NEUTRAL, "NAUTILUS"),
+    ZOMBIE_NAUTILUS("ZombieNautilus", Enemies.NEUTRAL, "ZOMBIE_NAUTILUS"),
+    PARCHED("Parched", Enemies.ENEMY, "PARCHED"),
+    SULFUR_CUBE("SulfurCube", Enemies.FRIENDLY, "SULFUR_CUBE"),
+    CUSHION("Cushion", Enemies.FRIENDLY, "CUSHION")
     ;
 
-    public static final Logger logger = Logger.getLogger("Essentials");
     private static final Map<String, Mob> hashMap = new HashMap<>();
     private static final Map<EntityType, Mob> bukkitMap = new HashMap<>();
 
@@ -166,7 +204,7 @@ public enum Mob {
     public Entity spawn(final World world, final Server server, final Location loc) throws MobException {
         final Entity entity = world.spawn(loc, this.bukkitType.getEntityClass());
         if (entity == null) {
-            logger.log(Level.WARNING, tl("unableToSpawnMob"));
+            Essentials.getWrappedLogger().log(Level.WARNING, AdventureUtil.getAdventureFacet().miniToLegacy(tlLiteral("unableToSpawnMob")));
             throw new MobException();
         }
         return entity;

Essentials/src/main/java/com/earth2me/essentials/MobCompat.java

@@ -1,20 +1,38 @@
 package com.earth2me.essentials;
 
 import com.earth2me.essentials.utils.EnumUtil;
+import com.earth2me.essentials.utils.RegistryUtil;
 import com.earth2me.essentials.utils.VersionUtil;
 import net.ess3.nms.refl.ReflUtil;
+import org.bukkit.Material;
+import org.bukkit.TreeSpecies;
+import org.bukkit.entity.AbstractNautilus;
 import org.bukkit.entity.Axolotl;
+import org.bukkit.entity.Boat;
+import org.bukkit.entity.Camel;
+import org.bukkit.entity.Chicken;
+import org.bukkit.entity.Cow;
 import org.bukkit.entity.Entity;
 import org.bukkit.entity.EntityType;
 import org.bukkit.entity.Fox;
+import org.bukkit.entity.Frog;
 import org.bukkit.entity.Llama;
 import org.bukkit.entity.MushroomCow;
 import org.bukkit.entity.Ocelot;
 import org.bukkit.entity.Panda;
 import org.bukkit.entity.Parrot;
+import org.bukkit.entity.Pig;
+import org.bukkit.entity.Player;
+import org.bukkit.entity.Salmon;
 import org.bukkit.entity.TropicalFish;
 import org.bukkit.entity.Villager;
+import org.bukkit.entity.Wolf;
+import org.bukkit.entity.ZombieNautilus;
+import org.bukkit.inventory.ItemStack;
 
+import java.lang.invoke.MethodHandle;
+import java.lang.invoke.MethodHandles;
+import java.lang.invoke.MethodType;
 import java.lang.reflect.Method;
 
 import static com.earth2me.essentials.utils.EnumUtil.getEntityType;
@@ -22,8 +40,21 @@ import static com.earth2me.essentials.utils.EnumUtil.getEntityType;
 public final class MobCompat {
 
     // Constants for mob interfaces added in later versions
-    @SuppressWarnings("rawtypes")
-    public static final Class RAIDER = ReflUtil.getClassCached("org.bukkit.entity.Raider");
+    public static final Class<?> RAIDER = ReflUtil.getClassCached("org.bukkit.entity.Raider");
+
+    // Stupid hacks to avoid Commodore rewrites.
+    private static final Class<?> COW = ReflUtil.getClassCached("org.bukkit.entity.Cow");
+    private static final Class<?> COW_VARIANT = ReflUtil.getClassCached("org.bukkit.entity.Cow$Variant");
+    private static final MethodHandle COW_VARIANT_HANDLE;
+
+    static {
+        MethodHandle handle = null;
+        try {
+            handle = MethodHandles.lookup().findVirtual(COW, "setVariant", MethodType.methodType(void.class, COW_VARIANT));
+        } catch (final Throwable ignored) {
+        }
+        COW_VARIANT_HANDLE = handle;
+    }
 
     // Constants for mobs added in later versions
     public static final EntityType LLAMA = getEntityType("LLAMA");
@@ -37,10 +68,27 @@ public final class MobCompat {
     public static final EntityType PHANTOM = getEntityType("PHANTOM");
     public static final EntityType AXOLOTL = getEntityType("AXOLOTL");
     public static final EntityType GOAT = getEntityType("GOAT");
+    public static final EntityType FROG = getEntityType("FROG");
+    public static final EntityType CAMEL = getEntityType("CAMEL");
+    public static final EntityType SALMON = getEntityType("SALMON");
+    public static final EntityType CAMEL_HUSK = getEntityType("CAMEL_HUSK");
+    public static final EntityType NAUTILUS = getEntityType("NAUTILUS");
+    public static final EntityType ZOMBIE_NAUTILUS = getEntityType("ZOMBIE_NAUTILUS");
 
     // Constants for mobs that have changed since earlier versions
     public static final EntityType CAT = getEntityType("CAT", "OCELOT");
     public static final EntityType ZOMBIFIED_PIGLIN = getEntityType("ZOMBIFIED_PIGLIN", "PIG_ZOMBIE");
+    public static final EntityType MOOSHROOM = getEntityType("MOOSHROOM", "MUSHROOM_COW");
+    public static final EntityType SNOW_GOLEM = getEntityType("SNOW_GOLEM", "SNOWMAN");
+    public static final EntityType CHEST_MINECART = getEntityType("CHEST_MINECART", "MINECART_CHEST");
+    public static final EntityType FURNACE_MINECART = getEntityType("FURNACE_MINECART", "MINECART_FURNACE");
+    public static final EntityType TNT_MINECART = getEntityType("TNT_MINECART", "MINECART_TNT");
+    public static final EntityType HOPPER_MINECART = getEntityType("HOPPER_MINECART", "MINECART_HOPPER");
+    public static final EntityType SPAWNER_MINECART = getEntityType("SPAWNER_MINECART", "MINECART_MOB_SPAWNER");
+    public static final EntityType END_CRYSTAL = getEntityType("END_CRYSTAL", "ENDER_CRYSTAL");
+    public static final EntityType FIREWORK_ROCKET = getEntityType("FIREWORK_ROCKET", "FIREWORK");
+    public static final EntityType OAK_BOAT = getEntityType("BOAT", "OAK_BOAT");
+    public static final EntityType OAK_CHEST_BOAT = getEntityType("CHEST_BOAT", "OAK_CHEST_BOAT");
 
     private MobCompat() {
     }
@@ -164,6 +212,128 @@ public final class MobCompat {
         }
     }
 
+    public static void setFrogVariant(final Entity entity, final String variant) {
+        if (VersionUtil.getServerBukkitVersion().isLowerThan(VersionUtil.v1_19_R01)) {
+            return;
+        }
+        if (entity instanceof Frog) {
+            ((Frog) entity).setVariant(Frog.Variant.valueOf(variant));
+        }
+    }
+
+    public static void setBoatVariant(final Entity entity, final BoatVariant variant) {
+        if (VersionUtil.getServerBukkitVersion().isHigherThanOrEqualTo(VersionUtil.v1_21_3_R01) || VersionUtil.getServerBukkitVersion().isLowerThan(VersionUtil.v1_9_R01)) {
+            return;
+        }
+        final Boat boat;
+        if (entity instanceof Boat) {
+            boat = (Boat) entity;
+        } else {
+            return;
+        }
+        if (VersionUtil.getServerBukkitVersion().isLowerThan(VersionUtil.v1_19_R01)) {
+            //noinspection deprecation
+            boat.setWoodType(TreeSpecies.valueOf(variant.getTreeSpecies()));
+        } else {
+            //noinspection deprecation
+            boat.setBoatType(Boat.Type.valueOf(variant.getBoatType()));
+        }
+    }
+
+    public static void setCamelSaddle(final Entity entity, final Player target) {
+        if (VersionUtil.getServerBukkitVersion().isLowerThan(VersionUtil.v1_20_1_R01)) {
+            return;
+        }
+
+        if (entity instanceof Camel) {
+            final Camel camel = (Camel) entity;
+            camel.setTamed(true);
+            camel.setOwner(target);
+            camel.getInventory().setSaddle(new ItemStack(Material.SADDLE, 1));
+        }
+    }
+
+    public static void setWolfVariant(final Entity entity, final String variant) {
+        if (VersionUtil.getServerBukkitVersion().isLowerThan(VersionUtil.v1_20_6_R01)) {
+            return;
+        }
+
+        if (entity instanceof Wolf) {
+            final Wolf wolf = (Wolf) entity;
+            //noinspection DataFlowIssue
+            wolf.setVariant(RegistryUtil.valueOf(Wolf.Variant.class, variant));
+        }
+    }
+
+    public static void setSalmonSize(Entity spawned, String s) {
+        if (VersionUtil.getServerBukkitVersion().isLowerThan(VersionUtil.v1_21_3_R01)) {
+            return;
+        }
+
+        if (spawned instanceof org.bukkit.entity.Salmon) {
+            ((Salmon) spawned).setVariant(Salmon.Variant.valueOf(s));
+        }
+    }
+
+    public static void setCowVariant(final Entity spawned, final String variant) {
+        if (VersionUtil.getServerBukkitVersion().isLowerThan(VersionUtil.v1_21_5_R01) || COW_VARIANT_HANDLE == null) {
+            return;
+        }
+
+        if (spawned instanceof Cow) {
+            try {
+                COW_VARIANT_HANDLE.invoke(spawned, RegistryUtil.valueOf(COW_VARIANT, variant));
+            } catch (Throwable ignored) {
+            }
+        }
+    }
+
+    public static void setChickenVariant(final Entity spawned, final String variant) {
+        if (VersionUtil.getServerBukkitVersion().isLowerThan(VersionUtil.v1_21_5_R01)) {
+            return;
+        }
+
+        if (spawned instanceof Chicken) {
+            //noinspection DataFlowIssue
+            ((Chicken) spawned).setVariant(RegistryUtil.valueOf(Chicken.Variant.class, variant));
+        }
+    }
+
+    public static void setPigVariant(final Entity spawned, final String variant) {
+        if (VersionUtil.getServerBukkitVersion().isLowerThan(VersionUtil.v1_21_5_R01)) {
+            return;
+        }
+
+        if (spawned instanceof Pig) {
+            //noinspection DataFlowIssue
+            ((Pig) spawned).setVariant(RegistryUtil.valueOf(Pig.Variant.class, variant));
+        }
+    }
+
+    public static void setZombieNautilusVariant(final Entity spawned, final String variant) {
+        if (VersionUtil.getServerBukkitVersion().isLowerThan(VersionUtil.v1_21_11_R01)) {
+            return;
+        }
+
+        if (spawned instanceof ZombieNautilus) {
+            //noinspection DataFlowIssue
+            ((ZombieNautilus) spawned).setVariant(RegistryUtil.valueOf(ZombieNautilus.Variant.class, variant));
+        }
+    }
+
+    public static void setNautilusSaddle(final Entity entity, final Player target) {
+        if (VersionUtil.getServerBukkitVersion().isLowerThan(VersionUtil.v1_21_11_R01)) {
+            return;
+        }
+
+        if (entity instanceof AbstractNautilus) {
+            final AbstractNautilus nautilus = (AbstractNautilus) entity;
+            nautilus.setTamed(true);
+            nautilus.setOwner(target);
+            nautilus.getInventory().setSaddle(new ItemStack(Material.SADDLE, 1));
+        }
+    }
+
     public enum CatType {
         // These are (loosely) Mojang names for the cats
         SIAMESE("SIAMESE", "SIAMESE_CAT"),
@@ -224,8 +394,39 @@ public final class MobCompat {
         }
 
         private Villager.Profession asEnum() {
-            return EnumUtil.valueOf(Villager.Profession.class, newProfession, oldProfession);
+            return RegistryUtil.valueOf(Villager.Profession.class, newProfession, oldProfession);
         }
     }
 
+    public enum BoatVariant {
+        // Mappings for TreeSpecies names
+        ACACIA("ACACIA", "ACACIA"),
+        BIRCH("BIRCH", "BIRCH"),
+        DARKOAK("DARK_OAK", "DARK_OAK"),
+        GENERIC("GENERIC", "OAK"),
+        JUNGLE("JUNGLE", "JUNGLE"),
+        REDWOOD("REDWOOD", "SPRUCE"),
+        // Mappings for Boat.Type names (falling back to GENERIC where undefined)
+        OAK("GENERIC", "OAK"),
+        SPRUCE("REDWOOD", "SPRUCE"),
+        MANGROVE("GENERIC", "MANGROVE"),
+        POPLAR("GENERIC", "POPLAR"),
+        ;
+
+        private final String treeSpecies;
+        private final String boatType;
+
+        BoatVariant(final String treeSpecies, final String boatType) {
+            this.treeSpecies = treeSpecies;
+            this.boatType = boatType;
+        }
+
+        public String getTreeSpecies() {
+            return treeSpecies;
+        }
+
+        public String getBoatType() {
+            return boatType;
+        }
+    }
 }

Essentials/src/main/java/com/earth2me/essentials/MobData.java

@@ -1,13 +1,16 @@
 package com.earth2me.essentials;
 
-import com.earth2me.essentials.craftbukkit.InventoryWorkaround;
+import com.earth2me.essentials.craftbukkit.Inventories;
 import com.earth2me.essentials.utils.EnumUtil;
 import com.earth2me.essentials.utils.StringUtil;
 import com.earth2me.essentials.utils.VersionUtil;
+import net.ess3.api.TranslatableException;
 import org.bukkit.DyeColor;
 import org.bukkit.Material;
 import org.bukkit.entity.Ageable;
+import org.bukkit.entity.Boat;
 import org.bukkit.entity.ChestedHorse;
+import org.bukkit.entity.Chicken;
 import org.bukkit.entity.Creeper;
 import org.bukkit.entity.Entity;
 import org.bukkit.entity.EntityType;
@@ -35,11 +38,8 @@ import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Locale;
 import java.util.Random;
-import java.util.logging.Logger;
 import java.util.stream.Collectors;
 
-import static com.earth2me.essentials.I18n.tl;
-
 public enum MobData {
 
     BABY_AGEABLE("baby", Ageable.class, Data.BABY, true),
@@ -55,8 +55,8 @@ public enum MobData {
     BABY_VILLAGER("child", EntityType.VILLAGER, Data.BABY, false),
     TAMED_TAMEABLE("tamed", Tameable.class, Data.TAMED, true),
     TAME_TAMEABLE("tame", Tameable.class, Data.TAMED, false),
-    RANDOM_SHEEP("random", EntityType.SHEEP, Data.COLORABLE, true),
-    COLORABLE_SHEEP("", Arrays.stream(DyeColor.values()).map(color -> color.name().toLowerCase(Locale.ENGLISH)).collect(Collectors.toList()), EntityType.SHEEP, Data.COLORABLE, true),
+    RANDOM_COLORABLE("random", Colorable.class, Data.COLORABLE, true),
+    COLORABLE("", Arrays.stream(DyeColor.values()).map(color -> color.name().toLowerCase(Locale.ENGLISH)).collect(Collectors.toList()), Colorable.class, Data.COLORABLE, true),
     POLKA_HORSE("polka", EntityType.HORSE, Horse.Style.BLACK_DOTS, true),
     SOOTY_HORSE("sooty", EntityType.HORSE, Horse.Style.BLACK_DOTS, false),
     BLAZE_HORSE("blaze", EntityType.HORSE, Horse.Style.WHITE, true),
@@ -82,6 +82,7 @@ public enum MobData {
     SADDLE_HORSE("saddle", EntityType.HORSE, Data.HORSESADDLE, true),
     GOLD_ARMOR_HORSE("goldarmor", EntityType.HORSE, EnumUtil.getMaterial("GOLDEN_HORSE_ARMOR", "GOLD_BARDING"), true),
     DIAMOND_ARMOR_HORSE("diamondarmor", EntityType.HORSE, EnumUtil.getMaterial("DIAMOND_HORSE_ARMOR", "DIAMOND_BARDING"), true),
+    NETHERITE_HORSE_ARMOR("netheritearmor", EntityType.HORSE, EnumUtil.getMaterial("NETHERITE_HORSE_ARMOR"), true),
     ARMOR_HORSE("armor", EntityType.HORSE, EnumUtil.getMaterial("IRON_HORSE_ARMOR", "IRON_BARDING"), true),
     SIAMESE_CAT("siamese", MobCompat.CAT, MobCompat.CatType.SIAMESE, true),
     WHITE_CAT("white", MobCompat.CAT, MobCompat.CatType.WHITE, false),
@@ -158,8 +159,8 @@ public enum MobData {
     BLOCKFISH_TROPICAL_FISH("blockfish", MobCompat.TROPICAL_FISH, "tropicalfish:BLOCKFISH", true),
     BETTY_TROPICAL_FISH("betty", MobCompat.TROPICAL_FISH, "tropicalfish:BETTY", true),
     CLAYFISH_TROPICAL_FISH("clayfish", MobCompat.TROPICAL_FISH, "tropicalfish:CLAYFISH", true),
-    BROWN_MUSHROOM_COW("brown", EntityType.MUSHROOM_COW, "mooshroom:BROWN", true),
-    RED_MUSHROOM_COW("red", EntityType.MUSHROOM_COW, "mooshroom:RED", true),
+    BROWN_MUSHROOM_COW("brown", MobCompat.MOOSHROOM, "mooshroom:BROWN", true),
+    RED_MUSHROOM_COW("red", MobCompat.MOOSHROOM, "mooshroom:RED", true),
     AGGRESSIVE_PANDA_MAIN("aggressive", MobCompat.PANDA, "pandamain:AGGRESSIVE", true),
     LAZY_PANDA_MAIN("lazy", MobCompat.PANDA, "pandamain:LAZY", true),
     WORRIED_PANDA_MAIN("worried", MobCompat.PANDA, "pandamain:WORRIED", true),
@@ -180,8 +181,6 @@ public enum MobData {
     WHITE_TRADER_LLAMA("white", MobCompat.TRADER_LLAMA, "llama:WHITE", true),
     BROWN_TRADER_LLAMA("brown", MobCompat.TRADER_LLAMA, "llama:BROWN", true),
     GRAY_TRADER_LLAMA("gray", MobCompat.TRADER_LLAMA, "llama:GRAY", true),
-    RANDOM_SHULKER("random", MobCompat.SHULKER, Data.COLORABLE, true),
-    COLORABLE_SHULKER("", Arrays.stream(DyeColor.values()).map(color -> color.name().toLowerCase(Locale.ENGLISH)).collect(Collectors.toList()), MobCompat.SHULKER, Data.COLORABLE, true),
     RED_FOX("red", MobCompat.FOX, "fox:RED", true),
     SNOW_FOX("snow", MobCompat.FOX, "fox:SNOW", true),
     SIZE_PHANTOM("", Collections.singletonList("<1-100>"), MobCompat.PHANTOM, Data.SIZE, true),
@@ -197,9 +196,48 @@ public enum MobData {
     CYAN_AXOLOTL("cyan", MobCompat.AXOLOTL, "axolotl:CYAN", true),
     BLUE_AXOLOTL("blue", MobCompat.AXOLOTL, "axolotl:BLUE", true),
     SCREAMING_GOAT("screaming", MobCompat.GOAT, Data.GOAT_SCREAMING, true),
+    TEMPERATE_FROG("temperate", MobCompat.FROG, "frog:TEMPERATE", true),
+    WARM_FROG("warm", MobCompat.FROG, "frog:WARM", true),
+    COLD_FROG("cold", MobCompat.FROG, "frog:COLD", true),
+    ACACIA_BOAT("acacia", Boat.class, MobCompat.BoatVariant.ACACIA, true),
+    BIRCH_BOAT("birch", Boat.class, MobCompat.BoatVariant.BIRCH, true),
+    DARK_OAK_BOAT("darkoak", Boat.class, MobCompat.BoatVariant.DARKOAK, true),
+    GENERIC_BOAT("generic", Boat.class, MobCompat.BoatVariant.GENERIC, true),
+    JUNGLE_BOAT("jungle", Boat.class, MobCompat.BoatVariant.JUNGLE, true),
+    REDWOOD_BOAT("redwood", Boat.class, MobCompat.BoatVariant.REDWOOD, true),
+    MANGROVE_BOAT("mangrove", Boat.class, MobCompat.BoatVariant.MANGROVE, true),
+    POPLAR_BOAT("poplar", Boat.class, MobCompat.BoatVariant.POPLAR, true),
+    OAK_BOAT("oak", Boat.class, MobCompat.BoatVariant.OAK, true),
+    SPRUCE_BOAT("spruce", Boat.class, MobCompat.BoatVariant.SPRUCE, true),
+    SADDLE_CAMEL("saddle", MobCompat.CAMEL, Data.CAMELSADDLE, true),
+    PALE_WOLF("pale", EntityType.WOLF, "wolf:PALE", true),
+    SPOTTED_WOLF("spotted", EntityType.WOLF, "wolf:SPOTTED", true),
+    SNOWY_WOLF("snowy", EntityType.WOLF, "wolf:SNOWY", true),
+    BLACK_WOLF("black", EntityType.WOLF, "wolf:BLACK", true),
+    ASHEN_WOLF("ashen", EntityType.WOLF, "wolf:ASHEN", true),
+    RUSTY_WOLF("rusty", EntityType.WOLF, "wolf:RUSTY", true),
+    WOODS_WOLF("woods", EntityType.WOLF, "wolf:WOODS", true),
+    CHESTNUT_WOLF("chestnut", EntityType.WOLF, "wolf:CHESTNUT", true),
+    STRIPED_WOLF("striped", EntityType.WOLF, "wolf:STRIPED", true),
+    SMALL_SALMON("small", MobCompat.SALMON, "salmon:SMALL", true),
+    MEDIUM_SALMON("medium", MobCompat.SALMON, "salmon:MEDIUM", true),
+    LARGE_SALMON("large", MobCompat.SALMON, "salmon:LARGE", true),
+    TEMPERATE_COW("temperate", EntityType.COW.getEntityClass(), "cow:TEMPERATE", true),
+    WARM_COW("warm", EntityType.COW.getEntityClass(), "cow:WARM", true),
+    COLD_COW("cold", EntityType.COW.getEntityClass(), "cow:COLD", true),
+    TEMPERATE_CHICKEN("temperate", Chicken.class, "chicken:TEMPERATE", true),
+    WARM_CHICKEN("warm", Chicken.class, "chicken:WARM", true),
+    COLD_CHICKEN("cold", Chicken.class, "chicken:COLD", true),
+    TEMPERATE_PIG("temperate", Pig.class, "pig:TEMPERATE", true),
+    WARM_PIG("warm", Pig.class, "pig:WARM", true),
+    COLD_PIG("cold", Pig.class, "pig:COLD", true),
+    SADDLE_CAMEL_HUSK("saddle", MobCompat.CAMEL_HUSK, Data.CAMELHUSKSADDLE, true),
+    TEMPERATE_ZOMBIE_NAUTILUS("temperate", MobCompat.ZOMBIE_NAUTILUS, "zombienautilus:TEMPERATE", true),
+    WARM_ZOMBIE_NAUTILUS("warm", MobCompat.ZOMBIE_NAUTILUS, "zombienautilus:WARM", true),
+    SADDLE_NAUTILUS("saddle", MobCompat.NAUTILUS, Data.NAUTILUSSADDLE, true),
+    SADDLE_ZOMBIE_NAUTILUS("saddle", MobCompat.ZOMBIE_NAUTILUS, Data.NAUTILUSSADDLE, true)
     ;
 
-    public static final Logger logger = Logger.getLogger("Essentials");
     final private String nickname;
     final private List<String> suggestions;
     final private Object type;
@@ -316,14 +354,14 @@ public enum MobData {
                 }
                 this.matched = rawData;
             } catch (final Exception e) {
-                throw new Exception(tl("sheepMalformedColor"), e);
+                throw new TranslatableException(e, "sheepMalformedColor");
             }
         } else if (this.value.equals(Data.EXP)) {
             try {
                 ((ExperienceOrb) spawned).setExperience(Integer.parseInt(rawData));
                 this.matched = rawData;
             } catch (final NumberFormatException e) {
-                throw new Exception(tl("invalidNumber"), e);
+                throw new TranslatableException(e, "invalidNumber");
             }
         } else if (this.value.equals(Data.SIZE)) {
             try {
@@ -335,7 +373,7 @@ public enum MobData {
                 }
                 this.matched = rawData;
             } catch (final NumberFormatException e) {
-                throw new Exception(tl("slimeMalformedSize"), e);
+                throw new TranslatableException(e, "slimeMalformedSize");
             }
         } else if (this.value instanceof Horse.Color) {
             ((Horse) spawned).setColor((Horse.Color) this.value);
@@ -351,8 +389,8 @@ public enum MobData {
                 ((Horse) spawned).getInventory().setArmor(new ItemStack((Material) this.value, 1));
             } else if (this.type.equals(EntityType.ZOMBIE.getEntityClass()) || this.type.equals(EntityType.SKELETON)) {
                 final EntityEquipment invent = ((LivingEntity) spawned).getEquipment();
-                InventoryWorkaround.setItemInMainHand(invent, new ItemStack((Material) this.value, 1));
-                InventoryWorkaround.setItemInMainHandDropChance(invent, 0.1f);
+                Inventories.setItemInMainHand(invent, new ItemStack((Material) this.value, 1));
+                Inventories.setItemInMainHandDropChance(invent, 0.1f);
             }
         } else if (this.value.equals(Data.RAID_LEADER)) {
             ((Raider) spawned).setPatrolLeader(true);
@@ -376,6 +414,16 @@ public enum MobData {
             }
         } else if (this.value.equals(Data.GOAT_SCREAMING)) {
             ((Goat) spawned).setScreaming(true);
+        } else if (this.value.equals(Data.CAMELSADDLE)) {
+            MobCompat.setCamelSaddle(spawned, target);
+        } else if (this.value.equals(Data.CAMELHUSKSADDLE)) {
+            MobCompat.setCamelSaddle(spawned, target);
+        } else if (this.value.equals(Data.NAUTILUSSADDLE)) {
+            MobCompat.setNautilusSaddle(spawned, target);
+        } else if (this.value.equals(Data.ZOMBIENAUTILUSSADDLE)) {
+            MobCompat.setNautilusSaddle(spawned, target);
+        } else if (this.value instanceof MobCompat.BoatVariant) {
+            MobCompat.setBoatVariant(spawned, (MobCompat.BoatVariant) this.value);
         } else if (this.value instanceof String) {
             final String[] split = ((String) this.value).split(":");
             switch (split[0]) {
@@ -403,13 +451,33 @@ public enum MobData {
                 case "fox":
                     MobCompat.setFoxType(spawned, split[1]);
                     break;
-                case "axolotl": {
+                case "axolotl":
                     MobCompat.setAxolotlVariant(spawned, split[1]);
                     break;
-                }
+                case "frog":
+                    MobCompat.setFrogVariant(spawned, split[1]);
+                    break;
+                case "wolf":
+                    MobCompat.setWolfVariant(spawned, split[1]);
+                    break;
+                case "salmon":
+                    MobCompat.setSalmonSize(spawned, split[1]);
+                    break;
+                case "cow":
+                    MobCompat.setCowVariant(spawned, split[1]);
+                    break;
+                case "chicken":
+                    MobCompat.setChickenVariant(spawned, split[1]);
+                    break;
+                case "pig":
+                    MobCompat.setPigVariant(spawned, split[1]);
+                    break;
+                case "zombienautilus":
+                    MobCompat.setZombieNautilusVariant(spawned, split[1]);
+                    break;
             }
         } else {
-            logger.warning("Unknown mob data type: " + this.toString());
+            Essentials.getWrappedLogger().warning("Unknown mob data type: " + this.toString());
         }
     }
 
@@ -431,5 +499,9 @@ public enum MobData {
         FISH_BODY_COLOR,
         FISH_PATTERN_COLOR,
         GOAT_SCREAMING,
+        CAMELSADDLE,
+        CAMELHUSKSADDLE,
+        NAUTILUSSADDLE,
+        ZOMBIENAUTILUSSADDLE,
     }
 }

Essentials/src/main/java/com/earth2me/essentials/PlayerExtension.java

@@ -1,6 +1,7 @@
 package com.earth2me.essentials;
 
 import org.bukkit.Location;
+import org.bukkit.OfflinePlayer;
 import org.bukkit.Server;
 import org.bukkit.World;
 import org.bukkit.entity.Player;
@@ -31,4 +32,11 @@ public class PlayerExtension {
     public Location getLocation() {
         return base.getLocation();
     }
+
+    public OfflinePlayer getOffline() {
+        if (base instanceof OfflinePlayerStub) {
+            return ((OfflinePlayerStub) base).base;
+        }
+        return base;
+    }
 }

Essentials/src/main/java/com/earth2me/essentials/PlayerList.java

@@ -2,7 +2,7 @@ package com.earth2me.essentials;
 
 import com.earth2me.essentials.utils.FormatUtil;
 import com.earth2me.essentials.utils.NumberUtil;
-import org.bukkit.ChatColor;
+import net.ess3.api.TranslatableException;
 import org.bukkit.Server;
 
 import java.util.ArrayList;
@@ -14,7 +14,7 @@ import java.util.Locale;
 import java.util.Map;
 import java.util.Set;
 
-import static com.earth2me.essentials.I18n.tl;
+import static com.earth2me.essentials.I18n.tlLiteral;
 
 public final class PlayerList {
 
@@ -32,19 +32,19 @@ public final class PlayerList {
             }
             needComma = true;
             if (user.isAfk()) {
-                groupString.append(tl("listAfkTag"));
+                groupString.append(tlLiteral("listAfkTag"));
             }
             if (user.isHidden()) {
-                groupString.append(tl("listHiddenTag"));
+                groupString.append(tlLiteral("listHiddenTag"));
             }
             user.setDisplayNick();
-            groupString.append(user.getDisplayName());
+            groupString.append(ess.getAdventureFacet().legacyToMini(user.getDisplayName()));
 
             final String strippedNick = FormatUtil.stripFormat(user.getNickname());
             if (ess.getSettings().realNamesOnList() && strippedNick != null && !strippedNick.equals(user.getName())) {
-                groupString.append(" ").append(tl("listRealName",user.getName()));
+                groupString.append(" ").append(tlLiteral("listRealName",user.getName()));
             }
-            groupString.append(ChatColor.WHITE.toString());
+            groupString.append("<white>");
         }
         return groupString.toString();
     }
@@ -55,27 +55,31 @@ public final class PlayerList {
         int playerHidden = 0;
         int hiddenCount = 0;
         for (final User onlinePlayer : ess.getOnlineUsers()) {
-            if (onlinePlayer.isHidden() || (user != null && !user.getBase().canSee(onlinePlayer.getBase()))) {
+            if (onlinePlayer.isHidden() || (user != null && onlinePlayer.isHiddenFrom(user.getBase()))) {
                 playerHidden++;
-                if (showHidden || user != null && user.getBase().canSee(onlinePlayer.getBase())) {
+                if (showHidden || user != null && !onlinePlayer.isHiddenFrom(user.getBase())) {
                     hiddenCount++;
                 }
             }
         }
-        final String online;
+
+        final String tlKey;
+        final Object[] objects;
         if (hiddenCount > 0) {
-            online = tl("listAmountHidden", ess.getOnlinePlayers().size() - playerHidden, hiddenCount, server.getMaxPlayers());
+            tlKey = "listAmountHidden";
+            objects = new Object[]{ess.getOnlinePlayers().size() - playerHidden, hiddenCount, server.getMaxPlayers()};
         } else {
-            online = tl("listAmount", ess.getOnlinePlayers().size() - playerHidden, server.getMaxPlayers());
+            tlKey = "listAmount";
+            objects = new Object[]{ess.getOnlinePlayers().size() - playerHidden, server.getMaxPlayers()};
         }
-        return online;
+        return user == null ? tlLiteral(tlKey, objects) : user.playerTl(tlKey, objects);
     }
 
     // Build the basic player list, divided by groups.
     public static Map<String, List<User>> getPlayerLists(final IEssentials ess, final IUser sender, final boolean showHidden) {
         final Map<String, List<User>> playerList = new HashMap<>();
         for (final User onlineUser : ess.getOnlineUsers()) {
-            if ((sender == null && !showHidden && onlineUser.isHidden()) || (sender != null && !showHidden && !sender.getBase().canSee(onlineUser.getBase()))) {
+            if ((sender == null && !showHidden && onlineUser.isHidden()) || (sender != null && !showHidden && onlineUser.isHiddenFrom(sender.getBase()))) {
                 continue;
             }
             final String group = FormatUtil.stripFormat(FormatUtil.stripEssentialsFormat(onlineUser.getGroup().toLowerCase()));
@@ -117,7 +121,7 @@ public final class PlayerList {
             users.addAll(groupUsers);
         }
         if (users.isEmpty()) {
-            throw new Exception(tl("groupDoesNotExist"));
+            throw new TranslatableException("groupDoesNotExist");
         }
         final String displayGroupName = Character.toTitleCase(groupName.charAt(0)) +
             groupName.substring(1);
@@ -126,11 +130,11 @@ public final class PlayerList {
 
     // Build the output string
     public static String outputFormat(final String group, final String message) {
-        return tl("listGroupTag", FormatUtil.replaceFormat(group)) +
+        return tlLiteral("listGroupTag", FormatUtil.replaceFormat(group)) +
             message;
     }
 
-    public static List<String> prepareGroupedList(final IEssentials ess, final String commandLabel, final Map<String, List<User>> playerList) {
+    public static List<String> prepareGroupedList(final IEssentials ess, final CommandSource source, final String commandLabel, final Map<String, List<User>> playerList) {
         final List<String> output = new ArrayList<>();
 
         final Set<String> configGroups = ess.getSettings().getListGroupConfig().keySet();
@@ -163,7 +167,9 @@ public final class PlayerList {
                     outputUserList = new ArrayList<>(matchedList);
                     final int limit = Integer.parseInt(groupValue);
                     if (matchedList.size() > limit) {
-                        output.add(outputFormat(oConfigGroup, tl("groupNumber", matchedList.size(), commandLabel, FormatUtil.stripFormat(configGroup))));
+                        final String tlKey = "groupNumber";
+                        final Object[] objects = {matchedList.size(), commandLabel, FormatUtil.stripFormat(configGroup)};
+                        output.add(outputFormat(oConfigGroup, source == null ? tlLiteral(tlKey, objects) : source.tl(tlKey, objects)));
                     } else {
                         output.add(outputFormat(oConfigGroup, listUsers(ess, outputUserList, ", ")));
                     }
@@ -203,7 +209,7 @@ public final class PlayerList {
             String groupName = asterisk.isEmpty() ? users.get(0).getGroup() : onlineGroup;
 
             if (ess.getPermissionsHandler().getName().equals("ConfigPermissions")) {
-                groupName = tl("connectedPlayers");
+                groupName = source == null ? tlLiteral("connectedPlayers") : source.tl("connectedPlayers");
             }
             if (users == null || users.isEmpty()) {
                 continue;

Essentials/src/main/java/com/earth2me/essentials/PlayerTarget.java

@@ -4,15 +4,17 @@ import org.bukkit.Bukkit;
 import org.bukkit.Location;
 import org.bukkit.entity.Player;
 
+import java.util.UUID;
+
 public class PlayerTarget implements ITarget {
-    private final String name;
+    private final UUID uuid;
 
     public PlayerTarget(final Player entity) {
-        this.name = entity.getName();
+        this.uuid = entity.getUniqueId();
     }
 
     @Override
     public Location getLocation() {
-        return Bukkit.getServer().getPlayerExact(name).getLocation();
+        return Bukkit.getPlayer(uuid).getLocation();
     }
 }

Essentials/src/main/java/com/earth2me/essentials/Potions.java

@@ -1,6 +1,7 @@
 package com.earth2me.essentials;
 
 import com.earth2me.essentials.utils.NumberUtil;
+import com.earth2me.essentials.utils.RegistryUtil;
 import org.bukkit.potion.PotionEffectType;
 
 import java.util.HashMap;
@@ -21,50 +22,68 @@ public final class Potions {
         ALIASPOTIONS.put("sprint", PotionEffectType.SPEED);
         ALIASPOTIONS.put("swift", PotionEffectType.SPEED);
 
-        POTIONS.put("slowness", PotionEffectType.SLOW);
-        ALIASPOTIONS.put("slow", PotionEffectType.SLOW);
-        ALIASPOTIONS.put("sluggish", PotionEffectType.SLOW);
+        final PotionEffectType SLOWNESS = RegistryUtil.valueOf(PotionEffectType.class, "SLOW", "SLOWNESS");
 
-        POTIONS.put("haste", PotionEffectType.FAST_DIGGING);
-        ALIASPOTIONS.put("superpick", PotionEffectType.FAST_DIGGING);
-        ALIASPOTIONS.put("quickmine", PotionEffectType.FAST_DIGGING);
-        ALIASPOTIONS.put("digspeed", PotionEffectType.FAST_DIGGING);
-        ALIASPOTIONS.put("digfast", PotionEffectType.FAST_DIGGING);
-        ALIASPOTIONS.put("sharp", PotionEffectType.FAST_DIGGING);
+        POTIONS.put("slowness", SLOWNESS);
+        ALIASPOTIONS.put("slow", SLOWNESS);
+        ALIASPOTIONS.put("sluggish", SLOWNESS);
 
-        POTIONS.put("fatigue", PotionEffectType.SLOW_DIGGING);
-        ALIASPOTIONS.put("slow", PotionEffectType.SLOW_DIGGING);
-        ALIASPOTIONS.put("dull", PotionEffectType.SLOW_DIGGING);
+        final PotionEffectType HASTE = RegistryUtil.valueOf(PotionEffectType.class, "FAST_DIGGING", "HASTE");
 
-        POTIONS.put("strength", PotionEffectType.INCREASE_DAMAGE);
-        ALIASPOTIONS.put("strong", PotionEffectType.INCREASE_DAMAGE);
-        ALIASPOTIONS.put("bull", PotionEffectType.INCREASE_DAMAGE);
-        ALIASPOTIONS.put("attack", PotionEffectType.INCREASE_DAMAGE);
+        POTIONS.put("haste", HASTE);
+        ALIASPOTIONS.put("superpick", HASTE);
+        ALIASPOTIONS.put("quickmine", HASTE);
+        ALIASPOTIONS.put("digspeed", HASTE);
+        ALIASPOTIONS.put("digfast", HASTE);
+        ALIASPOTIONS.put("sharp", HASTE);
 
-        POTIONS.put("heal", PotionEffectType.HEAL);
-        ALIASPOTIONS.put("healthy", PotionEffectType.HEAL);
-        ALIASPOTIONS.put("instaheal", PotionEffectType.HEAL);
+        final PotionEffectType MINING_FATIGUE = RegistryUtil.valueOf(PotionEffectType.class, "SLOW_DIGGING", "MINING_FATIGUE");
 
-        POTIONS.put("harm", PotionEffectType.HARM);
-        ALIASPOTIONS.put("harming", PotionEffectType.HARM);
-        ALIASPOTIONS.put("injure", PotionEffectType.HARM);
-        ALIASPOTIONS.put("damage", PotionEffectType.HARM);
-        ALIASPOTIONS.put("inflict", PotionEffectType.HARM);
+        POTIONS.put("fatigue", MINING_FATIGUE);
+        ALIASPOTIONS.put("slow", MINING_FATIGUE);
+        ALIASPOTIONS.put("dull", MINING_FATIGUE);
 
-        POTIONS.put("jump", PotionEffectType.JUMP);
-        ALIASPOTIONS.put("leap", PotionEffectType.JUMP);
+        final PotionEffectType STRENGTH = RegistryUtil.valueOf(PotionEffectType.class, "INCREASE_DAMAGE", "STRENGTH");
 
-        POTIONS.put("nausea", PotionEffectType.CONFUSION);
-        ALIASPOTIONS.put("sick", PotionEffectType.CONFUSION);
-        ALIASPOTIONS.put("sickness", PotionEffectType.CONFUSION);
-        ALIASPOTIONS.put("confusion", PotionEffectType.CONFUSION);
+        POTIONS.put("strength", STRENGTH);
+        ALIASPOTIONS.put("strong", STRENGTH);
+        ALIASPOTIONS.put("bull", STRENGTH);
+        ALIASPOTIONS.put("attack", STRENGTH);
+
+        final PotionEffectType INSTANT_HEALTH = RegistryUtil.valueOf(PotionEffectType.class, "HEAL", "INSTANT_HEALTH");
+
+        POTIONS.put("heal", INSTANT_HEALTH);
+        ALIASPOTIONS.put("healthy", INSTANT_HEALTH);
+        ALIASPOTIONS.put("instaheal", INSTANT_HEALTH);
+
+        final PotionEffectType INSTANT_DAMAGE = RegistryUtil.valueOf(PotionEffectType.class, "HARM", "INSTANT_DAMAGE");
+
+        POTIONS.put("harm", INSTANT_DAMAGE);
+        ALIASPOTIONS.put("harming", INSTANT_DAMAGE);
+        ALIASPOTIONS.put("injure", INSTANT_DAMAGE);
+        ALIASPOTIONS.put("damage", INSTANT_DAMAGE);
+        ALIASPOTIONS.put("inflict", INSTANT_DAMAGE);
+
+        final PotionEffectType JUMP_BOOST = RegistryUtil.valueOf(PotionEffectType.class, "JUMP", "JUMP_BOOST");
+
+        POTIONS.put("jump", JUMP_BOOST);
+        ALIASPOTIONS.put("leap", JUMP_BOOST);
+
+        final PotionEffectType NAUSEA = RegistryUtil.valueOf(PotionEffectType.class, "CONFUSION", "NAUSEA");
+
+        POTIONS.put("nausea", NAUSEA);
+        ALIASPOTIONS.put("sick", NAUSEA);
+        ALIASPOTIONS.put("sickness", NAUSEA);
+        ALIASPOTIONS.put("confusion", NAUSEA);
 
         POTIONS.put("regeneration", PotionEffectType.REGENERATION);
         ALIASPOTIONS.put("regen", PotionEffectType.REGENERATION);
 
-        POTIONS.put("resistance", PotionEffectType.DAMAGE_RESISTANCE);
-        ALIASPOTIONS.put("dmgresist", PotionEffectType.DAMAGE_RESISTANCE);
-        ALIASPOTIONS.put("armor", PotionEffectType.DAMAGE_RESISTANCE);
+        final PotionEffectType RESISTANCE = RegistryUtil.valueOf(PotionEffectType.class, "DAMAGE_RESISTANCE", "RESISTANCE");
+
+        POTIONS.put("resistance", RESISTANCE);
+        ALIASPOTIONS.put("dmgresist", RESISTANCE);
+        ALIASPOTIONS.put("armor", RESISTANCE);
 
         POTIONS.put("fireresist", PotionEffectType.FIRE_RESISTANCE);
         ALIASPOTIONS.put("fireresistance", PotionEffectType.FIRE_RESISTANCE);
@@ -125,6 +144,31 @@ public final class Potions {
             POTIONS.put("unluck", PotionEffectType.UNLUCK);
         } catch (final Throwable ignored) {
         }
+
+        // 1.21
+        try {
+            POTIONS.put("infested", PotionEffectType.INFESTED);
+            ALIASPOTIONS.put("silverfish", PotionEffectType.INFESTED);
+
+            POTIONS.put("oozing", PotionEffectType.OOZING);
+            ALIASPOTIONS.put("ooze", PotionEffectType.OOZING);
+
+            POTIONS.put("weaving", PotionEffectType.WEAVING);
+            ALIASPOTIONS.put("weave", PotionEffectType.WEAVING);
+
+            POTIONS.put("windcharged", PotionEffectType.WIND_CHARGED);
+            ALIASPOTIONS.put("windcharge", PotionEffectType.WIND_CHARGED);
+            ALIASPOTIONS.put("wind", PotionEffectType.WIND_CHARGED);
+        } catch (final Throwable ignored) {
+        }
+
+        // 1.21.11
+        try {
+            POTIONS.put("breathofthenautilus", PotionEffectType.BREATH_OF_THE_NAUTILUS);
+            ALIASPOTIONS.put("nautilusbreath", PotionEffectType.BREATH_OF_THE_NAUTILUS);
+            ALIASPOTIONS.put("nautilus", PotionEffectType.BREATH_OF_THE_NAUTILUS);
+        } catch (final Throwable ignored) {
+        }
     }
 
     private Potions() {

Essentials/src/main/java/com/earth2me/essentials/ProviderFactory.java

@@ -0,0 +1,137 @@
+package com.earth2me.essentials;
+
+import io.papermc.lib.PaperLib;
+import net.ess3.provider.Provider;
+import net.essentialsx.providers.NullableProvider;
+import net.essentialsx.providers.ProviderData;
+import net.essentialsx.providers.ProviderTest;
+import org.bukkit.plugin.Plugin;
+
+import java.lang.reflect.Constructor;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.logging.Level;
+
+public class ProviderFactory {
+    private final Map<Class<? extends Provider>, Provider> providers = new HashMap<>();
+    private final Map<Class<? extends Provider>, List<Class<? extends Provider>>> registeredProviders = new HashMap<>();
+    private final Essentials essentials;
+
+    public ProviderFactory(final Essentials essentials) {
+        this.essentials = essentials;
+    }
+
+    /**
+     * Gets the provider which has been selected for the given type.
+     * @param providerClass The provider type.
+     * @return the provider or null if no provider could be selected for that type.
+     */
+    public <P extends Provider> P get(final Class<P> providerClass) {
+        final Provider provider = providers.get(providerClass);
+        if (provider == null) {
+            return null;
+        }
+        //noinspection unchecked
+        return (P) provider;
+    }
+
+    @SafeVarargs
+    public final void registerProvider(final Class<? extends Provider>... toRegister) {
+        for (final Class<? extends Provider> provider : toRegister) {
+            final Class<?> superclass = provider.getInterfaces().length > 0 ? provider.getInterfaces()[0] : provider.getSuperclass();
+            if (Provider.class.isAssignableFrom(superclass)) {
+                //noinspection unchecked
+                registeredProviders.computeIfAbsent((Class<? extends Provider>) superclass, k -> new ArrayList<>()).add(provider);
+                if (essentials.getSettings().isDebug()) {
+                    essentials.getLogger().info("Registered provider " + provider.getSimpleName() + " for " + superclass.getSimpleName());
+                }
+            }
+        }
+    }
+
+    public void finalizeRegistration() {
+        for (final Map.Entry<Class<? extends Provider>, List<Class<? extends Provider>>> entry : registeredProviders.entrySet()) {
+            final Class<? extends Provider> providerClass = entry.getKey();
+            final boolean nullable = providerClass.isAnnotationPresent(NullableProvider.class);
+            Class<? extends Provider> highestProvider = null;
+            ProviderData highestProviderData = null;
+            int highestWeight = -1;
+            for (final Class<? extends Provider> provider : entry.getValue()) {
+                try {
+                    final ProviderData providerData = provider.getAnnotation(ProviderData.class);
+                    if (providerData.weight() > highestWeight && testProvider(provider)) {
+                        highestWeight = providerData.weight();
+                        highestProvider = provider;
+                        highestProviderData = providerData;
+                    }
+                } catch (final Throwable e) {
+                    essentials.getLogger().log(Level.SEVERE, "Failed to initialize provider " + provider.getName(), e);
+                }
+            }
+
+            if (highestProvider != null) {
+                essentials.getLogger().info("Selected " + highestProviderData.description() + " as the provider for " + providerClass.getSimpleName());
+                providers.put(providerClass, getProviderInstance(highestProvider));
+            } else if (!nullable) {
+                throw new IllegalStateException("No provider found for " + providerClass.getName());
+            } else {
+                essentials.getLogger().info("No provider found for " + providerClass.getSimpleName() + ", but it is nullable");
+            }
+        }
+        registeredProviders.clear();
+    }
+
+    private boolean testProvider(final Class<?> providerClass) throws InvocationTargetException, IllegalAccessException {
+        try {
+            for (final Method method : providerClass.getMethods()) {
+                if (method.isAnnotationPresent(ProviderTest.class)) {
+                    return (Boolean) method.invoke(null);
+                }
+            }
+            return true;
+        } catch (final NoClassDefFoundError ignored) {
+            return false;
+        }
+    }
+
+    private <P extends Provider> P getProviderInstance(final Class<P> provider) {
+        try {
+            final Constructor<?> constructor = provider.getConstructors()[0];
+            if (constructor.getParameterTypes().length == 0) {
+                //noinspection unchecked
+                return (P) constructor.newInstance();
+            }
+            final Object[] args = new Object[constructor.getParameterTypes().length];
+
+            /*
+            Providers can have constructors with any of the following types, and this code will automatically supply them;
+            - Plugin - The Essentials instance will be passed
+            - boolean - True will be passed if this server is running Paper, otherwise false.
+             */
+            for (int i = 0; i < args.length; i++) {
+                final Class<?> paramType = constructor.getParameterTypes()[i];
+                if (paramType.isAssignableFrom(Plugin.class)) {
+                    args[i] = essentials;
+                } else if (paramType.isAssignableFrom(boolean.class)) {
+                    args[i] = PaperLib.isPaper();
+                } else {
+                    throw new IllegalArgumentException("Unsupported parameter type " + paramType.getName());
+                }
+            }
+
+            //noinspection unchecked
+            return (P) constructor.newInstance(args);
+        } catch (InstantiationException | IllegalAccessException | InvocationTargetException e) {
+            try {
+                return provider.getConstructor().newInstance();
+            } catch (NoSuchMethodException | InvocationTargetException | InstantiationException | IllegalAccessException ex) {
+                e.printStackTrace();
+                throw new RuntimeException(ex);
+            }
+        }
+    }
+}

Essentials/src/main/java/com/earth2me/essentials/RandomTeleport.java

@@ -1,18 +1,24 @@
 package com.earth2me.essentials;
 
+import com.earth2me.essentials.config.ConfigurateUtil;
 import com.earth2me.essentials.config.EssentialsConfiguration;
 import com.earth2me.essentials.config.entities.LazyLocation;
 import com.earth2me.essentials.utils.LocationUtil;
 import com.earth2me.essentials.utils.VersionUtil;
 import io.papermc.lib.PaperLib;
-import net.ess3.api.InvalidWorldException;
+import net.ess3.provider.BiomeKeyProvider;
+import net.ess3.provider.BiomeNameProvider;
+import net.ess3.provider.WorldInfoProvider;
 import org.bukkit.Location;
+import org.bukkit.Material;
 import org.bukkit.World;
-import org.bukkit.block.Biome;
 
 import java.io.File;
+import java.util.ArrayList;
+import java.util.HashMap;
 import java.util.HashSet;
 import java.util.List;
+import java.util.Map;
 import java.util.Queue;
 import java.util.Random;
 import java.util.Set;
@@ -24,66 +30,83 @@ public class RandomTeleport implements IConf {
     private static final int HIGHEST_BLOCK_Y_OFFSET = VersionUtil.getServerBukkitVersion().isHigherThanOrEqualTo(VersionUtil.v1_15_R01) ? 1 : 0;
     private final IEssentials ess;
     private final EssentialsConfiguration config;
-    private final ConcurrentLinkedQueue<Location> cachedLocations = new ConcurrentLinkedQueue<>();
+    private final Map<String, ConcurrentLinkedQueue<Location>> cachedLocations = new HashMap<>();
+    private WorldInfoProvider worldInfoProvider;
 
     public RandomTeleport(final IEssentials essentials) {
         this.ess = essentials;
         config = new EssentialsConfiguration(new File(essentials.getDataFolder(), "tpr.yml"), "/tpr.yml",
-                "Configuration for the random teleport command.\nSome settings may be defaulted, and can be changed via the /settpr command in-game.");
-        reloadConfig();
+                "Configuration for the random teleport command.\nUse the /settpr command in-game to set random teleport locations.");
+    }
+
+    public EssentialsConfiguration getConfig() {
+        return config;
     }
 
     @Override
     public void reloadConfig() {
+        worldInfoProvider = ess.provider(WorldInfoProvider.class);
         config.load();
         cachedLocations.clear();
     }
 
-    public Location getCenter() {
-        try {
-            final LazyLocation center = config.getLocation("center");
-            if (center != null && center.location() != null) {
-                return center.location();
-            }
-        } catch (final InvalidWorldException ignored) {
+    public boolean hasLocation(final String name) {
+        return config.hasProperty("locations." + name);
+    }
+
+    public Location getCenter(final String name) {
+        final LazyLocation center = config.getLocation(locationKey(name, "center"));
+        if (center != null && center.location() != null) {
+            return center.location();
         }
-        final Location center = ess.getServer().getWorlds().get(0).getWorldBorder().getCenter();
-        center.setY(center.getWorld().getHighestBlockYAt(center) + HIGHEST_BLOCK_Y_OFFSET);
-        setCenter(center);
-        return center;
+
+        final Location worldCenter = ess.getServer().getWorlds().get(0).getWorldBorder().getCenter();
+        worldCenter.setY(worldCenter.getWorld().getHighestBlockYAt(worldCenter) + HIGHEST_BLOCK_Y_OFFSET);
+        setCenter(name, worldCenter);
+        return worldCenter;
     }
 
-    public void setCenter(final Location center) {
-        config.setProperty("center", center);
+    public void setCenter(final String name, final Location center) {
+        config.setProperty(locationKey(name, "center"), center);
         config.save();
+        // Clear cached locations since center changed
+        this.getCachedLocations(name).clear();
     }
 
-    public double getMinRange() {
-        return config.getDouble("min-range", 0d);
+    public double getMinRange(final String name) {
+        return config.getDouble(locationKey(name, "min-range"), 0d);
     }
 
-    public void setMinRange(final double minRange) {
-        config.setProperty("min-range", minRange);
+    public void setMinRange(final String name, final double minRange) {
+        config.setProperty(locationKey(name, "min-range"), minRange);
         config.save();
+        // Clear cached locations since min range changed
+        this.getCachedLocations(name).clear();
     }
 
-    public double getMaxRange() {
-        return config.getDouble("max-range", getCenter().getWorld().getWorldBorder().getSize() / 2);
+    public double getMaxRange(final String name) {
+        return config.getDouble(locationKey(name, "max-range"), getCenter(name).getWorld().getWorldBorder().getSize() / 2);
     }
 
-    public void setMaxRange(final double maxRange) {
-        config.setProperty("max-range", maxRange);
+    public void setMaxRange(final String name, final double maxRange) {
+        config.setProperty(locationKey(name, "max-range"), maxRange);
         config.save();
+        // Clear cached locations since max range changed
+        this.getCachedLocations(name).clear();
     }
 
-    public Set<Biome> getExcludedBiomes() {
-        final List<String> biomeNames = config.getList("excluded-biomes", String.class);
-        final Set<Biome> excludedBiomes = new HashSet<>();
-        for (final String biomeName : biomeNames) {
-            try {
-                excludedBiomes.add(Biome.valueOf(biomeName.toUpperCase()));
-            } catch (final IllegalArgumentException ignored) {
-            }
+    public String getDefaultLocation() {
+        return config.getString("default-location", "{world}");
+    }
+
+    public boolean isPerLocationPermission() {
+        return config.getBoolean("per-location-permission", false);
+    }
+
+    public Set<String> getExcludedBiomes() {
+        final Set<String> excludedBiomes = new HashSet<>();
+        for (final String key : config.getList("excluded-biomes", String.class)) {
+            excludedBiomes.add(key.toLowerCase());
         }
         return excludedBiomes;
     }
@@ -96,39 +119,48 @@ public class RandomTeleport implements IConf {
         return config.getInt("cache-threshold", 10);
     }
 
-    public boolean getPreCache() {
-        return config.getBoolean("pre-cache", false);
+    public List<String> listLocations() {
+        return new ArrayList<>(ConfigurateUtil.getKeys(config.getRootNode().node("locations")));
     }
 
-    public Queue<Location> getCachedLocations() {
-        return cachedLocations;
+    public Queue<Location> getCachedLocations(final String name) {
+        this.cachedLocations.computeIfAbsent(name, x -> new ConcurrentLinkedQueue<>());
+        return cachedLocations.get(name);
     }
 
-    // Get a random location; cached if possible. Otherwise on demand.
-    public CompletableFuture<Location> getRandomLocation(final Location center, final double minRange, final double maxRange) {
-        final int findAttempts = this.getFindAttempts();
-        final Queue<Location> cachedLocations = this.getCachedLocations();
+    // Get a named random teleport location; cached if possible, otherwise on demand.
+    public CompletableFuture<Location> getRandomLocation(final String name) {
+        final Queue<Location> cached = this.getCachedLocations(name);
         // Try to build up the cache if it is below the threshold
-        if (cachedLocations.size() < this.getCacheThreshold()) {
-            cacheRandomLocations(center, minRange, maxRange);
+        if (cached.size() < this.getCacheThreshold()) {
+            cacheRandomLocations(name);
         }
         final CompletableFuture<Location> future = new CompletableFuture<>();
         // Return a random location immediately if one is available, otherwise try to find one now
-        if (cachedLocations.isEmpty()) {
+        if (cached.isEmpty()) {
+            final int findAttempts = this.getFindAttempts();
+            final Location center = this.getCenter(name);
+            final double minRange = this.getMinRange(name);
+            final double maxRange = this.getMaxRange(name);
             attemptRandomLocation(findAttempts, center, minRange, maxRange).thenAccept(future::complete);
         } else {
-            future.complete(cachedLocations.poll());
+            future.complete(cached.poll());
         }
         return future;
     }
 
-    // Prompts caching random valid locations, up to a maximum number of attempts
-    public void cacheRandomLocations(final Location center, final double minRange, final double maxRange) {
+    // Get a random location with specific parameters (note: not cached).
+    public CompletableFuture<Location> getRandomLocation(final Location center, final double minRange, final double maxRange) {
+        return attemptRandomLocation(this.getFindAttempts(), center, minRange, maxRange);
+    }
+
+    // Prompts caching random valid locations, up to a maximum number of attempts.
+    public void cacheRandomLocations(final String name) {
         ess.getServer().getScheduler().scheduleSyncDelayedTask(ess, () -> {
             for (int i = 0; i < this.getFindAttempts(); ++i) {
-                calculateRandomLocation(center, minRange, maxRange).thenAccept(location -> {
+                calculateRandomLocation(getCenter(name), getMinRange(name), getMaxRange(name)).thenAccept(location -> {
                     if (isValidRandomLocation(location)) {
-                        this.getCachedLocations().add(location);
+                        this.getCachedLocations(name).add(location);
                     }
                 });
             }
@@ -177,7 +209,7 @@ public class RandomTeleport implements IConf {
         final Location location = new Location(
             center.getWorld(),
             center.getX() + offsetX,
-            ess.getWorldInfoProvider().getMaxHeight(center.getWorld()),
+            worldInfoProvider.getMaxHeight(center.getWorld()),
             center.getZ() + offsetZ,
             360 * RANDOM.nextFloat() - 180,
             0
@@ -193,17 +225,54 @@ public class RandomTeleport implements IConf {
         return future;
     }
 
-    // Returns an appropriate elevation for a given location in the nether, or -1 if none is found
+    // Returns an appropriate elevation for a given location in the nether, or MIN_VALUE if none is found
     private double getNetherYAt(final Location location) {
-        for (int y = 32; y < ess.getWorldInfoProvider().getMaxHeight(location.getWorld()); ++y) {
-            if (!LocationUtil.isBlockUnsafe(ess, location.getWorld(), location.getBlockX(), y, location.getBlockZ())) {
+        final World world = location.getWorld();
+        for (int y = 32; y < worldInfoProvider.getMaxHeight(world); ++y) {
+            if (Material.BEDROCK.equals(world.getBlockAt(location.getBlockX(), y, location.getBlockZ()).getType())) {
+                break;
+            }
+            if (!LocationUtil.isBlockUnsafe(ess, world, location.getBlockX(), y, location.getBlockZ())) {
                 return y;
             }
         }
-        return -1;
+        return Double.MIN_VALUE;
     }
 
     private boolean isValidRandomLocation(final Location location) {
-        return location.getBlockY() > ess.getWorldInfoProvider().getMinHeight(location.getWorld()) && !this.getExcludedBiomes().contains(location.getBlock().getBiome());
+        return location.getBlockY() > worldInfoProvider.getMinHeight(location.getWorld()) && !isExcludedBiome(location);
+    }
+
+    // Exclude biome if enum or namespaced key matches
+    private boolean isExcludedBiome(final Location location) {
+        final BiomeNameProvider biomeNameProvider = ess.provider(BiomeNameProvider.class);
+        final Set<String> excluded = getExcludedBiomes();
+        final String enumKey = biomeNameProvider.getBiomeName(location.getBlock());
+        // Try with good old bukkit enum
+        if (excluded.contains(enumKey)) {
+            return true;
+        }
+        if (VersionUtil.getServerBukkitVersion().isLowerThan(VersionUtil.v1_14_4_R01)) {
+            // No way to get the biome key on versions below this
+            return false;
+        }
+        final String biomeKey;
+        final BiomeKeyProvider biomeKeyProvider = ess.provider(BiomeKeyProvider.class);
+        if (biomeKeyProvider != null) {
+            // Works with custom biome keys
+            biomeKey = biomeKeyProvider.getBiomeKey(location.getBlock()).toString();
+        } else {
+            // Custom biome keys resolve as "minecraft:custom" which is unfortunate
+            biomeKey = location.getBlock().getBiome().getKey().toString();
+        }
+        return excluded.contains(biomeKey);
+    }
+
+    private String locationKey(final String name, final String key) {
+        return "locations." + name + "." + key;
+    }
+
+    public File getFile() {
+        return config.getFile();
     }
 }

Essentials/src/main/java/com/earth2me/essentials/Settings.java

@@ -1,5 +1,6 @@
 package com.earth2me.essentials;
 
+import com.earth2me.essentials.adventure.AdventureUtil;
 import com.earth2me.essentials.api.IItemDb;
 import com.earth2me.essentials.commands.IEssentialsCommand;
 import com.earth2me.essentials.config.ConfigurateUtil;
@@ -13,11 +14,17 @@ import com.earth2me.essentials.utils.FormatUtil;
 import com.earth2me.essentials.utils.LocationUtil;
 import com.earth2me.essentials.utils.NumberUtil;
 import net.ess3.api.IEssentials;
+import net.ess3.provider.KnownCommandsProvider;
+import net.ess3.provider.SyncCommandsProvider;
+import net.essentialsx.api.v2.ChatType;
+import net.kyori.adventure.text.format.NamedTextColor;
 import org.bukkit.ChatColor;
+import org.bukkit.Color;
 import org.bukkit.Material;
 import org.bukkit.command.Command;
 import org.bukkit.event.EventPriority;
 import org.bukkit.inventory.ItemStack;
+import org.bukkit.plugin.Plugin;
 import org.spongepowered.configurate.CommentedConfigurationNode;
 
 import java.io.File;
@@ -29,6 +36,7 @@ import java.text.NumberFormat;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collections;
+import java.util.EnumMap;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.LinkedHashMap;
@@ -36,24 +44,26 @@ import java.util.List;
 import java.util.Locale;
 import java.util.Map;
 import java.util.Map.Entry;
+import java.util.Objects;
 import java.util.Set;
 import java.util.concurrent.atomic.AtomicInteger;
 import java.util.function.Predicate;
+import java.util.function.Supplier;
 import java.util.logging.Level;
-import java.util.logging.Logger;
 import java.util.regex.Pattern;
 import java.util.regex.PatternSyntaxException;
 
-import static com.earth2me.essentials.I18n.tl;
+import static com.earth2me.essentials.I18n.tlLiteral;
 
 public class Settings implements net.ess3.api.ISettings {
-    private static final Logger logger = Logger.getLogger("Essentials");
     private static final BigDecimal DEFAULT_MAX_MONEY = new BigDecimal("10000000000000");
     private static final BigDecimal DEFAULT_MIN_MONEY = new BigDecimal("-10000000000000");
+    private static final String DEFAULT_PRIMARY_COLOR = NamedTextColor.GOLD.toString();
+    private static final String DEFAULT_SECONDARY_COLOR = NamedTextColor.RED.toString();
     private final transient EssentialsConfiguration config;
     private final transient IEssentials ess;
     private final transient AtomicInteger reloadCount = new AtomicInteger(0);
-    private final Map<String, String> chatFormats = Collections.synchronizedMap(new HashMap<>());
+    private final ChatFormats chatFormats = new ChatFormats();
     private int chatRadius = 0;
     // #easteregg
     private char chatShout = '!';
@@ -81,6 +91,7 @@ public class Settings implements net.ess3.api.ISettings {
     private BigDecimal maxMoney = DEFAULT_MAX_MONEY;
     private BigDecimal minMoney = DEFAULT_MIN_MONEY;
     private boolean economyLog = false;
+    private boolean economyLogUUID = false;
     // #easteregg
     private boolean economyLogUpdate = false;
     private boolean changeDisplayName = true;
@@ -134,10 +145,17 @@ public class Settings implements net.ess3.api.ISettings {
     private boolean isWaterSafe;
     private boolean isSafeUsermap;
     private boolean logCommandBlockCommands;
+    private boolean logConsoleCommands;
     private Set<Predicate<String>> nickBlacklist;
+    private boolean resetNickOnNameChange;
     private double maxProjectileSpeed;
     private boolean removeEffectsOnHeal;
     private Map<String, String> worldAliases;
+    private String primaryColor = DEFAULT_PRIMARY_COLOR;
+    private String secondaryColor = DEFAULT_SECONDARY_COLOR;
+    private Set<String> multiplierPerms;
+    private BigDecimal defaultMultiplier;
+    private List<String> afkTimeoutCommands = Collections.emptyList();
 
     public Settings(final IEssentials ess) {
         this.ess = ess;
@@ -155,6 +173,16 @@ public class Settings implements net.ess3.api.ISettings {
         return config.getBoolean("respawn-at-home", false);
     }
 
+    @Override
+    public String getRandomSpawnLocation() {
+        return config.getString("random-spawn-location", "none");
+    }
+
+    @Override
+    public String getRandomRespawnLocation() {
+        return config.getString("random-respawn-location", "none");
+    }
+
     @Override
     public boolean isRespawnAtAnchor() {
         return config.getBoolean("respawn-at-anchor", false);
@@ -181,7 +209,7 @@ public class Settings implements net.ess3.api.ISettings {
         final Set<String> homeList = getMultipleHomes();
         if (homeList != null) {
             for (final String set : homeList) {
-                if (user.isAuthorized("essentials.sethome.multiple." + set) && (limit < getHomeLimit(set))) {
+                if (user.isAuthorized("essentials.sethome.multiple." + set) && limit < getHomeLimit(set)) {
                     limit = getHomeLimit(set);
                 }
             }
@@ -226,6 +254,26 @@ public class Settings implements net.ess3.api.ISettings {
         return chatQuestion;
     }
 
+    @Override
+    public boolean isShoutDefault() {
+        return config.getBoolean("chat.shout-default", false);
+    }
+
+    @Override
+    public boolean isPersistShout() {
+        return config.getBoolean("chat.persist-shout", false);
+    }
+
+    @Override
+    public boolean isChatQuestionEnabled() {
+        return config.getBoolean("chat.question-enabled", true);
+    }
+
+    @Override
+    public boolean isUsePaperChatEvent() {
+        return config.getBoolean("chat.paper-chat-events", true);
+    }
+
     public boolean _isTeleportSafetyEnabled() {
         return config.getBoolean("teleport-safety", true);
     }
@@ -249,6 +297,11 @@ public class Settings implements net.ess3.api.ISettings {
         return config.getBoolean("force-safe-teleport-location", false);
     }
 
+    @Override
+    public boolean isConsiderWorldHeightForTeleportSafety() {
+        return config.getBoolean("consider-world-height-for-teleport-safety", false);
+    }
+
     @Override
     public boolean isTeleportPassengerDismount() {
         return config.getBoolean("teleport-passenger-dismount", true);
@@ -300,9 +353,11 @@ public class Settings implements net.ess3.api.ISettings {
     }
 
     private void _addAlternativeCommand(final String label, final Command current) {
+        final KnownCommandsProvider knownCommandsProvider = ess.provider(KnownCommandsProvider.class);
+
         Command cmd = ess.getAlternativeCommandsHandler().getAlternative(label);
         if (cmd == null) {
-            for (final Map.Entry<String, Command> entry : ess.getKnownCommandsProvider().getKnownCommands().entrySet()) {
+            for (final Map.Entry<String, Command> entry : knownCommandsProvider.getKnownCommands().entrySet()) {
                 final String[] split = entry.getKey().split(":");
                 if (entry.getValue() != current && split[split.length - 1].equals(label)) {
                     cmd = entry.getValue();
@@ -312,7 +367,7 @@ public class Settings implements net.ess3.api.ISettings {
         }
 
         if (cmd != null) {
-            ess.getKnownCommandsProvider().getKnownCommands().put(label, cmd);
+            knownCommandsProvider.getKnownCommands().put(label, cmd);
         }
     }
 
@@ -434,6 +489,11 @@ public class Settings implements net.ess3.api.ISettings {
         return config.getBoolean("socialspy-messages", true);
     }
 
+    @Override
+    public boolean isSocialSpyDisplayNames() {
+        return config.getBoolean("socialspy-uses-displaynames", true);
+    }
+
     private Set<String> _getMuteCommands() {
         final Set<String> muteCommands = new HashSet<>();
         if (config.isList("mute-commands")) {
@@ -454,11 +514,20 @@ public class Settings implements net.ess3.api.ISettings {
         return config.getString("nickname-prefix", "~");
     }
 
+    private boolean _resetNickOnNameChange() {
+        return config.getBoolean("reset-nick-on-name-change", false);
+    }
+
     @Override
     public String getNicknamePrefix() {
         return nicknamePrefix;
     }
 
+    @Override
+    public boolean isResetNickOnNameChange() {
+        return resetNickOnNameChange;
+    }
+
     @Override
     public double getTeleportCooldown() {
         return config.getDouble("teleport-cooldown", 0);
@@ -552,32 +621,132 @@ public class Settings implements net.ess3.api.ISettings {
 
     @Override
     public String getChatFormat(final String group) {
-        String mFormat = chatFormats.get(group);
-        if (mFormat == null) {
-            mFormat = config.getString("chat.group-formats." + (group == null ? "Default" : group), config.getString("chat.format", "&7[{GROUP}]&r {DISPLAYNAME}&7:&r {MESSAGE}"));
-            mFormat = FormatUtil.replaceFormat(mFormat);
-            mFormat = mFormat.replace("{DISPLAYNAME}", "%1$s");
-            mFormat = mFormat.replace("{MESSAGE}", "%2$s");
-            mFormat = mFormat.replace("{GROUP}", "{0}");
-            mFormat = mFormat.replace("{WORLD}", "{1}");
-            mFormat = mFormat.replace("{WORLDNAME}", "{1}");
-            mFormat = mFormat.replace("{SHORTWORLDNAME}", "{2}");
-            mFormat = mFormat.replace("{TEAMPREFIX}", "{3}");
-            mFormat = mFormat.replace("{TEAMSUFFIX}", "{4}");
-            mFormat = mFormat.replace("{TEAMNAME}", "{5}");
-            mFormat = mFormat.replace("{PREFIX}", "{6}");
-            mFormat = mFormat.replace("{SUFFIX}", "{7}");
-            mFormat = mFormat.replace("{USERNAME}", "{8}");
-            mFormat = mFormat.replace("{NICKNAME}", "{9}");
-            mFormat = "§r".concat(mFormat);
-            chatFormats.put(group, mFormat);
-        }
+        return getChatFormat(group, null);
+    }
+
+    @Override
+    public String getChatFormat(final String group, final ChatType chatType) {
+        final String mFormat = chatFormats.getFormat(group, chatType, new ChatFormatConfigSupplier(group, chatType));
         if (isDebug()) {
             ess.getLogger().info(String.format("Found format '%s' for group '%s'", mFormat, group));
         }
         return mFormat;
     }
 
+    private class ChatFormatConfigSupplier implements Supplier<String> {
+        private final String group;
+        private final ChatType chatType;
+
+        ChatFormatConfigSupplier(String group, ChatType chatType) {
+            this.group = group;
+            this.chatType = chatType;
+        }
+
+        @Override
+        public String get() {
+            final String chatKey = chatType.key();
+
+            final String groupPath = "chat.group-formats." + (group == null ? "Default" : group);
+            String configFormat = config.getString(groupPath + "." + chatKey, null);
+
+            if (configFormat == null) {
+                configFormat = config.getString(groupPath, null);
+            }
+
+            final String formatPath = "chat.format";
+            if (configFormat == null) {
+                configFormat = config.getString(formatPath + "." + chatKey, null);
+            }
+
+            if (configFormat == null) {
+                configFormat = config.getString(formatPath, null);
+            }
+
+            if (configFormat == null) {
+                configFormat = "&7[{GROUP}]&r {DISPLAYNAME}&7:&r {MESSAGE}";
+            }
+
+            configFormat = FormatUtil.replaceFormat(configFormat);
+            configFormat = configFormat.replace("{DISPLAYNAME}", "%1$s");
+            configFormat = configFormat.replace("{MESSAGE}", "%2$s");
+            configFormat = configFormat.replace("{GROUP}", "{0}");
+            configFormat = configFormat.replace("{WORLD}", "{1}");
+            configFormat = configFormat.replace("{WORLDNAME}", "{1}");
+            configFormat = configFormat.replace("{SHORTWORLDNAME}", "{2}");
+            configFormat = configFormat.replace("{TEAMPREFIX}", "{3}");
+            configFormat = configFormat.replace("{TEAMSUFFIX}", "{4}");
+            configFormat = configFormat.replace("{TEAMNAME}", "{5}");
+            configFormat = configFormat.replace("{PREFIX}", "{6}");
+            configFormat = configFormat.replace("{SUFFIX}", "{7}");
+            configFormat = configFormat.replace("{USERNAME}", "{8}");
+            configFormat = configFormat.replace("{NICKNAME}", "{9}");
+            configFormat = "§r".concat(configFormat);
+            return configFormat;
+        }
+    }
+
+    private static class ChatFormats {
+
+        private final Map<String, TypedChatFormat> groupFormats;
+        private TypedChatFormat defaultFormat;
+
+        ChatFormats() {
+            defaultFormat = null;
+            groupFormats = new HashMap<>();
+        }
+
+        public String getFormat(String group, ChatType type, Supplier<String> configSupplier) {
+            // With such a large synchronize block, we synchronize a potential config deserialization
+            // It does not matter as it needs to be done. It's even better as we ensure to do it once
+            // TypedChatFormat is also synchronized
+            synchronized (this) {
+                final TypedChatFormat typedChatFormat;
+                if (group == null) {
+                    if (defaultFormat == null) {
+                        defaultFormat = new TypedChatFormat();
+                    }
+                    typedChatFormat = defaultFormat;
+                } else {
+                    typedChatFormat = groupFormats.computeIfAbsent(group, s -> new TypedChatFormat());
+                }
+                return typedChatFormat.getFormat(type, configSupplier);
+            }
+        }
+
+        public void clear() {
+            synchronized (this) {
+                defaultFormat = null;
+                groupFormats.clear();
+            }
+        }
+
+    }
+
+    private static class TypedChatFormat {
+
+        private final Map<ChatType, String> typedFormats;
+        private String defaultFormat;
+
+        TypedChatFormat() {
+            defaultFormat = null;
+            typedFormats = new EnumMap<>(ChatType.class);
+        }
+
+        public String getFormat(ChatType type, Supplier<String> configSupplier) {
+            final String format;
+            if (type == null) {
+                if (defaultFormat == null) {
+                    defaultFormat = configSupplier.get();
+                }
+                format = defaultFormat;
+            } else {
+                format = typedFormats.computeIfAbsent(type, c -> configSupplier.get());
+            }
+            return format;
+        }
+
+    }
+
     @Override
     public String getWorldAlias(String world) {
         return worldAliases.getOrDefault(world.toLowerCase(), world);
@@ -666,29 +835,43 @@ public class Settings implements net.ess3.api.ISettings {
         overriddenCommands = _getOverriddenCommands();
         playerCommands = _getPlayerCommands();
 
+        final KnownCommandsProvider knownCommandsProvider = ess.provider(KnownCommandsProvider.class);
+
         // This will be late loaded
-        if (ess.getKnownCommandsProvider() != null) {
+        if (knownCommandsProvider != null) {
             boolean mapModified = false;
             if (!disabledBukkitCommands.isEmpty()) {
                 if (isDebug()) {
-                    logger.log(Level.INFO, "Re-adding " + disabledBukkitCommands.size() + " disabled commands!");
+                    ess.getLogger().log(Level.INFO, "Re-adding " + disabledBukkitCommands.size() + " disabled commands!");
                 }
-                ess.getKnownCommandsProvider().getKnownCommands().putAll(disabledBukkitCommands);
+                knownCommandsProvider.getKnownCommands().putAll(disabledBukkitCommands);
                 disabledBukkitCommands.clear();
                 mapModified = true;
             }
 
+            if (reloadCount.get() < 2) {
+                // on startup: add plugins again in case they registered commands with the new API
+                // we need to schedule this task before any of the below tasks using _addAlternativeCommand.
+                ess.scheduleSyncDelayedTask(() -> {
+                    for (final Plugin plugin : ess.getServer().getPluginManager().getPlugins()) {
+                        if (plugin.isEnabled()) {
+                            ess.getAlternativeCommandsHandler().addPlugin(plugin);
+                        }
+                    }
+                });
+            }
+
             for (final String command : disabledCommands) {
                 final String effectiveAlias = command.toLowerCase(Locale.ENGLISH);
                 final Command toDisable = ess.getPluginCommand(effectiveAlias);
                 if (toDisable != null) {
                     if (isDebug()) {
-                        logger.log(Level.INFO, "Attempting removal of " + effectiveAlias);
+                        ess.getLogger().log(Level.INFO, "Attempting removal of " + effectiveAlias);
                     }
-                    final Command removed = ess.getKnownCommandsProvider().getKnownCommands().remove(effectiveAlias);
+                    final Command removed = knownCommandsProvider.getKnownCommands().remove(effectiveAlias);
                     if (removed != null) {
                         if (isDebug()) {
-                            logger.log(Level.INFO, "Adding command " + effectiveAlias + " to disabled map!");
+                            ess.getLogger().log(Level.INFO, "Adding command " + effectiveAlias + " to disabled map!");
                         }
                         disabledBukkitCommands.put(effectiveAlias, removed);
                     }
@@ -703,19 +886,22 @@ public class Settings implements net.ess3.api.ISettings {
                 }
             }
 
+            final SyncCommandsProvider syncCommandsProvider = ess.provider(SyncCommandsProvider.class);
+
             if (mapModified) {
                 if (isDebug()) {
-                    logger.log(Level.INFO, "Syncing commands");
+                    ess.getLogger().log(Level.INFO, "Syncing commands");
                 }
                 if (reloadCount.get() < 2) {
-                    ess.scheduleSyncDelayedTask(() -> ess.getSyncCommandsProvider().syncCommands());
+                    ess.scheduleSyncDelayedTask(syncCommandsProvider::syncCommands);
                 } else {
-                    ess.getSyncCommandsProvider().syncCommands();
+                    syncCommandsProvider.syncCommands();
                 }
             }
         }
 
         nicknamePrefix = _getNicknamePrefix();
+        resetNickOnNameChange = _resetNickOnNameChange();
         operatorColor = _getOperatorColor();
         changePlayerListName = _changePlayerListName();
         configDebug = _isDebug();
@@ -735,6 +921,7 @@ public class Settings implements net.ess3.api.ISettings {
         permissionsLagWarning = _getPermissionsLagWarning();
         economyLagWarning = _getEconomyLagWarning();
         economyLog = _isEcoLogEnabled();
+        economyLogUUID = _isEcoLogUUIDEnabled();
         economyLogUpdate = _isEcoLogUpdateEnabled();
         economyDisabled = _isEcoDisabled();
         allowSilentJoin = _allowSilentJoinQuit();
@@ -759,6 +946,7 @@ public class Settings implements net.ess3.api.ISettings {
         isWaterSafe = _isWaterSafe();
         isSafeUsermap = _isSafeUsermap();
         logCommandBlockCommands = _logCommandBlockCommands();
+        logConsoleCommands = _logConsoleCommands();
         nickBlacklist = _getNickBlacklist();
         maxProjectileSpeed = _getMaxProjectileSpeed();
         removeEffectsOnHeal = _isRemovingEffectsOnHeal();
@@ -766,6 +954,11 @@ public class Settings implements net.ess3.api.ISettings {
         bindingItemPolicy = _getBindingItemsPolicy();
         currencySymbol = _getCurrencySymbol();
         worldAliases = _getWorldAliases();
+        primaryColor = _getPrimaryColor();
+        secondaryColor = _getSecondaryColor();
+        multiplierPerms = _getMultiplierPerms();
+        defaultMultiplier = _getDefaultMultiplier();
+        afkTimeoutCommands = _getAfkTimeoutCommands();
 
         reloadCount.incrementAndGet();
     }
@@ -784,7 +977,7 @@ public class Settings implements net.ess3.api.ISettings {
         //noinspection deprecation
         final IItemDb itemDb = ess.getItemDb();
         if (itemDb == null || !itemDb.isReady()) {
-            logger.log(Level.FINE, "Skipping item spawn blacklist read; item DB not yet loaded.");
+            ess.getLogger().log(Level.FINE, "Skipping item spawn blacklist read; item DB not yet loaded.");
             return epItemSpwn;
         }
         for (String itemName : config.getString("item-spawn-blacklist", "").split(",")) {
@@ -796,7 +989,7 @@ public class Settings implements net.ess3.api.ISettings {
                 final ItemStack iStack = itemDb.get(itemName);
                 epItemSpwn.add(iStack.getType());
             } catch (final Exception ex) {
-                logger.log(Level.SEVERE, tl("unknownItemInList", itemName, "item-spawn-blacklist"), ex);
+                ess.getLogger().log(Level.SEVERE, ess.getAdventureFacet().miniToLegacy(tlLiteral("unknownItemInList", itemName, "item-spawn-blacklist")), ex);
             }
         }
         return epItemSpwn;
@@ -824,7 +1017,7 @@ public class Settings implements net.ess3.api.ISettings {
             try {
                 newSigns.add(Signs.valueOf(signName).getSign());
             } catch (final Exception ex) {
-                logger.log(Level.SEVERE, tl("unknownItemInList", signName, "enabledSigns"));
+                ess.getLogger().log(Level.SEVERE, ess.getAdventureFacet().miniToLegacy(tlLiteral("unknownItemInList", signName, "enabledSigns")));
                 continue;
             }
             signsEnabled = true;
@@ -870,6 +1063,11 @@ public class Settings implements net.ess3.api.ISettings {
         return config.getString("locale", "");
     }
 
+    @Override
+    public boolean isPerPlayerLocale() {
+        return config.getBoolean("per-player-locale", false);
+    }
+
     private String currencySymbol = "$";
 
     // A valid currency symbol value must be one non-integer character.
@@ -919,14 +1117,23 @@ public class Settings implements net.ess3.api.ISettings {
     }
 
     @Override
-    public List<Material> getProtectList(final String configName) {
-        final List<Material> list = new ArrayList<>();
+    public List<String> getProtectListRaw(String configName) {
+        final List<String> list = new ArrayList<>();
         for (String itemName : config.getString(configName, "").split(",")) {
             itemName = itemName.trim();
             if (itemName.isEmpty()) {
                 continue;
             }
 
+            list.add(itemName);
+        }
+        return list;
+    }
+
+    @Override
+    public List<Material> getProtectList(final String configName) {
+        final List<Material> list = new ArrayList<>();
+        for (String itemName : getProtectListRaw(configName)) {
             Material mat = EnumUtil.getMaterial(itemName.toUpperCase());
 
             if (mat == null) {
@@ -938,7 +1145,7 @@ public class Settings implements net.ess3.api.ISettings {
             }
 
             if (mat == null) {
-                logger.log(Level.SEVERE, tl("unknownItemInList", itemName, configName));
+                ess.getLogger().log(Level.SEVERE, ess.getAdventureFacet().miniToLegacy(tlLiteral("unknownItemInList", itemName, configName)));
             } else {
                 list.add(mat);
             }
@@ -987,6 +1194,14 @@ public class Settings implements net.ess3.api.ISettings {
         return config.getBoolean("economy-log-enabled", false);
     }
 
+    public boolean _isEcoLogUUIDEnabled() {
+        return config.getBoolean("economy-log-uuids", false);
+    }
+
+    public boolean isEcoLogUUIDEnabled() {
+        return economyLogUUID;
+    }
+
     @Override
     public boolean isEcoLogUpdateEnabled() {
         return economyLogUpdate;
@@ -1076,8 +1291,17 @@ public class Settings implements net.ess3.api.ISettings {
     }
 
     @Override
-    public long getAutoAfkKick() {
-        return config.getLong("auto-afk-kick", -1);
+    public long getAutoAfkTimeout() {
+        return config.getLong("auto-afk-timeout", config.getLong("auto-afk-kick", -1));
+    }
+
+    private List<String> _getAfkTimeoutCommands() {
+        return new ArrayList<>(config.getList("afk-timeout-commands", String.class));
+    }
+
+    @Override
+    public List<String> getAfkTimeoutCommands() {
+        return afkTimeoutCommands;
     }
 
     @Override
@@ -1112,6 +1336,11 @@ public class Settings implements net.ess3.api.ISettings {
         return config.getBoolean("cancel-afk-on-chat", true);
     }
 
+    @Override
+    public boolean cancelAfkOnFish() {
+        return config.getBoolean("cancel-afk-on-fish", true);
+    }
+
     @Override
     public boolean sleepIgnoresAfkPlayers() {
         return sleepIgnoresAfkPlayers;
@@ -1212,6 +1441,11 @@ public class Settings implements net.ess3.api.ISettings {
         return registerBackInListener;
     }
 
+    @Override
+    public int getMaxTreeCommandRange() {
+        return config.getInt("tree-command-range-limit", 300);
+    }
+
     private boolean _registerBackInListener() {
         return config.getBoolean("register-back-in-listener", false);
     }
@@ -1428,6 +1662,11 @@ public class Settings implements net.ess3.api.ISettings {
         return config.getBoolean("use-custom-server-full-message", true);
     }
 
+    @Override
+    public boolean isCustomWhitelistMessage() {
+        return config.getBoolean("use-custom-whitelist-message", true);
+    }
+
     @Override
     public int getJoinQuitMessagePlayerCount() {
         return config.getInt("hide-join-quit-messages-above", -1);
@@ -1451,10 +1690,16 @@ public class Settings implements net.ess3.api.ISettings {
     // #easteregg
     @Override
     public int getMaxUserCacheCount() {
-        final long count = Runtime.getRuntime().maxMemory() / 1024 / 96;
+        final long count = Runtime.getRuntime().maxMemory() / 1024 / 1024;
         return config.getInt("max-user-cache-count", (int) count);
     }
 
+    // #easteregg
+    @Override
+    public long getMaxUserCacheValueExpiry() {
+        return config.getLong("max-user-cache-value-expiry", 600);
+    }
+
     @Override
     public boolean isLastMessageReplyRecipient() {
         return config.getBoolean("last-message-reply-recipient", false);
@@ -1675,7 +1920,7 @@ public class Settings implements net.ess3.api.ISettings {
             try {
                 newSigns.add(Signs.valueOf(signName).getSign());
             } catch (final Exception ex) {
-                logger.log(Level.SEVERE, tl("unknownItemInList", signName, "unprotected-sign-names"));
+                ess.getLogger().log(Level.SEVERE, ess.getAdventureFacet().miniToLegacy(tlLiteral("unknownItemInList", signName, "unprotected-sign-names")));
             }
         }
         return newSigns;
@@ -1736,6 +1981,16 @@ public class Settings implements net.ess3.api.ISettings {
         return config.getBoolean("world-change-fly-reset", true);
     }
 
+    @Override
+    public boolean isWorldChangePreserveFlying() {
+        return config.getBoolean("world-change-preserve-flying", true);
+    }
+
+    @Override
+    public boolean isGamemodeChangePreserveFlying() {
+        return config.getBoolean("gamemode-change-preserve-flying", false);
+    }
+
     @Override
     public boolean isWorldChangeSpeedResetEnabled() {
         return config.getBoolean("world-change-speed-reset", true);
@@ -1743,9 +1998,7 @@ public class Settings implements net.ess3.api.ISettings {
 
     private List<String> _getDefaultEnabledConfirmCommands() {
         final List<String> commands = config.getList("default-enabled-confirm-commands", String.class);
-        for (int i = 0; i < commands.size(); i++) {
-            commands.set(i, commands.get(i).toLowerCase());
-        }
+        commands.replaceAll(String::toLowerCase);
         return commands;
     }
 
@@ -1853,6 +2106,15 @@ public class Settings implements net.ess3.api.ISettings {
         return logCommandBlockCommands;
     }
 
+    private boolean _logConsoleCommands() {
+        return config.getBoolean("log-console-commands", true);
+    }
+
+    @Override
+    public boolean logConsoleCommands() {
+        return logConsoleCommands;
+    }
+
     private Set<Predicate<String>> _getNickBlacklist() {
         final Set<Predicate<String>> blacklist = new HashSet<>();
 
@@ -1860,7 +2122,7 @@ public class Settings implements net.ess3.api.ISettings {
             try {
                 blacklist.add(Pattern.compile(entry).asPredicate());
             } catch (final PatternSyntaxException e) {
-                logger.warning("Invalid nickname blacklist regex: " + entry);
+                ess.getLogger().warning("Invalid nickname blacklist regex: " + entry);
             }
         });
 
@@ -1919,4 +2181,95 @@ public class Settings implements net.ess3.api.ISettings {
     public boolean showZeroBaltop() {
         return config.getBoolean("show-zero-baltop", true);
     }
+
+    @Override
+    public String getNickRegex() {
+        return config.getString("allowed-nicks-regex", "^[a-zA-Z_0-9§]+$");
+    }
+
+    @Override
+    public BigDecimal getMultiplier(final User user) {
+        BigDecimal multiplier = defaultMultiplier;
+        if (multiplierPerms == null) {
+            return defaultMultiplier;
+        }
+
+        for (final String multiplierPerm : multiplierPerms) {
+            if (user.isAuthorized("essentials.sell.multiplier." + multiplierPerm)) {
+                final BigDecimal value = config.getBigDecimal("sell-multipliers." + multiplierPerm, BigDecimal.ZERO);
+                if (value.compareTo(multiplier) > 0) {
+                    multiplier = value;
+                }
+            }
+        }
+
+        return multiplier;
+    }
+
+    private BigDecimal _getDefaultMultiplier() {
+        return config.getBigDecimal("sell-multipliers.default", BigDecimal.ONE);
+    }
+
+    private Set<String> _getMultiplierPerms() {
+        final CommentedConfigurationNode section = config.getSection("sell-multipliers");
+        return section == null ? null : ConfigurateUtil.getKeys(section);
+    }
+
+    public int getMaxItemLore() {
+        return config.getInt("max-itemlore-lines", 10);
+    }
+
+    @Override
+    public String getPrimaryColor() {
+        return primaryColor;
+    }
+
+    private String _getPrimaryColor() {
+        final String color = config.getString("message-colors.primary", "#ffaa00");
+        final String textColor = _getTagColor(color);
+        return textColor != null ? textColor : DEFAULT_PRIMARY_COLOR;
+    }
+
+    @Override
+    public String getSecondaryColor() {
+        return secondaryColor;
+    }
+
+    private String _getSecondaryColor() {
+        final String color = config.getString("message-colors.secondary", "#ff5555");
+        final String textColor = _getTagColor(color);
+        return textColor != null ? textColor : DEFAULT_SECONDARY_COLOR;
+    }
+
+    private String _getTagColor(final String color) {
+        try {
+            if (color.startsWith("#") && color.length() == 7 && NumberUtil.isHexadecimal(color.substring(1))) {
+                Color.fromRGB(Integer.decode(color));
+                return color;
+            }
+
+            if (color.length() == 1) {
+                return Objects.requireNonNull(AdventureUtil.fromChar(color.charAt(0))).toString();
+            }
+
+            return Objects.requireNonNull(NamedTextColor.NAMES.value(color.toLowerCase(Locale.ENGLISH))).toString();
+        } catch (NullPointerException | IllegalArgumentException ignored) {
+        }
+        return null;
+    }
+
+    @Override
+    public BigDecimal getBaltopMinBalance() {
+        return config.getBigDecimal("baltop-requirements.minimum-balance", BigDecimal.ZERO);
+    }
+
+    @Override
+    public int getBaltopEntryLimit() {
+        return config.getInt("baltop-entry-limit", -1);
+    }
+
+    @Override
+    public long getBaltopMinPlaytime() {
+        return config.getLong("baltop-requirements.minimum-playtime", 0);
+    }
 }

Essentials/src/main/java/com/earth2me/essentials/SpawnMob.java

@@ -1,12 +1,13 @@
 package com.earth2me.essentials;
 
 import com.earth2me.essentials.Mob.MobException;
-import com.earth2me.essentials.craftbukkit.InventoryWorkaround;
+import com.earth2me.essentials.craftbukkit.Inventories;
 import com.earth2me.essentials.utils.EnumUtil;
 import com.earth2me.essentials.utils.LocationUtil;
 import com.earth2me.essentials.utils.StringUtil;
 import com.earth2me.essentials.utils.VersionUtil;
 import net.ess3.api.IEssentials;
+import net.ess3.api.TranslatableException;
 import org.bukkit.Location;
 import org.bukkit.Material;
 import org.bukkit.Server;
@@ -27,12 +28,14 @@ import java.util.List;
 import java.util.Locale;
 import java.util.Set;
 
-import static com.earth2me.essentials.I18n.tl;
-
 public final class SpawnMob {
 
     private static final Material GOLDEN_HELMET = EnumUtil.getMaterial("GOLDEN_HELMET", "GOLD_HELMET");
     private static final Material GOLDEN_CHESTPLATE = EnumUtil.getMaterial("GOLDEN_CHESTPLATE", "GOLD_CHESTPLATE");
+    private static final Material COPPER_HELMET = EnumUtil.getMaterial("COPPER_HELMET");
+    private static final Material COPPER_CHESTPLATE = EnumUtil.getMaterial("COPPER_CHESTPLATE");
+    private static final Material COPPER_LEGGINGS = EnumUtil.getMaterial("COPPER_LEGGINGS");
+    private static final Material COPPER_BOOTS = EnumUtil.getMaterial("COPPER_BOOTS");
     private static final Material GOLDEN_LEGGINGS = EnumUtil.getMaterial("GOLDEN_LEGGINGS", "GOLD_LEGGINGS");
     private static final Material GOLDEN_BOOTS = EnumUtil.getMaterial("GOLDEN_BOOTS", "GOLD_BOOTS");
     private static final Material GOLDEN_SWORD = EnumUtil.getMaterial("GOLDEN_SWORD", "GOLD_SWORD");
@@ -49,7 +52,7 @@ public final class SpawnMob {
             }
         }
         if (availableList.isEmpty()) {
-            availableList.add(tl("none"));
+            availableList.add(user.playerTl("none"));
         }
         return StringUtil.joinList(availableList);
     }
@@ -91,7 +94,7 @@ public final class SpawnMob {
     public static void spawnmob(final IEssentials ess, final Server server, final User user, final List<String> parts, final List<String> data, final int mobCount) throws Exception {
         final Block block = LocationUtil.getTarget(user.getBase()).getBlock();
         if (block == null) {
-            throw new Exception(tl("unableToSpawnMob"));
+            throw new TranslatableException("unableToSpawnMob");
         }
         spawnmob(ess, server, user.getSource(), user, block.getLocation(), parts, data, mobCount);
     }
@@ -122,7 +125,7 @@ public final class SpawnMob {
 
         if (mobCount > effectiveLimit) {
             mobCount = effectiveLimit;
-            sender.sendMessage(tl("mobSpawnLimit"));
+            sender.sendTl("mobSpawnLimit");
         }
 
         final Mob mob = Mob.fromName(parts.get(0)); // Get the first mob
@@ -130,13 +133,13 @@ public final class SpawnMob {
             for (int i = 0; i < mobCount; i++) {
                 spawnMob(ess, server, sender, target, sloc, parts, data);
             }
-            sender.sendMessage(mobCount * parts.size() + " " + mob.name.toLowerCase(Locale.ENGLISH) + mob.suffix + " " + tl("spawned"));
+            sender.sendMessage(mobCount * parts.size() + " " + mob.name.toLowerCase(Locale.ENGLISH) + mob.suffix + " " + sender.tl("spawned"));
         } catch (final MobException e1) {
-            throw new Exception(tl("unableToSpawnMob"), e1);
+            throw new TranslatableException(e1, "unableToSpawnMob");
         } catch (final NumberFormatException e2) {
-            throw new Exception(tl("numberRequired"), e2);
+            throw new TranslatableException(e2, "numberRequired");
         } catch (final NullPointerException np) {
-            throw new Exception(tl("soloMob"), np);
+            throw new TranslatableException(np, "soloMob");
         }
     }
 
@@ -176,15 +179,15 @@ public final class SpawnMob {
 
     private static void checkSpawnable(final IEssentials ess, final CommandSource sender, final Mob mob) throws Exception {
         if (mob == null || mob.getType() == null) {
-            throw new Exception(tl("invalidMob"));
+            throw new TranslatableException("invalidMob");
         }
 
         if (ess.getSettings().getProtectPreventSpawn(mob.getType().toString().toLowerCase(Locale.ENGLISH))) {
-            throw new Exception(tl("disabledToSpawnMob"));
+            throw new TranslatableException("disabledToSpawnMob");
         }
 
         if (sender.isPlayer() && !ess.getUser(sender.getPlayer()).isAuthorized("essentials.spawnmob." + mob.name.toLowerCase(Locale.ENGLISH))) {
-            throw new Exception(tl("noPermToSpawnMob"));
+            throw new TranslatableException("noPermToSpawnMob");
         }
     }
 
@@ -192,7 +195,7 @@ public final class SpawnMob {
         String data = inputData;
 
         if (data.isEmpty()) {
-            sender.sendMessage(tl("mobDataList", StringUtil.joinList(MobData.getValidHelp(spawned))));
+            sender.sendTl("mobDataList", StringUtil.joinList(MobData.getValidHelp(spawned)));
         }
 
         if (spawned instanceof Zombie) {
@@ -211,6 +214,11 @@ public final class SpawnMob {
                     invent.setLeggings(new ItemStack(Material.NETHERITE_LEGGINGS, 1));
                     invent.setChestplate(new ItemStack(Material.NETHERITE_CHESTPLATE, 1));
                     invent.setHelmet(new ItemStack(Material.NETHERITE_HELMET, 1));
+                } else if (inputData.contains("copper") && COPPER_HELMET != null) {
+                    invent.setBoots(new ItemStack(COPPER_BOOTS, 1));
+                    invent.setLeggings(new ItemStack(COPPER_LEGGINGS, 1));
+                    invent.setChestplate(new ItemStack(COPPER_CHESTPLATE, 1));
+                    invent.setHelmet(new ItemStack(COPPER_HELMET, 1));
                 } else if (inputData.contains("diamond")) {
                     invent.setBoots(new ItemStack(Material.DIAMOND_BOOTS, 1));
                     invent.setLeggings(new ItemStack(Material.DIAMOND_LEGGINGS, 1));
@@ -251,8 +259,8 @@ public final class SpawnMob {
     private static void defaultMobData(final EntityType type, final Entity spawned) {
         if (type == EntityType.SKELETON) {
             final EntityEquipment invent = ((LivingEntity) spawned).getEquipment();
-            InventoryWorkaround.setItemInMainHand(invent, new ItemStack(Material.BOW, 1));
-            InventoryWorkaround.setItemInMainHandDropChance(invent, 0.1f);
+            Inventories.setItemInMainHand(invent, new ItemStack(Material.BOW, 1));
+            Inventories.setItemInMainHandDropChance(invent, 0.1f);
         }
 
         if (type == MobCompat.ZOMBIFIED_PIGLIN) {
@@ -260,8 +268,8 @@ public final class SpawnMob {
             setVillager(zombie, false);
 
             final EntityEquipment invent = zombie.getEquipment();
-            InventoryWorkaround.setItemInMainHand(invent, new ItemStack(GOLDEN_SWORD, 1));
-            InventoryWorkaround.setItemInMainHandDropChance(invent, 0.1f);
+            Inventories.setItemInMainHand(invent, new ItemStack(GOLDEN_SWORD, 1));
+            Inventories.setItemInMainHandDropChance(invent, 0.1f);
         }
 
         if (type == EntityType.ZOMBIE) {

Essentials/src/main/java/com/earth2me/essentials/TNTExplodeListener.java

@@ -1,51 +1,22 @@
 package com.earth2me.essentials;
 
-import net.ess3.api.IEssentials;
-import org.bukkit.entity.LivingEntity;
+import com.earth2me.essentials.commands.Commandnuke;
+import org.bukkit.entity.TNTPrimed;
 import org.bukkit.event.EventHandler;
 import org.bukkit.event.EventPriority;
 import org.bukkit.event.Listener;
 import org.bukkit.event.entity.EntityExplodeEvent;
 
-public class TNTExplodeListener implements Listener, Runnable {
-    private final transient IEssentials ess;
-    private transient boolean enabled = false;
-    private transient int timer = -1;
-
-    public TNTExplodeListener(final IEssentials ess) {
-        super();
-        this.ess = ess;
-    }
-
-    public void enable() {
-        if (!enabled) {
-            enabled = true;
-            timer = ess.scheduleSyncDelayedTask(this, 200);
-            return;
-        }
-        if (timer != -1) {
-            ess.getScheduler().cancelTask(timer);
-            timer = ess.scheduleSyncDelayedTask(this, 200);
-        }
-    }
-
+public class TNTExplodeListener implements Listener {
     @EventHandler(priority = EventPriority.LOW)
     public void onEntityExplode(final EntityExplodeEvent event) {
-        if (!enabled) {
+        if (!(event.getEntity() instanceof TNTPrimed)) {
             return;
         }
-        if (event.getEntity() instanceof LivingEntity) {
-            return;
-        }
-        if (event.blockList().size() < 1) {
+        if (!event.getEntity().hasMetadata(Commandnuke.NUKE_META_KEY)) {
             return;
         }
         event.setCancelled(true);
         event.getLocation().getWorld().createExplosion(event.getLocation(), 0F);
     }
-
-    @Override
-    public void run() {
-        enabled = false;
-    }
 }

Essentials/src/main/java/com/earth2me/essentials/Teleport.java

@@ -1,403 +0,0 @@
-package com.earth2me.essentials;
-
-import com.earth2me.essentials.utils.DateUtil;
-import com.earth2me.essentials.utils.LocationUtil;
-import io.papermc.lib.PaperLib;
-import net.ess3.api.IEssentials;
-import net.ess3.api.ITeleport;
-import net.ess3.api.IUser;
-import net.ess3.api.events.UserWarpEvent;
-import net.ess3.api.events.teleport.PreTeleportEvent;
-import net.ess3.api.events.teleport.TeleportWarmupEvent;
-import org.bukkit.Bukkit;
-import org.bukkit.Location;
-import org.bukkit.entity.Player;
-import org.bukkit.event.player.PlayerRespawnEvent;
-import org.bukkit.event.player.PlayerTeleportEvent.TeleportCause;
-
-import java.math.BigDecimal;
-import java.util.Calendar;
-import java.util.GregorianCalendar;
-
-import static com.earth2me.essentials.I18n.tl;
-
-/**
- * @deprecated This API is not asynchronous. Use {@link com.earth2me.essentials.AsyncTeleport AsyncTeleport}
- */
-@Deprecated
-public class Teleport implements ITeleport {
-    private final IUser teleportOwner;
-    private final IEssentials ess;
-    private TimedTeleport timedTeleport;
-
-    private TeleportType tpType;
-
-    @Deprecated
-    public Teleport(final IUser user, final IEssentials ess) {
-        this.teleportOwner = user;
-        this.ess = ess;
-        tpType = TeleportType.NORMAL;
-    }
-
-    @Deprecated
-    public void cooldown(final boolean check) throws Exception {
-        final Calendar time = new GregorianCalendar();
-        if (teleportOwner.getLastTeleportTimestamp() > 0) {
-            // Take the current time, and remove the delay from it.
-            final double cooldown = ess.getSettings().getTeleportCooldown();
-            final Calendar earliestTime = new GregorianCalendar();
-            earliestTime.add(Calendar.SECOND, -(int) cooldown);
-            earliestTime.add(Calendar.MILLISECOND, -(int) ((cooldown * 1000.0) % 1000.0));
-            // This value contains the most recent time a teleportPlayer could have been used that would allow another use.
-            final long earliestLong = earliestTime.getTimeInMillis();
-
-            // When was the last teleportPlayer used?
-            final long lastTime = teleportOwner.getLastTeleportTimestamp();
-
-            if (lastTime > time.getTimeInMillis()) {
-                // This is to make sure time didn't get messed up on last teleportPlayer use.
-                // If this happens, let's give the user the benifit of the doubt.
-                teleportOwner.setLastTeleportTimestamp(time.getTimeInMillis());
-                return;
-            } else if (lastTime > earliestLong
-                && cooldownApplies()) {
-                time.setTimeInMillis(lastTime);
-                time.add(Calendar.SECOND, (int) cooldown);
-                time.add(Calendar.MILLISECOND, (int) ((cooldown * 1000.0) % 1000.0));
-                throw new Exception(tl("timeBeforeTeleport", DateUtil.formatDateDiff(time.getTimeInMillis())));
-            }
-        }
-        // if justCheck is set, don't update lastTeleport; we're just checking
-        if (!check) {
-            teleportOwner.setLastTeleportTimestamp(time.getTimeInMillis());
-        }
-    }
-
-    @Deprecated
-    private boolean cooldownApplies() {
-        boolean applies = true;
-        final String globalBypassPerm = "essentials.teleport.cooldown.bypass";
-        switch (tpType) {
-            case NORMAL:
-                applies = !teleportOwner.isAuthorized(globalBypassPerm);
-                break;
-            case BACK:
-                applies = !(teleportOwner.isAuthorized(globalBypassPerm) &&
-                    teleportOwner.isAuthorized("essentials.teleport.cooldown.bypass.back"));
-                break;
-            case TPA:
-                applies = !(teleportOwner.isAuthorized(globalBypassPerm) &&
-                    teleportOwner.isAuthorized("essentials.teleport.cooldown.bypass.tpa"));
-                break;
-        }
-        return applies;
-    }
-
-    @Deprecated
-    private void warnUser(final IUser user, final double delay) {
-        final Calendar c = new GregorianCalendar();
-        c.add(Calendar.SECOND, (int) delay);
-        c.add(Calendar.MILLISECOND, (int) ((delay * 1000.0) % 1000.0));
-        user.sendMessage(tl("dontMoveMessage", DateUtil.formatDateDiff(c.getTimeInMillis())));
-    }
-
-    //The now function is used when you want to skip tp delay when teleporting someone to a location or player.
-    @Override
-    @Deprecated
-    public void now(final Location loc, final boolean cooldown, final TeleportCause cause) throws Exception {
-        if (cooldown) {
-            cooldown(false);
-        }
-        final ITarget target = new LocationTarget(loc);
-        now(teleportOwner, target, cause);
-    }
-
-    @Override
-    @Deprecated
-    public void now(final Player entity, final boolean cooldown, final TeleportCause cause) throws Exception {
-        if (cooldown) {
-            cooldown(false);
-        }
-        final ITarget target = new PlayerTarget(entity);
-        now(teleportOwner, target, cause);
-        teleportOwner.sendMessage(tl("teleporting", target.getLocation().getWorld().getName(), target.getLocation().getBlockX(), target.getLocation().getBlockY(), target.getLocation().getBlockZ()));
-    }
-
-    @Deprecated
-    protected void now(final IUser teleportee, final ITarget target, final TeleportCause cause) throws Exception {
-        cancel(false);
-        Location loc = target.getLocation();
-
-        final PreTeleportEvent event = new PreTeleportEvent(teleportee, cause, target);
-        Bukkit.getServer().getPluginManager().callEvent(event);
-        if (event.isCancelled()) {
-            return;
-        }
-
-        if (teleportee.isAuthorized("essentials.back.onteleport")) {
-            teleportee.setLastLocation();
-        }
-
-        if (!teleportee.getBase().isEmpty()) {
-            if (!ess.getSettings().isTeleportPassengerDismount()) {
-                throw new Exception(tl("passengerTeleportFail"));
-            }
-            teleportee.getBase().eject();
-        }
-
-        if (LocationUtil.isBlockUnsafeForUser(ess, teleportee, loc.getWorld(), loc.getBlockX(), loc.getBlockY(), loc.getBlockZ())) {
-            if (ess.getSettings().isTeleportSafetyEnabled()) {
-                if (ess.getSettings().isForceDisableTeleportSafety()) {
-                    PaperLib.teleportAsync(teleportee.getBase(), loc, cause);
-                } else {
-                    PaperLib.teleportAsync(teleportee.getBase(), LocationUtil.getSafeDestination(ess, teleportee, loc), cause);
-                }
-            } else {
-                throw new Exception(tl("unsafeTeleportDestination", loc.getWorld().getName(), loc.getBlockX(), loc.getBlockY(), loc.getBlockZ()));
-            }
-        } else {
-            if (ess.getSettings().isForceDisableTeleportSafety()) {
-                PaperLib.teleportAsync(teleportee.getBase(), loc, cause);
-            } else {
-                if (ess.getSettings().isTeleportToCenterLocation()) {
-                    loc = LocationUtil.getRoundedDestination(loc);
-                }
-                PaperLib.teleportAsync(teleportee.getBase(), loc, cause);
-            }
-        }
-    }
-
-    //The teleportPlayer function is used when you want to normally teleportPlayer someone to a location or player.
-    //This method is nolonger used internally and will be removed.
-    @Deprecated
-    @Override
-    public void teleport(final Location loc, final Trade chargeFor) throws Exception {
-        teleport(loc, chargeFor, TeleportCause.PLUGIN);
-    }
-
-    @Override
-    @Deprecated
-    public void teleport(final Location loc, final Trade chargeFor, final TeleportCause cause) throws Exception {
-        teleport(teleportOwner, new LocationTarget(loc), chargeFor, cause);
-    }
-
-    //This is used when teleporting to a player
-    @Override
-    @Deprecated
-    public void teleport(final Player entity, final Trade chargeFor, final TeleportCause cause) throws Exception {
-        final ITarget target = new PlayerTarget(entity);
-        teleportOwner.sendMessage(tl("teleportToPlayer", entity.getDisplayName()));
-        teleport(teleportOwner, target, chargeFor, cause);
-    }
-
-    //This is used when teleporting to stored location
-    @Override
-    @Deprecated
-    public void teleportPlayer(final IUser teleportee, final Location loc, final Trade chargeFor, final TeleportCause cause) throws Exception {
-        teleport(teleportee, new LocationTarget(loc), chargeFor, cause);
-    }
-
-    //This is used on /tphere
-    @Override
-    @Deprecated
-    public void teleportPlayer(final IUser teleportee, final Player entity, final Trade chargeFor, final TeleportCause cause) throws Exception {
-        final ITarget target = new PlayerTarget(entity);
-        teleport(teleportee, target, chargeFor, cause);
-        teleportee.sendMessage(tl("teleporting", target.getLocation().getWorld().getName(), target.getLocation().getBlockX(), target.getLocation().getBlockY(), target.getLocation().getBlockZ()));
-        teleportOwner.sendMessage(tl("teleporting", target.getLocation().getWorld().getName(), target.getLocation().getBlockX(), target.getLocation().getBlockY(), target.getLocation().getBlockZ()));
-    }
-
-    @Deprecated
-    private void teleport(final IUser teleportee, final ITarget target, final Trade chargeFor, final TeleportCause cause) throws Exception {
-        double delay = ess.getSettings().getTeleportDelay();
-
-        final TeleportWarmupEvent event = new TeleportWarmupEvent(teleportee, cause, target, delay);
-        Bukkit.getServer().getPluginManager().callEvent(event);
-        if (event.isCancelled()) {
-            return;
-        }
-        delay = event.getDelay();
-
-        Trade cashCharge = chargeFor;
-
-        if (chargeFor != null) {
-            chargeFor.isAffordableFor(teleportOwner);
-
-            //This code is to make sure that commandcosts are checked in the initial world, and not in the resulting world.
-            if (!chargeFor.getCommandCost(teleportOwner).equals(BigDecimal.ZERO)) {
-                //By converting a command cost to a regular cost, the command cost permission isn't checked when executing the charge after teleport.
-                cashCharge = new Trade(chargeFor.getCommandCost(teleportOwner), ess);
-            }
-        }
-
-        cooldown(true);
-        if (delay <= 0 || teleportOwner.isAuthorized("essentials.teleport.timer.bypass") || teleportee.isAuthorized("essentials.teleport.timer.bypass")) {
-            cooldown(false);
-            now(teleportee, target, cause);
-            if (cashCharge != null) {
-                cashCharge.charge(teleportOwner);
-            }
-            return;
-        }
-
-        cancel(false);
-        warnUser(teleportee, delay);
-        initTimer((long) (delay * 1000.0), teleportee, target, cashCharge, cause, false);
-    }
-
-    @Deprecated
-    private void teleportOther(final IUser teleporter, final IUser teleportee, final ITarget target, final Trade chargeFor, final TeleportCause cause) throws Exception {
-        double delay = ess.getSettings().getTeleportDelay();
-
-        final TeleportWarmupEvent event = new TeleportWarmupEvent(teleporter, teleportee, cause, target, delay);
-        Bukkit.getServer().getPluginManager().callEvent(event);
-        if (event.isCancelled()) {
-            return;
-        }
-        delay = event.getDelay();
-
-        Trade cashCharge = chargeFor;
-
-        if (teleporter != null && chargeFor != null) {
-            chargeFor.isAffordableFor(teleporter);
-
-            //This code is to make sure that commandcosts are checked in the initial world, and not in the resulting world.
-            if (!chargeFor.getCommandCost(teleporter).equals(BigDecimal.ZERO)) {
-                //By converting a command cost to a regular cost, the command cost permission isn't checked when executing the charge after teleport.
-                cashCharge = new Trade(chargeFor.getCommandCost(teleporter), ess);
-            }
-        }
-
-        cooldown(true);
-        if (delay <= 0 || teleporter == null
-            || teleporter.isAuthorized("essentials.teleport.timer.bypass")
-            || teleportOwner.isAuthorized("essentials.teleport.timer.bypass")
-            || teleportee.isAuthorized("essentials.teleport.timer.bypass")) {
-            cooldown(false);
-            now(teleportee, target, cause);
-            if (teleporter != null && cashCharge != null) {
-                cashCharge.charge(teleporter);
-            }
-            return;
-        }
-
-        cancel(false);
-        warnUser(teleportee, delay);
-        initTimer((long) (delay * 1000.0), teleportee, target, cashCharge, cause, false);
-    }
-
-    //The respawn function is a wrapper used to handle tp fallback, on /jail and /home
-    @Override
-    @Deprecated
-    public void respawn(final Trade chargeFor, final TeleportCause cause) throws Exception {
-        double delay = ess.getSettings().getTeleportDelay();
-
-        final TeleportWarmupEvent event = new TeleportWarmupEvent(teleportOwner, cause, null, delay);
-        Bukkit.getServer().getPluginManager().callEvent(event);
-        if (event.isCancelled()) {
-            return;
-        }
-        delay = event.getDelay();
-
-        if (chargeFor != null) {
-            chargeFor.isAffordableFor(teleportOwner);
-        }
-        cooldown(true);
-        if (delay <= 0 || teleportOwner.isAuthorized("essentials.teleport.timer.bypass")) {
-            cooldown(false);
-            respawnNow(teleportOwner, cause);
-            if (chargeFor != null) {
-                chargeFor.charge(teleportOwner);
-            }
-            return;
-        }
-
-        cancel(false);
-        warnUser(teleportOwner, delay);
-        initTimer((long) (delay * 1000.0), teleportOwner, null, chargeFor, cause, true);
-    }
-
-    @Deprecated
-    void respawnNow(final IUser teleportee, final TeleportCause cause) throws Exception {
-        final Player player = teleportee.getBase();
-        final Location bed = player.getBedSpawnLocation();
-        if (bed != null) {
-            now(teleportee, new LocationTarget(bed), cause);
-        } else {
-            if (ess.getSettings().isDebug()) {
-                ess.getLogger().info("Could not find bed spawn, forcing respawn event.");
-            }
-            final PlayerRespawnEvent pre = new PlayerRespawnEvent(player, player.getWorld().getSpawnLocation(), false);
-            ess.getServer().getPluginManager().callEvent(pre);
-            now(teleportee, new LocationTarget(pre.getRespawnLocation()), cause);
-        }
-    }
-
-    //The warp function is a wrapper used to teleportPlayer a player to a /warp
-    @Override
-    @Deprecated
-    public void warp(final IUser teleportee, String warp, final Trade chargeFor, final TeleportCause cause) throws Exception {
-        final UserWarpEvent event = new UserWarpEvent(teleportee, warp, chargeFor);
-        Bukkit.getServer().getPluginManager().callEvent(event);
-        if (event.isCancelled()) {
-            return;
-        }
-
-        warp = event.getWarp();
-        final Location loc = ess.getWarps().getWarp(warp);
-        teleportee.sendMessage(tl("warpingTo", warp, loc.getWorld().getName(), loc.getBlockX(), loc.getBlockY(), loc.getBlockZ()));
-        if (!teleportee.equals(teleportOwner)) {
-            teleportOwner.sendMessage(tl("warpingTo", warp, loc.getWorld().getName(), loc.getBlockX(), loc.getBlockY(), loc.getBlockZ()));
-        }
-        teleport(teleportee, new LocationTarget(loc), chargeFor, cause);
-    }
-
-    //The back function is a wrapper used to teleportPlayer a player /back to their previous location.
-    @Override
-    @Deprecated
-    public void back(final Trade chargeFor) throws Exception {
-        back(teleportOwner, chargeFor);
-    }
-
-    //This function is a wrapper over the other back function for cases where another player performs back for them
-    @Override
-    @Deprecated
-    public void back(final IUser teleporter, final Trade chargeFor) throws Exception {
-        tpType = TeleportType.BACK;
-        final Location loc = teleportOwner.getLastLocation();
-        teleportOwner.sendMessage(tl("backUsageMsg", loc.getWorld().getName(), loc.getBlockX(), loc.getBlockY(), loc.getBlockZ()));
-        teleportOther(teleporter, teleportOwner, new LocationTarget(loc), chargeFor, TeleportCause.COMMAND);
-    }
-
-    //This function is used to throw a user back after a jail sentence
-    @Override
-    @Deprecated
-    public void back() throws Exception {
-        now(teleportOwner, new LocationTarget(teleportOwner.getLastLocation()), TeleportCause.COMMAND);
-    }
-
-    @Deprecated
-    public void setTpType(final TeleportType tpType) {
-        this.tpType = tpType;
-    }
-
-    //If we need to cancelTimer a pending teleportPlayer call this method
-    @Deprecated
-    private void cancel(final boolean notifyUser) {
-        if (timedTeleport != null) {
-            timedTeleport.cancelTimer(notifyUser);
-            timedTeleport = null;
-        }
-    }
-
-    @Deprecated
-    private void initTimer(final long delay, final IUser teleportUser, final ITarget target, final Trade chargeFor, final TeleportCause cause, final boolean respawn) {
-        timedTeleport = new TimedTeleport(teleportOwner, ess, this, delay, teleportUser, target, chargeFor, cause, respawn);
-    }
-
-    public enum TeleportType {
-        TPA,
-        BACK,
-        NORMAL
-    }
-}

Essentials/src/main/java/com/earth2me/essentials/TimedTeleport.java

@@ -1,140 +0,0 @@
-package com.earth2me.essentials;
-
-import net.ess3.api.IEssentials;
-import net.ess3.api.IUser;
-import org.bukkit.Location;
-import org.bukkit.event.player.PlayerTeleportEvent.TeleportCause;
-
-import java.util.UUID;
-
-import static com.earth2me.essentials.I18n.tl;
-
-@Deprecated
-public class TimedTeleport implements Runnable {
-    private static final double MOVE_CONSTANT = 0.3;
-    private final IUser teleportOwner;
-    private final IEssentials ess;
-    private final Teleport teleport;
-    private final UUID timer_teleportee;
-    private final long timer_started; // time this task was initiated
-    private final long timer_delay; // how long to delay the teleportPlayer
-    // note that I initially stored a clone of the location for reference, but...
-    // when comparing locations, I got incorrect mismatches (rounding errors, looked like)
-    // so, the X/Y/Z values are stored instead and rounded off
-    private final long timer_initX;
-    private final long timer_initY;
-    private final long timer_initZ;
-    private final ITarget timer_teleportTarget;
-    private final boolean timer_respawn;
-    private final boolean timer_canMove;
-    private final Trade timer_chargeFor;
-    private final TeleportCause timer_cause;
-    private int timer_task;
-    private double timer_health;
-
-    TimedTeleport(final IUser user, final IEssentials ess, final Teleport teleport, final long delay, final IUser teleportUser, final ITarget target, final Trade chargeFor, final TeleportCause cause, final boolean respawn) {
-        this.teleportOwner = user;
-        this.ess = ess;
-        this.teleport = teleport;
-        this.timer_started = System.currentTimeMillis();
-        this.timer_delay = delay;
-        this.timer_health = teleportUser.getBase().getHealth();
-        this.timer_initX = Math.round(teleportUser.getBase().getLocation().getX() * MOVE_CONSTANT);
-        this.timer_initY = Math.round(teleportUser.getBase().getLocation().getY() * MOVE_CONSTANT);
-        this.timer_initZ = Math.round(teleportUser.getBase().getLocation().getZ() * MOVE_CONSTANT);
-        this.timer_teleportee = teleportUser.getBase().getUniqueId();
-        this.timer_teleportTarget = target;
-        this.timer_chargeFor = chargeFor;
-        this.timer_cause = cause;
-        this.timer_respawn = respawn;
-        this.timer_canMove = user.isAuthorized("essentials.teleport.timer.move");
-
-        timer_task = ess.runTaskTimerAsynchronously(this, 20, 20).getTaskId();
-    }
-
-    @Override
-    public void run() {
-
-        if (teleportOwner == null || !teleportOwner.getBase().isOnline() || teleportOwner.getBase().getLocation() == null) {
-            cancelTimer(false);
-            return;
-        }
-
-        final IUser teleportUser = ess.getUser(this.timer_teleportee);
-
-        if (teleportUser == null || !teleportUser.getBase().isOnline()) {
-            cancelTimer(false);
-            return;
-        }
-
-        final Location currLocation = teleportUser.getBase().getLocation();
-        if (currLocation == null) {
-            cancelTimer(false);
-            return;
-        }
-
-        if (!timer_canMove && (Math.round(currLocation.getX() * MOVE_CONSTANT) != timer_initX || Math.round(currLocation.getY() * MOVE_CONSTANT) != timer_initY || Math.round(currLocation.getZ() * MOVE_CONSTANT) != timer_initZ || teleportUser.getBase().getHealth() < timer_health)) {
-            // user moved, cancelTimer teleportPlayer
-            cancelTimer(true);
-            return;
-        }
-
-        class DelayedTeleportTask implements Runnable {
-            @Override
-            public void run() {
-
-                timer_health = teleportUser.getBase().getHealth(); // in case user healed, then later gets injured
-                final long now = System.currentTimeMillis();
-                if (now > timer_started + timer_delay) {
-                    try {
-                        teleport.cooldown(false);
-                    } catch (final Exception ex) {
-                        teleportOwner.sendMessage(tl("cooldownWithMessage", ex.getMessage()));
-                        if (teleportOwner != teleportUser) {
-                            teleportUser.sendMessage(tl("cooldownWithMessage", ex.getMessage()));
-                        }
-                    }
-                    try {
-                        cancelTimer(false);
-                        teleportUser.sendMessage(tl("teleportationCommencing"));
-
-                        if (timer_chargeFor != null) {
-                            timer_chargeFor.isAffordableFor(teleportOwner);
-                        }
-                        if (timer_respawn) {
-                            teleport.respawnNow(teleportUser, timer_cause);
-                        } else {
-                            teleport.now(teleportUser, timer_teleportTarget, timer_cause);
-                        }
-                        if (timer_chargeFor != null) {
-                            timer_chargeFor.charge(teleportOwner);
-                        }
-
-                    } catch (final Exception ex) {
-                        ess.showError(teleportOwner.getSource(), ex, "\\ teleport");
-                    }
-                }
-            }
-        }
-
-        ess.scheduleSyncDelayedTask(new DelayedTeleportTask());
-    }
-
-    //If we need to cancelTimer a pending teleportPlayer call this method
-    void cancelTimer(final boolean notifyUser) {
-        if (timer_task == -1) {
-            return;
-        }
-        try {
-            ess.getServer().getScheduler().cancelTask(timer_task);
-            if (notifyUser) {
-                teleportOwner.sendMessage(tl("pendingTeleportCancelled"));
-                if (timer_teleportee != null && !timer_teleportee.equals(teleportOwner.getBase().getUniqueId())) {
-                    ess.getUser(timer_teleportee).sendMessage(tl("pendingTeleportCancelled"));
-                }
-            }
-        } finally {
-            timer_task = -1;
-        }
-    }
-}

Essentials/src/main/java/com/earth2me/essentials/Trade.java

@@ -1,13 +1,14 @@
 package com.earth2me.essentials;
 
-import com.earth2me.essentials.craftbukkit.InventoryWorkaround;
+import com.earth2me.essentials.craftbukkit.Inventories;
 import com.earth2me.essentials.craftbukkit.SetExpFix;
+import com.earth2me.essentials.adventure.AdventureUtil;
 import com.earth2me.essentials.utils.NumberUtil;
+import com.earth2me.essentials.utils.VersionUtil;
 import net.ess3.api.IEssentials;
 import net.ess3.api.IUser;
 import net.ess3.api.MaxMoneyException;
 import org.bukkit.Location;
-import org.bukkit.entity.Item;
 import org.bukkit.inventory.ItemStack;
 
 import java.io.File;
@@ -15,15 +16,14 @@ import java.io.FileWriter;
 import java.io.IOException;
 import java.math.BigDecimal;
 import java.text.DateFormat;
+import java.util.Collections;
 import java.util.Date;
 import java.util.Locale;
 import java.util.Map;
+import java.util.UUID;
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.ExecutionException;
 import java.util.logging.Level;
-import java.util.logging.Logger;
-
-import static com.earth2me.essentials.I18n.tl;
 
 public class Trade {
     private static FileWriter fw = null;
@@ -79,7 +79,7 @@ public class Trade {
             try {
                 fw = new FileWriter(new File(ess.getDataFolder(), "trade.log"), true);
             } catch (final IOException ex) {
-                Logger.getLogger("Essentials").log(Level.SEVERE, null, ex);
+                Essentials.getWrappedLogger().log(Level.SEVERE, null, ex);
             }
         }
         final StringBuilder sb = new StringBuilder();
@@ -87,7 +87,14 @@ public class Trade {
         sb.append(DateFormat.getDateTimeInstance(DateFormat.FULL, DateFormat.FULL).format(new Date()));
         sb.append("\",\"");
         if (sender != null) {
-            sb.append(sender);
+            String senderIdentifier = sender;
+            if (ess.getSettings().isEcoLogUUIDEnabled()) {
+                final UUID uuid = ess.getUsers().getNameCache().get(sender);
+                if (uuid != null) {
+                    senderIdentifier = uuid.toString();
+                }
+            }
+            sb.append(senderIdentifier);
         }
         sb.append("\",");
         if (charge == null) {
@@ -95,8 +102,10 @@ public class Trade {
         } else {
             if (charge.getItemStack() != null) {
                 sb.append(charge.getItemStack().getAmount()).append(",");
-                sb.append(charge.getItemStack().getType().toString()).append(",");
-                sb.append(charge.getItemStack().getDurability());
+                sb.append(charge.getItemStack().getType()).append(",");
+                if (VersionUtil.PRE_FLATTENING) {
+                    sb.append(charge.getItemStack().getDurability());
+                }
             }
             if (charge.getMoney() != null) {
                 sb.append(charge.getMoney()).append(",");
@@ -111,7 +120,14 @@ public class Trade {
         }
         sb.append(",\"");
         if (receiver != null) {
-            sb.append(receiver);
+            String receiverIdentifier = receiver;
+            if (ess.getSettings().isEcoLogUUIDEnabled()) {
+                final UUID uuid = ess.getUsers().getNameCache().get(receiver);
+                if (uuid != null) {
+                    receiverIdentifier = uuid.toString();
+                }
+            }
+            sb.append(receiverIdentifier);
         }
         sb.append("\",");
         if (pay == null) {
@@ -119,8 +135,10 @@ public class Trade {
         } else {
             if (pay.getItemStack() != null) {
                 sb.append(pay.getItemStack().getAmount()).append(",");
-                sb.append(pay.getItemStack().getType().toString()).append(",");
-                sb.append(pay.getItemStack().getDurability());
+                sb.append(pay.getItemStack().getType()).append(",");
+                if (VersionUtil.PRE_FLATTENING) {
+                    sb.append(pay.getItemStack().getDurability());
+                }
             }
             if (pay.getMoney() != null) {
                 sb.append(pay.getMoney()).append(",");
@@ -142,7 +160,7 @@ public class Trade {
             sb.append(loc.getBlockY()).append(",");
             sb.append(loc.getBlockZ()).append(",");
         }
-        
+
         if (endBalance == null) {
             sb.append(",");
         } else {
@@ -154,7 +172,7 @@ public class Trade {
             fw.write(sb.toString());
             fw.flush();
         } catch (final IOException ex) {
-            Logger.getLogger("Essentials").log(Level.SEVERE, null, ex);
+            Essentials.getWrappedLogger().log(Level.SEVERE, null, ex);
         }
     }
 
@@ -163,7 +181,7 @@ public class Trade {
             try {
                 fw.close();
             } catch (final IOException ex) {
-                Logger.getLogger("Essentials").log(Level.SEVERE, null, ex);
+                Essentials.getWrappedLogger().log(Level.SEVERE, null, ex);
             }
             fw = null;
         }
@@ -189,23 +207,23 @@ public class Trade {
         }
 
         if (getMoney() != null && getMoney().signum() > 0 && !user.canAfford(getMoney())) {
-            future.completeExceptionally(new ChargeException(tl("notEnoughMoney", NumberUtil.displayCurrency(getMoney(), ess))));
+            future.completeExceptionally(new ChargeException("notEnoughMoney", AdventureUtil.parsed(NumberUtil.displayCurrency(getMoney(), ess))));
             return;
         }
 
-        if (getItemStack() != null && !user.getBase().getInventory().containsAtLeast(itemStack, itemStack.getAmount())) {
-            future.completeExceptionally(new ChargeException(tl("missingItems", getItemStack().getAmount(), ess.getItemDb().name(getItemStack()))));
+        if (getItemStack() != null && !Inventories.containsAtLeast(user.getBase(), itemStack, itemStack.getAmount())) {
+            future.completeExceptionally(new ChargeException("missingItems", getItemStack().getAmount(), ess.getItemDb().name(getItemStack())));
             return;
         }
 
         final BigDecimal money;
         if (command != null && !command.isEmpty() && (money = getCommandCost(user)).signum() > 0 && !user.canAfford(money)) {
-            future.completeExceptionally(new ChargeException(tl("notEnoughMoney", NumberUtil.displayCurrency(money, ess))));
+            future.completeExceptionally(new ChargeException("notEnoughMoney", AdventureUtil.parsed(NumberUtil.displayCurrency(money, ess))));
             return;
         }
 
         if (exp != null && exp > 0 && SetExpFix.getTotalExperience(user.getBase()) < exp) {
-            future.completeExceptionally(new ChargeException(tl("notEnoughExperience")));
+            future.completeExceptionally(new ChargeException("notEnoughExperience"));
         }
     }
 
@@ -221,52 +239,33 @@ public class Trade {
             user.giveMoney(getMoney());
         }
         if (getItemStack() != null) {
-            // This stores the would be overflow
-            final Map<Integer, ItemStack> overFlow = InventoryWorkaround.addAllItems(user.getBase().getInventory(), getItemStack());
+            if (type == OverflowType.ABORT && !Inventories.hasSpace(user.getBase(), 0, false, getItemStack())) {
+                if (ess.getSettings().isDebug()) {
+                    ess.getLogger().log(Level.INFO, "abort paying " + user.getName() + " itemstack " + getItemStack().toString() + " due to lack of inventory space ");
+                }
+                return Collections.singletonMap(0, getItemStack());
+            }
 
-            if (overFlow != null) {
-                switch (type) {
-                    case ABORT:
-                        if (ess.getSettings().isDebug()) {
-                            ess.getLogger().log(Level.INFO, "abort paying " + user.getName() + " itemstack " + getItemStack().toString() + " due to lack of inventory space ");
+            final Map<Integer, ItemStack> leftover = Inventories.addItem(user.getBase(), getItemStack());
+            user.getBase().updateInventory();
+            if (!leftover.isEmpty()) {
+                if (type == OverflowType.RETURN) {
+                    if (ess.getSettings().isDebug()) {
+                        ess.getLogger().log(Level.INFO, "paying " + user.getName() + " partial itemstack " + getItemStack().toString() + " with overflow " + leftover.get(0).toString());
+                    }
+                    return leftover;
+                } else {
+                    for (final ItemStack itemStack : leftover.values()) {
+                        int spillAmount = itemStack.getAmount();
+                        while (spillAmount > 0) {
+                            itemStack.setAmount(Math.min(spillAmount, itemStack.getMaxStackSize()));
+                            user.getBase().getWorld().dropItemNaturally(user.getBase().getLocation(), itemStack);
+                            spillAmount -= itemStack.getAmount();
                         }
-
-                        return overFlow;
-
-                    case RETURN:
-                        // Pay the user the items, and return overflow
-                        final Map<Integer, ItemStack> returnStack = InventoryWorkaround.addItems(user.getBase().getInventory(), getItemStack());
-                        user.getBase().updateInventory();
-
-                        if (ess.getSettings().isDebug()) {
-                            ess.getLogger().log(Level.INFO, "paying " + user.getName() + " partial itemstack " + getItemStack().toString() + " with overflow " + returnStack.get(0).toString());
-                        }
-
-                        return returnStack;
-                    case DROP:
-                        // Pay the users the items directly, and drop the rest, will always return no overflow.
-                        final Map<Integer, ItemStack> leftOver = InventoryWorkaround.addItems(user.getBase().getInventory(), getItemStack());
-                        final Location loc = user.getBase().getLocation();
-                        for (final ItemStack loStack : leftOver.values()) {
-                            final int maxStackSize = loStack.getType().getMaxStackSize();
-                            final int stacks = loStack.getAmount() / maxStackSize;
-                            final int leftover = loStack.getAmount() % maxStackSize;
-                            final Item[] itemStacks = new Item[stacks + (leftover > 0 ? 1 : 0)];
-                            for (int i = 0; i < stacks; i++) {
-                                final ItemStack stack = loStack.clone();
-                                stack.setAmount(maxStackSize);
-                                itemStacks[i] = loc.getWorld().dropItem(loc, stack);
-                            }
-                            if (leftover > 0) {
-                                final ItemStack stack = loStack.clone();
-                                stack.setAmount(leftover);
-                                itemStacks[stacks] = loc.getWorld().dropItem(loc, stack);
-                            }
-                        }
-                        if (ess.getSettings().isDebug()) {
-                            ess.getLogger().log(Level.INFO, "paying " + user.getName() + " partial itemstack " + getItemStack().toString() + " and dropping overflow " + leftOver.get(0).toString());
-                        }
-                        break;
+                    }
+                    if (ess.getSettings().isDebug()) {
+                        ess.getLogger().log(Level.INFO, "paying " + user.getName() + " partial itemstack " + getItemStack().toString() + " and dropping overflow " + leftover.get(0).toString());
+                    }
                 }
             } else if (ess.getSettings().isDebug()) {
                 ess.getLogger().log(Level.INFO, "paying " + user.getName() + " itemstack " + getItemStack().toString());
@@ -302,7 +301,7 @@ public class Trade {
                 ess.getLogger().log(Level.INFO, "charging user " + user.getName() + " money " + getMoney().toPlainString());
             }
             if (!user.canAfford(getMoney()) && getMoney().signum() > 0) {
-                future.completeExceptionally(new ChargeException(tl("notEnoughMoney", NumberUtil.displayCurrency(getMoney(), ess))));
+                future.completeExceptionally(new ChargeException("notEnoughMoney", AdventureUtil.parsed(NumberUtil.displayCurrency(getMoney(), ess))));
                 return;
             }
             user.takeMoney(getMoney());
@@ -311,17 +310,17 @@ public class Trade {
             if (ess.getSettings().isDebug()) {
                 ess.getLogger().log(Level.INFO, "charging user " + user.getName() + " itemstack " + getItemStack().toString());
             }
-            if (!user.getBase().getInventory().containsAtLeast(getItemStack(), getItemStack().getAmount())) {
-                future.completeExceptionally(new ChargeException(tl("missingItems", getItemStack().getAmount(), getItemStack().getType().toString().toLowerCase(Locale.ENGLISH).replace("_", " "))));
+            if (!Inventories.containsAtLeast(user.getBase(), getItemStack(), getItemStack().getAmount())) {
+                future.completeExceptionally(new ChargeException("missingItems", getItemStack().getAmount(), getItemStack().getType().toString().toLowerCase(Locale.ENGLISH).replace("_", " ")));
                 return;
             }
-            user.getBase().getInventory().removeItem(getItemStack());
+            Inventories.removeItemAmount(user.getBase(), getItemStack(), getItemStack().getAmount());
             user.getBase().updateInventory();
         }
         if (command != null) {
             final BigDecimal cost = getCommandCost(user);
             if (!user.canAfford(cost) && cost.signum() > 0) {
-                future.completeExceptionally(new ChargeException(tl("notEnoughMoney", NumberUtil.displayCurrency(cost, ess))));
+                future.completeExceptionally(new ChargeException("notEnoughMoney", AdventureUtil.parsed(NumberUtil.displayCurrency(cost, ess))));
                 return;
             }
             user.takeMoney(cost);
@@ -332,7 +331,7 @@ public class Trade {
             }
             final int experience = SetExpFix.getTotalExperience(user.getBase());
             if (experience < getExperience() && getExperience() > 0) {
-                future.completeExceptionally(new ChargeException(tl("notEnoughExperience")));
+                future.completeExceptionally(new ChargeException("notEnoughExperience"));
                 return;
             }
             SetExpFix.setTotalExperience(user.getBase(), experience - getExperience());

Essentials/src/main/java/com/earth2me/essentials/UUIDMap.java

@@ -1,156 +1,19 @@
 package com.earth2me.essentials;
 
-import com.google.common.io.Files;
-import org.bukkit.Bukkit;
-
-import java.io.BufferedReader;
-import java.io.BufferedWriter;
-import java.io.File;
-import java.io.FileReader;
-import java.io.FileWriter;
-import java.io.IOException;
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.Map;
-import java.util.UUID;
-import java.util.concurrent.ConcurrentSkipListMap;
-import java.util.concurrent.Executors;
-import java.util.concurrent.ScheduledExecutorService;
-import java.util.concurrent.TimeUnit;
-import java.util.logging.Level;
-import java.util.regex.Pattern;
-
+@Deprecated
 public class UUIDMap {
-    private static final ScheduledExecutorService writeScheduler = Executors.newScheduledThreadPool(1);
-    private static boolean pendingWrite;
-    private static boolean loading = false;
-    private final transient net.ess3.api.IEssentials ess;
-    private final File userList;
-    private final transient Pattern splitPattern = Pattern.compile(",");
-    private final Runnable writeTaskRunnable;
-
-    public UUIDMap(final net.ess3.api.IEssentials ess) {
-        this.ess = ess;
-        userList = new File(ess.getDataFolder(), "usermap.csv");
-        pendingWrite = false;
-        writeTaskRunnable = () -> {
-            if (pendingWrite) {
-                try {
-                    new WriteRunner(ess.getDataFolder(), userList, ess.getUserMap().getNames()).run();
-                } catch (final Throwable t) { // bad code to prevent task from being suppressed
-                    t.printStackTrace();
-                }
-            }
-        };
-        writeScheduler.scheduleWithFixedDelay(writeTaskRunnable, 5, 5, TimeUnit.SECONDS);
-    }
-
-    public void loadAllUsers(final ConcurrentSkipListMap<String, UUID> names, final ConcurrentSkipListMap<UUID, ArrayList<String>> history) {
-        try {
-            if (!userList.exists()) {
-                userList.createNewFile();
-            }
-
-            if (ess.getSettings().isDebug()) {
-                ess.getLogger().log(Level.INFO, "Reading usermap from disk");
-            }
-
-            if (loading) {
-                return;
-            }
-
-            names.clear();
-            history.clear();
-            loading = true;
-
-            try (final BufferedReader reader = new BufferedReader(new FileReader(userList))) {
-                while (true) {
-                    final String line = reader.readLine();
-                    if (line == null) {
-                        break;
-                    } else {
-                        final String[] values = splitPattern.split(line);
-                        if (values.length == 2) {
-                            final String name = values[0];
-                            final UUID uuid = UUID.fromString(values[1]);
-                            names.put(name, uuid);
-                            if (!history.containsKey(uuid)) {
-                                final ArrayList<String> list = new ArrayList<>();
-                                list.add(name);
-                                history.put(uuid, list);
-                            } else {
-                                final ArrayList<String> list = history.get(uuid);
-                                if (!list.contains(name)) {
-                                    list.add(name);
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-            loading = false;
-        } catch (final IOException ex) {
-            Bukkit.getLogger().log(Level.SEVERE, ex.getMessage(), ex);
-        }
+    public UUIDMap() {
     }
 
     public void writeUUIDMap() {
-        pendingWrite = true;
+        //no-op
     }
 
     public void forceWriteUUIDMap() {
-        if (ess.getSettings().isDebug()) {
-            ess.getLogger().log(Level.INFO, "Forcing usermap write to disk");
-        }
-        pendingWrite = true;
-        writeTaskRunnable.run();
+        //no-op
     }
 
     public void shutdown() {
-        writeScheduler.submit(writeTaskRunnable);
-        writeScheduler.shutdown();
-    }
-
-    private static final class WriteRunner implements Runnable {
-        private final File location;
-        private final File endFile;
-        private final Map<String, UUID> names;
-
-        private WriteRunner(final File location, final File endFile, final Map<String, UUID> names) {
-            this.location = location;
-            this.endFile = endFile;
-            this.names = new HashMap<>(names);
-        }
-
-        @Override
-        public void run() {
-            pendingWrite = false;
-            if (loading || names.isEmpty()) {
-                return;
-            }
-            File configFile = null;
-
-            try {
-                configFile = File.createTempFile("usermap", ".tmp.csv", location);
-
-                final BufferedWriter bWriter = new BufferedWriter(new FileWriter(configFile));
-                for (final Map.Entry<String, UUID> entry : names.entrySet()) {
-                    bWriter.write(entry.getKey() + "," + entry.getValue().toString());
-                    bWriter.newLine();
-                }
-
-                bWriter.close();
-                Files.move(configFile, endFile);
-            } catch (final IOException ex) {
-                try {
-                    if (configFile != null && configFile.exists()) {
-                        Files.move(configFile, new File(endFile.getParentFile(), "usermap.bak.csv"));
-                    }
-                } catch (final Exception ex2) {
-                    Bukkit.getLogger().log(Level.SEVERE, ex2.getMessage(), ex2);
-                }
-                Bukkit.getLogger().log(Level.WARNING, ex.getMessage(), ex);
-            }
-        }
+        //no-op
     }
 }

Essentials/src/main/java/com/earth2me/essentials/User.java

@@ -1,6 +1,9 @@
 package com.earth2me.essentials;
 
+import com.earth2me.essentials.adventure.AdventureUtil;
+import com.earth2me.essentials.adventure.ComponentHolder;
 import com.earth2me.essentials.commands.IEssentialsCommand;
+import com.earth2me.essentials.craftbukkit.Inventories;
 import com.earth2me.essentials.economy.EconomyLayer;
 import com.earth2me.essentials.economy.EconomyLayers;
 import com.earth2me.essentials.messaging.IMessageRecipient;
@@ -14,10 +17,13 @@ import com.earth2me.essentials.utils.VersionUtil;
 import com.google.common.collect.Lists;
 import net.ess3.api.IEssentials;
 import net.ess3.api.MaxMoneyException;
+import net.ess3.api.TranslatableException;
 import net.ess3.api.events.AfkStatusChangeEvent;
 import net.ess3.api.events.JailStatusChangeEvent;
 import net.ess3.api.events.MuteStatusChangeEvent;
 import net.ess3.api.events.UserBalanceUpdateEvent;
+import net.ess3.provider.PlayerLocaleProvider;
+import net.essentialsx.api.v2.events.PreTransactionEvent;
 import net.essentialsx.api.v2.events.TransactionEvent;
 import net.essentialsx.api.v2.services.mail.MailSender;
 import org.bukkit.Location;
@@ -27,17 +33,17 @@ import org.bukkit.block.Block;
 import org.bukkit.entity.Player;
 import org.bukkit.event.player.PlayerTeleportEvent.TeleportCause;
 import org.bukkit.inventory.ItemStack;
-import org.bukkit.inventory.PlayerInventory;
 import org.bukkit.metadata.FixedMetadataValue;
 import org.bukkit.potion.PotionEffect;
 import org.bukkit.potion.PotionEffectType;
 import org.checkerframework.checker.nullness.qual.Nullable;
 
 import java.math.BigDecimal;
+import java.util.ArrayList;
 import java.util.Calendar;
 import java.util.Collection;
+import java.util.Collections;
 import java.util.GregorianCalendar;
-import java.util.Iterator;
 import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Locale;
@@ -47,21 +53,21 @@ import java.util.WeakHashMap;
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.TimeUnit;
 import java.util.logging.Level;
-import java.util.logging.Logger;
 
-import static com.earth2me.essentials.I18n.tl;
+import static com.earth2me.essentials.I18n.tlLiteral;
+import static com.earth2me.essentials.I18n.tlLocale;
 
 public class User extends UserData implements Comparable<User>, IMessageRecipient, net.ess3.api.IUser {
     private static final Statistic PLAY_ONE_TICK = EnumUtil.getStatistic("PLAY_ONE_MINUTE", "PLAY_ONE_TICK");
-    private static final Logger logger = Logger.getLogger("Essentials");
 
     // User modules
     private final IMessageRecipient messageRecipient;
     private transient final AsyncTeleport teleport;
-    private transient final Teleport legacyTeleport;
 
     // User command confirmation strings
     private final Map<User, BigDecimal> confirmingPayments = new WeakHashMap<>();
+    private String confirmingClearCommand;
+    private String lastHomeConfirmation;
 
     // User teleport variables
     private final transient LinkedHashMap<String, TpaRequest> teleportRequestQueue = new LinkedHashMap<>();
@@ -69,33 +75,38 @@ public class User extends UserData implements Comparable<User>, IMessageRecipien
     // User properties
     private transient boolean vanished;
     private boolean hidden = false;
+    private boolean leavingHidden = false;
     private boolean rightClickJump = false;
     private boolean invSee = false;
     private boolean recipeSee = false;
     private boolean enderSee = false;
     private boolean ignoreMsg = false;
+    private Boolean toggleShout;
+    private boolean freeze = false;
 
     // User afk variables
     private String afkMessage;
     private long afkSince;
     private transient Location afkPosition = null;
 
-    // Misc
+    // Timestamps
     private transient long lastOnlineActivity;
     private transient long lastThrottledAction;
     private transient long lastActivity = System.currentTimeMillis();
     private transient long teleportInvulnerabilityTimestamp = 0;
-    private String confirmingClearCommand;
     private long lastNotifiedAboutMailsMs;
-    private String lastHomeConfirmation;
     private long lastHomeConfirmationTimestamp;
-    private boolean toggleShout = false;
+
+    // Misc
     private transient final List<String> signCopy = Lists.newArrayList("", "", "", "");
+    private transient long lastVanishTime = System.currentTimeMillis();
+    private transient int flightTick = -1;
+    private String lastLocaleString;
+    private Locale playerLocale;
 
     public User(final Player base, final IEssentials ess) {
         super(base, ess);
         teleport = new AsyncTeleport(this, ess);
-        legacyTeleport = new Teleport(this, ess);
         if (isAfk()) {
             afkPosition = this.getLocation();
         }
@@ -105,10 +116,14 @@ public class User extends UserData implements Comparable<User>, IMessageRecipien
         this.messageRecipient = new SimpleMessageRecipient(ess, this);
     }
 
-    void update(final Player base) {
+    public void update(final Player base) {
         setBase(base);
     }
 
+    public IEssentials getEssentials() {
+        return ess;
+    }
+
     @Override
     public boolean isAuthorized(final IEssentialsCommand cmd) {
         return isAuthorized(cmd, "essentials.");
@@ -121,6 +136,10 @@ public class User extends UserData implements Comparable<User>, IMessageRecipien
 
     @Override
     public boolean isAuthorized(final String node) {
+        if (Essentials.TESTING) {
+            return false;
+        }
+
         final boolean result = isAuthorizedCheck(node);
         if (ess.getSettings().isDebug()) {
             ess.getLogger().log(Level.INFO, "checking if " + base.getName() + " has " + node + " - " + result);
@@ -128,8 +147,25 @@ public class User extends UserData implements Comparable<User>, IMessageRecipien
         return result;
     }
 
+    @Override
+    public boolean isAuthorizedCached(final String node) {
+        if (Essentials.TESTING) {
+            return false;
+        }
+
+        final boolean result = isAuthorizedCachedCheck(node);
+        if (ess.getSettings().isDebug()) {
+            ess.getLogger().log(Level.INFO, "checking if " + base.getName() + " has " + node + " (cached) - " + result);
+        }
+        return result;
+    }
+
     @Override
     public boolean isPermissionSet(final String node) {
+        if (Essentials.TESTING) {
+            return false;
+        }
+
         final boolean result = isPermSetCheck(node);
         if (ess.getSettings().isDebug()) {
             ess.getLogger().log(Level.INFO, "checking if " + base.getName() + " has " + node + " (set-explicit) - " + result);
@@ -146,7 +182,7 @@ public class User extends UserData implements Comparable<User>, IMessageRecipien
     }
 
     private boolean isAuthorizedCheck(final String node) {
-        if (base instanceof OfflinePlayer) {
+        if (base instanceof OfflinePlayerStub) {
             return false;
         }
 
@@ -163,8 +199,26 @@ public class User extends UserData implements Comparable<User>, IMessageRecipien
         }
     }
 
+    private boolean isAuthorizedCachedCheck(final String node) {
+        if (base instanceof OfflinePlayerStub) {
+            return false;
+        }
+
+        try {
+            return ess.getPermissionsHandler().hasPermissionCached(base, node);
+        } catch (final Exception ex) {
+            if (ess.getSettings().isDebug()) {
+                ess.getLogger().log(Level.SEVERE, "Permission System Error: " + ess.getPermissionsHandler().getName() + " returned: " + ex.getMessage(), ex);
+            } else {
+                ess.getLogger().log(Level.SEVERE, "Permission System Error: " + ess.getPermissionsHandler().getName() + " returned: " + ex.getMessage());
+            }
+
+            return false;
+        }
+    }
+
     private boolean isPermSetCheck(final String node) {
-        if (base instanceof OfflinePlayer) {
+        if (base instanceof OfflinePlayerStub) {
             return false;
         }
 
@@ -182,7 +236,7 @@ public class User extends UserData implements Comparable<User>, IMessageRecipien
     }
 
     private TriState isAuthorizedExactCheck(final String node) {
-        if (base instanceof OfflinePlayer) {
+        if (base instanceof OfflinePlayerStub) {
             return TriState.UNSET;
         }
 
@@ -209,7 +263,7 @@ public class User extends UserData implements Comparable<User>, IMessageRecipien
             cooldownTime.add(Calendar.SECOND, (int) cooldown);
             cooldownTime.add(Calendar.MILLISECOND, (int) ((cooldown * 1000.0) % 1000.0));
             if (cooldownTime.after(now) && !isAuthorized("essentials.heal.cooldown.bypass")) {
-                throw new Exception(tl("timeBeforeHeal", DateUtil.formatDateDiff(cooldownTime.getTimeInMillis())));
+                throw new TranslatableException("timeBeforeHeal", DateUtil.formatDateDiff(cooldownTime.getTimeInMillis()));
             }
         }
         setLastHealTimestamp(now.getTimeInMillis());
@@ -230,9 +284,9 @@ public class User extends UserData implements Comparable<User>, IMessageRecipien
             return;
         }
         setMoney(getMoney().add(value), cause);
-        sendMessage(tl("addedToAccount", NumberUtil.displayCurrency(value, ess)));
+        sendTl("addedToAccount", AdventureUtil.parsed(NumberUtil.displayCurrency(value, ess)));
         if (initiator != null) {
-            initiator.sendMessage(tl("addedToOthersAccount", NumberUtil.displayCurrency(value, ess), this.getDisplayName(), NumberUtil.displayCurrency(getMoney(), ess)));
+            initiator.sendTl("addedToOthersAccount", AdventureUtil.parsed(NumberUtil.displayCurrency(value, ess)), getDisplayName(), AdventureUtil.parsed(NumberUtil.displayCurrency(getMoney(), ess)));
         }
     }
 
@@ -241,20 +295,28 @@ public class User extends UserData implements Comparable<User>, IMessageRecipien
         payUser(reciever, value, UserBalanceUpdateEvent.Cause.UNKNOWN);
     }
 
-    public void payUser(final User reciever, final BigDecimal value, final UserBalanceUpdateEvent.Cause cause) throws Exception {
+    public void payUser(final User reciever, BigDecimal value, final UserBalanceUpdateEvent.Cause cause) throws Exception {
         if (value.compareTo(BigDecimal.ZERO) < 1) {
-            throw new Exception(tl("payMustBePositive"));
+            throw new Exception(tlLocale(playerLocale, "payMustBePositive"));
         }
 
         if (canAfford(value)) {
+            // Call an event for pre-transaction
+            final PreTransactionEvent preTransactionEvent = new PreTransactionEvent(this.getSource(), reciever, value);
+            ess.getServer().getPluginManager().callEvent(preTransactionEvent);
+            if (preTransactionEvent.isCancelled()) {
+                return;
+            }
+            value = preTransactionEvent.getAmount();
+
             setMoney(getMoney().subtract(value), cause);
             reciever.setMoney(reciever.getMoney().add(value), cause);
-            sendMessage(tl("moneySentTo", NumberUtil.displayCurrency(value, ess), reciever.getDisplayName()));
-            reciever.sendMessage(tl("moneyRecievedFrom", NumberUtil.displayCurrency(value, ess), getDisplayName()));
+            sendTl("moneySentTo", AdventureUtil.parsed(NumberUtil.displayCurrency(value, ess)), reciever.getDisplayName());
+            reciever.sendTl("moneyRecievedFrom", AdventureUtil.parsed(NumberUtil.displayCurrency(value, ess)), getDisplayName());
             final TransactionEvent transactionEvent = new TransactionEvent(this.getSource(), reciever, value);
             ess.getServer().getPluginManager().callEvent(transactionEvent);
         } else {
-            throw new ChargeException(tl("notEnoughMoney", NumberUtil.displayCurrency(value, ess)));
+            throw new ChargeException("notEnoughMoney", AdventureUtil.parsed(NumberUtil.displayCurrency(value, ess)));
         }
     }
 
@@ -277,9 +339,9 @@ public class User extends UserData implements Comparable<User>, IMessageRecipien
         } catch (final MaxMoneyException ex) {
             ess.getLogger().log(Level.WARNING, "Invalid call to takeMoney, total balance can't be more than the max-money limit.", ex);
         }
-        sendMessage(tl("takenFromAccount", NumberUtil.displayCurrency(value, ess)));
+        sendTl("takenFromAccount", AdventureUtil.parsed(NumberUtil.displayCurrency(value, ess)));
         if (initiator != null) {
-            initiator.sendMessage(tl("takenFromOthersAccount", NumberUtil.displayCurrency(value, ess), this.getDisplayName(), NumberUtil.displayCurrency(getMoney(), ess)));
+            initiator.sendTl("takenFromOthersAccount", AdventureUtil.parsed(NumberUtil.displayCurrency(value, ess)), getDisplayName(), AdventureUtil.parsed(NumberUtil.displayCurrency(getMoney(), ess)));
         }
     }
 
@@ -305,7 +367,7 @@ public class User extends UserData implements Comparable<User>, IMessageRecipien
 
     private void _dispose() {
         if (!base.isOnline()) {
-            this.base = new OfflinePlayer(getConfigUUID(), ess.getServer());
+            this.base = new OfflinePlayerStub(getConfigUUID(), ess.getServer());
         }
         cleanup();
     }
@@ -318,9 +380,10 @@ public class User extends UserData implements Comparable<User>, IMessageRecipien
             if (isAuthorized("essentials.itemspawn.item-all") || isAuthorized("essentials.itemspawn.item-" + name))
                 return true;
 
-            if (VersionUtil.getServerBukkitVersion().isLowerThan(VersionUtil.v1_13_0_R01)) {
+            if (VersionUtil.PRE_FLATTENING) {
+                //noinspection deprecation
                 final int id = material.getId();
-                if (isAuthorized("essentials.itemspawn.item-" + id)) return true;
+                return isAuthorized("essentials.itemspawn.item-" + id);
             }
 
             return false;
@@ -349,23 +412,14 @@ public class User extends UserData implements Comparable<User>, IMessageRecipien
         // Handle max queue size
         teleportRequestQueue.remove(request.getName());
         if (teleportRequestQueue.size() >= ess.getSettings().getTpaMaxRequests()) {
-            String lastKey = null;
-            for (Map.Entry<String, TpaRequest> entry : teleportRequestQueue.entrySet()) {
-                lastKey = entry.getKey();
-            }
-            teleportRequestQueue.remove(lastKey);
+            final List<String> keys = new ArrayList<>(teleportRequestQueue.keySet());
+            teleportRequestQueue.remove(keys.get(keys.size() - 1));
         }
 
         // Add request to queue
         teleportRequestQueue.put(request.getName(), request);
     }
 
-    @Override
-    @Deprecated
-    public boolean hasOutstandingTeleportRequest() {
-        return getNextTpaRequest(false, false, false) != null;
-    }
-
     public Collection<String> getPendingTpaKeys() {
         return teleportRequestQueue.keySet();
     }
@@ -392,7 +446,7 @@ public class User extends UserData implements Comparable<User>, IMessageRecipien
         }
         teleportRequestQueue.remove(playerUsername);
         if (inform) {
-            sendMessage(tl("requestTimedOutFrom", ess.getUser(request.getRequesterUuid()).getDisplayName()));
+            sendTl("requestTimedOutFrom", ess.getUser(request.getRequesterUuid()).getDisplayName());
         }
         return null;
     }
@@ -402,31 +456,33 @@ public class User extends UserData implements Comparable<User>, IMessageRecipien
     }
 
     @Override
-    public TpaRequest getNextTpaRequest(boolean inform, boolean performExpirations, boolean excludeHere) {
+    public TpaRequest getNextTpaRequest(boolean inform, boolean ignoreExpirations, boolean excludeHere) {
         if (teleportRequestQueue.isEmpty()) {
             return null;
         }
 
         final long timeout = ess.getSettings().getTpaAcceptCancellation();
-        final Iterator<Map.Entry<String, TpaRequest>> iterator = teleportRequestQueue.entrySet().iterator();
+        final List<String> keys = new ArrayList<>(teleportRequestQueue.keySet());
+        Collections.reverse(keys);
+
         TpaRequest nextRequest = null;
-        while (iterator.hasNext()) {
-            final TpaRequest request = iterator.next().getValue();
+        for (final String key : keys) {
+            final TpaRequest request = teleportRequestQueue.get(key);
             if (timeout < 1 || (System.currentTimeMillis() - request.getTime()) <= TimeUnit.SECONDS.toMillis(timeout)) {
                 if (excludeHere && request.isHere()) {
                     continue;
                 }
 
-                if (performExpirations) {
+                if (ignoreExpirations) {
                     return request;
                 } else if (nextRequest == null) {
                     nextRequest = request;
                 }
             } else {
                 if (inform) {
-                    sendMessage(tl("requestTimedOutFrom", ess.getUser(request.getRequesterUuid()).getDisplayName()));
+                    sendTl("requestTimedOutFrom", ess.getUser(request.getRequesterUuid()).getDisplayName());
                 }
-                iterator.remove();
+                teleportRequestQueue.remove(key);
             }
         }
         return nextRequest;
@@ -439,14 +495,15 @@ public class User extends UserData implements Comparable<User>, IMessageRecipien
     /**
      * Needed for backwards compatibility.
      */
-    public String getNick(final boolean longnick) {
+    public String getNick(@SuppressWarnings("unused") final boolean longNick) {
         return getNick(true, true);
     }
 
     /**
      * Needed for backwards compatibility.
      */
-    public String getNick(final boolean longnick, final boolean withPrefix, final boolean withSuffix) {
+    @SuppressWarnings("unused")
+    public String getNick(@SuppressWarnings("unused") final boolean longNick, final boolean withPrefix, final boolean withSuffix) {
         return getNick(withPrefix, withSuffix);
     }
 
@@ -460,7 +517,11 @@ public class User extends UserData implements Comparable<User>, IMessageRecipien
         } else if (nick.equalsIgnoreCase(getName())) {
             nickname = nick;
         } else {
-            nickname = FormatUtil.replaceFormat(ess.getSettings().getNicknamePrefix()) + nick;
+            if (isAuthorized("essentials.nick.hideprefix")) {
+                nickname = nick;
+            } else {
+                nickname = FormatUtil.replaceFormat(ess.getSettings().getNicknamePrefix()) + nick;
+            }
             suffix = "§r";
         }
 
@@ -515,7 +576,7 @@ public class User extends UserData implements Comparable<User>, IMessageRecipien
                     this.getBase().setPlayerListName(name);
                 } catch (final IllegalArgumentException e) {
                     if (ess.getSettings().isDebug()) {
-                        logger.log(Level.INFO, "Playerlist for " + name + " was not updated. Name clashed with another online player.");
+                        ess.getLogger().log(Level.INFO, "Playerlist for " + name + " was not updated. Name clashed with another online player.");
                     }
                 }
             }
@@ -524,6 +585,7 @@ public class User extends UserData implements Comparable<User>, IMessageRecipien
 
     @Override
     public String getDisplayName() {
+        //noinspection ConstantConditions
         return super.getBase().getDisplayName() == null || (ess.getSettings().hideDisplayNameInVanish() && isHidden()) ? super.getBase().getName() : super.getBase().getDisplayName();
     }
 
@@ -541,15 +603,6 @@ public class User extends UserData implements Comparable<User>, IMessageRecipien
         return teleport;
     }
 
-    /**
-     * @deprecated This API is not asynchronous. Use {@link User#getAsyncTeleport()}
-     */
-    @Override
-    @Deprecated
-    public Teleport getTeleport() {
-        return legacyTeleport;
-    }
-
     public long getLastOnlineActivity() {
         return lastOnlineActivity;
     }
@@ -564,7 +617,8 @@ public class User extends UserData implements Comparable<User>, IMessageRecipien
         final BigDecimal value = _getMoney();
         final long elapsed = System.nanoTime() - start;
         if (elapsed > ess.getSettings().getEconomyLagWarning()) {
-            ess.getLogger().log(Level.INFO, "Lag Notice - Slow Economy Response - Request took over {0}ms!", elapsed / 1000000.0);
+            ess.getLogger().log(Level.INFO, String.format(Locale.ROOT,
+                    "Lag Notice - Slow Economy Response - Request took over %.3fms!", elapsed / 1_000_000.0));
         }
         return value;
     }
@@ -620,6 +674,7 @@ public class User extends UserData implements Comparable<User>, IMessageRecipien
         }
     }
 
+    @SuppressWarnings("deprecation")
     @Override
     public void setAfk(final boolean set) {
         setAfk(set, AfkStatusChangeEvent.Cause.UNKNOWN);
@@ -670,6 +725,9 @@ public class User extends UserData implements Comparable<User>, IMessageRecipien
 
     @Override
     public boolean isHiddenFrom(Player player) {
+        if (getBase() instanceof OfflinePlayerStub || player instanceof OfflinePlayerStub) {
+            return true;
+        }
         return !player.canSee(getBase());
     }
 
@@ -678,6 +736,16 @@ public class User extends UserData implements Comparable<User>, IMessageRecipien
         return hidden;
     }
 
+    @Override
+    public boolean isLeavingHidden() {
+        return leavingHidden;
+    }
+
+    @Override
+    public void setLeavingHidden(boolean leavingHidden) {
+        this.leavingHidden = leavingHidden;
+    }
+
     @Override
     public void setHidden(final boolean hidden) {
         this.hidden = hidden;
@@ -687,7 +755,7 @@ public class User extends UserData implements Comparable<User>, IMessageRecipien
     }
 
     public boolean isHidden(final Player player) {
-        return hidden || !player.canSee(getBase());
+        return hidden || isHiddenFrom(player);
     }
 
     @Override
@@ -700,6 +768,7 @@ public class User extends UserData implements Comparable<User>, IMessageRecipien
     }
 
     //Returns true if status expired during this check
+    @SuppressWarnings("UnusedReturnValue")
     public boolean checkJailTimeout(final long currentTime) {
         if (getJailTimeout() > 0) {
 
@@ -717,7 +786,7 @@ public class User extends UserData implements Comparable<User>, IMessageRecipien
                     setJailTimeout(0);
                     setOnlineJailedTime(0);
                     setJailed(false);
-                    sendMessage(tl("haveBeenReleased"));
+                    sendTl("haveBeenReleased");
                     setJail(null);
                     if (ess.getSettings().getTeleportWhenFreePolicy() == ISettings.TeleportWhenFreePolicy.BACK) {
                         final CompletableFuture<Boolean> future = new CompletableFuture<>();
@@ -737,6 +806,7 @@ public class User extends UserData implements Comparable<User>, IMessageRecipien
     }
 
     //Returns true if status expired during this check
+    @SuppressWarnings("UnusedReturnValue")
     public boolean checkMuteTimeout(final long currentTime) {
         if (getMuteTimeout() > 0 && getMuteTimeout() < currentTime && isMuted()) {
             final MuteStatusChangeEvent event = new MuteStatusChangeEvent(this, null, false, getMuteTimeout(), getMuteReason());
@@ -744,7 +814,7 @@ public class User extends UserData implements Comparable<User>, IMessageRecipien
 
             if (!event.isCancelled()) {
                 setMuteTimeout(0);
-                sendMessage(tl("canTalkAgain"));
+                sendTl("canTalkAgain");
                 setMuted(false);
                 setMuteReason(null);
                 return true;
@@ -753,6 +823,29 @@ public class User extends UserData implements Comparable<User>, IMessageRecipien
         return false;
     }
 
+    // Notifies this (muted) user that they have been silenced, including the reason and remaining time if applicable.
+    public void notifyMuted() {
+        final String dateDiff = getMuteTimeout() > 0 ? DateUtil.formatDateDiff(getMuteTimeout()) : null;
+        if (dateDiff == null) {
+            if (hasMuteReason()) {
+                sendTl("voiceSilencedReason", getMuteReason());
+            } else {
+                sendTl("voiceSilenced");
+            }
+        } else {
+            if (hasMuteReason()) {
+                sendTl("voiceSilencedReasonTime", dateDiff, getMuteReason());
+            } else {
+                sendTl("voiceSilencedTime", dateDiff);
+            }
+        }
+    }
+
+    @Override
+    public long getLastActivityTime() {
+        return this.lastActivity;
+    }
+
     @Deprecated
     public void updateActivity(final boolean broadcast) {
         updateActivity(broadcast, AfkStatusChangeEvent.Cause.UNKNOWN);
@@ -763,15 +856,10 @@ public class User extends UserData implements Comparable<User>, IMessageRecipien
             setAfk(false, cause);
             if (broadcast && !isHidden() && !isAfk()) {
                 setDisplayNick();
-                final String msg = tl("userIsNotAway", getDisplayName());
-                final String selfmsg = tl("userIsNotAwaySelf", getDisplayName());
-                if (!msg.isEmpty() && ess.getSettings().broadcastAfkMessage()) {
-                    // exclude user from receiving general AFK announcement in favor of personal message
-                    ess.broadcastMessage(this, msg, u -> u == this);
-                }
-                if (!selfmsg.isEmpty()) {
-                    this.sendMessage(selfmsg);
+                if (ess.getSettings().broadcastAfkMessage()) {
+                    ess.broadcastTl(this, u -> u == this, "userIsNotAway", getDisplayName());
                 }
+                sendTl("userIsNotAwaySelf", getDisplayName());
             }
         }
         lastActivity = System.currentTimeMillis();
@@ -792,47 +880,56 @@ public class User extends UserData implements Comparable<User>, IMessageRecipien
     public void updateActivityOnChat(final boolean broadcast) {
         if (ess.getSettings().cancelAfkOnChat()) {
             //Chat happens async, make sure we have a sync context
-            ess.scheduleSyncDelayedTask(() -> {
-                updateActivity(broadcast, AfkStatusChangeEvent.Cause.CHAT);
-            });
+            ess.scheduleSyncDelayedTask(() -> updateActivity(broadcast, AfkStatusChangeEvent.Cause.CHAT));
         }
     }
 
     public void checkActivity() {
-        // Graceful time before the first afk check call. 
+        // Graceful time before the first afk check call.
         if (System.currentTimeMillis() - lastActivity <= 10000) {
             return;
         }
 
-        final long autoafkkick = ess.getSettings().getAutoAfkKick();
-        if (autoafkkick > 0
-                && lastActivity > 0 && (lastActivity + (autoafkkick * 1000)) < System.currentTimeMillis()
+        final long autoafktimeout = ess.getSettings().getAutoAfkTimeout();
+
+        // Checks if the player has been inactive for longer than the configured auto-afk-timeout time.
+        if (autoafktimeout > 0
+                && lastActivity > 0 && (lastActivity + (autoafktimeout * 1000)) < System.currentTimeMillis()
                 && !isAuthorized("essentials.kick.exempt")
                 && !isAuthorized("essentials.afk.kickexempt")) {
-            final String kickReason = tl("autoAfkKickReason", autoafkkick / 60.0);
             lastActivity = 0;
-            this.getBase().kickPlayer(kickReason);
+            final double kickTime = autoafktimeout / 60.0;
 
-            for (final User user : ess.getOnlineUsers()) {
-                if (user.isAuthorized("essentials.kick.notify")) {
-                    user.sendMessage(tl("playerKicked", Console.DISPLAY_NAME, getName(), kickReason));
+            // If `afk-timeout-command` in config.yml is empty, use default Essentials kicking behaviour instead of executing a command.
+            if (ess.getSettings().getAfkTimeoutCommands().isEmpty()) {
+                this.getBase().kickPlayer(ess.getAdventureFacet().miniToLegacy(playerTl("autoAfkKickReason", kickTime)));
+
+                for (final User user : ess.getOnlineUsers()) {
+                    if (user.isAuthorized("essentials.kick.notify")) {
+                        user.sendTl("playerKicked", Console.displayName(), getName(), user.playerTl("autoAfkKickReason", kickTime));
+                    }
+                }
+            } else {
+                // If `afk-timeout-commands` in config.yml is populated, execute the command(s) instead of kicking the player.
+                for (final String command : ess.getSettings().getAfkTimeoutCommands()) {
+                    if (command == null || command.isEmpty()){
+                        continue;
+                    }
+                    // Replace placeholders in the command with actual values.
+                    final String cmd = command.replace("{USERNAME}", getName()).replace("{KICKTIME}", String.valueOf(kickTime));
+                    ess.getServer().dispatchCommand(ess.getServer().getConsoleSender(), cmd);
                 }
             }
         }
         final long autoafk = ess.getSettings().getAutoAfk();
-        if (!isAfk() && autoafk > 0 && lastActivity + autoafk * 1000 < System.currentTimeMillis() && isAuthorized("essentials.afk.auto")) {
+        if (!isAfk() && autoafk > 0 && lastActivity + autoafk * 1000 < System.currentTimeMillis() && isAuthorizedCached("essentials.afk.auto")) {
             setAfk(true, AfkStatusChangeEvent.Cause.ACTIVITY);
             if (isAfk() && !isHidden()) {
                 setDisplayNick();
-                final String msg = tl("userIsAway", getDisplayName());
-                final String selfmsg = tl("userIsAwaySelf", getDisplayName());
-                if (!msg.isEmpty() && ess.getSettings().broadcastAfkMessage()) {
-                    // exclude user from receiving general AFK announcement in favor of personal message
-                    ess.broadcastMessage(this, msg, u -> u == this);
-                }
-                if (!selfmsg.isEmpty()) {
-                    this.sendMessage(selfmsg);
+                if (ess.getSettings().broadcastAfkMessage()) {
+                    ess.broadcastTl(this, u -> u == this, "userIsAway", getDisplayName());
                 }
+                sendTl("userIsAwaySelf", getDisplayName());
             }
         }
     }
@@ -847,6 +944,7 @@ public class User extends UserData implements Comparable<User>, IMessageRecipien
             // This enables the no-god-in-worlds functionality where the actual player god mode state is never modified in disabled worlds,
             // but this method gets called every time the player takes damage. In the case that the world has god-mode disabled then this method
             // will return false and the player will take damage, even though they are in god mode (isGodModeEnabledRaw()).
+            //noinspection ConstantConditions
             if (!ess.getSettings().getNoGodWorlds().contains(this.getLocation().getWorld().getName())) {
                 return true;
             }
@@ -888,6 +986,7 @@ public class User extends UserData implements Comparable<User>, IMessageRecipien
         return ess.getPermissionsHandler().canBuild(base, getGroup());
     }
 
+    @SuppressWarnings("deprecation")
     @Override
     @Deprecated
     public long getTeleportRequestTime() {
@@ -956,10 +1055,12 @@ public class User extends UserData implements Comparable<User>, IMessageRecipien
         if (set) {
             for (final User user : ess.getOnlineUsers()) {
                 if (!user.isAuthorized("essentials.vanish.see")) {
+                    //noinspection deprecation
                     user.getBase().hidePlayer(getBase());
                 }
             }
             setHidden(true);
+            lastVanishTime = System.currentTimeMillis();
             ess.getVanishedPlayersNew().add(getName());
             this.getBase().setMetadata("vanished", new FixedMetadataValue(ess, true));
             if (isAuthorized("essentials.vanish.effect")) {
@@ -970,6 +1071,7 @@ public class User extends UserData implements Comparable<User>, IMessageRecipien
             }
         } else {
             for (final Player p : ess.getOnlinePlayers()) {
+                //noinspection deprecation
                 p.showPlayer(getBase());
             }
             setHidden(false);
@@ -1029,6 +1131,52 @@ public class User extends UserData implements Comparable<User>, IMessageRecipien
         }
     }
 
+    @Override
+    public void sendComponent(ComponentHolder component) {
+        ess.getAdventureFacet().send(base, component);
+    }
+
+    @Override
+    public ComponentHolder tlComponent(String tlKey, Object... args) {
+        final String translation = playerTl(tlKey, args);
+        return ess.getAdventureFacet().deserializeMiniMessage(translation);
+    }
+
+    @Override
+    public void sendTl(String tlKey, Object... args) {
+        final String translation = playerTl(tlKey, args);
+        if (translation.trim().isEmpty()) {
+            return;
+        }
+
+        sendComponent(ess.getAdventureFacet().deserializeMiniMessage(translation));
+    }
+
+    @Override
+    public String playerTl(String tlKey, Object... args) {
+        if (ess.getSettings().isPerPlayerLocale()) {
+            final PlayerLocaleProvider provider = ess.provider(PlayerLocaleProvider.class);
+            final Locale locale = base != null ? getPlayerLocale(provider.getLocale(base)) : playerLocale;
+            if (locale != null) {
+                return tlLocale(locale, tlKey, args);
+            }
+        }
+        return tlLiteral(tlKey, args);
+    }
+
+    @Override
+    public String tlSender(String tlKey, Object... args) {
+        return playerTl(tlKey, args);
+    }
+
+    public Locale getPlayerLocale(final String locale) {
+        if (locale == null || locale.equals(lastLocaleString)) {
+            return playerLocale;
+        }
+        lastLocaleString = locale;
+        return playerLocale = I18n.getLocale(locale);
+    }
+
     @Override
     public int compareTo(final User other) {
         return FormatUtil.stripFormat(getDisplayName()).compareToIgnoreCase(FormatUtil.stripFormat(other.getDisplayName()));
@@ -1050,7 +1198,7 @@ public class User extends UserData implements Comparable<User>, IMessageRecipien
 
     @Override
     public CommandSource getSource() {
-        return new CommandSource(getBase());
+        return new CommandSource(ess, getBase());
     }
 
     @Override
@@ -1122,12 +1270,7 @@ public class User extends UserData implements Comparable<User>, IMessageRecipien
      * Returns the {@link ItemStack} in the main hand or off-hand. If the main hand is empty then the offhand item is returned - also nullable.
      */
     public ItemStack getItemInHand() {
-        if (VersionUtil.getServerBukkitVersion().isLowerThan(VersionUtil.v1_9_R01)) {
-            return getBase().getInventory().getItemInHand();
-        } else {
-            final PlayerInventory inventory = getBase().getInventory();
-            return inventory.getItemInMainHand() != null ? inventory.getItemInMainHand() : inventory.getItemInOffHand();
-        }
+        return Inventories.getItemInHand(getBase());
     }
 
     @Override
@@ -1140,6 +1283,7 @@ public class User extends UserData implements Comparable<User>, IMessageRecipien
         ess.getMail().sendMail(this, sender, message, expireAt);
     }
 
+    @SuppressWarnings("deprecation")
     @Override
     @Deprecated
     public void addMail(String mail) {
@@ -1151,7 +1295,7 @@ public class User extends UserData implements Comparable<User>, IMessageRecipien
         if (unread != 0) {
             final int notifyPlayerOfMailCooldown = ess.getSettings().getNotifyPlayerOfMailCooldown() * 1000;
             if (System.currentTimeMillis() - lastNotifiedAboutMailsMs >= notifyPlayerOfMailCooldown) {
-                sendMessage(tl("youHaveNewMail", unread));
+                sendTl("youHaveNewMail", unread);
                 lastNotifiedAboutMailsMs = System.currentTimeMillis();
             }
         }
@@ -1177,6 +1321,16 @@ public class User extends UserData implements Comparable<User>, IMessageRecipien
         return signCopy;
     }
 
+    @Override
+    public boolean isFreeze() {
+        return freeze;
+    }
+
+    @Override
+    public void setFreeze(boolean freeze) {
+        this.freeze = freeze;
+    }
+
     public boolean isBaltopExempt() {
         if (getBase().isOnline()) {
             final boolean exempt = isAuthorized("essentials.balancetop.exclude");
@@ -1186,6 +1340,10 @@ public class User extends UserData implements Comparable<User>, IMessageRecipien
         return isBaltopExcludeCache();
     }
 
+    public long getLastVanishTime() {
+        return lastVanishTime;
+    }
+
     @Override
     public Block getTargetBlock(int maxDistance) {
         final Block block;
@@ -1198,10 +1356,24 @@ public class User extends UserData implements Comparable<User>, IMessageRecipien
     @Override
     public void setToggleShout(boolean toggleShout) {
         this.toggleShout = toggleShout;
+        if (ess.getSettings().isPersistShout()) {
+            setShouting(toggleShout);
+        }
     }
 
     @Override
     public boolean isToggleShout() {
-        return toggleShout;
+        if (ess.getSettings().isPersistShout()) {
+            return toggleShout = isShouting();
+        }
+        return toggleShout == null ? toggleShout = ess.getSettings().isShoutDefault() : toggleShout;
+    }
+
+    public int getFlightTick() {
+        return flightTick;
+    }
+
+    public void setFlightTick(int flightTick) {
+        this.flightTick = flightTick;
     }
 }

Essentials/src/main/java/com/earth2me/essentials/UserData.java

@@ -5,18 +5,19 @@ import com.earth2me.essentials.config.EssentialsUserConfiguration;
 import com.earth2me.essentials.config.entities.CommandCooldown;
 import com.earth2me.essentials.config.entities.LazyLocation;
 import com.earth2me.essentials.config.holders.UserConfigHolder;
+import com.earth2me.essentials.userstorage.ModernUserMap;
 import com.earth2me.essentials.utils.NumberUtil;
 import com.earth2me.essentials.utils.StringUtil;
 import com.google.common.base.Charsets;
 import net.ess3.api.IEssentials;
 import net.ess3.api.MaxMoneyException;
+import net.ess3.api.TranslatableException;
 import net.essentialsx.api.v2.services.mail.MailMessage;
 import org.bukkit.ChatColor;
 import org.bukkit.Location;
 import org.bukkit.Material;
 import org.bukkit.entity.Player;
 import org.bukkit.inventory.ItemStack;
-import org.spongepowered.configurate.serialize.SerializationException;
 
 import java.io.File;
 import java.math.BigDecimal;
@@ -31,31 +32,26 @@ import java.util.UUID;
 import java.util.logging.Level;
 import java.util.regex.Pattern;
 
-import static com.earth2me.essentials.I18n.tl;
-
 public abstract class UserData extends PlayerExtension implements IConf {
-    protected final transient IEssentials ess;
+    protected final transient Essentials ess;
     private final EssentialsUserConfiguration config;
     private UserConfigHolder holder;
     private BigDecimal money;
 
     protected UserData(final Player base, final IEssentials ess) {
         super(base);
-        this.ess = ess;
+        this.ess = (Essentials) ess;
         final File folder = new File(ess.getDataFolder(), "userdata");
-        if (!folder.exists()) {
-            folder.mkdirs();
+        // mkdirs() may return false if another thread created the folder concurrently,
+        // so fall back to checking whether the directory now exists to avoid a race.
+        if (!folder.isDirectory() && !folder.mkdirs() && !folder.isDirectory()) {
+            throw new RuntimeException("Unable to create userdata folder!");
         }
 
-        String filename;
-        try {
-            filename = base.getUniqueId().toString();
-        } catch (final Throwable ex) {
-            ess.getLogger().warning("Falling back to old username system for " + base.getName());
-            filename = base.getName();
-        }
-
-        config = new EssentialsUserConfiguration(base.getName(), base.getUniqueId(), new File(folder, filename + ".yml"));
+        config = new EssentialsUserConfiguration(base.getName(), base.getUniqueId(), new File(folder, base.getUniqueId() + ".yml"));
+        config.setSaveHook(() -> {
+            config.setRootHolder(UserConfigHolder.class, holder);
+        });
         reloadConfig();
 
         if (config.getUsername() == null) {
@@ -65,18 +61,22 @@ public abstract class UserData extends PlayerExtension implements IConf {
 
     public final void reset() {
         config.blockingSave();
-        config.getFile().delete();
+        if (!config.getFile().delete()) {
+            ess.getLogger().warning("Unable to delete data file for " + config.getFile().getName());
+        }
         if (config.getUsername() != null) {
-            ess.getUserMap().removeUser(config.getUsername());
+            final ModernUserMap users = (ModernUserMap) ess.getUsers();
+            users.invalidate(config.getUuid());
             if (isNPC()) {
-                final String uuid = UUID.nameUUIDFromBytes(("NPC:" + StringUtil.safeString(config.getUsername())).getBytes(Charsets.UTF_8)).toString();
-                ess.getUserMap().removeUserUUID(uuid);
+                final String name = ess.getSettings().isSafeUsermap() ? StringUtil.safeString(config.getUsername()) : config.getUsername();
+                users.invalidate(UUID.nameUUIDFromBytes(("NPC:" + name).getBytes(Charsets.UTF_8)));
             }
         }
     }
 
     public final void cleanup() {
         config.blockingSave();
+        ess.getUsers().removeCache(getConfigUUID());
     }
 
     @Override
@@ -84,18 +84,10 @@ public abstract class UserData extends PlayerExtension implements IConf {
         config.load();
         try {
             holder = config.getRootNode().get(UserConfigHolder.class);
-        } catch (SerializationException e) {
-            ess.getLogger().log(Level.SEVERE, "Error while reading user config: " + e.getMessage(), e);
+        } catch (Throwable e) {
+            ess.getLogger().log(Level.SEVERE, "Error while reading user config: " + config.getFile().getName(), e);
             throw new RuntimeException(e);
         }
-        config.setSaveHook(() -> {
-            try {
-                config.getRootNode().set(UserConfigHolder.class, holder);
-            } catch (SerializationException e) {
-                ess.getLogger().log(Level.SEVERE, "Error while saving user config: " + e.getMessage(), e);
-                throw new RuntimeException(e);
-            }
-        });
         money = _getMoney();
     }
 
@@ -204,7 +196,17 @@ public abstract class UserData extends PlayerExtension implements IConf {
             holder.homes().remove(search);
             config.save();
         } else {
-            throw new Exception(tl("invalidHome", search));
+            throw new TranslatableException("invalidHome", search);
+        }
+    }
+
+    public void renameHome(final String name, final String newName) throws Exception {
+        final LazyLocation location = holder.homes().remove(name);
+        if (location != null) {
+            holder.homes().put(StringUtil.safeString(newName), location);
+            config.save();
+        } else {
+            throw new TranslatableException("invalidHome", name);
         }
     }
 
@@ -272,6 +274,10 @@ public abstract class UserData extends PlayerExtension implements IConf {
         return !holder.powertools().isEmpty();
     }
 
+    public Map<String, List<String>> getAllPowertools() {
+        return holder.powertools();
+    }
+
     public Location getLastLocation() {
         final LazyLocation lastLocation = holder.lastLocation();
         return lastLocation != null ? lastLocation.location() : null;
@@ -349,7 +355,17 @@ public abstract class UserData extends PlayerExtension implements IConf {
     }
 
     public int getMailAmount() {
-        return holder.mail() == null ? 0 : holder.mail().size();
+        if (holder.mail() == null) {
+            return 0;
+        }
+
+        int amount = 0;
+        for (MailMessage element : holder.mail()) {
+            if (!element.isExpired()) {
+                amount++;
+            }
+        }
+        return amount;
     }
 
     public int getUnreadMailAmount() {
@@ -359,7 +375,7 @@ public abstract class UserData extends PlayerExtension implements IConf {
 
         int unread = 0;
         for (MailMessage element : holder.mail()) {
-            if (!element.isRead()) {
+            if (!element.isRead() && !element.isExpired()) {
                 unread++;
             }
         }
@@ -455,6 +471,15 @@ public abstract class UserData extends PlayerExtension implements IConf {
         config.save();
     }
 
+    public boolean isFlyModeEnabled() {
+        return holder.flyMode();
+    }
+
+    public void setFlyModeEnabled(final boolean set) {
+        holder.flyMode(set);
+        config.save();
+    }
+
     public boolean getMuted() {
         return holder.muted();
     }
@@ -589,9 +614,13 @@ public abstract class UserData extends PlayerExtension implements IConf {
     }
 
     public void setLastAccountName(final String lastAccountName) {
+        if (getLastAccountName() != null && !getLastAccountName().equals(lastAccountName)) {
+            final List<String> usernames = holder.pastUsernames();
+            usernames.add(0, getLastAccountName());
+            holder.pastUsernames(usernames);
+        }
         holder.lastAccountName(lastAccountName);
         config.save();
-        ess.getUserMap().trackUUID(getConfigUUID(), lastAccountName, true);
     }
 
     public boolean arePowerToolsEnabled() {
@@ -722,6 +751,29 @@ public abstract class UserData extends PlayerExtension implements IConf {
         config.save();
     }
 
+    public List<String> getPastUsernames() {
+        return holder.pastUsernames();
+    }
+
+    public void addPastUsername(String username) {
+        final List<String> usernames = holder.pastUsernames();
+        usernames.add(0, username);
+        holder.pastUsernames(usernames);
+        config.save();
+    }
+
+    public boolean isShouting() {
+        if (holder.shouting() == null) {
+            holder.shouting(ess.getSettings().isShoutDefault());
+        }
+        return holder.shouting();
+    }
+
+    public void setShouting(boolean shouting) {
+        holder.shouting(shouting);
+        config.save();
+    }
+
     public UUID getConfigUUID() {
         return config.getUuid();
     }

Essentials/src/main/java/com/earth2me/essentials/UserMap.java

@@ -1,383 +1,70 @@
 package com.earth2me.essentials;
 
 import com.earth2me.essentials.api.UserDoesNotExistException;
-import com.earth2me.essentials.utils.StringUtil;
-import com.google.common.base.Charsets;
-import com.google.common.cache.Cache;
-import com.google.common.cache.CacheBuilder;
-import com.google.common.cache.CacheLoader;
-import com.google.common.cache.LoadingCache;
-import com.google.common.util.concurrent.UncheckedExecutionException;
-import net.ess3.api.IEssentials;
-import net.ess3.api.MaxMoneyException;
+import com.earth2me.essentials.userstorage.ModernUserMap;
+import org.bukkit.Bukkit;
 import org.bukkit.entity.Player;
 
-import java.io.File;
-import java.lang.reflect.InvocationTargetException;
-import java.lang.reflect.Method;
-import java.text.MessageFormat;
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.List;
 import java.util.Set;
 import java.util.UUID;
 import java.util.concurrent.ConcurrentSkipListMap;
-import java.util.concurrent.ConcurrentSkipListSet;
-import java.util.concurrent.ExecutionException;
-import java.util.logging.Level;
-import java.util.regex.Pattern;
 
-public class UserMap extends CacheLoader<String, User> implements IConf {
-    private static boolean legacy = false;
-    private static Method getLegacy;
-    private final transient IEssentials ess;
-    private final transient ConcurrentSkipListSet<UUID> keys = new ConcurrentSkipListSet<>();
-    private final transient ConcurrentSkipListMap<String, UUID> names = new ConcurrentSkipListMap<>();
-    private final transient ConcurrentSkipListMap<UUID, ArrayList<String>> history = new ConcurrentSkipListMap<>();
-    private final UUIDMap uuidMap;
-    private final transient Cache<String, User> users;
-    private final Pattern validUserPattern = Pattern.compile("^[a-zA-Z0-9_]{2,16}$");
+@Deprecated
+public class UserMap {
+    private final transient ModernUserMap userMap;
+    private final transient UUIDMap uuidMap;
 
-    private static final String WARN_UUID_NOT_REPLACE = "Found UUID {0} for player {1}, but player already has a UUID ({2}). Not replacing UUID in usermap.";
-
-    public UserMap(final IEssentials ess) {
-        super();
-        this.ess = ess;
-        uuidMap = new UUIDMap(ess);
-        //RemovalListener<UUID, User> remListener = new UserMapRemovalListener();
-        //users = CacheBuilder.newBuilder().maximumSize(ess.getSettings().getMaxUserCacheCount()).softValues().removalListener(remListener).build(this);
-        final CacheBuilder<Object, Object> cacheBuilder = CacheBuilder.newBuilder();
-        final int maxCount = ess.getSettings().getMaxUserCacheCount();
-        try {
-            cacheBuilder.maximumSize(maxCount);
-        } catch (final NoSuchMethodError nsme) {
-            legacy = true;
-            legacyMaximumSize(cacheBuilder, maxCount);
-        }
-        cacheBuilder.softValues();
-        if (!legacy) {
-            users = cacheBuilder.build(this);
-        } else {
-            users = legacyBuild(cacheBuilder);
-        }
-    }
-
-    private void loadAllUsersAsync(final IEssentials ess) {
-        ess.runTaskAsynchronously(() -> {
-            synchronized (users) {
-                final File userdir = new File(ess.getDataFolder(), "userdata");
-                if (!userdir.exists()) {
-                    return;
-                }
-                keys.clear();
-                users.invalidateAll();
-                for (final String string : userdir.list()) {
-                    if (!string.endsWith(".yml")) {
-                        continue;
-                    }
-                    final String name = string.substring(0, string.length() - 4);
-                    try {
-                        keys.add(UUID.fromString(name));
-                    } catch (final IllegalArgumentException ex) {
-                        //Ignore these users till they rejoin.
-                    }
-                }
-                uuidMap.loadAllUsers(names, history);
-            }
-        });
-    }
-
-    public boolean userExists(final UUID uuid) {
-        return keys.contains(uuid);
+    public UserMap(final ModernUserMap userMap) {
+        this.userMap = userMap;
+        this.uuidMap = new UUIDMap();
     }
 
     public User getUser(final String name) {
-        final String sanitizedName = StringUtil.safeString(name);
-        try {
-            if (ess.getSettings().isDebug()) {
-                ess.getLogger().warning("Looking up username " + name + " (" + sanitizedName + ") ...");
-            }
-
-            if (names.containsKey(sanitizedName)) {
-                final UUID uuid = names.get(sanitizedName);
-                return getUser(uuid);
-            }
-
-            if (ess.getSettings().isDebug()) {
-                ess.getLogger().warning(name + "(" + sanitizedName + ") has no known usermap entry");
-            }
-
-            final File userFile = getUserFileFromString(sanitizedName);
-            if (userFile.exists()) {
-                ess.getLogger().info("Importing user " + name + " to usermap.");
-                final User user = new User(new OfflinePlayer(sanitizedName, ess.getServer()), ess);
-                trackUUID(user.getBase().getUniqueId(), user.getName(), true);
-                return user;
-            }
-            return null;
-        } catch (final UncheckedExecutionException ex) {
-            if (ess.getSettings().isDebug()) {
-                ess.getLogger().log(Level.WARNING, ex, () -> String.format("Exception while getting user for %s (%s)", name, sanitizedName));
-            }
-            return null;
-        }
+        return userMap.getUser(name);
     }
 
     public User getUser(final UUID uuid) {
-        try {
-            if (!legacy) {
-                return ((LoadingCache<String, User>) users).get(uuid.toString());
-            } else {
-                return legacyCacheGet(uuid);
-            }
-        } catch (final ExecutionException | UncheckedExecutionException ex) {
-            if (ess.getSettings().isDebug()) {
-                ess.getLogger().log(Level.WARNING, ex, () -> "Exception while getting user for " + uuid);
-            }
-            return null;
-        }
+        return userMap.getUser(uuid);
     }
 
     public void trackUUID(final UUID uuid, final String name, final boolean replace) {
-        if (uuid != null) {
-            keys.add(uuid);
-            if (name != null && name.length() > 0) {
-                final String keyName = ess.getSettings().isSafeUsermap() ? StringUtil.safeString(name) : name;
-                if (!names.containsKey(keyName)) {
-                    names.put(keyName, uuid);
-                    uuidMap.writeUUIDMap();
-                } else if (!isUUIDMatch(uuid, keyName)) {
-                    if (replace) {
-                        ess.getLogger().info("Found new UUID for " + name + ". Replacing " + names.get(keyName).toString() + " with " + uuid.toString());
-                        names.put(keyName, uuid);
-                        uuidMap.writeUUIDMap();
-                    } else {
-                        ess.getLogger().log(Level.INFO, MessageFormat.format(WARN_UUID_NOT_REPLACE, uuid.toString(), name, names.get(keyName).toString()), new RuntimeException());
-                    }
-                }
-            }
-        }
+        // no-op
     }
 
-    public boolean isUUIDMatch(final UUID uuid, final String name) {
-        return names.containsKey(name) && names.get(name).equals(uuid);
-    }
-
-    @Override
     public User load(final String stringUUID) throws Exception {
-        final UUID uuid = UUID.fromString(stringUUID);
-        Player player = ess.getServer().getPlayer(uuid);
-        if (player != null) {
-            final User user = new User(player, ess);
-            trackUUID(uuid, user.getName(), true);
-            return user;
-        }
-
-        final File userFile = getUserFileFromID(uuid);
-
-        if (userFile.exists()) {
-            player = new OfflinePlayer(uuid, ess.getServer());
-            final User user = new User(player, ess);
-            ((OfflinePlayer) player).setName(user.getLastAccountName());
-            trackUUID(uuid, user.getName(), false);
-            return user;
-        }
-
-        throw new Exception("User not found!");
+        return userMap.load(UUID.fromString(stringUUID));
     }
 
     public User load(final org.bukkit.OfflinePlayer player) throws UserDoesNotExistException {
-        if (player == null) {
-            throw new IllegalArgumentException("Player cannot be null!");
-        }
-
+        final Player userPlayer;
         if (player instanceof Player) {
-            if (ess.getSettings().isDebug()) {
-                ess.getLogger().info("Loading online OfflinePlayer into user map...");
-            }
-            final User user = new User((Player) player, ess);
-            trackUUID(player.getUniqueId(), player.getName(), true);
-            return user;
-        }
-
-        final File userFile = getUserFileFromID(player.getUniqueId());
-        if (ess.getSettings().isDebug()) {
-            ess.getLogger().info("Loading OfflinePlayer into user map. Has data: " + userFile.exists() + " for " + player);
-        }
-
-        final OfflinePlayer essPlayer = new OfflinePlayer(player.getUniqueId(), ess.getServer());
-        final User user = new User(essPlayer, ess);
-        if (userFile.exists()) {
-            essPlayer.setName(user.getLastAccountName());
+            userPlayer = (Player) player;
         } else {
-            if (ess.getSettings().isDebug()) {
-                ess.getLogger().info("OfflinePlayer usermap load saving user data for " + player);
-            }
-
-            // this code makes me sad
-            user.startTransaction();
-            try {
-                user.setMoney(ess.getSettings().getStartingBalance());
-            } catch (MaxMoneyException e) {
-                // Shouldn't happen as it would be an illegal configuration state
-                throw new RuntimeException(e);
-            }
-            user.setLastAccountName(user.getName());
-            user.stopTransaction();
+            final OfflinePlayerStub essPlayer = new OfflinePlayerStub(player.getUniqueId(), Bukkit.getServer());
+            essPlayer.setName(player.getName());
+            userPlayer = essPlayer;
         }
 
-        trackUUID(player.getUniqueId(), user.getName(), false);
+        final User user = userMap.getUser(userPlayer);
+        if (user == null) {
+            throw new UserDoesNotExistException("User not found");
+        }
         return user;
     }
 
-    @Override
-    public void reloadConfig() {
-        getUUIDMap().forceWriteUUIDMap();
-        loadAllUsersAsync(ess);
-    }
-
-    public void invalidateAll() {
-        users.invalidateAll();
-    }
-
-    public void removeUser(final String name) {
-        if (names == null) {
-            ess.getLogger().warning("Name collection is null, cannot remove user.");
-            return;
-        }
-        final UUID uuid = names.get(name);
-        if (uuid != null) {
-            keys.remove(uuid);
-            users.invalidate(uuid.toString());
-        }
-        names.remove(name);
-        names.remove(StringUtil.safeString(name));
-    }
-
-    public void removeUserUUID(final String uuid) {
-        users.invalidate(uuid);
-    }
-
     public Set<UUID> getAllUniqueUsers() {
-        return Collections.unmodifiableSet(keys);
+        return userMap.getAllUserUUIDs();
     }
 
     public int getUniqueUsers() {
-        return keys.size();
+        return userMap.getUserCount();
     }
 
     protected ConcurrentSkipListMap<String, UUID> getNames() {
-        return names;
-    }
-
-    protected ConcurrentSkipListMap<UUID, ArrayList<String>> getHistory() {
-        return history;
-    }
-
-    public List<String> getUserHistory(final UUID uuid) {
-        return history.get(uuid);
+        return new ConcurrentSkipListMap<>(userMap.getNameCache());
     }
 
     public UUIDMap getUUIDMap() {
         return uuidMap;
     }
-    //  class UserMapRemovalListener implements RemovalListener
-    //  {
-    //      @Override
-    //      public void onRemoval(final RemovalNotification notification)
-    //      {
-    //          Object value = notification.getValue();
-    //          if (value != null)
-    //          {
-    //              ((User)value).cleanup();
-    //          }
-    //      }
-    //  }
-
-    private File getUserFileFromID(final UUID uuid) {
-        final File userFolder = new File(ess.getDataFolder(), "userdata");
-        return new File(userFolder, uuid.toString() + ".yml");
-    }
-
-    public File getUserFileFromString(final String name) {
-        final File userFolder = new File(ess.getDataFolder(), "userdata");
-        return new File(userFolder, StringUtil.sanitizeFileName(name) + ".yml");
-    }
-
-    @SuppressWarnings("deprecation")
-    public User getUserFromBukkit(String name) {
-        name = StringUtil.safeString(name);
-        if (ess.getSettings().isDebug()) {
-            ess.getLogger().warning("Using potentially blocking Bukkit UUID lookup for: " + name);
-        }
-        // Don't attempt to look up entirely invalid usernames
-        if (name == null || !validUserPattern.matcher(name).matches()) {
-            return null;
-        }
-        final org.bukkit.OfflinePlayer offlinePlayer = ess.getServer().getOfflinePlayer(name);
-        if (offlinePlayer == null) {
-            return null;
-        }
-        final UUID uuid;
-        try {
-            uuid = offlinePlayer.getUniqueId();
-        } catch (final UnsupportedOperationException | NullPointerException e) {
-            return null;
-        }
-        // This is how Bukkit generates fake UUIDs
-        if (UUID.nameUUIDFromBytes(("OfflinePlayer:" + name).getBytes(Charsets.UTF_8)).equals(uuid)) {
-            return null;
-        } else {
-            names.put(name, uuid);
-            return getUser(uuid);
-        }
-    }
-
-    private User legacyCacheGet(final UUID uuid) {
-        if (getLegacy == null) {
-            final Class<?> usersClass = users.getClass();
-            for (final Method m : usersClass.getDeclaredMethods()) {
-                if (m.getName().equals("get")) {
-                    getLegacy = m;
-                    getLegacy.setAccessible(true);
-                    break;
-                }
-            }
-        }
-        try {
-            return (User) getLegacy.invoke(users, uuid.toString());
-        } catch (final IllegalAccessException | InvocationTargetException e) {
-            return null;
-        }
-    }
-
-    private void legacyMaximumSize(final CacheBuilder builder, final int maxCount) {
-        try {
-            final Method maxSizeLegacy = builder.getClass().getDeclaredMethod("maximumSize", Integer.TYPE);
-            maxSizeLegacy.setAccessible(true);
-            maxSizeLegacy.invoke(builder, maxCount);
-        } catch (final NoSuchMethodException | InvocationTargetException | IllegalAccessException e) {
-            e.printStackTrace();
-        }
-    }
-
-    @SuppressWarnings("unchecked")
-    private Cache<String, User> legacyBuild(final CacheBuilder builder) {
-        Method build = null;
-        for (final Method method : builder.getClass().getDeclaredMethods()) {
-            if (method.getName().equals("build")) {
-                build = method;
-                break;
-            }
-        }
-        Cache<String, User> legacyUsers;
-        try {
-            assert build != null;
-            build.setAccessible(true);
-            legacyUsers = (Cache<String, User>) build.invoke(builder, this);
-        } catch (final IllegalAccessException | InvocationTargetException e) {
-            legacyUsers = null;
-        }
-        return legacyUsers;
-    }
 }

Essentials/src/main/java/com/earth2me/essentials/Warps.java

@@ -1,10 +1,11 @@
 package com.earth2me.essentials;
 
+import com.earth2me.essentials.adventure.AdventureUtil;
 import com.earth2me.essentials.commands.WarpNotFoundException;
 import com.earth2me.essentials.config.EssentialsConfiguration;
 import com.earth2me.essentials.utils.StringUtil;
 import net.ess3.api.InvalidNameException;
-import net.ess3.api.InvalidWorldException;
+import net.ess3.api.TranslatableException;
 import org.bukkit.Location;
 
 import java.io.File;
@@ -16,12 +17,10 @@ import java.util.Locale;
 import java.util.Map;
 import java.util.UUID;
 import java.util.logging.Level;
-import java.util.logging.Logger;
 
-import static com.earth2me.essentials.I18n.tl;
+import static com.earth2me.essentials.I18n.tlLiteral;
 
 public class Warps implements IConf, net.ess3.api.IWarps {
-    private static final Logger logger = Logger.getLogger("Essentials");
     private final Map<StringIgnoreCase, EssentialsConfiguration> warpPoints = new HashMap<>();
     private final File warpsFolder;
 
@@ -54,7 +53,7 @@ public class Warps implements IConf, net.ess3.api.IWarps {
     }
 
     @Override
-    public Location getWarp(final String warp) throws WarpNotFoundException, InvalidWorldException {
+    public Location getWarp(final String warp) throws WarpNotFoundException {
         final EssentialsConfiguration conf = warpPoints.get(new StringIgnoreCase(warp));
         if (conf == null) {
             throw new WarpNotFoundException();
@@ -79,7 +78,7 @@ public class Warps implements IConf, net.ess3.api.IWarps {
         if (conf == null) {
             final File confFile = new File(warpsFolder, filename + ".yml");
             if (confFile.exists()) {
-                throw new Exception(tl("similarWarpExist"));
+                throw new TranslatableException("similarWarpExist");
             }
             conf = new EssentialsConfiguration(confFile);
             conf.load();
@@ -111,10 +110,10 @@ public class Warps implements IConf, net.ess3.api.IWarps {
     public void removeWarp(final String name) throws Exception {
         final EssentialsConfiguration conf = warpPoints.get(new StringIgnoreCase(name));
         if (conf == null) {
-            throw new Exception(tl("warpNotExist"));
+            throw new TranslatableException("warpNotExist");
         }
         if (!conf.getFile().delete()) {
-            throw new Exception(tl("warpDeleteError"));
+            throw new TranslatableException("warpDeleteError");
         }
         warpPoints.remove(new StringIgnoreCase(name));
     }
@@ -123,7 +122,7 @@ public class Warps implements IConf, net.ess3.api.IWarps {
     public final void reloadConfig() {
         warpPoints.clear();
         final File[] listOfFiles = warpsFolder.listFiles();
-        if (listOfFiles.length >= 1) {
+        if (listOfFiles != null) {
             for (final File listOfFile : listOfFiles) {
                 final String filename = listOfFile.getName();
                 if (listOfFile.isFile() && filename.endsWith(".yml")) {
@@ -135,7 +134,7 @@ public class Warps implements IConf, net.ess3.api.IWarps {
                             warpPoints.put(new StringIgnoreCase(name), conf);
                         }
                     } catch (final Exception ex) {
-                        logger.log(Level.WARNING, tl("loadWarpError", filename), ex);
+                        Essentials.getWrappedLogger().log(Level.WARNING, AdventureUtil.getAdventureFacet().miniToLegacy(tlLiteral("loadWarpError", filename)), ex);
                     }
                 }
             }

Essentials/src/main/java/com/earth2me/essentials/Worth.java

@@ -3,7 +3,9 @@ package com.earth2me.essentials;
 import com.earth2me.essentials.commands.NotEnoughArgumentsException;
 import com.earth2me.essentials.config.ConfigurateUtil;
 import com.earth2me.essentials.config.EssentialsConfiguration;
+import com.earth2me.essentials.craftbukkit.Inventories;
 import com.earth2me.essentials.utils.VersionUtil;
+import net.ess3.api.TranslatableException;
 import org.bukkit.Material;
 import org.bukkit.inventory.ItemStack;
 import org.spongepowered.configurate.CommentedConfigurationNode;
@@ -12,8 +14,6 @@ import java.io.File;
 import java.math.BigDecimal;
 import java.util.Locale;
 
-import static com.earth2me.essentials.I18n.tl;
-
 public class Worth implements IConf {
     private final EssentialsConfiguration config;
 
@@ -30,13 +30,15 @@ public class Worth implements IConf {
      * @return The price from the config.
      */
     public BigDecimal getPrice(final IEssentials ess, final ItemStack itemStack) {
-        BigDecimal result;
+        BigDecimal result = BigDecimal.ONE.negate();
 
         final String itemname = itemStack.getType().toString().toLowerCase(Locale.ENGLISH).replace("_", "");
 
-        // Check for matches with data value from stack
-        // Note that we always default to BigDecimal.ONE.negate(), equivalent to -1
-        result = config.getBigDecimal("worth." + itemname + "." + itemStack.getDurability(), BigDecimal.ONE.negate());
+        if (VersionUtil.PRE_FLATTENING) {
+            // Check for matches with data value from stack
+            // Note that we always default to BigDecimal.ONE.negate(), equivalent to -1
+            result = config.getBigDecimal("worth." + itemname + "." + itemStack.getDurability(), BigDecimal.ONE.negate());
+        }
 
         // Check for matches with data value 0
         if (result.signum() < 0) {
@@ -75,7 +77,7 @@ public class Worth implements IConf {
      */
     public int getAmount(final IEssentials ess, final User user, final ItemStack is, final String[] args, final boolean isBulkSell) throws Exception {
         if (is == null || is.getType() == Material.AIR) {
-            throw new Exception(tl("itemSellAir"));
+            throw new TranslatableException("itemSellAir");
         }
 
         int amount = 0;
@@ -95,11 +97,11 @@ public class Worth implements IConf {
         final boolean requireStack = ess.getSettings().isTradeInStacks(is.getType());
 
         if (requireStack && !stack) {
-            throw new Exception(tl("itemMustBeStacked"));
+            throw new TranslatableException("itemMustBeStacked");
         }
 
         int max = 0;
-        for (final ItemStack s : user.getBase().getInventory().getContents()) {
+        for (final ItemStack s : Inventories.getInventory(user.getBase(), false)) {
             if (s == null || !s.isSimilar(is)) {
                 continue;
             }
@@ -118,9 +120,9 @@ public class Worth implements IConf {
         }
         if (amount > max || amount < 1) {
             if (!isBulkSell) {
-                user.sendMessage(tl("itemNotEnough2"));
-                user.sendMessage(tl("itemNotEnough3"));
-                throw new Exception(tl("itemNotEnough1"));
+                user.sendTl("itemNotEnough2");
+                user.sendTl("itemNotEnough3");
+                throw new TranslatableException("itemNotEnough1");
             } else {
                 return amount;
             }
@@ -140,7 +142,7 @@ public class Worth implements IConf {
         String path = "worth." + itemStack.getType().toString().toLowerCase(Locale.ENGLISH).replace("_", "");
 
         // Spigot 1.13+ throws an exception if a 1.13+ plugin even *attempts* to do set data.
-        if (VersionUtil.getServerBukkitVersion().isLowerThan(VersionUtil.v1_13_0_R01) && itemStack.getType().getData() == null) {
+        if (VersionUtil.PRE_FLATTENING && itemStack.getType().getData() == null) {
             // Bukkit-bug: getDurability still contains the correct value, while getData().getData() is 0.
             path = path + "." + itemStack.getDurability();
         }
@@ -149,6 +151,10 @@ public class Worth implements IConf {
         config.save();
     }
 
+    public File getFile() {
+        return config.getFile();
+    }
+
     @Override
     public void reloadConfig() {
         config.load();

Essentials/src/main/java/com/earth2me/essentials/adventure/AdventureUtil.java

@@ -0,0 +1,62 @@
+package com.earth2me.essentials.adventure;
+
+import net.kyori.adventure.text.format.NamedTextColor;
+
+public final class AdventureUtil {
+    private static final String LOOKUP = "0123456789abcdefklmnor";
+    private static final NamedTextColor[] COLORS = new NamedTextColor[]{NamedTextColor.BLACK, NamedTextColor.DARK_BLUE, NamedTextColor.DARK_GREEN, NamedTextColor.DARK_AQUA, NamedTextColor.DARK_RED, NamedTextColor.DARK_PURPLE, NamedTextColor.GOLD, NamedTextColor.GRAY, NamedTextColor.DARK_GRAY, NamedTextColor.BLUE, NamedTextColor.GREEN, NamedTextColor.AQUA, NamedTextColor.RED, NamedTextColor.LIGHT_PURPLE, NamedTextColor.YELLOW, NamedTextColor.WHITE};
+
+    private static AdventureFacet ADVENTURE_FACET_INSTANCE = null;
+
+    private AdventureUtil() {
+    }
+
+    public static void setAdventureFacet(AdventureFacet adventureFacetInstance) {
+        ADVENTURE_FACET_INSTANCE = adventureFacetInstance;
+    }
+
+    public static AdventureFacet getAdventureFacet() {
+        return ADVENTURE_FACET_INSTANCE;
+    }
+
+    /**
+     * Get the {@link NamedTextColor} from its associated section sign char.
+     */
+    public static NamedTextColor fromChar(final char c) {
+        final int index = LOOKUP.indexOf(c);
+        if (index == -1 || index > 15) {
+            return null;
+        }
+        return COLORS[index];
+    }
+
+    public static String fromCharName(final char c) {
+        final NamedTextColor namedTextColor = fromChar(c);
+        if (namedTextColor == null) {
+            return null;
+        }
+
+        return namedTextColor.toString();
+    }
+
+    /**
+     * Parameters for a translation message are not parsed for MiniMessage by default to avoid injection. If you want
+     * a parameter to be parsed for MiniMessage you must wrap it in a ParsedPlaceholder by using this method.
+     */
+    public static ParsedPlaceholder parsed(final String literal) {
+        return new ParsedPlaceholder(literal);
+    }
+
+    public static class ParsedPlaceholder {
+        private final String value;
+
+        protected ParsedPlaceholder(String value) {
+            this.value = value;
+        }
+
+        @Override
+        public String toString() {
+            return value;
+        }
+    }
+}

Essentials/src/main/java/com/earth2me/essentials/adventure/SpigotAdventureFacet.java

@@ -0,0 +1,155 @@
+package com.earth2me.essentials.adventure;
+
+import com.earth2me.essentials.Essentials;
+import com.earth2me.essentials.utils.NumberUtil;
+import com.earth2me.essentials.utils.VersionUtil;
+import net.ess3.provider.AbstractChatEvent;
+import net.kyori.adventure.platform.bukkit.BukkitAudiences;
+import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.flattener.ComponentFlattener;
+import net.kyori.adventure.text.format.NamedTextColor;
+import net.kyori.adventure.text.format.TextColor;
+import net.kyori.adventure.text.minimessage.MiniMessage;
+import net.kyori.adventure.text.minimessage.tag.Tag;
+import net.kyori.adventure.text.minimessage.tag.resolver.TagResolver;
+import net.kyori.adventure.text.serializer.legacy.LegacyComponentSerializer;
+import org.bukkit.Color;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+import java.util.Locale;
+
+public class SpigotAdventureFacet implements AdventureFacet {
+    private static final LegacyComponentSerializer LEGACY_SERIALIZER;
+    private static final LegacyComponentSerializer LEGACY_SERIALIZER_URLS;
+    private static final MiniMessage MINI_MESSAGE_NO_TAGS;
+
+    static {
+        final LegacyComponentSerializer.Builder builder = LegacyComponentSerializer.builder()
+                .flattener(ComponentFlattener.basic())
+                .useUnusualXRepeatedCharacterHexFormat();
+        if (VersionUtil.getServerBukkitVersion().isHigherThanOrEqualTo(VersionUtil.v1_16_1_R01)) {
+            builder.hexColors();
+        }
+        LEGACY_SERIALIZER = builder.build();
+        LEGACY_SERIALIZER_URLS = builder.extractUrls(AbstractChatEvent.URL_PATTERN).build();
+
+        MINI_MESSAGE_NO_TAGS = MiniMessage.builder().strict(true).build();
+    }
+
+    private final Essentials ess;
+    private final BukkitAudiences bukkitAudiences;
+    private final MiniMessage miniMessageInstance;
+
+    public SpigotAdventureFacet(final Essentials ess) {
+        this.ess = ess.getSettings() == null ? null : ess;
+        bukkitAudiences = BukkitAudiences.create(ess);
+
+        miniMessageInstance = MiniMessage.builder()
+                .tags(TagResolver.builder()
+                        .resolvers(TagResolver.standard())
+                        .resolver(TagResolver.resolver("primary", supplyTag(true)))
+                        .resolver(TagResolver.resolver("secondary", supplyTag(false)))
+                        .build())
+                .build();
+    }
+
+    private Tag supplyTag(final boolean primary) {
+        final String color = primary ? (ess != null ? ess.getSettings().getPrimaryColor() : "gold") : (ess != null ? ess.getSettings().getSecondaryColor() : "red");
+
+        final TextColor textColor;
+        if (color.startsWith("#") && color.length() == 7 && NumberUtil.isHexadecimal(color.substring(1))) {
+            textColor = TextColor.color(Color.fromRGB(Integer.decode(color)).asRGB());
+        } else if (color.length() == 1) {
+            textColor = AdventureUtil.fromChar(color.charAt(0));
+        } else {
+            textColor = NamedTextColor.NAMES.value(color.toLowerCase(Locale.ENGLISH));
+        }
+
+        return ess != null && textColor != null ? Tag.styling(textColor) : Tag.styling(primary ? NamedTextColor.GOLD : NamedTextColor.RED);
+    }
+
+    @Override
+    public ComponentHolder deserializeMiniMessage(String message) {
+        return new ComponentHolder(miniMessageInstance.deserialize(message));
+    }
+
+    @Override
+    public String legacyToMini(String message) {
+        return legacyToMini(message, false);
+    }
+
+    @Override
+    public void send(CommandSender sender, ComponentHolder component) {
+        bukkitAudiences.sender(sender).sendMessage((Component) component.getComponent());
+    }
+
+    @Override
+    public void send(Player player, ComponentHolder component) {
+        bukkitAudiences.player(player).sendMessage((Component) component.getComponent());
+    }
+
+    @Override
+    public String adventureToLegacy(ComponentHolder component) {
+        return adventureToLegacy((Component) component.getComponent());
+    }
+
+    private String adventureToLegacy(Component component) {
+        return LEGACY_SERIALIZER.serialize(component);
+    }
+
+    @Override
+    public ComponentHolder legacyToAdventure(String message) {
+        return new ComponentHolder(LEGACY_SERIALIZER.deserialize(message));
+    }
+
+    @Override
+    public ComponentHolder text(String message) {
+        return new ComponentHolder(Component.text(message));
+    }
+
+    @Override
+    public String legacyToMini(String message, boolean useCustomTags) {
+        final Component deserializedText = LEGACY_SERIALIZER.deserialize(message);
+        if (useCustomTags) {
+            return miniMessageInstance.serialize(deserializedText);
+        } else {
+            return MINI_MESSAGE_NO_TAGS.serialize(deserializedText);
+        }
+    }
+
+    @Override
+    public String miniToLegacy(String message) {
+        return adventureToLegacy(miniMessageInstance.deserialize(message));
+    }
+
+    @Override
+    public String stripTags(String input) {
+        return miniMessageInstance.stripTags(input);
+    }
+
+    @Override
+    public String legacyToMiniWithUrls(String message) {
+        return miniMessageInstance.serialize(LEGACY_SERIALIZER_URLS.deserialize(message));
+    }
+
+    @Override
+    public String escapeTags(String input) {
+        return miniMessageInstance.escapeTags(input);
+    }
+
+    @Override
+    public ComponentHolder append(ComponentHolder base, ComponentHolder... addition) {
+        Component baseComponent = (Component) base.getComponent();
+        for (ComponentHolder holder : addition) {
+            final Component additionComponent = (Component) holder.getComponent();
+            baseComponent = baseComponent.append(additionComponent);
+        }
+        return new ComponentHolder(baseComponent);
+    }
+
+    @Override
+    public void close() {
+        bukkitAudiences.close();
+    }
+}

Essentials/src/main/java/com/earth2me/essentials/api/Economy.java

@@ -3,6 +3,7 @@ package com.earth2me.essentials.api;
 import com.earth2me.essentials.Trade;
 import com.earth2me.essentials.User;
 import com.earth2me.essentials.config.EssentialsUserConfiguration;
+import com.earth2me.essentials.userstorage.ModernUserMap;
 import com.earth2me.essentials.utils.NumberUtil;
 import com.earth2me.essentials.utils.StringUtil;
 import com.google.common.base.Charsets;
@@ -17,14 +18,12 @@ import java.math.MathContext;
 import java.text.MessageFormat;
 import java.util.UUID;
 import java.util.logging.Level;
-import java.util.logging.Logger;
 
 /**
  * You should use Vault instead of directly using this class.
  */
 public class Economy {
     public static final MathContext MATH_CONTEXT = MathContext.DECIMAL128;
-    private static final Logger LOGGER = Logger.getLogger("Essentials");
     private static IEssentials ess;
 
     private static final String WARN_CALL_BEFORE_LOAD = "Essentials API is called before Essentials is loaded.";
@@ -43,9 +42,9 @@ public class Economy {
         ess = aEss;
     }
 
-    private static void createNPCFile(String name) {
+    private static void createNPCFile(final String unsanitizedName) {
         final File folder = new File(ess.getDataFolder(), "userdata");
-        name = StringUtil.safeString(name);
+        final String name = ess.getSettings().isSafeUsermap() ? StringUtil.safeString(unsanitizedName) : unsanitizedName;
         if (!folder.exists()) {
             if (!folder.mkdirs()) {
                 throw new RuntimeException("Error while creating userdata directory!");
@@ -54,16 +53,19 @@ public class Economy {
         final UUID npcUUID = UUID.nameUUIDFromBytes(("NPC:" + name).getBytes(Charsets.UTF_8));
         final File npcFile = new File(folder, npcUUID + ".yml");
         if (npcFile.exists()) {
-            LOGGER.log(Level.SEVERE, MessageFormat.format(WARN_NPC_RECREATE_1, name, npcUUID.toString()), new RuntimeException());
-            LOGGER.log(Level.SEVERE, WARN_NPC_RECREATE_2);
+            ess.getLogger().log(Level.SEVERE, MessageFormat.format(WARN_NPC_RECREATE_1, name, npcUUID.toString()), new RuntimeException());
+            ess.getLogger().log(Level.SEVERE, WARN_NPC_RECREATE_2);
         }
         final EssentialsUserConfiguration npcConfig = new EssentialsUserConfiguration(name, npcUUID, npcFile);
         npcConfig.load();
         npcConfig.setProperty("npc", true);
         npcConfig.setProperty("last-account-name", name);
+        npcConfig.setProperty("npc-name", unsanitizedName);
         npcConfig.setProperty("money", ess.getSettings().getStartingBalance());
         npcConfig.blockingSave();
-        ess.getUserMap().trackUUID(npcUUID, name, false);
+        // This will load the NPC into the UserMap + UUID cache
+        ((ModernUserMap) ess.getUsers()).addCachedNpcName(npcUUID, name);
+        ess.getUsers().getUser(npcUUID);
     }
 
     private static void deleteNPC(final String name) {
@@ -90,7 +92,7 @@ public class Economy {
             if (player != null) {
                 user = ess.getUser(player.getUniqueId());
                 if (user != null) {
-                    LOGGER.log(Level.INFO, MessageFormat.format(WARN_PLAYER_UUID_NO_NAME, name, player.getUniqueId().toString()), new RuntimeException());
+                    ess.getLogger().log(Level.INFO, MessageFormat.format(WARN_PLAYER_UUID_NO_NAME, name, player.getUniqueId().toString()), new RuntimeException());
                 }
             }
         }
@@ -190,7 +192,7 @@ public class Economy {
         try {
             setMoney(name, BigDecimal.valueOf(balance));
         } catch (final ArithmeticException e) {
-            LOGGER.log(Level.WARNING, "Failed to set balance of " + name + " to " + balance + ": " + e.getMessage(), e);
+            ess.getLogger().log(Level.WARNING, "Failed to set balance of " + name + " to " + balance + ": " + e.getMessage(), e);
         }
     }
 
@@ -268,7 +270,7 @@ public class Economy {
         try {
             add(name, BigDecimal.valueOf(amount));
         } catch (final ArithmeticException e) {
-            LOGGER.log(Level.WARNING, "Failed to add " + amount + " to balance of " + name + ": " + e.getMessage(), e);
+            ess.getLogger().log(Level.WARNING, "Failed to add " + amount + " to balance of " + name + ": " + e.getMessage(), e);
         }
     }
 
@@ -321,7 +323,13 @@ public class Economy {
             throw new IllegalArgumentException("Economy user cannot be null");
         }
         final BigDecimal result = getMoneyExact(user).add(amount, MATH_CONTEXT);
-        setMoney(user, result);
+        // Deposits (positive amounts) always improve the balance, so minMoney and
+        // loan checks don't apply — they exist to prevent the balance from dropping.
+        if (amount.signum() <= 0) {
+            setMoney(user, result);
+        } else {
+            user.setMoney(result, UserBalanceUpdateEvent.Cause.API);
+        }
         Trade.log("API", "Add", "API", user.getName(), new Trade(amount, ess), null, null, null, result, ess);
     }
 
@@ -340,7 +348,7 @@ public class Economy {
         try {
             substract(name, BigDecimal.valueOf(amount));
         } catch (final ArithmeticException e) {
-            LOGGER.log(Level.WARNING, "Failed to subtract " + amount + " of balance of " + name + ": " + e.getMessage(), e);
+            ess.getLogger().log(Level.WARNING, "Failed to subtract " + amount + " of balance of " + name + ": " + e.getMessage(), e);
         }
     }
 
@@ -410,7 +418,7 @@ public class Economy {
         try {
             divide(name, BigDecimal.valueOf(amount));
         } catch (final ArithmeticException e) {
-            LOGGER.log(Level.WARNING, "Failed to divide balance of " + name + " by " + amount + ": " + e.getMessage(), e);
+            ess.getLogger().log(Level.WARNING, "Failed to divide balance of " + name + " by " + amount + ": " + e.getMessage(), e);
         }
     }
 
@@ -482,7 +490,7 @@ public class Economy {
         try {
             multiply(name, BigDecimal.valueOf(amount));
         } catch (final ArithmeticException e) {
-            LOGGER.log(Level.WARNING, "Failed to multiply balance of " + name + " by " + amount + ": " + e.getMessage(), e);
+            ess.getLogger().log(Level.WARNING, "Failed to multiply balance of " + name + " by " + amount + ": " + e.getMessage(), e);
         }
     }
 
@@ -603,7 +611,7 @@ public class Economy {
         try {
             return hasEnough(name, BigDecimal.valueOf(amount));
         } catch (final ArithmeticException e) {
-            LOGGER.log(Level.WARNING, "Failed to compare balance of " + name + " with " + amount + ": " + e.getMessage(), e);
+            ess.getLogger().log(Level.WARNING, "Failed to compare balance of " + name + " with " + amount + ": " + e.getMessage(), e);
             return false;
         }
     }
@@ -664,7 +672,7 @@ public class Economy {
         try {
             return hasMore(name, BigDecimal.valueOf(amount));
         } catch (final ArithmeticException e) {
-            LOGGER.log(Level.WARNING, "Failed to compare balance of " + name + " with " + amount + ": " + e.getMessage(), e);
+            ess.getLogger().log(Level.WARNING, "Failed to compare balance of " + name + " with " + amount + ": " + e.getMessage(), e);
             return false;
         }
     }
@@ -726,7 +734,7 @@ public class Economy {
         try {
             return hasLess(name, BigDecimal.valueOf(amount));
         } catch (final ArithmeticException e) {
-            LOGGER.log(Level.WARNING, "Failed to compare balance of " + name + " with " + amount + ": " + e.getMessage(), e);
+            ess.getLogger().log(Level.WARNING, "Failed to compare balance of " + name + " with " + amount + ": " + e.getMessage(), e);
             return false;
         }
     }
@@ -833,7 +841,7 @@ public class Economy {
         try {
             return format(BigDecimal.valueOf(amount));
         } catch (final NumberFormatException e) {
-            LOGGER.log(Level.WARNING, "Failed to display " + amount + ": " + e.getMessage(), e);
+            ess.getLogger().log(Level.WARNING, "Failed to display " + amount + ": " + e.getMessage(), e);
             return "NaN";
         }
     }
@@ -900,7 +908,7 @@ public class Economy {
             createNPCFile(name);
             return true;
         }
-        LOGGER.log(Level.WARNING, MessageFormat.format(WARN_EXISTING_NPC_CREATE, name, user.getConfigUUID()), new RuntimeException());
+        ess.getLogger().log(Level.WARNING, MessageFormat.format(WARN_EXISTING_NPC_CREATE, name, user.getConfigUUID()), new RuntimeException());
         return false;
     }
 

Essentials/src/main/java/com/earth2me/essentials/api/IJails.java

@@ -46,17 +46,6 @@ public interface IJails extends IConf {
      */
     void removeJail(String jail) throws Exception;
 
-    /**
-     * Attempts to send the given user to the given jail
-     *
-     * @param user the user to send to jail
-     * @param jail the jail to send the user to
-     * @throws Exception if the user is offline or jail does not exist
-     * @deprecated Use {@link IJails#sendToJail(IUser, String, CompletableFuture)}
-     */
-    @Deprecated
-    void sendToJail(IUser user, String jail) throws Exception;
-
     /**
      * Attempts to send the given user to the given jail
      *

Essentials/src/main/java/com/earth2me/essentials/api/IWarps.java

@@ -22,9 +22,8 @@ public interface IWarps extends IConf {
      * @param warp - Warp name
      * @return - Location the warp is set to
      * @throws WarpNotFoundException When the warp is not found
-     * @throws net.ess3.api.InvalidWorldException When the world the warp is in is not found
      */
-    Location getWarp(String warp) throws WarpNotFoundException, net.ess3.api.InvalidWorldException;
+    Location getWarp(String warp) throws WarpNotFoundException;
 
     /**
      * Checks if the provided name is a warp.

Essentials/src/main/java/com/earth2me/essentials/api/InvalidWorldException.java

@@ -1,16 +1,16 @@
 package com.earth2me.essentials.api;
 
-import static com.earth2me.essentials.I18n.tl;
+import net.ess3.api.TranslatableException;
 
 /**
  * @deprecated This exception is unused. Use {@link net.ess3.api.InvalidWorldException} instead.
  */
 @Deprecated
-public class InvalidWorldException extends Exception {
+public class InvalidWorldException extends TranslatableException {
     private final String world;
 
     public InvalidWorldException(final String world) {
-        super(tl("invalidWorld"));
+        super("invalidWorld");
         this.world = world;
     }
 

Essentials/src/main/java/com/earth2me/essentials/api/UserDoesNotExistException.java

@@ -1,18 +1,18 @@
 package com.earth2me.essentials.api;
 
-import java.util.UUID;
+import net.ess3.api.TranslatableException;
 
-import static com.earth2me.essentials.I18n.tl;
+import java.util.UUID;
 
 /**
  * Thrown when the requested user does not exist.
  */
-public class UserDoesNotExistException extends Exception {
+public class UserDoesNotExistException extends TranslatableException {
     public UserDoesNotExistException(final String name) {
-        super(tl("userDoesNotExist", name));
+        super("userDoesNotExist", name);
     }
 
     public UserDoesNotExistException(final UUID uuid) {
-        super(tl("uuidDoesNotExist", uuid.toString()));
+        super("uuidDoesNotExist", uuid.toString());
     }
 }

Essentials/src/main/java/com/earth2me/essentials/commands/Commandafk.java

@@ -3,14 +3,13 @@ package com.earth2me.essentials.commands;
 import com.earth2me.essentials.CommandSource;
 import com.earth2me.essentials.User;
 import com.earth2me.essentials.utils.DateUtil;
+import net.ess3.api.TranslatableException;
 import net.ess3.api.events.AfkStatusChangeEvent;
 import org.bukkit.Server;
 
 import java.util.Collections;
 import java.util.List;
 
-import static com.earth2me.essentials.I18n.tl;
-
 public class Commandafk extends EssentialsCommand {
     public Commandafk() {
         super("afk");
@@ -50,17 +49,23 @@ public class Commandafk extends EssentialsCommand {
             if (sender.isMuted()) {
                 final String dateDiff = sender.getMuteTimeout() > 0 ? DateUtil.formatDateDiff(sender.getMuteTimeout()) : null;
                 if (dateDiff == null) {
-                    throw new Exception(sender.hasMuteReason() ? tl("voiceSilencedReason", sender.getMuteReason()) : tl("voiceSilenced"));
+                    if (sender.hasMuteReason()) {
+                        throw new TranslatableException("voiceSilencedReason", sender.getMuteReason());
+                    } else {
+                        throw new TranslatableException("voiceSilenced");
+                    }
+                }
+                if (sender.hasMuteReason()) {
+                    throw new TranslatableException("voiceSilencedReasonTime", dateDiff, sender.getMuteReason());
+                } else {
+                    throw new TranslatableException("voiceSilencedTime", dateDiff);
                 }
-                throw new Exception(sender.hasMuteReason() ? tl("voiceSilencedReasonTime", dateDiff, sender.getMuteReason()) : tl("voiceSilencedTime", dateDiff));
             }
             if (!sender.isAuthorized("essentials.afk.message")) {
-                throw new Exception(tl("noPermToAFKMessage"));
+                throw new TranslatableException("noPermToAFKMessage");
             }
         }
         user.setDisplayNick();
-        String msg = "";
-        String selfmsg = "";
 
         final boolean currentStatus = user.isAfk();
         final boolean afterStatus = user.toggleAfk(AfkStatusChangeEvent.Cause.COMMAND);
@@ -68,38 +73,40 @@ public class Commandafk extends EssentialsCommand {
             return;
         }
 
+        String tlKey = "";
+        String selfTlKey = "";
         if (!afterStatus) {
             if (!user.isHidden()) {
-                msg = tl("userIsNotAway", user.getDisplayName());
-                selfmsg = tl("userIsNotAwaySelf", user.getDisplayName());
+                tlKey = "userIsNotAway";
+                selfTlKey = "userIsNotAwaySelf";
             }
             user.updateActivity(false, AfkStatusChangeEvent.Cause.COMMAND);
         } else {
             if (!user.isHidden()) {
                 if (message != null) {
-                    msg = tl("userIsAwayWithMessage", user.getDisplayName(), message);
-                    selfmsg = tl("userIsAwaySelfWithMessage", user.getDisplayName(), message);
+                    tlKey = "userIsAwayWithMessage";
+                    selfTlKey = "userIsAwaySelfWithMessage";
                 } else {
-                    msg = tl("userIsAway", user.getDisplayName());
-                    selfmsg = tl("userIsAwaySelf", user.getDisplayName());
+                    tlKey = "userIsAway";
+                    selfTlKey = "userIsAwaySelf";
                 }
             }
             user.setAfkMessage(message);
         }
-        if (!msg.isEmpty() && ess.getSettings().broadcastAfkMessage()) {
+        if (!tlKey.isEmpty() && ess.getSettings().broadcastAfkMessage()) {
             // exclude user from receiving general AFK announcement in favor of personal message
-            ess.broadcastMessage(user, msg, u -> u == user);
+            ess.broadcastTl(user, u -> u == user, tlKey, user.getDisplayName(), message);
         }
-        if (!selfmsg.isEmpty()) {
-            user.sendMessage(selfmsg);
+        if (!selfTlKey.isEmpty()) {
+            user.sendTl(selfTlKey, user.getDisplayName(), message);
         }
         user.setDisplayNick(); // Set this again after toggling
     }
 
     @Override
     protected List<String> getTabCompleteOptions(final Server server, final CommandSource sender, final String commandLabel, final String[] args) {
-        if (args.length == 1 && sender.isAuthorized("essentials.afk.others", ess)) {
-            return getPlayers(server, sender);
+        if (args.length == 1 && sender.isAuthorized("essentials.afk.others")) {
+            return getPlayers(sender);
         } else {
             return Collections.emptyList();
         }

Essentials/src/main/java/com/earth2me/essentials/commands/Commandanvil.java

@@ -1,10 +1,9 @@
 package com.earth2me.essentials.commands;
 
 import com.earth2me.essentials.User;
+import net.ess3.provider.ContainerProvider;
 import org.bukkit.Server;
 
-import static com.earth2me.essentials.I18n.tl;
-
 public class Commandanvil extends EssentialsCommand {
 
     public Commandanvil() {
@@ -13,11 +12,13 @@ public class Commandanvil extends EssentialsCommand {
 
     @Override
     protected void run(Server server, User user, String commandLabel, String[] args) throws Exception {
-        if (ess.getContainerProvider() == null) {
-            user.sendMessage(tl("unsupportedBrand"));
+        final ContainerProvider containerProvider = ess.provider(ContainerProvider.class);
+
+        if (containerProvider == null) {
+            user.sendTl("unsupportedBrand");
             return;
         }
 
-        ess.getContainerProvider().openAnvil(user.getBase());
+        containerProvider.openAnvil(user.getBase());
     }
 }

Essentials/src/main/java/com/earth2me/essentials/commands/Commandback.java

@@ -3,13 +3,12 @@ package com.earth2me.essentials.commands;
 import com.earth2me.essentials.CommandSource;
 import com.earth2me.essentials.Trade;
 import com.earth2me.essentials.User;
+import net.ess3.api.TranslatableException;
 import org.bukkit.Server;
 
 import java.util.Collections;
 import java.util.List;
 
-import static com.earth2me.essentials.I18n.tl;
-
 public class Commandback extends EssentialsCommand {
     public Commandback() {
         super("back");
@@ -37,13 +36,13 @@ public class Commandback extends EssentialsCommand {
 
     private void parseOthers(final Server server, final CommandSource sender, final String[] args, final String commandLabel) throws Exception {
         final User player = getPlayer(server, args, 0, true, false);
-        sender.sendMessage(tl("backOther", player.getName()));
+        sender.sendTl("backOther", player.getName());
         teleportBack(sender, player, commandLabel);
     }
 
     private void teleportBack(final CommandSource sender, final User user, final String commandLabel) throws Exception {
         if (user.getLastLocation() == null) {
-            throw new Exception(tl("noLocationFound"));
+            throw new TranslatableException("noLocationFound");
         }
 
         final String lastWorldName = user.getLastLocation().getWorld().getName();
@@ -53,11 +52,11 @@ public class Commandback extends EssentialsCommand {
             requester = ess.getUser(sender.getPlayer());
 
             if (user.getWorld() != user.getLastLocation().getWorld() && this.ess.getSettings().isWorldTeleportPermissions() && !user.isAuthorized("essentials.worlds." + lastWorldName)) {
-                throw new Exception(tl("noPerm", "essentials.worlds." + lastWorldName));
+                throw new TranslatableException("noPerm", "essentials.worlds." + lastWorldName);
             }
 
             if (!requester.isAuthorized("essentials.back.into." + lastWorldName)) {
-                throw new Exception(tl("noPerm", "essentials.back.into." + lastWorldName));
+                throw new TranslatableException("noPerm", "essentials.back.into." + lastWorldName);
             }
         }
 
@@ -78,7 +77,7 @@ public class Commandback extends EssentialsCommand {
     @Override
     protected List<String> getTabCompleteOptions(final Server server, final User user, final String commandLabel, final String[] args) {
         if (user.isAuthorized("essentials.back.others") && args.length == 1) {
-            return getPlayers(server, user);
+            return getPlayers(user);
         } else {
             return Collections.emptyList();
         }

Essentials/src/main/java/com/earth2me/essentials/commands/Commandbackup.java

@@ -2,10 +2,9 @@ package com.earth2me.essentials.commands;
 
 import com.earth2me.essentials.Backup;
 import com.earth2me.essentials.CommandSource;
+import net.ess3.api.TranslatableException;
 import org.bukkit.Server;
 
-import static com.earth2me.essentials.I18n.tl;
-
 public class Commandbackup extends EssentialsCommand {
     public Commandbackup() {
         super("backup");
@@ -15,13 +14,13 @@ public class Commandbackup extends EssentialsCommand {
     protected void run(final Server server, final CommandSource sender, final String commandLabel, final String[] args) throws Exception {
         final Backup backup = ess.getBackup();
         if (backup == null) {
-            throw new Exception(tl("backupDisabled"));
+            throw new TranslatableException("backupDisabled");
         }
         final String command = ess.getSettings().getBackupCommand();
         if (command == null || "".equals(command) || "save-all".equalsIgnoreCase(command)) {
-            throw new Exception(tl("backupDisabled"));
+            throw new TranslatableException("backupDisabled");
         }
         backup.run();
-        sender.sendMessage(tl("backupStarted"));
+        sender.sendTl("backupStarted");
     }
 }

Essentials/src/main/java/com/earth2me/essentials/commands/Commandbalance.java

@@ -2,14 +2,13 @@ package com.earth2me.essentials.commands;
 
 import com.earth2me.essentials.CommandSource;
 import com.earth2me.essentials.User;
+import com.earth2me.essentials.adventure.AdventureUtil;
 import com.earth2me.essentials.utils.NumberUtil;
 import org.bukkit.Server;
 
 import java.util.Collections;
 import java.util.List;
 
-import static com.earth2me.essentials.I18n.tl;
-
 public class Commandbalance extends EssentialsCommand {
     public Commandbalance() {
         super("balance");
@@ -21,17 +20,17 @@ public class Commandbalance extends EssentialsCommand {
             throw new NotEnoughArgumentsException();
         }
 
-        final User target = getPlayer(server, args, 0, false, true);
-        sender.sendMessage(tl("balanceOther", target.isHidden() ? target.getName() : target.getDisplayName(), NumberUtil.displayCurrency(target.getMoney(), ess)));
+        final User target = getPlayer(server, args, 0, true, true);
+        sender.sendTl("balanceOther", target.isHidden() ? target.getName() : target.getDisplayName(), AdventureUtil.parsed(NumberUtil.displayCurrency(target.getMoney(), ess)));
     }
 
     @Override
     public void run(final Server server, final User user, final String commandLabel, final String[] args) throws Exception {
         if (args.length == 1 && user.isAuthorized("essentials.balance.others")) {
-            final User target = getPlayer(server, args, 0, true, true);
-            user.sendMessage(tl("balanceOther", target.isHidden() ? target.getName() : target.getDisplayName(), NumberUtil.displayCurrency(target.getMoney(), ess)));
+            final User target = getPlayer(server, args, 0, false, true);
+            user.sendTl("balanceOther", target.isHidden() ? target.getName() : target.getDisplayName(), AdventureUtil.parsed(NumberUtil.displayCurrency(target.getMoney(), ess)));
         } else if (args.length < 2) {
-            user.sendMessage(tl("balance", NumberUtil.displayCurrency(user.getMoney(), ess)));
+            user.sendTl("balance", AdventureUtil.parsed(NumberUtil.displayCurrency(user.getMoney(), ess)));
         } else {
             throw new NotEnoughArgumentsException();
         }
@@ -39,8 +38,8 @@ public class Commandbalance extends EssentialsCommand {
 
     @Override
     protected List<String> getTabCompleteOptions(final Server server, final CommandSource sender, final String commandLabel, final String[] args) {
-        if (args.length == 1 && sender.isAuthorized("essentials.balance.others", ess)) {
-            return getPlayers(server, sender);
+        if (args.length == 1 && sender.isAuthorized("essentials.balance.others")) {
+            return getPlayers(sender);
         } else {
             return Collections.emptyList();
         }

Essentials/src/main/java/com/earth2me/essentials/commands/Commandbalancetop.java

@@ -1,12 +1,19 @@
 package com.earth2me.essentials.commands;
 
 import com.earth2me.essentials.CommandSource;
+import com.earth2me.essentials.User;
 import com.earth2me.essentials.textreader.SimpleTextInput;
 import com.earth2me.essentials.textreader.TextPager;
+import com.earth2me.essentials.adventure.AdventureUtil;
+import com.earth2me.essentials.utils.EnumUtil;
 import com.earth2me.essentials.utils.NumberUtil;
+import com.earth2me.essentials.utils.VersionUtil;
 import com.google.common.collect.Lists;
 import net.essentialsx.api.v2.services.BalanceTop;
+import org.bukkit.Bukkit;
 import org.bukkit.Server;
+import org.bukkit.Statistic;
+import org.bukkit.command.BlockCommandSender;
 
 import java.math.BigDecimal;
 import java.text.DateFormat;
@@ -17,7 +24,7 @@ import java.util.Map;
 import java.util.UUID;
 import java.util.concurrent.CompletableFuture;
 
-import static com.earth2me.essentials.I18n.tl;
+import static com.earth2me.essentials.I18n.tlLiteral;
 
 public class Commandbalancetop extends EssentialsCommand {
     public static final int MINUSERS = 50;
@@ -32,8 +39,15 @@ public class Commandbalancetop extends EssentialsCommand {
         final Calendar cal = Calendar.getInstance();
         cal.setTimeInMillis(ess.getBalanceTop().getCacheAge());
         final DateFormat format = DateFormat.getDateTimeInstance(DateFormat.SHORT, DateFormat.SHORT);
-        sender.sendMessage(tl("balanceTop", format.format(cal.getTime())));
-        new TextPager(cache).showPage(Integer.toString(page), null, "balancetop", sender);
+        final Runnable runnable = () -> {
+            sender.sendTl("balanceTop", format.format(cal.getTime()));
+            new TextPager(cache).showPage(Integer.toString(page), null, "balancetop", sender);
+        };
+        if (sender.getSender() instanceof BlockCommandSender) {
+            ess.scheduleSyncDelayedTask(runnable);
+        } else {
+            runnable.run();
+        }
     }
 
     @Override
@@ -56,8 +70,8 @@ public class Commandbalancetop extends EssentialsCommand {
         }
 
         // If there are less than 50 users in our usermap, there is no need to display a warning as these calculations should be done quickly
-        if (ess.getUserMap().getUniqueUsers() > MINUSERS) {
-            sender.sendMessage(tl("orderBalances", ess.getUserMap().getUniqueUsers()));
+        if (ess.getUsers().getUserCount() > MINUSERS) {
+            sender.sendTl("orderBalances", ess.getUsers().getUserCount());
         }
 
         ess.runTaskAsynchronously(new Viewer(sender, page, force));
@@ -101,17 +115,38 @@ public class Commandbalancetop extends EssentialsCommand {
             future.thenRun(() -> {
                 if (fresh) {
                     final SimpleTextInput newCache = new SimpleTextInput();
-                    newCache.getLines().add(tl("serverTotal", NumberUtil.displayCurrency(ess.getBalanceTop().getBalanceTopTotal(), ess)));
+                    newCache.getLines().add(ess.getAdventureFacet().miniToLegacy(tlLiteral("serverTotal", AdventureUtil.parsed(NumberUtil.displayCurrency(ess.getBalanceTop().getBalanceTopTotal(), ess)))));
                     int pos = 1;
                     for (final Map.Entry<UUID, BalanceTop.Entry> entry : ess.getBalanceTop().getBalanceTopCache().entrySet()) {
-                        if (ess.getSettings().showZeroBaltop() || entry.getValue().getBalance().compareTo(BigDecimal.ZERO) > 0) {
-                            newCache.getLines().add(tl("balanceTopLine", pos, entry.getValue().getDisplayName(), NumberUtil.displayCurrency(entry.getValue().getBalance(), ess)));
+                        final BigDecimal balance = entry.getValue().getBalance();
+                        final User user = ess.getUser(entry.getKey());
+
+                        final Statistic PLAY_ONE_TICK = EnumUtil.getStatistic("PLAY_ONE_MINUTE", "PLAY_ONE_TICK");
+                        final boolean offlineStatisticSupported = VersionUtil.getServerBukkitVersion().isHigherThanOrEqualTo(VersionUtil.v1_15_2_R01);
+                        final long playtime;
+                        if (user.getBase() == null || !user.getBase().isOnline()) {
+                            if (offlineStatisticSupported) {
+                                playtime = Bukkit.getServer().getOfflinePlayer(entry.getKey()).getStatistic(PLAY_ONE_TICK);
+                            } else {
+                                playtime = -1;
+                            }
+                        } else {
+                            playtime = user.getBase().getStatistic(PLAY_ONE_TICK);
+                        }
+                        // Play time in seconds
+                        final long playTimeSecs = Math.max(playtime / 20, 0);
+
+                        // Checking if player meets the requirements of minimum balance and minimum playtime to be listed in baltop list
+                        if ((ess.getSettings().showZeroBaltop() || balance.compareTo(BigDecimal.ZERO) > 0)
+                                && balance.compareTo(ess.getSettings().getBaltopMinBalance()) >= 0 &&
+                                // Skip playtime check for offline players on versions below 1.15.2
+                                (playtime == -1 || playTimeSecs >= ess.getSettings().getBaltopMinPlaytime())) {
+                            newCache.getLines().add(ess.getAdventureFacet().miniToLegacy(tlLiteral("balanceTopLine", pos, entry.getValue().getDisplayName(), AdventureUtil.parsed(NumberUtil.displayCurrency(balance, ess)))));
                         }
                         pos++;
                     }
                     cache = newCache;
                 }
-
                 outputCache(sender, page);
             });
         }

Essentials/src/main/java/com/earth2me/essentials/commands/Commandban.java

@@ -2,9 +2,10 @@ package com.earth2me.essentials.commands;
 
 import com.earth2me.essentials.CommandSource;
 import com.earth2me.essentials.Console;
-import com.earth2me.essentials.OfflinePlayer;
+import com.earth2me.essentials.OfflinePlayerStub;
 import com.earth2me.essentials.User;
 import com.earth2me.essentials.utils.FormatUtil;
+import net.ess3.api.TranslatableException;
 import org.bukkit.BanList;
 import org.bukkit.Server;
 
@@ -12,7 +13,7 @@ import java.util.Collections;
 import java.util.List;
 import java.util.logging.Level;
 
-import static com.earth2me.essentials.I18n.tl;
+import static com.earth2me.essentials.I18n.tlLiteral;
 
 public class Commandban extends EssentialsCommand {
     public Commandban() {
@@ -30,43 +31,43 @@ public class Commandban extends EssentialsCommand {
             user = getPlayer(server, args, 0, true, true);
         } catch (final PlayerNotFoundException e) {
             nomatch = true;
-            user = ess.getUser(new OfflinePlayer(args[0], ess.getServer()));
+            user = ess.getUser(new OfflinePlayerStub(args[0], ess.getServer()));
         }
         if (!user.getBase().isOnline()) {
             if (sender.isPlayer() && !ess.getUser(sender.getPlayer()).isAuthorized("essentials.ban.offline")) {
-                throw new Exception(tl("banExemptOffline"));
+                throw new TranslatableException("banExemptOffline");
             }
         } else if (user.isAuthorized("essentials.ban.exempt") && sender.isPlayer()) {
-            throw new Exception(tl("banExempt"));
+            throw new TranslatableException("banExempt");
         }
 
         final String senderName = sender.isPlayer() ? sender.getPlayer().getDisplayName() : Console.NAME;
-        final String senderDisplayName = sender.isPlayer() ? sender.getPlayer().getDisplayName() : Console.DISPLAY_NAME;
+        final String senderDisplayName = sender.isPlayer() ? sender.getPlayer().getDisplayName() : Console.displayName();
         final String banReason;
         if (args.length > 1) {
             banReason = FormatUtil.replaceFormat(getFinalArg(args, 1).replace("\\n", "\n").replace("|", "\n"));
         } else {
-            banReason = tl("defaultBanReason");
+            banReason = tlLiteral("defaultBanReason");
         }
 
         ess.getServer().getBanList(BanList.Type.NAME).addBan(user.getName(), banReason, null, senderName);
 
-        final String banDisplay = tl("banFormat", banReason, senderDisplayName);
+        final String banDisplay = tlLiteral("banFormat", banReason, senderDisplayName);
 
-        user.getBase().kickPlayer(banDisplay);
-        server.getLogger().log(Level.INFO, tl("playerBanned", senderDisplayName, user.getName(), banDisplay));
+        user.getBase().kickPlayer(ess.getAdventureFacet().miniToLegacy(banDisplay));
+        ess.getLogger().log(Level.INFO, ess.getAdventureFacet().miniToLegacy(tlLiteral("playerBanned", senderDisplayName, user.getName(), banDisplay)));
 
         if (nomatch) {
-            sender.sendMessage(tl("userUnknown", user.getName()));
+            sender.sendTl("userUnknown", user.getName());
         }
 
-        ess.broadcastMessage("essentials.ban.notify", tl("playerBanned", senderDisplayName, user.getName(), banReason));
+        ess.broadcastTl(null, u -> !u.isAuthorized("essentials.ban.notify"), "playerBanned", senderDisplayName, user.getName(), banReason);
     }
 
     @Override
     protected List<String> getTabCompleteOptions(final Server server, final CommandSource sender, final String commandLabel, final String[] args) {
         if (args.length == 1) {
-            return getPlayers(server, sender);
+            return getPlayers(sender);
         } else {
             return Collections.emptyList();
         }

Essentials/src/main/java/com/earth2me/essentials/commands/Commandbanip.java

@@ -12,7 +12,7 @@ import java.util.Collections;
 import java.util.List;
 import java.util.logging.Level;
 
-import static com.earth2me.essentials.I18n.tl;
+import static com.earth2me.essentials.I18n.tlLiteral;
 
 public class Commandbanip extends EssentialsCommand {
     public Commandbanip() {
@@ -26,7 +26,7 @@ public class Commandbanip extends EssentialsCommand {
         }
 
         final String senderName = sender.isPlayer() ? sender.getPlayer().getDisplayName() : Console.NAME;
-        final String senderDisplayName = sender.isPlayer() ? sender.getPlayer().getDisplayName() : Console.DISPLAY_NAME;
+        final String senderDisplayName = sender.isPlayer() ? sender.getPlayer().getDisplayName() : Console.displayName();
 
         String ipAddress;
         if (FormatUtil.validIP(args[0])) {
@@ -48,13 +48,13 @@ public class Commandbanip extends EssentialsCommand {
         if (args.length > 1) {
             banReason = FormatUtil.replaceFormat(getFinalArg(args, 1).replace("\\n", "\n").replace("|", "\n"));
         } else {
-            banReason = tl("defaultBanReason");
+            banReason = tlLiteral("defaultBanReason");
         }
 
-        final String banDisplay = tl("banFormat", banReason, senderDisplayName);
+        final String banDisplay = ess.getAdventureFacet().miniToLegacy(tlLiteral("banFormat", banReason, senderDisplayName));
 
         ess.getServer().getBanList(BanList.Type.IP).addBan(ipAddress, banReason, null, senderName);
-        server.getLogger().log(Level.INFO, tl("playerBanIpAddress", senderDisplayName, ipAddress, banReason));
+        ess.getLogger().log(Level.INFO, ess.getAdventureFacet().miniToLegacy(tlLiteral("playerBanIpAddress", senderDisplayName, ipAddress, banReason)));
 
         for (final Player player : ess.getServer().getOnlinePlayers()) {
             if (player.getAddress().getAddress().getHostAddress().equalsIgnoreCase(ipAddress)) {
@@ -62,14 +62,14 @@ public class Commandbanip extends EssentialsCommand {
             }
         }
 
-        ess.broadcastMessage("essentials.banip.notify", tl("playerBanIpAddress", senderDisplayName, ipAddress, banReason));
+        ess.broadcastTl(null, u -> !u.isAuthorized("essentials.banip.notify"), "playerBanIpAddress", senderDisplayName, ipAddress, banReason);
     }
 
     @Override
     protected List<String> getTabCompleteOptions(final Server server, final CommandSource sender, final String commandLabel, final String[] args) {
         if (args.length == 1) {
             // TODO: Also list IP addresses?
-            return getPlayers(server, sender);
+            return getPlayers(sender);
         } else {
             return Collections.emptyList();
         }

Essentials/src/main/java/com/earth2me/essentials/commands/Commandbeezooka.java

@@ -7,8 +7,6 @@ import org.bukkit.Location;
 import org.bukkit.Server;
 import org.bukkit.entity.Entity;
 
-import static com.earth2me.essentials.I18n.tl;
-
 public class Commandbeezooka extends EssentialsCommand {
 
     public Commandbeezooka() {
@@ -18,7 +16,7 @@ public class Commandbeezooka extends EssentialsCommand {
     @Override
     protected void run(final Server server, final User user, final String commandLabel, final String[] args) throws Exception {
         if (VersionUtil.getServerBukkitVersion().isLowerThan(VersionUtil.v1_15_R01)) {
-            user.sendMessage(tl("unsupportedFeature"));
+            user.sendTl("unsupportedFeature");
             return;
         }
 

Essentials/src/main/java/com/earth2me/essentials/commands/Commandbigtree.java

@@ -3,6 +3,7 @@ package com.earth2me.essentials.commands;
 import com.earth2me.essentials.User;
 import com.earth2me.essentials.utils.LocationUtil;
 import com.google.common.collect.Lists;
+import net.ess3.api.TranslatableException;
 import org.bukkit.Location;
 import org.bukkit.Server;
 import org.bukkit.TreeType;
@@ -10,8 +11,6 @@ import org.bukkit.TreeType;
 import java.util.Collections;
 import java.util.List;
 
-import static com.earth2me.essentials.I18n.tl;
-
 public class Commandbigtree extends EssentialsCommand {
     public Commandbigtree() {
         super("bigtree");
@@ -32,15 +31,15 @@ public class Commandbigtree extends EssentialsCommand {
             throw new NotEnoughArgumentsException();
         }
 
-        final Location loc = LocationUtil.getTarget(user.getBase()).add(0, 1, 0);
+        final Location loc = LocationUtil.getTarget(user.getBase(), ess.getSettings().getMaxTreeCommandRange()).add(0, 1, 0);
         if (loc.getBlock().getType().isSolid()) {
-            throw new Exception(tl("bigTreeFailure"));
+            throw new TranslatableException("bigTreeFailure");
         }
         final boolean success = user.getWorld().generateTree(loc, tree);
         if (success) {
-            user.sendMessage(tl("bigTreeSuccess"));
+            user.sendTl("bigTreeSuccess");
         } else {
-            throw new Exception(tl("bigTreeFailure"));
+            throw new TranslatableException("bigTreeFailure");
         }
     }
 

Essentials/src/main/java/com/earth2me/essentials/commands/Commandbook.java

@@ -1,20 +1,21 @@
 package com.earth2me.essentials.commands;
 
 import com.earth2me.essentials.User;
-import com.earth2me.essentials.utils.FormatUtil;
-import com.earth2me.essentials.craftbukkit.InventoryWorkaround;
+import com.earth2me.essentials.craftbukkit.Inventories;
 import com.earth2me.essentials.utils.EnumUtil;
+import com.earth2me.essentials.utils.FormatUtil;
+import com.earth2me.essentials.utils.VersionUtil;
 import com.google.common.collect.Lists;
+import net.ess3.api.TranslatableException;
 import org.bukkit.Material;
 import org.bukkit.Server;
 import org.bukkit.inventory.ItemStack;
 import org.bukkit.inventory.meta.BookMeta;
+import org.bukkit.inventory.meta.WritableBookMeta;
 
 import java.util.Collections;
 import java.util.List;
 
-import static com.earth2me.essentials.I18n.tl;
-
 public class Commandbook extends EssentialsCommand {
 
     private static final Material WRITABLE_BOOK = EnumUtil.getMaterial("WRITABLE_BOOK", "BOOK_AND_QUILL");
@@ -25,7 +26,7 @@ public class Commandbook extends EssentialsCommand {
 
     @Override
     public void run(final Server server, final User user, final String commandLabel, final String[] args) throws Exception {
-        final ItemStack item = user.getItemInHand();
+        final ItemStack item = Inventories.getItemInMainHand(user.getBase());
         final String player = user.getName();
         if (item.getType() == Material.WRITTEN_BOOK) {
             final BookMeta bmeta = (BookMeta) item.getItemMeta();
@@ -35,27 +36,34 @@ public class Commandbook extends EssentialsCommand {
                     final String newAuthor = FormatUtil.formatString(user, "essentials.book.author", getFinalArg(args, 1)).trim();
                     bmeta.setAuthor(newAuthor);
                     item.setItemMeta(bmeta);
-                    user.sendMessage(tl("bookAuthorSet", newAuthor));
+                    user.sendTl("bookAuthorSet", newAuthor);
                 } else {
-                    throw new Exception(tl("denyChangeAuthor"));
+                    throw new TranslatableException("denyChangeAuthor");
                 }
             } else if (args.length > 1 && args[0].equalsIgnoreCase("title")) {
                 if (user.isAuthorized("essentials.book.title") && (isAuthor(bmeta, player) || user.isAuthorized("essentials.book.others"))) {
                     final String newTitle = FormatUtil.formatString(user, "essentials.book.title", getFinalArg(args, 1)).trim();
                     bmeta.setTitle(newTitle);
                     item.setItemMeta(bmeta);
-                    user.sendMessage(tl("bookTitleSet", newTitle));
+                    user.sendTl("bookTitleSet", newTitle);
                 } else {
-                    throw new Exception(tl("denyChangeTitle"));
+                    throw new TranslatableException("denyChangeTitle");
                 }
             } else {
                 if (isAuthor(bmeta, player) || user.isAuthorized("essentials.book.others")) {
                     final ItemStack newItem = new ItemStack(WRITABLE_BOOK, item.getAmount());
-                    newItem.setItemMeta(bmeta);
-                    InventoryWorkaround.setItemInMainHand(user.getBase(), newItem);
-                    user.sendMessage(tl("editBookContents"));
+                    if (VersionUtil.getServerBukkitVersion().isHigherThanOrEqualTo(VersionUtil.v1_20_6_R01)) {
+                        final WritableBookMeta wbmeta = (WritableBookMeta) newItem.getItemMeta();
+                        //noinspection DataFlowIssue
+                        wbmeta.setPages(bmeta.getPages());
+                        newItem.setItemMeta(wbmeta);
+                    } else {
+                        newItem.setItemMeta(bmeta);
+                    }
+                    Inventories.setItemInMainHand(user.getBase(), newItem);
+                    user.sendTl("editBookContents");
                 } else {
-                    throw new Exception(tl("denyBookEdit"));
+                    throw new TranslatableException("denyBookEdit");
                 }
             }
         } else if (item.getType() == WRITABLE_BOOK) {
@@ -64,11 +72,19 @@ public class Commandbook extends EssentialsCommand {
                 bmeta.setAuthor(player);
             }
             final ItemStack newItem = new ItemStack(Material.WRITTEN_BOOK, item.getAmount());
-            newItem.setItemMeta(bmeta);
-            InventoryWorkaround.setItemInMainHand(user.getBase(), newItem);
-            user.sendMessage(tl("bookLocked"));
+            if (VersionUtil.getServerBukkitVersion().isHigherThanOrEqualTo(VersionUtil.v1_20_6_R01)) {
+                final BookMeta real = (BookMeta) newItem.getItemMeta();
+                real.setAuthor(bmeta.getAuthor());
+                real.setTitle(bmeta.getTitle());
+                real.setPages(bmeta.getPages());
+                newItem.setItemMeta(real);
+            } else {
+                newItem.setItemMeta(bmeta);
+            }
+            Inventories.setItemInMainHand(user.getBase(), newItem);
+            user.sendTl("bookLocked");
         } else {
-            throw new Exception(tl("holdBook"));
+            throw new TranslatableException("holdBook");
         }
     }
 
@@ -90,7 +106,7 @@ public class Commandbook extends EssentialsCommand {
             }
             return options;
         } else if (args.length == 2 && args[0].equalsIgnoreCase("author") && user.isAuthorized("essentials.book.author")) {
-            final List<String> options = getPlayers(server, user);
+            final List<String> options = getPlayers(user);
             options.add("Herobrine"); // #EasterEgg
             return options;
         } else {

Essentials/src/main/java/com/earth2me/essentials/commands/Commandbottom.java

@@ -0,0 +1,35 @@
+package com.earth2me.essentials.commands;
+
+import com.earth2me.essentials.Trade;
+import com.earth2me.essentials.User;
+import com.earth2me.essentials.utils.LocationUtil;
+import net.ess3.provider.WorldInfoProvider;
+import org.bukkit.Location;
+import org.bukkit.Server;
+import org.bukkit.event.player.PlayerTeleportEvent;
+
+import java.util.concurrent.CompletableFuture;
+
+public class Commandbottom extends EssentialsCommand {
+
+    public Commandbottom() {
+        super("bottom");
+    }
+
+    @Override
+    public void run(final Server server, final User user, final String commandLabel, final String[] args) throws Exception {
+        final int bottomX = user.getLocation().getBlockX();
+        final int bottomZ = user.getLocation().getBlockZ();
+        final float pitch = user.getLocation().getPitch();
+        final float yaw = user.getLocation().getYaw();
+        final Location unsafe = new Location(user.getWorld(), bottomX, ess.provider(WorldInfoProvider.class).getMinHeight(user.getWorld()), bottomZ, yaw, pitch);
+        final Location safe = LocationUtil.getSafeDestination(ess, unsafe);
+        final CompletableFuture<Boolean> future = getNewExceptionFuture(user.getSource(), commandLabel);
+        future.thenAccept(success -> {
+            if (success) {
+                user.sendTl("teleportBottom", safe.getWorld().getName(), safe.getBlockX(), safe.getBlockY(), safe.getBlockZ());
+            }
+        });
+        user.getAsyncTeleport().teleport(safe, new Trade(this.getName(), ess), PlayerTeleportEvent.TeleportCause.COMMAND, future);
+    }
+}

Essentials/src/main/java/com/earth2me/essentials/commands/Commandbreak.java

@@ -1,13 +1,12 @@
 package com.earth2me.essentials.commands;
 
 import com.earth2me.essentials.User;
+import net.ess3.api.TranslatableException;
 import org.bukkit.Material;
 import org.bukkit.Server;
 import org.bukkit.block.Block;
 import org.bukkit.event.block.BlockBreakEvent;
 
-import static com.earth2me.essentials.I18n.tl;
-
 public class Commandbreak extends EssentialsCommand {
     public Commandbreak() {
         super("break");
@@ -22,7 +21,7 @@ public class Commandbreak extends EssentialsCommand {
             throw new NoChargeException();
         }
         if (block.getType() == Material.BEDROCK && !user.isAuthorized("essentials.break.bedrock")) {
-            throw new Exception(tl("noBreakBedrock"));
+            throw new TranslatableException("noBreakBedrock");
         }
         //final List<ItemStack> list = (List<ItemStack>)block.getDrops();
         //final BlockBreakEvent event = new BlockBreakEvent(block, user.getBase(), list);

Essentials/src/main/java/com/earth2me/essentials/commands/Commandbroadcast.java

@@ -1,11 +1,10 @@
 package com.earth2me.essentials.commands;
 
 import com.earth2me.essentials.CommandSource;
+import com.earth2me.essentials.adventure.AdventureUtil;
 import com.earth2me.essentials.utils.FormatUtil;
 import org.bukkit.Server;
 
-import static com.earth2me.essentials.I18n.tl;
-
 public class Commandbroadcast extends EssentialsCommand {
     public Commandbroadcast() {
         super("broadcast");
@@ -17,6 +16,9 @@ public class Commandbroadcast extends EssentialsCommand {
             throw new NotEnoughArgumentsException();
         }
 
-        ess.broadcastMessage(tl("broadcast", FormatUtil.replaceFormat(getFinalArg(args, 0)).replace("\\n", "\n"), sender.getDisplayName()));
+        final String message = FormatUtil.replaceFormat(getFinalArg(args, 0)).replace("\\n", "\n");
+        ess.broadcastTl("broadcast",
+                AdventureUtil.parsed(ess.getAdventureFacet().legacyToMiniWithUrls(ess.getAdventureFacet().escapeTags(message))),
+                sender.getDisplayName());
     }
 }

Essentials/src/main/java/com/earth2me/essentials/commands/Commandbroadcastworld.java

@@ -2,21 +2,16 @@ package com.earth2me.essentials.commands;
 
 import com.earth2me.essentials.CommandSource;
 import com.earth2me.essentials.User;
-import com.earth2me.essentials.textreader.IText;
-import com.earth2me.essentials.textreader.KeywordReplacer;
-import com.earth2me.essentials.textreader.SimpleTextInput;
+import com.earth2me.essentials.adventure.AdventureUtil;
 import com.earth2me.essentials.utils.FormatUtil;
 import com.google.common.collect.Lists;
+import net.ess3.api.TranslatableException;
 import org.bukkit.Server;
 import org.bukkit.World;
-import org.bukkit.entity.Player;
 
-import java.util.Collection;
 import java.util.Collections;
 import java.util.List;
 
-import static com.earth2me.essentials.I18n.tl;
-
 public class Commandbroadcastworld extends EssentialsCommand {
 
     public Commandbroadcastworld() {
@@ -25,13 +20,13 @@ public class Commandbroadcastworld extends EssentialsCommand {
 
     @Override
     public void run(final Server server, final User user, final String commandLabel, final String[] args) throws Exception {
-        if (args.length == 0) {
+        if (args.length < 2) {
             throw new NotEnoughArgumentsException();
         }
 
         World world = user.getWorld();
         String message = getFinalArg(args, 0);
-        if (args.length > 1 && ess.getSettings().isAllowWorldInBroadcastworld()) {
+        if (ess.getSettings().isAllowWorldInBroadcastworld()) {
             final World argWorld = ess.getWorld(args[0]);
             if (argWorld != null) {
                 world = argWorld;
@@ -45,12 +40,12 @@ public class Commandbroadcastworld extends EssentialsCommand {
     @Override
     public void run(final Server server, final CommandSource sender, final String commandLabel, final String[] args) throws Exception {
         if (args.length < 2) {
-            throw new NotEnoughArgumentsException("world");
+            throw new NotEnoughArgumentsException();
         }
 
         final World world = ess.getWorld(args[0]);
         if (world == null) {
-            throw new Exception(tl("invalidWorld"));
+            throw new TranslatableException("invalidWorld");
         }
         sendBroadcast(world, sender.getSender().getName(), getFinalArg(args, 1));
     }
@@ -59,22 +54,11 @@ public class Commandbroadcastworld extends EssentialsCommand {
         if (message.isEmpty()) {
             throw new NotEnoughArgumentsException();
         }
-        sendToWorld(world, tl("broadcast", FormatUtil.replaceFormat(message).replace("\\n", "\n"), name));
-    }
-
-    private void sendToWorld(final World world, final String message) {
-        IText broadcast = new SimpleTextInput(message);
-        final Collection<Player> players = ess.getOnlinePlayers();
-
-        for (final Player player : players) {
-            if (player.getWorld().equals(world)) {
-                final User user = ess.getUser(player);
-                broadcast = new KeywordReplacer(broadcast, new CommandSource(player), ess, false);
-                for (final String messageText : broadcast.getLines()) {
-                    user.sendMessage(messageText);
-                }
-            }
-        }
+        final String formatted = FormatUtil.replaceFormat(message).replace("\\n", "\n");
+        ess.broadcastTl(null, u -> !u.getBase().getWorld().equals(world), true, "broadcast",
+                AdventureUtil.parsed(
+                        ess.getAdventureFacet().legacyToMiniWithUrls(ess.getAdventureFacet().escapeTags(formatted))),
+                AdventureUtil.parsed(ess.getAdventureFacet().legacyToMini(name)));
     }
 
     @Override

Essentials/src/main/java/com/earth2me/essentials/commands/Commandburn.java

@@ -7,8 +7,6 @@ import org.bukkit.Server;
 import java.util.Collections;
 import java.util.List;
 
-import static com.earth2me.essentials.I18n.tl;
-
 public class Commandburn extends EssentialsCommand {
     public Commandburn() {
         super("burn");
@@ -21,14 +19,18 @@ public class Commandburn extends EssentialsCommand {
         }
 
         final User user = getPlayer(server, sender, args, 0);
-        user.getBase().setFireTicks(Integer.parseInt(args[1]) * 20);
-        sender.sendMessage(tl("burnMsg", user.getDisplayName(), Integer.parseInt(args[1])));
+        final int seconds = Integer.parseInt(args[1]);
+
+        final int fireTicks = (int) Math.max(0L, Math.min((long) seconds * 20, Integer.MAX_VALUE));
+
+        user.getBase().setFireTicks(fireTicks);
+        sender.sendTl("burnMsg", user.getDisplayName(), Math.max(0, seconds));
     }
 
     @Override
     protected List<String> getTabCompleteOptions(final Server server, final CommandSource sender, final String commandLabel, final String[] args) {
         if (args.length == 1) {
-            return getPlayers(server, sender);
+            return getPlayers(sender);
         } else if (args.length == 2) {
             return COMMON_DURATIONS;
         } else {

Essentials/src/main/java/com/earth2me/essentials/commands/Commandcartographytable.java

@@ -1,10 +1,9 @@
 package com.earth2me.essentials.commands;
 
 import com.earth2me.essentials.User;
+import net.ess3.provider.ContainerProvider;
 import org.bukkit.Server;
 
-import static com.earth2me.essentials.I18n.tl;
-
 public class Commandcartographytable extends EssentialsCommand {
 
     public Commandcartographytable() {
@@ -13,11 +12,13 @@ public class Commandcartographytable extends EssentialsCommand {
 
     @Override
     public void run(final Server server, final User user, final String commandLabel, final String[] args) throws Exception {
-        if (ess.getContainerProvider() == null) {
-            user.sendMessage(tl("unsupportedBrand"));
+        final ContainerProvider containerProvider = ess.provider(ContainerProvider.class);
+
+        if (containerProvider == null) {
+            user.sendTl("unsupportedBrand");
             return;
         }
 
-        ess.getContainerProvider().openCartographyTable(user.getBase());
+        containerProvider.openCartographyTable(user.getBase());
     }
 }

Essentials/src/main/java/com/earth2me/essentials/commands/Commandclearinventory.java

@@ -2,10 +2,11 @@ package com.earth2me.essentials.commands;
 
 import com.earth2me.essentials.CommandSource;
 import com.earth2me.essentials.User;
-import com.earth2me.essentials.craftbukkit.InventoryWorkaround;
+import com.earth2me.essentials.craftbukkit.Inventories;
 import com.earth2me.essentials.utils.NumberUtil;
 import com.earth2me.essentials.utils.StringUtil;
 import com.earth2me.essentials.utils.VersionUtil;
+import net.ess3.api.TranslatableException;
 import org.bukkit.Material;
 import org.bukkit.Server;
 import org.bukkit.entity.Player;
@@ -19,11 +20,7 @@ import java.util.List;
 import java.util.Locale;
 import java.util.Set;
 
-import static com.earth2me.essentials.I18n.tl;
-
 public class Commandclearinventory extends EssentialsCommand {
-
-    private static final int BASE_AMOUNT = 100000;
     private static final int EXTENDED_CAP = 8;
 
     public Commandclearinventory() {
@@ -57,7 +54,7 @@ public class Commandclearinventory extends EssentialsCommand {
         }
 
         if (allowAll && args.length > 0 && args[0].contentEquals("*")) {
-            sender.sendMessage(tl("inventoryClearingFromAll"));
+            sender.sendTl("inventoryClearingFromAll");
             offset = 1;
             players = ess.getOnlinePlayers();
         } else if (allowOthers && args.length > 0 && args[0].trim().length() > 2) {
@@ -74,7 +71,7 @@ public class Commandclearinventory extends EssentialsCommand {
         if (senderUser != null && senderUser.isPromptingClearConfirm()) {
             if (!formattedCommand.equals(previousClearCommand)) {
                 senderUser.setConfirmingClearCommand(formattedCommand);
-                senderUser.sendMessage(tl("confirmClear", formattedCommand));
+                senderUser.sendTl("confirmClear", formattedCommand);
                 return;
             }
         }
@@ -84,7 +81,7 @@ public class Commandclearinventory extends EssentialsCommand {
         }
     }
 
-    protected void clearHandler(final CommandSource sender, final Player player, final String[] args, final int offset, final boolean showExtended) {
+    protected void clearHandler(final CommandSource sender, final Player player, final String[] args, final int offset, final boolean showExtended) throws TranslatableException {
         ClearHandlerType type = ClearHandlerType.ALL_EXCEPT_ARMOR;
         final Set<Item> items = new HashSet<>();
         int amount = -1;
@@ -114,41 +111,37 @@ public class Commandclearinventory extends EssentialsCommand {
             }
         }
 
-        if (type == ClearHandlerType.ALL_EXCEPT_ARMOR) {
+        if (type != ClearHandlerType.SPECIFIC_ITEM) {
+            final boolean armor = type == ClearHandlerType.ALL_INCLUDING_ARMOR;
             if (showExtended) {
-                sender.sendMessage(tl("inventoryClearingAllItems", player.getDisplayName()));
+                sender.sendTl(armor ? "inventoryClearingAllArmor" : "inventoryClearingAllItems", player.getDisplayName());
             }
-            InventoryWorkaround.clearInventoryNoArmor(player.getInventory());
-            InventoryWorkaround.setItemInOffHand(player, null);
-        } else if (type == ClearHandlerType.ALL_INCLUDING_ARMOR) {
-            if (showExtended) {
-                sender.sendMessage(tl("inventoryClearingAllArmor", player.getDisplayName()));
-            }
-            InventoryWorkaround.clearInventoryNoArmor(player.getInventory());
-            InventoryWorkaround.setItemInOffHand(player, null);
-            player.getInventory().setArmorContents(null);
+            Inventories.removeItems(player, item -> true, armor);
         } else {
             for (final Item item : items) {
                 final ItemStack stack = new ItemStack(item.getMaterial());
-                if (VersionUtil.getServerBukkitVersion().isLowerThan(VersionUtil.v1_13_0_R01)) {
+                if (VersionUtil.PRE_FLATTENING) {
+                    //noinspection deprecation
                     stack.setDurability(item.getData());
                 }
+
+                // can't remove a negative amount of items. (it adds them)
+                if (amount < -1) {
+                    throw new TranslatableException("cannotRemoveNegativeItems");
+                }
+
                 // amount -1 means all items will be cleared
                 if (amount == -1) {
-                    stack.setAmount(BASE_AMOUNT);
-                    final ItemStack removedStack = player.getInventory().removeItem(stack).get(0);
-                    final int removedAmount = BASE_AMOUNT - removedStack.getAmount() + InventoryWorkaround.clearItemInOffHand(player, stack);
+                    final int removedAmount = Inventories.removeItemSimilar(player, stack, true);
                     if (removedAmount > 0 || showExtended) {
-                        sender.sendMessage(tl("inventoryClearingStack", removedAmount, stack.getType().toString().toLowerCase(Locale.ENGLISH), player.getDisplayName()));
+                        sender.sendTl("inventoryClearingStack", removedAmount, stack.getType().toString().toLowerCase(Locale.ENGLISH), player.getDisplayName());
                     }
                 } else {
-                    stack.setAmount(amount < 0 ? 1 : amount);
-                    if (player.getInventory().containsAtLeast(stack, amount)) {
-                        sender.sendMessage(tl("inventoryClearingStack", amount, stack.getType().toString().toLowerCase(Locale.ENGLISH), player.getDisplayName()));
-                        player.getInventory().removeItem(stack);
+                    if (Inventories.removeItemAmount(player, stack, amount)) {
+                        sender.sendTl("inventoryClearingStack", amount, stack.getType().toString().toLowerCase(Locale.ENGLISH), player.getDisplayName());
                     } else {
                         if (showExtended) {
-                            sender.sendMessage(tl("inventoryClearFail", player.getDisplayName(), amount, stack.getType().toString().toLowerCase(Locale.ENGLISH)));
+                            sender.sendTl("inventoryClearFail", player.getDisplayName(), amount, stack.getType().toString().toLowerCase(Locale.ENGLISH));
                         }
                     }
                 }
@@ -160,7 +153,7 @@ public class Commandclearinventory extends EssentialsCommand {
     protected List<String> getTabCompleteOptions(final Server server, final User user, final String commandLabel, final String[] args) {
         if (user.isAuthorized("essentials.clearinventory.others")) {
             if (args.length == 1) {
-                final List<String> options = getPlayers(server, user);
+                final List<String> options = getPlayers(user);
                 if (user.isAuthorized("essentials.clearinventory.all") || user.isAuthorized("essentials.clearinventory.multiple")) {
                     // Assume that nobody will have the 'all' permission without the 'others' permission
                     options.add("*");
@@ -189,7 +182,7 @@ public class Commandclearinventory extends EssentialsCommand {
     @Override
     protected List<String> getTabCompleteOptions(final Server server, final CommandSource sender, final String commandLabel, final String[] args) {
         if (args.length == 1) {
-            final List<String> options = getPlayers(server, sender);
+            final List<String> options = getPlayers(sender);
             options.add("*");
             return options;
         } else if (args.length == 2) {
@@ -203,7 +196,10 @@ public class Commandclearinventory extends EssentialsCommand {
     }
 
     private String formatCommand(final String commandLabel, final String[] args) {
-        return "/" + commandLabel + " " + StringUtil.joinList(" ", args);
+        if (args == null || args.length == 0) {
+            return "/" + commandLabel;
+        }
+        return "/" + commandLabel + " " + StringUtil.joinList(" ", (Object[]) args);
     }
 
     private enum ClearHandlerType {

Essentials/src/main/java/com/earth2me/essentials/commands/Commandclearinventoryconfirmtoggle.java

@@ -3,8 +3,6 @@ package com.earth2me.essentials.commands;
 import com.earth2me.essentials.User;
 import org.bukkit.Server;
 
-import static com.earth2me.essentials.I18n.tl;
-
 public class Commandclearinventoryconfirmtoggle extends EssentialsCommand {
 
     public Commandclearinventoryconfirmtoggle() {
@@ -21,9 +19,9 @@ public class Commandclearinventoryconfirmtoggle extends EssentialsCommand {
         }
         user.setPromptingClearConfirm(confirmingClear);
         if (confirmingClear) {
-            user.sendMessage(tl("clearInventoryConfirmToggleOn"));
+            user.sendTl("clearInventoryConfirmToggleOn");
         } else {
-            user.sendMessage(tl("clearInventoryConfirmToggleOff"));
+            user.sendTl("clearInventoryConfirmToggleOff");
         }
         user.setConfirmingClearCommand(null);
     }

Essentials/src/main/java/com/earth2me/essentials/commands/Commandcompass.java

@@ -3,8 +3,6 @@ package com.earth2me.essentials.commands;
 import com.earth2me.essentials.User;
 import org.bukkit.Server;
 
-import static com.earth2me.essentials.I18n.tl;
-
 public class Commandcompass extends EssentialsCommand {
     public Commandcompass() {
         super("compass");
@@ -15,24 +13,24 @@ public class Commandcompass extends EssentialsCommand {
         final int bearing = (int) (user.getLocation().getYaw() + 180 + 360) % 360;
         final String dir;
         if (bearing < 23) {
-            dir = tl("north");
+            dir = user.playerTl("north");
         } else if (bearing < 68) {
-            dir = tl("northEast");
+            dir = user.playerTl("northEast");
         } else if (bearing < 113) {
-            dir = tl("east");
+            dir = user.playerTl("east");
         } else if (bearing < 158) {
-            dir = tl("southEast");
+            dir = user.playerTl("southEast");
         } else if (bearing < 203) {
-            dir = tl("south");
+            dir = user.playerTl("south");
         } else if (bearing < 248) {
-            dir = tl("southWest");
+            dir = user.playerTl("southWest");
         } else if (bearing < 293) {
-            dir = tl("west");
+            dir = user.playerTl("west");
         } else if (bearing < 338) {
-            dir = tl("northWest");
+            dir = user.playerTl("northWest");
         } else {
-            dir = tl("north");
+            dir = user.playerTl("north");
         }
-        user.sendMessage(tl("compassBearing", dir, bearing));
+        user.sendTl("compassBearing", dir, bearing);
     }
 }

Essentials/src/main/java/com/earth2me/essentials/commands/Commandcondense.java

@@ -4,6 +4,8 @@ import com.earth2me.essentials.ChargeException;
 import com.earth2me.essentials.Trade;
 import com.earth2me.essentials.Trade.OverflowType;
 import com.earth2me.essentials.User;
+import com.earth2me.essentials.craftbukkit.Inventories;
+import com.earth2me.essentials.utils.VersionUtil;
 import net.ess3.api.MaxMoneyException;
 import org.bukkit.Material;
 import org.bukkit.Server;
@@ -21,8 +23,6 @@ import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
 
-import static com.earth2me.essentials.I18n.tl;
-
 public class Commandcondense extends EssentialsCommand {
     private final Map<ItemStack, SimpleRecipe> condenseList = new HashMap<>();
 
@@ -38,7 +38,7 @@ public class Commandcondense extends EssentialsCommand {
         if (args.length > 0) {
             is = ess.getItemDb().getMatching(user, args);
         } else {
-            for (final ItemStack stack : user.getBase().getInventory().getContents()) {
+            for (final ItemStack stack : Inventories.getInventory(user.getBase(), false)) {
                 if (stack == null || stack.getType() == Material.AIR) {
                     continue;
                 }
@@ -56,9 +56,9 @@ public class Commandcondense extends EssentialsCommand {
         user.getBase().updateInventory();
 
         if (didConvert) {
-            user.sendMessage(tl("itemsConverted"));
+            user.sendTl("itemsConverted");
         } else {
-            user.sendMessage(tl("itemsNotConverted"));
+            user.sendTl("itemsNotConverted");
             throw new NoChargeException();
         }
     }
@@ -84,7 +84,7 @@ public class Commandcondense extends EssentialsCommand {
 
             int amount = 0;
 
-            for (final ItemStack contents : user.getBase().getInventory().getContents()) {
+            for (final ItemStack contents : Inventories.getInventory(user.getBase(), false)) {
                 if (contents != null && contents.isSimilar(stack)) {
                     amount += contents.getAmount();
                 }
@@ -161,8 +161,7 @@ public class Commandcondense extends EssentialsCommand {
                 iter.remove();
                 continue;
             }
-
-            if (inputSlot.getDurability() == Short.MAX_VALUE) {
+            if (VersionUtil.PRE_FLATTENING && inputSlot.getDurability() == Short.MAX_VALUE) {
                 inputSlot.setDurability((short) 0);
             }
             if (!inputSlot.isSimilar(stack)) {

Essentials/src/main/java/com/earth2me/essentials/commands/Commandcreatekit.java

@@ -2,8 +2,11 @@ package com.earth2me.essentials.commands;
 
 import com.earth2me.essentials.CommandSource;
 import com.earth2me.essentials.User;
+import com.earth2me.essentials.craftbukkit.Inventories;
 import com.earth2me.essentials.utils.DateUtil;
 import com.earth2me.essentials.utils.PasteUtil;
+import net.ess3.api.TranslatableException;
+import net.ess3.provider.SerializationProvider;
 import org.bukkit.Material;
 import org.bukkit.Server;
 import org.bukkit.inventory.ItemStack;
@@ -20,7 +23,7 @@ import java.util.List;
 import java.util.concurrent.CompletableFuture;
 import java.util.logging.Level;
 
-import static com.earth2me.essentials.I18n.tl;
+import static com.earth2me.essentials.I18n.tlLiteral;
 
 public class Commandcreatekit extends EssentialsCommand {
     public Commandcreatekit() {
@@ -37,23 +40,25 @@ public class Commandcreatekit extends EssentialsCommand {
         // Command handler will auto fail if this fails.
         final long delay = Long.parseLong(args[1]);
         final String kitname = args[0];
-        final ItemStack[] items = user.getBase().getInventory().getContents();
+        final ItemStack[] items = Inventories.getInventory(user.getBase(), true);
         final List<String> list = new ArrayList<>();
 
+        final SerializationProvider serializationProvider = ess.provider(SerializationProvider.class);
         boolean useSerializationProvider = ess.getSettings().isUseBetterKits();
 
-        if (useSerializationProvider && ess.getSerializationProvider() == null) {
-            ess.showError(user.getSource(), new Exception(tl("createKitUnsupported")), commandLabel);
+        if (useSerializationProvider && serializationProvider == null) {
+            ess.showError(user.getSource(), new TranslatableException("createKitUnsupported"), commandLabel);
             useSerializationProvider = false;
         }
 
-        for (ItemStack is : items) {
+        for (int i = 0; i < items.length; i++) {
+            final ItemStack is = items[i];
             if (is != null && is.getType() != null && is.getType() != Material.AIR) {
                 final String serialized;
                 if (useSerializationProvider) {
-                    serialized = "@" + Base64Coder.encodeLines(ess.getSerializationProvider().serializeItem(is));
+                    serialized = "slot:" + i + " @" + Base64Coder.encodeLines(serializationProvider.serializeItem(is));
                 } else {
-                    serialized = ess.getItemDb().serialize(is);
+                    serialized = "slot:" + i + " " + ess.getItemDb().serialize(is);
                 }
                 list.add(serialized);
             }
@@ -61,7 +66,7 @@ public class Commandcreatekit extends EssentialsCommand {
         // Some users might want to directly write to config knowing the consequences. *shrug*
         if (!ess.getSettings().isPastebinCreateKit()) {
             ess.getKits().addKit(kitname, list, delay);
-            user.sendMessage(tl("createdKit", kitname, list.size(), delay));
+            user.sendTl("createdKit", kitname, list.size(), delay);
         } else {
             uploadPaste(user.getSource(), kitname, delay, list);
         }
@@ -85,10 +90,10 @@ public class Commandcreatekit extends EssentialsCommand {
                 final CompletableFuture<PasteUtil.PasteResult> future = PasteUtil.createPaste(Collections.singletonList(new PasteUtil.PasteFile("kit_" + kitName + ".yml", fileContents)));
                 future.thenAccept(result -> {
                     if (result != null) {
-                        final String separator = tl("createKitSeparator");
+                        final String separator = tlLiteral("createKitSeparator");
                         final String delayFormat = delay <= 0 ? "0" : DateUtil.formatDateDiff(System.currentTimeMillis() + (delay * 1000));
                         sender.sendMessage(separator);
-                        sender.sendMessage(tl("createKitSuccess", kitName, delayFormat, result.getPasteUrl()));
+                        sender.sendTl("createKitSuccess", kitName, delayFormat, result.getPasteUrl());
                         sender.sendMessage(separator);
                         if (ess.getSettings().isDebug()) {
                             ess.getLogger().info(sender.getSender().getName() + " created a kit: " + result.getPasteUrl());
@@ -96,12 +101,12 @@ public class Commandcreatekit extends EssentialsCommand {
                     }
                 });
                 future.exceptionally(throwable -> {
-                    sender.sendMessage(tl("createKitFailed", kitName));
+                    sender.sendTl("createKitFailed", kitName);
                     ess.getLogger().log(Level.SEVERE, "Error creating kit: ", throwable);
                     return null;
                 });
             } catch (Exception e) {
-                sender.sendMessage(tl("createKitFailed", kitName));
+                sender.sendTl("createKitFailed", kitName);
                 ess.getLogger().log(Level.SEVERE, "Error creating kit: ", e);
             }
         });

Essentials/src/main/java/com/earth2me/essentials/commands/Commanddelhome.java

@@ -3,6 +3,9 @@ package com.earth2me.essentials.commands;
 import com.earth2me.essentials.CommandSource;
 import com.earth2me.essentials.IUser;
 import com.earth2me.essentials.User;
+import net.ess3.api.TranslatableException;
+import net.essentialsx.api.v2.events.HomeModifyEvent;
+import org.bukkit.Bukkit;
 import org.bukkit.Server;
 
 import java.util.ArrayList;
@@ -10,13 +13,29 @@ import java.util.Collections;
 import java.util.List;
 import java.util.Locale;
 
-import static com.earth2me.essentials.I18n.tl;
-
 public class Commanddelhome extends EssentialsCommand {
     public Commanddelhome() {
         super("delhome");
     }
 
+    private void deleteHome(CommandSource sender, User user, String home) {
+        final HomeModifyEvent event = new HomeModifyEvent(sender.getUser(), user, home, user.getHome(home), false);
+        Bukkit.getServer().getPluginManager().callEvent(event);
+        if (event.isCancelled()) {
+            if (ess.getSettings().isDebug()) {
+                ess.getLogger().info("HomeModifyEvent canceled for /delhome execution by " + sender.getDisplayName());
+            }
+            return;
+        }
+
+        try {
+            user.delHome(home);
+            sender.sendTl("deleteHome", home);
+        } catch (Exception e) {
+            sender.sendTl("invalidHome", home);
+        }
+    }
+
     @Override
     public void run(final Server server, final CommandSource sender, final String commandLabel, final String[] args) throws Exception {
         if (args.length < 1) {
@@ -37,31 +56,38 @@ public class Commanddelhome extends EssentialsCommand {
 
         if (expandedArg.length > 1 && (user == null || user.isAuthorized("essentials.delhome.others"))) {
             user = getPlayer(server, expandedArg, 0, true, true);
-            name = expandedArg[1];
+            name = expandedArg[1].toLowerCase(Locale.ENGLISH);
         } else if (user == null) {
             throw new NotEnoughArgumentsException();
         } else {
-            name = expandedArg[0];
+            name = expandedArg[0].toLowerCase(Locale.ENGLISH);
         }
 
-        if (name.equalsIgnoreCase("bed")) {
-            throw new Exception(tl("invalidHomeName"));
+        switch (name) {
+            case "bed":
+                throw new TranslatableException("invalidHomeName");
+            case "*":
+                final List<String> homes = user.getHomes();
+                for (String home : homes) {
+                    deleteHome(sender, user, home);
+                }
+                break;
+            default:
+                deleteHome(sender, user, name);
+                break;
         }
-
-        user.delHome(name.toLowerCase(Locale.ENGLISH));
-        sender.sendMessage(tl("deleteHome", name));
     }
 
     @Override
     protected List<String> getTabCompleteOptions(final Server server, final CommandSource sender, final String commandLabel, final String[] args) {
-        final IUser user = sender.getUser(ess);
-        final boolean canDelOthers = sender.isAuthorized("essentials.delhome.others", ess);
+        final IUser user = sender.getUser();
+        final boolean canDelOthers = sender.isAuthorized("essentials.delhome.others");
         if (args.length == 1) {
             final List<String> homes = user == null ? new ArrayList<>() : user.getHomes();
             if (canDelOthers) {
                 final int sepIndex = args[0].indexOf(':');
                 if (sepIndex < 0) {
-                    getPlayers(server, sender).forEach(player -> homes.add(player + ":"));
+                    getPlayers(sender).forEach(player -> homes.add(player + ":"));
                 } else {
                     final String namePart = args[0].substring(0, sepIndex);
                     final User otherUser;
@@ -71,6 +97,7 @@ public class Commanddelhome extends EssentialsCommand {
                         return homes;
                     }
                     otherUser.getHomes().forEach(home -> homes.add(namePart + ":" + home));
+                    homes.add(namePart + ":" + "*");
                 }
             }
             return homes;

Essentials/src/main/java/com/earth2me/essentials/commands/Commanddeljail.java

@@ -1,14 +1,13 @@
 package com.earth2me.essentials.commands;
 
 import com.earth2me.essentials.CommandSource;
+import net.ess3.api.TranslatableException;
 import org.bukkit.Server;
 
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
 
-import static com.earth2me.essentials.I18n.tl;
-
 public class Commanddeljail extends EssentialsCommand {
     public Commanddeljail() {
         super("deljail");
@@ -21,11 +20,11 @@ public class Commanddeljail extends EssentialsCommand {
         }
 
         if (ess.getJails().getJail(args[0]) == null) {
-            throw new Exception(tl("jailNotExist"));
+            throw new TranslatableException("jailNotExist");
         }
 
         ess.getJails().removeJail(args[0]);
-        sender.sendMessage(tl("deleteJail", args[0]));
+        sender.sendTl("deleteJail", args[0]);
     }
 
     @Override

Essentials/src/main/java/com/earth2me/essentials/commands/Commanddelkit.java

@@ -8,8 +8,6 @@ import org.bukkit.Server;
 import java.util.Collections;
 import java.util.List;
 
-import static com.earth2me.essentials.I18n.tl;
-
 public class Commanddelkit extends EssentialsCommand {
     public Commanddelkit() {
         super("delkit");
@@ -19,7 +17,7 @@ public class Commanddelkit extends EssentialsCommand {
     public void run(final Server server, final CommandSource sender, final String commandLabel, final String[] args) throws Exception {
         if (args.length == 0) {
             final String kitList = ess.getKits().listKits(ess, null);
-            sender.sendMessage(kitList.length() > 0 ? tl("kits", kitList) : tl("noKits"));
+            sender.sendTl(kitList.length() > 0 ? "kits" : "noKits", kitList);
             throw new NoChargeException();
         } else {
             final String kitName = ess.getKits().matchKit(args[0]);
@@ -30,7 +28,7 @@ public class Commanddelkit extends EssentialsCommand {
             }
 
             ess.getKits().removeKit(kitName);
-            sender.sendMessage(tl("deleteKit", kitName));
+            sender.sendTl("deleteKit", kitName);
         }
     }
 

Essentials/src/main/java/com/earth2me/essentials/commands/Commanddelwarp.java

@@ -1,6 +1,7 @@
 package com.earth2me.essentials.commands;
 
 import com.earth2me.essentials.CommandSource;
+import net.ess3.api.TranslatableException;
 import net.essentialsx.api.v2.events.WarpModifyEvent;
 import org.bukkit.Bukkit;
 import org.bukkit.Location;
@@ -10,8 +11,6 @@ import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
 
-import static com.earth2me.essentials.I18n.tl;
-
 public class Commanddelwarp extends EssentialsCommand {
     public Commanddelwarp() {
         super("delwarp");
@@ -31,15 +30,15 @@ public class Commanddelwarp extends EssentialsCommand {
                 // World is unloaded/deleted
                 location = null;
             }
-            final WarpModifyEvent event = new WarpModifyEvent(sender.getUser(this.ess), args[0], location, null, WarpModifyEvent.WarpModifyCause.DELETE);
+            final WarpModifyEvent event = new WarpModifyEvent(sender.getUser(), args[0], location, null, WarpModifyEvent.WarpModifyCause.DELETE);
             Bukkit.getServer().getPluginManager().callEvent(event);
             if (event.isCancelled()) {
                 return;
             }
             ess.getWarps().removeWarp(args[0]);
-            sender.sendMessage(tl("deleteWarp", args[0]));
+            sender.sendTl("deleteWarp", args[0]);
         } else {
-            throw new Exception(tl("warpNotExist"));
+            throw new TranslatableException("warpNotExist");
         }
     }
 

Essentials/src/main/java/com/earth2me/essentials/commands/Commanddepth.java

@@ -3,8 +3,6 @@ package com.earth2me.essentials.commands;
 import com.earth2me.essentials.User;
 import org.bukkit.Server;
 
-import static com.earth2me.essentials.I18n.tl;
-
 public class Commanddepth extends EssentialsCommand {
     public Commanddepth() {
         super("depth");
@@ -14,11 +12,11 @@ public class Commanddepth extends EssentialsCommand {
     public void run(final Server server, final User user, final String commandLabel, final String[] args) throws Exception {
         final int depth = user.getLocation().getBlockY() - user.getWorld().getSeaLevel();
         if (depth > 0) {
-            user.sendMessage(tl("depthAboveSea", depth));
+            user.sendTl("depthAboveSea", depth);
         } else if (depth < 0) {
-            user.sendMessage(tl("depthBelowSea", -depth));
+            user.sendTl("depthBelowSea", -depth);
         } else {
-            user.sendMessage(tl("depth"));
+            user.sendTl("depth");
         }
     }
 }

Essentials/src/main/java/com/earth2me/essentials/commands/Commanddisposal.java

@@ -3,8 +3,6 @@ package com.earth2me.essentials.commands;
 import com.earth2me.essentials.User;
 import org.bukkit.Server;
 
-import static com.earth2me.essentials.I18n.tl;
-
 public class Commanddisposal extends EssentialsCommand {
 
     public Commanddisposal() {
@@ -13,8 +11,9 @@ public class Commanddisposal extends EssentialsCommand {
 
     @Override
     protected void run(final Server server, final User user, final String commandLabel, final String[] args) throws Exception {
-        user.sendMessage(tl("openingDisposal"));
-        user.getBase().openInventory(ess.getServer().createInventory(user.getBase(), 36, tl("disposal")));
+        user.sendTl("openingDisposal");
+        final String title = ess.getAdventureFacet().miniToLegacy(user.playerTl("disposal"));
+        user.getBase().openInventory(ess.getServer().createInventory(user.getBase(), 36, title));
     }
 
 }

Essentials/src/main/java/com/earth2me/essentials/commands/Commandeco.java

@@ -3,10 +3,13 @@ package com.earth2me.essentials.commands;
 import com.earth2me.essentials.ChargeException;
 import com.earth2me.essentials.CommandSource;
 import com.earth2me.essentials.User;
+import com.earth2me.essentials.adventure.AdventureUtil;
 import com.earth2me.essentials.utils.NumberUtil;
 import com.google.common.collect.Lists;
 import net.ess3.api.MaxMoneyException;
+import net.ess3.api.TranslatableException;
 import net.ess3.api.events.UserBalanceUpdateEvent;
+import net.ess3.provider.PlayerLocaleProvider;
 import org.bukkit.Server;
 
 import java.math.BigDecimal;
@@ -14,8 +17,6 @@ import java.util.Collections;
 import java.util.List;
 import java.util.Locale;
 
-import static com.earth2me.essentials.I18n.tl;
-
 public class Commandeco extends EssentialsLoopCommand {
 
     public Commandeco() {
@@ -34,7 +35,14 @@ public class Commandeco extends EssentialsLoopCommand {
         try {
             cmd = EcoCommands.valueOf(args[0].toUpperCase(Locale.ENGLISH));
             isPercent = cmd != EcoCommands.RESET && args[2].endsWith("%");
-            amount = (cmd == EcoCommands.RESET) ? ess.getSettings().getStartingBalance() : new BigDecimal(args[2].replaceAll("[^0-9\\.]", ""));
+            if (cmd == EcoCommands.RESET) {
+                amount = ess.getSettings().getStartingBalance();
+            } else if (sender.isPlayer() && ess.getSettings().isPerPlayerLocale()) {
+                final String playerLocale = ess.provider(PlayerLocaleProvider.class).getLocale(sender.getPlayer());
+                amount = NumberUtil.parseStringToBDecimal(args[2], ess.getUser(sender.getPlayer()).getPlayerLocale(playerLocale));
+            } else {
+                amount = NumberUtil.parseStringToBDecimal(args[2]);
+            }
         } catch (final Exception ex) {
             throw new NotEnoughArgumentsException(ex);
         }
@@ -54,7 +62,7 @@ public class Commandeco extends EssentialsLoopCommand {
                     if (player.getMoney().subtract(userAmount).compareTo(ess.getSettings().getMinMoney()) >= 0) {
                         player.takeMoney(userAmount, sender, UserBalanceUpdateEvent.Cause.COMMAND_ECO);
                     } else {
-                        ess.showError(sender, new Exception(tl("minimumBalanceError", NumberUtil.displayCurrency(ess.getSettings().getMinMoney(), ess))), commandLabel);
+                        ess.showError(sender, new TranslatableException("minimumBalanceError", AdventureUtil.parsed(NumberUtil.displayCurrency(ess.getSettings().getMinMoney(), ess))), commandLabel);
                     }
                     break;
                 }
@@ -65,8 +73,8 @@ public class Commandeco extends EssentialsLoopCommand {
                     final boolean underMin = userAmount.compareTo(minBal) < 0;
                     final boolean aboveMax = userAmount.compareTo(maxBal) > 0;
                     player.setMoney(underMin ? minBal : aboveMax ? maxBal : userAmount, UserBalanceUpdateEvent.Cause.COMMAND_ECO);
-                    player.sendMessage(tl("setBal", NumberUtil.displayCurrency(player.getMoney(), ess)));
-                    sender.sendMessage(tl("setBalOthers", player.getDisplayName(), NumberUtil.displayCurrency(player.getMoney(), ess)));
+                    player.sendTl("setBal", AdventureUtil.parsed(NumberUtil.displayCurrency(player.getMoney(), ess)));
+                    sender.sendTl("setBalOthers", player.getDisplayName(), AdventureUtil.parsed(NumberUtil.displayCurrency(player.getMoney(), ess)));
                     break;
                 }
             }
@@ -87,7 +95,7 @@ public class Commandeco extends EssentialsLoopCommand {
             }
             return options;
         } else if (args.length == 2) {
-            return getPlayers(server, sender);
+            return getPlayers(sender);
         } else if (args.length == 3 && !args[0].equalsIgnoreCase(EcoCommands.RESET.name())) {
             if (args[0].equalsIgnoreCase(EcoCommands.SET.name())) {
                 return Lists.newArrayList("0", ess.getSettings().getStartingBalance().toString());

Essentials/src/main/java/com/earth2me/essentials/commands/Commandeditsign.java

@@ -3,17 +3,26 @@ package com.earth2me.essentials.commands;
 import com.earth2me.essentials.User;
 import com.earth2me.essentials.utils.FormatUtil;
 import com.earth2me.essentials.utils.NumberUtil;
+import com.earth2me.essentials.utils.VersionUtil;
 import com.google.common.collect.Lists;
+import net.ess3.api.TranslatableException;
+import org.bukkit.Bukkit;
 import org.bukkit.ChatColor;
 import org.bukkit.Server;
 import org.bukkit.block.Block;
+import org.bukkit.block.BlockFace;
 import org.bukkit.block.Sign;
+import org.bukkit.block.data.BlockData;
+import org.bukkit.block.data.type.HangingSign;
+import org.bukkit.block.data.type.WallHangingSign;
+import org.bukkit.block.data.type.WallSign;
+import org.bukkit.block.sign.Side;
+import org.bukkit.event.block.SignChangeEvent;
+import org.bukkit.util.Vector;
 
 import java.util.Collections;
 import java.util.List;
 
-import static com.earth2me.essentials.I18n.tl;
-
 public class Commandeditsign extends EssentialsCommand {
     public Commandeditsign() {
         super("editsign");
@@ -27,67 +36,113 @@ public class Commandeditsign extends EssentialsCommand {
 
         final Block target = user.getTargetBlock(5); //5 is a good number
         if (!(target.getState() instanceof Sign)) {
-            throw new Exception(tl("editsignCommandTarget"));
+            throw new TranslatableException("editsignCommandTarget");
         }
-        final Sign sign = (Sign) target.getState();
+        final ModifiableSign sign = wrapSign((Sign) target.getState(), user);
         try {
             if (args[0].equalsIgnoreCase("set") && args.length > 2) {
+                final String[] existingLines = sign.getLines();
                 final int line = Integer.parseInt(args[1]) - 1;
                 final String text = FormatUtil.formatString(user, "essentials.editsign", getFinalArg(args, 2)).trim();
                 if (ChatColor.stripColor(text).length() > 15 && !user.isAuthorized("essentials.editsign.unlimited")) {
-                    throw new Exception(tl("editsignCommandLimit"));
+                    throw new TranslatableException("editsignCommandLimit");
                 }
-                sign.setLine(line, text);
-                sign.update();
-                user.sendMessage(tl("editsignCommandSetSuccess", line + 1, text));
+                existingLines[line] = text;
+                if (callSignEvent(sign, user, existingLines)) {
+                    return;
+                }
+
+                user.sendTl("editsignCommandSetSuccess", line + 1, text);
             } else if (args[0].equalsIgnoreCase("clear")) {
                 if (args.length == 1) {
+                    final String[] existingLines = sign.getLines();
                     for (int i = 0; i < 4; i++) { // A whole one line of line savings!
-                        sign.setLine(i, "");
+                        existingLines[i] = "";
                     }
-                    sign.update();
-                    user.sendMessage(tl("editsignCommandClear"));
+
+                    if (callSignEvent(sign, user, existingLines)) {
+                        return;
+                    }
+
+                    user.sendTl("editsignCommandClear");
                 } else {
+                    final String[] existingLines = sign.getLines();
                     final int line = Integer.parseInt(args[1]) - 1;
-                    sign.setLine(line, "");
-                    sign.update();
-                    user.sendMessage(tl("editsignCommandClearLine", line + 1));
+                    existingLines[line] = "";
+
+                    if (callSignEvent(sign, user, existingLines)) {
+                        return;
+                    }
+
+                    user.sendTl("editsignCommandClearLine", line + 1);
                 }
-            } else if (args[0].equalsIgnoreCase("copy") || args[0].equalsIgnoreCase("paste")) {
-                final boolean copy = args[0].equalsIgnoreCase("copy");
-                final String tlPrefix = copy ? "editsignCopy" : "editsignPaste";
+            } else if (args[0].equalsIgnoreCase("copy")) {
                 final int line = args.length == 1 ? -1 : Integer.parseInt(args[1]) - 1;
 
                 if (line == -1) {
                     for (int i = 0; i < 4; i++) {
-                        processSignCopyPaste(user, sign, i, copy);
+                        // We use unformat here to prevent players from copying signs with colors that they do not have permission to use.
+                        user.getSignCopy().set(i, FormatUtil.unformatString(user, "essentials.editsign", sign.getLine(i)));
                     }
-                    user.sendMessage(tl(tlPrefix, commandLabel));
+                    user.sendTl("editsignCopy", commandLabel);
                 } else {
-                    processSignCopyPaste(user, sign, line, copy);
-                    user.sendMessage(tl(tlPrefix + "Line", line + 1, commandLabel));
+                    // We use unformat here to prevent players from copying signs with colors that they do not have permission to use.
+                    user.getSignCopy().set(line, FormatUtil.unformatString(user, "essentials.editsign", sign.getLine(line)));
+                    user.sendTl("editsignCopyLine", line + 1, commandLabel);
                 }
 
-                if (!copy) {
-                    sign.update();
+            } else if (args[0].equalsIgnoreCase("paste")) {
+                final int line = args.length == 1 ? -1 : Integer.parseInt(args[1]) - 1;
+
+                final String[] existingLines = sign.getLines();
+                if (line == -1) {
+                    for (int i = 0; i < 4; i++) {
+                        existingLines[i] = FormatUtil.formatString(user, "essentials.editsign", user.getSignCopy().get(i));
+                    }
+                    if (callSignEvent(sign, user, existingLines)) {
+                        return;
+                    }
+                    user.sendTl("editsignPaste", commandLabel);
+                } else {
+                    existingLines[line] = FormatUtil.formatString(user, "essentials.editsign", user.getSignCopy().get(line));
+                    if (callSignEvent(sign, user, existingLines)) {
+                        return;
+                    }
+                    user.sendTl("editsignPasteLine", line + 1, commandLabel);
                 }
             } else {
                 throw new NotEnoughArgumentsException();
             }
         } catch (final IndexOutOfBoundsException e) {
-            throw new Exception(tl("editsignCommandNoLine"), e);
+            throw new TranslatableException(e, "editsignCommandNoLine");
         }
     }
 
-    private void processSignCopyPaste(final User user, final Sign sign, final int index, final boolean copy) {
-        if (copy) {
-            // We use unformat here to prevent players from copying signs with colors that they do not have permission to use.
-            user.getSignCopy().set(index, FormatUtil.unformatString(user, "essentials.editsign", sign.getLine(index)));
-            return;
+    private boolean callSignEvent(final ModifiableSign sign, final User user, final String[] lines) {
+        final SignChangeEvent event;
+        if (VersionUtil.getServerBukkitVersion().isHigherThanOrEqualTo(VersionUtil.v1_20_1_R01)) {
+            if (sign.isWaxed() && !user.isAuthorized("essentials.editsign.waxed.exempt")) {
+                return true;
+            }
+            event = new SignChangeEvent(sign.getBlock(), user.getBase(), lines, sign.isFront() ? Side.FRONT : Side.BACK);
+        } else {
+            //noinspection deprecation
+            event = new SignChangeEvent(sign.getBlock(), user.getBase(), lines);
         }
 
-        final String line = FormatUtil.formatString(user, "essentials.editsign", user.getSignCopy().get(index));
-        sign.setLine(index, line == null ? "" : line);
+        Bukkit.getServer().getPluginManager().callEvent(event);
+        if (event.isCancelled()) {
+            if (ess.getSettings().isDebug()) {
+                ess.getLogger().info("SignChangeEvent canceled for /editsign execution by " + user.getName());
+            }
+            return true;
+        }
+
+        for (int i = 0; i < 4; i++) {
+            sign.setLine(i, lines[i]);
+        }
+        sign.update();
+        return false;
     }
 
     @Override
@@ -100,7 +155,7 @@ public class Commandeditsign extends EssentialsCommand {
             final int line = Integer.parseInt(args[1]);
             final Block target = user.getTargetBlock(5);
             if (target.getState() instanceof Sign && line <= 4) {
-                final Sign sign = (Sign) target.getState();
+                final ModifiableSign sign = wrapSign((Sign) target.getState(), user);
                 return Lists.newArrayList(FormatUtil.unformatString(user, "essentials.editsign", sign.getLine(line - 1)));
             }
             return Collections.emptyList();
@@ -108,4 +163,105 @@ public class Commandeditsign extends EssentialsCommand {
             return Collections.emptyList();
         }
     }
+
+    private ModifiableSign wrapSign(final Sign sign, final User user) {
+        if (VersionUtil.getServerBukkitVersion().isHigherThanOrEqualTo(VersionUtil.v1_20_1_R01)) {
+            final Vector eyeLocLessSign = user.getBase().getEyeLocation().toVector().subtract(sign.getLocation().add(.5, .5, .5).toVector());
+            final BlockData signBlockData = sign.getBlockData();
+
+            final BlockFace signDirection;
+            if (signBlockData instanceof org.bukkit.block.data.type.Sign) {
+                signDirection = ((org.bukkit.block.data.type.Sign) signBlockData).getRotation();
+            } else if (signBlockData instanceof WallSign) {
+                signDirection = ((WallSign) signBlockData).getFacing();
+            } else if (signBlockData instanceof HangingSign) {
+                signDirection = ((HangingSign) signBlockData).getRotation();
+            } else if (signBlockData instanceof WallHangingSign) {
+                signDirection = ((WallHangingSign) signBlockData).getFacing();
+            } else {
+                throw new IllegalStateException("Unknown block data for sign: " + signBlockData.getClass());
+            }
+
+            final Side side = eyeLocLessSign.dot(signDirection.getDirection()) > 0 ? Side.FRONT : Side.BACK;
+
+            return new ModifiableSign(sign) {
+                @Override
+                String[] getLines() {
+                    return sign.getSide(side).getLines();
+                }
+
+                @Override
+                String getLine(int line) {
+                    return sign.getSide(side).getLine(line);
+                }
+
+                @Override
+                void setLine(int line, String text) {
+                    sign.getSide(side).setLine(line, text);
+                }
+
+                @Override
+                boolean isFront() {
+                    return side == Side.FRONT;
+                }
+
+                @Override
+                boolean isWaxed() {
+                    return sign.isWaxed();
+                }
+            };
+        }
+        return new ModifiableSign(sign) {
+            @Override
+            String[] getLines() {
+                return sign.getLines();
+            }
+
+            @Override
+            String getLine(int line) {
+                return sign.getLine(line);
+            }
+
+            @Override
+            void setLine(int line, String text) {
+                sign.setLine(line, text);
+            }
+
+            @Override
+            boolean isFront() {
+                return true;
+            }
+
+            @Override
+            boolean isWaxed() {
+                return false;
+            }
+        };
+    }
+
+    private abstract static class ModifiableSign {
+        protected final Sign sign;
+
+        protected ModifiableSign(final Sign sign) {
+            this.sign = sign;
+        }
+
+        abstract String getLine(int line);
+
+        abstract String[] getLines();
+
+        abstract void setLine(int line, String text);
+
+        abstract boolean isFront();
+
+        abstract boolean isWaxed();
+
+        Block getBlock() {
+            return sign.getBlock();
+        }
+
+        void update() {
+            sign.update();
+        }
+    }
 }

Essentials/src/main/java/com/earth2me/essentials/commands/Commandenchant.java

@@ -3,9 +3,9 @@ package com.earth2me.essentials.commands;
 import com.earth2me.essentials.Enchantments;
 import com.earth2me.essentials.MetaItemStack;
 import com.earth2me.essentials.User;
-import com.earth2me.essentials.craftbukkit.InventoryWorkaround;
 import com.earth2me.essentials.utils.StringUtil;
 import com.google.common.collect.Lists;
+import net.ess3.api.TranslatableException;
 import org.bukkit.Material;
 import org.bukkit.Server;
 import org.bukkit.enchantments.Enchantment;
@@ -14,13 +14,10 @@ import org.bukkit.inventory.ItemStack;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
-import java.util.Locale;
 import java.util.Map;
 import java.util.Set;
 import java.util.TreeSet;
 
-import static com.earth2me.essentials.I18n.tl;
-
 public class Commandenchant extends EssentialsCommand {
     public Commandenchant() {
         super("enchant");
@@ -31,18 +28,18 @@ public class Commandenchant extends EssentialsCommand {
     protected void run(final Server server, final User user, final String commandLabel, final String[] args) throws Exception {
         final ItemStack stack = user.getItemInHand();
         if (stack == null || stack.getType() == Material.AIR) {
-            throw new Exception(tl("nothingInHand"));
+            throw new TranslatableException("nothingInHand");
         }
 
         if (args.length == 0) {
             final Set<String> usableEnchants = new TreeSet<>();
             for (final Map.Entry<String, Enchantment> entry : Enchantments.entrySet()) {
-                final String name = entry.getValue().getName().toLowerCase(Locale.ENGLISH);
+                final String name = Enchantments.getRealName(entry.getValue());
                 if (usableEnchants.contains(name) || (user.isAuthorized("essentials.enchantments." + name) && entry.getValue().canEnchantItem(stack))) {
                     usableEnchants.add(entry.getKey());
                 }
             }
-            throw new NotEnoughArgumentsException(tl("enchantments", StringUtil.joinList(usableEnchants.toArray())));
+            throw new NotEnoughArgumentsException(user.playerTl("enchantments", StringUtil.joinList(usableEnchants.toArray())));
         }
 
         int level = 1;
@@ -57,13 +54,13 @@ public class Commandenchant extends EssentialsCommand {
         final MetaItemStack metaStack = new MetaItemStack(stack);
         final Enchantment enchantment = metaStack.getEnchantment(user, args[0]);
         metaStack.addEnchantment(user.getSource(), ess.getSettings().allowUnsafeEnchantments() && user.isAuthorized("essentials.enchantments.allowunsafe"), enchantment, level);
-        InventoryWorkaround.setItemInMainHand(user.getBase(), metaStack.getItemStack());
+        stack.setItemMeta(metaStack.getItemStack().getItemMeta());
         user.getBase().updateInventory();
-        final String enchantName = enchantment.getName().toLowerCase(Locale.ENGLISH).replace('_', ' ');
+        final String enchantName = Enchantments.getRealName(enchantment).replace('_', ' ');
         if (level == 0) {
-            user.sendMessage(tl("enchantmentRemoved", enchantName));
+            user.sendTl("enchantmentRemoved", enchantName);
         } else {
-            user.sendMessage(tl("enchantmentApplied", enchantName));
+            user.sendTl("enchantmentApplied", enchantName);
         }
     }