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>

.checkstyle/checkstyle.xml

@@ -0,0 +1,183 @@
+<?xml version="1.0" encoding="utf-8" ?>
+<!DOCTYPE module PUBLIC "-//Checkstyle//DTD Checkstyle Configuration 1.3//EN"
+        "https://checkstyle.org/dtds/configuration_1_3.dtd">
+
+<!-- based on https://github.com/KyoriPowered/adventure/blob/master/.checkstyle/checkstyle.xml -->
+
+<module name="Checker">
+    <property name="charset" value="UTF-8"/>
+    <property name="fileExtensions" value="java, properties, xml"/>
+    <property name="severity" value="error"/>
+
+    <!-- https://checkstyle.org/config_filefilters.html#BeforeExecutionExclusionFileFilter -->
+    <module name="BeforeExecutionExclusionFileFilter">
+        <property name="fileNamePattern" value="module\-info\.java$"/>
+    </module>
+
+    <!-- https://checkstyle.org/config_whitespace.html#FileTabCharacter -->
+    <module name="FileTabCharacter">
+        <property name="eachLine" value="true"/>
+    </module>
+
+    <!-- https://checkstyle.org/config_misc.html#NewlineAtEndOfFile -->
+    <module name="NewlineAtEndOfFile"/>
+
+    <!-- https://checkstyle.org/config_filters.html#SuppressionFilter -->
+    <module name="SuppressionFilter">
+        <property name="file" value="${configDirectory}/suppressions.xml"/>
+    </module>
+
+    <!-- https://checkstyle.org/config_filters.html#SuppressWithPlainTextCommentFilter -->
+    <module name="SuppressWithPlainTextCommentFilter"/>
+
+    <module name="TreeWalker">
+        <!-- https://checkstyle.org/config_misc.html#ArrayTypeStyle -->
+        <module name="ArrayTypeStyle"/>
+
+        <!-- https://checkstyle.org/config_imports.html#AvoidStarImport -->
+        <module name="AvoidStarImport"/>
+
+        <!-- https://checkstyle.org/config_misc.html#AvoidEscapedUnicodeCharacters -->
+        <module name="AvoidEscapedUnicodeCharacters">
+            <property name="allowByTailComment" value="true"/>
+            <property name="allowEscapesForControlCharacters" value="true"/>
+            <property name="allowNonPrintableEscapes" value="true"/>
+            <property name="severity" value="info"/>
+        </module>
+
+        <!-- https://checkstyle.org/config_misc.html#CommentsIndentation -->
+        <module name="CommentsIndentation"/>
+
+        <!-- https://checkstyle.org/config_whitespace.html#EmptyForInitializerPad -->
+        <module name="EmptyForInitializerPad"/>
+
+        <!-- https://checkstyle.org/config_whitespace.html#EmptyForIteratorPad -->
+        <module name="EmptyForIteratorPad"/>
+
+        <!-- https://checkstyle.org/config_whitespace.html#EmptyLineSeparator -->
+        <module name="EmptyLineSeparator">
+            <property name="allowMultipleEmptyLines" value="false"/>
+            <property name="allowMultipleEmptyLinesInsideClassMembers" value="false"/>
+            <property name="allowNoEmptyLineBetweenFields" value="true"/>
+            <property name="tokens"
+                      value="CLASS_DEF, CTOR_DEF, ENUM_DEF, IMPORT, INSTANCE_INIT, INTERFACE_DEF, METHOD_DEF, STATIC_IMPORT, STATIC_INIT, VARIABLE_DEF"/> <!-- remove PACKAGE_DEF, temporarily remove COMPACT_CTOR_DEF, RECORD_DEF -->
+        </module>
+
+        <!-- https://checkstyle.org/config_coding.html#FallThrough -->
+        <module name="FallThrough">
+            <property name="checkLastCaseGroup" value="true"/>
+        </module>
+
+        <!-- https://checkstyle.org/config_design.html#FinalClass -->
+        <module name="FinalClass"/>
+
+        <!-- https://checkstyle.org/config_coding.html#FinalLocalVariable -->
+        <module name="FinalLocalVariable"/>
+
+        <!-- https://checkstyle.org/config_whitespace.html#GenericWhitespace -->
+        <module name="GenericWhitespace"/>
+
+        <!-- https://checkstyle.org/config_design.html#HideUtilityClassConstructor -->
+        <module name="HideUtilityClassConstructor"/>
+
+        <!-- https://checkstyle.org/config_imports.html#IllegalImport -->
+        <module name="IllegalImport">
+            <property name="illegalPkgs" value="sun, jdk, com.sun"/>
+        </module>
+
+        <!-- https://checkstyle.org/config_coding.html#IllegalTokenText -->
+        <module name="IllegalTokenText">
+            <property name="format"
+                      value="\\u00(09|0(a|A)|0(c|C)|0(d|D)|22|27|5(C|c))|\\(0(10|11|12|14|15|42|47)|134)"/>
+            <property name="message"
+                      value="Consider using special escape sequence instead of octal value or Unicode escaped value."/>
+            <property name="tokens" value="CHAR_LITERAL, STRING_LITERAL"/>
+        </module>
+
+        <!-- https://checkstyle.org/config_misc.html#Indentation -->
+        <module name="Indentation"/>
+
+        <!-- https://checkstyle.org/config_blocks.html#LeftCurly -->
+        <module name="LeftCurly"/>
+
+        <!-- https://checkstyle.org/config_naming.html#MethodName -->
+        <module name="MethodName">
+            <property name="format" value="^[_]?[a-z][a-zA-Z0-9]*$"/>
+        </module>
+
+        <!-- https://checkstyle.org/config_whitespace.html#MethodParamPad -->
+        <module name="MethodParamPad"/>
+
+        <!-- https://checkstyle.org/config_javadoc.html#MissingJavadocMethod -->
+        <module name="MissingJavadocMethod">
+            <property name="allowMissingPropertyJavadoc" value="true"/>
+            <property name="tokens" value="METHOD_DEF, ANNOTATION_FIELD_DEF"/> <!-- remove CTOR_DEF, COMPACT_CTOR_DEF -->
+        </module>
+
+        <!-- https://checkstyle.org/config_javadoc.html#MissingJavadocType -->
+        <module name="MissingJavadocType"/>
+
+        <!-- https://checkstyle.org/config_coding.html#NoFinalizer -->
+        <module name="NoFinalizer"/>
+
+        <!-- https://checkstyle.org/config_whitespace.html#NoLineWrap -->
+        <module name="NoLineWrap"/>
+
+        <!-- https://checkstyle.org/config_whitespace.html#NoWhitespaceAfter -->
+        <module name="NoWhitespaceAfter">
+            <property name="allowLineBreaks" value="false"/>
+        </module>
+
+        <!-- https://checkstyle.org/config_whitespace.html#NoWhitespaceBefore -->
+        <module name="NoWhitespaceBefore">
+            <property name="allowLineBreaks" value="true"/>
+        </module>
+
+        <!-- https://checkstyle.org/config_coding.html#OneStatementPerLine -->
+        <module name="OneStatementPerLine"/>
+
+        <!-- https://checkstyle.org/config_misc.html#OuterTypeFilename -->
+        <module name="OuterTypeFilename"/>
+
+        <!-- https://checkstyle.org/config_imports.html#RedundantImport -->
+        <module name="RedundantImport"/>
+
+        <!-- https://checkstyle.org/config_modifier.html#RedundantModifier -->
+        <module name="RedundantModifier">
+            <property name="tokens"
+                      value="ANNOTATION_FIELD_DEF, CLASS_DEF, CTOR_DEF, ENUM_DEF, INTERFACE_DEF, VARIABLE_DEF"/> <!-- remove METHOD_DEF and RESOURCE -->
+        </module>
+
+        <!-- https://checkstyle.org/config_coding.html#RequireThis -->
+        <module name="RequireThis"/>
+
+        <!-- https://checkstyle.org/config_blocks.html#RightCurly -->
+        <module name="RightCurly">
+            <property name="id" value="RightCurlyAlone"/>
+            <property name="option" value="alone"/>
+            <property name="tokens"
+                      value="ANNOTATION_DEF, CLASS_DEF, CTOR_DEF, ENUM_DEF, INSTANCE_INIT, LITERAL_FOR, LITERAL_WHILE, METHOD_DEF, STATIC_INIT"/>
+        </module>
+        <module name="RightCurly">
+            <property name="id" value="RightCurlySame"/>
+            <property name="option" value="same"/>
+            <property name="tokens"
+                      value="LITERAL_CATCH, LITERAL_DO, LITERAL_ELSE, LITERAL_FINALLY, LITERAL_IF, LITERAL_TRY"/> <!-- add LITERAL_DO -->
+        </module>
+
+        <!-- https://checkstyle.org/config_whitespace.html#SingleSpaceSeparator -->
+        <module name="SingleSpaceSeparator">
+            <property name="validateComments" value="true"/>
+        </module>
+
+        <!-- https://checkstyle.org/config_whitespace.html#TypecastParenPad -->
+        <module name="TypecastParenPad"/>
+
+        <!-- https://checkstyle.org/config_coding.html#UnnecessaryParentheses -->
+        <module name="UnnecessaryParentheses"/>
+
+        <!-- https://checkstyle.org/config_imports.html#UnusedImports -->
+        <module name="UnusedImports"/>
+
+    </module>
+</module>

.checkstyle/suppressions.xml

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE suppressions PUBLIC "-//Checkstyle//DTD SuppressionFilter Configuration 1.2//EN" "http://checkstyle.org/dtds/suppressions_1_2.dtd">
+<suppressions>
+    <suppress files=".*[\\/]test[\\/]java[\\/].*" checks="RequireExplicitVisibilityModifier"/>
+    <!-- TODO: don't suppress I-prefixed API interfaces under com.earth2me.essentials -->
+    <suppress files="(com[\\/]earth2me[\\/]essentials[\\/]|net[\\/]ess3[\\/]|net[\\/]essentialsx[\\/])(?:[^\\/]+$|(?!api)[^\\/]+[\\/])" checks="MissingJavadoc(Method|Type)"/>
+</suppressions>

.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/FUNDING.yml

@@ -1,10 +1,10 @@
 # Currently used
 patreon: EssentialsX
+ko_fi: essentialsx
+github: EssentialsX
+open_collective: EssentialsX
 
 # Currently not used
-#github: # Replace with up to 4 GitHub Sponsors-enabled usernames e.g., [user1, user2]
-#open_collective: # Replace with a single Open Collective username
-#ko_fi: # Replace with a single Ko-fi username
 #tidelift: # Replace with a single Tidelift platform-name/package-name e.g., npm/babel
 #community_bridge: # Replace with a single Community Bridge project-name e.g., cloud-foundry
 #liberapay: # Replace with a single Liberapay username

.github/ISSUE_TEMPLATE/config.yml

@@ -0,0 +1,17 @@
+blank_issues_enabled: false
+contact_links:
+  - name: View common issues
+    url: https://github.com/EssentialsX/Essentials/issues/3956
+    about: Check the list of known common issues to see if it solves your problem.
+  - name: Check past help requests
+    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/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: 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/help.md

@@ -1,45 +0,0 @@
----
-name: Help!
-about: Encountered a problem with EssentialsX? Not sure how to fix it?
-
----
-
-<!-- EssentialsX help guide
-
-Don't write inside the arrows as they will be hidden when you post your issue.
-
-Want faster support? Come join our Discord server to get help sooner:
-https://discord.gg/F7gexAQ
-
-If you're happy to wait (or you were sent here from Discord), read on:
-
-1.  Fill out the template.
-      This will help us understand what problem you've encountered and help us
-      find a solution.
-
-2.  Check the Common Issues page.
-      Read through the wiki page to see if you've encountered a regular issue:
-      https://essentialsx.github.io/#/Common-Issues
-
-3.  Delete this line and all above lines before posting your issue!       -->
-
-### Information
-
-Full output of `/ess version`:
-
-<!-- Replace this with the command output -->
-
-**Server log:** <!-- Upload `logs/latest.log` to https://gist.github.com/ -->
-
-**EssentialsX config** <!-- Upload `plugins/Essentials/config.yml` to https://gist.github.com/ -->
-
-### Help request
-
-**Problem**
-<!-- What problem did you encounter? -->
-
-**What I have tried**
-<!-- What have you tried so far? -->
-
-**Screenshots**
-<!-- If relevant, include any screenshots here. -->

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

@@ -1,58 +0,0 @@
----
-name: Report a bug
-about: Report an EssentialsX bug. Only use this if you're 100% sure there's something wrong with EssentialsX - otherwise, try "Help!".
-
----
-
-<!-- EssentialsX bug reporting guide
-
-Don't put anything inside this block, as it won't be included in the issue.
-
-If you are reporting a bug, please follow the following steps:
-
-1.  Fill out the template in full.
-      Run the commands in the console. Don't just put "latest" as a version,
-      or we will ignore it.
-
-2.  When linking files, do not attach them to the post!
-      Copy and paste any logs into https://gist.github.com/, then paste a
-      link to them in the relevant parts of the template. Avoid using
-      Hastebin or Pastebin, as this makes providing support more difficult.
-      **DO NOT drag files into this box!**
-
-3.  If you are reporting a performance issue, please include a link to a
-    Timings and/or profiler report.
-
-4.  If you are reporting a bug with commands or something else in-game,
-    please include screenshots to help us diagnose the problem.
-
-5.  Make sure not to write between the arrows, as anything there will be
-    hidden.
-
-6.  Delete this line and all above lines before posting your issue!       -->
-
-### Information
-
-**Full output of `/ess version`**:
-
-```
-<!-- Run the command in your console, and copy and paste the whole output here -->
-```
-
-**Server log**: <!-- Upload `logs/latest.log` to https://gist.github.com/, replace this with link -->
-
-**EssentialsX config**: <!-- Upload `plugins/Essentials/config.yml` to https://gist.github.com/, replace this with link -->
-
-### Details
-
-**Description**  
-<!-- Replace this with a brief summary of the bug. -->
-
-**Steps to reproduce**  
-<!-- Replace this with exactly what you did to cause the bug. -->
-
-**Expected behavior**  
-<!-- Replace this with what you expected to happen. -->
-
-**Screenshots**  
-<!-- Replace this with screenshots, if necessary. -->

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

@@ -0,0 +1,83 @@
+name: Report bug
+description: Report a bug in EssentialsX.
+labels: 'bug: unconfirmed'
+type: Bug
+body:
+- type: markdown
+  attributes:
+    value: |
+      Thanks for taking the time to report an EssentialsX bug! Fill out the form below to provide us with info to help fix the bug.
+      Only use this if you're 100% sure you've found a bug and can reproduce it. If you're looking for general help with EssentialsX, try the Q&A forum or MOSS Discord server.
+- type: dropdown
+  attributes:
+    label: Type of bug
+    description: What type of bug is this? Choose all that apply.
+    multiple: true
+    options:
+      - Performance issue or memory leak
+      - Data loss
+      - Exploit
+      - Compatibility issue
+      - Error in console
+      - Other unexpected behaviour
+  validations:
+    required: true
+
+- type: input
+  attributes:
+    label: "`/ess dump all` output"
+    description: Run `/ess dump all` in the console, then copy and paste the link from the output of the command into this box. (If this command doesn't work, you should [update EssentialsX](https://essentialsx.net/downloads.html) and try again.)
+  validations:
+    required: true
+- type: input
+  attributes:
+    label: Error log (if applicable)
+    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:
+    label: Bug description
+    description: Describe roughly what the bug is here.
+    placeholder: |
+      Example: "When running /nuke after putting everyone into adventure mode, there aren't any explosions..."
+  validations:
+    required: true
+- type: textarea
+  attributes:
+    label: Steps to reproduce
+    description: Provide an example of how to trigger the bug.
+    placeholder: |
+      Example:
+      1. Have at least 3 people online
+      2. Run `/gma *` to put everyone into adventure mode
+      3. Run `/nuke`
+  validations:
+    required: true
+- type: textarea
+  attributes:
+    label: Expected behaviour
+    description: Explain what you should expect to happen.
+    placeholder: |
+      Example: "Everything should explode!"
+  validations:
+    required: true
+- type: textarea
+  attributes:
+    label: Actual behaviour
+    description: Explain what actually happens.
+    placeholder: |
+      Example: "Everything doesn't explode :("
+  validations:
+    required: true
+
+- type: textarea
+  attributes:
+    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.md

@@ -1,45 +0,0 @@
----
-name: Request a feature
-about: Suggest a feature you want to see in EssentialsX!
-
----
-
-<!-- EssentialsX feature request guide
-
-Fill out the template. Don't write inside the arrows as they will be hidden
-when you post your issue.
-
-Not sure if your feature fits in EssentialsX? Feel free to ask on our Discord
-server: https://discord.gg/F7gexAQ
-
-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 wiki at https://essentialsx.github.io/ to see if the
-      feature was recently added.
-
-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.
-
-5.  Delete this line and all above lines before posting your issue!       -->
-
-### Feature request
-
-**Feature description**
-<!-- What feature are you suggesting? -->
-
-**How the feature is useful**
-<!-- How is the feature useful to players, server owners and/or developers? -->

.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

@@ -0,0 +1,94 @@
+<!--
+
+EssentialsX bug fix submission guide
+====================================
+
+NOTE: Failure to fill out this template properly may result in your PR being
+      delayed or ignored without warning.
+
+NOTE: Don't type between any arrows in the template, as this text will be
+      hidden. This includes this header block and any other explanation text
+      blocks.
+
+Want to discuss your PR before submitting it? Join the EssentialsX Development
+server: https://discord.gg/CUN7qVb
+
+
+EssentialsX is GPL
+------------------
+
+By contributing to EssentialsX, you agree to license your code under the
+GNU General Public License version 3, which can be found at the link below:
+https://github.com/EssentialsX/Essentials/blob/2.x/LICENSE
+
+
+Instructions
+------------
+
+If you are submitting a bug fix, please follow the following steps:
+
+1.  Fill out the template in full.
+      This includes providing screenshots and a link to the original bug 
+      report. If there isn't an existing bug report, we recommend opening a new
+      detailed bug report BEFORE opening your PR to fix it, else your PR may be
+      delayed or rejected without warning.
+      
+      You can open a new bug report by following this link:
+      https://github.com/EssentialsX/Essentials/issues/new/choose 
+
+2.  When linking logs or config files, do not attach them to the post!
+      Copy and paste any logs into https://gist.github.com/, then paste a
+      link to them in the relevant parts of the template. Do not use Hastebin
+      or Pastebin, as this can cause issues with future reviews.
+      
+      DO NOT drag logs directly into this text box, as we cannot read these!
+
+3.  If you are fixing a performance issue, please include a link to a
+    Timings and/or profiler report, both before and after your PR.
+
+4.  If you are fixing a visual bug, such as in commands, please include
+    screenshots so that we can more easily review the proposed fix.
+    (You can drag screenshots into the bottom of the editor.)
+
+-->
+
+### Information
+
+<!--
+    Replace #nnnn with the number of the original issue. If this PR fixes
+    multiple issues, you should repeat the phrase "fixes #nnnn" for each issue. 
+-->
+
+This PR fixes #nnnn. 
+
+### Details
+
+**Proposed fix:**    
+<!-- Type a description of your proposed fix below this line. -->
+
+
+**Environments tested:**    
+
+<!-- Type the OS you have used below. -->
+OS: 
+
+<!-- Type the JDK version (from java -version) you have used below. -->
+Java version:  
+
+<!--
+    Put an "x" inside the boxes for the server software you have tested this 
+    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 (XX.YY.Z, git-Paper-BUILD)
+- [ ] CraftBukkit/Spigot/Paper 1.12.2
+- [ ] CraftBukkit 1.8.8
+
+
+**Demonstration:**    
+<!--
+    Below this block, include screenshots/log snippets from before and after as
+    necessary. If you have created or used a test case plugin, please link to a
+    download of the plugin, source code and exact version used where possible.
+-->
+

.github/PULL_REQUEST_TEMPLATE/config.yml

@@ -0,0 +1,8 @@
+blank_issues_enabled: false
+contact_links:
+  - name: MOSS Discord Server
+    url: https://discord.gg/casfFyh
+    about: Need help with using EssentialsX? Join the MOSS Discord server for help.
+  - name: EssentialsX Development Discord Server
+    url: https://discord.gg/CUN7qVb
+    about: Got questions or want to discuss changes before opening your PR? Join the EssentialsX Development Discord server. (Need help? Join MOSS instead.)

.github/PULL_REQUEST_TEMPLATE/new-feature.md

@@ -0,0 +1,93 @@
+<!--
+
+EssentialsX feature submission guide
+====================================
+
+NOTE: Failure to fill out this template properly may result in your PR being
+      delayed or ignored without warning.
+
+NOTE: Don't type between any arrows in the template, as this text will be
+      hidden. This includes this header block and any other explanation text
+      blocks.
+
+Want to discuss your PR before submitting it? Join the EssentialsX Development
+server: https://discord.gg/CUN7qVb
+
+
+EssentialsX is GPL
+------------------
+
+By contributing to EssentialsX, you agree to license your code under the
+GNU General Public License version 3, which can be found at the link below:
+https://github.com/EssentialsX/Essentials/blob/2.x/LICENSE
+
+
+Instructions
+------------
+
+If you are submitting a new feature, please follow the following steps:
+
+1.  Fill out the template in full.
+      This includes providing screenshots and a link to the original feature 
+      request. If there isn't an existing feature request, we strongly
+      recommend opening a new feature request BEFORE opening your PR to
+      implement it, as this allows us to review whether we're likely to accept
+      your feature in advance, and also allows us to discuss possible
+      implementations for the feature. If there is no associated feature
+      request, your PR may be delayed or rejected without warning.
+      
+      You can open a new feature request by following this link:
+      https://github.com/EssentialsX/Essentials/issues/new/choose
+
+2.  If you are fixing a performance issue, please use the "Bug fix" PR template
+      instead. The "bug fix" template is better suited to performance issues.
+
+3.  Include a demonstration.
+      If you are adding commands, please provide screenshots and/or a video
+      demonstration of the feature. Similarly, if you are adding a new API,
+      please include a link to example code that takes advantage of your
+      proposed API. This will aid us in reviewing PRs and speed up the process
+      significantly.
+
+-->
+
+### Information
+
+<!--
+    Replace #nnnn with the number of the original issue. If this PR implements
+    features from multiple issues, you should repeat the phrase "closes #nnnn"
+    for each issue. 
+-->
+
+This PR closes #nnnn. 
+
+### Details
+
+**Proposed feature:**  
+<!-- Type a description of your proposed feature below this line. -->
+
+
+**Environments tested:**    
+
+<!-- Type the OS you have used below. -->
+OS: 
+
+<!-- Type the JDK version (from java -version) you have used below. -->
+Java version:  
+
+<!--
+    Put an "x" inside the boxes for the server software you have tested this 
+    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 (XX.YY.Z, git-Paper-BUILD)
+- [ ] CraftBukkit/Spigot/Paper 1.12.2
+- [ ] CraftBukkit 1.8.8
+
+
+**Demonstration:**  
+<!--
+    Below this block, include screenshots/log snippets from before and after as
+    necessary. If you have created or used a test case plugin, please link to a
+    download of the plugin, source code and exact version used where possible.
+-->

.github/pull_request_template.md

@@ -0,0 +1,10 @@
+You need to select a pull request template!
+
+If you're adding a new feature, copy and paste the following parameter at the end of the URL:
+    ?template=new-feature.md
+
+If you're fixing a bug, copy and paste the following parameter at the end of the URL:
+    ?template=bug-fix.md
+
+For more information about contributing to EssentialsX, see CONTRIBUTING.md:
+    https://github.com/EssentialsX/Essentials/blob/2.x/CONTRIBUTING.md

.github/workflows/build-master.yml

@@ -0,0 +1,151 @@
+name: Build EssentialsX
+
+on:
+  push:
+    branches:
+    - 2.x
+    - dev/*
+  release:
+    types:
+    - published
+
+jobs:
+  build:
+    name: Build and upload
+    runs-on: ubuntu-latest
+
+    steps:
+    - name: Checkout Git repo
+      uses: actions/checkout@v4
+      with:
+        fetch-depth: 0
+
+    - name: Set up JDK 25
+      uses: actions/setup-java@v4
+      with:
+        distribution: 'temurin'
+        java-version: 25
+
+    - 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@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:
+        ORG_GRADLE_PROJECT_essxUsername: ${{ secrets.ESSENTIALSX_DEPLOY_USERNAME }}
+        ORG_GRADLE_PROJECT_essxPassword: ${{ secrets.ESSENTIALSX_DEPLOY_PASSWORD }}
+      run: |
+        ./gradlew publish
+
+    - name: Prepare Javadocs
+      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: Archive Javadocs
+      uses: actions/upload-artifact@v7
+      with:
+        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

@@ -0,0 +1,108 @@
+name: Build Pull Request
+
+on:
+  push:
+    branches:
+    - mc/* # MC version updates
+    - pr/* # PR rebases
+  pull_request:
+    branches:
+    - 2.x
+    - mc/*
+    - dev/*
+  merge_group:
+    types: [checks_requested]
+
+permissions:
+  checks: write
+
+jobs:
+  build:
+    name: Build and upload
+    runs-on: ubuntu-latest
+
+    steps:
+    - name: Checkout Git repo
+      uses: actions/checkout@v4
+      with:
+        fetch-depth: 0
+
+    - name: Set up JDK 25
+      uses: actions/setup-java@v4
+      with:
+        distribution: 'temurin'
+        java-version: 25
+
+    - 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@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

@@ -1,18 +1,35 @@
-# IDE files
+# Other IDE files
 *.classpath
 *.project
 *.settings/
-.idea/
+.idea/*
 *.iml
 .DS_Store
 
+# Checkstyle-IDEA config
+!.idea/checkstyle-idea.xml
+
 # Essentials files
 /Essentials/userdata
 /Essentials/config.yml
 /Essentials/kits.yml
 /Essentials/userdata/testplayer1.yml
 /Essentials/usermap.csv
+/Essentials/usermap.bin
+/Essentials/uuids.bin
 
 # Build files
+.gradle/
+/jars/
+generated/
+out/
+build/
 target/
-jars/
+*.class
+build-logic/.kotlin/
+build-logic/bin/
+bin/
+test-tmp/
+
+# Run directory
+/run/

.idea/checkstyle-idea.xml

@@ -0,0 +1,27 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <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>

.travis.yml

@@ -1,13 +0,0 @@
-language: java
-
-jdk:
-  - openjdk8
-
-cache:
-  directories:
-  - .buildtools
-  - $HOME/.m2
-
-before_install:
-  - chmod +x scripts/buildtools.sh
-  - scripts/buildtools.sh

CONTRIBUTING.md

@@ -0,0 +1,102 @@
+# Contributing to EssentialsX
+
+*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).*
+
+## Submitting code changes to EssentialsX
+
+If you're interested in submitting new code to EssentialsX, we accept changes via GitHub pull requests.
+
+### Adding features
+
+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.
+
+#### Keep it focused
+
+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

@@ -0,0 +1,106 @@
+plugins {
+    id("essentials.shadow-module")
+}
+
+dependencies {
+    compileOnly('net.essentialsx.deps:VaultAPI:1.7') {
+        exclude group: "org.bukkit", module: "bukkit"
+    }
+    compileOnly 'net.luckperms:api:5.3'
+
+    api 'io.papermc:paperlib:1.0.6'
+
+    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 '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')) {
+        exclude(module: 'spigot-api')
+    }
+    api(project(path: ':providers:PaperProvider', configuration: 'shadow')){
+        exclude(module: 'paper-api')
+    }
+    api(project(':providers:NMSReflectionProvider')) {
+        exclude(module: 'bukkit')
+    }
+    api(project(':providers:1_8Provider')) {
+        exclude(module: 'spigot-api')
+    }
+    api(project(':providers:1_12Provider')) {
+        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'))
+        include (dependency('org.bstats:bstats-bukkit'))
+        include (dependency('org.bstats:bstats-base'))
+        include (dependency('org.spongepowered:configurate-yaml'))
+        include (dependency('org.spongepowered:configurate-core'))
+        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(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'
+    relocate 'org.spongepowered.configurate', 'com.earth2me.essentials.libs.configurate'
+    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/pom.xml

@@ -1,118 +0,0 @@
-<project xmlns="http://maven.apache.org/POM/4.0.0"
-         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
-    <modelVersion>4.0.0</modelVersion>
-
-    <parent>
-        <groupId>net.ess3</groupId>
-        <artifactId>EssentialsXParent</artifactId>
-        <version>2.17-pre1</version>
-    </parent>
-
-    <artifactId>EssentialsX</artifactId>
-
-    <build>
-        <finalName>EssentialsX-${full.version}</finalName>
-        <plugins>
-            <plugin>
-                <groupId>org.apache.maven.plugins</groupId>
-                <artifactId>maven-compiler-plugin</artifactId>
-                <version>3.8.0</version>
-                <configuration>
-                    <showDeprecation>false</showDeprecation>
-                </configuration>
-            </plugin>
-            <plugin>
-                <groupId>org.apache.maven.plugins</groupId>
-                <artifactId>maven-shade-plugin</artifactId>
-                <version>3.2.1</version>
-                <executions>
-                    <execution>
-                        <phase>package</phase>
-                        <goals>
-                            <goal>shade</goal>
-                        </goals>
-                    </execution>
-                </executions>
-                <configuration>
-                    <createDependencyReducedPom>false</createDependencyReducedPom>
-                    <relocations>
-                        <relocation>
-                            <pattern>io.papermc.lib</pattern>
-                            <shadedPattern>com.earth2me.essentials.paperlib</shadedPattern>
-                        </relocation>
-                    </relocations>
-                </configuration>
-            </plugin>
-        </plugins>
-    </build>
-
-    <dependencies>
-        <dependency>
-            <groupId>net.milkbowl.vault</groupId>
-            <artifactId>VaultAPI</artifactId>
-            <version>1.7</version>
-            <scope>provided</scope>
-        </dependency>
-        <dependency>
-            <groupId>io.papermc</groupId>
-            <artifactId>paperlib</artifactId>
-            <version>1.0.2</version>
-            <scope>compile</scope>
-        </dependency>
-        <dependency>
-            <groupId>net.ess3</groupId>
-            <artifactId>NMSProvider</artifactId>
-            <version>2.17-pre1</version>
-            <scope>compile</scope>
-        </dependency>
-        <dependency>
-            <groupId>net.ess3</groupId>
-            <artifactId>UpdatedMetaProvider</artifactId>
-            <version>2.17-pre1</version>
-            <scope>compile</scope>
-        </dependency>
-        <dependency>
-            <groupId>net.ess3</groupId>
-            <artifactId>1_8_R1Provider</artifactId>
-            <version>2.17-pre1</version>
-            <scope>compile</scope>
-            <exclusions>
-                <exclusion>
-                    <groupId>org.bukkit</groupId>
-                    <artifactId>craftbukkit</artifactId>
-                </exclusion>
-            </exclusions>
-        </dependency>
-        <dependency>
-            <groupId>net.ess3</groupId>
-            <artifactId>1_8_R2Provider</artifactId>
-            <version>2.17-pre1</version>
-            <scope>compile</scope>
-            <exclusions>
-                <exclusion>
-                    <groupId>org.bukkit</groupId>
-                    <artifactId>craftbukkit</artifactId>
-                </exclusion>
-            </exclusions>
-        </dependency>
-        <dependency>
-            <groupId>net.ess3</groupId>
-            <artifactId>LegacyProvider</artifactId>
-            <version>2.17-pre1</version>
-            <scope>compile</scope>
-        </dependency>
-        <dependency>
-            <groupId>net.ess3</groupId>
-            <artifactId>ReflectionProvider</artifactId>
-            <version>2.17-pre1</version>
-            <scope>compile</scope>
-        </dependency>
-        <dependency>
-            <groupId>net.ess3</groupId>
-            <artifactId>FlattenedProvider</artifactId>
-            <version>2.17-pre1</version>
-            <scope>compile</scope>
-        </dependency>
-    </dependencies>
-</project>

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

@@ -1,113 +0,0 @@
-package com.earth2me.essentials;
-
-import net.ess3.api.IEssentials;
-import org.bukkit.command.Command;
-import org.bukkit.command.PluginCommand;
-import org.bukkit.command.PluginCommandYamlParser;
-import org.bukkit.plugin.Plugin;
-
-import java.util.*;
-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<PluginCommand>> altcommands = new HashMap<>();
-    private final transient Map<String, String> disabledList = new HashMap<>();
-    private final transient IEssentials ess;
-
-    public AlternativeCommandsHandler(final IEssentials ess) {
-        this.ess = ess;
-        for (Plugin plugin : ess.getServer().getPluginManager().getPlugins()) {
-            if (plugin.isEnabled()) {
-                addPlugin(plugin);
-            }
-        }
-    }
-
-    public final void addPlugin(final Plugin plugin) {
-        if (plugin.getDescription().getMain().contains("com.earth2me.essentials")) {
-            return;
-        }
-        final List<Command> commands = PluginCommandYamlParser.parse(plugin);
-        final String pluginName = plugin.getDescription().getName().toLowerCase(Locale.ENGLISH);
-
-        for (Command command : commands) {
-            final PluginCommand pc = (PluginCommand) command;
-            final List<String> labels = new ArrayList<>(pc.getAliases());
-            labels.add(pc.getName());
-
-            PluginCommand reg = ess.getServer().getPluginCommand(pluginName + ":" + pc.getName().toLowerCase(Locale.ENGLISH));
-            if (reg == null) {
-                reg = ess.getServer().getPluginCommand(pc.getName().toLowerCase(Locale.ENGLISH));
-            }
-            if (reg == null || !reg.getPlugin().equals(plugin)) {
-                continue;
-            }
-            for (String label : labels) {
-                List<PluginCommand> plugincommands = altcommands.get(label.toLowerCase(Locale.ENGLISH));
-                if (plugincommands == null) {
-                    plugincommands = new ArrayList<>();
-                    altcommands.put(label.toLowerCase(Locale.ENGLISH), plugincommands);
-                }
-                boolean found = false;
-                for (PluginCommand pc2 : plugincommands) {
-                    if (pc2.getPlugin().equals(plugin)) {
-                        found = true;
-                    }
-                }
-                if (!found) {
-                    plugincommands.add(reg);
-                }
-            }
-        }
-    }
-
-    public void removePlugin(final Plugin plugin) {
-        final Iterator<Map.Entry<String, List<PluginCommand>>> iterator = altcommands.entrySet().iterator();
-        while (iterator.hasNext()) {
-            final Map.Entry<String, List<PluginCommand>> entry = iterator.next();
-            final Iterator<PluginCommand> pcIterator = entry.getValue().iterator();
-            while (pcIterator.hasNext()) {
-                final PluginCommand pc = pcIterator.next();
-                if (pc.getPlugin() == null || pc.getPlugin().equals(plugin)) {
-                    pcIterator.remove();
-                }
-            }
-            if (entry.getValue().isEmpty()) {
-                iterator.remove();
-            }
-        }
-    }
-
-    public PluginCommand getAlternative(final String label) {
-        final List<PluginCommand> commands = altcommands.get(label);
-        if (commands == null || commands.isEmpty()) {
-            return null;
-        }
-        if (commands.size() == 1) {
-            return commands.get(0);
-        }
-        // return the first command that is not an alias
-        for (PluginCommand command : commands) {
-            if (command.getName().equalsIgnoreCase(label)) {
-                return command;
-            }
-        }
-        // return the first alias
-        return commands.get(0);
-    }
-
-    public void executed(final String label, final PluginCommand pc) {
-        final String altString = pc.getPlugin().getName() + ":" + pc.getLabel();
-        if (ess.getSettings().isDebug()) {
-            LOGGER.log(Level.INFO, "Essentials: Alternative command " + label + " found, using " + altString);
-        }
-        disabledList.put(label, altString);
-    }
-
-    public Map<String, String> disabledCommands() {
-        return disabledList;
-    }
-}

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

@@ -1,132 +0,0 @@
-package com.earth2me.essentials;
-
-import net.ess3.api.IEssentials;
-import org.bukkit.Server;
-import org.bukkit.command.CommandSender;
-
-import java.io.BufferedReader;
-import java.io.IOException;
-import java.io.InputStreamReader;
-import java.util.logging.Level;
-import java.util.logging.Logger;
-
-import static com.earth2me.essentials.I18n.tl;
-
-
-public class Backup implements Runnable {
-    private static final Logger LOGGER = Logger.getLogger("Essentials");
-    private transient final Server server;
-    private transient final IEssentials ess;
-    private transient boolean running = false;
-    private transient int taskId = -1;
-    private transient boolean active = false;
-
-    public Backup(final IEssentials ess) {
-        this.ess = ess;
-        server = ess.getServer();
-        if (!ess.getOnlinePlayers().isEmpty()) {
-            ess.runTaskAsynchronously(new Runnable() {
-                @Override
-                public void run() {
-                    startTask();
-                }
-            });
-        }
-    }
-
-    public void onPlayerJoin() {
-        startTask();
-    }
-
-    public synchronized void stopTask() {
-        running = false;
-        if (taskId != -1) {
-            server.getScheduler().cancelTask(taskId);
-        }
-        taskId = -1;
-    }
-
-    private synchronized void startTask() {
-        if (!running) {
-            final long interval = ess.getSettings().getBackupInterval() * 1200; // minutes -> ticks
-            if (interval < 1200) {
-                return;
-            }
-            taskId = ess.scheduleSyncRepeatingTask(this, interval, interval);
-            running = true;
-        }
-    }
-
-    @Override
-    public void run() {
-        if (active) {
-            return;
-        }
-        active = true;
-        final String command = ess.getSettings().getBackupCommand();
-        if (command == null || "".equals(command)) {
-            return;
-        }
-        if ("save-all".equalsIgnoreCase(command)) {
-            final CommandSender cs = server.getConsoleSender();
-            server.dispatchCommand(cs, "save-all");
-            active = false;
-            return;
-        }
-        LOGGER.log(Level.INFO, tl("backupStarted"));
-        final CommandSender cs = server.getConsoleSender();
-        server.dispatchCommand(cs, "save-all");
-        server.dispatchCommand(cs, "save-off");
-
-        ess.runTaskAsynchronously(new Runnable() {
-            @Override
-            public void run() {
-                try {
-                    final ProcessBuilder childBuilder = new ProcessBuilder(command);
-                    childBuilder.redirectErrorStream(true);
-                    childBuilder.directory(ess.getDataFolder().getParentFile().getParentFile());
-                    final Process child = childBuilder.start();
-                    ess.runTaskAsynchronously(new Runnable() {
-                        @Override
-                        public void run() {
-                            try {
-                                final BufferedReader reader = new BufferedReader(new InputStreamReader(child.getInputStream()));
-                                try {
-                                    String line;
-                                    do {
-                                        line = reader.readLine();
-                                        if (line != null) {
-                                            LOGGER.log(Level.INFO, line);
-                                        }
-                                    } while (line != null);
-                                } finally {
-                                    reader.close();
-                                }
-                            } catch (IOException ex) {
-                                LOGGER.log(Level.SEVERE, null, ex);
-                            }
-                        }
-                    });
-                    child.waitFor();
-                } catch (InterruptedException ex) {
-                    LOGGER.log(Level.SEVERE, null, ex);
-                } catch (IOException ex) {
-                    LOGGER.log(Level.SEVERE, null, ex);
-                } finally {
-                    class BackupEnableSaveTask implements Runnable {
-                        @Override
-                        public void run() {
-                            server.dispatchCommand(cs, "save-on");
-                            if (ess.getOnlinePlayers().isEmpty()) {
-                                stopTask();
-                            }
-                            active = false;
-                            LOGGER.log(Level.INFO, tl("backupFinished"));
-                        }
-                    }
-                    ess.scheduleSyncDelayedTask(new BackupEnableSaveTask());
-                }
-            }
-        });
-    }
-}

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

@@ -1,12 +0,0 @@
-package com.earth2me.essentials;
-
-
-public class ChargeException extends Exception {
-    public ChargeException(final String message) {
-        super(message);
-    }
-
-    public ChargeException(final String message, final Throwable throwable) {
-        super(message, throwable);
-    }
-}

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

@@ -1,39 +0,0 @@
-package com.earth2me.essentials;
-
-import org.bukkit.command.CommandSender;
-import org.bukkit.entity.Player;
-
-
-public class CommandSource {
-    protected CommandSender sender;
-
-    public CommandSource(final CommandSender base) {
-        this.sender = base;
-    }
-
-    public final CommandSender getSender() {
-        return sender;
-    }
-
-    public final Player getPlayer() {
-        if (sender instanceof Player) {
-            return (Player) sender;
-        }
-        return null;
-    }
-
-    public final boolean isPlayer() {
-        return (sender instanceof Player);
-    }
-
-    public final CommandSender setSender(final CommandSender base) {
-        return this.sender = base;
-    }
-
-
-    public void sendMessage(String message) {
-        if (!message.isEmpty()) {
-            sender.sendMessage(message);
-        }
-    }
-}

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

@@ -1,77 +0,0 @@
-package com.earth2me.essentials;
-
-import com.earth2me.essentials.messaging.IMessageRecipient;
-import com.earth2me.essentials.messaging.SimpleMessageRecipient;
-
-import org.bukkit.Server;
-import org.bukkit.command.CommandSender;
-
-
-public final class Console implements IMessageRecipient {
-    public static final String NAME = "Console";
-    private static Console instance; // Set in essentials
-    
-    private final IEssentials ess;
-    private final IMessageRecipient messageRecipient;
-
-    public static Console getInstance() {
-        return instance;
-    }
-
-    static void setInstance(IEssentials ess) { // Called in Essentials#onEnable()
-        instance = new Console(ess);
-    }
-    
-    /**
-     * @deprecated Use {@link Console#getCommandSender()}
-     */
-    @Deprecated
-    public static CommandSender getCommandSender(Server server) throws Exception {
-        return server.getConsoleSender();
-    }
-
-    private Console(IEssentials ess) {
-        this.ess = ess;
-        this.messageRecipient = new SimpleMessageRecipient(ess, this);
-    }
-
-    public CommandSender getCommandSender() {
-        return ess.getServer().getConsoleSender();
-    }
-
-    @Override public String getName() {
-        return Console.NAME;
-    }
-
-    @Override public String getDisplayName() {
-        return Console.NAME;
-    }
-
-    @Override public void sendMessage(String message) {
-        getCommandSender().sendMessage(message);
-    }
-
-    @Override public boolean isReachable() {
-        return true;
-    }
-    
-    /* ================================
-     * >> DELEGATE METHODS
-     * ================================ */
-
-    @Override public MessageResponse sendMessage(IMessageRecipient recipient, String message) {
-        return this.messageRecipient.sendMessage(recipient, message);
-    }
-
-    @Override public MessageResponse onReceiveMessage(IMessageRecipient sender, String message) {
-        return this.messageRecipient.onReceiveMessage(sender, message);
-    }
-
-    @Override public IMessageRecipient getReplyRecipient() {
-        return this.messageRecipient.getReplyRecipient();
-    }
-
-    @Override public void setReplyRecipient(IMessageRecipient recipient) {
-        this.messageRecipient.setReplyRecipient(recipient);
-    }
-}

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

@@ -1,289 +0,0 @@
-package com.earth2me.essentials;
-
-import org.bukkit.NamespacedKey;
-import org.bukkit.enchantments.Enchantment;
-
-import java.util.HashMap;
-import java.util.Locale;
-import java.util.Map;
-import java.util.Map.Entry;
-import java.util.Set;
-
-
-public class Enchantments {
-    private static final Map<String, Enchantment> ENCHANTMENTS = new HashMap<String, Enchantment>();
-    private static final Map<String, Enchantment> ALIASENCHANTMENTS = new HashMap<String, Enchantment>();
-    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);
-
-        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("undeaddamage", Enchantment.DAMAGE_UNDEAD);
-        ENCHANTMENTS.put("smite", Enchantment.DAMAGE_UNDEAD);
-        ALIASENCHANTMENTS.put("du", Enchantment.DAMAGE_UNDEAD);
-
-        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("durability", Enchantment.DURABILITY);
-        ALIASENCHANTMENTS.put("dura", Enchantment.DURABILITY);
-        ENCHANTMENTS.put("unbreaking", Enchantment.DURABILITY);
-        ALIASENCHANTMENTS.put("d", Enchantment.DURABILITY);
-
-        ENCHANTMENTS.put("thorns", Enchantment.THORNS);
-        ENCHANTMENTS.put("highcrit", Enchantment.THORNS);
-        ALIASENCHANTMENTS.put("thorn", Enchantment.THORNS);
-        ALIASENCHANTMENTS.put("highercrit", Enchantment.THORNS);
-        ALIASENCHANTMENTS.put("t", Enchantment.THORNS);
-
-        ENCHANTMENTS.put("fireaspect", Enchantment.FIRE_ASPECT);
-        ENCHANTMENTS.put("fire", Enchantment.FIRE_ASPECT);
-        ALIASENCHANTMENTS.put("meleefire", Enchantment.FIRE_ASPECT);
-        ALIASENCHANTMENTS.put("meleeflame", Enchantment.FIRE_ASPECT);
-        ALIASENCHANTMENTS.put("fa", Enchantment.FIRE_ASPECT);
-
-        ENCHANTMENTS.put("knockback", Enchantment.KNOCKBACK);
-        ALIASENCHANTMENTS.put("kback", Enchantment.KNOCKBACK);
-        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);
-
-        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("oxygen", Enchantment.OXYGEN);
-        ENCHANTMENTS.put("respiration", Enchantment.OXYGEN);
-        ALIASENCHANTMENTS.put("breathing", Enchantment.OXYGEN);
-        ENCHANTMENTS.put("breath", Enchantment.OXYGEN);
-        ALIASENCHANTMENTS.put("o", Enchantment.OXYGEN);
-
-        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("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);
-
-        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("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);
-
-        ENCHANTMENTS.put("projectileprotection", Enchantment.PROTECTION_PROJECTILE);
-        ENCHANTMENTS.put("projprot", Enchantment.PROTECTION_PROJECTILE);
-        ALIASENCHANTMENTS.put("pp", Enchantment.PROTECTION_PROJECTILE);
-
-        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);
-
-        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("arrowdamage", Enchantment.ARROW_DAMAGE);
-        ENCHANTMENTS.put("power", Enchantment.ARROW_DAMAGE);
-        ALIASENCHANTMENTS.put("arrowpower", Enchantment.ARROW_DAMAGE);
-        ALIASENCHANTMENTS.put("ad", Enchantment.ARROW_DAMAGE);
-
-        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("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);
-
-        ENCHANTMENTS.put("luck", Enchantment.LUCK);
-        ALIASENCHANTMENTS.put("luckofsea", Enchantment.LUCK);
-        ALIASENCHANTMENTS.put("luckofseas", Enchantment.LUCK);
-        ALIASENCHANTMENTS.put("rodluck", Enchantment.LUCK);
-
-        ENCHANTMENTS.put("lure", Enchantment.LURE);
-        ALIASENCHANTMENTS.put("rodlure", Enchantment.LURE);
-
-        // 1.8
-        try {
-            Enchantment depthStrider = Enchantment.getByName("DEPTH_STRIDER");
-            if (depthStrider != null) {
-                ENCHANTMENTS.put("depthstrider", depthStrider);
-                ALIASENCHANTMENTS.put("depth", depthStrider);
-                ALIASENCHANTMENTS.put("strider", depthStrider);
-            }
-        } catch (IllegalArgumentException ignored) {}
-
-        // 1.9
-        try {
-            Enchantment frostWalker = Enchantment.getByName("FROST_WALKER");
-            if (frostWalker != null) {
-                ENCHANTMENTS.put("frostwalker", frostWalker);
-                ALIASENCHANTMENTS.put("frost", frostWalker);
-                ALIASENCHANTMENTS.put("walker", frostWalker);
-            }
-
-            Enchantment mending = Enchantment.getByName("MENDING");
-            if (mending != null) {
-                ENCHANTMENTS.put("mending", mending);
-            }
-        } catch (IllegalArgumentException ignored) {}
-
-        // 1.11
-        try {
-            Enchantment bindingCurse = Enchantment.getByName("BINDING_CURSE");
-            if (bindingCurse != null) {
-                ENCHANTMENTS.put("bindingcurse", bindingCurse);
-                ALIASENCHANTMENTS.put("bindcurse", bindingCurse);
-                ALIASENCHANTMENTS.put("binding", bindingCurse);
-                ALIASENCHANTMENTS.put("bind", bindingCurse);
-            }
-            Enchantment vanishingCurse = Enchantment.getByName("VANISHING_CURSE");
-            if (vanishingCurse != null) {
-                ENCHANTMENTS.put("vanishingcurse", vanishingCurse);
-                ALIASENCHANTMENTS.put("vanishcurse", vanishingCurse);
-                ALIASENCHANTMENTS.put("vanishing", vanishingCurse);
-                ALIASENCHANTMENTS.put("vanish", vanishingCurse);
-            }
-            Enchantment sweeping = Enchantment.getByName("SWEEPING_EDGE");
-            if (sweeping != null) {
-                ENCHANTMENTS.put("sweepingedge", sweeping);
-                ALIASENCHANTMENTS.put("sweepedge", sweeping);
-                ALIASENCHANTMENTS.put("sweeping", sweeping);
-            }
-        } catch (IllegalArgumentException ignored) {}
-
-
-        try { // 1.13
-            Enchantment loyalty = Enchantment.getByName("LOYALTY");
-            if (loyalty != null) {
-                ENCHANTMENTS.put("loyalty", loyalty);
-                ALIASENCHANTMENTS.put("loyal", loyalty);
-                ALIASENCHANTMENTS.put("return", loyalty);
-            }
-            Enchantment impaling = Enchantment.getByName("IMPALING");
-            if (impaling != null) {
-                ENCHANTMENTS.put("impaling", impaling);
-                ALIASENCHANTMENTS.put("impale", impaling);
-                ALIASENCHANTMENTS.put("oceandamage", impaling);
-                ALIASENCHANTMENTS.put("oceandmg", impaling);
-            }
-            Enchantment riptide = Enchantment.getByName("RIPTIDE");
-            if (riptide != null) {
-                ENCHANTMENTS.put("riptide", riptide);
-                ALIASENCHANTMENTS.put("rip", riptide);
-                ALIASENCHANTMENTS.put("tide", riptide);
-                ALIASENCHANTMENTS.put("launch", riptide);
-            }
-            Enchantment channelling = Enchantment.getByName("CHANNELING");
-            if (channelling != null) {
-                ENCHANTMENTS.put("channelling", channelling);
-                ALIASENCHANTMENTS.put("chanelling", channelling);
-                ALIASENCHANTMENTS.put("channeling", channelling);
-                ALIASENCHANTMENTS.put("chaneling", channelling);
-                ALIASENCHANTMENTS.put("channel", channelling);
-            }
-        } catch (IllegalArgumentException ignored) {}
-
-
-        try { // 1.14
-            Enchantment multishot = Enchantment.getByName("MULTISHOT");
-            if (multishot != null) {
-                ENCHANTMENTS.put("multishot", multishot);
-                ALIASENCHANTMENTS.put("tripleshot", multishot);
-            }
-            Enchantment quickCharge = Enchantment.getByName("QUICK_CHARGE");
-            if (quickCharge != null) {
-                ENCHANTMENTS.put("quickcharge", quickCharge);
-                ALIASENCHANTMENTS.put("quickdraw", quickCharge);
-                ALIASENCHANTMENTS.put("fastcharge", quickCharge);
-                ALIASENCHANTMENTS.put("fastdraw", quickCharge);
-            }
-            Enchantment piercing = Enchantment.getByName("PIERCING");
-            if (piercing != null) {
-                ENCHANTMENTS.put("piercing", piercing);
-            }
-        } catch (IllegalArgumentException ignored) {}
-
-        try {
-            Class<?> namespacedKeyClass = Class.forName("org.bukkit.NamespacedKey");
-            Class<?> enchantmentClass = Class.forName("org.bukkit.enchantments.Enchantment");
-            enchantmentClass.getDeclaredMethod("getByKey", namespacedKeyClass);
-            isFlat = true;
-        } catch (ClassNotFoundException | NoSuchMethodException e) {
-            isFlat = false;
-        }
-    }
-
-    public static Enchantment getByName(String name) {
-        Enchantment enchantment = null;
-        if (isFlat) { // 1.13+ only
-            enchantment = Enchantment.getByKey(NamespacedKey.minecraft(name.toLowerCase()));
-        }
-
-        if (enchantment == null) {
-            enchantment = Enchantment.getByName(name.toUpperCase());
-        }
-        if (enchantment == null) {
-            enchantment = ENCHANTMENTS.get(name.toLowerCase(Locale.ENGLISH));
-        }
-        if (enchantment == null) {
-            enchantment = ALIASENCHANTMENTS.get(name.toLowerCase(Locale.ENGLISH));
-        }
-        return enchantment;
-    }
-
-    public static Set<Entry<String, Enchantment>> entrySet() {
-        return ENCHANTMENTS.entrySet();
-    }
-
-    public static Set<String> keySet() {
-        return ENCHANTMENTS.keySet();
-    }
-}

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

@@ -1,964 +0,0 @@
-/*
- * Essentials - a bukkit plugin
- * Copyright (C) 2011  Essentials Team
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-package com.earth2me.essentials;
-
-import com.earth2me.essentials.commands.*;
-import com.earth2me.essentials.items.AbstractItemDb;
-import com.earth2me.essentials.items.FlatItemDb;
-import com.earth2me.essentials.items.LegacyItemDb;
-import com.earth2me.essentials.metrics.Metrics;
-import com.earth2me.essentials.perm.PermissionsHandler;
-import com.earth2me.essentials.register.payment.Methods;
-import com.earth2me.essentials.signs.SignBlockListener;
-import com.earth2me.essentials.signs.SignEntityListener;
-import com.earth2me.essentials.signs.SignPlayerListener;
-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.VersionUtil;
-import com.google.common.base.Function;
-import com.google.common.base.Throwables;
-import com.google.common.collect.Iterables;
-import net.ess3.api.*;
-import net.ess3.api.IEssentials;
-import net.ess3.api.ISettings;
-import net.ess3.nms.PotionMetaProvider;
-import net.ess3.nms.SpawnEggProvider;
-import net.ess3.nms.SpawnerProvider;
-import net.ess3.nms.flattened.FlatSpawnEggProvider;
-import net.ess3.nms.legacy.LegacyPotionMetaProvider;
-import net.ess3.nms.legacy.LegacySpawnEggProvider;
-import net.ess3.nms.legacy.LegacySpawnerProvider;
-import net.ess3.nms.refl.ReflSpawnEggProvider;
-import net.ess3.nms.updatedmeta.BasePotionDataProvider;
-import net.ess3.nms.updatedmeta.BlockMetaSpawnerProvider;
-import net.ess3.nms.v1_8_R1.v1_8_R1SpawnerProvider;
-import net.ess3.nms.v1_8_R2.v1_8_R2SpawnerProvider;
-import net.ess3.providers.ProviderFactory;
-import org.bukkit.Bukkit;
-import org.bukkit.Server;
-import org.bukkit.World;
-import org.bukkit.block.Block;
-import org.bukkit.command.*;
-import org.bukkit.entity.Player;
-import org.bukkit.event.EventHandler;
-import org.bukkit.event.EventPriority;
-import org.bukkit.event.HandlerList;
-import org.bukkit.event.Listener;
-import org.bukkit.event.player.PlayerJoinEvent;
-import org.bukkit.event.world.WorldLoadEvent;
-import org.bukkit.event.world.WorldUnloadEvent;
-import org.bukkit.permissions.Permission;
-import org.bukkit.permissions.PermissionDefault;
-import org.bukkit.plugin.InvalidDescriptionException;
-import org.bukkit.plugin.Plugin;
-import org.bukkit.plugin.PluginDescriptionFile;
-import org.bukkit.plugin.PluginManager;
-import org.bukkit.plugin.java.JavaPlugin;
-import org.bukkit.plugin.java.JavaPluginLoader;
-import org.bukkit.scheduler.BukkitScheduler;
-import org.bukkit.scheduler.BukkitTask;
-import org.yaml.snakeyaml.error.YAMLException;
-
-import java.io.File;
-import java.io.IOException;
-import java.lang.reflect.InvocationTargetException;
-import java.lang.reflect.Method;
-import java.util.*;
-import java.util.logging.Level;
-import java.util.logging.Logger;
-
-import static com.earth2me.essentials.I18n.tl;
-
-
-public class Essentials extends JavaPlugin implements net.ess3.api.IEssentials {
-    private static final Logger LOGGER = Logger.getLogger("Essentials");
-    private transient ISettings settings;
-    private final transient TNTExplodeListener tntListener = new TNTExplodeListener(this);
-    private transient Jails jails;
-    private transient Warps warps;
-    private transient Worth worth;
-    private transient List<IConf> confList;
-    private transient Backup backup;
-    private transient AbstractItemDb itemDb;
-    private transient final Methods paymentMethod = new Methods();
-    private transient PermissionsHandler permissionsHandler;
-    private transient AlternativeCommandsHandler alternativeCommandsHandler;
-    private transient UserMap userMap;
-    private transient ExecuteTimer execTimer;
-    private transient I18n i18n;
-    private transient Metrics metrics;
-    private transient EssentialsTimer timer;
-    private final transient Set<String> vanishedPlayers = new LinkedHashSet<>();
-    private transient Method oldGetOnlinePlayers;
-    private transient SpawnerProvider spawnerProvider;
-    private transient SpawnEggProvider spawnEggProvider;
-    private transient PotionMetaProvider potionMetaProvider;
-    private transient Kits kits;
-
-    public Essentials() {
-    }
-
-    public Essentials(final Server server) {
-        super(new JavaPluginLoader(server), new PluginDescriptionFile("Essentials", "", "com.earth2me.essentials.Essentials"), null, null);
-    }
-
-    @SuppressWarnings("unused")
-    public void forceLoadClasses() {
-        try {
-            Class.forName(OfflinePlayer.class.getName());
-        } catch (ClassNotFoundException e) {
-            e.printStackTrace();
-        }
-    }
-
-    @Override
-    public ISettings getSettings() {
-        return settings;
-    }
-
-    public void setupForTesting(final Server server) throws IOException, InvalidDescriptionException {
-        final File dataFolder = File.createTempFile("essentialstest", "");
-        if (!dataFolder.delete()) {
-            throw new IOException();
-        }
-        if (!dataFolder.mkdir()) {
-            throw new IOException();
-        }
-        i18n = new I18n(this);
-        i18n.onEnable();
-        i18n.updateLocale("en");
-        Console.setInstance(this);
-        
-        LOGGER.log(Level.INFO, tl("usingTempFolderForTesting"));
-        LOGGER.log(Level.INFO, dataFolder.toString());
-        settings = new Settings(this);
-        userMap = new UserMap(this);
-        permissionsHandler = new PermissionsHandler(this, false);
-        Economy.setEss(this);
-        confList = new ArrayList<>();
-        jails = new Jails(this);
-        registerListeners(server.getPluginManager());
-        kits = new Kits(this);
-    }
-
-    @Override
-    public void onEnable() {
-        try {
-            if (LOGGER != this.getLogger()) {
-                LOGGER.setParent(this.getLogger());
-            }
-            execTimer = new ExecuteTimer();
-            execTimer.start();
-            i18n = new I18n(this);
-            i18n.onEnable();
-            execTimer.mark("I18n1");
-            
-            Console.setInstance(this);
-
-            if (!VersionUtil.isServerSupported()) {
-                getLogger().severe(tl("serverUnsupported"));
-            }
-
-            final PluginManager pm = getServer().getPluginManager();
-            for (Plugin plugin : pm.getPlugins()) {
-                if (plugin.getDescription().getName().startsWith("Essentials") && !plugin.getDescription().getVersion().equals(this.getDescription().getVersion()) && !plugin.getDescription().getName().equals("EssentialsAntiCheat")) {
-                    getLogger().warning(tl("versionMismatch", plugin.getDescription().getName()));
-                }
-            }
-
-            for (Method method : Server.class.getDeclaredMethods()) {
-                if (method.getName().endsWith("getOnlinePlayers") && method.getReturnType() == Player[].class) {
-                    oldGetOnlinePlayers = method;
-                    break;
-                }
-            }
-
-            forceLoadClasses();
-
-            try {
-                final EssentialsUpgrade upgrade = new EssentialsUpgrade(this);
-                upgrade.beforeSettings();
-                execTimer.mark("Upgrade");
-
-                confList = new ArrayList<>();
-                settings = new Settings(this);
-                confList.add(settings);
-                execTimer.mark("Settings");
-
-                userMap = new UserMap(this);
-                confList.add(userMap);
-                execTimer.mark("Init(Usermap)");
-
-                kits = new Kits(this);
-                confList.add(kits);
-                upgrade.convertKits();
-                execTimer.mark("Kits");
-
-                upgrade.afterSettings();
-                execTimer.mark("Upgrade2");
-
-                warps = new Warps(getServer(), this.getDataFolder());
-                confList.add(warps);
-                execTimer.mark("Init(Spawn/Warp)");
-
-                worth = new Worth(this.getDataFolder());
-                confList.add(worth);
-                itemDb = getItemDbFromConfig();
-                confList.add(itemDb);
-                execTimer.mark("Init(Worth/ItemDB)");
-
-                jails = new Jails(this);
-                confList.add(jails);
-                execTimer.mark("Init(Jails)");
-
-                spawnerProvider = new ProviderFactory<>(getLogger(),
-                        Arrays.asList(
-                                BlockMetaSpawnerProvider.class,
-                                v1_8_R2SpawnerProvider.class,
-                                v1_8_R1SpawnerProvider.class,
-                                LegacySpawnerProvider.class
-                        ), "mob spawner").getProvider();
-                spawnEggProvider = new ProviderFactory<>(getLogger(),
-                        Arrays.asList(
-                                FlatSpawnEggProvider.class,
-                                ReflSpawnEggProvider.class,
-                                LegacySpawnEggProvider.class
-                        ), "spawn egg").getProvider();
-                potionMetaProvider = new ProviderFactory<>(getLogger(),
-                        Arrays.asList(
-                                BasePotionDataProvider.class,
-                                LegacyPotionMetaProvider.class
-                        ), "potion meta").getProvider();
-                execTimer.mark("Init(Providers)");
-                reload();
-
-                // The item spawn blacklist is loaded with all other settings, before the item
-                // DB, but it depends on the item DB, so we need to reload it again here:
-                ((Settings) settings)._lateLoadItemSpawnBlacklist();
-            } catch (YAMLException exception) {
-                if (pm.getPlugin("EssentialsUpdate") != null) {
-                    LOGGER.log(Level.SEVERE, tl("essentialsHelp2"));
-                } else {
-                    LOGGER.log(Level.SEVERE, tl("essentialsHelp1"));
-                }
-                handleCrash(exception);
-                return;
-            }
-            backup = new Backup(this);
-            permissionsHandler = new PermissionsHandler(this, settings.useBukkitPermissions());
-            alternativeCommandsHandler = new AlternativeCommandsHandler(this);
-
-            timer = new EssentialsTimer(this);
-            scheduleSyncRepeatingTask(timer, 1000, 50);
-
-            Economy.setEss(this);
-            execTimer.mark("RegHandler");
-
-            for (World w : Bukkit.getWorlds())
-                addDefaultBackPermissionsToWorld(w);
-
-            metrics = new Metrics(this);
-            if (metrics.isEnabled()) {
-                getLogger().info("Starting Metrics. Opt-out using the global bStats config.");
-            } else {
-                getLogger().info("Metrics disabled per bStats config.");
-            }
-
-            final String timeroutput = execTimer.end();
-            if (getSettings().isDebug()) {
-                LOGGER.log(Level.INFO, "Essentials load {0}", timeroutput);
-            }
-        } catch (NumberFormatException ex) {
-            handleCrash(ex);
-        } catch (Error ex) {
-            handleCrash(ex);
-            throw ex;
-        }
-    }
-
-    @Override
-    public void saveConfig() {
-        // We don't use any of the bukkit config writing, as this breaks our config file formatting.
-    }
-
-    private void registerListeners(PluginManager pm) {
-        HandlerList.unregisterAll(this);
-
-        if (getSettings().isDebug()) {
-            LOGGER.log(Level.INFO, "Registering Listeners");
-        }
-
-        final EssentialsPluginListener pluginListener = new EssentialsPluginListener(this);
-        pm.registerEvents(pluginListener, this);
-        confList.add(pluginListener);
-
-        final EssentialsPlayerListener playerListener = new EssentialsPlayerListener(this);
-        playerListener.registerEvents();
-
-        final EssentialsBlockListener blockListener = new EssentialsBlockListener(this);
-        pm.registerEvents(blockListener, this);
-
-        final SignBlockListener signBlockListener = new SignBlockListener(this);
-        pm.registerEvents(signBlockListener, this);
-
-        final SignPlayerListener signPlayerListener = new SignPlayerListener(this);
-        pm.registerEvents(signPlayerListener, this);
-
-        final SignEntityListener signEntityListener = new SignEntityListener(this);
-        pm.registerEvents(signEntityListener, this);
-
-        final EssentialsEntityListener entityListener = new EssentialsEntityListener(this);
-        pm.registerEvents(entityListener, this);
-
-        final EssentialsWorldListener worldListener = new EssentialsWorldListener(this);
-        pm.registerEvents(worldListener, this);
-
-        final EssentialsServerListener serverListener = new EssentialsServerListener(this);
-        pm.registerEvents(serverListener, this);
-
-        pm.registerEvents(tntListener, this);
-
-        jails.resetListener();
-    }
-
-    @Override
-    public void onDisable() {
-        for (User user : getOnlineUsers()) {
-            if (user.isVanished()) {
-                user.setVanished(false);
-                user.sendMessage(tl("unvanishedReload"));
-            }
-            user.stopTransaction();
-        }
-        cleanupOpenInventories();
-        if (i18n != null) {
-            i18n.onDisable();
-        }
-        if (backup != null) {
-            backup.stopTask();
-        }
-        Economy.setEss(null);
-        Trade.closeLog();
-        getUserMap().getUUIDMap().shutdown();
-
-        HandlerList.unregisterAll(this);
-    }
-
-    @Override
-    public void reload() {
-        Trade.closeLog();
-
-        for (IConf iConf : confList) {
-            iConf.reloadConfig();
-            execTimer.mark("Reload(" + iConf.getClass().getSimpleName() + ")");
-        }
-
-        i18n.updateLocale(settings.getLocale());
-
-        final PluginManager pm = getServer().getPluginManager();
-        registerListeners(pm);
-    }
-
-    @Override
-    public List<String> onTabComplete(CommandSender sender, Command command, String commandLabel, String[] args) {
-        return onTabCompleteEssentials(sender, command, commandLabel, args, Essentials.class.getClassLoader(),
-            "com.earth2me.essentials.commands.Command", "essentials.", null);
-    }
-
-    @Override
-    public List<String> onTabCompleteEssentials(final CommandSender cSender, final Command command, final String commandLabel, final String[] args,
-                                                final ClassLoader classLoader, final String commandPath, final String permissionPrefix,
-                                                final IEssentialsModule module) {
-        if (!getSettings().isCommandOverridden(command.getName()) && (!commandLabel.startsWith("e") || commandLabel.equalsIgnoreCase(command.getName()))) {
-            final PluginCommand pc = alternativeCommandsHandler.getAlternative(commandLabel);
-            if (pc != null) {
-                try {
-                    TabCompleter completer = pc.getTabCompleter();
-                    if (completer != null) {
-                        return completer.onTabComplete(cSender, command, commandLabel, args);
-                    }
-                } catch (final Exception ex) {
-                    Bukkit.getLogger().log(Level.SEVERE, ex.getMessage(), ex);
-                }
-            }
-        }
-
-        try {
-            // Note: The tab completer is always a player, even when tab-completing in a command block
-            User user = null;
-            if (cSender instanceof Player) {
-                user = getUser((Player) cSender);
-            }
-
-            CommandSource sender = new CommandSource(cSender);
-
-            // Check for disabled commands
-            if (getSettings().isCommandDisabled(commandLabel)) {
-                return Collections.emptyList();
-            }
-
-            IEssentialsCommand cmd;
-            try {
-                cmd = (IEssentialsCommand) classLoader.loadClass(commandPath + command.getName()).newInstance();
-                cmd.setEssentials(this);
-                cmd.setEssentialsModule(module);
-            } catch (Exception ex) {
-                sender.sendMessage(tl("commandNotLoaded", commandLabel));
-                LOGGER.log(Level.SEVERE, tl("commandNotLoaded", commandLabel), ex);
-                return Collections.emptyList();
-            }
-
-            // Check authorization
-            if (user != null && !user.isAuthorized(cmd, permissionPrefix)) {
-                return Collections.emptyList();
-            }
-
-            if (user != null && user.isJailed() && !user.isAuthorized(cmd, "essentials.jail.allow.")) {
-                return Collections.emptyList();
-            }
-
-            // Run the command
-            try {
-                if (user == null) {
-                    return cmd.tabComplete(getServer(), sender, commandLabel, command, args);
-                } else {
-                    return cmd.tabComplete(getServer(), user, commandLabel, command, args);
-                }
-            } catch (Exception ex) {
-                showError(sender, ex, commandLabel);
-                // Tab completion shouldn't fail
-                LOGGER.log(Level.SEVERE, tl("commandFailed", commandLabel), ex);
-                return Collections.emptyList();
-            }
-        } catch (Throwable ex) {
-            LOGGER.log(Level.SEVERE, tl("commandFailed", commandLabel), ex);
-            return Collections.emptyList();
-        }
-    }
-
-    @Override
-    public boolean onCommand(final CommandSender sender, final Command command, final String commandLabel, final String[] args) {
-        return onCommandEssentials(sender, command, commandLabel, args, Essentials.class.getClassLoader(), "com.earth2me.essentials.commands.Command", "essentials.", null);
-    }
-
-    @Override
-    public boolean onCommandEssentials(final CommandSender cSender, final Command command, final String commandLabel, final String[] args, final ClassLoader classLoader, final String commandPath, final String permissionPrefix, final IEssentialsModule module) {
-        // Allow plugins to override the command via onCommand
-        if (!getSettings().isCommandOverridden(command.getName()) && (!commandLabel.startsWith("e") || commandLabel.equalsIgnoreCase(command.getName()))) {
-            final PluginCommand pc = alternativeCommandsHandler.getAlternative(commandLabel);
-            if (pc != null) {
-                alternativeCommandsHandler.executed(commandLabel, pc);
-                try {
-                    return pc.execute(cSender, commandLabel, args);
-                } catch (final Exception ex) {
-                    Bukkit.getLogger().log(Level.SEVERE, ex.getMessage(), ex);
-                    cSender.sendMessage(tl("internalError"));
-                    return true;
-                }
-            }
-        }
-
-        try {
-
-            User user = null;
-            Block bSenderBlock = null;
-            if (cSender instanceof Player) {
-                user = getUser((Player) cSender);
-            } else if (cSender instanceof BlockCommandSender) {
-                BlockCommandSender bsender = (BlockCommandSender) cSender;
-                bSenderBlock = bsender.getBlock();
-            }
-
-            if (bSenderBlock != null) {
-                Bukkit.getLogger().log(Level.INFO, "CommandBlock at {0},{1},{2} issued server command: /{3} {4}", new Object[]{bSenderBlock.getX(), bSenderBlock.getY(), bSenderBlock.getZ(), commandLabel, EssentialsCommand.getFinalArg(args, 0)});
-            } else if (user == null) {
-                Bukkit.getLogger().log(Level.INFO, "{0} issued server command: /{1} {2}", new Object[]{cSender.getName(), commandLabel, EssentialsCommand.getFinalArg(args, 0)});
-            }
-
-            CommandSource sender = new CommandSource(cSender);
-
-            // New mail notification
-            if (user != null && !getSettings().isCommandDisabled("mail") && !command.getName().equals("mail") && user.isAuthorized("essentials.mail")) {
-                user.notifyOfMail();
-            }
-
-            //Print version even if admin command is not available #easteregg
-            if (commandLabel.equalsIgnoreCase("essversion")) {
-                sender.sendMessage("This server is running Essentials " + getDescription().getVersion());
-                return true;
-            }
-
-            // Check for disabled commands
-            if (getSettings().isCommandDisabled(commandLabel)) {
-                return true;
-            }
-
-            IEssentialsCommand cmd;
-            try {
-                cmd = (IEssentialsCommand) classLoader.loadClass(commandPath + command.getName()).newInstance();
-                cmd.setEssentials(this);
-                cmd.setEssentialsModule(module);
-            } catch (Exception ex) {
-                sender.sendMessage(tl("commandNotLoaded", commandLabel));
-                LOGGER.log(Level.SEVERE, tl("commandNotLoaded", commandLabel), ex);
-                return true;
-            }
-
-            // Check authorization
-            if (user != null && !user.isAuthorized(cmd, permissionPrefix)) {
-                LOGGER.log(Level.INFO, tl("deniedAccessCommand", user.getName()));
-                user.sendMessage(tl("noAccessCommand"));
-                return true;
-            }
-
-            if (user != null && user.isJailed() && !user.isAuthorized(cmd, "essentials.jail.allow.")) {
-                if (user.getJailTimeout() > 0) {
-                    user.sendMessage(tl("playerJailedFor", user.getName(), DateUtil.formatDateDiff(user.getJailTimeout())));
-                } else {
-                    user.sendMessage(tl("jailMessage"));
-                }
-                return true;
-            }
-
-            // Run the command
-            try {
-                if (user == null) {
-                    cmd.run(getServer(), sender, commandLabel, command, args);
-                } else {
-                    cmd.run(getServer(), user, commandLabel, command, args);
-                }
-                return true;
-            } catch (NoChargeException ex) {
-                return true;
-            } catch (QuietAbortException ex) {
-                return true;
-            } catch (NotEnoughArgumentsException ex) {
-                sender.sendMessage(command.getDescription());
-                sender.sendMessage(command.getUsage().replaceAll("<command>", commandLabel));
-                if (!ex.getMessage().isEmpty()) {
-                    sender.sendMessage(ex.getMessage());
-                }
-                return true;
-            } catch (Exception ex) {
-                showError(sender, ex, commandLabel);
-                if (settings.isDebug()) {
-                    ex.printStackTrace();
-                }
-                return true;
-            }
-        } catch (Throwable ex) {
-            LOGGER.log(Level.SEVERE, tl("commandFailed", commandLabel), ex);
-            return true;
-        }
-    }
-
-    public void cleanupOpenInventories() {
-        for (User user : getOnlineUsers()) {
-            if (user.isRecipeSee()) {
-                user.getBase().getOpenInventory().getTopInventory().clear();
-                user.getBase().getOpenInventory().close();
-                user.setRecipeSee(false);
-            }
-            if (user.isInvSee() || user.isEnderSee()) {
-                user.getBase().getOpenInventory().close();
-                user.setInvSee(false);
-                user.setEnderSee(false);
-            }
-        }
-    }
-
-    @Override
-    public void showError(final CommandSource sender, final Throwable exception, final String commandLabel) {
-        sender.sendMessage(tl("errorWithMessage", exception.getMessage()));
-        if (getSettings().isDebug()) {
-            LOGGER.log(Level.INFO, tl("errorCallingCommand", commandLabel), exception);
-        }
-    }
-
-    @Override
-    public BukkitScheduler getScheduler() {
-        return this.getServer().getScheduler();
-    }
-
-    @Override
-    public IJails getJails() {
-        return jails;
-    }
-
-    @Override
-    public Warps getWarps() {
-        return warps;
-    }
-
-    @Override
-    public Worth getWorth() {
-        return worth;
-    }
-
-    @Override
-    public Backup getBackup() {
-        return backup;
-    }
-
-    @Override
-    public Kits getKits() {
-        return kits;
-    }
-
-    @Override
-    public Metrics getMetrics() {
-        return metrics;
-    }
-
-    @Override
-    public void setMetrics(Metrics metrics) {
-        this.metrics = metrics;
-    }
-
-    @Deprecated
-    @Override
-    public User getUser(final Object base) {
-        if (base instanceof Player) {
-            return getUser((Player) base);
-        }
-        if (base instanceof org.bukkit.OfflinePlayer) {
-            return getUser(((org.bukkit.OfflinePlayer) base).getUniqueId());
-        }
-        if (base instanceof UUID) {
-            return getUser((UUID) base);
-        }
-        if (base instanceof String) {
-            return getOfflineUser((String) base);
-        }
-        return null;
-    }
-
-    //This will return null if there is not a match.
-    @Override
-    public User getUser(final String base) {
-        return getOfflineUser(base);
-    }
-
-    //This will return null if there is not a match.
-    @Override
-    public User getUser(final UUID base) {
-        return userMap.getUser(base);
-    }
-
-    //This will return null if there is not a match.
-    @Override
-    public User getOfflineUser(final String name) {
-        final User user = userMap.getUser(name);
-        if (user != null && user.getBase() instanceof OfflinePlayer) {
-            //This code should attempt to use the last known name of a user, if Bukkit returns name as null.
-            final String lastName = user.getLastAccountName();
-            if (lastName != null) {
-                ((OfflinePlayer) user.getBase()).setName(lastName);
-            } else {
-                ((OfflinePlayer) user.getBase()).setName(name);
-            }
-        }
-        return user;
-    }
-
-    //This will create a new user if there is not a match.
-    @Override
-    public User getUser(final Player base) {
-        if (base == null) {
-            return null;
-        }
-
-        if (userMap == null) {
-            LOGGER.log(Level.WARNING, "Essentials userMap not initialized");
-            return null;
-        }
-
-        User user = userMap.getUser(base.getUniqueId());
-
-        if (user == null) {
-            if (getSettings().isDebug()) {
-                LOGGER.log(Level.INFO, "Constructing new userfile from base player {0}", base.getName());
-            }
-            user = new User(base, this);
-        } else {
-            user.update(base);
-        }
-        return user;
-    }
-
-    private void handleCrash(Throwable exception) {
-        final PluginManager pm = getServer().getPluginManager();
-        LOGGER.log(Level.SEVERE, exception.toString());
-        exception.printStackTrace();
-        pm.registerEvents(new Listener() {
-            @EventHandler(priority = EventPriority.LOW)
-            public void onPlayerJoin(final PlayerJoinEvent event) {
-                event.getPlayer().sendMessage("Essentials failed to load, read the log file.");
-            }
-        }, this);
-        for (Player player : getOnlinePlayers()) {
-            player.sendMessage("Essentials failed to load, read the log file.");
-        }
-        this.setEnabled(false);
-    }
-
-    @Override
-    public World getWorld(final String name) {
-        if (name.matches("[0-9]+")) {
-            final int worldId = Integer.parseInt(name);
-            if (worldId < getServer().getWorlds().size()) {
-                return getServer().getWorlds().get(worldId);
-            }
-        }
-        return getServer().getWorld(name);
-    }
-
-    @Override
-    public void addReloadListener(final IConf listener) {
-        confList.add(listener);
-    }
-
-    @Override
-    public Methods getPaymentMethod() {
-        return paymentMethod;
-    }
-
-    @Override
-    public int broadcastMessage(final String message) {
-        return broadcastMessage(null, null, message, true);
-    }
-
-    @Override
-    public int broadcastMessage(final IUser sender, final String message) {
-        return broadcastMessage(sender, null, message, false);
-    }
-
-    @Override
-    public int broadcastMessage(final String permission, final String message) {
-        return broadcastMessage(null, permission, message, false);
-    }
-
-    private int broadcastMessage(final IUser sender, final String permission, final String message, final boolean keywords) {
-        if (sender != null && sender.isHidden()) {
-            return 0;
-        }
-
-        IText broadcast = new SimpleTextInput(message);
-
-        final Collection<Player> players = getOnlinePlayers();
-
-        for (Player player : players) {
-            final User user = getUser(player);
-            if ((permission == null && (sender == null || !user.isIgnoredPlayer(sender))) || (permission != null && user.isAuthorized(permission))) {
-                if (keywords) {
-                    broadcast = new KeywordReplacer(broadcast, new CommandSource(player), this, false);
-                }
-                for (String messageText : broadcast.getLines()) {
-                    user.sendMessage(messageText);
-                }
-            }
-        }
-
-        return players.size();
-    }
-
-    @Override
-    public BukkitTask runTaskAsynchronously(final Runnable run) {
-        return this.getScheduler().runTaskAsynchronously(this, run);
-    }
-
-    @Override
-    public BukkitTask runTaskLaterAsynchronously(final Runnable run, final long delay) {
-        return this.getScheduler().runTaskLaterAsynchronously(this, run, delay);
-    }
-
-    @Override
-    public BukkitTask runTaskTimerAsynchronously(final Runnable run, final long delay, final long period) {
-        return this.getScheduler().runTaskTimerAsynchronously(this, run, delay, period);
-    }
-
-    @Override
-    public int scheduleSyncDelayedTask(final Runnable run) {
-        return this.getScheduler().scheduleSyncDelayedTask(this, run);
-    }
-
-    @Override
-    public int scheduleSyncDelayedTask(final Runnable run, final long delay) {
-        return this.getScheduler().scheduleSyncDelayedTask(this, run, delay);
-    }
-
-    @Override
-    public int scheduleSyncRepeatingTask(final Runnable run, final long delay, final long period) {
-        return this.getScheduler().scheduleSyncRepeatingTask(this, run, delay, period);
-    }
-
-    @Override
-    public TNTExplodeListener getTNTListener() {
-        return tntListener;
-    }
-
-    @Override
-    public PermissionsHandler getPermissionsHandler() {
-        return permissionsHandler;
-    }
-
-    @Override
-    public AlternativeCommandsHandler getAlternativeCommandsHandler() {
-        return alternativeCommandsHandler;
-    }
-
-    @Override
-    public IItemDb getItemDb() {
-        return itemDb;
-    }
-
-    @Override
-    public UserMap getUserMap() {
-        return userMap;
-    }
-
-    @Override
-    public I18n getI18n() {
-        return i18n;
-    }
-
-    @Override
-    public EssentialsTimer getTimer() {
-        return timer;
-    }
-
-    @Override
-    public List<String> getVanishedPlayers() {
-        return Collections.unmodifiableList(new ArrayList<>(vanishedPlayers));
-    }
-
-    @Override
-    public Collection<String> getVanishedPlayersNew() {
-        return vanishedPlayers;
-    }
-
-    @Override
-    public Collection<Player> getOnlinePlayers() {
-        try {
-            return (Collection<Player>) getServer().getOnlinePlayers(); // Needed for sanity here, the Bukkit API is a bit broken in the sense it only allows subclasses of Player to this list
-        } catch (NoSuchMethodError ex) {
-            try {
-                return Arrays.asList((Player[]) oldGetOnlinePlayers.invoke(getServer()));
-            } catch (InvocationTargetException ex1) {
-                throw Throwables.propagate(ex.getCause());
-            } catch (IllegalAccessException ex1) {
-                throw new RuntimeException("Error invoking oldGetOnlinePlayers", ex1);
-            }
-        }
-    }
-
-    @Override
-    public Iterable<User> getOnlineUsers() {
-        return Iterables.transform(getOnlinePlayers(), new Function<Player, User>() {
-
-            @Override
-            public User apply(Player player) {
-                return getUser(player);
-            }
-        });
-    }
-
-    @Override
-    public SpawnerProvider getSpawnerProvider() {
-        return spawnerProvider;
-    }
-
-    @Override
-    public SpawnEggProvider getSpawnEggProvider() {
-        return spawnEggProvider;
-    }
-
-    @Override
-    public PotionMetaProvider getPotionMetaProvider() {
-        return potionMetaProvider;
-    }
-
-    private static void addDefaultBackPermissionsToWorld(World w) {
-        String permName = "essentials.back.into." + w.getName();
-
-        Permission p = Bukkit.getPluginManager().getPermission(permName);
-        if (p == null) {
-            p = new Permission(permName,
-                    "Allows access to /back when the destination location is within world " + w.getName(),
-                    PermissionDefault.TRUE);
-            Bukkit.getPluginManager().addPermission(p);
-        }
-    }
-
-    private static class EssentialsWorldListener implements Listener, Runnable {
-        private transient final IEssentials ess;
-
-        public EssentialsWorldListener(final IEssentials ess) {
-            this.ess = ess;
-        }
-
-        @EventHandler(priority = EventPriority.LOW)
-        public void onWorldLoad(final WorldLoadEvent event) {
-            addDefaultBackPermissionsToWorld(event.getWorld());
-
-            ess.getJails().onReload();
-            ess.getWarps().reloadConfig();
-            for (IConf iConf : ((Essentials) ess).confList) {
-                if (iConf instanceof IEssentialsModule) {
-                    iConf.reloadConfig();
-                }
-            }
-        }
-
-        @EventHandler(priority = EventPriority.LOW)
-        public void onWorldUnload(final WorldUnloadEvent event) {
-            ess.getJails().onReload();
-            ess.getWarps().reloadConfig();
-            for (IConf iConf : ((Essentials) ess).confList) {
-                if (iConf instanceof IEssentialsModule) {
-                    iConf.reloadConfig();
-                }
-            }
-        }
-
-        @Override
-        public void run() {
-            ess.reload();
-        }
-    }
-
-    private AbstractItemDb getItemDbFromConfig() {
-        final String setting = settings.getItemDbType();
-
-        if (setting.equalsIgnoreCase("json")) {
-            return new FlatItemDb(this);
-        } else if (setting.equalsIgnoreCase("csv")) {
-            return new LegacyItemDb(this);
-        } else {
-            VersionUtil.BukkitVersion version = VersionUtil.getServerBukkitVersion();
-
-            if (version.isHigherThanOrEqualTo(VersionUtil.v1_13_0_R01)) {
-                return new FlatItemDb(this);
-            } else {
-                return new LegacyItemDb(this);
-            }
-        }
-    }
-}

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

@@ -1,661 +0,0 @@
-package com.earth2me.essentials;
-
-import com.google.common.io.Files;
-import net.ess3.api.InvalidWorldException;
-import org.bukkit.*;
-import org.bukkit.OfflinePlayer;
-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.*;
-import java.math.BigDecimal;
-import java.math.MathContext;
-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.util.*;
-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 final File configFile;
-    protected String templateName = null;
-    protected static final Charset UTF8 = Charset.forName("UTF-8");
-    private Class<?> resourceClass = EssentialsConf.class;
-    private static final ExecutorService EXECUTOR_SERVICE = Executors.newSingleThreadExecutor();
-    private final AtomicInteger pendingDiskWrites = new AtomicInteger(0);
-    private final AtomicBoolean transaction = new AtomicBoolean(false);
-
-    public EssentialsConf(final File configFile) {
-        super();
-        this.configFile = configFile.getAbsoluteFile();
-    }
-
-    private final byte[] bytebuffer = new byte[1024];
-
-    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 (IOException ex) {
-                    LOGGER.log(Level.SEVERE, null, ex);
-                } finally {
-                    try {
-                        input.close();
-                    } catch (IOException ex) {
-                        LOGGER.log(Level.SEVERE, null, ex);
-                    }
-                }
-            } catch (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 (FileInputStream inputStream = new FileInputStream(configFile)) {
-                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()) {
-                        ByteBuffer resize = ByteBuffer.allocate(buffer.capacity() + length - buffer.remaining());
-                        int resizePosition = buffer.position();
-                        buffer.rewind();
-                        resize.put(buffer);
-                        resize.position(resizePosition);
-                        buffer = resize;
-                    }
-                    buffer.put(bytebuffer, 0, length);
-                }
-                buffer.rewind();
-                final CharBuffer data = CharBuffer.allocate(buffer.capacity());
-                CharsetDecoder decoder = UTF8.newDecoder();
-                CoderResult result = decoder.decode(buffer, data, true);
-                if (result.isError()) {
-                    buffer.rewind();
-                    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();
-                data.rewind();
-                super.loadFromString(data.subSequence(0, end).toString());
-            }
-        } catch (IOException ex) {
-            LOGGER.log(Level.SEVERE, ex.getMessage(), ex);
-        } catch (InvalidConfigurationException ex) {
-            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);
-            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 (IOException ex) {
-            LOGGER.log(Level.SEVERE, tl("failedToWriteConfig", configFile.toString()), ex);
-        } finally {
-            try {
-                if (istr != null) {
-                    istr.close();
-                }
-            } catch (IOException ex) {
-                Logger.getLogger(EssentialsConf.class.getName()).log(Level.SEVERE, null, ex);
-            }
-            try {
-                if (ostr != null) {
-                    ostr.close();
-                }
-            } catch (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 (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 {
-            Future<?> future = delayedSave(configFile);
-            if (future != null) {
-                future.get();
-            }
-        } catch (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));
-    }
-
-
-    private static 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 (IOException ex) {
-                            LOGGER.log(Level.SEVERE, tl("failedToCreateConfig", configFile.toString()), ex);
-                            return;
-                        }
-                    }
-
-                    try (FileOutputStream fos = new FileOutputStream(configFile)) {
-                        try (OutputStreamWriter writer = new OutputStreamWriter(fos, UTF8)) {
-                            writer.write(data);
-                        }
-                    }
-                } catch (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();
-                }
-            }
-        }
-    }
-
-    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 (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());
-        Map<Enchantment, Integer> enchantments = stack.getEnchantments();
-        if (!enchantments.isEmpty()) {
-            Map<String, Integer> enchant = new HashMap<>();
-            for (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(String path, List object) {
-        set(path, new ArrayList(object));
-    }
-
-    public void setProperty(String path, Map object) {
-        set(path, new LinkedHashMap(object));
-    }
-
-    public Object getProperty(String path) {
-        return get(path);
-    }
-
-    public void setProperty(final String path, final BigDecimal bigDecimal) {
-        set(path, bigDecimal.toString());
-    }
-
-    public void setProperty(String path, Object object) {
-        set(path, object);
-    }
-
-    public void removeProperty(String path) {
-        set(path, null);
-    }
-
-    @Override
-    public synchronized Object get(String path) {
-        return super.get(path);
-    }
-
-    @Override
-    public synchronized Object get(String path, 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);
-    }
-
-    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 (NumberFormatException e) {
-                return def;
-            } catch (ArithmeticException e) {
-                return def;
-            }
-        }
-    }
-
-    @Override
-    public synchronized boolean getBoolean(String path) {
-        return super.getBoolean(path);
-    }
-
-    @Override
-    public synchronized boolean getBoolean(String path, boolean def) {
-        return super.getBoolean(path, def);
-    }
-
-    @Override
-    public synchronized List<Boolean> getBooleanList(String path) {
-        return super.getBooleanList(path);
-    }
-
-    @Override
-    public synchronized List<Byte> getByteList(String path) {
-        return super.getByteList(path);
-    }
-
-    @Override
-    public synchronized List<Character> getCharacterList(String path) {
-        return super.getCharacterList(path);
-    }
-
-    @Override
-    public synchronized ConfigurationSection getConfigurationSection(String path) {
-        return super.getConfigurationSection(path);
-    }
-
-    @Override
-    public synchronized double getDouble(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(String path) {
-        return super.getDoubleList(path);
-    }
-
-    @Override
-    public synchronized List<Float> getFloatList(String path) {
-        return super.getFloatList(path);
-    }
-
-    @Override
-    public synchronized int getInt(String path) {
-        return super.getInt(path);
-    }
-
-    @Override
-    public synchronized int getInt(String path, int def) {
-        return super.getInt(path, def);
-    }
-
-    @Override
-    public synchronized List<Integer> getIntegerList(String path) {
-        return super.getIntegerList(path);
-    }
-
-    @Override
-    public synchronized ItemStack getItemStack(String path, ItemStack def) {
-        return super.getItemStack(path, def);
-    }
-
-    @Override
-    public synchronized Set<String> getKeys(boolean deep) {
-        return super.getKeys(deep);
-    }
-
-    @Override
-    public synchronized List<?> getList(String path) {
-        return super.getList(path);
-    }
-
-    @Override
-    public synchronized List<?> getList(String path, List<?> def) {
-        return super.getList(path, def);
-    }
-
-    @Override
-    public synchronized long getLong(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(String path) {
-        return super.getLongList(path);
-    }
-
-    public synchronized Map<String, Object> getMap() {
-        return map;
-    }
-
-    @Override
-    public synchronized List<Map<?, ?>> getMapList(String path) {
-        return super.getMapList(path);
-    }
-
-    @Override
-    public synchronized OfflinePlayer getOfflinePlayer(String path) {
-        return super.getOfflinePlayer(path);
-    }
-
-    @Override
-    public synchronized OfflinePlayer getOfflinePlayer(String path, OfflinePlayer def) {
-        return super.getOfflinePlayer(path, def);
-    }
-
-    @Override
-    public synchronized List<Short> getShortList(String path) {
-        return super.getShortList(path);
-    }
-
-    @Override
-    public synchronized String getString(String path) {
-        return super.getString(path);
-    }
-
-    @Override
-    public synchronized String getString(String path, String def) {
-        return super.getString(path, def);
-    }
-
-    @Override
-    public synchronized List<String> getStringList(String path) {
-        return super.getStringList(path);
-    }
-
-    @Override
-    public synchronized Map<String, Object> getValues(boolean deep) {
-        return super.getValues(deep);
-    }
-
-    @Override
-    public synchronized Vector getVector(String path) {
-        return super.getVector(path);
-    }
-
-    @Override
-    public synchronized Vector getVector(String path, Vector def) {
-        return super.getVector(path, def);
-    }
-
-    @Override
-    public synchronized boolean isBoolean(String path) {
-        return super.isBoolean(path);
-    }
-
-    @Override
-    public synchronized boolean isConfigurationSection(String path) {
-        return super.isConfigurationSection(path);
-    }
-
-    @Override
-    public synchronized boolean isDouble(String path) {
-        return super.isDouble(path);
-    }
-
-    @Override
-    public synchronized boolean isInt(String path) {
-        return super.isInt(path);
-    }
-
-    @Override
-    public synchronized boolean isItemStack(String path) {
-        return super.isItemStack(path);
-    }
-
-    @Override
-    public synchronized boolean isList(String path) {
-        return super.isList(path);
-    }
-
-    @Override
-    public synchronized boolean isLong(String path) {
-        return super.isLong(path);
-    }
-
-    @Override
-    public synchronized boolean isOfflinePlayer(String path) {
-        return super.isOfflinePlayer(path);
-    }
-
-    @Override
-    public synchronized boolean isSet(String path) {
-        return super.isSet(path);
-    }
-
-    @Override
-    public synchronized boolean isString(String path) {
-        return super.isString(path);
-    }
-
-    @Override
-    public synchronized boolean isVector(String path) {
-        return super.isVector(path);
-    }
-
-    @Override
-    public synchronized void set(String path, Object value) {
-        super.set(path, value);
-    }
-}

Essentials/src/com/earth2me/essentials/EssentialsPlayerListener.java

@@ -1,875 +0,0 @@
-package com.earth2me.essentials;
-
-import com.earth2me.essentials.textreader.IText;
-import com.earth2me.essentials.textreader.KeywordReplacer;
-import com.earth2me.essentials.textreader.TextInput;
-import com.earth2me.essentials.textreader.TextPager;
-import com.earth2me.essentials.utils.DateUtil;
-import com.earth2me.essentials.utils.LocationUtil;
-import com.earth2me.essentials.utils.MaterialUtil;
-import io.papermc.lib.PaperLib;
-import net.ess3.api.IEssentials;
-import org.bukkit.*;
-import org.bukkit.command.PluginCommand;
-import org.bukkit.entity.HumanEntity;
-import org.bukkit.entity.Player;
-import org.bukkit.event.EventHandler;
-import org.bukkit.event.EventPriority;
-import org.bukkit.event.Listener;
-import org.bukkit.event.inventory.ClickType;
-import org.bukkit.event.inventory.InventoryClickEvent;
-import org.bukkit.event.inventory.InventoryCloseEvent;
-import org.bukkit.event.inventory.InventoryType;
-import org.bukkit.event.player.*;
-import org.bukkit.event.player.PlayerLoginEvent.Result;
-import org.bukkit.event.player.PlayerTeleportEvent.TeleportCause;
-import org.bukkit.inventory.Inventory;
-import org.bukkit.inventory.InventoryHolder;
-import org.bukkit.inventory.ItemStack;
-import org.bukkit.inventory.PlayerInventory;
-
-import java.io.IOException;
-import java.text.NumberFormat;
-import java.util.*;
-import java.util.Map.Entry;
-import java.util.logging.Level;
-import java.util.logging.Logger;
-import java.util.regex.Pattern;
-
-import static com.earth2me.essentials.I18n.tl;
-
-
-public class EssentialsPlayerListener implements Listener {
-    private static final Logger LOGGER = Logger.getLogger("Essentials");
-    private final transient IEssentials ess;
-
-    public EssentialsPlayerListener(final IEssentials parent) {
-        this.ess = parent;
-    }
-
-    public void registerEvents() {
-        ess.getServer().getPluginManager().registerEvents(this, ess);
-
-        if (isEntityPickupEvent()) {
-            ess.getServer().getPluginManager().registerEvents(new PickupListener1_12(), ess);
-        } else {
-            ess.getServer().getPluginManager().registerEvents(new PickupListenerPre1_12(), ess);
-        }
-
-        if (isCommandSendEvent()) {
-            ess.getServer().getPluginManager().registerEvents(new CommandSendListener(), ess);
-        }
-    }
-
-    @EventHandler(priority = EventPriority.NORMAL)
-    public void onPlayerRespawn(final PlayerRespawnEvent event) {
-        final User user = ess.getUser(event.getPlayer());
-        updateCompass(user);
-        user.setDisplayNick();
-
-        if (ess.getSettings().isTeleportInvulnerability()) {
-            user.enableInvulnerabilityAfterTeleport();
-        }
-    }
-
-    @EventHandler(priority = EventPriority.LOWEST)
-    public void onPlayerChat(final AsyncPlayerChatEvent event) {
-        final User user = ess.getUser(event.getPlayer());
-        if (user.isMuted()) {
-            event.setCancelled(true);
-
-            user.sendMessage(user.hasMuteReason() ? tl("voiceSilencedReason", user.getMuteReason()) : tl("voiceSilenced"));
-
-            LOGGER.info(tl("mutedUserSpeaks", user.getName(), event.getMessage()));
-        }
-        try {
-            final Iterator<Player> it = event.getRecipients().iterator();
-            while (it.hasNext()) {
-                final User u = ess.getUser(it.next());
-                if (u.isIgnoredPlayer(user)) {
-                    it.remove();
-                }
-            }
-        } catch (UnsupportedOperationException ex) {
-            if (ess.getSettings().isDebug()) {
-                ess.getLogger().log(Level.INFO, "Ignore could not block chat due to custom chat plugin event.", ex);
-            } else {
-                ess.getLogger().info("Ignore could not block chat due to custom chat plugin event.");
-            }
-        }
-
-        user.updateActivityOnInteract(true);
-        user.setDisplayNick();
-    }
-
-    @EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
-    public void onPlayerMove(final PlayerMoveEvent event) {
-        if (event.getFrom().getBlockX() == event.getTo().getBlockX() && event.getFrom().getBlockZ() == event.getTo().getBlockZ() && event.getFrom().getBlockY() == event.getTo().getBlockY()) {
-            return;
-        }
-
-        if (!ess.getSettings().cancelAfkOnMove() && !ess.getSettings().getFreezeAfkPlayers()) {
-            event.getHandlers().unregister(this);
-
-            if (ess.getSettings().isDebug()) {
-                LOGGER.log(Level.INFO, "Unregistering move listener");
-            }
-
-            return;
-        }
-
-        final User user = ess.getUser(event.getPlayer());
-        if (user.isAfk() && ess.getSettings().getFreezeAfkPlayers()) {
-            final Location from = event.getFrom();
-            final Location origTo = event.getTo();
-            final Location to = origTo.clone();
-            if (origTo.getY() >= from.getBlockY() + 1) {
-                user.updateActivityOnMove(true);
-                return;
-            }
-            to.setX(from.getX());
-            to.setY(from.getY());
-            to.setZ(from.getZ());
-            try {
-                event.setTo(LocationUtil.getSafeDestination(to));
-            } catch (Exception ex) {
-                event.setTo(to);
-            }
-            return;
-        }
-        final Location afk = user.getAfkPosition();
-        if (afk == null || !event.getTo().getWorld().equals(afk.getWorld()) || afk.distanceSquared(event.getTo()) > 9) {
-            user.updateActivityOnMove(true);
-        }
-    }
-
-    @EventHandler(priority = EventPriority.HIGHEST)
-    public void onPlayerQuit(final PlayerQuitEvent event) {
-        final User user = ess.getUser(event.getPlayer());
-
-        if (ess.getSettings().allowSilentJoinQuit() && user.isAuthorized("essentials.silentquit")) {
-            event.setQuitMessage(null);
-        } else if (ess.getSettings().isCustomQuitMessage() && event.getQuitMessage() != null) {
-            final Player player = event.getPlayer();
-            final String msg = ess.getSettings().getCustomQuitMessage()
-                    .replace("{PLAYER}", player.getDisplayName())
-                    .replace("{USERNAME}", player.getName())
-                    .replace("{ONLINE}", NumberFormat.getInstance().format(ess.getOnlinePlayers().size()));
-            
-            event.setQuitMessage(msg.isEmpty() ? null : msg);
-        }
-
-        user.startTransaction();
-        if (ess.getSettings().removeGodOnDisconnect() && user.isGodModeEnabled()) {
-            user.setGodModeEnabled(false);
-        }
-        if (user.isVanished()) {
-            user.setVanished(false);
-        }
-        user.setLogoutLocation();
-        if (user.isRecipeSee()) {
-            user.getBase().getOpenInventory().getTopInventory().clear();
-        }
-
-        for (HumanEntity viewer : user.getBase().getInventory().getViewers()) {
-            if (viewer instanceof Player) {
-                User uviewer = ess.getUser((Player) viewer);
-                if (uviewer.isInvSee()) {
-                    uviewer.getBase().closeInventory();
-                }
-            }
-        }
-
-        user.updateActivity(false);
-        if (!user.isHidden()) {
-            user.setLastLogout(System.currentTimeMillis());
-        }
-        user.stopTransaction();
-
-        user.dispose();
-    }
-
-    @EventHandler(priority = EventPriority.HIGHEST)
-    public void onPlayerJoin(final PlayerJoinEvent event) {
-        final String joinMessage = event.getJoinMessage();
-        ess.runTaskAsynchronously(new Runnable() {
-            @Override
-            public void run() {
-                delayedJoin(event.getPlayer(), joinMessage);
-            }
-        });
-        if (ess.getSettings().allowSilentJoinQuit() || ess.getSettings().isCustomJoinMessage()) {
-            event.setJoinMessage(null);
-        }
-    }
-
-    public void delayedJoin(final Player player, final String message) {
-        if (!player.isOnline()) {
-            return;
-        }
-
-        ess.getBackup().onPlayerJoin();
-        final User dUser = ess.getUser(player);
-
-        dUser.startTransaction();
-        if (dUser.isNPC()) {
-            dUser.setNPC(false);
-        }
-
-        final long currentTime = System.currentTimeMillis();
-        dUser.checkMuteTimeout(currentTime);
-        dUser.updateActivity(false);
-        dUser.stopTransaction();
-
-        class DelayJoinTask implements Runnable {
-            @Override
-            public void run() {
-                final User user = ess.getUser(player);
-
-                if (!user.getBase().isOnline()) {
-                    return;
-                }
-
-                user.startTransaction();
-
-                user.setLastAccountName(user.getBase().getName());
-                user.setLastLogin(currentTime);
-                user.setDisplayNick();
-                updateCompass(user);
-
-                if (!ess.getVanishedPlayersNew().isEmpty() && !user.isAuthorized("essentials.vanish.see")) {
-                    for (String p : ess.getVanishedPlayersNew()) {
-                        Player toVanish = ess.getServer().getPlayerExact(p);
-                        if (toVanish != null && toVanish.isOnline()) {
-                            user.getBase().hidePlayer(toVanish);
-                            if (ess.getSettings().isDebug()) {
-                                ess.getLogger().info("Hiding vanished player: " + p);
-                            }
-                        }
-                    }
-                }
-
-                if (user.isAuthorized("essentials.sleepingignored")) {
-                    user.getBase().setSleepingIgnored(true);
-                }
-
-                if (ess.getSettings().allowSilentJoinQuit() && (user.isAuthorized("essentials.silentjoin") || user.isAuthorized("essentials.silentjoin.vanish"))) {
-                    if (user.isAuthorized("essentials.silentjoin.vanish")) {
-                        user.setVanished(true);
-                    }
-                } else if (message == null) {
-                    //NOOP
-                } else if (ess.getSettings().isCustomJoinMessage()) {
-                    String msg = ess.getSettings().getCustomJoinMessage()
-                        .replace("{PLAYER}", player.getDisplayName()).replace("{USERNAME}", player.getName())
-                        .replace("{UNIQUE}", NumberFormat.getInstance().format(ess.getUserMap().getUniqueUsers()))
-                        .replace("{ONLINE}", NumberFormat.getInstance().format(ess.getOnlinePlayers().size()));
-                    if (!msg.isEmpty()) {
-                        ess.getServer().broadcastMessage(msg);
-                    }
-                } else if (ess.getSettings().allowSilentJoinQuit()) {
-                    ess.getServer().broadcastMessage(message);
-                }
-
-                int motdDelay = ess.getSettings().getMotdDelay() / 50;
-                DelayMotdTask motdTask = new DelayMotdTask(user);
-                if (motdDelay > 0) {
-                    ess.scheduleSyncDelayedTask(motdTask, motdDelay);
-                } else {
-                    motdTask.run();
-                }
-
-                if (!ess.getSettings().isCommandDisabled("mail") && user.isAuthorized("essentials.mail")) {
-                    final List<String> mail = user.getMails();
-                    if (mail.isEmpty()) {
-                        if (ess.getSettings().isNotifyNoNewMail()) {
-                            user.sendMessage(tl("noNewMail")); // Only notify if they want us to.
-                        }
-                    } else {
-                        user.notifyOfMail();
-                    }
-                }
-
-                if (user.isAuthorized("essentials.fly.safelogin")) {
-                    user.getBase().setFallDistance(0);
-                    if (LocationUtil.shouldFly(user.getLocation())) {
-                        user.getBase().setAllowFlight(true);
-                        user.getBase().setFlying(true);
-                        if (ess.getSettings().isSendFlyEnableOnJoin()) {
-                            user.getBase().sendMessage(tl("flyMode", tl("enabled"), user.getDisplayName()));
-                        }
-                    }
-                }
-
-                if (!user.isAuthorized("essentials.speed")) {
-                    user.getBase().setFlySpeed(0.1f);
-                    user.getBase().setWalkSpeed(0.2f);
-                }
-
-                if (user.isSocialSpyEnabled() && !user.isAuthorized("essentials.socialspy")) {
-                    user.setSocialSpyEnabled(false);
-                    ess.getLogger().log(Level.INFO, "Set socialspy to false for {0} because they had it enabled without permission.", user.getName());
-                }
-
-                if (user.isGodModeEnabled() && !user.isAuthorized("essentials.god")) {
-                    user.setGodModeEnabled(false);
-                    ess.getLogger().log(Level.INFO, "Set god mode to false for {0} because they had it enabled without permission.", user.getName());
-                }
-                
-                user.setConfirmingClearCommand(null);
-                user.getConfirmingPayments().clear();
-
-                user.stopTransaction();
-            }
-
-            class DelayMotdTask implements Runnable {
-                private User user;
-
-                public DelayMotdTask(User user) {
-                    this.user = user;
-                }
-
-                @Override
-                public void run() {
-                    IText tempInput = null;
-
-                    if (!ess.getSettings().isCommandDisabled("motd")) {
-                        try {
-                            tempInput = new TextInput(user.getSource(), "motd", true, ess);
-                        } catch (IOException ex) {
-                            if (ess.getSettings().isDebug()) {
-                                LOGGER.log(Level.WARNING, ex.getMessage(), ex);
-                            } else {
-                                LOGGER.log(Level.WARNING, ex.getMessage());
-                            }
-                        }
-                    }
-
-                    final IText input = tempInput;
-
-                    if (input != null && !input.getLines().isEmpty() && user.isAuthorized("essentials.motd")) {
-                        final IText output = new KeywordReplacer(input, user.getSource(), ess);
-                        final TextPager pager = new TextPager(output, true);
-                        pager.showPage("1", null, "motd", user.getSource());
-                    }
-                }
-            }
-        }
-
-        ess.scheduleSyncDelayedTask(new DelayJoinTask());
-    }
-
-    // Makes the compass item ingame always point to the first essentials home.  #EasterEgg
-    // EssentialsX: This can now optionally require a permission to enable, if set in the config.
-    private void updateCompass(final User user) {
-        if (ess.getSettings().isCompassTowardsHomePerm() && !user.isAuthorized("essentials.home.compass")) return;
-
-        Location loc = user.getHome(user.getLocation());
-        if (loc == null) {
-            loc = user.getBase().getBedSpawnLocation();
-        }
-        if (loc != null) {
-            user.getBase().setCompassTarget(loc);
-        }
-    }
-
-    @EventHandler(priority = EventPriority.LOW)
-    public void onPlayerLoginBanned(final PlayerLoginEvent event) {
-        switch (event.getResult()) {
-            case KICK_BANNED:
-                BanEntry banEntry = ess.getServer().getBanList(BanList.Type.NAME).getBanEntry(event.getPlayer().getName());
-                if (banEntry != null) {
-                    Date banExpiry = banEntry.getExpiration();
-                    if (banExpiry != null) {
-                        String expiry = DateUtil.formatDateDiff(banExpiry.getTime());
-                        event.setKickMessage(tl("tempbanJoin", expiry, banEntry.getReason()));
-                    } else {
-                        event.setKickMessage(tl("banJoin", banEntry.getReason()));
-                    }
-                } else {
-                    banEntry = ess.getServer().getBanList(BanList.Type.IP).getBanEntry(event.getAddress().getHostAddress());
-                    if (banEntry != null) {
-                        event.setKickMessage(tl("banIpJoin", banEntry.getReason()));
-                    }
-                }
-                break;
-            default:
-                break;
-        }
-    }
-
-    @EventHandler(priority = EventPriority.HIGH)
-    public void onPlayerLogin(final PlayerLoginEvent event) {
-        switch (event.getResult()) {
-            case KICK_FULL:
-                final User kfuser = ess.getUser(event.getPlayer());
-                if (kfuser.isAuthorized("essentials.joinfullserver")) {
-                    event.allow();
-                    return;
-                }
-                event.disallow(Result.KICK_FULL, tl("serverFull"));
-                break;
-            default:
-                break;
-        }
-    }
-
-    @EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
-    public void onPlayerTeleport(final PlayerTeleportEvent event) {
-        final boolean backListener = ess.getSettings().registerBackInListener();
-        final boolean teleportInvulnerability = ess.getSettings().isTeleportInvulnerability();
-        if (backListener || teleportInvulnerability) {
-            final User user = ess.getUser(event.getPlayer());
-            //There is TeleportCause.COMMMAND but plugins have to actively pass the cause in on their teleports.
-            if (backListener && (event.getCause() == TeleportCause.PLUGIN || event.getCause() == TeleportCause.COMMAND)) {
-                user.setLastLocation();
-            }
-            if (teleportInvulnerability && (event.getCause() == TeleportCause.PLUGIN || event.getCause() == TeleportCause.COMMAND)) {
-                user.enableInvulnerabilityAfterTeleport();
-            }
-        }
-    }
-
-    @EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
-    public void onPlayerEggThrow(final PlayerEggThrowEvent event) {
-        final User user = ess.getUser(event.getPlayer());
-        final ItemStack stack = new ItemStack(Material.EGG, 1);
-        if (user.hasUnlimited(stack)) {
-            user.getBase().getInventory().addItem(stack);
-            user.getBase().updateInventory();
-        }
-    }
-
-    @EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
-    public void onPlayerBucketEmpty(final PlayerBucketEmptyEvent event) {
-        final User user = ess.getUser(event.getPlayer());
-        if (user.hasUnlimited(new ItemStack(event.getBucket()))) {
-            event.getItemStack().setType(event.getBucket());
-            ess.scheduleSyncDelayedTask(new Runnable() {
-                @Override
-                public void run() {
-                    user.getBase().updateInventory();
-                }
-            });
-        }
-    }
-
-    @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
-    public void onPlayerCommandPreprocess(final PlayerCommandPreprocessEvent event) {
-        final Player player = event.getPlayer();
-        final String cmd = event.getMessage().toLowerCase(Locale.ENGLISH).split(" ")[0].replace("/", "").toLowerCase(Locale.ENGLISH);
-
-        PluginCommand pluginCommand = ess.getServer().getPluginCommand(cmd);
-
-        if (ess.getSettings().getSocialSpyCommands().contains(cmd) || ess.getSettings().getSocialSpyCommands().contains("*")) {
-            if (pluginCommand == null
-                    || (!pluginCommand.getName().equals("msg") && !pluginCommand.getName().equals("r"))) { // /msg and /r are handled in SimpleMessageRecipient
-                User user = ess.getUser(player);
-                if (!user.isAuthorized("essentials.chat.spy.exempt")) {
-                    for (User spyer : ess.getOnlineUsers()) {
-                        if (spyer.isSocialSpyEnabled() && !player.equals(spyer.getBase())) {
-                            if (user.isMuted() && ess.getSettings().getSocialSpyListenMutedPlayers()) {
-                                spyer.sendMessage(tl("socialSpyMutedPrefix") + player.getDisplayName() + ": " + event.getMessage());
-                            } else {
-                                spyer.sendMessage(tl("socialSpyPrefix") + player.getDisplayName() + ": " + event.getMessage());
-                            }
-                        }
-                    }
-                }
-            }
-        }
-
-        if (ess.getUser(player).isMuted() && (ess.getSettings().getMuteCommands().contains(cmd) || ess.getSettings().getMuteCommands().contains("*"))) {
-            event.setCancelled(true);
-            player.sendMessage(tl("voiceSilenced"));
-            LOGGER.info(tl("mutedUserSpeaks", player.getName(), event.getMessage()));
-            return;
-        }
-        
-        boolean broadcast = true; // whether to broadcast the updated activity
-        boolean update = true; // Only modified when the command is afk
-
-        if (pluginCommand != null) {
-            // Switch case for commands that shouldn't broadcast afk activity.
-            switch (pluginCommand.getName()) {
-                case "afk":
-                    update = false;
-                case "vanish":
-                    broadcast = false;
-            }
-        }
-        final User user = ess.getUser(player);
-        if (update) {
-            user.updateActivityOnInteract(broadcast);
-        }
-
-        if (ess.getSettings().isCommandCooldownsEnabled() && pluginCommand != null
-            && !user.isAuthorized("essentials.commandcooldowns.bypass")) {
-            int argStartIndex = event.getMessage().indexOf(" ");
-            String args = argStartIndex == -1 ? "" // No arguments present 
-                : " " + event.getMessage().substring(argStartIndex); // arguments start at argStartIndex; substring from there.
-            String fullCommand = pluginCommand.getName() + args;
-
-            // Used to determine whether a user already has an existing cooldown
-            // If so, no need to check for (and write) new ones.
-            boolean cooldownFound = false;
-            
-            // Iterate over a copy of getCommandCooldowns in case of concurrent modifications
-            for (Entry<Pattern, Long> entry : new HashMap<>(user.getCommandCooldowns()).entrySet()) {
-                // Remove any expired cooldowns
-                if (entry.getValue() <= System.currentTimeMillis()) {
-                    user.clearCommandCooldown(entry.getKey());
-                    // Don't break in case there are other command cooldowns left to clear.
-                } else if (entry.getKey().matcher(fullCommand).matches()) {
-                    // User's current cooldown hasn't expired, inform and terminate cooldown code.
-                    if (entry.getValue() > System.currentTimeMillis()) {
-                        String commandCooldownTime = DateUtil.formatDateDiff(entry.getValue());
-                        user.sendMessage(tl("commandCooldown", commandCooldownTime));
-                        cooldownFound = true;
-                        event.setCancelled(true);
-                        break;
-                    }
-                }
-            }
-
-            if (!cooldownFound) {
-                Entry<Pattern, Long> cooldownEntry = ess.getSettings().getCommandCooldownEntry(fullCommand);
-
-                if (cooldownEntry != null) {
-                    if (ess.getSettings().isDebug()) {
-                        ess.getLogger().info("Applying " + cooldownEntry.getValue() + "ms cooldown on /" + fullCommand + " for" + user.getName() + ".");
-                    }
-                    Date expiry = new Date(System.currentTimeMillis() + cooldownEntry.getValue());
-                    user.addCommandCooldown(cooldownEntry.getKey(), expiry, ess.getSettings().isCommandCooldownPersistent(fullCommand));
-                }
-            }
-        }
-    }
-
-    @EventHandler(priority = EventPriority.NORMAL)
-    public void onPlayerChangedWorldFlyReset(final PlayerChangedWorldEvent event) {
-        final User user = ess.getUser(event.getPlayer());
-        if (user.getBase().getGameMode() != GameMode.CREATIVE
-                // COMPAT: String compare for 1.7.10
-            && !user.getBase().getGameMode().name().equals("SPECTATOR")
-            && !user.isAuthorized("essentials.fly")) {
-            user.getBase().setFallDistance(0f);
-            user.getBase().setAllowFlight(false);
-        }
-        if (!user.isAuthorized("essentials.speed")) {
-            user.getBase().setFlySpeed(0.1f);
-            user.getBase().setWalkSpeed(0.2f);
-        } else {
-            if (user.getBase().getFlySpeed() > ess.getSettings().getMaxFlySpeed() && !user.isAuthorized("essentials.speed.bypass")) {
-                user.getBase().setFlySpeed((float) ess.getSettings().getMaxFlySpeed());
-            } else {
-                user.getBase().setFlySpeed(user.getBase().getFlySpeed() * 0.99999f);
-            }
-
-            if (user.getBase().getWalkSpeed() > ess.getSettings().getMaxWalkSpeed() && !user.isAuthorized("essentials.speed.bypass")) {
-                user.getBase().setWalkSpeed((float) ess.getSettings().getMaxWalkSpeed());
-            } else {
-                user.getBase().setWalkSpeed(user.getBase().getWalkSpeed() * 0.99999f);
-            }
-        }
-    }
-
-    @EventHandler(priority = EventPriority.MONITOR)
-    public void onPlayerChangedWorld(final PlayerChangedWorldEvent event) {
-        final User user = ess.getUser(event.getPlayer());
-        final String newWorld = event.getPlayer().getLocation().getWorld().getName();
-        user.setDisplayNick();
-        updateCompass(user);
-        if (ess.getSettings().getNoGodWorlds().contains(newWorld) && user.isGodModeEnabledRaw()) {
-            // Player god mode is never disabled in order to retain it when changing worlds once more.
-            // With that said, players will still take damage as per the result of User#isGodModeEnabled()
-            user.sendMessage(tl("noGodWorldWarning"));
-        }
-
-        if (!user.getWorld().getName().equals(newWorld)) {
-            user.sendMessage(tl("currentWorld", newWorld));
-        }
-        if (user.isVanished()) {
-            user.setVanished(user.isAuthorized("essentials.vanish"));
-        }
-    }
-
-    @EventHandler(priority = EventPriority.NORMAL)
-    public void onPlayerInteract(final PlayerInteractEvent event) {
-        boolean updateActivity = true;
-
-        switch (event.getAction()) {
-            case RIGHT_CLICK_BLOCK:
-                if (!event.isCancelled() && MaterialUtil.isBed(event.getClickedBlock().getType()) && ess.getSettings().getUpdateBedAtDaytime()) {
-                    User player = ess.getUser(event.getPlayer());
-                    if (player.isAuthorized("essentials.sethome.bed") && player.getWorld().getEnvironment().equals(World.Environment.NORMAL)) {
-                        player.getBase().setBedSpawnLocation(event.getClickedBlock().getLocation());
-                        player.sendMessage(tl("bedSet", player.getLocation().getWorld().getName(), player.getLocation().getBlockX(), player.getLocation().getBlockY(), player.getLocation().getBlockZ()));
-                    }
-                }
-                break;
-            case LEFT_CLICK_AIR:
-                if (event.getPlayer().isFlying()) {
-                    final User user = ess.getUser(event.getPlayer());
-                    if (user.isFlyClickJump()) {
-                        useFlyClickJump(user);
-                        break;
-                    }
-                }
-            case LEFT_CLICK_BLOCK:
-                if (event.getItem() != null && event.getItem().getType() != Material.AIR) {
-                    final User user = ess.getUser(event.getPlayer());
-                    if (user.hasPowerTools() && user.arePowerToolsEnabled() && usePowertools(user, event.getItem().getType())) {
-                        event.setCancelled(true);
-                    }
-                }
-                break;
-            case PHYSICAL:
-                updateActivity = false;
-                break;
-        }
-
-        if (updateActivity) {
-            ess.getUser(event.getPlayer()).updateActivityOnInteract(true);
-        }
-    }
-
-    // This method allows the /jump lock feature to work, allows teleporting while flying #EasterEgg
-    private void useFlyClickJump(final User user) {
-        try {
-            final Location otarget = LocationUtil.getTarget(user.getBase());
-
-            class DelayedClickJumpTask implements Runnable {
-                @Override
-                public void run() {
-                    Location loc = user.getLocation();
-                    loc.setX(otarget.getX());
-                    loc.setZ(otarget.getZ());
-                    while (LocationUtil.isBlockDamaging(loc.getWorld(), loc.getBlockX(), loc.getBlockY() - 1, loc.getBlockZ())) {
-                        loc.setY(loc.getY() + 1d);
-                    }
-                    PaperLib.teleportAsync(user.getBase(), loc, TeleportCause.PLUGIN);
-                }
-            }
-            ess.scheduleSyncDelayedTask(new DelayedClickJumpTask());
-        } catch (Exception ex) {
-            if (ess.getSettings().isDebug()) {
-                LOGGER.log(Level.WARNING, ex.getMessage(), ex);
-            }
-        }
-    }
-
-    private boolean usePowertools(final User user, final Material material) {
-        final List<String> commandList = user.getPowertool(material);
-        if (commandList == null || commandList.isEmpty()) {
-            return false;
-        }
-        boolean used = false;
-        // We need to loop through each command and execute
-        for (final String command : commandList) {
-            if (command.contains("{player}")) {
-                continue;
-            } else if (command.startsWith("c:")) {
-                used = true;
-                user.getBase().chat(command.substring(2));
-            } else {
-                used = true;
-
-                class PowerToolUseTask implements Runnable {
-                    @Override
-                    public void run() {
-                        user.getBase().chat("/" + command);
-                        LOGGER.log(Level.INFO, String.format("[PT] %s issued server command: /%s", user.getName(), command));
-                    }
-                }
-                ess.scheduleSyncDelayedTask(new PowerToolUseTask());
-
-            }
-        }
-        return used;
-    }
-
-    @EventHandler(priority = EventPriority.LOWEST, ignoreCancelled = true)
-    public void onInventoryClickEvent(final InventoryClickEvent event) {
-        Player refreshPlayer = null;
-        final Inventory top = event.getView().getTopInventory();
-        final InventoryType type = top.getType();
-
-        final Inventory clickedInventory;
-        if (event.getRawSlot() < 0) {
-            clickedInventory = null;
-        } else {
-            clickedInventory = event.getRawSlot() < top.getSize() ? top : event.getView().getBottomInventory();
-        }
-
-        if (type == InventoryType.PLAYER) {
-            final User user = ess.getUser((Player) event.getWhoClicked());
-            final InventoryHolder invHolder = top.getHolder();
-            if (invHolder != null && invHolder instanceof HumanEntity) {
-                final User invOwner = ess.getUser((Player) invHolder);
-                if (user.isInvSee() && (!user.isAuthorized("essentials.invsee.modify") || invOwner.isAuthorized("essentials.invsee.preventmodify") || !invOwner.getBase().isOnline())) {
-                    event.setCancelled(true);
-                    refreshPlayer = user.getBase();
-                }
-            }
-        } else if (type == InventoryType.ENDER_CHEST) {
-            final User user = ess.getUser((Player) event.getWhoClicked());
-            if (user.isEnderSee() && (!user.isAuthorized("essentials.enderchest.modify"))) {
-                event.setCancelled(true);
-                refreshPlayer = user.getBase();
-            }
-        } else if (type == InventoryType.WORKBENCH) {
-            User user = ess.getUser((Player) event.getWhoClicked());
-            if (user.isRecipeSee()) {
-                event.setCancelled(true);
-                refreshPlayer = user.getBase();
-            }
-        } else if (type == InventoryType.CHEST && top.getSize() == 9) {
-            final User user = ess.getUser((Player) event.getWhoClicked());
-            final InventoryHolder invHolder = top.getHolder();
-            if (invHolder != null && invHolder instanceof HumanEntity && user.isInvSee()) {
-                event.setCancelled(true);
-                refreshPlayer = user.getBase();
-            }
-        } else if (clickedInventory != null && clickedInventory.getType() == InventoryType.PLAYER) {
-            if (ess.getSettings().isDirectHatAllowed() && event.getClick() == ClickType.LEFT && event.getSlot() == 39
-                && event.getCursor().getType() != Material.AIR && event.getCursor().getType().getMaxDurability() == 0
-                && !MaterialUtil.isSkull(event.getCursor().getType())
-                && ess.getUser(event.getWhoClicked()).isAuthorized("essentials.hat")) {
-                event.setCancelled(true);
-                final PlayerInventory inv = (PlayerInventory) clickedInventory;
-                final ItemStack head = inv.getHelmet();
-                inv.setHelmet(event.getCursor());
-                event.setCursor(head);
-            }
-        }
-
-        if (refreshPlayer != null) {
-            final Player player = refreshPlayer;
-            ess.scheduleSyncDelayedTask(new Runnable() {
-                @Override
-                public void run() {
-                    player.updateInventory();
-                }
-            }, 1);
-        }
-    }
-
-    @EventHandler(priority = EventPriority.MONITOR)
-    public void onInventoryCloseEvent(final InventoryCloseEvent event) {
-        Player refreshPlayer = null;
-        final Inventory top = event.getView().getTopInventory();
-        final InventoryType type = top.getType();
-        if (type == InventoryType.PLAYER) {
-            final User user = ess.getUser((Player) event.getPlayer());
-            user.setInvSee(false);
-            refreshPlayer = user.getBase();
-        } else if (type == InventoryType.ENDER_CHEST) {
-            final User user = ess.getUser((Player) event.getPlayer());
-            user.setEnderSee(false);
-            refreshPlayer = user.getBase();
-        } else if (type == InventoryType.WORKBENCH) {
-            final User user = ess.getUser((Player) event.getPlayer());
-            if (user.isRecipeSee()) {
-                user.setRecipeSee(false);
-                event.getView().getTopInventory().clear();
-                refreshPlayer = user.getBase();
-            }
-        } else if (type == InventoryType.CHEST && top.getSize() == 9) {
-            final InventoryHolder invHolder = top.getHolder();
-            if (invHolder != null && invHolder instanceof HumanEntity) {
-                final User user = ess.getUser((Player) event.getPlayer());
-                user.setInvSee(false);
-                refreshPlayer = user.getBase();
-            }
-        }
-
-        if (refreshPlayer != null) {
-            final Player player = refreshPlayer;
-            ess.scheduleSyncDelayedTask(new Runnable() {
-                @Override
-                public void run() {
-                    player.updateInventory();
-                }
-            }, 1);
-        }
-    }
-
-    @EventHandler(priority = EventPriority.LOW, ignoreCancelled = true)
-    public void onPlayerFishEvent(final PlayerFishEvent event) {
-        final User user = ess.getUser(event.getPlayer());
-            user.updateActivityOnInteract(true);
-    }
-
-    private static boolean isEntityPickupEvent() {
-        try {
-            Class.forName("org.bukkit.event.entity.EntityPickupItemEvent");
-            return true;
-        } catch (ClassNotFoundException ignored) {
-            return false;
-        }
-    }
-
-    private static boolean isCommandSendEvent() {
-        try {
-            Class.forName("org.bukkit.event.player.PlayerCommandSendEvent");
-            return true;
-        } catch (ClassNotFoundException ignored) {
-            return false;
-        }
-    }
-
-    private final class PickupListenerPre1_12 implements Listener {
-        @EventHandler(priority = EventPriority.LOW, ignoreCancelled = true)
-        public void onPlayerPickupItem(final org.bukkit.event.player.PlayerPickupItemEvent event) {
-            if (ess.getSettings().getDisableItemPickupWhileAfk()) {
-                if (ess.getUser(event.getPlayer()).isAfk()) {
-                    event.setCancelled(true);
-                }
-            }
-        }
-    }
-
-    private final class PickupListener1_12 implements Listener {
-        @EventHandler(priority = EventPriority.LOW, ignoreCancelled = true)
-        public void onPlayerPickupItem(final org.bukkit.event.entity.EntityPickupItemEvent event) {
-            if (ess.getSettings().getDisableItemPickupWhileAfk() && event.getEntity() instanceof Player) {
-                if (ess.getUser((Player) event.getEntity()).isAfk()) {
-                    event.setCancelled(true);
-                }
-            }
-        }
-    }
-
-    private final class CommandSendListener implements Listener {
-        @EventHandler(priority = EventPriority.NORMAL)
-        public void onCommandSend(final PlayerCommandSendEvent event) {
-            User user = ess.getUser(event.getPlayer());
-
-            ArrayList<String> removedCmds = new ArrayList<>(event.getCommands());
-
-            event.getCommands().removeIf(str -> shouldHideFromUser(str, user));
-
-            if (ess.getSettings().isDebug()) {
-                removedCmds.removeAll(event.getCommands());
-                ess.getLogger().info("Removed commands: " + removedCmds.toString());
-            }
-        }
-
-        /**
-         * Returns true if all of the following are true:
-         *   - The command is a plugin command
-         *   - The plugin command is from Essentials
-         *   - There is no known alternative OR the alternative is overridden by Essentials
-         *   - The user is not allowed to perform the given Essentials command
-         */
-        private boolean shouldHideFromUser(String commandLabel, User user) {
-            PluginCommand command = ess.getServer().getPluginCommand(commandLabel);
-
-            return command != null
-                && command.getPlugin().getName().equals("Essentials")
-                && (ess.getSettings().isCommandOverridden(commandLabel) || (ess.getAlternativeCommandsHandler().getAlternative(commandLabel) == null))
-                && !user.isAuthorized("essentials." + command.getName());
-        }
-    }
-}

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

@@ -1,722 +0,0 @@
-package com.earth2me.essentials;
-
-import com.earth2me.essentials.craftbukkit.BanLookup;
-import com.earth2me.essentials.craftbukkit.FakeWorld;
-import com.earth2me.essentials.settings.Spawns;
-import com.earth2me.essentials.storage.YamlStorageWriter;
-import com.earth2me.essentials.utils.StringUtil;
-import com.google.common.base.Charsets;
-import com.google.common.collect.Maps;
-import net.ess3.api.IEssentials;
-import org.bukkit.BanList;
-import org.bukkit.Bukkit;
-import org.bukkit.Location;
-import org.bukkit.World;
-import org.bukkit.configuration.ConfigurationSection;
-
-import java.io.*;
-import java.math.BigInteger;
-import java.security.DigestInputStream;
-import java.security.MessageDigest;
-import java.text.DecimalFormat;
-import java.util.*;
-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;
-
-
-public class EssentialsUpgrade {
-    private final static Logger LOGGER = Logger.getLogger("Essentials");
-    private final transient IEssentials ess;
-    private final transient EssentialsConf doneFile;
-
-    EssentialsUpgrade(final IEssentials essentials) {
-        ess = essentials;
-        if (!ess.getDataFolder().exists()) {
-            ess.getDataFolder().mkdirs();
-        }
-        doneFile = new EssentialsConf(new File(ess.getDataFolder(), "upgrades-done.yml"));
-        doneFile.load();
-    }
-
-    public void convertKits() {
-        Kits kits = ess.getKits();
-        EssentialsConf config = kits.getConfig();
-        if (doneFile.getBoolean("kitsyml", false)) {
-            return;
-        }
-
-        LOGGER.info("Attempting to convert old kits in config.yml to new kits.yml");
-
-        ConfigurationSection section = ess.getSettings().getKitSection();
-        if (section == null) {
-            LOGGER.info("No kits found to migrate.");
-            return;
-        }
-
-        Map<String, Object> legacyKits = ess.getSettings().getKitSection().getValues(true);
-
-        for (Map.Entry<String, Object> entry : legacyKits.entrySet()) {
-            LOGGER.info("Converting " + entry.getKey());
-            config.set("kits." + entry.getKey(), entry.getValue());
-        }
-
-        config.save();
-        doneFile.setProperty("kitsyml", true);
-        doneFile.save();
-        LOGGER.info("Done converting kits.");
-    }
-
-    private void moveMotdRulesToFile(String name) {
-        if (doneFile.getBoolean("move" + name + "ToFile", false)) {
-            return;
-        }
-        try {
-            final File file = new File(ess.getDataFolder(), name + ".txt");
-            if (file.exists()) {
-                return;
-            }
-            final File configFile = new File(ess.getDataFolder(), "config.yml");
-            if (!configFile.exists()) {
-                return;
-            }
-            final EssentialsConf conf = new EssentialsConf(configFile);
-            conf.load();
-            List<String> lines = conf.getStringList(name);
-            if (lines != null && !lines.isEmpty()) {
-                if (!file.createNewFile()) {
-                    throw new IOException("Failed to create file " + file);
-                }
-                PrintWriter writer = new PrintWriter(file);
-
-                for (String line : lines) {
-                    writer.println(line);
-                }
-                writer.close();
-            }
-            doneFile.setProperty("move" + name + "ToFile", true);
-            doneFile.save();
-        } catch (IOException e) {
-            LOGGER.log(Level.SEVERE, tl("upgradingFilesError"), e);
-        }
-    }
-
-    private void removeLinesFromConfig(File file, String regex, String info) throws Exception {
-        boolean needUpdate = false;
-        final BufferedReader bReader = new BufferedReader(new FileReader(file));
-        final File tempFile = File.createTempFile("essentialsupgrade", ".tmp.yml", ess.getDataFolder());
-        final BufferedWriter bWriter = new BufferedWriter(new FileWriter(tempFile));
-        do {
-            final String line = bReader.readLine();
-            if (line == null) {
-                break;
-            }
-            if (line.matches(regex)) {
-                if (!needUpdate && info != null) {
-                    bWriter.write(info, 0, info.length());
-                    bWriter.newLine();
-                }
-                needUpdate = true;
-            } else {
-                if (line.endsWith("\r\n")) {
-                    bWriter.write(line, 0, line.length() - 2);
-                } else if (line.endsWith("\r") || line.endsWith("\n")) {
-                    bWriter.write(line, 0, line.length() - 1);
-                } else {
-                    bWriter.write(line, 0, line.length());
-                }
-                bWriter.newLine();
-            }
-        } while (true);
-        bReader.close();
-        bWriter.close();
-        if (needUpdate) {
-            if (!file.renameTo(new File(file.getParentFile(), file.getName().concat("." + System.currentTimeMillis() + ".upgradebackup")))) {
-                throw new Exception(tl("configFileMoveError"));
-            }
-            if (!tempFile.renameTo(file)) {
-                throw new Exception(tl("configFileRenameError"));
-            }
-        } else {
-            tempFile.delete();
-        }
-    }
-
-    private void updateUsersPowerToolsFormat() {
-        if (doneFile.getBoolean("updateUsersPowerToolsFormat", false)) {
-            return;
-        }
-        final File userdataFolder = new File(ess.getDataFolder(), "userdata");
-        if (!userdataFolder.exists() || !userdataFolder.isDirectory()) {
-            return;
-        }
-        final File[] userFiles = userdataFolder.listFiles();
-
-        for (File file : userFiles) {
-            if (!file.isFile() || !file.getName().endsWith(".yml")) {
-                continue;
-            }
-            final EssentialsConf config = new EssentialsConf(file);
-            try {
-                config.load();
-                if (config.hasProperty("powertools")) {
-                    @SuppressWarnings("unchecked") final Map<String, Object> powertools = config.getConfigurationSection("powertools").getValues(false);
-                    if (powertools == null) {
-                        continue;
-                    }
-                    for (Map.Entry<String, Object> entry : powertools.entrySet()) {
-                        if (entry.getValue() instanceof String) {
-                            List<String> temp = new ArrayList<>();
-                            temp.add((String) entry.getValue());
-                            powertools.put(entry.getKey(), temp);
-                        }
-                    }
-                    config.forceSave();
-                }
-            } catch (RuntimeException ex) {
-                LOGGER.log(Level.INFO, "File: " + file.toString());
-                throw ex;
-            }
-        }
-        doneFile.setProperty("updateUsersPowerToolsFormat", true);
-        doneFile.save();
-    }
-
-    private void updateUsersHomesFormat() {
-        if (doneFile.getBoolean("updateUsersHomesFormat", false)) {
-            return;
-        }
-        final File userdataFolder = new File(ess.getDataFolder(), "userdata");
-        if (!userdataFolder.exists() || !userdataFolder.isDirectory()) {
-            return;
-        }
-        final File[] userFiles = userdataFolder.listFiles();
-
-        for (File file : userFiles) {
-            if (!file.isFile() || !file.getName().endsWith(".yml")) {
-                continue;
-            }
-            final EssentialsConf config = new EssentialsConf(file);
-            try {
-
-                config.load();
-                if (config.hasProperty("home") && config.hasProperty("home.default")) {
-                    @SuppressWarnings("unchecked") final String defworld = (String) config.getProperty("home.default");
-                    final Location defloc = getFakeLocation(config, "home.worlds." + defworld);
-                    if (defloc != null) {
-                        config.setProperty("homes.home", defloc);
-                    }
-
-                    Set<String> worlds = config.getConfigurationSection("home.worlds").getKeys(false);
-                    Location loc;
-                    String worldName;
-
-                    if (worlds == null) {
-                        continue;
-                    }
-                    for (String world : worlds) {
-                        if (defworld.equalsIgnoreCase(world)) {
-                            continue;
-                        }
-                        loc = getFakeLocation(config, "home.worlds." + world);
-                        if (loc == null) {
-                            continue;
-                        }
-                        worldName = loc.getWorld().getName().toLowerCase(Locale.ENGLISH);
-                        if (worldName != null && !worldName.isEmpty()) {
-                            config.setProperty("homes." + worldName, loc);
-                        }
-                    }
-                    config.removeProperty("home");
-                    config.forceSave();
-                }
-
-            } catch (RuntimeException ex) {
-                LOGGER.log(Level.INFO, "File: " + file.toString());
-                throw ex;
-            }
-        }
-        doneFile.setProperty("updateUsersHomesFormat", true);
-        doneFile.save();
-    }
-
-    private void sanitizeAllUserFilenames() {
-        if (doneFile.getBoolean("sanitizeAllUserFilenames", false)) {
-            return;
-        }
-        final File usersFolder = new File(ess.getDataFolder(), "userdata");
-        if (!usersFolder.exists()) {
-            return;
-        }
-        final File[] listOfFiles = usersFolder.listFiles();
-        for (File listOfFile : listOfFiles) {
-            final String filename = listOfFile.getName();
-            if (!listOfFile.isFile() || !filename.endsWith(".yml")) {
-                continue;
-            }
-            final String sanitizedFilename = StringUtil.sanitizeFileName(filename.substring(0, filename.length() - 4)) + ".yml";
-            if (sanitizedFilename.equals(filename)) {
-                continue;
-            }
-            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));
-                continue;
-            }
-            if (newFile.exists()) {
-                LOGGER.log(Level.WARNING, tl("duplicatedUserdata", filename, sanitizedFilename));
-                continue;
-            }
-            if (!tmpFile.renameTo(newFile)) {
-                LOGGER.log(Level.WARNING, tl("userdataMoveBackError", sanitizedFilename, sanitizedFilename));
-            }
-        }
-        doneFile.setProperty("sanitizeAllUserFilenames", true);
-        doneFile.save();
-    }
-
-    private World getFakeWorld(final String name) {
-        final File bukkitDirectory = ess.getDataFolder().getParentFile().getParentFile();
-        final File worldDirectory = new File(bukkitDirectory, name);
-        if (worldDirectory.exists() && worldDirectory.isDirectory()) {
-            return new FakeWorld(worldDirectory.getName(), World.Environment.NORMAL);
-        }
-        return null;
-    }
-
-    public Location getFakeLocation(EssentialsConf config, String path) {
-        String worldName = config.getString((path != null ? path + "." : "") + "world");
-        if (worldName == null || worldName.isEmpty()) {
-            return null;
-        }
-        World world = getFakeWorld(worldName);
-        if (world == null) {
-            return null;
-        }
-        return new Location(world, config.getDouble((path != null ? path + "." : "") + "x", 0), config.getDouble((path != null ? path + "." : "") + "y", 0), config.getDouble((path != null ? path + "." : "") + "z", 0), (float) config.getDouble((path != null ? path + "." : "") + "yaw", 0), (float) config.getDouble((path != null ? path + "." : "") + "pitch", 0));
-    }
-
-    private void deleteOldItemsCsv() {
-        if (doneFile.getBoolean("deleteOldItemsCsv", false)) {
-            return;
-        }
-        final File file = new File(ess.getDataFolder(), "items.csv");
-        if (file.exists()) {
-            try {
-                final Set<BigInteger> oldconfigs = new HashSet<>();
-                oldconfigs.add(new BigInteger("66ec40b09ac167079f558d1099e39f10", 16)); // sep 1
-                oldconfigs.add(new BigInteger("34284de1ead43b0bee2aae85e75c041d", 16)); // crlf
-                oldconfigs.add(new BigInteger("c33bc9b8ee003861611bbc2f48eb6f4f", 16)); // jul 24
-                oldconfigs.add(new BigInteger("6ff17925430735129fc2a02f830c1daa", 16)); // crlf
-
-                MessageDigest digest = ManagedFile.getDigest();
-                final BufferedInputStream bis = new BufferedInputStream(new FileInputStream(file));
-                final byte[] buffer = new byte[1024];
-                try (DigestInputStream dis = new DigestInputStream(bis, digest)) {
-                    while (dis.read(buffer) != -1) {
-                    }
-                }
-
-                BigInteger hash = new BigInteger(1, digest.digest());
-                if (oldconfigs.contains(hash) && !file.delete()) {
-                    throw new IOException("Could not delete file " + file.toString());
-                }
-                doneFile.setProperty("deleteOldItemsCsv", true);
-                doneFile.save();
-            } catch (IOException ex) {
-                Bukkit.getLogger().log(Level.SEVERE, ex.getMessage(), ex);
-            }
-        }
-    }
-
-    private void updateSpawnsToNewSpawnsConfig() {
-        if (doneFile.getBoolean("updateSpawnsToNewSpawnsConfig", false)) {
-            return;
-        }
-        final File configFile = new File(ess.getDataFolder(), "spawn.yml");
-        if (configFile.exists()) {
-
-            final EssentialsConf config = new EssentialsConf(configFile);
-            try {
-                config.load();
-                if (!config.hasProperty("spawns")) {
-                    final Spawns spawns = new Spawns();
-                    Set<String> keys = config.getKeys(false);
-                    for (String group : keys) {
-                        Location loc = getFakeLocation(config, group);
-                        spawns.getSpawns().put(group.toLowerCase(Locale.ENGLISH), loc);
-                    }
-                    if (!configFile.renameTo(new File(ess.getDataFolder(), "spawn.yml.old"))) {
-                        throw new Exception(tl("fileRenameError", "spawn.yml"));
-                    }
-                    try (PrintWriter writer = new PrintWriter(configFile)) {
-                        new YamlStorageWriter(writer).save(spawns);
-                    }
-                }
-            } catch (Exception ex) {
-                Bukkit.getLogger().log(Level.SEVERE, ex.getMessage(), ex);
-            }
-        }
-        doneFile.setProperty("updateSpawnsToNewSpawnsConfig", true);
-        doneFile.save();
-    }
-
-    private void updateJailsToNewJailsConfig() {
-        if (doneFile.getBoolean("updateJailsToNewJailsConfig", false)) {
-            return;
-        }
-        final File configFile = new File(ess.getDataFolder(), "jail.yml");
-        if (configFile.exists()) {
-
-            final EssentialsConf config = new EssentialsConf(configFile);
-            try {
-                config.load();
-                if (!config.hasProperty("jails")) {
-                    final com.earth2me.essentials.settings.Jails jails = new com.earth2me.essentials.settings.Jails();
-                    Set<String> keys = config.getKeys(false);
-                    for (String jailName : keys) {
-                        Location loc = getFakeLocation(config, jailName);
-                        jails.getJails().put(jailName.toLowerCase(Locale.ENGLISH), loc);
-                    }
-                    if (!configFile.renameTo(new File(ess.getDataFolder(), "jail.yml.old"))) {
-                        throw new Exception(tl("fileRenameError", "jail.yml"));
-                    }
-                    try (PrintWriter writer = new PrintWriter(configFile)) {
-                        new YamlStorageWriter(writer).save(jails);
-                    }
-                }
-            } catch (Exception ex) {
-                Bukkit.getLogger().log(Level.SEVERE, ex.getMessage(), ex);
-            }
-        }
-        doneFile.setProperty("updateJailsToNewJailsConfig", true);
-        doneFile.save();
-    }
-
-    private void warnMetrics() {
-        if (doneFile.getBoolean("warnMetrics", false)) {
-            return;
-        }
-        doneFile.setProperty("warnMetrics", true);
-        doneFile.save();
-    }
-
-    private void uuidFileChange() {
-        if (doneFile.getBoolean("uuidFileChange", false)) {
-            return;
-        }
-
-        Boolean ignoreUFCache = doneFile.getBoolean("ignore-userfiles-cache", false);
-
-        final File userdir = new File(ess.getDataFolder(), "userdata");
-        if (!userdir.exists()) {
-            return;
-        }
-
-        int countFiles = 0;
-        int countReqFiles = 0;
-        for (String string : userdir.list()) {
-            if (!string.endsWith(".yml") || string.length() < 5) {
-                continue;
-            }
-
-            countFiles++;
-
-            final String name = string.substring(0, string.length() - 4);
-            UUID uuid = null;
-
-            try {
-                uuid = UUID.fromString(name);
-            } catch (IllegalArgumentException ex) {
-                countReqFiles++;
-            }
-
-            if (countFiles > 100) {
-                break;
-            }
-        }
-
-        if (countReqFiles < 1) {
-            return;
-        }
-
-        ess.getLogger().info("#### Starting Essentials UUID userdata conversion in a few seconds. ####");
-        ess.getLogger().info("We recommend you take a backup of your server before upgrading from the old username system.");
-
-        try {
-            Thread.sleep(15000);
-        } catch (InterruptedException ex) {
-            // NOOP
-        }
-
-        uuidFileConvert(ess, ignoreUFCache);
-
-        doneFile.setProperty("uuidFileChange", true);
-        doneFile.save();
-    }
-
-    public static void uuidFileConvert(IEssentials ess, Boolean ignoreUFCache) {
-        ess.getLogger().info("Starting Essentials UUID userdata conversion");
-
-        final File userdir = new File(ess.getDataFolder(), "userdata");
-        if (!userdir.exists()) {
-            return;
-        }
-
-        int countFiles = 0;
-        int countFails = 0;
-        int countEssCache = 0;
-        int countBukkit = 0;
-
-        ess.getLogger().info("Found " + userdir.list().length + " files to convert...");
-
-        for (String string : userdir.list()) {
-            if (!string.endsWith(".yml") || string.length() < 5) {
-                continue;
-            }
-
-            final int showProgress = countFiles % 250;
-
-            if (showProgress == 0) {
-                ess.getUserMap().getUUIDMap().forceWriteUUIDMap();
-                ess.getLogger().info("Converted " + countFiles + "/" + userdir.list().length);
-            }
-
-            countFiles++;
-
-            String name = string.substring(0, string.length() - 4);
-            EssentialsUserConf config;
-            UUID uuid = null;
-            try {
-                uuid = UUID.fromString(name);
-            } catch (IllegalArgumentException ex) {
-                File file = new File(userdir, string);
-                EssentialsConf conf = new EssentialsConf(file);
-                conf.load();
-                conf.setProperty("lastAccountName", name);
-                conf.save();
-
-                String uuidConf = ignoreUFCache ? "force-uuid" : "uuid";
-
-                String uuidString = conf.getString(uuidConf, null);
-
-                for (int i = 0; i < 4; i++) {
-                    try {
-                        uuid = UUID.fromString(uuidString);
-                        countEssCache++;
-                        break;
-                    } catch (Exception ex2) {
-                        if (conf.getBoolean("npc", false)) {
-                            uuid = UUID.nameUUIDFromBytes(("NPC:" + name).getBytes(Charsets.UTF_8));
-                            break;
-                        }
-
-                        org.bukkit.OfflinePlayer player = ess.getServer().getOfflinePlayer(name);
-                        uuid = player.getUniqueId();
-                    }
-
-                    if (uuid != null) {
-                        countBukkit++;
-                        break;
-                    }
-                }
-
-                if (uuid != null) {
-                    conf.forceSave();
-                    config = new EssentialsUserConf(name, uuid, new File(userdir, uuid + ".yml"));
-                    config.convertLegacyFile();
-                    ess.getUserMap().trackUUID(uuid, name, false);
-                    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 banFormatChange() {
-        if (doneFile.getBoolean("banFormatChange", false)) {
-            return;
-        }
-
-        ess.getLogger().info("Starting Essentials ban format conversion");
-
-        final File userdir = new File(ess.getDataFolder(), "userdata");
-        if (!userdir.exists()) {
-            return;
-        }
-
-        int countFiles = 0;
-
-        ess.getLogger().info("Found " + userdir.list().length + " files to convert...");
-
-        for (String string : userdir.list()) {
-            if (!string.endsWith(".yml") || string.length() < 5) {
-                continue;
-            }
-
-            final int showProgress = countFiles % 250;
-
-            if (showProgress == 0) {
-                ess.getLogger().info("Converted " + countFiles + "/" + userdir.list().length);
-            }
-
-            countFiles++;
-            final File pFile = new File(userdir, string);
-            final EssentialsConf conf = new EssentialsConf(pFile);
-            conf.load();
-
-            String banReason;
-            Long banTimeout;
-
-            try {
-                banReason = conf.getConfigurationSection("ban").getString("reason");
-            } catch (NullPointerException n) {
-                banReason = null;
-            }
-
-            final String playerName = conf.getString("lastAccountName");
-            if (playerName != null && playerName.length() > 1 && banReason != null && banReason.length() > 1) {
-                try {
-                    if (conf.getConfigurationSection("ban").contains("timeout")) {
-                        banTimeout = Long.parseLong(conf.getConfigurationSection("ban").getString("timeout"));
-                    } else {
-                        banTimeout = 0L;
-                    }
-                } catch (NumberFormatException n) {
-                    banTimeout = 0L;
-                }
-
-                if (BanLookup.isBanned(ess, playerName)) {
-                    updateBan(playerName, banReason, banTimeout);
-                }
-            }
-            conf.removeProperty("ban");
-            conf.save();
-        }
-
-        doneFile.setProperty("banFormatChange", true);
-        doneFile.save();
-        ess.getLogger().info("Ban format update complete.");
-    }
-
-    private void updateBan(String playerName, String banReason, Long banTimeout) {
-        if (banTimeout == 0) {
-            Bukkit.getBanList(BanList.Type.NAME).addBan(playerName, banReason, null, Console.NAME);
-        } else {
-            Bukkit.getBanList(BanList.Type.NAME).addBan(playerName, banReason, new Date(banTimeout), Console.NAME);
-        }
-    }
-
-    private static final FileFilter YML_FILTER = new FileFilter() {
-        @Override
-        public boolean accept(File pathname) {
-            return 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*$";
-    private static final Pattern PATTERN_CONFIG_NAME = Pattern.compile(PATTERN_CONFIG_NAME_REGEX);
-
-    private void repairUserMap() {
-        if (doneFile.getBoolean("userMapRepaired", false)) {
-            return;
-        }
-        ess.getLogger().info("Starting usermap repair");
-
-        File userdataFolder = new File(ess.getDataFolder(), "userdata");
-        if (!userdataFolder.isDirectory()) {
-            ess.getLogger().warning("Missing userdata folder, aborting");
-            return;
-        }
-        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 (IllegalArgumentException ignored) {
-                    }
-                }
-
-                final Matcher uuidMatcher = PATTERN_CONFIG_UUID.matcher(configData);
-                if (uuidMatcher.find()) {
-                    try {
-                        uuid = UUID.fromString(uuidMatcher.group(1));
-                    } catch (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);
-                return;
-            }
-        }
-
-        ess.getUserMap().getNames().putAll(names);
-        ess.getUserMap().reloadConfig();
-
-        doneFile.setProperty("userMapRepaired", true);
-        doneFile.save();
-        ess.getLogger().info("Completed usermap repair.");
-    }
-
-    public void beforeSettings() {
-        if (!ess.getDataFolder().exists()) {
-            ess.getDataFolder().mkdirs();
-        }
-        moveMotdRulesToFile("motd");
-        moveMotdRulesToFile("rules");
-    }
-
-    public void afterSettings() {
-        sanitizeAllUserFilenames();
-        updateUsersPowerToolsFormat();
-        updateUsersHomesFormat();
-        deleteOldItemsCsv();
-        updateSpawnsToNewSpawnsConfig();
-        updateJailsToNewJailsConfig();
-        uuidFileChange();
-        banFormatChange();
-        warnMetrics();
-        repairUserMap();
-    }
-}

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

@@ -1,63 +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 final 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;
-    }
-
-    @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 (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 (IOException ex) {
-            Bukkit.getLogger().log(Level.WARNING, "Failed to migrate user: " + username, ex);
-        }
-    }
-}

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

@@ -1,166 +0,0 @@
-package com.earth2me.essentials;
-
-import net.ess3.api.IEssentials;
-
-import java.io.File;
-import java.io.FileInputStream;
-import java.io.FileNotFoundException;
-import java.io.InputStream;
-import java.net.MalformedURLException;
-import java.net.URL;
-import java.text.MessageFormat;
-import java.util.*;
-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 I18n instance;
-    private static final String MESSAGES = "messages";
-    private final transient Locale defaultLocale = Locale.getDefault();
-    private transient Locale currentLocale = defaultLocale;
-    private transient ResourceBundle customBundle;
-    private transient ResourceBundle localeBundle;
-    private final transient ResourceBundle defaultBundle;
-    private transient Map<String, MessageFormat> messageFormatCache = new HashMap<String, MessageFormat>();
-    private final transient IEssentials ess;
-    private static final Pattern NODOUBLEMARK = Pattern.compile("''");
-    private static final ResourceBundle NULL_BUNDLE = new ResourceBundle() {
-        public Enumeration<String> getKeys() {
-            return null;
-        }
-
-        protected Object handleGetObject(String key) {
-            return null;
-        }
-    };
-
-    public I18n(final IEssentials ess) {
-        this.ess = ess;
-        defaultBundle = ResourceBundle.getBundle(MESSAGES, Locale.ENGLISH);
-        localeBundle = defaultBundle;
-        customBundle = NULL_BUNDLE;
-    }
-
-    public void onEnable() {
-        instance = this;
-    }
-
-    public void onDisable() {
-        instance = null;
-    }
-
-    @Override
-    public Locale getCurrentLocale() {
-        return currentLocale;
-    }
-
-    private String translate(final String string) {
-        try {
-            try {
-                return customBundle.getString(string);
-            } catch (MissingResourceException ex) {
-                return localeBundle.getString(string);
-            }
-        } catch (MissingResourceException ex) {
-            Logger.getLogger("Essentials").log(Level.WARNING, String.format("Missing translation key \"%s\" in translation file %s", ex.getKey(), localeBundle.getLocale().toString()), ex);
-            return defaultBundle.getString(string);
-        }
-    }
-
-    public static String tl(final String string, final Object... objects) {
-        if (instance == null) {
-            return "";
-        }
-        if (objects.length == 0) {
-            return NODOUBLEMARK.matcher(instance.translate(string)).replaceAll("'");
-        } else {
-            return instance.format(string, objects);
-        }
-    }
-
-    public String format(final String string, final Object... objects) {
-        String format = translate(string);
-        MessageFormat messageFormat = messageFormatCache.get(format);
-        if (messageFormat == null) {
-            try {
-                messageFormat = new MessageFormat(format);
-            } catch (IllegalArgumentException e) {
-                ess.getLogger().log(Level.SEVERE, "Invalid Translation key for '" + string + "': " + e.getMessage());
-                format = format.replaceAll("\\{(\\D*?)\\}", "\\[$1\\]");
-                messageFormat = new MessageFormat(format);
-            }
-            messageFormatCache.put(format, messageFormat);
-        }
-        return messageFormat.format(objects).replace(' ', ' '); // replace nbsp with a space
-    }
-
-    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]);
-            }
-        }
-        ResourceBundle.clearCache();
-        messageFormatCache = new HashMap<String, MessageFormat>();
-        Logger.getLogger("Essentials").log(Level.INFO, String.format("Using locale %s", currentLocale.toString()));
-
-        try {
-            localeBundle = ResourceBundle.getBundle(MESSAGES, currentLocale);
-        } catch (MissingResourceException ex) {
-            localeBundle = NULL_BUNDLE;
-        }
-
-        try {
-            customBundle = ResourceBundle.getBundle(MESSAGES, currentLocale, new FileResClassLoader(I18n.class.getClassLoader(), ess));
-        } catch (MissingResourceException ex) {
-            customBundle = NULL_BUNDLE;
-        }
-    }
-
-    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);
-    }
-
-
-    private static class FileResClassLoader extends ClassLoader {
-        private final transient File dataFolder;
-
-        FileResClassLoader(final ClassLoader classLoader, final IEssentials ess) {
-            super(classLoader);
-            this.dataFolder = ess.getDataFolder();
-        }
-
-        @Override
-        public URL getResource(final String string) {
-            final File file = new File(dataFolder, string);
-            if (file.exists()) {
-                try {
-                    return file.toURI().toURL();
-                } catch (MalformedURLException ex) {
-                }
-            }
-            return null;
-        }
-
-        @Override
-        public InputStream getResourceAsStream(final String string) {
-            final File file = new File(dataFolder, string);
-            if (file.exists()) {
-                try {
-                    return new FileInputStream(file);
-                } catch (FileNotFoundException ex) {
-                }
-            }
-            return null;
-        }
-    }
-}

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

@@ -1,194 +0,0 @@
-package com.earth2me.essentials;
-
-import com.earth2me.essentials.commands.IEssentialsCommand;
-import net.ess3.api.ITeleport;
-import net.ess3.api.MaxMoneyException;
-import org.bukkit.Location;
-import org.bukkit.Material;
-import org.bukkit.entity.Player;
-
-import java.math.BigDecimal;
-import java.util.Date;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
-import java.util.regex.Pattern;
-
-
-public interface IUser {
-    boolean isAuthorized(String node);
-
-    boolean isAuthorized(IEssentialsCommand cmd);
-
-    boolean isAuthorized(IEssentialsCommand cmd, String permissionPrefix);
-
-    boolean isPermissionSet(String node);
-
-    void healCooldown() throws Exception;
-
-    void giveMoney(BigDecimal value) throws MaxMoneyException;
-
-    void giveMoney(final BigDecimal value, final CommandSource initiator) throws MaxMoneyException;
-
-    void payUser(final User reciever, final BigDecimal value) throws Exception;
-
-    void takeMoney(BigDecimal value);
-
-    void takeMoney(final BigDecimal value, final CommandSource initiator);
-
-    boolean canAfford(BigDecimal value);
-
-    Boolean canSpawnItem(final Material material);
-
-    void setLastLocation();
-
-    void setLogoutLocation();
-
-    void requestTeleport(final User player, final boolean here);
-
-    /**
-     * Returns whether this user has an outstanding teleport request to deal with.
-     *
-     * @return whether there is a teleport request
-     */
-    boolean hasOutstandingTeleportRequest();
-
-    ITeleport getTeleport();
-
-    BigDecimal getMoney();
-
-    void setMoney(final BigDecimal value) throws MaxMoneyException;
-
-    void setAfk(final boolean set);
-
-    /**
-     * 'Hidden' Represents when a player is hidden from others. This status includes when the player is hidden via other
-     * supported plugins. Use isVanished() if you want to check if a user is vanished by Essentials.
-     *
-     * @return If the user is hidden or not
-     *
-     * @see isVanished
-     */
-    boolean isHidden();
-
-    void setHidden(boolean vanish);
-
-    boolean isGodModeEnabled();
-
-    String getGroup();
-
-    boolean inGroup(final String group);
-
-    boolean canBuild();
-
-    long getTeleportRequestTime();
-
-    void enableInvulnerabilityAfterTeleport();
-
-    void resetInvulnerabilityAfterTeleport();
-
-    boolean hasInvulnerabilityAfterTeleport();
-
-    /**
-     * 'Vanished' Represents when a player is hidden from others by Essentials. This status does NOT include when the
-     * player is hidden via other plugins. Use isHidden() if you want to check if a user is vanished by any supported
-     * plugin.
-     *
-     * @return If the user is vanished or not
-     *
-     * @see isHidden
-     */
-    boolean isVanished();
-
-    void setVanished(boolean vanish);
-
-    boolean isIgnoreExempt();
-
-    void sendMessage(String message);
-
-    /*
-     * UserData
-     */
-    Location getHome(String name) throws Exception;
-
-    Location getHome(Location loc) throws Exception;
-
-    List<String> getHomes();
-
-    void setHome(String name, Location loc);
-
-    void delHome(String name) throws Exception;
-
-    boolean hasHome();
-
-    Location getLastLocation();
-
-    Location getLogoutLocation();
-
-    long getLastTeleportTimestamp();
-
-    void setLastTeleportTimestamp(long time);
-
-    String getJail();
-
-    void setJail(String jail);
-
-    List<String> getMails();
-
-    void addMail(String mail);
-
-    boolean isAfk();
-
-    void setIgnoreMsg(boolean ignoreMsg);
-
-    boolean isIgnoreMsg();
-
-    void setConfigProperty(String node, Object object);
-
-    Set<String> getConfigKeys();
-
-    Map<String, Object> getConfigMap();
-
-    Map<String, Object> getConfigMap(String node);
-    
-    Map<Pattern, Long> getCommandCooldowns();
-
-    Date getCommandCooldownExpiry(String label);
-    
-    void addCommandCooldown(Pattern pattern, Date expiresAt, boolean save);
-    
-    boolean clearCommandCooldown(Pattern pattern);
-
-    /*
-     *  PlayerExtension
-     */
-    Player getBase();
-
-    CommandSource getSource();
-
-    String getName();
-
-    String getAfkMessage();
-
-    void setAfkMessage(final String message);
-    
-    long getAfkSince();
-    
-    boolean isAcceptingPay();
-    
-    void setAcceptingPay(boolean acceptingPay);
-    
-    boolean isPromptingPayConfirm();
-    
-    void setPromptingPayConfirm(boolean prompt);
-    
-    boolean isPromptingClearConfirm();
-    
-    void setPromptingClearConfirm(boolean prompt);
-
-    boolean isLastMessageReplyRecipient();
-
-    void setLastMessageReplyRecipient(boolean enabled);
-
-    Map<User, BigDecimal> getConfirmingPayments();
-}

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

@@ -1,264 +0,0 @@
-package com.earth2me.essentials;
-
-import com.earth2me.essentials.storage.AsyncStorageObjectHolder;
-import net.ess3.api.IEssentials;
-import net.ess3.api.IUser;
-import org.bukkit.Bukkit;
-import org.bukkit.Location;
-import org.bukkit.entity.Entity;
-import org.bukkit.entity.EntityType;
-import org.bukkit.entity.Player;
-import org.bukkit.event.EventHandler;
-import org.bukkit.event.EventPriority;
-import org.bukkit.event.Listener;
-import org.bukkit.event.block.BlockBreakEvent;
-import org.bukkit.event.block.BlockDamageEvent;
-import org.bukkit.event.block.BlockPlaceEvent;
-import org.bukkit.event.entity.EntityDamageByEntityEvent;
-import org.bukkit.event.entity.EntityDamageEvent.DamageCause;
-import org.bukkit.event.player.PlayerInteractEvent;
-import org.bukkit.event.player.PlayerJoinEvent;
-import org.bukkit.event.player.PlayerRespawnEvent;
-import org.bukkit.event.player.PlayerTeleportEvent;
-import org.bukkit.event.player.PlayerTeleportEvent.TeleportCause;
-import org.bukkit.plugin.PluginManager;
-
-import java.io.File;
-import java.util.*;
-import java.util.logging.Level;
-import java.util.logging.Logger;
-
-import static com.earth2me.essentials.I18n.tl;
-
-
-public class Jails extends AsyncStorageObjectHolder<com.earth2me.essentials.settings.Jails> implements net.ess3.api.IJails {
-    private static final transient Logger LOGGER = Bukkit.getLogger();
-    private static transient boolean enabled = false;
-
-    public Jails(final IEssentials ess) {
-        super(ess, com.earth2me.essentials.settings.Jails.class);
-        reloadConfig();
-    }
-
-    private void registerListeners() {
-        enabled = true;
-        final PluginManager pluginManager = ess.getServer().getPluginManager();
-        final JailListener blockListener = new JailListener();
-        pluginManager.registerEvents(blockListener, ess);
-        if (ess.getSettings().isDebug()) {
-            LOGGER.log(Level.INFO, "Registering Jail listener");
-        }
-    }
-
-    @Override
-    public File getStorageFile() {
-        return new File(ess.getDataFolder(), "jail.yml");
-    }
-
-    @Override
-    public void finishRead() {
-        checkRegister();
-    }
-
-    @Override
-    public void finishWrite() {
-        checkRegister();
-    }
-
-    public void resetListener() {
-        enabled = false;
-        checkRegister();
-    }
-
-    private void checkRegister() {
-        if (enabled == false && getCount() > 0) {
-            registerListeners();
-        }
-    }
-
-    @Override
-    public Location getJail(final String jailName) throws Exception {
-        acquireReadLock();
-        try {
-            if (getData().getJails() == null || jailName == null || !getData().getJails().containsKey(jailName.toLowerCase(Locale.ENGLISH))) {
-                throw new Exception(tl("jailNotExist"));
-            }
-            Location loc = getData().getJails().get(jailName.toLowerCase(Locale.ENGLISH));
-            if (loc == null || loc.getWorld() == null) {
-                throw new Exception(tl("jailNotExist"));
-            }
-            return loc;
-        } finally {
-            unlock();
-        }
-    }
-
-    @Override
-    public Collection<String> getList() throws Exception {
-        acquireReadLock();
-        try {
-            if (getData().getJails() == null) {
-                return Collections.emptyList();
-            }
-            return new ArrayList<String>(getData().getJails().keySet());
-        } finally {
-            unlock();
-        }
-    }
-
-    @Override
-    public void removeJail(final String jail) throws Exception {
-        acquireWriteLock();
-        try {
-            if (getData().getJails() == null) {
-                return;
-            }
-            getData().getJails().remove(jail.toLowerCase(Locale.ENGLISH));
-        } finally {
-            unlock();
-        }
-    }
-
-    @Override
-    public void sendToJail(final IUser user, final String jail) throws Exception {
-        acquireReadLock();
-        try {
-            if (user.getBase().isOnline()) {
-                Location loc = getJail(jail);
-                user.getTeleport().now(loc, false, TeleportCause.COMMAND);
-            }
-            user.setJail(jail);
-        } finally {
-            unlock();
-        }
-    }
-
-    @Override
-    public void setJail(final String jailName, final Location loc) throws Exception {
-        acquireWriteLock();
-        try {
-            if (getData().getJails() == null) {
-                getData().setJails(new HashMap<String, Location>());
-            }
-            getData().getJails().put(jailName.toLowerCase(Locale.ENGLISH), loc);
-        } finally {
-            unlock();
-        }
-    }
-
-    @Override
-    public int getCount() {
-        try {
-            return getList().size();
-        } catch (Exception ex) {
-            return 0;
-        }
-    }
-
-
-    private class JailListener implements Listener {
-        @EventHandler(priority = EventPriority.LOW, ignoreCancelled = true)
-        public void onJailBlockBreak(final BlockBreakEvent event) {
-            final User user = ess.getUser(event.getPlayer());
-            if (user.isJailed()) {
-                event.setCancelled(true);
-            }
-        }
-
-        @EventHandler(priority = EventPriority.LOW, ignoreCancelled = true)
-        public void onJailBlockPlace(final BlockPlaceEvent event) {
-            final User user = ess.getUser(event.getPlayer());
-            if (user.isJailed()) {
-                event.setCancelled(true);
-            }
-        }
-
-        @EventHandler(priority = EventPriority.LOW, ignoreCancelled = true)
-        public void onJailBlockDamage(final BlockDamageEvent event) {
-            final User user = ess.getUser(event.getPlayer());
-            if (user.isJailed()) {
-                event.setCancelled(true);
-            }
-        }
-
-        @EventHandler(priority = EventPriority.LOW, ignoreCancelled = true)
-        public void onJailEntityDamageByEntity(final EntityDamageByEntityEvent event) {
-            if (event.getCause() != DamageCause.ENTITY_ATTACK || event.getEntity().getType() != EntityType.PLAYER) {
-                return;
-            }
-            final Entity damager = event.getDamager();
-            if (damager.getType() == EntityType.PLAYER) {
-                final User user = ess.getUser((Player) damager);
-                if (user != null && user.isJailed()) {
-                    event.setCancelled(true);
-                }
-            }
-        }
-
-        @EventHandler(priority = EventPriority.LOW, ignoreCancelled = true)
-        public void onJailPlayerInteract(final PlayerInteractEvent event) {
-            final User user = ess.getUser(event.getPlayer());
-            if (user.isJailed()) {
-                event.setCancelled(true);
-            }
-        }
-
-        @EventHandler(priority = EventPriority.HIGHEST)
-        public void onJailPlayerRespawn(final PlayerRespawnEvent event) {
-            final User user = ess.getUser(event.getPlayer());
-            if (!user.isJailed() || user.getJail() == null || user.getJail().isEmpty()) {
-                return;
-            }
-
-            try {
-                event.setRespawnLocation(getJail(user.getJail()));
-            } catch (Exception ex) {
-                if (ess.getSettings().isDebug()) {
-                    LOGGER.log(Level.INFO, tl("returnPlayerToJailError", user.getName(), ex.getLocalizedMessage()), ex);
-                } else {
-                    LOGGER.log(Level.INFO, tl("returnPlayerToJailError", user.getName(), ex.getLocalizedMessage()));
-                }
-            }
-        }
-
-        @EventHandler(priority = EventPriority.HIGH)
-        public void onJailPlayerTeleport(final PlayerTeleportEvent event) {
-            final User user = ess.getUser(event.getPlayer());
-            if (!user.isJailed() || user.getJail() == null || user.getJail().isEmpty()) {
-                return;
-            }
-
-            try {
-                event.setTo(getJail(user.getJail()));
-            } catch (Exception ex) {
-                if (ess.getSettings().isDebug()) {
-                    LOGGER.log(Level.INFO, tl("returnPlayerToJailError", user.getName(), ex.getLocalizedMessage()), ex);
-                } else {
-                    LOGGER.log(Level.INFO, tl("returnPlayerToJailError", user.getName(), ex.getLocalizedMessage()));
-                }
-            }
-            user.sendMessage(tl("jailMessage"));
-        }
-
-        @EventHandler(priority = EventPriority.HIGHEST)
-        public void onJailPlayerJoin(final PlayerJoinEvent event) {
-            final User user = ess.getUser(event.getPlayer());
-            final long currentTime = System.currentTimeMillis();
-            user.checkJailTimeout(currentTime);
-            if (!user.isJailed() || user.getJail() == null || user.getJail().isEmpty()) {
-                return;
-            }
-
-            try {
-                sendToJail(user, user.getJail());
-            } catch (Exception ex) {
-                if (ess.getSettings().isDebug()) {
-                    LOGGER.log(Level.INFO, tl("returnPlayerToJailError", user.getName(), ex.getLocalizedMessage()), ex);
-                } else {
-                    LOGGER.log(Level.INFO, tl("returnPlayerToJailError", user.getName(), ex.getLocalizedMessage()));
-                }
-            }
-            user.sendMessage(tl("jailMessage"));
-        }
-    }
-}

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

@@ -1,214 +0,0 @@
-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.textreader.IText;
-import com.earth2me.essentials.textreader.KeywordReplacer;
-import com.earth2me.essentials.textreader.SimpleTextInput;
-import com.earth2me.essentials.utils.DateUtil;
-import net.ess3.api.IEssentials;
-import org.bukkit.Bukkit;
-import org.bukkit.Material;
-import org.bukkit.inventory.ItemStack;
-
-import java.math.BigDecimal;
-import java.util.*;
-import java.util.logging.Level;
-
-import static com.earth2me.essentials.I18n.tl;
-
-
-public class Kit {
-    final IEssentials ess;
-    final String kitName;
-    final Map<String, Object> kit;
-    final Trade charge;
-
-    public Kit(final String kitName, final IEssentials ess) throws Exception {
-        this.kitName = kitName;
-        this.ess = ess;
-        this.kit = ess.getKits().getKit(kitName);
-        this.charge = new Trade("kit-" + kitName, new Trade("kit-kit", ess), ess);
-
-        if (kit == null) {
-            throw new Exception(tl("kitNotFound"));
-        }
-    }
-
-    public String getName() {
-        return kitName;
-    }
-
-    public void checkPerms(final User user) throws Exception {
-        if (!user.isAuthorized("essentials.kits." + kitName)) {
-            throw new Exception(tl("noKitPermission", "essentials.kits." + kitName));
-        }
-    }
-
-    public void checkDelay(final User user) throws Exception {
-        long nextUse = getNextUse(user);
-
-        if (nextUse == 0L) {
-            return;
-        } else if (nextUse < 0L) {
-            user.sendMessage(tl("kitOnce"));
-            throw new NoChargeException();
-        } else {
-            user.sendMessage(tl("kitTimed", DateUtil.formatDateDiff(nextUse)));
-            throw new NoChargeException();
-        }
-    }
-
-    public void checkAffordable(final User user) throws Exception {
-        charge.isAffordableFor(user);
-    }
-
-    public void setTime(final User user) throws Exception {
-        final Calendar time = new GregorianCalendar();
-        user.setKitTimestamp(kitName, time.getTimeInMillis());
-    }
-
-    public void chargeUser(final User user) throws Exception {
-        charge.charge(user);
-    }
-
-    public long getNextUse(final User user) throws Exception {
-        if (user.isAuthorized("essentials.kit.exemptdelay")) {
-            return 0L;
-        }
-
-        final Calendar time = new GregorianCalendar();
-
-        double delay = 0;
-        try {
-            // Make sure delay is valid
-            delay = kit.containsKey("delay") ? ((Number) kit.get("delay")).doubleValue() : 0.0d;
-        } catch (Exception e) {
-            throw new Exception(tl("kitError2"));
-        }
-
-        // When was the last kit used?
-        final long lastTime = user.getKitTimestamp(kitName);
-
-        // When can be use the kit again?
-        final Calendar delayTime = new GregorianCalendar();
-        delayTime.setTimeInMillis(lastTime);
-        delayTime.add(Calendar.SECOND, (int) delay);
-        delayTime.add(Calendar.MILLISECOND, (int) ((delay * 1000.0) % 1000.0));
-
-        if (lastTime == 0L || lastTime > time.getTimeInMillis()) {
-            // If we have no record of kit use, or its corrupted, give them benefit of the doubt.
-            return 0L;
-        } else if (delay < 0d) {
-            // If the kit has a negative kit time, it can only be used once.
-            return -1;
-        } else if (delayTime.before(time)) {
-            // If the kit was used in the past, but outside the delay time, it can be used.
-            return 0L;
-        } else {
-            // If the kit has been used recently, return the next time it can be used.
-            return delayTime.getTimeInMillis();
-        }
-    }
-
-    @Deprecated
-    public List<String> getItems(final User user) throws Exception {
-        return getItems();
-    }
-
-    public List<String> getItems() throws Exception {
-        if (kit == null) {
-            throw new Exception(tl("kitNotFound"));
-        }
-        try {
-            final List<String> itemList = new ArrayList<String>();
-            final Object kitItems = kit.get("items");
-            if (kitItems instanceof List) {
-                for (Object item : (List) kitItems) {
-                    if (item instanceof String) {
-                        itemList.add(item.toString());
-                        continue;
-                    }
-                    throw new Exception("Invalid kit item: " + item.toString());
-                }
-                return itemList;
-            }
-            throw new Exception("Invalid item list");
-        } catch (Exception e) {
-            ess.getLogger().log(Level.WARNING, "Error parsing kit " + kitName + ": " + e.getMessage());
-            throw new Exception(tl("kitError2"), e);
-        }
-    }
-
-    public void expandItems(final User user) throws Exception {
-        expandItems(user, getItems(user));
-    }
-
-    public void expandItems(final User user, final List<String> items) throws Exception {
-        try {
-            IText input = new SimpleTextInput(items);
-            IText output = new KeywordReplacer(input, user.getSource(), ess, true, true);
-
-            boolean spew = false;
-            final boolean allowUnsafe = ess.getSettings().allowUnsafeEnchantments();
-            for (String kitItem : output.getLines()) {
-                if (kitItem.startsWith(ess.getSettings().getCurrencySymbol())) {
-                    BigDecimal value = new BigDecimal(kitItem.substring(ess.getSettings().getCurrencySymbol().length()).trim());
-                    Trade t = new Trade(value, ess);
-                    t.pay(user, OverflowType.DROP);
-                    continue;
-                }
-
-                if (kitItem.startsWith("/")) {
-                    String command = kitItem.substring(1);
-                    String name = user.getName();
-                    command = command.replace("{player}", name);
-                    Bukkit.dispatchCommand(Bukkit.getConsoleSender(), command);
-                    continue;
-                }
-
-                final String[] parts = kitItem.split(" +");
-                final ItemStack parseStack = ess.getItemDb().get(parts[0], parts.length > 1 ? Integer.parseInt(parts[1]) : 1);
-
-                if (parseStack.getType() == Material.AIR) {
-                    continue;
-                }
-
-                final MetaItemStack metaStack = new MetaItemStack(parseStack);
-
-                if (parts.length > 2) {
-                    // We pass a null sender here because kits should not do perm checks
-                    metaStack.parseStringMeta(null, allowUnsafe, parts, 2, ess);
-                }
-
-                final Map<Integer, ItemStack> overfilled;
-                final boolean allowOversizedStacks = user.isAuthorized("essentials.oversizedstacks");
-                if (allowOversizedStacks) {
-                    overfilled = InventoryWorkaround.addOversizedItems(user.getBase().getInventory(), ess.getSettings().getOversizedStackSize(), metaStack.getItemStack());
-                } else {
-                    overfilled = InventoryWorkaround.addItems(user.getBase().getInventory(), metaStack.getItemStack());
-                }
-                for (ItemStack itemStack : overfilled.values()) {
-                    int spillAmount = itemStack.getAmount();
-                    if (!allowOversizedStacks) {
-                        itemStack.setAmount(spillAmount < itemStack.getMaxStackSize() ? spillAmount : itemStack.getMaxStackSize());
-                    }
-                    while (spillAmount > 0) {
-                        user.getWorld().dropItemNaturally(user.getLocation(), itemStack);
-                        spillAmount -= itemStack.getAmount();
-                    }
-                    spew = true;
-                }
-            }
-            user.getBase().updateInventory();
-            if (spew) {
-                user.sendMessage(tl("kitInvFull"));
-            }
-        } catch (Exception e) {
-            user.getBase().updateInventory();
-            ess.getLogger().log(Level.WARNING, e.getMessage());
-            throw new Exception(tl("kitError2"), e);
-        }
-    }
-}

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

@@ -1,114 +0,0 @@
-package com.earth2me.essentials;
-
-import com.earth2me.essentials.utils.NumberUtil;
-import org.bukkit.configuration.ConfigurationSection;
-import org.bukkit.configuration.MemoryConfiguration;
-
-import java.io.File;
-import java.math.BigDecimal;
-import java.util.List;
-import java.util.Locale;
-import java.util.Map;
-
-import static com.earth2me.essentials.I18n.capitalCase;
-import static com.earth2me.essentials.I18n.tl;
-
-public class Kits implements IConf {
-
-    private final EssentialsConf config;
-    private ConfigurationSection kits;
-
-    public Kits(final IEssentials essentials) {
-        config = new EssentialsConf(new File(essentials.getDataFolder(), "kits.yml"));
-        config.setTemplateName("/kits.yml");
-
-        reloadConfig();
-    }
-
-    @Override
-    public void reloadConfig() {
-        config.load();
-        kits = _getKits();
-    }
-
-    private ConfigurationSection _getKits() {
-        if (config.isConfigurationSection("kits")) {
-            final ConfigurationSection section = config.getConfigurationSection("kits");
-            final ConfigurationSection newSection = new MemoryConfiguration();
-            for (String kitItem : section.getKeys(false)) {
-                if (section.isConfigurationSection(kitItem)) {
-                    newSection.set(kitItem.toLowerCase(Locale.ENGLISH), section.getConfigurationSection(kitItem));
-                }
-            }
-            return newSection;
-        }
-        return null;
-    }
-
-    public EssentialsConf getConfig() {
-        return config;
-    }
-
-    public ConfigurationSection getKits() {
-        return kits;
-    }
-
-    public Map<String, Object> getKit(String name) {
-        name = name.replace('.', '_').replace('/', '_');
-        if (getKits() != null) {
-            final ConfigurationSection kits = getKits();
-            // For some reason, YAML doesn't sees keys as always lowercase even if they aren't defined like that.
-            // Workaround is to toLowercase when getting from the config, but showing normally elsewhere.
-            // ODDLY ENOUGH when you get the configuration section for ALL kits, it will return the proper
-            // case of each kit. But when you check for each kit's configuration section, it won't return the kit
-            // you just found if you don't toLowercase it.
-            if (kits.isConfigurationSection(name.toLowerCase())) {
-                return kits.getConfigurationSection(name.toLowerCase()).getValues(true);
-            } else {
-            }
-        }
-
-        return null;
-    }
-
-    public void addKit(String name, List<String> lines, long delay) {
-        // Will overwrite but w/e
-        config.set("kits." + name + ".delay", delay);
-        config.set("kits." + name + ".items", lines);
-        kits = _getKits();
-        config.save();
-    }
-
-    public String listKits(final net.ess3.api.IEssentials ess, final User user) throws Exception {
-        try {
-            final ConfigurationSection kits = config.getConfigurationSection("kits");
-            final StringBuilder list = new StringBuilder();
-            for (String kitItem : kits.getKeys(false)) {
-                if (user == null) {
-                    list.append(" ").append(capitalCase(kitItem));
-                } else if (user.isAuthorized("essentials.kits." + kitItem.toLowerCase(Locale.ENGLISH))) {
-                    String cost = "";
-                    String name = capitalCase(kitItem);
-                    BigDecimal costPrice = new Trade("kit-" + kitItem.toLowerCase(Locale.ENGLISH), ess).getCommandCost(user);
-                    if (costPrice.signum() > 0) {
-                        cost = tl("kitCost", NumberUtil.displayCurrency(costPrice, ess));
-                    }
-
-                    Kit kit = new Kit(kitItem, ess);
-                    double nextUse = kit.getNextUse(user);
-                    if (nextUse == -1 && ess.getSettings().isSkippingUsedOneTimeKitsFromKitList()) {
-                        continue;
-                    } else if (nextUse != 0) {
-                        name = tl("kitDelay", name);
-                    }
-
-                    list.append(" ").append(name).append(cost);
-                }
-            }
-            return list.toString().trim();
-        } catch (Exception ex) {
-            throw new Exception(tl("kitError"), ex);
-        }
-
-    }
-}

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

@@ -1,587 +0,0 @@
-package com.earth2me.essentials;
-
-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.google.common.base.Joiner;
-import net.ess3.api.IEssentials;
-import net.ess3.nms.refl.ReflUtil;
-
-import org.apache.commons.lang.ArrayUtils;
-import org.bukkit.Color;
-import org.bukkit.DyeColor;
-import org.bukkit.FireworkEffect;
-import org.bukkit.Material;
-import org.bukkit.block.Banner;
-import org.bukkit.block.banner.PatternType;
-import org.bukkit.enchantments.Enchantment;
-import org.bukkit.inventory.ItemFlag;
-import org.bukkit.inventory.ItemStack;
-import org.bukkit.inventory.meta.*;
-import org.bukkit.potion.Potion;
-import org.bukkit.potion.PotionEffect;
-import org.bukkit.potion.PotionEffectType;
-
-import java.lang.reflect.Method;
-import java.util.*;
-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<>();
-
-    static {
-        for (DyeColor color : DyeColor.values()) {
-            colorMap.put(color.name(), color);
-        }
-        for (FireworkEffect.Type type : FireworkEffect.Type.values()) {
-            fireworkShape.put(type.name(), type);
-        }
-    }
-
-    private final transient Pattern splitPattern = Pattern.compile("[:+',;.]");
-    private ItemStack stack;
-    private FireworkEffect.Builder builder = FireworkEffect.builder();
-    private PotionEffectType pEffectType;
-    private PotionEffect pEffect;
-    private boolean validFirework = false;
-    private boolean validPotionEffect = false;
-    private boolean validPotionDuration = false;
-    private boolean validPotionPower = false;
-    private boolean isSplashPotion = false;
-    private boolean completePotion = false;
-    private int power = 1;
-    private int duration = 120;
-
-    public MetaItemStack(final ItemStack stack) {
-        this.stack = stack.clone();
-    }
-
-    public ItemStack getItemStack() {
-        return stack;
-    }
-
-    public boolean isValidFirework() {
-        return validFirework;
-    }
-
-    public boolean isValidPotion() {
-        return validPotionEffect && validPotionDuration && validPotionPower;
-    }
-
-    public FireworkEffect.Builder getFireworkBuilder() {
-        return builder;
-    }
-
-    public PotionEffect getPotionEffect() {
-        return pEffect;
-    }
-
-    public boolean completePotion() {
-        return completePotion;
-    }
-
-    private void resetPotionMeta() {
-        pEffect = null;
-        pEffectType = null;
-        validPotionEffect = false;
-        validPotionDuration = false;
-        validPotionPower = false;
-        isSplashPotion = false;
-        completePotion = true;
-    }
-
-    public boolean canSpawn(final IEssentials ess) {
-        try {
-            ess.getServer().getUnsafe().modifyItemStack(stack.clone(), "{}");
-            return true;
-        } catch (NullPointerException npe) {
-            if (ess.getSettings().isDebug()) {
-                ess.getLogger().log(Level.INFO, "Itemstack is invalid", npe);
-            }
-            return false;
-        } catch (NoSuchMethodError nsme) {
-            return true;
-        } catch (Throwable throwable) {
-            if (ess.getSettings().isDebug()) {
-                ess.getLogger().log(Level.INFO, "Itemstack is invalid", throwable);
-            }
-            return false;
-        }
-    }
-
-    public void parseStringMeta(final CommandSource sender, final boolean allowUnsafe, String[] string, int fromArg, final IEssentials ess) throws Exception {
-        if (string[fromArg].startsWith("{") && hasMetaPermission(sender, "vanilla", false, true, ess)) {
-            try {
-                stack = ess.getServer().getUnsafe().modifyItemStack(stack, Joiner.on(' ').join(Arrays.asList(string).subList(fromArg, string.length)));
-            } catch (NullPointerException npe) {
-                if (ess.getSettings().isDebug()) {
-                    ess.getLogger().log(Level.INFO, "Itemstack is invalid", npe);
-                }
-            } catch (NoSuchMethodError nsme) {
-                throw new Exception(tl("noMetaJson"), nsme);
-            } catch (Throwable throwable) {
-                throw new Exception(throwable.getMessage(), throwable);
-            }
-        } else {
-            for (int i = fromArg; i < string.length; i++) {
-                addStringMeta(sender, allowUnsafe, string[i], ess);
-            }
-            if (validFirework) {
-                if (!hasMetaPermission(sender, "firework", true, true, ess)) {
-                    throw new Exception(tl("noMetaFirework"));
-                }
-                FireworkEffect effect = builder.build();
-                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"));
-                }
-                stack.setItemMeta(fmeta);
-            }
-        }
-    }
-
-    public void addStringMeta(final CommandSource sender, final boolean allowUnsafe, final String string, final IEssentials ess) throws Exception {
-        final String[] split = splitPattern.split(string, 2);
-        if (split.length < 1) {
-            return;
-        }
-
-        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 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<String>();
-            for (String line : split[1].split("\\|")) {
-                lore.add(FormatUtil.replaceFormat(line.replace('_', ' ')));
-            }
-            final ItemMeta meta = stack.getItemMeta();
-            meta.setLore(lore);
-            stack.setItemMeta(meta);
-        } else if (split[0].equalsIgnoreCase("unbreakable") && hasMetaPermission(sender, "unbreakable", false, true, ess)) {
-            boolean value = split.length > 1 ? Boolean.valueOf(split[1]) : true;
-            setUnbreakable(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())) {
-                final String owner = split[1];
-                final SkullMeta meta = (SkullMeta) stack.getItemMeta();
-                meta.setOwningPlayer(ess.getServer().getOfflinePlayer(owner));
-                stack.setItemMeta(meta);
-            } else {
-                throw new Exception(tl("onlyPlayerSkulls"));
-            }
-        } else if (split.length > 1 && split[0].equalsIgnoreCase("book") && stack.getType() == WRITTEN_BOOK && (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);
-
-            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)) {
-            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('_', ' '));
-            final BookMeta meta = (BookMeta) stack.getItemMeta();
-            meta.setTitle(title);
-            stack.setItemMeta(meta);
-        } else if (split.length > 1 && split[0].equalsIgnoreCase("power") && (MaterialUtil.isFirework(stack.getType()))&& hasMetaPermission(sender, "firework-power", false, true, ess)) {
-            final int power = NumberUtil.isInt(split[1]) ? Integer.parseInt(split[1]) : 0;
-            final FireworkMeta meta = (FireworkMeta) stack.getItemMeta();
-            meta.setPower(power > 3 ? 4 : power);
-            stack.setItemMeta(meta);
-        } else if (split.length > 1 && split[0].equalsIgnoreCase("itemflags") && hasMetaPermission(sender, "itemflags", false, true, ess)) {
-            addItemFlags(string);
-        } else if (MaterialUtil.isFirework(stack.getType())) {
-            //WARNING - Meta for fireworks will be ignored after this point.
-            addFireworkMeta(sender, false, string, ess);
-        } else if (MaterialUtil.isPotion(stack.getType())) {
-            //WARNING - Meta for potions will be ignored after this point.
-            addPotionMeta(sender, false, string, ess);
-        } else if (MaterialUtil.isBanner(stack.getType())) {
-            if (stack.getType().toString().equals("SHIELD") && Enchantments.getByName(split[0]) != null) {
-                parseEnchantmentStrings(sender, allowUnsafe, split, ess);
-            } else {
-                //WARNING - Meta for banners will be ignored after this point.
-                addBannerMeta(sender, false, string, ess);
-            }
-        } else if (split.length > 1 && (split[0].equalsIgnoreCase("color") || split[0].equalsIgnoreCase("colour")) && MaterialUtil.isLeatherArmor(stack.getType())) {
-            final String[] color = split[1].split("(\\||,)");
-            if (color.length == 1 && (NumberUtil.isInt(color[0]) || color[0].startsWith("#"))) {
-                // Either integer or hexadecimal
-                final LeatherArmorMeta meta = (LeatherArmorMeta) stack.getItemMeta();
-                String input = color[0];
-                if (input.startsWith("#")) { // Hex
-                    meta.setColor(Color.fromRGB(
-                        Integer.valueOf(input.substring(1, 3), 16),
-                        Integer.valueOf(input.substring(3, 5), 16),
-                        Integer.valueOf(input.substring(5, 7), 16)));
-                } else { // Int
-                    meta.setColor(Color.fromRGB(Integer.parseInt(input)));
-                }
-                stack.setItemMeta(meta);
-            } else if (color.length == 3) { // r,g,b
-                final int red = NumberUtil.isInt(color[0]) ? Integer.parseInt(color[0]) : 0;
-                final int green = NumberUtil.isInt(color[1]) ? Integer.parseInt(color[1]) : 0;
-                final int blue = NumberUtil.isInt(color[2]) ? Integer.parseInt(color[2]) : 0;
-                final LeatherArmorMeta meta = (LeatherArmorMeta) stack.getItemMeta();
-                meta.setColor(Color.fromRGB(red, green, blue));
-                stack.setItemMeta(meta);
-            } else {
-                throw new Exception(tl("leatherSyntax"));
-            }
-        } else {
-            parseEnchantmentStrings(sender, allowUnsafe, split, ess);
-        }
-    }
-
-    public void addItemFlags(final String string) throws Exception {
-        String[] separate = splitPattern.split(string, 2);
-        if (separate.length != 2) {
-            throw new Exception(tl("invalidItemFlagMeta", string));
-        }
-
-        String[] split = separate[1].split(",");
-        ItemMeta meta = stack.getItemMeta();
-
-        for (String s : split) {
-            for (ItemFlag flag : ItemFlag.values()) {
-                if (s.equalsIgnoreCase(flag.name())) {
-                    meta.addItemFlags(flag);
-                }
-            }
-        }
-
-        if (meta.getItemFlags().isEmpty()) {
-            throw new Exception(tl("invalidItemFlagMeta", string));
-        }
-
-        stack.setItemMeta(meta);
-    }
-
-    public void addFireworkMeta(final CommandSource sender, final boolean allowShortName, final String string, final IEssentials ess) throws Exception {
-    if (MaterialUtil.isFirework(stack.getType())) {
-            final String[] split = splitPattern.split(string, 2);
-            if (split.length < 2) {
-                return;
-            }
-
-            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"));
-                    }
-                    FireworkEffect effect = builder.build();
-                    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"));
-                    }
-                    stack.setItemMeta(fmeta);
-                    builder = FireworkEffect.builder();
-                }
-
-                List<Color> primaryColors = new ArrayList<Color>();
-                String[] colors = split[1].split(",");
-                for (String color : colors) {
-                    if (colorMap.containsKey(color.toUpperCase())) {
-                        validFirework = true;
-                        primaryColors.add(colorMap.get(color.toUpperCase()).getFireworkColor());
-                    } else {
-                        throw new Exception(tl("invalidFireworkFormat", split[1], split[0]));
-                    }
-                }
-                builder.withColor(primaryColors);
-            } else if (split[0].equalsIgnoreCase("shape") || split[0].equalsIgnoreCase("type") || (allowShortName && (split[0].equalsIgnoreCase("s") || split[0].equalsIgnoreCase("t")))) {
-                FireworkEffect.Type finalEffect = null;
-                split[1] = (split[1].equalsIgnoreCase("large") ? "BALL_LARGE" : split[1]);
-                if (fireworkShape.containsKey(split[1].toUpperCase())) {
-                    finalEffect = fireworkShape.get(split[1].toUpperCase());
-                } else {
-                    throw new Exception(tl("invalidFireworkFormat", split[1], split[0]));
-                }
-                if (finalEffect != null) {
-                    builder.with(finalEffect);
-                }
-            } else if (split[0].equalsIgnoreCase("fade") || (allowShortName && split[0].equalsIgnoreCase("f"))) {
-                List<Color> fadeColors = new ArrayList<Color>();
-                String[] colors = split[1].split(",");
-                for (String color : colors) {
-                    if (colorMap.containsKey(color.toUpperCase())) {
-                        fadeColors.add(colorMap.get(color.toUpperCase()).getFireworkColor());
-                    } else {
-                        throw new Exception(tl("invalidFireworkFormat", split[1], split[0]));
-                    }
-                }
-                if (!fadeColors.isEmpty()) {
-                    builder.withFade(fadeColors);
-                }
-            } else if (split[0].equalsIgnoreCase("effect") || (allowShortName && split[0].equalsIgnoreCase("e"))) {
-                String[] effects = split[1].split(",");
-                for (String effect : effects) {
-                    if (effect.equalsIgnoreCase("twinkle")) {
-                        builder.flicker(true);
-                    } else if (effect.equalsIgnoreCase("trail")) {
-                        builder.trail(true);
-                    } else {
-                        throw new Exception(tl("invalidFireworkFormat", split[1], split[0]));
-                    }
-                }
-            }
-        }
-    }
-
-    public void addPotionMeta(final CommandSource sender, final boolean allowShortName, final String string, final IEssentials ess) throws Exception {
-        if (MaterialUtil.isPotion(stack.getType())) {
-            final String[] split = splitPattern.split(string, 2);
-
-            if (split.length < 2) {
-                return;
-            }
-
-            if (split[0].equalsIgnoreCase("effect") || (allowShortName && split[0].equalsIgnoreCase("e"))) {
-                pEffectType = Potions.getByName(split[1]);
-                if (pEffectType != null && pEffectType.getName() != null) {
-                    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)));
-                    }
-                } else {
-                    throw new Exception(tl("invalidPotionMeta", split[1]));
-                }
-            } else if (split[0].equalsIgnoreCase("power") || (allowShortName && split[0].equalsIgnoreCase("p"))) {
-                if (NumberUtil.isInt(split[1])) {
-                    validPotionPower = true;
-                    power = Integer.parseInt(split[1]);
-                    if (power > 0 && power < 4) {
-                        power -= 1;
-                    }
-                } else {
-                    throw new Exception(tl("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
-                } else {
-                    throw new Exception(tl("invalidPotionMeta", split[1]));
-                }
-            } else if (split[0].equalsIgnoreCase("splash") || (allowShortName && split[0].equalsIgnoreCase("s"))) {
-                isSplashPotion = Boolean.valueOf(split[1]);
-            }
-
-            if (isValidPotion()) {
-                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"));
-                }
-                pmeta.addCustomEffect(pEffect, true);
-                stack.setItemMeta(pmeta);
-                if (ReflUtil.getNmsVersionObject().isHigherThanOrEqualTo(ReflUtil.V1_9_R1)) {
-                    if (isSplashPotion && stack.getType() != Material.SPLASH_POTION) {
-                        stack.setType(Material.SPLASH_POTION);
-                    } else if (!isSplashPotion && stack.getType() != Material.POTION) {
-                        stack.setType(Material.POTION);
-                    }
-                } else {
-                    Potion potion = Potion.fromItemStack(stack);
-                    potion.setSplash(isSplashPotion);
-                    potion.apply(stack);
-                }
-                resetPotionMeta();
-            }
-        }
-    }
-
-    private void parseEnchantmentStrings(final CommandSource sender, final boolean allowUnsafe, final String[] split, final IEssentials ess) throws Exception {
-        final Enchantment enchantment = Enchantments.getByName(split[0]);
-        if (enchantment == null || !hasMetaPermission(sender, "enchantments." + enchantment.getName().toLowerCase(Locale.ENGLISH), false, false, ess)) {
-            return;
-        }
-
-        int level = -1;
-        if (split.length > 1) {
-            try {
-                level = Integer.parseInt(split[1]);
-            } catch (NumberFormatException ex) {
-                level = -1;
-            }
-        }
-
-        if (level < 0 || (!allowUnsafe && level > enchantment.getMaxLevel())) {
-            level = enchantment.getMaxLevel();
-        }
-        addEnchantment(sender, allowUnsafe, enchantment, level);
-    }
-
-    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"));
-        }
-        try {
-            if (stack.getType().equals(Material.ENCHANTED_BOOK)) {
-                EnchantmentStorageMeta meta = (EnchantmentStorageMeta) stack.getItemMeta();
-                if (level == 0) {
-                    meta.removeStoredEnchant(enchantment);
-                } else {
-                    meta.addStoredEnchant(enchantment, level, allowUnsafe);
-                }
-                stack.setItemMeta(meta);
-            } else // all other material types besides ENCHANTED_BOOK
-            {
-                if (level == 0) {
-                    stack.removeEnchantment(enchantment);
-                } else {
-                    if (allowUnsafe) {
-                        stack.addUnsafeEnchantment(enchantment, level);
-                    } else {
-                        stack.addEnchantment(enchantment, level);
-                    }
-                }
-            }
-        } catch (Exception ex) {
-            throw new Exception("Enchantment " + enchantment.getName() + ": " + ex.getMessage(), ex);
-        }
-    }
-
-    public Enchantment getEnchantment(final User user, final String name) throws Exception {
-        final Enchantment enchantment = Enchantments.getByName(name);
-        if (enchantment == null) {
-            return null;
-        }
-
-        final String enchantmentName = enchantment.getName().toLowerCase(Locale.ENGLISH);
-
-        if (!hasMetaPermission(user, "enchantments." + enchantmentName, true, false)) {
-            throw new Exception(tl("enchantmentPerm", enchantmentName));
-        }
-        return enchantment;
-    }
-
-    public void addBannerMeta(final CommandSource sender, final boolean allowShortName, final String string, final IEssentials ess) throws Exception {
-        if (MaterialUtil.isBanner(stack.getType()) && !stack.getType().toString().equals("SHIELD") && string != null) {
-            final String[] split = splitPattern.split(string, 2);
-
-            if (split.length < 2) {
-                throw new Exception(tl("invalidBanner", split[1]));
-            }
-
-            PatternType patternType = null;
-            try {
-                patternType = PatternType.valueOf(split[0]);
-            } catch (Exception ignored ) {}
-
-            final BannerMeta meta = (BannerMeta) stack.getItemMeta();
-            if (split[0].equalsIgnoreCase("basecolor")) {
-                Color color = Color.fromRGB(Integer.valueOf(split[1]));
-                meta.setBaseColor(DyeColor.getByColor(color));
-            } else if (patternType != null) {
-                PatternType type = PatternType.valueOf(split[0]);
-                DyeColor color = DyeColor.getByColor(Color.fromRGB(Integer.valueOf(split[1])));
-                org.bukkit.block.banner.Pattern pattern = new org.bukkit.block.banner.Pattern(color, type);
-                meta.addPattern(pattern);
-            }
-
-            stack.setItemMeta(meta);
-        } else if (stack.getType().toString().equals("SHIELD") && string != null) {
-            final String[] split = splitPattern.split(string, 2);
-
-            if (split.length < 2) {
-                throw new Exception(tl("invalidBanner", split[1]));
-            }
-
-            PatternType patternType = null;
-            try {
-                patternType = PatternType.valueOf(split[0]);
-            } catch (Exception ignored ) {}
-
-            // Hacky fix for accessing Shield meta - https://github.com/drtshock/Essentials/pull/745#issuecomment-234843795
-            BlockStateMeta meta = (BlockStateMeta) stack.getItemMeta();
-            Banner banner = (Banner) meta.getBlockState();
-            if (split[0].equalsIgnoreCase("basecolor")) {
-                Color color = Color.fromRGB(Integer.valueOf(split[1]));
-                banner.setBaseColor(DyeColor.getByColor(color));
-            } else if (patternType != null) {
-                PatternType type = PatternType.valueOf(split[0]);
-                DyeColor color = DyeColor.getByColor(Color.fromRGB(Integer.valueOf(split[1])));
-                org.bukkit.block.banner.Pattern pattern = new org.bukkit.block.banner.Pattern(color, type);
-                banner.addPattern(pattern);
-            }
-            banner.update();
-            meta.setBlockState(banner);
-            stack.setItemMeta(meta);
-        }
-    }
-
-    private boolean hasMetaPermission(final CommandSource sender, final String metaPerm, final boolean graceful, final boolean includeBase, final IEssentials ess) throws Exception {
-        final User user = sender != null && sender.isPlayer() ? ess.getUser(sender.getPlayer()) : null;
-        return hasMetaPermission(user, metaPerm, graceful, includeBase);
-    }
-
-    private boolean hasMetaPermission(final User user, final String metaPerm, final boolean graceful, final boolean includeBase) throws Exception {
-        final String permBase = includeBase ? "essentials.itemspawn.meta-" : "essentials.";
-        if (user == null || user.isAuthorized(permBase + metaPerm)) {
-            return true;
-        }
-
-        if (graceful) {
-            return false;
-        } else {
-            throw new Exception(tl("noMetaPerm", metaPerm));
-        }
-    }
-
-    private static int bukkitUnbreakableSupport = -1;
-    private static Method spigotMethod;
-    private static Method setUnbreakableMethod;
-
-    private void setUnbreakable(ItemStack is, boolean unbreakable) {
-        ItemMeta meta = is.getItemMeta();
-        try {
-            if (bukkitUnbreakableSupport == -1) {
-                try {
-                    ItemMeta.class.getDeclaredMethod("setUnbreakable", boolean.class);
-                    bukkitUnbreakableSupport = 1;
-                } catch (NoSuchMethodException | SecurityException ex) {
-                    bukkitUnbreakableSupport = 0;
-                }
-            }
-
-            if (bukkitUnbreakableSupport == 1) {
-                meta.setUnbreakable(unbreakable);
-            } else {
-                if (spigotMethod == null) {
-                    spigotMethod = meta.getClass().getDeclaredMethod("spigot");
-                    spigotMethod.setAccessible(true);
-                }
-                Object itemStackSpigot = spigotMethod.invoke(meta);
-                if (setUnbreakableMethod == null) {
-                    setUnbreakableMethod = itemStackSpigot.getClass().getDeclaredMethod("setUnbreakable", Boolean.TYPE);
-                    setUnbreakableMethod.setAccessible(true);
-                }
-                setUnbreakableMethod.invoke(itemStackSpigot, unbreakable);
-            }
-            is.setItemMeta(meta);
-        } catch (Throwable t) {
-            t.printStackTrace();
-        }
-    }
-}

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

@@ -1,224 +0,0 @@
-package com.earth2me.essentials;
-
-import com.earth2me.essentials.utils.EnumUtil;
-import net.ess3.nms.refl.ReflUtil;
-import org.bukkit.entity.Entity;
-import org.bukkit.entity.EntityType;
-import org.bukkit.entity.Ocelot;
-import org.bukkit.entity.Villager;
-
-import java.lang.reflect.InvocationTargetException;
-import java.lang.reflect.Method;
-
-import static com.earth2me.essentials.utils.EnumUtil.getEntityType;
-
-public class MobCompat {
-
-    // Constants for mobs added in later versions
-    public static final EntityType LLAMA = getEntityType("LLAMA");
-    public static final EntityType PARROT = getEntityType("PARROT");
-    public static final EntityType TROPICAL_FISH = getEntityType("TROPICAL_FISH");
-    public static final EntityType PANDA = getEntityType("PANDA");
-    public static final EntityType TRADER_LLAMA = getEntityType("TRADER_LLAMA");
-
-    // Constants for mobs that have changed since earlier versions
-    public static final EntityType CAT = getEntityType("CAT", "OCELOT");
-
-    public enum CatType {
-        // These are (loosely) Mojang names for the cats
-        SIAMESE("SIAMESE", "SIAMESE_CAT"),
-        WHITE("WHITE", "SIAMESE_CAT"),
-        RED("RED", "RED_CAT"),
-        TABBY("TABBY", "RED_CAT"),
-        TUXEDO("BLACK", "BLACK_CAT"),
-        BRITISH_SHORTHAIR("BRITISH_SHORTHAIR", "SIAMESE_CAT"),
-        CALICO("CALICO", "RED_CAT"),
-        PERSIAN("PERSIAN", "RED_CAT"),
-        RAGDOLL("RAGDOLL", "SIAMESE_CAT"),
-        JELLIE("JELLIE", "SIAMESE_CAT"),
-        BLACK("ALL_BLACK", "BLACK_CAT"),
-        ;
-
-        private final String catTypeName;
-        private final String ocelotTypeName;
-
-        CatType(final String catTypeName, final String ocelotTypeName) {
-            this.catTypeName = catTypeName;
-            this.ocelotTypeName = ocelotTypeName;
-        }
-    }
-
-    public enum VillagerProfession {
-        // These are 1.14+ villager professions mapped to their respective pre-V&P profession and career
-        NONE("FARMER", "FARMER", "NONE"),
-        ARMORER("BLACKSMITH", "ARMORER"),
-        BUTCHER("FARMER", "BUTCHER"),
-        CARTOGRAPHER("LIBRARIAN", "CARTOGRAPHER"),
-        CLERIC("PRIEST", "CLERIC"),
-        FARMER("FARMER", "FARMER"),
-        FISHERMAN("FARMER", "FISHERMAN"),
-        FLETCHER("FARMER", "FLETCHER"),
-        LEATHERWORKER("BUTCHER", "LEATHERWORKER"),
-        LIBRARIAN("LIBRARIAN", "LIBRARIAN"),
-        MASON(null, null, "MASON"),
-        NITWIT("NITWIT", "NITWIT"),
-        SHEPHERD("FARMER", "SHEPHERD"),
-        TOOLSMITH("BLACKSMITH", "TOOL_SMITH", "TOOLSMITH"),
-        WEAPONSMITH("BLACKSMITH", "WEAPON_SMITH", "WEAPONSMITH")
-        ;
-
-        private String oldProfession;
-        private String oldCareer;
-        private String newProfession;
-
-        VillagerProfession(final String oldProfession, final String career) {
-            this.oldProfession = oldProfession;
-            this.oldCareer = career;
-            this.newProfession = career;
-        }
-
-        VillagerProfession(final String oldProfession, final String oldCareer, final String newProfession) {
-            this.oldProfession = oldProfession;
-            this.oldCareer = oldCareer;
-            this.newProfession = newProfession;
-        }
-
-        private Villager.Profession asEnum() {
-            return EnumUtil.valueOf(Villager.Profession.class, newProfession, oldProfession);
-        }
-    }
-
-    // Older cats are Ocelots, whereas 1.14+ cats are Cats
-    private static Class catClass = ReflUtil.getClassCached("org.bukkit.entity.Cat");
-    private static Class catTypeClass = ReflUtil.getClassCached("org.bukkit.entity.Cat.Type");
-    private static Method catSetTypeMethod = (catClass == null || catTypeClass == null) ? null : ReflUtil.getMethodCached(catClass, "setCatType", catTypeClass);
-
-    private static boolean isNewCat() {
-        return (catClass != null && catTypeClass != null && catSetTypeMethod != null);
-    }
-
-    public static void setCatType(final Entity entity, final CatType type) {
-        if (isNewCat()) {
-            try {
-                catSetTypeMethod.invoke(entity, EnumUtil.valueOf(catTypeClass, type.catTypeName));
-            } catch (IllegalAccessException | InvocationTargetException e) {
-                e.printStackTrace();
-            }
-        } else {
-            ((Ocelot) entity).setCatType(Ocelot.Type.valueOf(type.ocelotTypeName));
-        }
-    }
-
-    // Older villagers have professions and careers, 1.14+ villagers only have professions
-    private static Class villagerCareerClass = ReflUtil.getClassCached("org.bukkit.entity.Villager.Career");
-    private static Method villagerSetCareerMethod = (villagerCareerClass == null) ? null : ReflUtil.getMethodCached(Villager.class, "setCareer", villagerCareerClass);
-
-    private static boolean isCareerVillager() {
-        return (villagerCareerClass != null && villagerSetCareerMethod != null);
-    }
-
-    public static void setVillagerProfession(final Entity entity, final VillagerProfession profession) {
-        if (!isCareerVillager()) {
-            ((Villager) entity).setProfession(profession.asEnum());
-        } else {
-            ((Villager) entity).setProfession(profession.asEnum());
-            try {
-                villagerSetCareerMethod.invoke(entity, EnumUtil.valueOf(villagerCareerClass, profession.oldCareer));
-            } catch (Exception e) {
-                e.printStackTrace();
-            }
-        }
-    }
-
-    // Only 1.14+ villagers have biome variants
-    public static void setVillagerType(final Entity entity, final String type) {
-        Class typeEnum = ReflUtil.getClassCached("org.bukkit.entity.Villager.Type");
-        if (typeEnum == null) return;
-
-        Method villagerSetTypeMethod = ReflUtil.getMethodCached(Villager.class, "setVillagerType", typeEnum);
-        try {
-            villagerSetTypeMethod.invoke(entity, EnumUtil.valueOf(typeEnum, type));
-        } catch (Exception e) {
-            e.printStackTrace();
-        }
-    }
-
-    // Llamas only exist in 1.11+
-    public static void setLlamaColor(final Entity entity, final String color) {
-        Class llamaClass = ReflUtil.getClassCached("org.bukkit.entity.Llama");
-        if (llamaClass == null) return;
-
-        Class colorEnum = ReflUtil.getClassCached("org.bukkit.entity.Llama.Color");
-        Method setVariantMethod = ReflUtil.getMethodCached(llamaClass, "setColor");
-
-        try {
-            setVariantMethod.invoke(entity, EnumUtil.valueOf(colorEnum, color));
-        } catch (Exception e) {
-            e.printStackTrace();
-        }
-    }
-
-    // Parrots only exist in 1.12+
-    public static void setParrotVariant(final Entity entity, final String variant) {
-        Class parrotClass = ReflUtil.getClassCached("org.bukkit.entity.Parrot");
-        if (parrotClass == null) return;
-
-        Class variantEnum = ReflUtil.getClassCached("org.bukkit.entity.Parrot.Variant");
-        Method setVariantMethod = ReflUtil.getMethodCached(parrotClass, "setVariant");
-        try {
-            setVariantMethod.invoke(entity, EnumUtil.valueOf(variantEnum, variant));
-        } catch (Exception e) {
-            e.printStackTrace();
-        }
-    }
-
-    // Tropical fish only exist in 1.13+
-    public static void setTropicalFishPattern(final Entity entity, final String pattern) {
-        Class tropicalFishClass = ReflUtil.getClassCached("org.bukkit.entity.TropicalFish");
-        if (tropicalFishClass == null) return;
-
-        Class patternEnum = ReflUtil.getClassCached("org.bukkit.entity.TropicalFish.Pattern");
-        Method setPatternMethod = ReflUtil.getMethodCached(tropicalFishClass, "setPattern");
-        try {
-            setPatternMethod.invoke(entity, EnumUtil.valueOf(patternEnum, pattern));
-        } catch (Exception e) {
-            e.printStackTrace();
-        }
-    }
-
-    // Mushroom cow variant API only exists in 1.14+
-    public static void setMooshroomVariant(final Entity entity, final String variant) {
-        Class mushroomCowClass = ReflUtil.getClassCached("org.bukkit.entity.MushroomCow");
-        Class variantEnum = ReflUtil.getClassCached("org.bukkit.entity.MushroomCow.Variant");
-        if (mushroomCowClass == null || variantEnum == null) return;
-
-        Method setVariantMethod = ReflUtil.getMethodCached(mushroomCowClass, "setVariant");
-        try {
-            setVariantMethod.invoke(entity, EnumUtil.valueOf(variantEnum, variant));
-        } catch (Exception e) {
-            e.printStackTrace();
-        }
-    }
-
-    // Pandas only exists in 1.14+
-    public static void setPandaGene(final Entity entity, final String gene, final boolean mainGene) {
-        Class pandaClass = ReflUtil.getClassCached("org.bukkit.entity.Panda");
-        if (pandaClass == null) return;
-
-        Class geneEnum = ReflUtil.getClassCached("org.bukkit.entity.Panda.Gene");
-        Method setGeneMethod;
-
-        if (mainGene) {
-            setGeneMethod = ReflUtil.getMethodCached(pandaClass, "setMainGene");
-        } else {
-            setGeneMethod = ReflUtil.getMethodCached(pandaClass, "setHiddenGene");
-        }
-
-        try {
-            setGeneMethod.invoke(entity, EnumUtil.valueOf(geneEnum, gene));
-        } catch (Exception e) {
-            e.printStackTrace();
-        }
-    }
-
-}

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

@@ -1,123 +0,0 @@
-package com.earth2me.essentials;
-
-import com.earth2me.essentials.utils.FormatUtil;
-import org.bukkit.Server;
-
-import java.util.*;
-
-import static com.earth2me.essentials.I18n.tl;
-
-
-public class PlayerList {
-    // Cosmetic list formatting
-    public static String listUsers(final IEssentials ess, final List<User> users, final String seperator) {
-        final StringBuilder groupString = new StringBuilder();
-        Collections.sort(users);
-        boolean needComma = false;
-        for (User user : users) {
-            if (needComma) {
-                groupString.append(seperator);
-            }
-            needComma = true;
-            if (user.isAfk()) {
-                groupString.append(tl("listAfkTag"));
-            }
-            if (user.isHidden()) {
-                groupString.append(tl("listHiddenTag"));
-            }
-            user.setDisplayNick();
-            groupString.append(user.getDisplayName());
-            groupString.append("\u00a7f");
-        }
-        return groupString.toString();
-    }
-
-    // Produce a user summary: There are 5 out of maximum 10 players online.
-    public static String listSummary(final IEssentials ess, final User user, final boolean showHidden) {
-        Server server = ess.getServer();
-        int playerHidden = 0;
-        int hiddenCount = 0;
-        for (User onlinePlayer : ess.getOnlineUsers()) {
-            if (onlinePlayer.isHidden() || (user != null && !user.getBase().canSee(onlinePlayer.getBase()))) {
-                playerHidden++;
-                if (showHidden || user.getBase().canSee(onlinePlayer.getBase())) {
-                    hiddenCount++;
-                }
-            }
-        }
-        String online;
-        if (hiddenCount > 0) {
-            online = tl("listAmountHidden", ess.getOnlinePlayers().size() - playerHidden, hiddenCount, server.getMaxPlayers());
-        } else {
-            online = tl("listAmount", ess.getOnlinePlayers().size() - playerHidden, server.getMaxPlayers());
-        }
-        return online;
-    }
-
-    // Build the basic player list, divided by groups.
-    public static Map<String, List<User>> getPlayerLists(final IEssentials ess, final User sender, final boolean showHidden) {
-        Server server = ess.getServer();
-        final Map<String, List<User>> playerList = new HashMap<String, List<User>>();
-        for (User onlineUser : ess.getOnlineUsers()) {
-            if ((sender == null && !showHidden && onlineUser.isHidden()) || (sender != null && !showHidden && !sender.getBase().canSee(onlineUser.getBase()))) {
-                continue;
-            }
-            final String group = FormatUtil.stripFormat(FormatUtil.stripEssentialsFormat(onlineUser.getGroup().toLowerCase()));
-            List<User> list = playerList.get(group);
-            if (list == null) {
-                list = new ArrayList<User>();
-                playerList.put(group, list);
-            }
-            list.add(onlineUser);
-        }
-        return playerList;
-    }
-
-    // Handle the merging of groups
-    public static List<User> getMergedList(final IEssentials ess, final Map<String, List<User>> playerList, final String groupName) {
-        final Set<String> configGroups = ess.getSettings().getListGroupConfig().keySet();
-        final List<User> users = new ArrayList<User>();
-        for (String configGroup : configGroups) {
-            if (configGroup.equalsIgnoreCase(groupName)) {
-                String[] groupValues = ess.getSettings().getListGroupConfig().get(configGroup).toString().trim().split(" ");
-                for (String groupValue : groupValues) {
-                    groupValue = groupValue.toLowerCase(Locale.ENGLISH);
-                    if (groupValue == null || groupValue.isEmpty()) {
-                        continue;
-                    }
-                    List<User> u = playerList.get(groupValue.trim());
-                    if (u == null || u.isEmpty()) {
-                        continue;
-                    }
-                    playerList.remove(groupValue);
-                    users.addAll(u);
-                }
-            }
-        }
-        return users;
-    }
-
-    // Output a playerlist of just a single group, /list <groupname>
-    public static String listGroupUsers(final IEssentials ess, final Map<String, List<User>> playerList, final String groupName) throws Exception {
-        final List<User> users = getMergedList(ess, playerList, groupName);
-        final List<User> groupUsers = playerList.get(groupName);
-        if (groupUsers != null && !groupUsers.isEmpty()) {
-            users.addAll(groupUsers);
-        }
-        if (users == null || users.isEmpty()) {
-            throw new Exception(tl("groupDoesNotExist"));
-        }
-        final StringBuilder displayGroupName = new StringBuilder();
-        displayGroupName.append(Character.toTitleCase(groupName.charAt(0)));
-        displayGroupName.append(groupName.substring(1));
-        return outputFormat(displayGroupName.toString(), listUsers(ess, users, ", "));
-    }
-
-    // Build the output string
-    public static String outputFormat(final String group, final String message) {
-        final StringBuilder outputString = new StringBuilder();
-        outputString.append(tl("listGroupTag", FormatUtil.replaceFormat(group)));
-        outputString.append(message);
-        return outputString.toString();
-    }
-}

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

@@ -1,52 +0,0 @@
-package com.earth2me.essentials;
-
-import net.ess3.api.IEssentials;
-import org.bukkit.entity.LivingEntity;
-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);
-        }
-    }
-
-    @EventHandler(priority = EventPriority.LOW)
-    public void onEntityExplode(final EntityExplodeEvent event) {
-        if (!enabled) {
-            return;
-        }
-        if (event.getEntity() instanceof LivingEntity) {
-            return;
-        }
-        if (event.blockList().size() < 1) {
-            return;
-        }
-        event.setCancelled(true);
-        event.getLocation().getWorld().createExplosion(event.getLocation(), 0F);
-    }
-
-    @Override
-    public void run() {
-        enabled = false;
-    }
-}

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

@@ -1,338 +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 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;
-
-
-public class Teleport implements ITeleport {
-    private final IUser teleportOwner;
-    private final IEssentials ess;
-    private TimedTeleport timedTeleport;
-
-    private TeleportType tpType;
-
-    public Teleport(IUser user, IEssentials ess) {
-        this.teleportOwner = user;
-        this.ess = ess;
-        tpType = TeleportType.NORMAL;
-    }
-
-    public enum TeleportType {
-        TPA,
-        BACK,
-        NORMAL
-    }
-
-    public void cooldown(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());
-        }
-    }
-
-    private boolean cooldownApplies() {
-        boolean applies = true;
-        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;
-    }
-
-    private void warnUser(final IUser user, final double delay) {
-        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
-    public void now(Location loc, boolean cooldown, TeleportCause cause) throws Exception {
-        if (cooldown) {
-            cooldown(false);
-        }
-        final ITarget target = new LocationTarget(loc);
-        now(teleportOwner, target, cause);
-    }
-
-    @Override
-    public void now(Player entity, boolean cooldown, 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()));
-    }
-
-    protected void now(IUser teleportee, ITarget target, TeleportCause cause) throws Exception {
-        cancel(false);
-        teleportee.setLastLocation();
-        Location loc = target.getLocation();
-
-        if (LocationUtil.isBlockUnsafeForUser(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(Location loc, Trade chargeFor) throws Exception {
-        teleport(loc, chargeFor, TeleportCause.PLUGIN);
-    }
-
-    @Override
-    public void teleport(Location loc, Trade chargeFor, TeleportCause cause) throws Exception {
-        teleport(teleportOwner, new LocationTarget(loc), chargeFor, cause);
-    }
-
-    //This is used when teleporting to a player
-    @Override
-    public void teleport(Player entity, Trade chargeFor, TeleportCause cause) throws Exception {
-        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
-    public void teleportPlayer(IUser teleportee, Location loc, Trade chargeFor, TeleportCause cause) throws Exception {
-        teleport(teleportee, new LocationTarget(loc), chargeFor, cause);
-    }
-
-    //This is used on /tphere
-    @Override
-    public void teleportPlayer(IUser teleportee, Player entity, Trade chargeFor, TeleportCause cause) throws Exception {
-        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()));
-    }
-
-    private void teleport(IUser teleportee, ITarget target, Trade chargeFor, TeleportCause cause) throws Exception {
-        double delay = ess.getSettings().getTeleportDelay();
-
-        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);
-    }
-
-    private void teleportOther(IUser teleporter, IUser teleportee, ITarget target, Trade chargeFor, TeleportCause cause) throws Exception {
-        double delay = ess.getSettings().getTeleportDelay();
-
-        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
-    public void respawn(final Trade chargeFor, TeleportCause cause) throws Exception {
-        double delay = ess.getSettings().getTeleportDelay();
-        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);
-    }
-
-    void respawnNow(IUser teleportee, TeleportCause cause) throws Exception {
-        final Player player = teleportee.getBase();
-        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
-    public void warp(IUser teleportee, String warp, Trade chargeFor, TeleportCause cause) throws Exception {
-        UserWarpEvent event = new UserWarpEvent(teleportee, warp, chargeFor);
-        Bukkit.getServer().getPluginManager().callEvent(event);
-
-        if(event.isCancelled()) {
-            return;
-        }
-        warp = event.getWarp();
-        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
-    public void back(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
-    public void back(IUser teleporter, 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
-    public void back() throws Exception {
-        now(teleportOwner, new LocationTarget(teleportOwner.getLastLocation()), TeleportCause.COMMAND);
-    }
-
-    public void setTpType(TeleportType tpType) {
-        this.tpType = tpType;
-    }
-
-    //If we need to cancelTimer a pending teleportPlayer call this method
-    private void cancel(boolean notifyUser) {
-        if (timedTeleport != null) {
-            timedTeleport.cancelTimer(notifyUser);
-            timedTeleport = null;
-        }
-    }
-
-    private void initTimer(long delay, IUser teleportUser, ITarget target, Trade chargeFor, TeleportCause cause, boolean respawn) {
-        timedTeleport = new TimedTeleport(teleportOwner, ess, this, delay, teleportUser, target, chargeFor, cause, respawn);
-    }
-}

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

@@ -1,154 +0,0 @@
-package com.earth2me.essentials;
-
-import com.google.common.io.Files;
-import org.bukkit.Bukkit;
-
-import java.io.*;
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.Map;
-import java.util.UUID;
-import java.util.concurrent.*;
-import java.util.logging.Level;
-import java.util.regex.Pattern;
-
-
-public class UUIDMap {
-    private final transient net.ess3.api.IEssentials ess;
-    private File userList;
-    private final transient Pattern splitPattern = Pattern.compile(",");
-
-    private static boolean pendingWrite;
-    private static final ScheduledExecutorService writeScheduler = Executors.newScheduledThreadPool(1);
-    private final Runnable writeTaskRunnable;
-
-    private static boolean loading = false;
-
-    public UUIDMap(final net.ess3.api.IEssentials ess) {
-        this.ess = ess;
-        userList = new File(ess.getDataFolder(), "usermap.csv");
-        pendingWrite = false;
-        writeTaskRunnable = new Runnable() {
-            @Override
-            public void run() {
-                if (pendingWrite) {
-                    try {
-                        new WriteRunner(ess.getDataFolder(), userList, ess.getUserMap().getNames()).run();
-                    } catch (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 (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 (IOException ex) {
-            Bukkit.getLogger().log(Level.SEVERE, ex.getMessage(), ex);
-        }
-    }
-
-    public void writeUUIDMap() {
-        pendingWrite = true;
-    }
-
-    public void forceWriteUUIDMap() {
-        if (ess.getSettings().isDebug()) {
-            ess.getLogger().log(Level.INFO, "Forcing usermap write to disk");
-        }
-        pendingWrite = true;
-        writeTaskRunnable.run();
-    }
-
-    public void shutdown() {
-        writeScheduler.submit(writeTaskRunnable);
-        writeScheduler.shutdown();
-    }
-
-    private static 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 (Map.Entry<String, UUID> entry : names.entrySet()) {
-                    bWriter.write(entry.getKey() + "," + entry.getValue().toString());
-                    bWriter.newLine();
-                }
-
-                bWriter.close();
-                Files.move(configFile, endFile);
-            } catch (IOException ex) {
-                try {
-                    if (configFile != null && configFile.exists()) {
-                        Files.move(configFile, new File(endFile.getParentFile(), "usermap.bak.csv"));
-                    }
-                } catch (Exception ex2) {
-                    Bukkit.getLogger().log(Level.SEVERE, ex2.getMessage(), ex2);
-                }
-                Bukkit.getLogger().log(Level.WARNING, ex.getMessage(), ex);
-            }
-        }
-    }
-}

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

@@ -1,926 +0,0 @@
-package com.earth2me.essentials;
-
-import com.earth2me.essentials.commands.IEssentialsCommand;
-import com.earth2me.essentials.messaging.IMessageRecipient;
-import com.earth2me.essentials.messaging.SimpleMessageRecipient;
-import com.earth2me.essentials.register.payment.Method;
-import com.earth2me.essentials.register.payment.Methods;
-import com.earth2me.essentials.utils.DateUtil;
-import com.earth2me.essentials.utils.FormatUtil;
-import com.earth2me.essentials.utils.NumberUtil;
-import com.earth2me.essentials.utils.VersionUtil;
-import net.ess3.api.IEssentials;
-import net.ess3.api.MaxMoneyException;
-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.nms.refl.ReflUtil;
-
-import org.bukkit.ChatColor;
-import org.bukkit.Location;
-import org.bukkit.Material;
-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.potion.PotionEffect;
-import org.bukkit.potion.PotionEffectType;
-
-import java.math.BigDecimal;
-import java.util.*;
-import java.util.logging.Level;
-import java.util.logging.Logger;
-
-import static com.earth2me.essentials.I18n.tl;
-
-
-public class User extends UserData implements Comparable<User>, IMessageRecipient, net.ess3.api.IUser {
-    private static final Logger logger = Logger.getLogger("Essentials");
-    private IMessageRecipient messageRecipient;
-    private transient UUID teleportRequester;
-    private transient boolean teleportRequestHere;
-    private transient Location teleportLocation;
-    private transient boolean vanished;
-    private transient final Teleport teleport;
-    private transient long teleportRequestTime;
-    private transient long lastOnlineActivity;
-    private transient long lastThrottledAction;
-    private transient long lastActivity = System.currentTimeMillis();
-    private boolean hidden = false;
-    private boolean rightClickJump = false;
-    private transient Location afkPosition = null;
-    private boolean invSee = false;
-    private boolean recipeSee = false;
-    private boolean enderSee = false;
-    private transient long teleportInvulnerabilityTimestamp = 0;
-    private boolean ignoreMsg = false;
-    private String afkMessage;
-    private long afkSince;
-    private Map<User, BigDecimal> confirmingPayments = new WeakHashMap<>();
-    private String confirmingClearCommand;
-    private long lastNotifiedAboutMailsMs;
-
-    public User(final Player base, final IEssentials ess) {
-        super(base, ess);
-        teleport = new Teleport(this, ess);
-        if (isAfk()) {
-            afkPosition = this.getLocation();
-        }
-        if (this.getBase().isOnline()) {
-            lastOnlineActivity = System.currentTimeMillis();
-        }
-        this.messageRecipient = new SimpleMessageRecipient(ess, this);
-    }
-
-    User update(final Player base) {
-        setBase(base);
-        return this;
-    }
-
-    @Override
-    public boolean isAuthorized(final IEssentialsCommand cmd) {
-        return isAuthorized(cmd, "essentials.");
-    }
-
-    @Override
-    public boolean isAuthorized(final IEssentialsCommand cmd, final String permissionPrefix) {
-        return isAuthorized(permissionPrefix + (cmd.getName().equals("r") ? "msg" : cmd.getName()));
-    }
-
-    @Override
-    public boolean isAuthorized(final String node) {
-        final boolean result = isAuthorizedCheck(node);
-        if (ess.getSettings().isDebug()) {
-            ess.getLogger().log(Level.INFO, "checking if " + base.getName() + " has " + node + " - " + result);
-        }
-        return result;
-    }
-
-    @Override
-    public boolean isPermissionSet(final String node) {
-        return isPermSetCheck(node);
-    }
-
-    private boolean isAuthorizedCheck(final String node) {
-
-        if (base instanceof OfflinePlayer) {
-            return false;
-        }
-
-        try {
-            return ess.getPermissionsHandler().hasPermission(base, node);
-        } catch (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) {
-            return false;
-        }
-
-        try {
-            return ess.getPermissionsHandler().isPermissionSet(base, node);
-        } catch (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;
-        }
-    }
-
-    @Override
-    public void healCooldown() throws Exception {
-        final Calendar now = new GregorianCalendar();
-        if (getLastHealTimestamp() > 0) {
-            final double cooldown = ess.getSettings().getHealCooldown();
-            final Calendar cooldownTime = new GregorianCalendar();
-            cooldownTime.setTimeInMillis(getLastHealTimestamp());
-            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())));
-            }
-        }
-        setLastHealTimestamp(now.getTimeInMillis());
-    }
-
-    @Override
-    public void giveMoney(final BigDecimal value) throws MaxMoneyException {
-        giveMoney(value, null);
-    }
-
-    @Override
-    public void giveMoney(final BigDecimal value, final CommandSource initiator) throws MaxMoneyException {
-        if (value.signum() == 0) {
-            return;
-        }
-        setMoney(getMoney().add(value));
-        sendMessage(tl("addedToAccount", NumberUtil.displayCurrency(value, ess)));
-        if (initiator != null) {
-            initiator.sendMessage(tl("addedToOthersAccount", NumberUtil.displayCurrency(value, ess), this.getDisplayName(), NumberUtil.displayCurrency(getMoney(), ess)));
-        }
-    }
-
-    @Override
-    public void payUser(final User reciever, final BigDecimal value) throws Exception {
-        if (value.compareTo(BigDecimal.ZERO) < 1) {
-            throw new Exception(tl("payMustBePositive"));
-        }
-
-        if (canAfford(value)) {
-            setMoney(getMoney().subtract(value));
-            reciever.setMoney(reciever.getMoney().add(value));
-            sendMessage(tl("moneySentTo", NumberUtil.displayCurrency(value, ess), reciever.getDisplayName()));
-            reciever.sendMessage(tl("moneyRecievedFrom", NumberUtil.displayCurrency(value, ess), getDisplayName()));
-        } else {
-            throw new ChargeException(tl("notEnoughMoney", NumberUtil.displayCurrency(value, ess)));
-        }
-    }
-
-    @Override
-    public void takeMoney(final BigDecimal value) {
-        takeMoney(value, null);
-    }
-
-    @Override
-    public void takeMoney(final BigDecimal value, final CommandSource initiator) {
-        if (value.signum() == 0) {
-            return;
-        }
-        try {
-            setMoney(getMoney().subtract(value));
-        } catch (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)));
-        if (initiator != null) {
-            initiator.sendMessage(tl("takenFromOthersAccount", NumberUtil.displayCurrency(value, ess), this.getDisplayName(), NumberUtil.displayCurrency(getMoney(), ess)));
-        }
-    }
-
-    @Override
-    public boolean canAfford(final BigDecimal cost) {
-        return canAfford(cost, true);
-    }
-
-    public boolean canAfford(final BigDecimal cost, final boolean permcheck) {
-        if (cost.signum() <= 0) {
-            return true;
-        }
-        final BigDecimal remainingBalance = getMoney().subtract(cost);
-        if (!permcheck || isAuthorized("essentials.eco.loan")) {
-            return (remainingBalance.compareTo(ess.getSettings().getMinMoney()) >= 0);
-        }
-        return (remainingBalance.signum() >= 0);
-    }
-
-    public void dispose() {
-        ess.runTaskAsynchronously(new Runnable() {
-            @Override
-            public void run() {
-                _dispose();
-            }
-        });
-    }
-
-    private void _dispose() {
-        if (!base.isOnline()) {
-            this.base = new OfflinePlayer(getConfigUUID(), ess.getServer());
-        }
-        cleanup();
-    }
-
-    @Override
-    public Boolean canSpawnItem(final Material material) {
-        if (ess.getSettings().permissionBasedItemSpawn()) {
-            final String name = material.toString().toLowerCase(Locale.ENGLISH).replace("_", "");
-
-            if (isAuthorized("essentials.itemspawn.item-all") || isAuthorized("essentials.itemspawn.item-" + name)) return true;
-
-            if (VersionUtil.getServerBukkitVersion().isLowerThan(VersionUtil.v1_13_0_R01)) {
-                final int id = material.getId();
-                if (isAuthorized("essentials.itemspawn.item-" + id)) return true;
-            }
-        }
-
-        return isAuthorized("essentials.itemspawn.exempt") || !ess.getSettings().itemSpawnBlacklist().contains(material);
-    }
-
-    @Override
-    public void setLastLocation() {
-        setLastLocation(this.getLocation());
-    }
-
-    @Override
-    public void setLogoutLocation() {
-        setLogoutLocation(this.getLocation());
-    }
-
-    @Override
-    public void requestTeleport(final User player, final boolean here) {
-        teleportRequestTime = System.currentTimeMillis();
-        teleportRequester = player == null ? null : player.getBase().getUniqueId();
-        teleportRequestHere = here;
-        if (player == null) {
-            teleportLocation = null;
-        } else {
-            teleportLocation = here ? player.getLocation() : this.getLocation();
-        }
-    }
-
-    @Override
-    public boolean hasOutstandingTeleportRequest() {
-        if (getTeleportRequest() != null) { // Player has outstanding teleport request.
-            long timeout = ess.getSettings().getTpaAcceptCancellation();
-            if (timeout != 0) {
-                if ((System.currentTimeMillis() - getTeleportRequestTime()) / 1000 <= timeout) { // Player has outstanding request
-                    return true;
-                } else { // outstanding request expired.
-                    requestTeleport(null, false);
-                    return false;
-                }
-            } else { // outstanding request does not expire
-                return true;
-            }
-        }
-        return false;
-    }
-
-    public UUID getTeleportRequest() {
-        return teleportRequester;
-    }
-
-    public boolean isTpRequestHere() {
-        return teleportRequestHere;
-    }
-
-    public Location getTpRequestLocation() {
-        return teleportLocation;
-    }
-
-    public String getNick(final boolean longnick) {
-        return getNick(longnick, true, true);
-    }
-
-    public String getNick(final boolean longnick, final boolean withPrefix, final boolean withSuffix) {
-        final StringBuilder prefix = new StringBuilder();
-        String nickname;
-        String suffix = "";
-        final String nick = getNickname();
-        if (ess.getSettings().isCommandDisabled("nick") || nick == null || nick.isEmpty() || nick.equals(getName())) {
-            nickname = getName();
-        } else if (nick.equalsIgnoreCase(getName())) {
-            nickname = nick;
-        } else {
-            nickname = FormatUtil.replaceFormat(ess.getSettings().getNicknamePrefix()) + nick;
-            suffix = "§r";
-        }
-
-        if (this.getBase().isOp()) {
-            try {
-                final ChatColor opPrefix = ess.getSettings().getOperatorColor();
-                if (opPrefix != null && opPrefix.toString().length() > 0) {
-                    prefix.insert(0, opPrefix.toString());
-                    suffix = "§r";
-                }
-            } catch (Exception e) {
-            }
-        }
-
-        if (ess.getSettings().addPrefixSuffix()) {
-            //These two extra toggles are not documented, because they are mostly redundant #EasterEgg
-            if (withPrefix || !ess.getSettings().disablePrefix()) {
-                final String ptext = ess.getPermissionsHandler().getPrefix(base).replace('&', '§');
-                prefix.insert(0, ptext);
-                suffix = "§r";
-            }
-            if (withSuffix || !ess.getSettings().disableSuffix()) {
-                final String stext = ess.getPermissionsHandler().getSuffix(base).replace('&', '§');
-                suffix = stext + "§r";
-                suffix = suffix.replace("§f§f", "§f").replace("§f§r", "§r").replace("§r§r", "§r");
-            }
-        }
-        final String strPrefix = prefix.toString();
-        String output = strPrefix + nickname + suffix;
-        if (!longnick && output.length() > 16) {
-            output = strPrefix + nickname;
-        }
-        if (!longnick && output.length() > 16) {
-            output = FormatUtil.lastCode(strPrefix) + nickname;
-        }
-        if (!longnick && output.length() > 16) {
-            output = FormatUtil.lastCode(strPrefix) + nickname.substring(0, 14);
-        }
-        if (output.charAt(output.length() - 1) == '§') {
-            output = output.substring(0, output.length() - 1);
-        }
-        return output;
-    }
-
-    public void setDisplayNick() {
-        if (base.isOnline() && ess.getSettings().changeDisplayName()) {
-            this.getBase().setDisplayName(getNick(true));
-            if (isAfk()) {
-                updateAfkListName();
-            } else if (ess.getSettings().changePlayerListName()) {
-                // 1.8 enabled player list-names longer than 16 characters.
-                // If the server is on 1.8 or higher, provide that functionality. Otherwise, keep prior functionality.
-                boolean higherOrEqualTo1_8 = ReflUtil.getNmsVersionObject().isHigherThanOrEqualTo(ReflUtil.V1_8_R1);
-                String name = getNick(higherOrEqualTo1_8, ess.getSettings().isAddingPrefixInPlayerlist(), ess.getSettings().isAddingSuffixInPlayerlist());
-                try {
-                    this.getBase().setPlayerListName(name);
-                } catch (IllegalArgumentException e) {
-                    if (ess.getSettings().isDebug()) {
-                        logger.log(Level.INFO, "Playerlist for " + name + " was not updated. Name clashed with another online player.");
-                    }
-                }
-            }
-        }
-    }
-
-    public String getDisplayName() {
-        return super.getBase().getDisplayName() == null || (ess.getSettings().hideDisplayNameInVanish() && isHidden()) ? super.getBase().getName() : super.getBase().getDisplayName();
-    }
-
-    @Override
-    public Teleport getTeleport() {
-        return teleport;
-    }
-
-    public long getLastOnlineActivity() {
-        return lastOnlineActivity;
-    }
-
-    public void setLastOnlineActivity(final long timestamp) {
-        lastOnlineActivity = timestamp;
-    }
-
-    @Override
-    public BigDecimal getMoney() {
-        final long start = System.nanoTime();
-        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);
-        }
-        return value;
-    }
-
-    private BigDecimal _getMoney() {
-        if (ess.getSettings().isEcoDisabled()) {
-            if (ess.getSettings().isDebug()) {
-                ess.getLogger().info("Internal economy functions disabled, aborting balance check.");
-            }
-            return BigDecimal.ZERO;
-        }
-        if (Methods.hasMethod()) {
-            try {
-                final Method method = Methods.getMethod();
-                if (!method.hasAccount(this.getName())) {
-                    throw new Exception();
-                }
-                final Method.MethodAccount account = Methods.getMethod().getAccount(this.getName());
-                return BigDecimal.valueOf(account.balance());
-            } catch (Exception ex) {
-            }
-        }
-        return super.getMoney();
-    }
-
-    @Override
-    public void setMoney(final BigDecimal value) throws MaxMoneyException {
-        if (ess.getSettings().isEcoDisabled()) {
-            if (ess.getSettings().isDebug()) {
-                ess.getLogger().info("Internal economy functions disabled, aborting balance change.");
-            }
-            return;
-        }
-        final BigDecimal oldBalance = _getMoney();
-        
-        UserBalanceUpdateEvent updateEvent = new UserBalanceUpdateEvent(this.getBase(), oldBalance, value);
-        ess.getServer().getPluginManager().callEvent(updateEvent);
-        BigDecimal newBalance = updateEvent.getNewBalance();
-        
-        if (Methods.hasMethod()) {
-            try {
-                final Method method = Methods.getMethod();
-                if (!method.hasAccount(this.getName())) {
-                    throw new Exception();
-                }
-                final Method.MethodAccount account = Methods.getMethod().getAccount(this.getName());
-                account.set(newBalance.doubleValue());
-            } catch (Exception ex) {
-            }
-        }
-        super.setMoney(newBalance, true);
-        Trade.log("Update", "Set", "API", getName(), new Trade(newBalance, ess), null, null, null, ess);
-    }
-
-    public void updateMoneyCache(final BigDecimal value) {
-        if (ess.getSettings().isEcoDisabled()) {
-            return;
-        }
-        if (Methods.hasMethod() && super.getMoney() != value) {
-            try {
-                super.setMoney(value, false);
-            } catch (MaxMoneyException ex) {
-                // We don't want to throw any errors here, just updating a cache
-            }
-        }
-    }
-
-    @Override
-    public void setAfk(final boolean set) {
-        final AfkStatusChangeEvent afkEvent = new AfkStatusChangeEvent(this, set);
-        ess.getServer().getPluginManager().callEvent(afkEvent);
-        if (afkEvent.isCancelled()) {
-            return;
-        }
-
-        this.getBase().setSleepingIgnored(this.isAuthorized("essentials.sleepingignored") || set && ess.getSettings().sleepIgnoresAfkPlayers());
-        if (set && !isAfk()) {
-            afkPosition = this.getLocation();
-            this.afkSince = System.currentTimeMillis();
-        } else if (!set && isAfk()) {
-            afkPosition = null;
-            this.afkMessage = null;
-            this.afkSince = 0;
-        }
-        _setAfk(set);
-        updateAfkListName();
-    }
-    
-    private void updateAfkListName() {
-        if (ess.getSettings().isAfkListName()) {
-            if(isAfk()) {
-                String afkName = ess.getSettings().getAfkListName().replace("{PLAYER}", getDisplayName()).replace("{USERNAME}", getName());
-                getBase().setPlayerListName(afkName);
-            } else {
-                getBase().setPlayerListName(null);
-            }
-        }
-    }
-
-    public boolean toggleAfk() {
-        setAfk(!isAfk());
-        return isAfk();
-    }
-
-    @Override
-    public boolean isHidden() {
-        return hidden;
-    }
-
-    public boolean isHidden(final Player player) {
-        return hidden || !player.canSee(getBase());
-    }
-
-    @Override
-    public void setHidden(final boolean hidden) {
-        this.hidden = hidden;
-        if (hidden == true) {
-            setLastLogout(getLastOnlineActivity());
-        }
-    }
-
-    //Returns true if status expired during this check
-    public boolean checkJailTimeout(final long currentTime) {
-        if (getJailTimeout() > 0 && getJailTimeout() < currentTime && isJailed()) {
-            final JailStatusChangeEvent event = new JailStatusChangeEvent(this, null, false);
-            ess.getServer().getPluginManager().callEvent(event);
-
-            if (!event.isCancelled()) {
-                setJailTimeout(0);
-                setJailed(false);
-                sendMessage(tl("haveBeenReleased"));
-                setJail(null);
-                if (ess.getSettings().isTeleportBackWhenFreedFromJail()) {
-                    try {
-                        getTeleport().back();
-                    } catch (Exception ex) {
-                        try {
-                            getTeleport().respawn(null, TeleportCause.PLUGIN);
-                        } catch (Exception ex1) {
-                        }
-                    }
-                }
-                return true;
-            }
-        }
-        return false;
-    }
-
-    //Returns true if status expired during this check
-    public boolean checkMuteTimeout(final long currentTime) {
-        if (getMuteTimeout() > 0 && getMuteTimeout() < currentTime && isMuted()) {
-            final MuteStatusChangeEvent event = new MuteStatusChangeEvent(this, null, false);
-            ess.getServer().getPluginManager().callEvent(event);
-            
-            if (!event.isCancelled()) {
-                setMuteTimeout(0);
-                sendMessage(tl("canTalkAgain"));
-                setMuted(false);
-                setMuteReason(null);
-                return true;
-            }
-        }
-        return false;
-    }
-
-    public void updateActivity(final boolean broadcast) {
-        if (isAfk()) {
-            setAfk(false);
-            if (broadcast && !isHidden()) {
-                setDisplayNick();
-                final String msg = tl("userIsNotAway", getDisplayName());
-                if (!msg.isEmpty()) {
-                    ess.broadcastMessage(this, msg);
-                }
-            }
-        }
-        lastActivity = System.currentTimeMillis();
-    }
-
-    public void updateActivityOnMove(final boolean broadcast) {
-        if(ess.getSettings().cancelAfkOnMove()) {
-            updateActivity(broadcast);
-        }
-    }
-
-    public void updateActivityOnInteract(final boolean broadcast) {
-        if(ess.getSettings().cancelAfkOnInteract()) {
-            updateActivity(broadcast);
-        }
-    }
-
-    public void checkActivity() {
-        // 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()
-            && !isAuthorized("essentials.kick.exempt")
-            && !isAuthorized("essentials.afk.kickexempt")) {
-            final String kickReason = tl("autoAfkKickReason", autoafkkick / 60.0);
-            lastActivity = 0;
-            this.getBase().kickPlayer(kickReason);
-
-
-            for (User user : ess.getOnlineUsers()) {
-                if (user.isAuthorized("essentials.kick.notify")) {
-                    user.sendMessage(tl("playerKicked", Console.NAME, getName(), kickReason));
-                }
-            }
-        }
-        final long autoafk = ess.getSettings().getAutoAfk();
-        if (!isAfk() && autoafk > 0 && lastActivity + autoafk * 1000 < System.currentTimeMillis() && isAuthorized("essentials.afk.auto")) {
-            setAfk(true);
-            if (!isHidden()) {
-                setDisplayNick();
-                final String msg = tl("userIsAway", getDisplayName());
-                if (!msg.isEmpty()) {
-                    ess.broadcastMessage(this, msg);
-                }
-            }
-        }
-    }
-
-    public Location getAfkPosition() {
-        return afkPosition;
-    }
-
-    @Override
-    public boolean isGodModeEnabled() {
-        if (super.isGodModeEnabled()) {
-            // 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()).
-            if (!ess.getSettings().getNoGodWorlds().contains(this.getLocation().getWorld().getName())) {
-                return true;
-            }
-        }
-        if (isAfk()) {
-            // Protect AFK players by representing them in a god mode state to render them invulnerable to damage.
-            if (ess.getSettings().getFreezeAfkPlayers()) {
-                return true;
-            }
-        }
-        return false;
-    }
-
-    public boolean isGodModeEnabledRaw() {
-        return super.isGodModeEnabled();
-    }
-
-    @Override
-    public String getGroup() {
-        final String result = ess.getPermissionsHandler().getGroup(base);
-        if (ess.getSettings().isDebug()) {
-            ess.getLogger().log(Level.INFO, "looking up groupname of " + base.getName() + " - " + result);
-        }
-        return result;
-    }
-
-    @Override
-    public boolean inGroup(final String group) {
-        final boolean result = ess.getPermissionsHandler().inGroup(base, group);
-        if (ess.getSettings().isDebug()) {
-            ess.getLogger().log(Level.INFO, "checking if " + base.getName() + " is in group " + group + " - " + result);
-        }
-        return result;
-    }
-
-    @Override
-    public boolean canBuild() {
-        if (this.getBase().isOp()) {
-            return true;
-        }
-        return ess.getPermissionsHandler().canBuild(base, getGroup());
-    }
-
-    public long getTeleportRequestTime() {
-        return teleportRequestTime;
-    }
-
-    public boolean isInvSee() {
-        return invSee;
-    }
-
-    public void setInvSee(final boolean set) {
-        invSee = set;
-    }
-
-    public boolean isEnderSee() {
-        return enderSee;
-    }
-
-    public void setEnderSee(final boolean set) {
-        enderSee = set;
-    }
-
-    @Override
-    public void enableInvulnerabilityAfterTeleport() {
-        final long time = ess.getSettings().getTeleportInvulnerability();
-        if (time > 0) {
-            teleportInvulnerabilityTimestamp = System.currentTimeMillis() + time;
-        }
-    }
-
-    @Override
-    public void resetInvulnerabilityAfterTeleport() {
-        if (teleportInvulnerabilityTimestamp != 0 && teleportInvulnerabilityTimestamp < System.currentTimeMillis()) {
-            teleportInvulnerabilityTimestamp = 0;
-        }
-    }
-
-    @Override
-    public boolean hasInvulnerabilityAfterTeleport() {
-        return teleportInvulnerabilityTimestamp != 0 && teleportInvulnerabilityTimestamp >= System.currentTimeMillis();
-    }
-
-    public boolean canInteractVanished() {
-        return isAuthorized("essentials.vanish.interact");
-    }
-
-    @Override
-    public boolean isIgnoreMsg() {
-        return ignoreMsg;
-    }
-
-    @Override
-    public void setIgnoreMsg(boolean ignoreMsg) {
-        this.ignoreMsg = ignoreMsg;
-    }
-
-    @Override
-    public boolean isVanished() {
-        return vanished;
-    }
-
-    @Override
-    public void setVanished(final boolean set) {
-        vanished = set;
-        if (set) {
-            for (User user : ess.getOnlineUsers()) {
-                if (!user.isAuthorized("essentials.vanish.see")) {
-                    user.getBase().hidePlayer(getBase());
-                }
-            }
-            setHidden(true);
-            ess.getVanishedPlayersNew().add(getName());
-            if (isAuthorized("essentials.vanish.effect")) {
-                this.getBase().addPotionEffect(new PotionEffect(PotionEffectType.INVISIBILITY, Integer.MAX_VALUE, 1, false));
-            }
-        } else {
-            for (Player p : ess.getOnlinePlayers()) {
-                p.showPlayer(getBase());
-            }
-            setHidden(false);
-            ess.getVanishedPlayersNew().remove(getName());
-            if (isAuthorized("essentials.vanish.effect")) {
-                this.getBase().removePotionEffect(PotionEffectType.INVISIBILITY);
-            }
-        }
-    }
-
-    public boolean checkSignThrottle() {
-        if (isSignThrottled()) {
-            return true;
-        }
-        updateThrottle();
-        return false;
-    }
-
-    public boolean isSignThrottled() {
-        final long minTime = lastThrottledAction + (1000 / ess.getSettings().getSignUsePerSecond());
-        return (System.currentTimeMillis() < minTime);
-    }
-
-    public void updateThrottle() {
-        lastThrottledAction = System.currentTimeMillis();
-    }
-
-    public boolean isFlyClickJump() {
-        return rightClickJump;
-    }
-
-    public void setRightClickJump(boolean rightClickJump) {
-        this.rightClickJump = rightClickJump;
-    }
-
-    @Override
-    public boolean isIgnoreExempt() {
-        return this.isAuthorized("essentials.chat.ignoreexempt");
-    }
-
-    public boolean isRecipeSee() {
-        return recipeSee;
-    }
-
-    public void setRecipeSee(boolean recipeSee) {
-        this.recipeSee = recipeSee;
-    }
-
-    @Override
-    public void sendMessage(String message) {
-        if (!message.isEmpty()) {
-            base.sendMessage(message);
-        }
-    }
-
-    @Override
-    public int compareTo(final User other) {
-        return FormatUtil.stripFormat(getDisplayName()).compareToIgnoreCase(FormatUtil.stripFormat(other.getDisplayName()));
-    }
-
-    @Override
-    public boolean equals(final Object object) {
-        if (!(object instanceof User)) {
-            return false;
-        }
-        return this.getName().equalsIgnoreCase(((User) object).getName());
-
-    }
-
-    @Override
-    public int hashCode() {
-        return this.getName().hashCode();
-    }
-
-    @Override
-    public CommandSource getSource() {
-        return new CommandSource(getBase());
-    }
-
-    @Override
-    public String getName() {
-        return this.getBase().getName();
-    }
-    
-    @Override public boolean isReachable() {
-        return getBase().isOnline();
-    }
-
-    @Override public MessageResponse sendMessage(IMessageRecipient recipient, String message) {
-        return this.messageRecipient.sendMessage(recipient, message);
-    }
-
-    @Override public MessageResponse onReceiveMessage(IMessageRecipient sender, String message) {
-        return this.messageRecipient.onReceiveMessage(sender, message);
-    }
-
-    @Override public IMessageRecipient getReplyRecipient() {
-        return this.messageRecipient.getReplyRecipient();
-    }
-
-    @Override public void setReplyRecipient(IMessageRecipient recipient) {
-        this.messageRecipient.setReplyRecipient(recipient);
-    }
-
-    @Override
-    public String getAfkMessage() {
-        return this.afkMessage;
-    }
-
-    @Override
-    public void setAfkMessage(String message) {
-        if (isAfk()) {
-            this.afkMessage = message;
-        }
-    }
-
-    @Override
-    public long getAfkSince() {
-        return afkSince;
-    }
-
-    @Override
-    public Map<User, BigDecimal> getConfirmingPayments() {
-        return confirmingPayments;
-    }
-
-    public String getConfirmingClearCommand() {
-        return confirmingClearCommand;
-    }
-    
-    public void setConfirmingClearCommand(String command) {
-        this.confirmingClearCommand = command;
-    }
-
-    /**
-     * 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 {
-            PlayerInventory inventory = getBase().getInventory();
-            return inventory.getItemInMainHand() != null ? inventory.getItemInMainHand() : inventory.getItemInOffHand();
-        }
-    }
-    
-    public void notifyOfMail() {
-        List<String> mails = getMails();
-        if (mails != null && !mails.isEmpty()) {
-            int notifyPlayerOfMailCooldown = ess.getSettings().getNotifyPlayerOfMailCooldown() * 1000;
-            if (System.currentTimeMillis() - lastNotifiedAboutMailsMs >= notifyPlayerOfMailCooldown) {
-                sendMessage(tl("youHaveNewMail", mails.size()));
-                lastNotifiedAboutMailsMs = System.currentTimeMillis();
-            }
-        }
-    }
-}

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

@@ -1,318 +0,0 @@
-package com.earth2me.essentials;
-
-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 org.bukkit.entity.Player;
-
-import java.io.File;
-import java.lang.reflect.InvocationTargetException;
-import java.lang.reflect.Method;
-import java.util.*;
-import java.util.concurrent.ConcurrentSkipListMap;
-import java.util.concurrent.ConcurrentSkipListSet;
-import java.util.concurrent.ExecutionException;
-import java.util.regex.Pattern;
-
-
-public class UserMap extends CacheLoader<String, User> implements IConf {
-    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 UUIDMap uuidMap;
-
-    private final transient Cache<String, User> users;
-    private static boolean legacy = false;
-
-    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);
-        CacheBuilder<Object, Object> cacheBuilder = CacheBuilder.newBuilder();
-        int maxCount = ess.getSettings().getMaxUserCacheCount();
-        try {
-            cacheBuilder.maximumSize(maxCount);
-        } catch (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(new Runnable() {
-            @Override
-            public void run() {
-                synchronized (users) {
-                    final File userdir = new File(ess.getDataFolder(), "userdata");
-                    if (!userdir.exists()) {
-                        return;
-                    }
-                    keys.clear();
-                    users.invalidateAll();
-                    for (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 (IllegalArgumentException ex) {
-                            //Ignore these users till they rejoin.
-                        }
-                    }
-                    uuidMap.loadAllUsers(names, history);
-                }
-            }
-        });
-    }
-
-    public boolean userExists(final UUID uuid) {
-        return keys.contains(uuid);
-    }
-
-    public User getUser(final String name) {
-        try {
-            final String sanitizedName = StringUtil.safeString(name);
-            if (names.containsKey(sanitizedName)) {
-                final UUID uuid = names.get(sanitizedName);
-                return getUser(uuid);
-            }
-
-            final File userFile = getUserFileFromString(sanitizedName);
-            if (userFile.exists()) {
-                ess.getLogger().info("Importing user " + name + " to usermap.");
-                User user = new User(new OfflinePlayer(sanitizedName, ess.getServer()), ess);
-                trackUUID(user.getBase().getUniqueId(), user.getName(), true);
-                return user;
-            }
-            return null;
-        } catch (UncheckedExecutionException ex) {
-            return null;
-        }
-    }
-
-    public User getUser(final UUID uuid) {
-        try {
-            if (!legacy) {
-                return ((LoadingCache<String, User>) users).get(uuid.toString());
-            } else {
-                return legacyCacheGet(uuid);
-            }
-        } catch (ExecutionException ex) {
-            return null;
-        } catch (UncheckedExecutionException ex) {
-            return null;
-        }
-    }
-
-    public void trackUUID(final UUID uuid, final String name, 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 (!names.get(keyName).equals(uuid)) {
-                    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 {
-                        if (ess.getSettings().isDebug()) {
-                            ess.getLogger().info("Found old UUID for " + name + " (" + uuid.toString() + "). Not adding to usermap.");
-                        }
-                    }
-                }
-            }
-        }
-    }
-
-    @Override
-    public User load(final String stringUUID) throws Exception {
-        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!");
-    }
-
-    @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;
-        }
-        UUID uuid = names.get(name);
-        if (uuid != null) {
-            keys.remove(uuid);
-            users.invalidate(uuid.toString());
-        }
-        names.remove(name);
-        names.remove(StringUtil.safeString(name));
-    }
-
-    public Set<UUID> getAllUniqueUsers() {
-        return Collections.unmodifiableSet(keys);
-    }
-
-    public int getUniqueUsers() {
-        return keys.size();
-    }
-
-    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);
-    }
-
-    public UUIDMap getUUIDMap() {
-        return uuidMap;
-    }
-
-    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");
-    }
-//	class UserMapRemovalListener implements RemovalListener
-//	{
-//		@Override
-//		public void onRemoval(final RemovalNotification notification)
-//		{
-//			Object value = notification.getValue();
-//			if (value != null)
-//			{
-//				((User)value).cleanup();
-//			}
-//		}
-//	}
-
-    private final Pattern validUserPattern = Pattern.compile("^[a-zA-Z0-9_]{2,16}$");
-
-    @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;
-        }
-        org.bukkit.OfflinePlayer offlinePlayer = ess.getServer().getOfflinePlayer(name);
-        if (offlinePlayer == null) {
-            return null;
-        }
-        UUID uuid;
-        try {
-            uuid = offlinePlayer.getUniqueId();
-        } catch (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 static Method getLegacy;
-
-    private User legacyCacheGet(UUID uuid) {
-        if (getLegacy == null) {
-            Class<?> usersClass = users.getClass();
-            for (Method m : usersClass.getDeclaredMethods()) {
-                if (m.getName().equals("get")) {
-                    getLegacy = m;
-                    getLegacy.setAccessible(true);
-                    break;
-                }
-            }
-        }
-        try {
-            return (User) getLegacy.invoke(users, uuid.toString());
-        } catch (IllegalAccessException | InvocationTargetException e) {
-            return null;
-        }
-    }
-
-    private void legacyMaximumSize(CacheBuilder builder, int maxCount) {
-        try {
-            Method maxSizeLegacy = builder.getClass().getDeclaredMethod("maximumSize", Integer.TYPE);
-            maxSizeLegacy.setAccessible(true);
-            maxSizeLegacy.invoke(builder, maxCount);
-        } catch (NoSuchMethodException | InvocationTargetException | IllegalAccessException e) {
-            e.printStackTrace();
-        }
-    }
-
-    @SuppressWarnings("unchecked")
-    private Cache<String, User> legacyBuild(CacheBuilder builder) {
-        Method build = null;
-        for (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 (IllegalAccessException | InvocationTargetException e) {
-            legacyUsers = null;
-        }
-        return legacyUsers;
-    }
-}

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

@@ -1,167 +0,0 @@
-package com.earth2me.essentials;
-
-import com.earth2me.essentials.commands.WarpNotFoundException;
-import com.earth2me.essentials.utils.StringUtil;
-import net.ess3.api.InvalidNameException;
-import net.ess3.api.InvalidWorldException;
-import org.bukkit.Location;
-import org.bukkit.Server;
-import java.io.File;
-import java.io.IOException;
-import java.util.*;
-import java.util.logging.Level;
-import java.util.logging.Logger;
-import static com.earth2me.essentials.I18n.tl;
-
-
-public class Warps implements IConf, net.ess3.api.IWarps {
-    private static final Logger logger = Logger.getLogger("Essentials");
-    private final Map<StringIgnoreCase, EssentialsConf> warpPoints = new HashMap<StringIgnoreCase, EssentialsConf>();
-    private final File warpsFolder;
-    private final Server server;
-
-    public Warps(Server server, File dataFolder) {
-        this.server = server;
-        warpsFolder = new File(dataFolder, "warps");
-        if (!warpsFolder.exists()) {
-            warpsFolder.mkdirs();
-        }
-        reloadConfig();
-    }
-
-    @Override
-    public boolean isEmpty() {
-        return warpPoints.isEmpty();
-    }
-
-    @Override
-    public Collection<String> getList() {
-        final List<String> keys = new ArrayList<String>();
-        for (StringIgnoreCase stringIgnoreCase : warpPoints.keySet()) {
-            keys.add(stringIgnoreCase.getString());
-        }
-        Collections.sort(keys, String.CASE_INSENSITIVE_ORDER);
-        return keys;
-    }
-
-    @Override
-    public Location getWarp(String warp) throws WarpNotFoundException, InvalidWorldException {
-        EssentialsConf conf = warpPoints.get(new StringIgnoreCase(warp));
-        if (conf == null) {
-            throw new WarpNotFoundException();
-        }
-        return conf.getLocation(null, server);
-    }
-
-    @Override
-    public void setWarp(String name, Location loc) throws Exception {
-        setWarp(null, name, loc);
-    }
-    
-    @Override
-    public void setWarp(IUser user, String name, Location loc) throws Exception {
-        String filename = StringUtil.sanitizeFileName(name);
-        EssentialsConf conf = warpPoints.get(new StringIgnoreCase(name));
-        if (conf == null) {
-            File confFile = new File(warpsFolder, filename + ".yml");
-            if (confFile.exists()) {
-                throw new Exception(tl("similarWarpExist"));
-            }
-            conf = new EssentialsConf(confFile);
-            warpPoints.put(new StringIgnoreCase(name), conf);
-        }
-        conf.setProperty(null, loc);
-        conf.setProperty("name", name);
-        if (user != null) conf.setProperty("lastowner", user.getBase().getUniqueId().toString());
-        try {
-            conf.saveWithError();
-        } catch (IOException ex) {
-            throw new IOException(tl("invalidWarpName"));
-        }
-    }
-    
-    @Override
-    public UUID getLastOwner(String warp) throws WarpNotFoundException {
-        EssentialsConf conf = warpPoints.get(new StringIgnoreCase(warp));
-        if (conf == null) {
-            throw new WarpNotFoundException();
-        }
-        UUID uuid = null;
-        try {
-            uuid = UUID.fromString(conf.getString("lastowner"));
-        }
-        catch (Exception ex) {}
-        return uuid;
-    }
-    
-    @Override
-    public void removeWarp(String name) throws Exception {
-        EssentialsConf conf = warpPoints.get(new StringIgnoreCase(name));
-        if (conf == null) {
-            throw new Exception(tl("warpNotExist"));
-        }
-        if (!conf.getFile().delete()) {
-            throw new Exception(tl("warpDeleteError"));
-        }
-        warpPoints.remove(new StringIgnoreCase(name));
-    }
-
-    @Override
-    public final void reloadConfig() {
-        warpPoints.clear();
-        File[] listOfFiles = warpsFolder.listFiles();
-        if (listOfFiles.length >= 1) {
-            for (int i = 0; i < listOfFiles.length; i++) {
-                String filename = listOfFiles[i].getName();
-                if (listOfFiles[i].isFile() && filename.endsWith(".yml")) {
-                    try {
-                        EssentialsConf conf = new EssentialsConf(listOfFiles[i]);
-                        conf.load();
-                        String name = conf.getString("name");
-                        if (name != null) {
-                            warpPoints.put(new StringIgnoreCase(name), conf);
-                        }
-                    } catch (Exception ex) {
-                        logger.log(Level.WARNING, tl("loadWarpError", filename), ex);
-                    }
-                }
-            }
-        }
-    }
-
-    //This is here for future 3.x api support. Not implemented here becasue storage is handled differently
-    @Override
-    public File getWarpFile(String name) throws InvalidNameException {
-        throw new UnsupportedOperationException("Not supported yet.");
-    }
-
-    @Override
-    public int getCount() {
-        return getList().size();
-    }
-
-    private static class StringIgnoreCase {
-        private final String string;
-
-        public StringIgnoreCase(String string) {
-            this.string = string;
-        }
-
-        @Override
-        public int hashCode() {
-            return getString().toLowerCase(Locale.ENGLISH).hashCode();
-        }
-
-        @Override
-        public boolean equals(Object o) {
-            if (o instanceof StringIgnoreCase) {
-                return getString().equalsIgnoreCase(((StringIgnoreCase) o).getString());
-            }
-            return false;
-        }
-
-        public String getString() {
-            return string;
-        }
-    }
-}

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

@@ -1,427 +0,0 @@
-package com.earth2me.essentials.api;
-
-import com.earth2me.essentials.EssentialsUserConf;
-import com.earth2me.essentials.Trade;
-import com.earth2me.essentials.User;
-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 org.bukkit.entity.Player;
-
-import java.io.File;
-import java.math.BigDecimal;
-import java.math.MathContext;
-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 Economy() {
-    }
-
-    private static final Logger logger = Logger.getLogger("Essentials");
-    private static IEssentials ess;
-    private static final String noCallBeforeLoad = "Essentials API is called before Essentials is loaded.";
-    public static final MathContext MATH_CONTEXT = MathContext.DECIMAL128;
-
-    /**
-     * @param aEss the ess to set
-     */
-    public static void setEss(IEssentials aEss) {
-        ess = aEss;
-    }
-
-    private static void createNPCFile(String name) {
-        File folder = new File(ess.getDataFolder(), "userdata");
-        name = StringUtil.safeString(name);
-        if (!folder.exists()) {
-            folder.mkdirs();
-        }
-        UUID npcUUID = UUID.nameUUIDFromBytes(("NPC:" + name).getBytes(Charsets.UTF_8));
-        EssentialsUserConf npcConfig = new EssentialsUserConf(name, npcUUID, new File(folder, npcUUID.toString() + ".yml"));
-        npcConfig.load();
-        npcConfig.setProperty("npc", true);
-        npcConfig.setProperty("lastAccountName", name);
-        npcConfig.setProperty("money", ess.getSettings().getStartingBalance());
-        npcConfig.forceSave();
-        ess.getUserMap().trackUUID(npcUUID, name, false);
-    }
-
-    private static void deleteNPC(String name) {
-        User user = ess.getUser(name);
-        user.reset();
-    }
-
-    private static User getUserByName(String name) {
-        if (ess == null) {
-            throw new RuntimeException(noCallBeforeLoad);
-        }
-        if (name == null) {
-            throw new RuntimeException("Economy username cannot be null");
-        }
-
-        User user = ess.getUser(name);
-        if (user == null) {
-            /*
-                Attempt lookup using UUID - this prevents balance resets when accessing economy
-                via Vault during player join.
-                See: https://github.com/EssentialsX/Essentials/issues/2400
-            */
-            Player player = ess.getServer().getPlayerExact(name);
-            if (player != null) {
-                user = ess.getUser(player.getUniqueId());
-                if (user != null) {
-                    logger.info(String.format("[Economy] Found player %s by UUID %s but not by their actual name - they may have changed their username", name, player.getUniqueId().toString()));
-                }
-            }
-        }
-
-        return user;
-    }
-
-    /**
-     * Returns the balance of a user
-     *
-     * @param name Name of the user
-     *
-     * @return balance
-     *
-     * @throws UserDoesNotExistException
-     */
-    @Deprecated
-    public static double getMoney(String name) throws UserDoesNotExistException {
-        BigDecimal exactAmount = getMoneyExact(name);
-        double amount = exactAmount.doubleValue();
-        if (new BigDecimal(amount).compareTo(exactAmount) > 0) {
-            // closest double is bigger than the exact amount
-            // -> get the previous double value to not return more money than the user has
-            amount = Math.nextAfter(amount, Double.NEGATIVE_INFINITY);
-        }
-        return amount;
-    }
-
-    public static BigDecimal getMoneyExact(String name) throws UserDoesNotExistException {
-        User user = getUserByName(name);
-        if (user == null) {
-            throw new UserDoesNotExistException(name);
-        }
-        return user.getMoney();
-    }
-
-    /**
-     * Sets the balance of a user
-     *
-     * @param name    Name of the user
-     * @param balance The balance you want to set
-     *
-     * @throws UserDoesNotExistException If a user by that name does not exists
-     * @throws NoLoanPermittedException  If the user is not allowed to have a negative balance
-     */
-    @Deprecated
-    public static void setMoney(String name, double balance) throws UserDoesNotExistException, NoLoanPermittedException {
-        try {
-            setMoney(name, BigDecimal.valueOf(balance));
-        } catch (ArithmeticException e) {
-            logger.log(Level.WARNING, "Failed to set balance of " + name + " to " + balance + ": " + e.getMessage(), e);
-        }
-    }
-
-    public static void setMoney(String name, BigDecimal balance) throws UserDoesNotExistException, NoLoanPermittedException {
-        User user = getUserByName(name);
-        if (user == null) {
-            throw new UserDoesNotExistException(name);
-        }
-        if (balance.compareTo(ess.getSettings().getMinMoney()) < 0) {
-            throw new NoLoanPermittedException();
-        }
-        if (balance.signum() < 0 && !user.isAuthorized("essentials.eco.loan")) {
-            throw new NoLoanPermittedException();
-        }
-        try {
-            user.setMoney(balance);
-        } catch (MaxMoneyException ex) {
-            //TODO: Update API to show max balance errors
-        }
-        Trade.log("API", "Set", "API", name, new Trade(balance, ess), null, null, null, ess);
-    }
-
-    /**
-     * Adds money to the balance of a user
-     *
-     * @param name   Name of the user
-     * @param amount The money you want to add
-     *
-     * @throws UserDoesNotExistException If a user by that name does not exists
-     * @throws NoLoanPermittedException  If the user is not allowed to have a negative balance
-     */
-    @Deprecated
-    public static void add(String name, double amount) throws UserDoesNotExistException, NoLoanPermittedException {
-        try {
-            add(name, BigDecimal.valueOf(amount));
-        } catch (ArithmeticException e) {
-            logger.log(Level.WARNING, "Failed to add " + amount + " to balance of " + name + ": " + e.getMessage(), e);
-        }
-    }
-
-    public static void add(String name, BigDecimal amount) throws UserDoesNotExistException, NoLoanPermittedException, ArithmeticException {
-        BigDecimal result = getMoneyExact(name).add(amount, MATH_CONTEXT);
-        setMoney(name, result);
-        Trade.log("API", "Add", "API", name, new Trade(amount, ess), null, null, null, ess);
-    }
-
-    /**
-     * Substracts money from the balance of a user
-     *
-     * @param name   Name of the user
-     * @param amount The money you want to substract
-     *
-     * @throws UserDoesNotExistException If a user by that name does not exists
-     * @throws NoLoanPermittedException  If the user is not allowed to have a negative balance
-     */
-    @Deprecated
-    public static void subtract(String name, double amount) throws UserDoesNotExistException, NoLoanPermittedException {
-        try {
-            substract(name, BigDecimal.valueOf(amount));
-        } catch (ArithmeticException e) {
-            logger.log(Level.WARNING, "Failed to substract " + amount + " of balance of " + name + ": " + e.getMessage(), e);
-        }
-    }
-
-    public static void substract(String name, BigDecimal amount) throws UserDoesNotExistException, NoLoanPermittedException, ArithmeticException {
-        BigDecimal result = getMoneyExact(name).subtract(amount, MATH_CONTEXT);
-        setMoney(name, result);
-        Trade.log("API", "Subtract", "API", name, new Trade(amount, ess), null, null, null, ess);
-    }
-
-    /**
-     * Divides the balance of a user by a value
-     *
-     * @param name  Name of the user
-     * @param amount The balance is divided by this value
-     *
-     * @throws UserDoesNotExistException If a user by that name does not exists
-     * @throws NoLoanPermittedException  If the user is not allowed to have a negative balance
-     */
-    @Deprecated
-    public static void divide(String name, double amount) throws UserDoesNotExistException, NoLoanPermittedException {
-        try {
-            divide(name, BigDecimal.valueOf(amount));
-        } catch (ArithmeticException e) {
-            logger.log(Level.WARNING, "Failed to divide balance of " + name + " by " + amount + ": " + e.getMessage(), e);
-        }
-    }
-
-    public static void divide(String name, BigDecimal amount) throws UserDoesNotExistException, NoLoanPermittedException, ArithmeticException {
-        BigDecimal result = getMoneyExact(name).divide(amount, MATH_CONTEXT);
-        setMoney(name, result);
-        Trade.log("API", "Divide", "API", name, new Trade(amount, ess), null, null, null, ess);
-    }
-
-    /**
-     * Multiplies the balance of a user by a value
-     *
-     * @param name  Name of the user
-     * @param amount The balance is multiplied by this value
-     *
-     * @throws UserDoesNotExistException If a user by that name does not exists
-     * @throws NoLoanPermittedException  If the user is not allowed to have a negative balance
-     */
-    @Deprecated
-    public static void multiply(String name, double amount) throws UserDoesNotExistException, NoLoanPermittedException {
-        try {
-            multiply(name, BigDecimal.valueOf(amount));
-        } catch (ArithmeticException e) {
-            logger.log(Level.WARNING, "Failed to multiply balance of " + name + " by " + amount + ": " + e.getMessage(), e);
-        }
-    }
-
-    public static void multiply(String name, BigDecimal amount) throws UserDoesNotExistException, NoLoanPermittedException, ArithmeticException {
-        BigDecimal result = getMoneyExact(name).multiply(amount, MATH_CONTEXT);
-        setMoney(name, result);
-        Trade.log("API", "Multiply", "API", name, new Trade(amount, ess), null, null, null, ess);
-    }
-
-    /**
-     * Resets the balance of a user to the starting balance
-     *
-     * @param name Name of the user
-     *
-     * @throws UserDoesNotExistException If a user by that name does not exists
-     * @throws NoLoanPermittedException  If the user is not allowed to have a negative balance
-     */
-    public static void resetBalance(String name) throws UserDoesNotExistException, NoLoanPermittedException {
-        if (ess == null) {
-            throw new RuntimeException(noCallBeforeLoad);
-        }
-        setMoney(name, ess.getSettings().getStartingBalance());
-        Trade.log("API", "Reset", "API", name, new Trade(BigDecimal.ZERO, ess), null, null, null, ess);
-    }
-
-    /**
-     * @param name   Name of the user
-     * @param amount The amount of money the user should have
-     *
-     * @return true, if the user has more or an equal amount of money
-     *
-     * @throws UserDoesNotExistException If a user by that name does not exists
-     */
-    @Deprecated
-    public static boolean hasEnough(String name, double amount) throws UserDoesNotExistException {
-        try {
-            return hasEnough(name, BigDecimal.valueOf(amount));
-        } catch (ArithmeticException e) {
-            logger.log(Level.WARNING, "Failed to compare balance of " + name + " with " + amount + ": " + e.getMessage(), e);
-            return false;
-        }
-    }
-
-    public static boolean hasEnough(String name, BigDecimal amount) throws UserDoesNotExistException, ArithmeticException {
-        return amount.compareTo(getMoneyExact(name)) <= 0;
-    }
-
-    /**
-     * @param name   Name of the user
-     * @param amount The amount of money the user should have
-     *
-     * @return true, if the user has more money
-     *
-     * @throws UserDoesNotExistException If a user by that name does not exists
-     */
-    @Deprecated
-    public static boolean hasMore(String name, double amount) throws UserDoesNotExistException {
-        try {
-            return hasMore(name, BigDecimal.valueOf(amount));
-        } catch (ArithmeticException e) {
-            logger.log(Level.WARNING, "Failed to compare balance of " + name + " with " + amount + ": " + e.getMessage(), e);
-            return false;
-        }
-    }
-
-    public static boolean hasMore(String name, BigDecimal amount) throws UserDoesNotExistException, ArithmeticException {
-        return amount.compareTo(getMoneyExact(name)) < 0;
-    }
-
-    /**
-     * @param name   Name of the user
-     * @param amount The amount of money the user should not have
-     *
-     * @return true, if the user has less money
-     *
-     * @throws UserDoesNotExistException If a user by that name does not exists
-     */
-    @Deprecated
-    public static boolean hasLess(String name, double amount) throws UserDoesNotExistException {
-        try {
-            return hasLess(name, BigDecimal.valueOf(amount));
-        } catch (ArithmeticException e) {
-            logger.log(Level.WARNING, "Failed to compare balance of " + name + " with " + amount + ": " + e.getMessage(), e);
-            return false;
-        }
-    }
-
-    public static boolean hasLess(String name, BigDecimal amount) throws UserDoesNotExistException, ArithmeticException {
-        return amount.compareTo(getMoneyExact(name)) > 0;
-    }
-
-    /**
-     * Test if the user has a negative balance
-     *
-     * @param name Name of the user
-     *
-     * @return true, if the user has a negative balance
-     *
-     * @throws UserDoesNotExistException If a user by that name does not exists
-     */
-    public static boolean isNegative(String name) throws UserDoesNotExistException {
-        return getMoneyExact(name).signum() < 0;
-    }
-
-    /**
-     * Formats the amount of money like all other Essentials functions. Example: $100000 or $12345.67
-     *
-     * @param amount The amount of money
-     *
-     * @return Formatted money
-     */
-    @Deprecated
-    public static String format(double amount) {
-        try {
-            return format(BigDecimal.valueOf(amount));
-        } catch (NumberFormatException e) {
-            logger.log(Level.WARNING, "Failed to display " + amount + ": " + e.getMessage(), e);
-            return "NaN";
-        }
-    }
-
-    public static String format(BigDecimal amount) {
-        if (ess == null) {
-            throw new RuntimeException(noCallBeforeLoad);
-        }
-        return NumberUtil.displayCurrency(amount, ess);
-    }
-
-    /**
-     * Test if a player exists to avoid the UserDoesNotExistException
-     *
-     * @param name Name of the user
-     *
-     * @return true, if the user exists
-     */
-    public static boolean playerExists(String name) {
-        return getUserByName(name) != null;
-    }
-
-    /**
-     * Test if a player is a npc
-     *
-     * @param name Name of the player
-     *
-     * @return true, if it's a npc
-     *
-     * @throws UserDoesNotExistException
-     */
-    public static boolean isNPC(String name) throws UserDoesNotExistException {
-        User user = getUserByName(name);
-        if (user == null) {
-            throw new UserDoesNotExistException(name);
-        }
-        return user.isNPC();
-    }
-
-    /**
-     * Creates dummy files for a npc, if there is no player yet with that name.
-     *
-     * @param name Name of the player
-     *
-     * @return true, if a new npc was created
-     */
-    public static boolean createNPC(String name) {
-        User user = getUserByName(name);
-        if (user == null) {
-            createNPCFile(name);
-            return true;
-        }
-        return false;
-    }
-
-    /**
-     * Deletes a user, if it is marked as npc.
-     *
-     * @param name Name of the player
-     *
-     * @throws UserDoesNotExistException
-     */
-    public static void removeNPC(String name) throws UserDoesNotExistException {
-        User user = getUserByName(name);
-        if (user == null) {
-            throw new UserDoesNotExistException(name);
-        }
-        deleteNPC(name);
-    }
-}

Essentials/src/com/earth2me/essentials/api/II18n.java

@@ -1,13 +0,0 @@
-package com.earth2me.essentials.api;
-
-import java.util.Locale;
-
-
-public interface II18n {
-    /**
-     * Gets the current locale setting
-     *
-     * @return the current locale, if not set it will return the default locale
-     */
-    Locale getCurrentLocale();
-}

Essentials/src/com/earth2me/essentials/api/IReload.java

@@ -1,6 +0,0 @@
-package com.earth2me.essentials.api;
-
-
-public interface IReload {
-    void onReload();
-}

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

@@ -1,17 +0,0 @@
-package com.earth2me.essentials.api;
-
-import static com.earth2me.essentials.I18n.tl;
-
-
-public class InvalidWorldException extends Exception {
-    private final String world;
-
-    public InvalidWorldException(final String world) {
-        super(tl("invalidWorld"));
-        this.world = world;
-    }
-
-    public String getWorld() {
-        return this.world;
-    }
-}

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

@@ -1,10 +0,0 @@
-package com.earth2me.essentials.api;
-
-import static com.earth2me.essentials.I18n.tl;
-
-
-public class UserDoesNotExistException extends Exception {
-    public UserDoesNotExistException(String name) {
-        super(tl("userDoesNotExist", name));
-    }
-}

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

@@ -1,103 +0,0 @@
-package com.earth2me.essentials.commands;
-
-import com.earth2me.essentials.CommandSource;
-import com.earth2me.essentials.User;
-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");
-    }
-
-    @Override
-    public void run(Server server, User user, String commandLabel, String[] args) throws Exception {
-        if (args.length > 0 && user.isAuthorized("essentials.afk.others")) {
-            User afkUser = user; // if no player found, but message specified, set command executor to target user
-            String message;
-            try {
-                afkUser = getPlayer(server, user, args, 0);
-                message = args.length > 1 ? getFinalArg(args, 1) : null;
-            } catch (PlayerNotFoundException e) {
-                // If only one arg is passed, assume the command executor is targeting another player.
-                if (args.length == 1) {
-                    throw e;
-                }
-                message = getFinalArg(args, 0);
-            }
-            toggleAfk(user, afkUser, message);
-        } else {
-            String message = args.length > 0 ? getFinalArg(args, 0) : null;
-            toggleAfk(user, user, message);
-        }
-    }
-
-    @Override
-    public void run(Server server, CommandSource sender, String commandLabel, String[] args) throws Exception {
-        if (args.length > 0) {
-            User afkUser = getPlayer(server, args, 0, true, false);
-            String message = args.length > 1 ? getFinalArg(args, 1) : null;
-            toggleAfk(null, afkUser, message);
-        } else {
-            throw new NotEnoughArgumentsException();
-        }
-    }
-
-    private void toggleAfk(User sender, User user, String message) throws Exception {
-        if (message != null && sender != null) {
-            if (sender.isMuted()) {
-                throw new Exception(sender.hasMuteReason() ? tl("voiceSilencedReason", sender.getMuteReason()) : tl("voiceSilenced"));
-            }
-            if (!sender.isAuthorized("essentials.afk.message")) {
-                throw new Exception(tl("noPermToAFKMessage"));
-            }
-        }
-        user.setDisplayNick();
-        String msg = "";
-        if (!user.toggleAfk()) {
-            //user.sendMessage(_("markedAsNotAway"));
-            if (!user.isHidden()) {
-                msg = tl("userIsNotAway", user.getDisplayName());
-            }
-            user.updateActivity(false);
-        } else {
-            //user.sendMessage(_("markedAsAway"));
-            if (!user.isHidden()) {
-                if (message != null) {
-                    msg = tl("userIsAwayWithMessage", user.getDisplayName(), message);
-                } else {
-                    msg = tl("userIsAway", user.getDisplayName());
-                }
-            }
-            user.setAfkMessage(message);
-        }
-        if (!msg.isEmpty()) {
-            ess.broadcastMessage(user, msg);
-        }
-        user.setDisplayNick(); // Set this again after toggling
-    }
-
-    @Override
-    protected List<String> getTabCompleteOptions(Server server, User user, String commandLabel, String[] args) {
-        if (args.length == 1 && user.isAuthorized("essentials.afk.others")) {
-            return getPlayers(server, user);
-        } else {
-            return Collections.emptyList();
-        }
-    }
-
-    @Override
-    protected List<String> getTabCompleteOptions(Server server, CommandSource sender, String commandLabel, String[] args) {
-        if (args.length == 1) {
-            return getPlayers(server, sender);
-        } else {
-            return Collections.emptyList();
-        }
-    }
-}
-

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

@@ -1,101 +0,0 @@
-package com.earth2me.essentials.commands;
-
-import com.earth2me.essentials.CommandSource;
-import com.earth2me.essentials.Trade;
-import com.earth2me.essentials.User;
-import org.bukkit.Server;
-import org.bukkit.entity.Player;
-
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.Collections;
-import java.util.List;
-
-import static com.earth2me.essentials.I18n.tl;
-
-
-public class Commandback extends EssentialsCommand {
-    public Commandback() {
-        super("back");
-    }
-
-    @Override
-    protected void run(Server server, User user, String commandLabel, String[] args) throws Exception {
-        CommandSource sender = user.getSource();
-        if (args.length > 0 && user.isAuthorized("essentials.back.others")) {
-            this.parseCommand(server, sender, args, true);
-            return;
-        }
-
-        teleportBack(sender, user);
-    }
-
-    @Override
-    protected void run(Server server, CommandSource sender, String commandLabel, String[] args) throws Exception {
-        if (args.length < 1) {
-            throw new NotEnoughArgumentsException();
-        }
-
-        this.parseCommand(server, sender, args, true);
-    }
-
-    private void parseCommand(Server server, CommandSource sender, String[] args, boolean allowOthers) throws Exception {
-        Collection<Player> players = new ArrayList<>();
-
-        if (allowOthers && args.length > 0 && args[0].trim().length() > 2) {
-            players = server.matchPlayer(args[0].trim());
-        }
-
-        if (players.size() < 1) {
-            throw new PlayerNotFoundException();
-        }
-
-        for (Player player : players) {
-            sender.sendMessage(tl("backOther", player.getName()));
-            teleportBack(sender, ess.getUser(player));
-        }
-    }
-
-    private void teleportBack(CommandSource sender, User user) throws Exception {
-        if (user.getLastLocation() == null) {
-            throw new Exception(tl("noLocationFound"));
-        }
-
-        String lastWorldName = user.getLastLocation().getWorld().getName();
-
-        User requester = null;
-        if (sender.isPlayer()) {
-            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));
-            }
-
-            if (!requester.isAuthorized("essentials.back.into." + lastWorldName)) {
-                throw new Exception(tl("noPerm", "essentials.back.into." + lastWorldName));
-            }
-        }
-
-        if (requester == null) {
-            user.getTeleport().back(null, null);
-        } else if (!requester.equals(user)) {
-            Trade charge = new Trade(this.getName(), this.ess);
-            charge.isAffordableFor(requester);
-            user.getTeleport().back(requester, charge);
-        } else {
-            Trade charge = new Trade(this.getName(), this.ess);
-            charge.isAffordableFor(user);
-            user.getTeleport().back(charge);
-        }
-        throw new NoChargeException();
-    }
-
-    @Override
-    protected List<String> getTabCompleteOptions(Server server, User user, String commandLabel, String[] args) {
-        if (user.isAuthorized("essentials.back.others") && args.length == 1) {
-            return getPlayers(server, user);
-        } else {
-            return Collections.emptyList();
-        }
-    }
-}

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

@@ -1,61 +0,0 @@
-package com.earth2me.essentials.commands;
-
-import com.earth2me.essentials.CommandSource;
-import com.earth2me.essentials.User;
-import com.earth2me.essentials.utils.NumberUtil;
-import org.bukkit.Server;
-
-import java.math.BigDecimal;
-import java.util.Collections;
-import java.util.List;
-
-import static com.earth2me.essentials.I18n.tl;
-
-
-public class Commandbalance extends EssentialsCommand {
-    public Commandbalance() {
-        super("balance");
-    }
-
-    @Override
-    protected void run(final Server server, final CommandSource sender, final String commandLabel, final String[] args) throws Exception {
-        if (args.length < 1) {
-            throw new NotEnoughArgumentsException();
-        }
-
-        User target = getPlayer(server, args, 0, true, true);
-        sender.sendMessage(tl("balanceOther", target.isHidden() ? target.getName() : target.getDisplayName(), 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);
-            final BigDecimal bal = target.getMoney();
-            user.sendMessage(tl("balanceOther", target.isHidden() ? target.getName() : target.getDisplayName(), NumberUtil.displayCurrency(bal, ess)));
-        } else if (args.length < 2) {
-            final BigDecimal bal = user.getMoney();
-            user.sendMessage(tl("balance", NumberUtil.displayCurrency(bal, ess)));
-        } else {
-            throw new NotEnoughArgumentsException();
-        }
-    }
-
-    @Override
-    protected List<String> getTabCompleteOptions(Server server, User user, String commandLabel, String[] args) {
-        if (args.length == 1 && user.isAuthorized("essentials.balance.others")) {
-            return getPlayers(server, user);
-        } else {
-            return Collections.emptyList();
-        }
-    }
-
-    @Override
-    protected List<String> getTabCompleteOptions(Server server, CommandSource sender, String commandLabel, String[] args) {
-        if (args.length == 1) {
-            return getPlayers(server, sender);
-        } else {
-            return Collections.emptyList();
-        }
-    }
-}

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

@@ -1,180 +0,0 @@
-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.utils.NumberUtil;
-import com.google.common.collect.Lists;
-import org.bukkit.Server;
-
-import java.math.BigDecimal;
-import java.text.DateFormat;
-import java.util.*;
-import java.util.Map.Entry;
-import java.util.concurrent.locks.ReentrantReadWriteLock;
-
-import static com.earth2me.essentials.I18n.tl;
-
-
-public class Commandbalancetop extends EssentialsCommand {
-    public Commandbalancetop() {
-        super("balancetop");
-    }
-
-    private static final int CACHETIME = 2 * 60 * 1000;
-    public static final int MINUSERS = 50;
-    private static final SimpleTextInput cache = new SimpleTextInput();
-    private static long cacheage = 0;
-    private static final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
-
-    @Override
-    protected void run(final Server server, final CommandSource sender, final String commandLabel, final String[] args) throws Exception {
-        int page = 0;
-        boolean force = false;
-        if (args.length > 0) {
-            try {
-                page = Integer.parseInt(args[0]);
-            } catch (NumberFormatException ex) {
-                if (args[0].equalsIgnoreCase("force") && (!sender.isPlayer() || ess.getUser(sender.getPlayer()).isAuthorized("essentials.balancetop.force"))) {
-                    force = true;
-                }
-            }
-        }
-
-        if (!force && lock.readLock().tryLock()) {
-            try {
-                if (cacheage > System.currentTimeMillis() - CACHETIME) {
-                    outputCache(sender, commandLabel, page);
-                    return;
-                }
-                if (ess.getUserMap().getUniqueUsers() > MINUSERS) {
-                    sender.sendMessage(tl("orderBalances", ess.getUserMap().getUniqueUsers()));
-                }
-            } finally {
-                lock.readLock().unlock();
-            }
-            ess.runTaskAsynchronously(new Viewer(sender, commandLabel, page, force));
-        } else {
-            if (ess.getUserMap().getUniqueUsers() > MINUSERS) {
-                sender.sendMessage(tl("orderBalances", ess.getUserMap().getUniqueUsers()));
-            }
-            ess.runTaskAsynchronously(new Viewer(sender, commandLabel, page, force));
-        }
-
-    }
-
-    private static void outputCache(final CommandSource sender, String command, int page) {
-        final Calendar cal = Calendar.getInstance();
-        cal.setTimeInMillis(cacheage);
-        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);
-    }
-
-
-    private class Calculator implements Runnable {
-        private final transient Viewer viewer;
-        private final boolean force;
-
-        public Calculator(final Viewer viewer, final boolean force) {
-            this.viewer = viewer;
-            this.force = force;
-        }
-
-        @Override
-        public void run() {
-            lock.writeLock().lock();
-            try {
-                if (force || cacheage <= System.currentTimeMillis() - CACHETIME) {
-                    cache.getLines().clear();
-                    final Map<String, BigDecimal> balances = new HashMap<String, BigDecimal>();
-                    BigDecimal totalMoney = BigDecimal.ZERO;
-                    if (ess.getSettings().isEcoDisabled()) {
-                        if (ess.getSettings().isDebug()) {
-                            ess.getLogger().info("Internal economy functions disabled, aborting baltop.");
-                        }
-                    } else {
-                        for (UUID u : ess.getUserMap().getAllUniqueUsers()) {
-                            final User user = ess.getUserMap().getUser(u);
-                            if (user != null) {
-                                if (!ess.getSettings().isNpcsInBalanceRanking() && user.isNPC()) {
-                                    // Don't list NPCs in output
-                                    continue;
-                                }
-                                if (!user.isAuthorized("essentials.balancetop.exclude")) {
-                                    final BigDecimal userMoney = user.getMoney();
-                                    user.updateMoneyCache(userMoney);
-                                    totalMoney = totalMoney.add(userMoney);
-                                    final String name = user.isHidden() ? user.getName() : user.getDisplayName();
-                                    balances.put(name, userMoney);
-                                }
-                            }
-                        }
-                    }
-
-                    final List<Map.Entry<String, BigDecimal>> sortedEntries = new ArrayList<Map.Entry<String, BigDecimal>>(balances.entrySet());
-                    Collections.sort(sortedEntries, new Comparator<Map.Entry<String, BigDecimal>>() {
-                        @Override
-                        public int compare(final Entry<String, BigDecimal> entry1, final Entry<String, BigDecimal> entry2) {
-                            return entry2.getValue().compareTo(entry1.getValue());
-                        }
-                    });
-
-                    cache.getLines().add(tl("serverTotal", NumberUtil.displayCurrency(totalMoney, ess)));
-                    int pos = 1;
-                    for (Map.Entry<String, BigDecimal> entry : sortedEntries) {
-                        cache.getLines().add(pos + ". " + entry.getKey() + ", " + NumberUtil.displayCurrency(entry.getValue(), ess));
-                        pos++;
-                    }
-                    cacheage = System.currentTimeMillis();
-                }
-            } finally {
-                lock.writeLock().unlock();
-            }
-            ess.runTaskAsynchronously(viewer);
-        }
-    }
-
-
-    private class Viewer implements Runnable {
-        private final transient CommandSource sender;
-        private final transient int page;
-        private final transient boolean force;
-        private final transient String commandLabel;
-
-        public Viewer(final CommandSource sender, final String commandLabel, final int page, final boolean force) {
-            this.sender = sender;
-            this.page = page;
-            this.force = force;
-            this.commandLabel = commandLabel;
-        }
-
-        @Override
-        public void run() {
-            lock.readLock().lock();
-            try {
-                if (!force && cacheage > System.currentTimeMillis() - CACHETIME) {
-                    outputCache(sender, commandLabel, page);
-                    return;
-                }
-            } finally {
-                lock.readLock().unlock();
-            }
-            ess.runTaskAsynchronously(new Calculator(new Viewer(sender, commandLabel, page, false), force));
-        }
-    }
-
-    @Override
-    protected List<String> getTabCompleteOptions(Server server, CommandSource sender, String commandLabel, String[] args) {
-        if (args.length == 1) {
-            List<String> options = Lists.newArrayList("1");
-            if (!sender.isPlayer() || ess.getUser(sender.getPlayer()).isAuthorized("essentials.balancetop.force")) {
-                options.add("force");
-            }
-            return options;
-        } else {
-            return Collections.emptyList();
-        }
-    }
-}

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

@@ -1,98 +0,0 @@
-package com.earth2me.essentials.commands;
-
-import com.earth2me.essentials.User;
-import com.earth2me.essentials.craftbukkit.InventoryWorkaround;
-import com.earth2me.essentials.utils.EnumUtil;
-import com.google.common.collect.Lists;
-import org.bukkit.Material;
-import org.bukkit.Server;
-import org.bukkit.inventory.ItemStack;
-import org.bukkit.inventory.meta.BookMeta;
-
-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");
-
-    public Commandbook() {
-        super("book");
-    }
-
-    @Override
-    public void run(final Server server, final User user, final String commandLabel, final String[] args) throws Exception {
-        final ItemStack item = user.getItemInHand();
-        final String player = user.getName();
-        if (item.getType() == Material.WRITTEN_BOOK) {
-            BookMeta bmeta = (BookMeta) item.getItemMeta();
-
-            if (args.length > 1 && args[0].equalsIgnoreCase("author")) {
-                if (user.isAuthorized("essentials.book.author") && (isAuthor(bmeta, player) || user.isAuthorized("essentials.book.others"))) {
-                    bmeta.setAuthor(args[1]);
-                    item.setItemMeta(bmeta);
-                    user.sendMessage(tl("bookAuthorSet", getFinalArg(args, 1)));
-                } else {
-                    throw new Exception(tl("denyChangeAuthor"));
-                }
-            } else if (args.length > 1 && args[0].equalsIgnoreCase("title")) {
-                if (user.isAuthorized("essentials.book.title") && (isAuthor(bmeta, player) || user.isAuthorized("essentials.book.others"))) {
-                    bmeta.setTitle(args[1]);
-                    item.setItemMeta(bmeta);
-                    user.sendMessage(tl("bookTitleSet", getFinalArg(args, 1)));
-                } else {
-                    throw new Exception(tl("denyChangeTitle"));
-                }
-            } else {
-                if (isAuthor(bmeta, player) || user.isAuthorized("essentials.book.others")) {
-                    ItemStack newItem = new ItemStack(WRITABLE_BOOK, item.getAmount());
-                    newItem.setItemMeta(bmeta);
-                    InventoryWorkaround.setItemInMainHand(user.getBase(), newItem);
-                    user.sendMessage(tl("editBookContents"));
-                } else {
-                    throw new Exception(tl("denyBookEdit"));
-                }
-            }
-        } else if (item.getType() == WRITABLE_BOOK) {
-            BookMeta bmeta = (BookMeta) item.getItemMeta();
-            if (!user.isAuthorized("essentials.book.author")) {
-                bmeta.setAuthor(player);
-            }
-            ItemStack newItem = new ItemStack(Material.WRITTEN_BOOK, item.getAmount());
-            newItem.setItemMeta(bmeta);
-            InventoryWorkaround.setItemInMainHand(user.getBase(), newItem);
-            user.sendMessage(tl("bookLocked"));
-        } else {
-            throw new Exception(tl("holdBook"));
-        }
-    }
-
-    private boolean isAuthor(BookMeta bmeta, String player) {
-        String author = bmeta.getAuthor();
-        return author != null && author.equalsIgnoreCase(player);
-    }
-
-    @Override
-    protected List<String> getTabCompleteOptions(Server server, User user, String commandLabel, String[] args) {
-        // Right now, we aren't testing what's held in the player's hand - we could, but it's not necessarily worth it
-        if (args.length == 1) {
-            List<String> options = Lists.newArrayList("sign", "unsign");  // sign and unsign aren't real, but work
-            if (user.isAuthorized("essentials.book.author")) {
-                options.add("author");
-            }
-            if (user.isAuthorized("essentials.book.title")) {
-                options.add("title");
-            }
-            return options;
-        } else if (args.length == 2 && args[0].equalsIgnoreCase("author") && user.isAuthorized("essentials.book.author")) {
-            List<String> options = getPlayers(server, user);
-            options.add("Herobrine"); // #EasterEgg
-            return options;
-        } else {
-            return Collections.emptyList();
-        }
-    }
-}

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

@@ -1,33 +0,0 @@
-package com.earth2me.essentials.commands;
-
-import com.earth2me.essentials.CommandSource;
-import com.earth2me.essentials.User;
-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");
-    }
-
-    @Override
-    public void run(final Server server, final User user, final String commandLabel, final String[] args) throws Exception {
-        sendBroadcast(user.getDisplayName(), args);
-    }
-
-    @Override
-    public void run(final Server server, final CommandSource sender, final String commandLabel, final String[] args) throws Exception {
-        sendBroadcast(sender.getSender().getName(), args);
-    }
-
-    private void sendBroadcast(final String name, final String[] args) throws NotEnoughArgumentsException {
-        if (args.length < 1) {
-            throw new NotEnoughArgumentsException();
-        }
-
-        ess.broadcastMessage(tl("broadcast", FormatUtil.replaceFormat(getFinalArg(args, 0)).replace("\\n", "\n"), name));
-    }
-}

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

@@ -1,110 +0,0 @@
-package com.earth2me.essentials.commands;
-
-import static com.earth2me.essentials.I18n.tl;
-
-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.utils.FormatUtil;
-import com.google.common.collect.Lists;
-
-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;
-
-
-public class Commandbroadcastworld extends EssentialsCommand {
-
-    public Commandbroadcastworld() {
-        super("broadcastworld");
-    }
-
-    @Override
-    public void run(final Server server, final User user, final String commandLabel, final String[] args) throws Exception {
-        World world = user.getWorld();
-        String message = getFinalArg(args, 0);
-
-        if (args.length < 1) {
-            throw new NotEnoughArgumentsException();
-        } else if (args.length > 1 && ess.getSettings().isAllowWorldInBroadcastworld()) {
-            World argWorld = ess.getWorld(args[0]);
-            if (argWorld != null) {
-                world = argWorld;
-                message = getFinalArg(args, 1);
-            }
-        }
-
-        if (world == null) {
-            world = user.getWorld();
-            message = getFinalArg(args, 0);
-        }
-
-        sendBroadcast(world.getName(), user.getDisplayName(), message);
-    }
-
-    @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");
-        }
-        sendBroadcast(args[0], sender.getSender().getName(), getFinalArg(args, 1));
-    }
-
-    private void sendBroadcast(final String worldName, final String name, final String message) throws Exception {
-        World world = ess.getWorld(worldName);
-        if (world == null) {
-            throw new Exception(tl("invalidWorld"));
-        }
-        if (message.isEmpty()) {
-            throw new NotEnoughArgumentsException();
-        }
-        sendToWorld(world, tl("broadcast", FormatUtil.replaceFormat(message).replace("\\n", "\n"), name));
-    }
-
-    private void sendToWorld(World world, String message) {
-        IText broadcast = new SimpleTextInput(message);
-        final Collection<Player> players = ess.getOnlinePlayers();
-
-        for (Player player : players) {
-            if (player.getWorld().equals(world)) {
-                final User user = ess.getUser(player);
-                broadcast = new KeywordReplacer(broadcast, new CommandSource(player), ess, false);
-                for (String messageText : broadcast.getLines()) {
-                    user.sendMessage(messageText);
-                }
-            }
-        }
-    }
-
-    @Override
-    protected List<String> getTabCompleteOptions(Server server, User user, String commandLabel, String[] args) {
-        if (args.length == 1 && ess.getSettings().isAllowWorldInBroadcastworld()) {
-            List<String> worlds = Lists.newArrayList();
-            for (World world : server.getWorlds()) {
-                worlds.add(world.getName());
-            }
-            return worlds;
-        } else {
-            return Collections.emptyList();
-        }
-    }
-
-    @Override
-    protected List<String> getTabCompleteOptions(Server server, CommandSource sender, String commandLabel, String[] args) {
-        if (args.length == 1) {
-            List<String> worlds = Lists.newArrayList();
-            for (World world : server.getWorlds()) {
-                worlds.add(world.getName());
-            }
-            return worlds;
-        } else {
-            return Collections.emptyList();
-        }
-    }
-}

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

@@ -1,200 +0,0 @@
-package com.earth2me.essentials.commands;
-
-import static com.earth2me.essentials.I18n.tl;
-
-import com.earth2me.essentials.CommandSource;
-import com.earth2me.essentials.User;
-import com.earth2me.essentials.craftbukkit.InventoryWorkaround;
-import com.earth2me.essentials.utils.NumberUtil;
-import com.earth2me.essentials.utils.StringUtil;
-
-import org.bukkit.Material;
-import org.bukkit.Server;
-import org.bukkit.entity.Player;
-import org.bukkit.inventory.ItemStack;
-
-import java.util.*;
-
-
-public class Commandclearinventory extends EssentialsCommand {
-
-    public Commandclearinventory() {
-        super("clearinventory");
-    }
-
-    private static final int BASE_AMOUNT = 100000;
-    private static final int EXTENDED_CAP = 8;
-
-    @Override
-    public void run(Server server, User user, String commandLabel, String[] args) throws Exception {
-        parseCommand(server, user.getSource(), commandLabel, args, user.isAuthorized("essentials.clearinventory.others"),
-            user.isAuthorized("essentials.clearinventory.all") || user.isAuthorized("essentials.clearinventory.multiple"));
-    }
-
-    @Override
-    protected void run(Server server, CommandSource sender, String commandLabel, String[] args) throws Exception {
-        parseCommand(server, sender, commandLabel, args, true, true);
-    }
-
-    private void parseCommand(Server server, CommandSource sender, String commandLabel, String[] args, boolean allowOthers, boolean allowAll)
-        throws Exception {
-        Collection<Player> players = new ArrayList<Player>();
-        User senderUser = ess.getUser(sender.getPlayer());
-        String previousClearCommand = "";
-        
-        int offset = 0;
-
-        if (sender.isPlayer()) {
-            players.add(sender.getPlayer());
-            // Clear previous command execution before potential errors to reset confirmation.
-            previousClearCommand = senderUser.getConfirmingClearCommand();
-            senderUser.setConfirmingClearCommand(null);
-        }
-
-        if (allowAll && args.length > 0 && args[0].contentEquals("*")) {
-            sender.sendMessage(tl("inventoryClearingFromAll"));
-            offset = 1;
-            players = ess.getOnlinePlayers();
-        } else if (allowOthers && args.length > 0 && args[0].trim().length() > 2) {
-            offset = 1;
-            players = server.matchPlayer(args[0].trim());
-        }
-
-        if (players.size() < 1) {
-            throw new PlayerNotFoundException();
-        }
-
-
-        // Confirm
-        String formattedCommand = formatCommand(commandLabel, args);
-        if (senderUser != null && senderUser.isPromptingClearConfirm()) {
-            if (!formattedCommand.equals(previousClearCommand)) {
-                senderUser.setConfirmingClearCommand(formattedCommand);
-                senderUser.sendMessage(tl("confirmClear", formattedCommand));
-                return;
-            }
-        }
-
-        for (Player player : players) {
-            clearHandler(sender, player, args, offset, players.size() < EXTENDED_CAP);
-        }
-    }
-
-    protected void clearHandler(CommandSource sender, Player player, String[] args, int offset, boolean showExtended) throws Exception {
-        short data = -1;
-        int type = -1;
-        int amount = -1;
-        final Set<Material> mats = new HashSet<>();
-
-        if (args.length > (offset + 1) && NumberUtil.isInt(args[(offset + 1)])) {
-            amount = Integer.parseInt(args[(offset + 1)]);
-        }
-        if (args.length > offset) {
-            if (args[offset].equalsIgnoreCase("**")) {
-                type = -2;
-            } else if (!args[offset].equalsIgnoreCase("*")) {
-                final String[] split = args[offset].split(",");
-
-                for (String name : split) {
-                    try {
-                        mats.add(ess.getItemDb().get(name).getType());
-                    } catch (Exception ignored) {}
-                }
-
-                type = 1;
-            }
-        }
-
-        if (type == -1) // type -1 represents wildcard or all items
-        {
-            if (showExtended) {
-                sender.sendMessage(tl("inventoryClearingAllItems", player.getDisplayName()));
-            }
-            InventoryWorkaround.clearInventoryNoArmor(player.getInventory());
-            InventoryWorkaround.setItemInOffHand(player, null);
-        } else if (type == -2) // type -2 represents double wildcard or all items and armor
-        {
-            if (showExtended) {
-                sender.sendMessage(tl("inventoryClearingAllArmor", player.getDisplayName()));
-            }
-            InventoryWorkaround.clearInventoryNoArmor(player.getInventory());
-            InventoryWorkaround.setItemInOffHand(player, null);
-            player.getInventory().setArmorContents(null);
-        } else {
-            for (Material mat : mats) {
-                if (amount == -1) // amount -1 means all items will be cleared
-                {
-                    ItemStack stack = new ItemStack(mat, BASE_AMOUNT, data);
-                    ItemStack removedStack = player.getInventory().removeItem(stack).get(0);
-                    final int removedAmount = (BASE_AMOUNT - removedStack.getAmount());
-                    if (removedAmount > 0 || showExtended) {
-                        sender.sendMessage(tl("inventoryClearingStack", removedAmount, stack.getType().toString().toLowerCase(Locale.ENGLISH), player.getDisplayName()));
-                    }
-                } else {
-                    if (amount < 0) {
-                        amount = 1;
-                    }
-                    ItemStack stack = new ItemStack(mat, amount);
-                    if (player.getInventory().containsAtLeast(stack, amount)) {
-                        sender.sendMessage(tl("inventoryClearingStack", amount, stack.getType().toString().toLowerCase(Locale.ENGLISH), player.getDisplayName()));
-                        player.getInventory().removeItem(stack);
-                    } else {
-                        if (showExtended) {
-                            sender.sendMessage(tl("inventoryClearFail", player.getDisplayName(), amount, stack.getType().toString().toLowerCase(Locale.ENGLISH)));
-                        }
-                    }
-                }
-            }
-        }
-    }
-
-    @Override
-    protected List<String> getTabCompleteOptions(Server server, User user, String commandLabel, String[] args) {
-        if (user.isAuthorized("essentials.clearinventory.others")) {
-            if (args.length == 1) {
-                List<String> options = getPlayers(server, 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("*");
-                }
-                return options;
-            } else if (args.length == 2) {
-                List<String> items = new ArrayList<>(getItems());
-                items.add("*");
-                items.add("**");
-                return items;
-            } else {
-                return Collections.emptyList();
-            }
-        } else {
-            if (args.length == 1) {
-                List<String> items = new ArrayList<>(getItems());
-                items.add("*");
-                items.add("**");
-                return items;
-            } else {
-                return Collections.emptyList();
-            }
-        }
-    }
-
-    @Override
-    protected List<String> getTabCompleteOptions(Server server, CommandSource sender, String commandLabel, String[] args) {
-        if (args.length == 1) {
-            List<String> options = getPlayers(server, sender);
-            options.add("*");
-            return options;
-        } else if (args.length == 2) {
-            List<String> items = new ArrayList<>(getItems());
-            items.add("*");
-            items.add("**");
-            return items;
-        } else {
-            return Collections.emptyList();
-        }
-    }
-
-    private String formatCommand(String commandLabel, String[] args) {
-        return "/" + commandLabel + " " + StringUtil.joinList(" ", (Object[]) args);
-    }
-}

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

@@ -1,131 +0,0 @@
-package com.earth2me.essentials.commands;
-
-import com.google.common.base.Charsets;
-import com.google.common.io.CharStreams;
-import com.google.gson.Gson;
-import com.google.gson.JsonObject;
-
-import com.earth2me.essentials.CommandSource;
-import com.earth2me.essentials.User;
-import com.earth2me.essentials.utils.DateUtil;
-
-import org.bukkit.Material;
-import org.bukkit.Server;
-import org.bukkit.configuration.ConfigurationSection;
-import org.bukkit.configuration.MemoryConfiguration;
-import org.bukkit.configuration.file.YamlConstructor;
-import org.bukkit.configuration.file.YamlRepresenter;
-import org.bukkit.inventory.ItemStack;
-import org.yaml.snakeyaml.DumperOptions;
-import org.yaml.snakeyaml.DumperOptions.FlowStyle;
-import org.yaml.snakeyaml.Yaml;
-import org.yaml.snakeyaml.representer.Representer;
-
-import java.io.InputStreamReader;
-import java.io.OutputStream;
-import java.net.HttpURLConnection;
-import java.net.URL;
-import java.util.ArrayList;
-import java.util.List;
-import java.util.concurrent.ExecutorService;
-import java.util.concurrent.Executors;
-
-import static com.earth2me.essentials.I18n.tl;
-
-public class Commandcreatekit extends EssentialsCommand {
-
-    private static final String PASTE_URL = "https://hastebin.com/";
-    private static final String PASTE_UPLOAD_URL = PASTE_URL + "documents";
-    private static final Gson GSON = new Gson();
-
-    private final ExecutorService executorService = Executors.newSingleThreadExecutor();
-    private final DumperOptions yamlOptions = new DumperOptions();
-    private final Representer yamlRepresenter = new YamlRepresenter();
-    private final YamlConstructor yamlConstructor = new YamlConstructor();
-
-    public Commandcreatekit() {
-        super("createkit");
-        yamlOptions.setDefaultFlowStyle(FlowStyle.BLOCK);
-        yamlRepresenter.setDefaultFlowStyle(FlowStyle.BLOCK);
-    }
-
-    // /createkit <name> <delay>
-    @Override
-    public void run(final Server server, final User user, final String commandLabel, final String[] args) throws Exception {
-        if (args.length != 2) {
-            throw new NotEnoughArgumentsException();
-        }
-
-        // Command handler will auto fail if this fails.
-        long delay = Long.valueOf(args[1]);
-        String kitname = args[0];
-        ItemStack[] items = user.getBase().getInventory().getContents();
-        List<String> list = new ArrayList<>();
-        for (ItemStack is : items) {
-            if (is != null && is.getType() != null && is.getType() != Material.AIR) {
-                String serialized = ess.getItemDb().serialize(is);
-                list.add(serialized);
-            }
-        }
-        // 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));
-        } else {
-            ConfigurationSection config = new MemoryConfiguration();
-            config.set("kits." + kitname + ".delay", delay);
-            config.set("kits." + kitname + ".items", list);
-
-            final Yaml yaml = new Yaml(yamlConstructor, yamlRepresenter, yamlOptions);
-            String fileContents = "# Copy the kit code below into the kits section in your config.yml file\n";
-            fileContents += yaml.dump(config.getValues(false));
-
-            uploadPaste(user.getSource(), kitname, delay, fileContents);
-        }
-    }
-
-    private void uploadPaste(final CommandSource sender, final String kitName, final long delay, final String contents) {
-        executorService.submit(new Runnable() {
-            @Override
-            public void run() {
-                try {
-                    HttpURLConnection connection = (HttpURLConnection) new URL(PASTE_UPLOAD_URL).openConnection();
-                    connection.setRequestMethod("POST");
-                    connection.setDoInput(true);
-                    connection.setDoOutput(true);
-                    connection.setRequestProperty("User-Agent", "EssentialsX plugin");
-                    try (OutputStream os = connection.getOutputStream()) {
-                        os.write(contents.getBytes(Charsets.UTF_8));
-                    }
-                    // Error
-                    if (connection.getResponseCode() >= 400) {
-                        sender.sendMessage(tl("createKitFailed", kitName));
-                        String message = CharStreams.toString(new InputStreamReader(connection.getErrorStream(), Charsets.UTF_8));
-                        ess.getLogger().severe("Error creating kit: " + message);
-                        return;
-                    }
-
-                    // Read URL
-                    JsonObject object = GSON.fromJson(new InputStreamReader(connection.getInputStream(), Charsets.UTF_8), JsonObject.class);
-                    String pasteUrl = PASTE_URL + object.get("key").getAsString();
-                    connection.disconnect();
-
-                    String separator = tl("createKitSeparator");
-                    String delayFormat = "0";
-                    if (delay > 0) {
-                        delayFormat = DateUtil.formatDateDiff(System.currentTimeMillis() + (delay * 1000));
-                    }
-                    sender.sendMessage(separator);
-                    sender.sendMessage(tl("createKitSuccess", kitName, delayFormat, pasteUrl));
-                    sender.sendMessage(separator);
-                    if (ess.getSettings().isDebug()) {
-                        ess.getLogger().info(sender.getSender().getName() + " created a kit: " + pasteUrl);
-                    }
-                } catch (Exception e) {
-                    sender.sendMessage(tl("createKitFailed", kitName));
-                    e.printStackTrace();
-                }
-            }
-        });
-    }
-}

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

@@ -1,78 +0,0 @@
-package com.earth2me.essentials.commands;
-
-import com.earth2me.essentials.CommandSource;
-import com.earth2me.essentials.User;
-import org.bukkit.Server;
-
-import java.util.ArrayList;
-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");
-    }
-
-    @Override
-    public void run(final Server server, final CommandSource sender, final String commandLabel, String[] args) throws Exception {
-        if (args.length < 1) {
-            throw new NotEnoughArgumentsException();
-        }
-
-        User user = ess.getUser(sender.getPlayer());
-        String name;
-        String[] expandedArg;
-
-        //Allowing both formats /sethome khobbits house | /sethome khobbits:house
-        final String[] nameParts = args[0].split(":");
-        if (nameParts[0].length() != args[0].length()) {
-            expandedArg = nameParts;
-        } else {
-            expandedArg = args;
-        }
-
-        if (expandedArg.length > 1 && (user == null || user.isAuthorized("essentials.delhome.others"))) {
-            user = getPlayer(server, expandedArg, 0, true, true);
-            name = expandedArg[1];
-        } else if (user == null) {
-            throw new NotEnoughArgumentsException();
-        } else {
-            name = expandedArg[0];
-        }
-
-        if (name.equalsIgnoreCase("bed")) {
-            throw new Exception(tl("invalidHomeName"));
-        }
-
-        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) {
-        User user = ess.getUser(sender.getPlayer());
-        boolean canDelOthers = (user == null || user.isAuthorized("essentials.delhome.others"));
-
-        if (args.length == 1) {
-            if (canDelOthers) {
-                return getPlayers(server, sender);
-            } else {
-                return user.getHomes();
-            }
-        } else if (args.length == 2 && canDelOthers) {
-            try {
-                user = getPlayer(server, args, 0, true, true);
-                return user.getHomes();
-            } catch (Exception ex) {
-                // No such user
-                return Collections.emptyList();
-            }
-        } else {
-            return Collections.emptyList();
-        }
-    }
-}

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

@@ -1,36 +0,0 @@
-package com.earth2me.essentials.commands;
-
-import com.earth2me.essentials.CommandSource;
-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 Commanddelwarp extends EssentialsCommand {
-    public Commanddelwarp() {
-        super("delwarp");
-    }
-
-    @Override
-    public void run(final Server server, final CommandSource sender, final String commandLabel, final String[] args) throws Exception {
-        if (args.length < 1) {
-            throw new NotEnoughArgumentsException();
-        }
-
-        ess.getWarps().removeWarp(args[0]);
-        sender.sendMessage(tl("deleteWarp", args[0]));
-    }
-
-    @Override
-    protected List<String> getTabCompleteOptions(final Server server, final CommandSource sender, final String commandLabel, final String[] args) {
-        if (args.length == 1) {
-            return new ArrayList<>(ess.getWarps().getList());
-        } else {
-            return Collections.emptyList();
-        }
-    }
-}

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

@@ -1,125 +0,0 @@
-package com.earth2me.essentials.commands;
-
-import com.earth2me.essentials.ChargeException;
-import com.earth2me.essentials.CommandSource;
-import com.earth2me.essentials.User;
-import com.earth2me.essentials.utils.NumberUtil;
-import com.google.common.collect.Lists;
-import net.ess3.api.MaxMoneyException;
-import org.bukkit.Server;
-
-import java.math.BigDecimal;
-import java.util.Collections;
-import java.util.List;
-import java.util.Locale;
-
-import static com.earth2me.essentials.I18n.tl;
-
-
-public class Commandeco extends EssentialsLoopCommand {
-    Commandeco.EcoCommands cmd;
-    BigDecimal amount;
-
-    public Commandeco() {
-        super("eco");
-    }
-
-    @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();
-        }
-
-        BigDecimal startingBalance = ess.getSettings().getStartingBalance();
-
-        try {
-            cmd = Commandeco.EcoCommands.valueOf(args[0].toUpperCase(Locale.ENGLISH));
-            amount = (cmd == Commandeco.EcoCommands.RESET) ? startingBalance : new BigDecimal(args[2].replaceAll("[^0-9\\.]", ""));
-        } catch (Exception ex) {
-            throw new NotEnoughArgumentsException(ex);
-        }
-
-        loopOfflinePlayers(server, sender, false, true, args[1], args);
-
-        if (cmd == Commandeco.EcoCommands.RESET || cmd == Commandeco.EcoCommands.SET) {
-            if (args[1].contentEquals("**")) {
-                server.broadcastMessage(tl("resetBalAll", NumberUtil.displayCurrency(amount, ess)));
-            } else if (args[1].contentEquals("*")) {
-                server.broadcastMessage(tl("resetBal", NumberUtil.displayCurrency(amount, ess)));
-            }
-        }
-    }
-
-    @Override
-    protected void updatePlayer(final Server server, final CommandSource sender, final User player, final String[] args) throws NotEnoughArgumentsException, ChargeException, MaxMoneyException {
-        switch (cmd) {
-            case GIVE:
-                player.giveMoney(amount, sender);
-                break;
-
-            case TAKE:
-                take(amount, player, sender);
-                break;
-
-            case RESET:
-            case SET:
-                set(amount, player, sender);
-                break;
-        }
-    }
-
-    private void take(BigDecimal amount, final User player, final CommandSource sender) throws ChargeException {
-        BigDecimal money = player.getMoney();
-        BigDecimal minBalance = ess.getSettings().getMinMoney();
-        if (money.subtract(amount).compareTo(minBalance) >= 0) {
-            player.takeMoney(amount, sender);
-        } else if (sender == null) {
-            try {
-                player.setMoney(minBalance);
-            } catch (MaxMoneyException ex) {
-                // Take shouldn't be able to throw a max money exception
-            }
-            player.sendMessage(tl("takenFromAccount", NumberUtil.displayCurrency(player.getMoney(), ess)));
-        } else {
-            throw new ChargeException(tl("insufficientFunds"));
-        }
-    }
-
-    private void set(BigDecimal amount, final User player, final CommandSource sender) throws MaxMoneyException {
-        BigDecimal minBalance = ess.getSettings().getMinMoney();
-        BigDecimal maxBalance = ess.getSettings().getMaxMoney();
-        boolean underMinimum = (amount.compareTo(minBalance) < 0);
-        boolean aboveMax = (amount.compareTo(maxBalance) > 0);
-        player.setMoney(underMinimum ? minBalance : aboveMax ? maxBalance : amount);
-        player.sendMessage(tl("setBal", NumberUtil.displayCurrency(player.getMoney(), ess)));
-        if (sender != null) {
-            sender.sendMessage(tl("setBalOthers", player.getDisplayName(), NumberUtil.displayCurrency(player.getMoney(), ess)));
-        }
-    }
-
-
-    private enum EcoCommands {
-        GIVE, TAKE, SET, RESET
-    }
-
-    @Override
-    protected List<String> getTabCompleteOptions(Server server, final CommandSource sender, String commandLabel, String[] args) {
-        if (args.length == 1) {
-            List<String> options = Lists.newArrayList();
-            for (EcoCommands command : EcoCommands.values()) {
-                options.add(command.name().toLowerCase(Locale.ENGLISH));
-            }
-            return options;
-        } else if (args.length == 2) {
-            return getPlayers(server, 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());
-            } else {
-                return Lists.newArrayList("1", "10", "100", "1000");
-            }
-        } else {
-            return Collections.emptyList();
-        }
-    }
-}

Essentials/src/com/earth2me/essentials/commands/Commandessentials.java

@@ -1,415 +0,0 @@
-package com.earth2me.essentials.commands;
-
-import com.earth2me.essentials.CommandSource;
-import com.earth2me.essentials.EssentialsUpgrade;
-import com.earth2me.essentials.User;
-import com.earth2me.essentials.UserMap;
-import com.earth2me.essentials.utils.*;
-import com.google.common.base.Charsets;
-import com.google.common.collect.Lists;
-import org.bukkit.Material;
-import org.bukkit.Server;
-import org.bukkit.Sound;
-import org.bukkit.block.Block;
-import org.bukkit.entity.Player;
-import org.bukkit.plugin.Plugin;
-import org.bukkit.plugin.PluginDescriptionFile;
-import org.bukkit.plugin.PluginManager;
-
-import java.util.*;
-
-import static com.earth2me.essentials.I18n.tl;
-
-// This command has 4 undocumented behaviours #EasterEgg
-public class Commandessentials extends EssentialsCommand {
-
-    private final Sound NOTE_HARP = EnumUtil.valueOf(Sound.class, "BLOCK_NOTE_BLOCK_HARP", "BLOCK_NOTE_HARP", "NOTE_PIANO");
-
-    public Commandessentials() {
-        super("essentials");
-    }
-
-    private transient int taskid;
-    private final transient Map<Player, Block> noteBlocks = new HashMap<Player, Block>();
-
-    private final List<String> versionPlugins = Arrays.asList(
-            "Vault",
-            "LuckPerms",
-            "PermissionsEx",
-            "GroupManager"
-    );
-
-    private final List<String> officialPlugins = Arrays.asList(
-            "EssentialsAntiBuild",
-            "EssentialsChat",
-            "EssentialsGeoIP",
-            "EssentialsProtect",
-            "EssentialsSpawn",
-            "EssentialsXMPP"
-    );
-
-    private final List<String> warnPlugins = Arrays.asList(
-            "PermissionsEx",
-            "GroupManager"
-    );
-
-    @Override
-    public void run(final Server server, final CommandSource sender, final String commandLabel, final String[] args) throws Exception {
-        if (args.length == 0) {
-            run_disabled(server, sender, commandLabel, args);
-        } else if (args[0].equalsIgnoreCase("debug")) {
-            run_debug(server, sender, commandLabel, args);
-        } else if (args[0].equalsIgnoreCase("nya")) {
-            run_nya(server, sender, commandLabel, args);
-        } else if (args[0].equalsIgnoreCase("moo")) {
-            run_moo(server, sender, commandLabel, args);
-        } else if (args[0].equalsIgnoreCase("reset")) {
-            run_reset(server, sender, commandLabel, args);
-        } else if (args[0].equalsIgnoreCase("cleanup")) {
-            run_cleanup(server, sender, commandLabel, args);
-        } else if (args[0].equalsIgnoreCase("uuidconvert")) {
-            run_uuidconvert(server, sender, commandLabel, args);
-        } else if (args[0].equalsIgnoreCase("uuidtest")) {
-            run_uuidtest(server, sender, commandLabel, args);
-        } else if (args[0].equalsIgnoreCase("version")) {
-            run_version(server, sender, commandLabel, args);
-        } else {
-            run_reload(server, sender, commandLabel, args);
-        }
-    }
-
-    //If you do not supply an argument this command will list 'overridden' commands.
-    private void run_disabled(final Server server, final CommandSource sender, final String commandLabel, final String[] args) throws Exception {
-        sender.sendMessage("/<command> <reload/debug>");
-
-        final StringBuilder disabledCommands = new StringBuilder();
-        for (Map.Entry<String, String> entry : ess.getAlternativeCommandsHandler().disabledCommands().entrySet()) {
-            if (disabledCommands.length() > 0) {
-                disabledCommands.append(", ");
-            }
-            disabledCommands.append(entry.getKey()).append(" => ").append(entry.getValue());
-        }
-        if (disabledCommands.length() > 0) {
-            sender.sendMessage(tl("blockList"));
-            sender.sendMessage(disabledCommands.toString());
-        }
-    }
-
-    private void run_reset(final Server server, final CommandSource sender, final String commandLabel, final String[] args) throws Exception {
-        if (args.length < 2) {
-            throw new Exception("/<command> reset <player>");
-        }
-        final User user = getPlayer(server, args, 1, true, true);
-        user.reset();
-        sender.sendMessage("Reset Essentials userdata for player: " + user.getDisplayName());
-    }
-
-    private void run_debug(final Server server, final CommandSource sender, final String commandLabel, final String[] args) throws Exception {
-        ess.getSettings().setDebug(!ess.getSettings().isDebug());
-        sender.sendMessage("Essentials " + ess.getDescription().getVersion() + " debug mode " + (ess.getSettings().isDebug() ? "enabled" : "disabled"));
-    }
-
-    private void run_reload(final Server server, final CommandSource sender, final String commandLabel, final String[] args) throws Exception {
-        ess.reload();
-        sender.sendMessage(tl("essentialsReload", ess.getDescription().getVersion()));
-    }
-
-    private void run_nya(final Server server, final CommandSource sender, final String commandLabel, final String[] args) throws Exception {
-        final Map<String, Float> noteMap = new HashMap<String, Float>();
-        noteMap.put("1F#", 0.5f);
-        noteMap.put("1G", 0.53f);
-        noteMap.put("1G#", 0.56f);
-        noteMap.put("1A", 0.6f);
-        noteMap.put("1A#", 0.63f);
-        noteMap.put("1B", 0.67f);
-        noteMap.put("1C", 0.7f);
-        noteMap.put("1C#", 0.76f);
-        noteMap.put("1D", 0.8f);
-        noteMap.put("1D#", 0.84f);
-        noteMap.put("1E", 0.9f);
-        noteMap.put("1F", 0.94f);
-        noteMap.put("2F#", 1.0f);
-        noteMap.put("2G", 1.06f);
-        noteMap.put("2G#", 1.12f);
-        noteMap.put("2A", 1.18f);
-        noteMap.put("2A#", 1.26f);
-        noteMap.put("2B", 1.34f);
-        noteMap.put("2C", 1.42f);
-        noteMap.put("2C#", 1.5f);
-        noteMap.put("2D", 1.6f);
-        noteMap.put("2D#", 1.68f);
-        noteMap.put("2E", 1.78f);
-        noteMap.put("2F", 1.88f);
-        final String tuneStr = "1D#,1E,2F#,,2A#,1E,1D#,1E,2F#,2B,2D#,2E,2D#,2A#,2B,,2F#,,1D#,1E,2F#,2B,2C#,2A#,2B,2C#,2E,2D#,2E,2C#,,2F#,,2G#,,1D,1D#,,1C#,1D,1C#,1B,,1B,,1C#,,1D,,1D,1C#,1B,1C#,1D#,2F#,2G#,1D#,2F#,1C#,1D#,1B,1C#,1B,1D#,,2F#,,2G#,1D#,2F#,1C#,1D#,1B,1D,1D#,1D,1C#,1B,1C#,1D,,1B,1C#,1D#,2F#,1C#,1D,1C#,1B,1C#,,1B,,1C#,,2F#,,2G#,,1D,1D#,,1C#,1D,1C#,1B,,1B,,1C#,,1D,,1D,1C#,1B,1C#,1D#,2F#,2G#,1D#,2F#,1C#,1D#,1B,1C#,1B,1D#,,2F#,,2G#,1D#,2F#,1C#,1D#,1B,1D,1D#,1D,1C#,1B,1C#,1D,,1B,1C#,1D#,2F#,1C#,1D,1C#,1B,1C#,,1B,,1B,,1B,,1F#,1G#,1B,,1F#,1G#,1B,1C#,1D#,1B,1E,1D#,1E,2F#,1B,,1B,,1F#,1G#,1B,1E,1D#,1C#,1B,,,,1F#,1B,,1F#,1G#,1B,,1F#,1G#,1B,1B,1C#,1D#,1B,1F#,1G#,1F#,1B,,1B,1A#,1B,1F#,1G#,1B,1E,1D#,1E,2F#,1B,,1A#,,1B,,1F#,1G#,1B,,1F#,1G#,1B,1C#,1D#,1B,1E,1D#,1E,2F#,1B,,1B,,1F#,1G#,1B,1F#,1E,1D#,1C#,1B,,,,1F#,1B,,1F#,1G#,1B,,1F#,1G#,1B,1B,1C#,1D#,1B,1F#,1G#,1F#,1B,,1B,1A#,1B,1F#,1G#,1B,1E,1D#,1E,2F#,1B,,1A#,,1B,,1F#,1G#,1B,,1F#,1G#,1B,1C#,1D#,1B,1E,1D#,1E,2F#,1B,,1B,,1F#,1G#,1B,1F#,1E,1D#,1C#,1B,,,,1F#,1B,,1F#,1G#,1B,,1F#,1G#,1B,1B,1C#,1D#,1B,1F#,1G#,1F#,1B,,1B,1A#,1B,1F#,1G#,1B,1E,1D#,1E,2F#,1B,,1A#,,1B,,1F#,1G#,1B,,1F#,1G#,1B,1C#,1D#,1B,1E,1D#,1E,2F#,1B,,1B,,1F#,1G#,1B,1F#,1E,1D#,1C#,1B,,,,1F#,1B,,1F#,1G#,1B,,1F#,1G#,1B,1B,1C#,1D#,1B,1F#,1G#,1F#,1B,,1B,1A#,1B,1F#,1G#,1B,1E,1D#,1E,2F#,1B,,1A#,,1B,,1F#,1G#,1B,,1F#,1G#,1B,1C#,1D#,1B,1E,1D#,1E,2F#,1B,,1B,,1F#,1G#,1B,1F#,1E,1D#,1C#,1B,,,,1F#,1B,,1F#,1G#,1B,,1F#,1G#,1B,1B,1C#,1D#,1B,1F#,1G#,1F#,1B,,1B,1A#,1B,1F#,1G#,1B,1E,1D#,1E,2F#,1B,,1B,,";
-        final String[] tune = tuneStr.split(",");
-        taskid = ess.scheduleSyncRepeatingTask(new Runnable() {
-            int i = 0;
-
-            @Override
-            public void run() {
-                final String note = tune[i];
-                i++;
-                if (i >= tune.length) {
-                    Commandessentials.this.stopTune();
-                }
-                if (note == null || note.isEmpty()) {
-                    return;
-                }
-
-                for (Player onlinePlayer : ess.getOnlinePlayers()) {
-                    onlinePlayer.playSound(onlinePlayer.getLocation(), NOTE_HARP, 1, noteMap.get(note));
-                }
-            }
-        }, 20, 2);
-    }
-
-    private void stopTune() {
-        ess.getScheduler().cancelTask(taskid);
-        for (Block block : noteBlocks.values()) {
-            if (block.getType() == Material.NOTE_BLOCK) {
-                block.setType(Material.AIR);
-            }
-        }
-        noteBlocks.clear();
-    }
-
-    private final String[] consoleMoo = new String[]{"         (__)", "         (oo)", "   /------\\/", "  / |    ||", " *  /\\---/\\", "    ~~   ~~", "....\"Have you mooed today?\"..."};
-    private final String[] playerMoo = new String[]{"            (__)", "            (oo)", "   /------\\/", "  /  |      | |", " *  /\\---/\\", "    ~~    ~~", "....\"Have you mooed today?\"..."};
-
-    private void run_moo(final Server server, final CommandSource sender, final String command, final String args[]) {
-        Sound moo = EnumUtil.valueOf(Sound.class, "COW_IDLE", "ENTITY_COW_MILK");
-
-        if (args.length == 2 && args[1].equals("moo")) {
-            for (String s : consoleMoo) {
-                logger.info(s);
-            }
-            for (Player player : ess.getOnlinePlayers()) {
-                player.sendMessage(playerMoo);
-                player.playSound(player.getLocation(), moo, 1, 1.0f);
-            }
-        } else {
-            if (sender.isPlayer()) {
-                sender.getSender().sendMessage(playerMoo);
-                final Player player = sender.getPlayer();
-                player.playSound(player.getLocation(), moo, 1, 1.0f);
-
-            } else {
-                sender.getSender().sendMessage(consoleMoo);
-            }
-        }
-    }
-
-    private void run_cleanup(final Server server, final CommandSource sender, final String command, final String args[]) throws Exception {
-        if (args.length < 2 || !NumberUtil.isInt(args[1])) {
-            sender.sendMessage("This sub-command will delete users who havent logged in in the last <days> days.");
-            sender.sendMessage("Optional parameters define the minium amount required to prevent deletion.");
-            sender.sendMessage("Unless you define larger default values, this command wil ignore people who have more than 0 money/homes.");
-            throw new Exception("/<command> cleanup <days> [money] [homes]");
-        }
-        sender.sendMessage(tl("cleaning"));
-
-        final long daysArg = Long.parseLong(args[1]);
-        final double moneyArg = args.length >= 3 ? FloatUtil.parseDouble(args[2].replaceAll("[^0-9\\.]", "")) : 0;
-        final int homesArg = args.length >= 4 && NumberUtil.isInt(args[3]) ? Integer.parseInt(args[3]) : 0;
-        final UserMap userMap = ess.getUserMap();
-
-        ess.runTaskAsynchronously(new Runnable() {
-            @Override
-            public void run() {
-                Long currTime = System.currentTimeMillis();
-                for (UUID u : userMap.getAllUniqueUsers()) {
-                    final User user = ess.getUserMap().getUser(u);
-                    if (user == null) {
-                        continue;
-                    }
-
-                    long lastLog = user.getLastLogout();
-                    if (lastLog == 0) {
-                        lastLog = user.getLastLogin();
-                    }
-                    if (lastLog == 0) {
-                        user.setLastLogin(currTime);
-                    }
-
-                    if (user.isNPC()) {
-                        continue;
-                    }
-
-                    long timeDiff = currTime - lastLog;
-                    long milliDays = daysArg * 24L * 60L * 60L * 1000L;
-                    int homeCount = user.getHomes().size();
-                    double moneyCount = user.getMoney().doubleValue();
-
-                    if ((lastLog == 0) || (timeDiff < milliDays) || (homeCount > homesArg) || (moneyCount > moneyArg)) {
-                        continue;
-                    }
-
-                    if (ess.getSettings().isDebug()) {
-                        ess.getLogger().info("Deleting user: " + user.getName() + " Money: " + moneyCount + " Homes: " + homeCount + " Last seen: " + DateUtil.formatDateDiff(lastLog));
-                    }
-
-                    user.reset();
-                }
-                sender.sendMessage(tl("cleaned"));
-            }
-        });
-
-    }
-
-    private void run_uuidconvert(final Server server, final CommandSource sender, final String commandLabel, final String[] args) throws Exception {
-        sender.sendMessage("Starting Essentials UUID userdata conversion, this may lag the server.");
-
-        Boolean ignoreUFCache = (args.length > 2 && args[1].toLowerCase(Locale.ENGLISH).contains("ignore"));
-        EssentialsUpgrade.uuidFileConvert(ess, ignoreUFCache);
-
-        sender.sendMessage("UUID conversion complete, check your server log for more information.");
-    }
-
-    private void run_uuidtest(final Server server, final CommandSource sender, final String commandLabel, final String[] args) throws Exception {
-        if (args.length < 2) {
-            throw new Exception("/<command> uuidtest <name>");
-        }
-        String name = args[1];
-        sender.sendMessage("Looking up UUID for " + name);
-
-        UUID onlineUUID = null;
-
-        for (Player player : ess.getOnlinePlayers()) {
-            if (player.getName().equalsIgnoreCase(name)) {
-                onlineUUID = player.getUniqueId();
-                break;
-            }
-        }
-
-        UUID essUUID = ess.getUserMap().getUser(name).getConfigUUID();
-
-        org.bukkit.OfflinePlayer player = ess.getServer().getOfflinePlayer(name);
-        UUID bukkituuid = player.getUniqueId();
-        sender.sendMessage("Bukkit Lookup: " + bukkituuid.toString());
-
-        if (onlineUUID != null && onlineUUID != bukkituuid) {
-            sender.sendMessage("Online player: " + onlineUUID.toString());
-        }
-
-        if (essUUID != null && essUUID != bukkituuid) {
-            sender.sendMessage("Essentials config: " + essUUID.toString());
-        }
-
-        UUID npcuuid = UUID.nameUUIDFromBytes(("NPC:" + name).getBytes(Charsets.UTF_8));
-        sender.sendMessage("NPC UUID: " + npcuuid.toString());
-
-        UUID offlineuuid = UUID.nameUUIDFromBytes(("OfflinePlayer:" + name).getBytes(Charsets.UTF_8));
-        sender.sendMessage("Offline Mode UUID: " + offlineuuid.toString());
-    }
-
-    private void run_version(final Server server, final CommandSource sender, final String commandLabel, final String[] args) throws Exception {
-        if (sender.isPlayer() && !ess.getUser(sender.getPlayer()).isAuthorized("essentials.version")) return;
-
-        boolean isMismatched = false;
-        boolean isVaultInstalled = false;
-        boolean isUnsupported = false;
-        final boolean isServerSupported = VersionUtil.isServerSupported();
-        final PluginManager pm = server.getPluginManager();
-        final String essVer = pm.getPlugin("Essentials").getDescription().getVersion();
-
-        sender.sendMessage(tl(isServerSupported ? "versionOutputFine" : "versionOutputWarn", "Server", server.getBukkitVersion() + " " + server.getVersion()));
-        sender.sendMessage(tl("versionOutputFine", "EssentialsX", essVer));
-
-        for (Plugin plugin : pm.getPlugins()) {
-            final PluginDescriptionFile desc = plugin.getDescription();
-            String name = desc.getName();
-            String version = desc.getVersion();
-
-            if (name.startsWith("Essentials") && !name.equalsIgnoreCase("Essentials")) {
-                if (officialPlugins.contains(name)) {
-                    name = name.replace("Essentials", "EssentialsX");
-
-                    if (!version.equalsIgnoreCase(essVer)) {
-                        isMismatched = true;
-                        sender.sendMessage(tl("versionOutputWarn", name, version));
-                    } else {
-                        sender.sendMessage(tl("versionOutputFine", name, version));
-                    }
-                } else {
-                    sender.sendMessage(tl("versionOutputUnsupported", name, version));
-                    isUnsupported = true;
-                }
-            }
-
-            if (versionPlugins.contains(name)) {
-                if (warnPlugins.contains(name)) {
-                    sender.sendMessage(tl("versionOutputUnsupported", name, version));
-                    isUnsupported = true;
-                } else {
-                    sender.sendMessage(tl("versionOutputFine", name, version));
-                }
-            }
-
-            if (name.equals("Vault")) isVaultInstalled = true;
-        }
-
-        if (isMismatched) {
-            sender.sendMessage(tl("versionMismatchAll"));
-        }
-
-        if (!isVaultInstalled) {
-            sender.sendMessage(tl("versionOutputVaultMissing"));
-        }
-
-        if (isUnsupported) {
-            sender.sendMessage(tl("versionOutputUnsupportedPlugins"));
-        }
-
-        if (!VersionUtil.isServerSupported()) {
-            sender.sendMessage(tl("serverUnsupported"));
-        }
-    }
-
-    @Override
-    protected List<String> getTabCompleteOptions(final Server server, final CommandSource sender, final String commandLabel, final String[] args) {
-        if (args.length == 1) {
-            List<String> options = Lists.newArrayList();
-            options.add("reload");
-            options.add("debug");
-            //options.add("nya");
-            //options.add("moo");
-            options.add("reset");
-            options.add("cleanup");
-            //options.add("uuidconvert");
-            //options.add("uuidtest");
-            options.add("version");
-            return options;
-        } else if (args[0].equalsIgnoreCase("debug")) {
-            // No args
-        } else if (args[0].equalsIgnoreCase("nya")) {
-            // No args
-        } else if (args[0].equalsIgnoreCase("moo")) {
-            if (args.length == 2) {
-                return Lists.newArrayList("moo");
-            }
-        } else if (args[0].equalsIgnoreCase("reset")) {
-            if (args.length == 2) {
-                return getPlayers(server, sender);
-            }
-        } else if (args[0].equalsIgnoreCase("cleanup")) {
-            if (args.length == 2) {
-                return COMMON_DURATIONS;
-            } else if (args.length == 3 || args.length == 4) {
-                return Lists.newArrayList("-1", "0");
-            }
-        } else if (args[0].equalsIgnoreCase("uuidconvert")) {
-            if (args.length == 2) {
-                return Lists.newArrayList("ignoreUFCache");
-            }
-        } else if (args[0].equalsIgnoreCase("uuidtest")) {
-            if (args.length == 2) {
-                return getPlayers(server, sender);
-            }
-        } else if (args[0].equalsIgnoreCase("version")) {
-            // No args
-        } else {
-            // No args
-        }
-        return Collections.emptyList();
-    }
-}

Essentials/src/com/earth2me/essentials/commands/Commandexp.java

@@ -1,223 +0,0 @@
-package com.earth2me.essentials.commands;
-
-import com.earth2me.essentials.CommandSource;
-import com.earth2me.essentials.User;
-import com.earth2me.essentials.craftbukkit.SetExpFix;
-import com.earth2me.essentials.utils.NumberUtil;
-import com.google.common.collect.Lists;
-import org.bukkit.Server;
-import org.bukkit.entity.Player;
-
-import java.util.Collections;
-import java.util.List;
-import java.util.Locale;
-
-import static com.earth2me.essentials.I18n.tl;
-
-
-public class Commandexp extends EssentialsCommand {
-    public Commandexp() {
-        super("exp");
-    }
-
-    @Override
-    public void run(final Server server, final User user, final String commandLabel, final String[] args) throws Exception {
-        if (args.length == 0) {
-            showExp(user.getSource(), user);
-        } else if (args.length > 1 && args[0].equalsIgnoreCase("set") && user.isAuthorized("essentials.exp.set")) {
-            if (args.length == 3 && user.isAuthorized("essentials.exp.set.others")) {
-                expMatch(server, user.getSource(), args[1], args[2], false);
-            } else {
-                setExp(user.getSource(), user, args[1], false);
-            }
-        } else if (args.length > 1 && args[0].equalsIgnoreCase("give") && user.isAuthorized("essentials.exp.give")) {
-            if (args.length == 3 && user.isAuthorized("essentials.exp.give.others")) {
-                expMatch(server, user.getSource(), args[1], args[2], true);
-            } else {
-                setExp(user.getSource(), user, args[1], true);
-            }
-        } else if (args.length > 1 && args[0].equalsIgnoreCase("take") && user.isAuthorized("essentials.exp.take")) {
-            if (args.length == 3 && user.isAuthorized("essentials.exp.take.others")) {
-                expMatch(server, user.getSource(), args[1], "-" + args[2], true);
-            } else {
-                setExp(user.getSource(), user, "-" + args[1], true);
-            }        
-        } else if (args.length < 3 && args[0].equalsIgnoreCase("reset") && user.isAuthorized("essentials.exp.reset")) {
-            if (args.length == 2 && user.isAuthorized("essentials.exp.reset.others")) {
-                expMatch(server, user.getSource(), args[1], "0", false);
-            } else {
-                setExp(user.getSource(), user, "0", false);
-            }
-        } else if (args[0].equalsIgnoreCase("show")) {
-            if (args.length >= 2 && user.isAuthorized("essentials.exp.others")) {
-                String match = args[1].trim();
-                showMatch(server, user.getSource(), match);
-            } else {
-                showExp(user.getSource(), user);
-            }
-        } else {
-            if (args.length >= 1 && NumberUtil.isInt(args[0].toLowerCase(Locale.ENGLISH).replace("l", "")) && user.isAuthorized("essentials.exp.give")) {
-                if (args.length >= 2 && user.isAuthorized("essentials.exp.give.others")) {
-                    expMatch(server, user.getSource(), args[1], args[0], true);
-                } else {
-                    setExp(user.getSource(), user, args[0], true);
-                }
-            } else if (args.length >= 1 && user.isAuthorized("essentials.exp.others")) {
-                String match = args[0].trim();
-                showMatch(server, user.getSource(), match);
-            } else {
-                showExp(user.getSource(), user);
-            }
-        }
-    }
-
-    @Override
-    public void run(final Server server, final CommandSource sender, final String commandLabel, final String[] args) throws Exception {
-        if (args.length < 1) {
-            throw new NotEnoughArgumentsException();
-        } else if (args.length > 2 && args[0].equalsIgnoreCase("set")) {
-            expMatch(server, sender, args[1], args[2], false);
-        } else if (args.length > 2 && args[0].equalsIgnoreCase("give")) {
-            expMatch(server, sender, args[1], args[2], true);
-        } else {
-            String match = args[0].trim();
-            if (args.length >= 2 && NumberUtil.isInt(args[0].toLowerCase(Locale.ENGLISH).replace("l", ""))) {
-                match = args[1].trim();
-                expMatch(server, sender, match, args[0], true);
-            } else if (args.length == 1) {
-                match = args[0].trim();
-            }
-            showMatch(server, sender, match);
-        }
-    }
-
-    private void showMatch(final Server server, final CommandSource sender, final String match) throws PlayerNotFoundException {
-        boolean skipHidden = sender.isPlayer() && !ess.getUser(sender.getPlayer()).canInteractVanished();
-        boolean foundUser = false;
-        final List<Player> matchedPlayers = server.matchPlayer(match);
-        for (Player matchPlayer : matchedPlayers) {
-            final User player = ess.getUser(matchPlayer);
-            if (skipHidden && player.isHidden(sender.getPlayer()) && !sender.getPlayer().canSee(matchPlayer)) {
-                continue;
-            }
-            foundUser = true;
-            showExp(sender, player);
-        }
-        if (!foundUser) {
-            throw new PlayerNotFoundException();
-        }
-    }
-
-    private void expMatch(final Server server, final CommandSource sender, final String match, String amount, final boolean give) throws NotEnoughArgumentsException, PlayerNotFoundException {
-        boolean skipHidden = sender.isPlayer() && !ess.getUser(sender.getPlayer()).canInteractVanished();
-        boolean foundUser = false;
-        final List<Player> matchedPlayers = server.matchPlayer(match);
-        for (Player matchPlayer : matchedPlayers) {
-            final User player = ess.getUser(matchPlayer);
-            if (skipHidden && player.isHidden(sender.getPlayer()) && !sender.getPlayer().canSee(matchPlayer)) {
-                continue;
-            }
-            foundUser = true;
-            setExp(sender, player, amount, give);
-        }
-        if (!foundUser) {
-            throw new PlayerNotFoundException();
-        }
-    }
-
-    private void showExp(final CommandSource sender, final User target) {
-        sender.sendMessage(tl("exp", target.getDisplayName(), SetExpFix.getTotalExperience(target.getBase()), target.getBase().getLevel(), SetExpFix.getExpUntilNextLevel(target.getBase())));
-    }
-
-    //TODO: Limit who can give negative exp?
-    private void setExp(final CommandSource sender, final User target, String strAmount, final boolean give) throws NotEnoughArgumentsException {
-        long amount;
-        strAmount = strAmount.toLowerCase(Locale.ENGLISH);
-        if (strAmount.contains("l")) {
-            strAmount = strAmount.replaceAll("l", "");
-            int neededLevel = Integer.parseInt(strAmount);
-            if (give) {
-                neededLevel += target.getBase().getLevel();
-            }
-            amount = (long) SetExpFix.getExpToLevel(neededLevel);
-            SetExpFix.setTotalExperience(target.getBase(), 0);
-        } else {
-            amount = Long.parseLong(strAmount);
-            if (amount > Integer.MAX_VALUE || amount < Integer.MIN_VALUE) {
-                throw new NotEnoughArgumentsException();
-            }
-        }
-
-        if (give) {
-            amount += SetExpFix.getTotalExperience(target.getBase());
-        }
-        if (amount > Integer.MAX_VALUE) {
-            amount = (long) Integer.MAX_VALUE;
-        }
-        if (amount < 0l) {
-            amount = 0l;
-        }
-        SetExpFix.setTotalExperience(target.getBase(), (int) amount);
-        sender.sendMessage(tl("expSet", target.getDisplayName(), amount));
-    }
-
-    @Override
-    protected List<String> getTabCompleteOptions(final Server server, final User user, final String commandLabel, final String[] args) {
-        if (args.length == 1) {
-            List<String> options = Lists.newArrayList("show");
-            if (user.isAuthorized("essentials.exp.set")) {
-                options.add("set");
-            }
-            if (user.isAuthorized("essentials.exp.give")) {
-                options.add("give");
-            }
-            if (user.isAuthorized("essentials.exp.take")) {
-                options.add("take");
-            }
-            if (user.isAuthorized("essentials.exp.reset")) {
-                options.add("reset");
-            }
-            return options;
-        } else if (args.length == 2) {
-            if ((args[0].equalsIgnoreCase("set") && user.isAuthorized("essentials.exp.set")) || (args[0].equalsIgnoreCase("give") && user.isAuthorized("essentials.exp.give"))) {
-                String levellessArg = args[1].toLowerCase(Locale.ENGLISH).replace("l", "");
-                if (NumberUtil.isInt(levellessArg)) {
-                    return Lists.newArrayList(levellessArg, args[1] + "l");
-                } else {
-                    return Collections.emptyList();
-                }
-            } else if (args[0].equalsIgnoreCase("show") && user.isAuthorized("essentials.exp.others")) {
-                return getPlayers(server, user);
-            } else {
-                return Collections.emptyList();
-            }
-        } else if (args.length == 3 && (args[0].equalsIgnoreCase("set") && user.isAuthorized("essentials.exp.set.others")) || (args[0].equalsIgnoreCase("give") && user.isAuthorized("essentials.exp.give.others"))) {
-            return getPlayers(server, user);
-        } else {
-            return Collections.emptyList();
-        }
-    }
-
-    @Override
-    protected List<String> getTabCompleteOptions(final Server server, final CommandSource sender, final String commandLabel, final String[] args) {
-        if (args.length == 1) {
-            // TODO: This seems somewhat buggy, both setting and showing - right now, ignoring that
-            return Lists.newArrayList("set", "give", "show", "take", "reset");
-        } else if (args.length == 2) {
-            if (args[0].equalsIgnoreCase("set") || args[0].equalsIgnoreCase("give")) {
-                String levellessArg = args[1].toLowerCase(Locale.ENGLISH).replace("l", "");
-                if (NumberUtil.isInt(levellessArg)) {
-                    return Lists.newArrayList(levellessArg, args[1] + "l");
-                } else {
-                    return Collections.emptyList();
-                }
-            } else { // even without 'show'
-                return getPlayers(server, sender);
-            }
-        } else if (args.length == 3 && (args[0].equalsIgnoreCase("set") || args[0].equalsIgnoreCase("give"))) {
-            return getPlayers(server, sender);
-        } else {
-            return Collections.emptyList();
-        }
-    }
-}

Essentials/src/com/earth2me/essentials/commands/Commandfireball.java

@@ -1,57 +0,0 @@
-package com.earth2me.essentials.commands;
-
-import com.earth2me.essentials.User;
-import com.google.common.collect.Lists;
-import org.bukkit.Server;
-import org.bukkit.entity.*;
-import org.bukkit.util.Vector;
-
-import java.util.Collections;
-import java.util.List;
-
-public class Commandfireball extends EssentialsCommand {
-    public Commandfireball() {
-        super("fireball");
-    }
-
-    @Override
-    protected void run(final Server server, final User user, final String commandLabel, final String[] args) throws Exception {
-        Class<? extends Entity> type = Fireball.class;
-        Projectile projectile;
-        int speed = 2;
-        if (args.length > 0) {
-            if (args[0].equalsIgnoreCase("small")) {
-                type = SmallFireball.class;
-            } else if (args[0].equalsIgnoreCase("arrow")) {
-                type = Arrow.class;
-            } else if (args[0].equalsIgnoreCase("skull")) {
-                type = WitherSkull.class;
-            } else if (args[0].equalsIgnoreCase("egg")) {
-                type = Egg.class;
-            } else if (args[0].equalsIgnoreCase("snowball")) {
-                type = Snowball.class;
-            } else if (args[0].equalsIgnoreCase("expbottle")) {
-                type = ThrownExpBottle.class;
-            } else if (args[0].equalsIgnoreCase("large")) {
-                type = LargeFireball.class;
-            } else if (args[0].equalsIgnoreCase("splashpotion")) {
-                type = SplashPotion.class;
-            } else if (args[0].equalsIgnoreCase("lingeringpotion")) {
-                type = LingeringPotion.class;
-            }
-        }
-        final Vector direction = user.getBase().getEyeLocation().getDirection().multiply(speed);
-        projectile = (Projectile) user.getWorld().spawn(user.getBase().getEyeLocation().add(direction.getX(), direction.getY(), direction.getZ()), type);
-        projectile.setShooter(user.getBase());
-        projectile.setVelocity(direction);
-    }
-
-    @Override
-    protected List<String> getTabCompleteOptions(final Server server, final User user, final String commandLabel, final String[] args) {
-        if (args.length == 1) {
-            return Lists.newArrayList("small", "arrow", "skull", "egg", "snowball", "expbottle", "large", "splashpotion", "lingeringpotion");
-        } else {
-            return Collections.emptyList();
-        }
-    }
-}

Essentials/src/com/earth2me/essentials/commands/Commandfirework.java

@@ -1,178 +0,0 @@
-package com.earth2me.essentials.commands;
-
-import com.earth2me.essentials.MetaItemStack;
-import com.earth2me.essentials.User;
-import com.earth2me.essentials.utils.MaterialUtil;
-import com.earth2me.essentials.utils.NumberUtil;
-import com.google.common.collect.Lists;
-import org.bukkit.DyeColor;
-import org.bukkit.FireworkEffect;
-import org.bukkit.Material;
-import org.bukkit.Server;
-import org.bukkit.entity.EntityType;
-import org.bukkit.entity.Firework;
-import org.bukkit.inventory.ItemStack;
-import org.bukkit.inventory.meta.FireworkMeta;
-import org.bukkit.util.Vector;
-
-import java.util.Collections;
-import java.util.List;
-
-import static com.earth2me.essentials.I18n.tl;
-
-//This command has quite a complicated syntax, in theory it has 4 seperate syntaxes which are all variable:
-//
-//1: /firework clear             - This clears all of the effects on a firework stack
-//
-//2: /firework power <int>       - This changes the base power of a firework
-//
-//3: /firework fire              - This 'fires' a copy of the firework held.
-//3: /firework fire <int>        - This 'fires' a number of copies of the firework held.
-//3: /firework fire <other>      - This 'fires' a copy of the firework held, in the direction you are looking, #easteregg
-//
-//4: /firework [meta]            - This will add an effect to the firework stack held
-//4: /firework color:<color>     - The minimum you need to set an effect is 'color'
-//4: Full Syntax:                  color:<color[,color,..]> [fade:<color[,color,..]>] [shape:<shape>] [effect:<effect[,effect]>]
-//4: Possible Shapes:              star, ball, large, creeper, burst
-//4: Possible Effects              trail, twinkle
-
-public class Commandfirework extends EssentialsCommand {
-
-    public Commandfirework() {
-        super("firework");
-    }
-
-    @Override
-    protected void run(final Server server, final User user, final String commandLabel, final String[] args) throws Exception {
-        final ItemStack stack = user.getItemInHand();
-        if (MaterialUtil.isFirework(stack.getType())) {
-            if (args.length > 0) {
-                if (args[0].equalsIgnoreCase("clear")) {
-                    FireworkMeta fmeta = (FireworkMeta) stack.getItemMeta();
-                    fmeta.clearEffects();
-                    stack.setItemMeta(fmeta);
-                    user.sendMessage(tl("fireworkEffectsCleared"));
-                } else if (args.length > 1 && (args[0].equalsIgnoreCase("power") || (args[0].equalsIgnoreCase("p")))) {
-                    FireworkMeta fmeta = (FireworkMeta) stack.getItemMeta();
-                    try {
-                        int power = Integer.parseInt(args[1]);
-                        fmeta.setPower(power > 3 ? 4 : power);
-                    } catch (NumberFormatException e) {
-                        throw new Exception(tl("invalidFireworkFormat", args[1], args[0]));
-                    }
-                    stack.setItemMeta(fmeta);
-                } else if ((args[0].equalsIgnoreCase("fire") || (args[0].equalsIgnoreCase("f"))) && user.isAuthorized("essentials.firework.fire")) {
-                    int amount = 1;
-                    boolean direction = false;
-                    if (args.length > 1) {
-                        if (NumberUtil.isInt(args[1])) {
-                            final int serverLimit = ess.getSettings().getSpawnMobLimit();
-                            amount = Integer.parseInt(args[1]);
-                            if (amount > serverLimit) {
-                                amount = serverLimit;
-                                user.sendMessage(tl("mobSpawnLimit"));
-                            }
-                        } else {
-                            direction = true;
-                        }
-                    }
-                    for (int i = 0; i < amount; i++) {
-                        Firework firework = (Firework) user.getWorld().spawnEntity(user.getLocation(), EntityType.FIREWORK);
-                        FireworkMeta fmeta = (FireworkMeta) stack.getItemMeta();
-                        if (direction) {
-                            final Vector vector = user.getBase().getEyeLocation().getDirection().multiply(0.070);
-                            if (fmeta.getPower() > 1) {
-                                fmeta.setPower(1);
-                            }
-                            firework.setVelocity(vector);
-                        }
-                        firework.setFireworkMeta(fmeta);
-                    }
-                } else {
-                    final MetaItemStack mStack = new MetaItemStack(stack);
-                    for (String arg : args) {
-                        try {
-                            mStack.addFireworkMeta(user.getSource(), true, arg, ess);
-                        } catch (Exception e) {
-                            user.sendMessage(tl("fireworkSyntax"));
-                            throw e;
-                        }
-                    }
-
-                    if (mStack.isValidFirework()) {
-                        FireworkMeta fmeta = (FireworkMeta) mStack.getItemStack().getItemMeta();
-                        FireworkEffect effect = mStack.getFireworkBuilder().build();
-                        if (fmeta.getEffects().size() > 0 && !user.isAuthorized("essentials.firework.multiple")) {
-                            throw new Exception(tl("multipleCharges"));
-                        }
-                        fmeta.addEffect(effect);
-                        stack.setItemMeta(fmeta);
-                    } else {
-                        user.sendMessage(tl("fireworkSyntax"));
-                        throw new Exception(tl("fireworkColor"));
-                    }
-                }
-            } else {
-                throw new NotEnoughArgumentsException();
-            }
-        } else {
-            throw new Exception(tl("holdFirework"));
-        }
-    }
-
-    @Override
-    protected List<String> getTabCompleteOptions(Server server, User user, String commandLabel, String[] args) {
-        // Note: this enforces an order of color fade shape effect, which the actual command doesn't have.  But that's fine. 
-        if (args.length == 1) {
-            List<String> options = Lists.newArrayList();
-            if (args[0].startsWith("color:")) {
-                String prefix;
-                if (args[0].contains(",")) {
-                    prefix = args[0].substring(0, args[0].lastIndexOf(',') + 1);
-                } else {
-                    prefix = "color:";
-                }
-                for (DyeColor color : DyeColor.values()) {
-                    options.add(prefix + color.name().toLowerCase() + ",");
-                }
-                return options;
-            }
-            options.add("clear");
-            options.add("power");
-            options.add("color:");
-            if (user.isAuthorized("essentials.firework.fire")) {
-                options.add("fire");
-            }
-            return options;
-        } else if (args.length == 2) {
-            if (args[0].equals("power")) {
-                return Lists.newArrayList("1", "2", "3", "4");
-            } else if (args[0].equals("fire")) {
-                return Lists.newArrayList("1");
-            } else if (args[0].startsWith("color:")) {
-                List<String> options = Lists.newArrayList();
-                if (!args[1].startsWith("fade:")) {
-                    args[1] = "fade:";
-                }
-                String prefix;
-                if (args[1].contains(",")) {
-                    prefix = args[1].substring(0, args[1].lastIndexOf(',') + 1);
-                } else {
-                    prefix = "fade:";
-                }
-                for (DyeColor color : DyeColor.values()) {
-                    options.add(prefix + color.name().toLowerCase() + ",");
-                }
-                return options;
-            } else {
-                return Collections.emptyList();
-            }
-        } else if (args.length == 3 && args[0].startsWith("color:")) {
-            return Lists.newArrayList("shape:star", "shape:ball", "shape:large", "shape:creeper", "shape:burst");
-        } else if (args.length == 4 && args[0].startsWith("color:")) {
-            return Lists.newArrayList("effect:trail", "effect:twinkle", "effect:trail,twinkle", "effect:twinkle,trail");
-        } else {
-            return Collections.emptyList();
-        }
-    }
-}

Essentials/src/com/earth2me/essentials/commands/Commandgc.java

@@ -1,63 +0,0 @@
-package com.earth2me.essentials.commands;
-
-import com.earth2me.essentials.CommandSource;
-import com.earth2me.essentials.utils.DateUtil;
-import com.earth2me.essentials.utils.NumberUtil;
-import org.bukkit.*;
-
-import java.lang.management.ManagementFactory;
-import java.util.List;
-import java.util.logging.Level;
-
-import static com.earth2me.essentials.I18n.tl;
-
-
-public class Commandgc extends EssentialsCommand {
-    public Commandgc() {
-        super("gc");
-    }
-
-    @Override
-    protected void run(final Server server, final CommandSource sender, final String commandLabel, final String[] args) throws Exception {
-        double tps = ess.getTimer().getAverageTPS();
-        ChatColor color;
-        if (tps >= 18.0) {
-            color = ChatColor.GREEN;
-        } else if (tps >= 15.0) {
-            color = ChatColor.YELLOW;
-        } else {
-            color = ChatColor.RED;
-        }
-
-        sender.sendMessage(tl("uptime", DateUtil.formatDateDiff(ManagementFactory.getRuntimeMXBean().getStartTime())));
-        sender.sendMessage(tl("tps", "" + color + NumberUtil.formatDouble(tps)));
-        sender.sendMessage(tl("gcmax", (Runtime.getRuntime().maxMemory() / 1024 / 1024)));
-        sender.sendMessage(tl("gctotal", (Runtime.getRuntime().totalMemory() / 1024 / 1024)));
-        sender.sendMessage(tl("gcfree", (Runtime.getRuntime().freeMemory() / 1024 / 1024)));
-
-        List<World> worlds = server.getWorlds();
-        for (World w : worlds) {
-            String worldType = "World";
-            switch (w.getEnvironment()) {
-                case NETHER:
-                    worldType = "Nether";
-                    break;
-                case THE_END:
-                    worldType = "The End";
-                    break;
-            }
-
-            int tileEntities = 0;
-
-            try {
-                for (Chunk chunk : w.getLoadedChunks()) {
-                    tileEntities += chunk.getTileEntities().length;
-                }
-            } catch (java.lang.ClassCastException ex) {
-                Bukkit.getLogger().log(Level.SEVERE, "Corrupted chunk data on world " + w, ex);
-            }
-
-            sender.sendMessage(tl("gcWorld", worldType, w.getName(), w.getLoadedChunks().length, w.getEntities().size(), tileEntities));
-        }
-    }
-}

Essentials/src/com/earth2me/essentials/commands/Commandhat.java

@@ -1,61 +0,0 @@
-package com.earth2me.essentials.commands;
-
-import com.earth2me.essentials.User;
-import com.earth2me.essentials.craftbukkit.InventoryWorkaround;
-import com.google.common.collect.Lists;
-import org.bukkit.Material;
-import org.bukkit.Server;
-import org.bukkit.inventory.ItemStack;
-import org.bukkit.inventory.PlayerInventory;
-
-import java.util.Collections;
-import java.util.List;
-
-import static com.earth2me.essentials.I18n.tl;
-
-
-public class Commandhat extends EssentialsCommand {
-    public Commandhat() {
-        super("hat");
-    }
-
-    @Override
-    protected void run(final Server server, final User user, final String commandLabel, final String[] args) throws Exception {
-        if (args.length > 0 && (args[0].contains("rem") || args[0].contains("off") || args[0].equalsIgnoreCase("0"))) {
-            final PlayerInventory inv = user.getBase().getInventory();
-            final ItemStack head = inv.getHelmet();
-            if (head == null || head.getType() == Material.AIR) {
-                user.sendMessage(tl("hatEmpty"));
-            } else {
-                final ItemStack air = new ItemStack(Material.AIR);
-                inv.setHelmet(air);
-                InventoryWorkaround.addItems(user.getBase().getInventory(), head);
-                user.sendMessage(tl("hatRemoved"));
-            }
-        } else {
-            final ItemStack hand = user.getItemInHand();
-            if (hand != null && hand.getType() != Material.AIR) {
-                if (hand.getType().getMaxDurability() == 0) {
-                    final PlayerInventory inv = user.getBase().getInventory();
-                    final ItemStack head = inv.getHelmet();
-                    inv.setHelmet(hand);
-                    inv.setItemInHand(head);
-                    user.sendMessage(tl("hatPlaced"));
-                } else {
-                    user.sendMessage(tl("hatArmor"));
-                }
-            } else {
-                user.sendMessage(tl("hatFail"));
-            }
-        }
-    }
-
-    @Override
-    protected List<String> getTabCompleteOptions(final Server server, final User user, final String commandLabel, final String[] args) {
-        if (args.length == 1) {
-            return Lists.newArrayList("remove", "wear"); // "wear" isn't real
-        } else {
-            return Collections.emptyList();
-        }
-    }
-}

Essentials/src/com/earth2me/essentials/commands/Commandheal.java

@@ -1,100 +0,0 @@
-package com.earth2me.essentials.commands;
-
-import com.earth2me.essentials.CommandSource;
-import com.earth2me.essentials.User;
-import org.bukkit.Server;
-import org.bukkit.entity.Player;
-import org.bukkit.event.entity.EntityRegainHealthEvent;
-import org.bukkit.event.entity.EntityRegainHealthEvent.RegainReason;
-import org.bukkit.potion.PotionEffect;
-
-import java.util.Collections;
-import java.util.List;
-
-import static com.earth2me.essentials.I18n.tl;
-
-
-public class Commandheal extends EssentialsLoopCommand {
-    public Commandheal() {
-        super("heal");
-    }
-
-    @Override
-    public void run(final Server server, final User user, final String commandLabel, final String[] args) throws Exception {
-        if (!user.isAuthorized("essentials.heal.cooldown.bypass")) {
-            user.healCooldown();
-        }
-
-        if (args.length > 0 && user.isAuthorized("essentials.heal.others")) {
-            loopOnlinePlayers(server, user.getSource(), true, true, args[0], null);
-            return;
-        }
-
-        healPlayer(user);
-    }
-
-    @Override
-    public void run(final Server server, final CommandSource sender, final String commandLabel, final String[] args) throws Exception {
-        if (args.length < 1) {
-            throw new NotEnoughArgumentsException();
-        }
-
-        loopOnlinePlayers(server, sender, true, true, args[0], null);
-    }
-
-    @Override
-    protected void updatePlayer(final Server server, final CommandSource sender, final User player, final String[] args) throws PlayerExemptException {
-        try {
-            healPlayer(player);
-            sender.sendMessage(tl("healOther", player.getDisplayName()));
-        } catch (QuietAbortException e) {
-            //Handle Quietly
-        }
-    }
-
-    private void healPlayer(final User user) throws PlayerExemptException, QuietAbortException {
-        final Player player = user.getBase();
-
-        if (player.getHealth() == 0) {
-            throw new PlayerExemptException(tl("healDead"));
-        }
-
-        final double amount = player.getMaxHealth() - player.getHealth();
-        final EntityRegainHealthEvent erhe = new EntityRegainHealthEvent(player, amount, RegainReason.CUSTOM);
-        ess.getServer().getPluginManager().callEvent(erhe);
-        if (erhe.isCancelled()) {
-            throw new QuietAbortException();
-        }
-
-        double newAmount = player.getHealth() + erhe.getAmount();
-        if (newAmount > player.getMaxHealth()) {
-            newAmount = player.getMaxHealth();
-        }
-
-        player.setHealth(newAmount);
-        player.setFoodLevel(20);
-        player.setFireTicks(0);
-        user.sendMessage(tl("heal"));
-        for (PotionEffect effect : player.getActivePotionEffects()) {
-            player.removePotionEffect(effect.getType());
-        }
-    }
-
-    @Override
-    protected List<String> getTabCompleteOptions(Server server, User user, String commandLabel, String[] args) {
-        if (args.length == 1 && user.isAuthorized("essentials.heal.others")) {
-            return getPlayers(server, user);
-        } else {
-            return Collections.emptyList();
-        }
-    }
-
-    @Override
-    protected List<String> getTabCompleteOptions(Server server, CommandSource sender, String commandLabel, String[] args) {
-        if (args.length == 1) {
-            return getPlayers(server, sender);
-        } else {
-            return Collections.emptyList();
-        }
-    }
-}

Essentials/src/com/earth2me/essentials/commands/Commandhelp.java

@@ -1,62 +0,0 @@
-package com.earth2me.essentials.commands;
-
-import com.earth2me.essentials.CommandSource;
-import com.earth2me.essentials.User;
-import com.earth2me.essentials.textreader.*;
-import com.earth2me.essentials.utils.NumberUtil;
-import org.bukkit.Server;
-
-import java.util.Collections;
-import java.util.List;
-import java.util.Locale;
-
-import static com.earth2me.essentials.I18n.tl;
-
-
-public class Commandhelp extends EssentialsCommand {
-    public Commandhelp() {
-        super("help");
-    }
-
-    @Override
-    protected void run(final Server server, final User user, final String commandLabel, final String[] args) throws Exception {
-        IText output;
-        String pageStr = args.length > 0 ? args[0] : null;
-        String chapterPageStr = args.length > 1 ? args[1] : null;
-        String command = commandLabel;
-        final IText input = new TextInput(user.getSource(), "help", false, ess);
-
-        if (input.getLines().isEmpty()) {
-            if (NumberUtil.isInt(pageStr) || pageStr == null) {
-                output = new HelpInput(user, "", ess);
-            } else {
-                if (pageStr.length() > 26) {
-                    pageStr = pageStr.substring(0, 25);
-                }
-                output = new HelpInput(user, pageStr.toLowerCase(Locale.ENGLISH), ess);
-                command = command.concat(" ").concat(pageStr);
-                pageStr = chapterPageStr;
-            }
-            chapterPageStr = null;
-        } else {
-            user.setDisplayNick();
-            output = new KeywordReplacer(input, user.getSource(), ess);
-        }
-        final TextPager pager = new TextPager(output);
-        pager.showPage(pageStr, chapterPageStr, command, user.getSource());
-    }
-
-    @Override
-    protected void run(final Server server, final CommandSource sender, final String commandLabel, final String[] args) throws Exception {
-        sender.sendMessage(tl("helpConsole"));
-    }
-
-    @Override
-    protected List<String> getTabCompleteOptions(Server server, CommandSource sender, String commandLabel, String[] args) {
-        if (args.length == 1) {
-            return getCommands(server);
-        } else {
-            return Collections.emptyList();
-        }
-    }
-}

Essentials/src/com/earth2me/essentials/commands/Commandhelpop.java

@@ -1,48 +0,0 @@
-package com.earth2me.essentials.commands;
-
-import com.earth2me.essentials.CommandSource;
-import com.earth2me.essentials.Console;
-import com.earth2me.essentials.User;
-import com.earth2me.essentials.utils.FormatUtil;
-import org.bukkit.Server;
-
-import java.util.List;
-import java.util.logging.Level;
-
-import static com.earth2me.essentials.I18n.tl;
-
-
-public class Commandhelpop extends EssentialsCommand {
-    public Commandhelpop() {
-        super("helpop");
-    }
-
-    @Override
-    public void run(final Server server, final User user, final String commandLabel, final String[] args) throws Exception {
-        user.setDisplayNick();
-        final String message = sendMessage(server, user.getSource(), user.getDisplayName(), args);
-        if (!user.isAuthorized("essentials.helpop.receive")) {
-            user.sendMessage(message);
-        }
-    }
-
-    @Override
-    public void run(final Server server, final CommandSource sender, final String commandLabel, final String[] args) throws Exception {
-        sendMessage(server, sender, Console.NAME, args);
-    }
-
-    private String sendMessage(final Server server, final CommandSource sender, final String from, final String[] args) throws Exception {
-        if (args.length < 1) {
-            throw new NotEnoughArgumentsException();
-        }
-        final String message = tl("helpOp", from, FormatUtil.stripFormat(getFinalArg(args, 0)));
-        server.getLogger().log(Level.INFO, message);
-        ess.broadcastMessage("essentials.helpop.receive", message);
-        return message;
-    }
-
-    @Override
-    protected List<String> getTabCompleteOptions(Server server, CommandSource sender, String commandLabel, String[] args) {
-        return null;  // Use vanilla handler for message
-    }
-}

Essentials/src/com/earth2me/essentials/commands/Commandhome.java

@@ -1,131 +0,0 @@
-package com.earth2me.essentials.commands;
-
-import com.earth2me.essentials.Trade;
-import com.earth2me.essentials.User;
-import com.earth2me.essentials.utils.StringUtil;
-import org.bukkit.Location;
-import org.bukkit.Server;
-import org.bukkit.event.player.PlayerTeleportEvent.TeleportCause;
-
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.List;
-import java.util.Locale;
-
-import static com.earth2me.essentials.I18n.tl;
-
-
-public class Commandhome extends EssentialsCommand {
-    public Commandhome() {
-        super("home");
-    }
-
-    // This method contains an undocumented translation parameters #EasterEgg
-    @Override
-    public void run(final Server server, final User user, final String commandLabel, final String[] args) throws Exception {
-        final Trade charge = new Trade(this.getName(), ess);
-        User player = user;
-        String homeName = "";
-        String[] nameParts;
-        if (args.length > 0) {
-            nameParts = args[0].split(":");
-            if (nameParts[0].length() == args[0].length() || !user.isAuthorized("essentials.home.others")) {
-                homeName = nameParts[0];
-            } else {
-                player = getPlayer(server, nameParts, 0, true, true);
-                if (nameParts.length > 1) {
-                    homeName = nameParts[1];
-                }
-            }
-        }
-        try {
-            if ("bed".equalsIgnoreCase(homeName) && user.isAuthorized("essentials.home.bed")) {
-                final Location bed = player.getBase().getBedSpawnLocation();
-                if (bed != null) {
-                    user.getTeleport().teleport(bed, charge, TeleportCause.COMMAND);
-                    throw new NoChargeException();
-                } else {
-                    throw new Exception(tl("bedMissing"));
-                }
-            }
-            goHome(user, player, homeName.toLowerCase(Locale.ENGLISH), charge);
-        } catch (NotEnoughArgumentsException e) {
-            Location bed = player.getBase().getBedSpawnLocation();
-            final List<String> homes = player.getHomes();
-            if (homes.isEmpty() && player.equals(user)) {
-                user.getTeleport().respawn(charge, TeleportCause.COMMAND);
-            } else if (homes.isEmpty()) {
-                throw new Exception(tl("noHomeSetPlayer"));
-            } else if (homes.size() == 1 && player.equals(user)) {
-                goHome(user, player, homes.get(0), charge);
-            } else {
-                final int count = homes.size();
-                if (user.isAuthorized("essentials.home.bed")) {
-                    if (bed != null) {
-                        homes.add(tl("bed"));
-                    } else {
-                        homes.add(tl("bedNull"));
-                    }
-                }
-                user.sendMessage(tl("homes", StringUtil.joinList(homes), count, getHomeLimit(player)));
-            }
-        }
-        throw new NoChargeException();
-    }
-
-    private String getHomeLimit(final User player) {
-        if (!player.getBase().isOnline()) {
-            return "?";
-        }
-        if (player.isAuthorized("essentials.sethome.multiple.unlimited")) {
-            return "*";
-        }
-        return Integer.toString(ess.getSettings().getHomeLimit(player));
-    }
-
-    private void goHome(final User user, final User player, final String home, final Trade charge) throws Exception {
-        if (home.length() < 1) {
-            throw new NotEnoughArgumentsException();
-        }
-        final Location loc = player.getHome(home);
-        if (loc == null) {
-            throw new NotEnoughArgumentsException();
-        }
-        if (user.getWorld() != loc.getWorld() && ess.getSettings().isWorldHomePermissions() && !user.isAuthorized("essentials.worlds." + loc.getWorld().getName())) {
-            throw new Exception(tl("noPerm", "essentials.worlds." + loc.getWorld().getName()));
-        }
-        user.getTeleport().teleport(loc, charge, TeleportCause.COMMAND);
-        user.sendMessage(tl("teleportHome", home));
-    }
-
-    @Override
-    protected List<String> getTabCompleteOptions(final Server server, final User user, final String commandLabel, final String[] args) {
-        boolean canVisitOthers = user.isAuthorized("essentials.home.others");
-
-        if (args.length == 1) {
-            if (canVisitOthers) {
-                return getPlayers(server, user);
-            } else {
-                List<String> homes = user.getHomes();
-                if (user.isAuthorized("essentials.home.bed")) {
-                    homes.add("bed");
-                }
-                return homes;
-            }
-        } else if (args.length == 2 && canVisitOthers) {
-            try {
-                User otherUser = getPlayer(server, args, 0, true, true);
-                List<String> homes = otherUser.getHomes();
-                if (user.isAuthorized("essentials.home.bed")) {
-                    homes.add("bed");
-                }
-                return homes;
-            } catch (Exception ex) {
-                // No such user
-                return Collections.emptyList();
-            }
-        } else {
-            return Collections.emptyList();
-        }
-    }
-}

Essentials/src/com/earth2me/essentials/commands/Commandignore.java

@@ -1,56 +0,0 @@
-package com.earth2me.essentials.commands;
-
-import com.earth2me.essentials.User;
-import org.bukkit.Server;
-
-import java.util.Collections;
-import java.util.List;
-
-import static com.earth2me.essentials.I18n.tl;
-
-
-public class Commandignore extends EssentialsCommand {
-    public Commandignore() {
-        super("ignore");
-    }
-
-    @Override
-    protected void run(final Server server, final User user, final String commandLabel, final String[] args) throws Exception {
-        if (args.length < 1) {
-            StringBuilder sb = new StringBuilder();
-            for (String s : user._getIgnoredPlayers()) {
-                sb.append(s).append(" ");
-            }
-            String ignoredList = sb.toString().trim();
-            user.sendMessage(ignoredList.length() > 0 ? tl("ignoredList", ignoredList) : tl("noIgnored"));
-        } else {
-            User player;
-            try {
-                player = getPlayer(server, args, 0, true, true);
-            } catch (PlayerNotFoundException ex) {
-                player = ess.getOfflineUser(args[0]);
-            }
-            if (player == null) {
-                throw new PlayerNotFoundException();
-            }
-            if (player.isIgnoreExempt()) {
-                user.sendMessage(tl("ignoreExempt"));
-            } else if (user.isIgnoredPlayer(player)) {
-                user.setIgnoredPlayer(player, false);
-                user.sendMessage(tl("unignorePlayer", player.getName()));
-            } else {
-                user.setIgnoredPlayer(player, true);
-                user.sendMessage(tl("ignorePlayer", player.getName()));
-            }
-        }
-    }
-
-    @Override
-    protected List<String> getTabCompleteOptions(Server server, User user, String commandLabel, String[] args) {
-        if (args.length == 1) {
-            return getPlayers(server, user);
-        } else {
-            return Collections.emptyList();
-        }
-    }
-}

Essentials/src/com/earth2me/essentials/commands/Commanditemdb.java

@@ -1,70 +0,0 @@
-package com.earth2me.essentials.commands;
-
-import com.earth2me.essentials.CommandSource;
-import com.earth2me.essentials.utils.VersionUtil;
-import org.bukkit.Material;
-import org.bukkit.Server;
-import org.bukkit.inventory.ItemStack;
-
-import java.util.Collections;
-import java.util.List;
-
-import static com.earth2me.essentials.I18n.tl;
-
-
-public class Commanditemdb extends EssentialsCommand {
-    public Commanditemdb() {
-        super("itemdb");
-    }
-
-    @Override
-    protected void run(Server server, CommandSource sender, String commandLabel, String[] args) throws Exception {
-        ItemStack itemStack = null;
-        boolean itemHeld = false;
-        if (args.length < 1) {
-            if (sender.isPlayer() && sender.getPlayer() != null) {
-                itemHeld = true;
-                itemStack = ess.getUser(sender.getPlayer()).getItemInHand();
-            }
-            if (itemStack == null) {
-                throw new NotEnoughArgumentsException();
-            }
-        } else {
-            itemStack = ess.getItemDb().get(args[0]);
-        }
-
-        String itemId = "none";
-
-        if (VersionUtil.getServerBukkitVersion().isLowerThan(VersionUtil.v1_13_0_R01)) {
-            itemId = itemStack.getType().getId() + ":" + itemStack.getDurability();
-        }
-
-        sender.sendMessage(tl("itemType", itemStack.getType().toString(), itemId));
-
-        // Don't send IDs twice
-        if (!tl("itemType").contains("{1}") && !itemId.equals("none")) {
-            sender.sendMessage(tl("itemId", itemId));
-        }
-
-        if (itemHeld && itemStack.getType() != Material.AIR) {
-            int maxuses = itemStack.getType().getMaxDurability();
-            int durability = ((maxuses + 1) - itemStack.getDurability());
-            if (maxuses != 0) {
-                sender.sendMessage(tl("durability", Integer.toString(durability)));
-            }
-        }
-        final String itemNameList = ess.getItemDb().names(itemStack);
-        if (itemNameList != null) {
-            sender.sendMessage(tl("itemNames", ess.getItemDb().names(itemStack)));
-        }
-    }
-
-    @Override
-    protected List<String> getTabCompleteOptions(Server server, CommandSource sender, String commandLabel, String[] args) {
-        if (args.length == 1) {
-            return getItems();
-        } else {
-            return Collections.emptyList();
-        }
-    }
-}

Essentials/src/com/earth2me/essentials/commands/Commanditemname.java

@@ -1,40 +0,0 @@
-package com.earth2me.essentials.commands;
-
-import static com.earth2me.essentials.I18n.tl;
-
-import com.earth2me.essentials.CommandSource;
-import com.earth2me.essentials.I18n;
-import com.earth2me.essentials.User;
-import com.earth2me.essentials.utils.FormatUtil;
-
-import com.earth2me.essentials.utils.MaterialUtil;
-import org.bukkit.Material;
-import org.bukkit.Server;
-import org.bukkit.inventory.ItemStack;
-import org.bukkit.inventory.meta.ItemMeta;
-
-import java.util.Locale;
-
-public class Commanditemname extends EssentialsCommand {
-    
-    public Commanditemname() {
-        super("itemname");
-    }
-
-    @Override
-    protected void run(Server server, User user, String commandLabel, String[] args) throws Exception {
-        ItemStack item = user.getBase().getItemInHand();
-        if (item.getType().name().contains("AIR")) {
-            user.sendMessage(tl("itemnameInvalidItem", item.getType().toString().toLowerCase(Locale.ENGLISH).replace('_', ' ')));
-            return;
-        }
-
-        String name = FormatUtil.formatString(user, "essentials.itemname", getFinalArg(args, 0)).trim();
-        if (name.isEmpty()) name = null;
-
-        ItemMeta im = item.getItemMeta();
-        im.setDisplayName(name);
-        item.setItemMeta(im);
-        user.sendMessage(name == null ? tl("itemnameClear") : tl("itemnameSuccess", name));
-    }
-}

Essentials/src/com/earth2me/essentials/commands/Commandlist.java

@@ -1,128 +0,0 @@
-package com.earth2me.essentials.commands;
-
-import com.earth2me.essentials.CommandSource;
-import com.earth2me.essentials.PlayerList;
-import com.earth2me.essentials.User;
-import com.earth2me.essentials.utils.FormatUtil;
-import com.earth2me.essentials.utils.NumberUtil;
-import org.bukkit.Server;
-
-import java.util.*;
-
-import static com.earth2me.essentials.I18n.tl;
-
-
-public class Commandlist extends EssentialsCommand {
-    public Commandlist() {
-        super("list");
-    }
-
-    @Override
-    public void run(final Server server, final CommandSource sender, final String commandLabel, final String[] args) throws Exception {
-        boolean showHidden = true;
-        User user = null;
-        if (sender.isPlayer()) {
-            user = ess.getUser(sender.getPlayer());
-            showHidden = user.isAuthorized("essentials.list.hidden") || user.canInteractVanished();
-        }
-        sender.sendMessage(PlayerList.listSummary(ess, user, showHidden));
-        final Map<String, List<User>> playerList = PlayerList.getPlayerLists(ess, user, showHidden);
-
-        if (args.length > 0) {
-            sender.sendMessage(PlayerList.listGroupUsers(ess, playerList, args[0].toLowerCase()));
-        } else {
-            sendGroupedList(sender, commandLabel, playerList);
-        }
-    }
-
-    // Output the standard /list output, when no group is specified
-    private void sendGroupedList(CommandSource sender, String commandLabel, Map<String, List<User>> playerList) {
-        final Set<String> configGroups = ess.getSettings().getListGroupConfig().keySet();
-        final List<String> asterisk = new ArrayList<>();
-
-        // Loop through the custom defined groups and display them
-        for (String oConfigGroup : configGroups) {
-            String groupValue = ess.getSettings().getListGroupConfig().get(oConfigGroup).toString().trim();
-            String configGroup = oConfigGroup.toLowerCase();
-
-            // If the group value is an asterisk, then skip it, and handle it later
-            if (groupValue.equals("*")) {
-                asterisk.add(oConfigGroup);
-                continue;
-            }
-
-            // If the group value is hidden, we don't need to display it
-            if (groupValue.equalsIgnoreCase("hidden")) {
-                playerList.remove(configGroup);
-                continue;
-            }
-
-            List<User> outputUserList = new ArrayList<>();
-            final List<User> matchedList = playerList.get(configGroup);
-
-            // If the group value is an int, then we might need to truncate it
-            if (NumberUtil.isInt(groupValue)) {
-                if (matchedList != null && !matchedList.isEmpty()) {
-                    playerList.remove(configGroup);
-                    outputUserList.addAll(matchedList);
-                    int limit = Integer.parseInt(groupValue);
-                    if (matchedList.size() > limit) {
-                        sender.sendMessage(PlayerList.outputFormat(oConfigGroup, tl("groupNumber", matchedList.size(), commandLabel, FormatUtil.stripFormat(configGroup))));
-                    } else {
-                        sender.sendMessage(PlayerList.outputFormat(oConfigGroup, PlayerList.listUsers(ess, outputUserList, ", ")));
-                    }
-                    continue;
-                }
-            }
-
-            outputUserList = PlayerList.getMergedList(ess, playerList, configGroup);
-
-            // If we have no users, than we don't need to continue parsing this group
-            if (outputUserList == null || outputUserList.isEmpty()) {
-                continue;
-            }
-
-            sender.sendMessage(PlayerList.outputFormat(oConfigGroup, PlayerList.listUsers(ess, outputUserList, ", ")));
-        }
-
-        Set<String> var = playerList.keySet();
-        String[] onlineGroups = var.toArray(new String[var.size()]);
-        Arrays.sort(onlineGroups, String.CASE_INSENSITIVE_ORDER);
-
-        // If we have an asterisk group, then merge all remaining groups
-        if (!asterisk.isEmpty()) {
-            List<User> asteriskUsers = new ArrayList<>();
-            for (String onlineGroup : onlineGroups) {
-                asteriskUsers.addAll(playerList.get(onlineGroup));
-            }
-            for (String key : asterisk) {
-                playerList.put(key, asteriskUsers);
-            }
-            onlineGroups = asterisk.toArray(new String[asterisk.size()]);
-        }
-
-        // If we have any groups remaining after the custom groups loop through and display them
-        for (String onlineGroup : onlineGroups) {
-            List<User> users = playerList.get(onlineGroup);
-            String groupName = asterisk.isEmpty() ? users.get(0).getGroup() : onlineGroup;
-
-            if (ess.getPermissionsHandler().getName().equals("ConfigPermissions")) {
-                groupName = tl("connectedPlayers");
-            }
-            if (users == null || users.isEmpty()) {
-                continue;
-            }
-
-            sender.sendMessage(PlayerList.outputFormat(groupName, PlayerList.listUsers(ess, users, ", ")));
-        }
-    }
-
-    @Override
-    protected List<String> getTabCompleteOptions(final Server server, final CommandSource sender, final String commandLabel, final String[] args) {
-        if (args.length == 1) {
-            return getGroups();
-        } else {
-            return Collections.emptyList();
-        }
-    }
-}

Essentials/src/com/earth2me/essentials/commands/Commandmail.java

@@ -1,196 +0,0 @@
-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.SimpleTextInput;
-import com.earth2me.essentials.textreader.TextPager;
-import com.earth2me.essentials.utils.FormatUtil;
-import com.earth2me.essentials.utils.StringUtil;
-import com.google.common.collect.Lists;
-import org.bukkit.Server;
-
-import java.util.Collections;
-import java.util.List;
-import java.util.UUID;
-
-import static com.earth2me.essentials.I18n.tl;
-
-
-public class Commandmail extends EssentialsCommand {
-    private static int mailsPerMinute = 0;
-    private static long timestamp = 0;
-
-    public Commandmail() {
-        super("mail");
-    }
-
-    //TODO: Tidy this up / TL these errors.
-    @Override
-    public void run(final Server server, final User user, final String commandLabel, final String[] args) throws Exception {
-        if (args.length >= 1 && "read".equalsIgnoreCase(args[0])) {
-            final List<String> mail = user.getMails();
-            if (mail.isEmpty()) {
-                user.sendMessage(tl("noMail"));
-                throw new NoChargeException();
-            }
-
-            IText input = new SimpleTextInput(mail);
-            final TextPager pager = new TextPager(input);
-            pager.showPage(args.length > 1 ? args[1] : null, null, commandLabel + " " + args[0], user.getSource());
-
-            user.sendMessage(tl("mailClear"));
-            return;
-        }
-        if (args.length >= 3 && "send".equalsIgnoreCase(args[0])) {
-            if (!user.isAuthorized("essentials.mail.send")) {
-                throw new Exception(tl("noPerm", "essentials.mail.send"));
-            }
-
-            if (user.isMuted()) {
-                throw new Exception(user.hasMuteReason() ? tl("voiceSilencedReason", user.getMuteReason()) : tl("voiceSilenced"));
-            }
-
-            User u = getPlayer(server, args[1], true, true);
-            if (u == null) {
-                throw new Exception(tl("playerNeverOnServer", args[1]));
-            }
-
-            String mail = tl("mailFormat", user.getName(), FormatUtil.formatMessage(user, "essentials.mail", StringUtil.sanitizeString(FormatUtil.stripFormat(getFinalArg(args, 2)))));
-            if (mail.length() > 1000) {
-                throw new Exception(tl("mailTooLong"));
-            }
-
-            if (!u.isIgnoredPlayer(user)) {
-                if (Math.abs(System.currentTimeMillis() - timestamp) > 60000) {
-                    timestamp = System.currentTimeMillis();
-                    mailsPerMinute = 0;
-                }
-                mailsPerMinute++;
-                if (mailsPerMinute > ess.getSettings().getMailsPerMinute()) {
-                    throw new Exception(tl("mailDelay", ess.getSettings().getMailsPerMinute()));
-                }
-                u.addMail(tl("mailMessage", mail));
-            }
-
-            user.sendMessage(tl("mailSentTo", u.getDisplayName(), u.getName()));
-            user.sendMessage(mail);
-            return;
-        }
-        if (args.length > 1 && "sendall".equalsIgnoreCase(args[0])) {
-            if (!user.isAuthorized("essentials.mail.sendall")) {
-                throw new Exception(tl("noPerm", "essentials.mail.sendall"));
-            }
-            ess.runTaskAsynchronously(new SendAll(tl("mailFormat", user.getName(),
-                    FormatUtil.formatMessage(user, "essentials.mail", StringUtil.sanitizeString(FormatUtil.stripFormat(getFinalArg(args, 1)))))));
-            user.sendMessage(tl("mailSent"));
-            return;
-        }
-        if (args.length >= 1 && "clear".equalsIgnoreCase(args[0])) {
-            if (user.getMails() == null || user.getMails().isEmpty()) {
-                user.sendMessage(tl("noMail"));
-                throw new NoChargeException();
-            }
-
-            user.setMails(null);
-            user.sendMessage(tl("mailCleared"));
-            return;
-        }
-        throw new NotEnoughArgumentsException();
-    }
-
-    @Override
-    protected void run(Server server, CommandSource sender, String commandLabel, String[] args) throws Exception {
-        if (args.length >= 1 && "read".equalsIgnoreCase(args[0])) {
-            throw new Exception(tl("onlyPlayers", commandLabel + " read"));
-        } else if (args.length >= 1 && "clear".equalsIgnoreCase(args[0])) {
-            throw new Exception(tl("onlyPlayers", commandLabel + " clear"));
-        } else if (args.length >= 3 && "send".equalsIgnoreCase(args[0])) {
-            User u = getPlayer(server, args[1], true, true);
-            if (u == null) {
-                throw new Exception(tl("playerNeverOnServer", args[1]));
-            }
-            u.addMail(tl("mailFormat", "Server", FormatUtil.replaceFormat(getFinalArg(args, 2))));
-            sender.sendMessage(tl("mailSent"));
-            return;
-        } else if (args.length >= 2 && "sendall".equalsIgnoreCase(args[0])) {
-            ess.runTaskAsynchronously(new SendAll(tl("mailFormat", "Server", FormatUtil.replaceFormat(getFinalArg(args, 1)))));
-            sender.sendMessage(tl("mailSent"));
-            return;
-        } else if (args.length >= 2) {
-            //allow sending from console without "send" argument, since it's the only thing the console can do
-            User u = getPlayer(server, args[0], true, true);
-            if (u == null) {
-                throw new Exception(tl("playerNeverOnServer", args[0]));
-            }
-            u.addMail(tl("mailFormat", "Server", FormatUtil.replaceFormat(getFinalArg(args, 1))));
-            sender.sendMessage(tl("mailSent"));
-            return;
-        }
-        throw new NotEnoughArgumentsException();
-    }
-
-
-    private class SendAll implements Runnable {
-        String message;
-
-        public SendAll(String message) {
-            this.message = message;
-        }
-
-        @Override
-        public void run() {
-            for (UUID userid : ess.getUserMap().getAllUniqueUsers()) {
-                User user = ess.getUserMap().getUser(userid);
-                if (user != null) {
-                    user.addMail(message);
-                }
-            }
-        }
-    }
-
-    @Override
-    protected List<String> getTabCompleteOptions(final Server server, final User user, final String commandLabel, final String[] args) {
-        if (args.length == 1) {
-            List<String> options = Lists.newArrayList("read", "clear");
-            if (user.isAuthorized("essentials.mail.send")) {
-                options.add("send");
-            }
-            if (user.isAuthorized("essentials.mail.sendall")) {
-                options.add("sendall");
-            }
-            return options;
-        } else if (args.length == 2 && args[0].equalsIgnoreCase("send") && user.isAuthorized("essentials.mail.send")) {
-            return getPlayers(server, user);
-        } else if (args.length == 2 && args[0].equalsIgnoreCase("read")) {
-            final List<String> mail = user.getMails();
-            int pages = mail.size() / 9 + (mail.size() % 9 > 0 ? 1 : 0);
-            if (pages == 0) {
-                return Lists.newArrayList("0");
-            } else {
-                List<String> options = Lists.newArrayList("1");
-                if (pages > 1) {
-                    options.add(String.valueOf(pages));
-                }
-                return options;
-            }
-        } else if ((args.length > 2 && args[0].equalsIgnoreCase("send") && user.isAuthorized("essentials.mail.send")) || (args.length > 1 && args[0].equalsIgnoreCase("sendall") && user.isAuthorized("essentials.mail.sendall"))) {
-            return null; // Use vanilla handler
-        } else {
-            return Collections.emptyList();
-        }
-    }
-
-    @Override
-    protected List<String> getTabCompleteOptions(final Server server, final CommandSource sender, final String commandLabel, final String[] args) {
-        if (args.length == 1) {
-            return Lists.newArrayList("send", "sendall");
-        } else if (args.length == 2 && args[0].equalsIgnoreCase("send")) {
-            return getPlayers(server, sender);
-        } else if ((args.length > 2 && args[0].equalsIgnoreCase("send")) || (args.length > 1 && args[0].equalsIgnoreCase("sendall"))) {
-            return null; // Use vanilla handler
-        } else {
-            return Collections.emptyList();
-        }
-    }
-}

Essentials/src/com/earth2me/essentials/commands/Commandme.java

@@ -1,101 +0,0 @@
-package com.earth2me.essentials.commands;
-
-import com.earth2me.essentials.CommandSource;
-import com.earth2me.essentials.User;
-import com.earth2me.essentials.utils.FormatUtil;
-import org.bukkit.Bukkit;
-import org.bukkit.Location;
-import org.bukkit.Server;
-import org.bukkit.World;
-import org.bukkit.entity.Player;
-
-import java.util.HashSet;
-import java.util.List;
-import java.util.Set;
-
-import static com.earth2me.essentials.I18n.tl;
-
-
-public class Commandme extends EssentialsCommand {
-    public Commandme() {
-        super("me");
-    }
-
-    @Override
-    public void run(Server server, User user, String commandLabel, String[] args) throws Exception {
-        if (user.isMuted()) {
-            throw new Exception(user.hasMuteReason() ? tl("voiceSilencedReason", user.getMuteReason()) : tl("voiceSilenced"));
-        }
-
-        if (args.length < 1) {
-            throw new NotEnoughArgumentsException();
-        }
-
-        String message = getFinalArg(args, 0);
-        message = FormatUtil.formatMessage(user, "essentials.chat", message);
-
-        user.setDisplayNick();
-        int radius = ess.getSettings().getChatRadius();
-        String toSend = tl("action", user.getDisplayName(), message);
-        if (radius < 1) {
-            ess.broadcastMessage(user, toSend);
-            return;
-        }
-
-        World world = user.getWorld();
-        Location loc = user.getLocation();
-        Set<Player> outList = new HashSet<>();
-
-        for (Player player : Bukkit.getOnlinePlayers()) {
-            final User onlineUser = ess.getUser(player);
-            if (!onlineUser.equals(user)) {
-                boolean abort = false;
-                final Location playerLoc = onlineUser.getLocation();
-                if (playerLoc.getWorld() != world) {
-                    abort = true;
-                } else if (onlineUser.isIgnoredPlayer(user)) {
-                    abort = true;
-                } else {
-                    final double delta = playerLoc.distanceSquared(loc);
-                    if (delta > radius) {
-                        abort = true;
-                    }
-                }
-                if (abort) {
-                    if (onlineUser.isAuthorized("essentials.chat.spy")) {
-                        outList.add(player); // Just use the same list unless we wanted to format spyying for this.
-                    }
-                } else {
-                    outList.add(player);
-                }
-            } else {
-                outList.add(player); // Add yourself to the list.
-            }
-        }
-
-        if (outList.size() < 2) {
-            user.sendMessage(tl("localNoOne"));
-        }
-
-        for (Player onlinePlayer : outList) {
-            onlinePlayer.sendMessage(toSend);
-        }
-    }
-
-    @Override
-    public void run(Server server, CommandSource sender, String commandLabel, String[] args) throws Exception {
-        if (args.length < 1) {
-            throw new NotEnoughArgumentsException();
-        }
-
-        String message = getFinalArg(args, 0);
-        message = FormatUtil.replaceFormat(message);
-
-        ess.getServer().broadcastMessage(tl("action", "@", message));
-    }
-
-    @Override
-    protected List<String> getTabCompleteOptions(Server server, CommandSource sender, String commandLabel, String[] args) {
-        return null;  // It's a chat message, use the default chat handler
-    }
-}

Essentials/src/com/earth2me/essentials/commands/Commandmore.java

@@ -1,38 +0,0 @@
-package com.earth2me.essentials.commands;
-
-import com.earth2me.essentials.User;
-import org.bukkit.Server;
-import org.bukkit.inventory.ItemStack;
-
-import java.util.Locale;
-
-import static com.earth2me.essentials.I18n.tl;
-
-
-public class Commandmore extends EssentialsCommand {
-    public Commandmore() {
-        super("more");
-    }
-
-    @Override
-    public void run(final Server server, final User user, final String commandLabel, final String[] args) throws Exception {
-        final ItemStack stack = user.getItemInHand();
-        if (stack == null) {
-            throw new Exception(tl("cantSpawnItem", "Air"));
-        }
-
-        if (stack.getAmount() >= ((user.isAuthorized("essentials.oversizedstacks")) ? ess.getSettings().getOversizedStackSize() : stack.getMaxStackSize())) {
-            throw new Exception(tl("fullStack"));
-        }
-        final String itemname = stack.getType().toString().toLowerCase(Locale.ENGLISH).replace("_", "");
-        if (!user.canSpawnItem(stack.getType())) {
-            throw new Exception(tl("cantSpawnItem", itemname));
-        }
-        if (user.isAuthorized("essentials.oversizedstacks")) {
-            stack.setAmount(ess.getSettings().getOversizedStackSize());
-        } else {
-            stack.setAmount(stack.getMaxStackSize());
-        }
-        user.getBase().updateInventory();
-    }
-}

Essentials/src/com/earth2me/essentials/commands/Commandmsg.java

@@ -1,65 +0,0 @@
-package com.earth2me.essentials.commands;
-
-import static com.earth2me.essentials.I18n.tl;
-
-import com.earth2me.essentials.CommandSource;
-import com.earth2me.essentials.Console;
-import com.earth2me.essentials.User;
-import com.earth2me.essentials.messaging.IMessageRecipient;
-import com.earth2me.essentials.utils.FormatUtil;
-
-import org.bukkit.Server;
-
-import java.util.List;
-
-public class Commandmsg extends EssentialsLoopCommand {
-
-    public Commandmsg() {
-        super("msg");
-    }
-
-    @Override
-    public void run(Server server, CommandSource sender, String commandLabel, String[] args) throws Exception {
-        if (args.length < 2 || args[0].trim().length() < 2 || args[1].trim().isEmpty()) {
-            throw new NotEnoughArgumentsException();
-        }
-
-        String message = getFinalArg(args, 1);
-        boolean canWildcard;
-        if (sender.isPlayer()) {
-            User user = ess.getUser(sender.getPlayer());
-            if (user.isMuted()) {
-                throw new Exception(user.hasMuteReason() ? tl("voiceSilencedReason", user.getMuteReason()) : tl("voiceSilenced"));
-            }
-            message = FormatUtil.formatMessage(user, "essentials.msg", message);
-            canWildcard = user.isAuthorized("essentials.msg.multiple");
-        } else {
-            message = FormatUtil.replaceFormat(message);
-            canWildcard = true;
-        }
-
-        // Sending messages to console
-        if (args[0].equalsIgnoreCase(Console.NAME)) {
-            IMessageRecipient messageSender = sender.isPlayer() ? ess.getUser(sender.getPlayer()) : Console.getInstance();
-            messageSender.sendMessage(Console.getInstance(), message);
-            return;
-        }
-
-        loopOnlinePlayers(server, sender, canWildcard, canWildcard, args[0], new String[]{message});
-    }
-
-    @Override
-    protected void updatePlayer(final Server server, final CommandSource sender, final User messageReceiver, final String[] args) {
-        IMessageRecipient messageSender = sender.isPlayer() ? ess.getUser(sender.getPlayer()) : Console.getInstance();
-        messageSender.sendMessage(messageReceiver, args[0]); // args[0] is the message.
-    }
-
-    @Override
-    protected List<String> getTabCompleteOptions(Server server, CommandSource sender, String commandLabel, String[] args) {
-        if (args.length == 1) {
-            return getPlayers(server, sender);
-        } else {
-            return null;  // It's a chat message, use the default chat handler
-        }
-    }
-}

Essentials/src/com/earth2me/essentials/commands/Commandmute.java

@@ -1,127 +0,0 @@
-package com.earth2me.essentials.commands;
-
-import com.earth2me.essentials.CommandSource;
-import com.earth2me.essentials.OfflinePlayer;
-import com.earth2me.essentials.User;
-import com.earth2me.essentials.utils.DateUtil;
-import net.ess3.api.events.MuteStatusChangeEvent;
-import org.bukkit.Server;
-
-import java.util.List;
-import java.util.logging.Level;
-
-import static com.earth2me.essentials.I18n.tl;
-
-
-public class Commandmute extends EssentialsCommand {
-    public Commandmute() {
-        super("mute");
-    }
-
-    @Override
-    public void run(final Server server, final CommandSource sender, final String commandLabel, final String[] args) throws Exception {
-        boolean nomatch = false;
-        if (args.length < 1) {
-            throw new NotEnoughArgumentsException();
-        }
-        User user;
-        try {
-            user = getPlayer(server, args, 0, true, true);
-        } catch (PlayerNotFoundException e) {
-            nomatch = true;
-            user = ess.getUser(new OfflinePlayer(args[0], ess.getServer()));
-        }
-        if (!user.getBase().isOnline()) {
-            if (sender.isPlayer() && !ess.getUser(sender.getPlayer()).isAuthorized("essentials.mute.offline")) {
-                throw new Exception(tl("muteExemptOffline"));
-            }
-        } else {
-            if (user.isAuthorized("essentials.mute.exempt") && sender.isPlayer()) {
-                throw new Exception(tl("muteExempt"));
-            }
-        }
-        
-        final boolean willMute = (args.length > 1) || !user.getMuted();
-        final User controller = sender.isPlayer() ? ess.getUser(sender.getPlayer()) : null;
-        final MuteStatusChangeEvent event = new MuteStatusChangeEvent(user, controller, willMute);
-        ess.getServer().getPluginManager().callEvent(event);
-        
-        if (!event.isCancelled()) {
-            long muteTimestamp = 0;
-
-            if (args.length > 1) {
-                final String time = args[1];
-                String muteReason;
-                try {
-                    muteTimestamp = DateUtil.parseDateDiff(time, true);
-                    muteReason = getFinalArg(args, 2);
-                } catch (Exception e) {
-                    muteReason = getFinalArg(args, 1);
-                }
-
-                user.setMuteReason(muteReason.isEmpty() ? null : muteReason);
-                user.setMuted(true);
-            } else {
-                user.setMuted(!user.getMuted());
-                if (!user.getMuted()) {
-                    user.setMuteReason(null);
-                }
-            }
-            user.setMuteTimeout(muteTimestamp);
-            final boolean muted = user.getMuted();
-            String muteTime = DateUtil.formatDateDiff(muteTimestamp);
-
-            if (nomatch) {
-                sender.sendMessage(tl("userUnknown", user.getName()));
-            }
-
-            if (muted) {
-                if (muteTimestamp > 0) {
-                    if (!user.hasMuteReason()) {
-                        sender.sendMessage(tl("mutedPlayerFor", user.getDisplayName(), muteTime));
-                        user.sendMessage(tl("playerMutedFor", muteTime));
-                    } else {
-                        sender.sendMessage(tl("mutedPlayerForReason", user.getDisplayName(), muteTime, user.getMuteReason()));
-                        user.sendMessage(tl("playerMutedForReason", muteTime, user.getMuteReason()));
-                    }
-                } else {
-                    if (!user.hasMuteReason()) {
-                        sender.sendMessage(tl("mutedPlayer", user.getDisplayName()));
-                        user.sendMessage(tl("playerMuted"));
-                    } else {
-                        sender.sendMessage(tl("mutedPlayerReason", user.getDisplayName(), user.getMuteReason()));
-                        user.sendMessage(tl("playerMutedReason", user.getMuteReason()));
-                    }
-                }
-                final String message;
-                if (muteTimestamp > 0) {
-                    if (!user.hasMuteReason()) {
-                        message = tl("muteNotifyFor", sender.getSender().getName(), user.getName(), muteTime);
-                    } else {
-                        message = tl("muteNotifyForReason", sender.getSender().getName(), user.getName(), muteTime, user.getMuteReason());
-                    }
-                } else {
-                    if (!user.hasMuteReason()) {
-                        message = tl("muteNotify", sender.getSender().getName(), user.getName());
-                    } else {
-                        message = tl("muteNotifyReason", sender.getSender().getName(), user.getName(), user.getMuteReason());
-                    }
-                }
-                server.getLogger().log(Level.INFO, message);
-                ess.broadcastMessage("essentials.mute.notify", message);
-            } else {
-                sender.sendMessage(tl("unmutedPlayer", user.getDisplayName()));
-                user.sendMessage(tl("playerUnmuted"));
-            }
-        }
-    }
-
-    @Override
-    protected List<String> getTabCompleteOptions(Server server, CommandSource sender, String commandLabel, String[] args) {
-        if (args.length == 1) {
-            return getPlayers(server, sender);
-        } else {
-            return COMMON_DATE_DIFFS; // Date diff can span multiple words
-        }
-    }
-}

Essentials/src/com/earth2me/essentials/commands/Commandnick.java

@@ -1,135 +0,0 @@
-package com.earth2me.essentials.commands;
-
-import com.earth2me.essentials.CommandSource;
-import com.earth2me.essentials.User;
-import com.earth2me.essentials.utils.FormatUtil;
-import net.ess3.api.events.NickChangeEvent;
-import org.bukkit.ChatColor;
-import org.bukkit.Server;
-import org.bukkit.entity.Player;
-
-import java.util.Collections;
-import java.util.List;
-import java.util.Locale;
-
-import static com.earth2me.essentials.I18n.tl;
-
-
-public class Commandnick extends EssentialsLoopCommand {
-    public Commandnick() {
-        super("nick");
-    }
-
-    @Override
-    public void run(final Server server, final User user, final String commandLabel, final String[] args) throws Exception {
-        if (args.length < 1) {
-            throw new NotEnoughArgumentsException();
-        }
-        if (!ess.getSettings().changeDisplayName()) {
-            throw new Exception(tl("nickDisplayName"));
-        }
-
-        if (args.length > 1 && user.isAuthorized("essentials.nick.others")) {
-            final String[] nickname = formatNickname(user, args[1]).split(" ");
-            loopOfflinePlayers(server, user.getSource(), false, true, args[0], nickname);
-            user.sendMessage(tl("nickChanged"));
-        } else {
-            final String[] nickname = formatNickname(user, args[0]).split(" ");
-            updatePlayer(server, user.getSource(), user, nickname);
-        }
-    }
-
-    @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();
-        }
-        if (!ess.getSettings().changeDisplayName()) {
-            throw new Exception(tl("nickDisplayName"));
-        }
-        final String[] nickname = formatNickname(null, args[1]).split(" ");
-        loopOfflinePlayers(server, sender, false, true, args[0], nickname);
-        sender.sendMessage(tl("nickChanged"));
-    }
-
-    @Override
-    protected void updatePlayer(final Server server, final CommandSource sender, final User target, final String[] args) throws NotEnoughArgumentsException {
-        final String nick = args[0];
-        if ("off".equalsIgnoreCase(nick)) {
-            setNickname(server, sender, target, null);
-            target.sendMessage(tl("nickNoMore"));
-        } else if (target.getName().equalsIgnoreCase(nick)) {
-            String oldName = target.getDisplayName();
-            setNickname(server, sender, target, nick);
-            if (!target.getDisplayName().equalsIgnoreCase(oldName)) {
-                target.sendMessage(tl("nickNoMore"));
-            }
-            target.sendMessage(tl("nickSet", target.getDisplayName()));
-        } else if (nickInUse(server, target, nick)) {
-            throw new NotEnoughArgumentsException(tl("nickInUse"));
-        } else {
-            setNickname(server, sender, target, nick);
-            target.sendMessage(tl("nickSet", target.getDisplayName()));
-        }
-    }
-
-    private String formatNickname(final User user, final String nick) throws Exception {
-        String newNick = user == null ? FormatUtil.replaceFormat(nick) : FormatUtil.formatString(user, "essentials.nick", nick);
-        if (!newNick.matches("^[a-zA-Z_0-9\u00a7]+$") && user != null && !user.isAuthorized("essentials.nick.allowunsafe")) {
-            throw new Exception(tl("nickNamesAlpha"));
-        } else if (getNickLength(newNick) > ess.getSettings().getMaxNickLength()) {
-            throw new Exception(tl("nickTooLong"));
-        } else if (FormatUtil.stripFormat(newNick).length() < 1) {
-            throw new Exception(tl("nickNamesAlpha"));
-        } else if (user != null && (user.isAuthorized("essentials.nick.changecolors") && !user.isAuthorized("essentials.nick.changecolors.bypass")) && !FormatUtil.stripFormat(newNick).equals(user.getName())) {
-            throw new Exception(tl("nickNamesOnlyColorChanges"));
-        }
-        return newNick;
-    }
-
-    private int getNickLength(final String nick) {
-        return ess.getSettings().ignoreColorsInMaxLength() ? ChatColor.stripColor(nick).length() : nick.length();
-    }
-
-    private boolean nickInUse(final Server server, final User target, String nick) {
-        final String lowerNick = FormatUtil.stripFormat(nick.toLowerCase(Locale.ENGLISH));
-        for (final Player onlinePlayer : ess.getOnlinePlayers()) {
-            if (target.getBase().getName().equals(onlinePlayer.getName())) {
-                continue;
-            }
-            final String matchNick = FormatUtil.stripFormat(onlinePlayer.getDisplayName().replace(ess.getSettings().getNicknamePrefix(), ""));
-            if (lowerNick.equals(matchNick.toLowerCase(Locale.ENGLISH)) || lowerNick.equals(onlinePlayer.getName().toLowerCase(Locale.ENGLISH))) {
-                return true;
-            }
-        }
-        return ess.getUser(lowerNick) != null && ess.getUser(lowerNick) != target;
-    }
-
-    private void setNickname(final Server server, final CommandSource sender, final User target, final String nickname) {
-        final User controller = sender.isPlayer() ? ess.getUser(sender.getPlayer()) : null;
-        final NickChangeEvent nickEvent = new NickChangeEvent(controller, target, nickname);
-        server.getPluginManager().callEvent(nickEvent);
-        if (!nickEvent.isCancelled()) {
-            target.setNickname(nickname);
-            target.setDisplayNick();
-        }
-    }
-
-    @Override
-    protected List<String> getTabCompleteOptions(final Server server, final User user, final String commandLabel, final String[] args) {
-        if (args.length == 1 && user.isAuthorized("essentials.nick.others")) {
-            return getPlayers(server, user);
-        } else {
-            return Collections.emptyList();
-        }
-    }
-
-    @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);
-        } else {
-            return Collections.emptyList();
-        }
-    }
-}

Essentials/src/com/earth2me/essentials/commands/Commandnuke.java

@@ -1,61 +0,0 @@
-package com.earth2me.essentials.commands;
-
-import com.earth2me.essentials.CommandSource;
-import org.bukkit.Location;
-import org.bukkit.Server;
-import org.bukkit.World;
-import org.bukkit.entity.Player;
-import org.bukkit.entity.TNTPrimed;
-
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.Collections;
-import java.util.List;
-
-import static com.earth2me.essentials.I18n.tl;
-
-
-public class Commandnuke extends EssentialsCommand {
-    public Commandnuke() {
-        super("nuke");
-    }
-
-    @Override
-    protected void run(final Server server, final CommandSource sender, final String commandLabel, final String[] args) throws NoSuchFieldException, NotEnoughArgumentsException {
-        Collection<Player> targets;
-        if (args.length > 0) {
-            targets = new ArrayList<>();
-            int pos = 0;
-            for (String arg : args) {
-                targets.add(getPlayer(server, sender, args, pos).getBase());
-                pos++;
-            }
-        } else {
-            targets = ess.getOnlinePlayers();
-        }
-        ess.getTNTListener().enable();
-        for (Player player : targets) {
-            if (player == null) {
-                continue;
-            }
-            player.sendMessage(tl("nuke"));
-            final Location loc = player.getLocation();
-            final World world = loc.getWorld();
-            for (int x = -10; x <= 10; x += 5) {
-                for (int z = -10; z <= 10; z += 5) {
-                    final Location tntloc = new Location(world, loc.getBlockX() + x, world.getHighestBlockYAt(loc) + 64, loc.getBlockZ() + z);
-                    final TNTPrimed tnt = world.spawn(tntloc, TNTPrimed.class);
-                }
-            }
-        }
-    }
-
-    @Override
-    protected List<String> getTabCompleteOptions(Server server, CommandSource sender, String commandLabel, String[] args) {
-        if (args.length == 1) {
-            return getPlayers(server, sender);
-        } else {
-            return Collections.emptyList();
-        }
-    }
-}

Essentials/src/com/earth2me/essentials/commands/Commandpay.java

@@ -1,101 +0,0 @@
-package com.earth2me.essentials.commands;
-
-import com.earth2me.essentials.ChargeException;
-import com.earth2me.essentials.CommandSource;
-import com.earth2me.essentials.Trade;
-import com.earth2me.essentials.User;
-import com.earth2me.essentials.utils.NumberUtil;
-import com.earth2me.essentials.utils.StringUtil;
-
-import com.google.common.collect.Lists;
-import net.ess3.api.MaxMoneyException;
-import org.bukkit.Server;
-
-import java.math.BigDecimal;
-import java.util.Collections;
-import java.util.List;
-
-import static com.earth2me.essentials.I18n.tl;
-
-
-public class Commandpay extends EssentialsLoopCommand {
-    BigDecimal amount;
-    boolean informToConfirm;
-
-    public Commandpay() {
-        super("pay");
-    }
-
-    @Override
-    public void run(final Server server, final User user, final String commandLabel, final String[] args) throws Exception {
-        informToConfirm = false;
-        if (args.length < 2) {
-            throw new NotEnoughArgumentsException();
-        }
-        
-        if (args[1].contains("-")) {
-            throw new Exception(tl("payMustBePositive"));
-        }
-
-        String stringAmount = args[1].replaceAll("[^0-9\\.]", "");
-
-        if (stringAmount.length() < 1) {
-            throw new NotEnoughArgumentsException();
-        }
-
-        amount = new BigDecimal(stringAmount);
-        if (amount.compareTo(ess.getSettings().getMinimumPayAmount()) < 0) { // Check if amount is less than minimum-pay-amount
-            throw new Exception(tl("minimumPayAmount", NumberUtil.displayCurrencyExactly(ess.getSettings().getMinimumPayAmount(), ess)));
-        }
-        loopOnlinePlayers(server, user.getSource(), false, user.isAuthorized("essentials.pay.multiple"), args[0], args);
-        if (informToConfirm) {
-            String cmd = "/" + commandLabel + " " + StringUtil.joinList(" ", (Object[]) args);
-            user.sendMessage(tl("confirmPayment", NumberUtil.displayCurrency(amount, ess), cmd));
-        }
-    }
-
-    @Override
-    protected void updatePlayer(final Server server, final CommandSource sender, final User player, final String[] args) throws ChargeException {
-        User user = ess.getUser(sender.getPlayer());
-        try {
-            if (!player.isAcceptingPay()) {
-                sender.sendMessage(tl("notAcceptingPay", player.getDisplayName()));
-                return;
-            }
-            if (user.isPromptingPayConfirm() && !amount.equals(user.getConfirmingPayments().get(player))) { // checks if exists and if command needs to be repeated.
-                // Used to reset confirmations and inform to confirm when a new pay command has been inserted.
-                if (!informToConfirm) {
-                    // User hasnt been asked to confirm payment to this player, reset all confirmed payments and ask to confirm again.
-                    // Clear previous confirmations to ensure that a new confirmation message is brought up.
-                    user.getConfirmingPayments().clear();
-                    this.informToConfirm = true;
-                }
-                user.getConfirmingPayments().put(player, amount);
-                return;
-            }
-            user.payUser(player, amount);
-            user.getConfirmingPayments().remove(player);
-            Trade.log("Command", "Pay", "Player", user.getName(), new Trade(amount, ess), player.getName(), new Trade(amount, ess), user.getLocation(), ess);
-        } catch (MaxMoneyException ex) {
-            sender.sendMessage(tl("maxMoney"));
-            try {
-                user.setMoney(user.getMoney().add(amount));
-            } catch (MaxMoneyException ignored) {
-                // this should never happen
-            }
-        } catch (Exception e) {
-            sender.sendMessage(e.getMessage());
-        }
-    }
-
-    @Override
-    protected List<String> getTabCompleteOptions(Server server, CommandSource sender, String commandLabel, String[] args) {
-        if (args.length == 1) {
-            return getPlayers(server, sender);
-        } else if (args.length == 2) {
-            return Lists.newArrayList(ess.getSettings().getMinimumPayAmount().toString());
-        } else {
-            return Collections.emptyList();
-        }
-    }
-}

Essentials/src/com/earth2me/essentials/commands/Commandpaytoggle.java

@@ -1,32 +0,0 @@
-package com.earth2me.essentials.commands;
-
-import static com.earth2me.essentials.I18n.tl;
-
-import com.earth2me.essentials.I18n;
-import com.earth2me.essentials.User;
-
-import org.bukkit.Server;
-
-public class Commandpaytoggle extends EssentialsCommand {
-
-    public Commandpaytoggle() {
-        super("paytoggle");
-    }
-
-    @Override
-    public void run(Server server, User user, String commandLabel, String[] args) throws Exception {
-        boolean acceptingPay = !user.isAcceptingPay();
-        if (commandLabel.contains("payon")) {
-            acceptingPay = true;
-        } else if (commandLabel.contains("payoff")) {
-            acceptingPay = false;
-        }
-        user.setAcceptingPay(acceptingPay);
-        if (acceptingPay) {
-            user.sendMessage(tl("payToggleOn"));
-        } else {
-            user.sendMessage(tl("payToggleOff"));
-        }
-    }
-}
-

Essentials/src/com/earth2me/essentials/commands/Commandptime.java

@@ -1,209 +0,0 @@
-package com.earth2me.essentials.commands;
-
-import com.google.common.collect.Lists;
-
-import com.earth2me.essentials.CommandSource;
-import com.earth2me.essentials.User;
-import com.earth2me.essentials.utils.DescParseTickFormat;
-import org.bukkit.Server;
-import org.bukkit.World;
-import org.bukkit.entity.Player;
-
-import java.util.*;
-
-import static com.earth2me.essentials.I18n.tl;
-
-
-public class Commandptime extends EssentialsCommand {
-    private static final Set<String> getAliases = new HashSet<>();
-
-    static {
-        getAliases.add("get");
-        getAliases.add("list");
-        getAliases.add("show");
-        getAliases.add("display");
-    }
-
-    public Commandptime() {
-        super("ptime");
-    }
-
-    @Override
-    public void run(final Server server, final CommandSource sender, final String commandLabel, final String[] args) throws Exception {
-        // Which Players(s) / Users(s) are we interested in?
-        String userSelector = null;
-        if (args.length == 2) {
-            userSelector = args[1];
-        }
-        Set<User> users = getUsers(server, sender, userSelector);
-
-        // If no arguments we are reading the time
-        if (args.length == 0) {
-            getUsersTime(sender, users);
-            return;
-        }
-
-        if (sender.isPlayer()) {
-            User user = ess.getUser(sender.getPlayer());
-            if (user != null && (!users.contains(user) || users.size() > 1) && !user.isAuthorized("essentials.ptime.others")) {
-                user.sendMessage(tl("pTimeOthersPermission"));
-                return;
-            }
-        }
-
-        Long ticks;
-        // Parse the target time int ticks from args[0]
-        String timeParam = args[0];
-        boolean relative = true;
-        if (timeParam.startsWith("@")) {
-            relative = false;
-            timeParam = timeParam.substring(1);
-        }
-
-        if (getAliases.contains(timeParam)) {
-            getUsersTime(sender, users);
-            return;
-        } else if (DescParseTickFormat.meansReset(timeParam)) {
-            ticks = null;
-        } else {
-            try {
-                ticks = DescParseTickFormat.parse(timeParam);
-            } catch (NumberFormatException e) {
-                throw new NotEnoughArgumentsException(e);
-            }
-        }
-
-        setUsersTime(sender, users, ticks, relative);
-    }
-
-    /**
-     * Used to get the time and inform
-     */
-    private void getUsersTime(final CommandSource sender, final Collection<User> users) {
-        if (users.size() > 1) {
-            sender.sendMessage(tl("pTimePlayers"));
-        }
-
-        for (User user : users) {
-            if (user.getBase().getPlayerTimeOffset() == 0) {
-                sender.sendMessage(tl("pTimeNormal", user.getName()));
-            } else {
-                String time = DescParseTickFormat.format(user.getBase().getPlayerTime());
-                if (!user.getBase().isPlayerTimeRelative()) {
-                    sender.sendMessage(tl("pTimeCurrentFixed", user.getName(), time));
-                } else {
-                    sender.sendMessage(tl("pTimeCurrent", user.getName(), time));
-                }
-            }
-        }
-    }
-
-    /**
-     * Used to set the time and inform of the change
-     */
-    private void setUsersTime(final CommandSource sender, final Collection<User> users, final Long ticks, Boolean relative) {
-        // Update the time
-        if (ticks == null) {
-            // Reset
-            for (User user : users) {
-                user.getBase().resetPlayerTime();
-            }
-        } else {
-            // Set
-            for (User user : users) {
-                final World world = user.getWorld();
-                long time = user.getBase().getPlayerTime();
-                time -= time % 24000;
-                time += 24000 + ticks;
-                if (relative) {
-                    time -= world.getTime();
-                }
-                user.getBase().setPlayerTime(time, relative);
-            }
-        }
-
-        final StringBuilder msg = new StringBuilder();
-        for (User user : users) {
-            if (msg.length() > 0) {
-                msg.append(", ");
-            }
-
-            msg.append(user.getName());
-        }
-
-        // Inform the sender of the change
-        if (ticks == null) {
-            sender.sendMessage(tl("pTimeReset", msg.toString()));
-        } else {
-            String time = DescParseTickFormat.format(ticks);
-            if (!relative) {
-                sender.sendMessage(tl("pTimeSetFixed", time, msg.toString()));
-            } else {
-                sender.sendMessage(tl("pTimeSet", time, msg.toString()));
-            }
-        }
-    }
-
-    /**
-     * Used to parse an argument of the type "users(s) selector"
-     */
-    private Set<User> getUsers(final Server server, final CommandSource sender, final String selector) throws Exception {
-        final Set<User> users = new TreeSet<>(new UserNameComparator());
-        // If there is no selector we want the sender itself. Or all users if sender isn't a user.
-        if (selector == null) {
-            if (sender.isPlayer()) {
-                final User user = ess.getUser(sender.getPlayer());
-                users.add(user);
-            } else {
-                for (User user : ess.getOnlineUsers()) {
-                    users.add(user);
-                }
-            }
-            return users;
-        }
-
-        // Try to find the user with name = selector
-        User user = null;
-        final List<Player> matchedPlayers = server.matchPlayer(selector);
-        if (!matchedPlayers.isEmpty()) {
-            user = ess.getUser(matchedPlayers.get(0));
-        }
-
-        if (user != null) {
-            users.add(user);
-        }
-        // If that fails, Is the argument something like "*" or "all"?
-        else if (selector.equalsIgnoreCase("*") || selector.equalsIgnoreCase("all")) {
-            for (User u : ess.getOnlineUsers()) {
-                users.add(u);
-            }
-        }
-        // We failed to understand the world target...
-        else {
-            throw new PlayerNotFoundException();
-        }
-
-        return users;
-    }
-
-    @Override
-    protected List<String> getTabCompleteOptions(Server server, CommandSource sender, String commandLabel, String[] args) {
-        final User user = ess.getUser(sender.getPlayer());
-
-        if (args.length == 1) {
-            return Lists.newArrayList("get", "reset", "sunrise", "day", "morning", "noon", "afternoon", "sunset", "night", "midnight");
-        } else if (args.length == 2 && (getAliases.contains(args[0]) || user == null || user.isAuthorized("essentials.ptime.others"))) {
-            return getPlayers(server, sender);
-        } else {
-            return Collections.emptyList();
-        }
-    }
-}
-
-
-class UserNameComparator implements Comparator<User> {
-    @Override
-    public int compare(User a, User b) {
-        return a.getName().compareTo(b.getName());
-    }
-}

Essentials/src/com/earth2me/essentials/commands/Commandpweather.java

@@ -1,166 +0,0 @@
-package com.earth2me.essentials.commands;
-
-import com.google.common.collect.Lists;
-
-import com.earth2me.essentials.CommandSource;
-import com.earth2me.essentials.User;
-import org.bukkit.Server;
-import org.bukkit.WeatherType;
-import org.bukkit.entity.Player;
-
-import java.util.*;
-
-import static com.earth2me.essentials.I18n.tl;
-
-
-public class Commandpweather extends EssentialsCommand {
-    public static final Set<String> getAliases = new HashSet<>();
-    public static final Map<String, WeatherType> weatherAliases = new HashMap<>();
-
-    static {
-        getAliases.add("get");
-        getAliases.add("list");
-        getAliases.add("show");
-        getAliases.add("display");
-        weatherAliases.put("sun", WeatherType.CLEAR);
-        weatherAliases.put("clear", WeatherType.CLEAR);
-        weatherAliases.put("storm", WeatherType.DOWNFALL);
-        weatherAliases.put("thunder", WeatherType.DOWNFALL);
-    }
-
-    public Commandpweather() {
-        super("pweather");
-    }
-
-    @Override
-    public void run(final Server server, final CommandSource sender, final String commandLabel, final String[] args) throws Exception {
-        // Which Players(s) / Users(s) are we interested in?
-        String userSelector = null;
-        if (args.length == 2) {
-            userSelector = args[1];
-        }
-        Set<User> users = getUsers(server, sender, userSelector);
-
-        if (args.length == 0) {
-            getUsersWeather(sender, users);
-            return;
-        }
-
-        if (getAliases.contains(args[0])) {
-            getUsersWeather(sender, users);
-            return;
-        }
-
-        if (sender.isPlayer()) {
-            User user = ess.getUser(sender.getPlayer());
-            if (user != null && (!users.contains(user) || users.size() > 1) && !user.isAuthorized("essentials.pweather.others")) {
-                user.sendMessage(tl("pWeatherOthersPermission"));
-                return;
-            }
-        }
-
-        setUsersWeather(sender, users, args[0].toLowerCase());
-    }
-
-    /**
-     * Used to get the time and inform
-     */
-    private void getUsersWeather(final CommandSource sender, final Collection<User> users) {
-        if (users.size() > 1) {
-            sender.sendMessage(tl("pWeatherPlayers"));
-        }
-
-        for (User user : users) {
-            if (user.getBase().getPlayerWeather() == null) {
-                sender.sendMessage(tl("pWeatherNormal", user.getName()));
-            } else {
-                sender.sendMessage(tl("pWeatherCurrent", user.getName(), user.getBase().getPlayerWeather().toString().toLowerCase(Locale.ENGLISH)));
-            }
-        }
-    }
-
-    /**
-     * Used to set the time and inform of the change
-     */
-    private void setUsersWeather(final CommandSource sender, final Collection<User> users, final String weatherType) throws Exception {
-
-        final StringBuilder msg = new StringBuilder();
-        for (User user : users) {
-            if (msg.length() > 0) {
-                msg.append(", ");
-            }
-
-            msg.append(user.getName());
-        }
-
-        if (weatherType.equalsIgnoreCase("reset")) {
-            for (User user : users) {
-                user.getBase().resetPlayerWeather();
-            }
-
-            sender.sendMessage(tl("pWeatherReset", msg));
-        } else {
-            if (!weatherAliases.containsKey(weatherType)) {
-                throw new NotEnoughArgumentsException(tl("pWeatherInvalidAlias"));
-            }
-
-            for (User user : users) {
-                user.getBase().setPlayerWeather(weatherAliases.get(weatherType));
-            }
-            sender.sendMessage(tl("pWeatherSet", weatherType, msg.toString()));
-        }
-    }
-
-    /**
-     * Used to parse an argument of the type "users(s) selector"
-     */
-    private Set<User> getUsers(final Server server, final CommandSource sender, final String selector) throws Exception {
-        final Set<User> users = new TreeSet<>(new UserNameComparator());
-        // If there is no selector we want the sender itself. Or all users if sender isn't a user.
-        if (selector == null) {
-            if (sender.isPlayer()) {
-                final User user = ess.getUser(sender.getPlayer());
-                users.add(user);
-            } else {
-                for (User user : ess.getOnlineUsers()) {
-                    users.add(user);
-                }
-            }
-            return users;
-        }
-
-        // Try to find the user with name = selector
-        User user = null;
-        final List<Player> matchedPlayers = server.matchPlayer(selector);
-        if (!matchedPlayers.isEmpty()) {
-            user = ess.getUser(matchedPlayers.get(0));
-        }
-
-        if (user != null) {
-            users.add(user);
-        }
-        // If that fails, Is the argument something like "*" or "all"?
-        else if (selector.equalsIgnoreCase("*") || selector.equalsIgnoreCase("all")) {
-            for (User u : ess.getOnlineUsers()) {
-                users.add(u);
-            }
-        }
-        // We failed to understand the world target...
-        else {
-            throw new PlayerNotFoundException();
-        }
-
-        return users;
-    }
-
-    @Override
-    protected List<String> getTabCompleteOptions(Server server, User user, String commandLabel, String[] args) {
-        if (args.length == 1) {
-            return Lists.newArrayList("get", "reset", "storm", "sun");
-        } else if (args.length == 2 && (getAliases.contains(args[0]) || user == null || user.isAuthorized("essentials.pweather.others"))) {
-            return getPlayers(server, user);
-        } else {
-            return Collections.emptyList();
-        }
-    }
-}

Essentials/src/com/earth2me/essentials/commands/Commandrecipe.java

@@ -1,195 +0,0 @@
-package com.earth2me.essentials.commands;
-
-import com.earth2me.essentials.CommandSource;
-import com.earth2me.essentials.User;
-import com.earth2me.essentials.utils.EnumUtil;
-import com.earth2me.essentials.utils.NumberUtil;
-import com.earth2me.essentials.utils.VersionUtil;
-import org.bukkit.Material;
-import org.bukkit.Server;
-import org.bukkit.inventory.*;
-
-import java.util.HashMap;
-import java.util.Collections;
-import java.util.List;
-import java.util.Locale;
-import java.util.Map;
-
-import static com.earth2me.essentials.I18n.tl;
-
-import net.ess3.nms.refl.ReflUtil;
-
-
-public class Commandrecipe extends EssentialsCommand {
-
-    private static final Material FIREWORK_ROCKET = EnumUtil.getMaterial("FIREWORK_ROCKET", "FIREWORK");
-    private static final Material FIREWORK_STAR = EnumUtil.getMaterial("FIREWORK_STAR", "FIREWORK_CHARGE");
-    private static final Material GUNPOWDER = EnumUtil.getMaterial("GUNPOWDER", "SULPHUR");
-
-    public Commandrecipe() {
-        super("recipe");
-    }
-    
-    private void disableCommandForVersion1_12() throws Exception {
-        VersionUtil.BukkitVersion version = VersionUtil.getServerBukkitVersion();
-        if (version.isHigherThanOrEqualTo(VersionUtil.v1_12_0_R01)
-            && !ess.getSettings().isForceEnableRecipe()) {
-            throw new Exception("Please use the recipe book in your inventory.");
-        }
-    }
-
-    @Override
-    public void run(final Server server, final CommandSource sender, final String commandLabel, final String[] args) throws Exception {
-        disableCommandForVersion1_12();
-        if (args.length < 1) {
-            throw new NotEnoughArgumentsException();
-        }
-
-        final ItemStack itemType = ess.getItemDb().get(args[0]);
-        int recipeNo = 0;
-
-        if (args.length > 1) {
-            if (NumberUtil.isInt(args[1])) {
-                recipeNo = Integer.parseInt(args[1]) - 1;
-            } else {
-                throw new Exception(tl("invalidNumber"));
-            }
-        }
-
-        final List<Recipe> recipesOfType = ess.getServer().getRecipesFor(itemType);
-        if (recipesOfType.size() < 1) {
-            throw new Exception(tl("recipeNone", getMaterialName(itemType)));
-        }
-
-        if (recipeNo < 0 || recipeNo >= recipesOfType.size()) {
-            throw new Exception(tl("recipeBadIndex"));
-        }
-
-        final Recipe selectedRecipe = recipesOfType.get(recipeNo);
-        sender.sendMessage(tl("recipe", getMaterialName(itemType), recipeNo + 1, recipesOfType.size()));
-
-        if (selectedRecipe instanceof FurnaceRecipe) {
-            furnaceRecipe(sender, (FurnaceRecipe) selectedRecipe);
-        } else if (selectedRecipe instanceof ShapedRecipe) {
-            shapedRecipe(sender, (ShapedRecipe) selectedRecipe, sender.isPlayer());
-        } else if (selectedRecipe instanceof ShapelessRecipe) {
-            if (recipesOfType.size() == 1 && (itemType.getType() == FIREWORK_ROCKET)) {
-                ShapelessRecipe shapelessRecipe = new ShapelessRecipe(itemType);
-                shapelessRecipe.addIngredient(GUNPOWDER);
-                shapelessRecipe.addIngredient(Material.PAPER);
-                shapelessRecipe.addIngredient(FIREWORK_STAR);
-                shapelessRecipe(sender, shapelessRecipe, sender.isPlayer());
-            } else {
-                shapelessRecipe(sender, (ShapelessRecipe) selectedRecipe, sender.isPlayer());
-            }
-        }
-
-        if (recipesOfType.size() > 1 && args.length == 1) {
-            sender.sendMessage(tl("recipeMore", commandLabel, args[0], getMaterialName(itemType)));
-        }
-    }
-
-    public void furnaceRecipe(final CommandSource sender, final FurnaceRecipe recipe) {
-        sender.sendMessage(tl("recipeFurnace", getMaterialName(recipe.getInput())));
-    }
-
-    public void shapedRecipe(final CommandSource sender, final ShapedRecipe recipe, final boolean showWindow) {
-        final Map<Character, ItemStack> recipeMap = recipe.getIngredientMap();
-
-        if (showWindow) {
-            final User user = ess.getUser(sender.getPlayer());
-            user.getBase().closeInventory();
-            user.setRecipeSee(true);
-            final InventoryView view = user.getBase().openWorkbench(null, true);
-            final String[] recipeShape = recipe.getShape();
-            final Map<Character, ItemStack> ingredientMap = recipe.getIngredientMap();
-            for (int j = 0; j < recipeShape.length; j++) {
-                for (int k = 0; k < recipeShape[j].length(); k++) {
-                    final ItemStack item = ingredientMap.get(recipeShape[j].toCharArray()[k]);
-                    if (item == null) {
-                        continue;
-                    }
-                    if (item.getDurability() == Short.MAX_VALUE) {
-                        item.setDurability((short) 0);
-                    }
-                    view.getTopInventory().setItem(j * 3 + k + 1, item);
-                }
-            }
-        } else {
-            final HashMap<Material, String> colorMap = new HashMap<>();
-            int i = 1;
-            for (Character c : "abcdefghi".toCharArray()) {
-                ItemStack item = recipeMap.get(c);
-                if (!colorMap.containsKey(item == null ? null : item.getType())) {
-                    colorMap.put(item == null ? null : item.getType(), String.valueOf(i++));
-                }
-            }
-            final Material[][] materials = new Material[3][3];
-            for (int j = 0; j < recipe.getShape().length; j++) {
-                for (int k = 0; k < recipe.getShape()[j].length(); k++) {
-                    ItemStack item = recipe.getIngredientMap().get(recipe.getShape()[j].toCharArray()[k]);
-                    materials[j][k] = item == null ? null : item.getType();
-                }
-            }
-            sender.sendMessage(tl("recipeGrid", colorMap.get(materials[0][0]), colorMap.get(materials[0][1]), colorMap.get(materials[0][2])));
-            sender.sendMessage(tl("recipeGrid", colorMap.get(materials[1][0]), colorMap.get(materials[1][1]), colorMap.get(materials[1][2])));
-            sender.sendMessage(tl("recipeGrid", colorMap.get(materials[2][0]), colorMap.get(materials[2][1]), colorMap.get(materials[2][2])));
-
-            StringBuilder s = new StringBuilder();
-            for (Material items : colorMap.keySet().toArray(new Material[colorMap.size()])) {
-                s.append(tl("recipeGridItem", colorMap.get(items), getMaterialName(items)));
-            }
-            sender.sendMessage(tl("recipeWhere", s.toString()));
-        }
-    }
-
-    public void shapelessRecipe(final CommandSource sender, final ShapelessRecipe recipe, final boolean showWindow) {
-        final List<ItemStack> ingredients = recipe.getIngredientList();
-        if (showWindow) {
-            final User user = ess.getUser(sender.getPlayer());
-            user.setRecipeSee(true);
-            final InventoryView view = user.getBase().openWorkbench(null, true);
-            for (int i = 0; i < ingredients.size(); i++) {
-                final ItemStack item = ingredients.get(i);
-                if (item.getDurability() == Short.MAX_VALUE) {
-                    item.setDurability((short) 0);
-                }
-                view.setItem(i + 1, item);
-            }
-
-        } else {
-            StringBuilder s = new StringBuilder();
-            for (int i = 0; i < ingredients.size(); i++) {
-                s.append(getMaterialName(ingredients.get(i)));
-                if (i != ingredients.size() - 1) {
-                    s.append(",");
-                }
-                s.append(" ");
-            }
-            sender.sendMessage(tl("recipeShapeless", s.toString()));
-        }
-    }
-
-    public String getMaterialName(final ItemStack stack) {
-        if (stack == null) {
-            return tl("recipeNothing");
-        }
-        return getMaterialName(stack.getType());
-    }
-
-    public String getMaterialName(final Material type) {
-        if (type == null) {
-            return tl("recipeNothing");
-        }
-        return type.toString().replace("_", " ").toLowerCase(Locale.ENGLISH);
-    }
-
-    @Override
-    protected List<String> getTabCompleteOptions(final Server server, final CommandSource sender, final String commandLabel, final String[] args) {
-        if (args.length == 1) {
-            return getItems();
-        } else {
-            return Collections.emptyList();
-        }
-    }
-}

Essentials/src/com/earth2me/essentials/commands/Commandseen.java

@@ -1,239 +0,0 @@
-package com.earth2me.essentials.commands;
-
-import com.earth2me.essentials.CommandSource;
-import com.earth2me.essentials.User;
-import com.earth2me.essentials.UserMap;
-import com.earth2me.essentials.craftbukkit.BanLookup;
-import com.earth2me.essentials.utils.DateUtil;
-import com.earth2me.essentials.utils.FormatUtil;
-import com.earth2me.essentials.utils.StringUtil;
-import org.bukkit.BanEntry;
-import org.bukkit.BanList;
-import org.bukkit.Location;
-import org.bukkit.Server;
-
-import java.util.ArrayList;
-import java.util.Date;
-import java.util.List;
-import java.util.UUID;
-import java.util.Collections;
-
-import static com.earth2me.essentials.I18n.tl;
-
-
-public class Commandseen extends EssentialsCommand {
-    public Commandseen() {
-        super("seen");
-    }
-
-    @Override
-    protected void run(final Server server, final CommandSource sender, final String commandLabel, final String[] args) throws Exception {
-        seen(server, sender, commandLabel, args, true, true, true, true);
-    }
-
-    @Override
-    protected void run(final Server server, final User user, final String commandLabel, final String[] args) throws Exception {
-        seen(server, user.getSource(), commandLabel, args, user.isAuthorized("essentials.seen.banreason"), user.isAuthorized("essentials.seen.ip"), user.isAuthorized("essentials.seen.location"), user.isAuthorized("essentials.seen.ipsearch"));
-    }
-
-    protected void seen(final Server server, final CommandSource sender, final String commandLabel, final String[] args,
-                        final boolean showBan, final boolean showIp, final boolean showLocation, final boolean ipLookup) throws Exception {
-        if (args.length < 1) {
-            throw new NotEnoughArgumentsException();
-        }
-        User player;
-        // Check by uuid, if it fails check by name.
-        try {
-            UUID uuid = UUID.fromString(args[0]);
-            player = ess.getUser(uuid);
-        }catch (IllegalArgumentException ignored) { // Thrown if invalid UUID from string, check by name.
-            player = ess.getOfflineUser(args[0]);
-        }
-
-        if (player == null) {
-            if (ipLookup && FormatUtil.validIP(args[0])) {
-                seenIP(server, sender, args[0]);
-                return;
-            } else if (ess.getServer().getBanList(BanList.Type.IP).isBanned(args[0])) {
-                sender.sendMessage(tl("isIpBanned", args[0]));
-                return;
-            } else if (BanLookup.isBanned(ess, args[0])) {
-                sender.sendMessage(tl("whoisBanned", showBan ? BanLookup.getBanEntry(ess, args[0]).getReason() : tl("true")));
-                return;
-            }
-            ess.getScheduler().runTaskAsynchronously(ess, new Runnable() {
-                @Override
-                public void run() {
-                    User userFromBukkit = ess.getUserMap().getUserFromBukkit(args[0]);
-                    try {
-                        if (userFromBukkit != null) {
-                            showUserSeen(userFromBukkit);
-                        } else {
-                            showUserSeen(getPlayer(server, sender, args, 0));
-                        }
-                    } catch (Exception e) {
-                        ess.showError(sender, e, commandLabel);
-                    }
-                }
-
-                private void showUserSeen(User user) throws Exception {
-                    if (user == null) {
-                        throw new PlayerNotFoundException();
-                    }
-                    showSeenMessage(server, sender, user, showBan, showIp, showLocation);
-                }
-            });
-        } else {
-            showSeenMessage(server, sender, player, showBan, showIp, showLocation);
-        }
-    }
-
-    private void showSeenMessage(Server server, CommandSource sender, User player, boolean showBan, boolean showIp, boolean showLocation)  throws Exception {
-        if (player.getBase().isOnline() && canInteractWith(sender, player)) {
-            seenOnline(server, sender, player, showBan, showIp, showLocation);
-        } else {
-            seenOffline(server, sender, player, showBan, showIp, showLocation);
-        }
-    }
-
-    private void seenOnline(final Server server, final CommandSource sender, final User user, final boolean showBan, final boolean showIp, final boolean showLocation) throws Exception {
-
-        user.setDisplayNick();
-        sender.sendMessage(tl("seenOnline", user.getDisplayName(), DateUtil.formatDateDiff(user.getLastLogin())));
-
-        if (ess.getSettings().isDebug()) {
-            ess.getLogger().info("UUID: " + user.getBase().getUniqueId().toString());
-        }
-
-        List<String> history = ess.getUserMap().getUserHistory(user.getBase().getUniqueId());
-        if (history != null && history.size() > 1) {
-            sender.sendMessage(tl("seenAccounts", StringUtil.joinListSkip(", ", user.getName(), history)));
-        }
-
-        if (user.isAfk()) {
-            sender.sendMessage(tl("whoisAFK", tl("true")));
-        }
-        if (user.isJailed()) {
-            sender.sendMessage(tl("whoisJail", (user.getJailTimeout() > 0 ? DateUtil.formatDateDiff(user.getJailTimeout()) : tl("true"))));
-        }
-        if (user.isMuted()) {
-            long muteTimeout = user.getMuteTimeout();
-            if (!user.hasMuteReason()) {
-                sender.sendMessage(tl("whoisMuted", (muteTimeout > 0 ? DateUtil.formatDateDiff(muteTimeout) : tl("true"))));
-            } else {
-                sender.sendMessage(tl("whoisMutedReason", (muteTimeout > 0 ? DateUtil.formatDateDiff(muteTimeout) : tl("true")), user.getMuteReason()));
-            }
-        }
-        final String location = user.getGeoLocation();
-        if (location != null && (!(sender.isPlayer()) || ess.getUser(sender.getPlayer()).isAuthorized("essentials.geoip.show"))) {
-            sender.sendMessage(tl("whoisGeoLocation", location));
-        }
-        if (showIp) {
-            sender.sendMessage(tl("whoisIPAddress", user.getBase().getAddress().getAddress().toString()));
-        }
-    }
-
-    private void seenOffline(final Server server, final CommandSource sender, User user, final boolean showBan, final boolean showIp, final boolean showLocation) throws Exception {
-        user.setDisplayNick();
-        if (user.getLastLogout() > 0) {
-            sender.sendMessage(tl("seenOffline", user.getName(), DateUtil.formatDateDiff(user.getLastLogout())));
-        } else {
-            sender.sendMessage(tl("userUnknown", user.getName()));
-        }
-
-        if (ess.getSettings().isDebug()) {
-            ess.getLogger().info("UUID: " + user.getBase().getUniqueId().toString());
-        }
-
-        List<String> history = ess.getUserMap().getUserHistory(user.getBase().getUniqueId());
-        if (history != null && history.size() > 1) {
-            sender.sendMessage(tl("seenAccounts", StringUtil.joinListSkip(", ", user.getName(), history)));
-        }
-
-        if (BanLookup.isBanned(ess, user)) {
-            final BanEntry banEntry = BanLookup.getBanEntry(ess, user.getName());
-            final String reason = showBan ? banEntry.getReason() : tl("true");
-            sender.sendMessage(tl("whoisBanned", reason));
-            if (banEntry.getExpiration() != null) {
-                Date expiry = banEntry.getExpiration();
-                String expireString = tl("now");
-                if (expiry.after(new Date())) {
-                    expireString = DateUtil.formatDateDiff(expiry.getTime());
-                }
-                sender.sendMessage(tl("whoisTempBanned", expireString));
-            }
-        }
-
-        if (user.isMuted()) {
-            long muteTimeout = user.getMuteTimeout();
-            if (!user.hasMuteReason()) {
-                sender.sendMessage(tl("whoisMuted", (muteTimeout > 0 ? DateUtil.formatDateDiff(muteTimeout) : tl("true"))));
-            } else {
-                sender.sendMessage(tl("whoisMutedReason", (muteTimeout > 0 ? DateUtil.formatDateDiff(muteTimeout) : tl("true")), user.getMuteReason()));
-            }
-        }
-
-        final String location = user.getGeoLocation();
-        if (location != null && (!(sender.isPlayer()) || ess.getUser(sender.getPlayer()).isAuthorized("essentials.geoip.show"))) {
-            sender.sendMessage(tl("whoisGeoLocation", location));
-        }
-        if (showIp) {
-            if (!user.getLastLoginAddress().isEmpty()) {
-                sender.sendMessage(tl("whoisIPAddress", user.getLastLoginAddress()));
-            }
-        }
-        if (showLocation) {
-            final Location loc = user.getLogoutLocation();
-            if (loc != null) {
-                sender.sendMessage(tl("whoisLocation", loc.getWorld().getName(), loc.getBlockX(), loc.getBlockY(), loc.getBlockZ()));
-            }
-        }
-    }
-
-    private void seenIP(final Server server, final CommandSource sender, final String ipAddress) throws Exception {
-        final UserMap userMap = ess.getUserMap();
-
-        if (ess.getServer().getBanList(BanList.Type.IP).isBanned(ipAddress)) {
-            sender.sendMessage(tl("isIpBanned", ipAddress));
-        }
-
-        sender.sendMessage(tl("runningPlayerMatch", ipAddress));
-
-        ess.runTaskAsynchronously(new Runnable() {
-            @Override
-            public void run() {
-                final List<String> matches = new ArrayList<>();
-                for (final UUID u : userMap.getAllUniqueUsers()) {
-                    final User user = ess.getUserMap().getUser(u);
-                    if (user == null) {
-                        continue;
-                    }
-
-                    final String uIPAddress = user.getLastLoginAddress();
-
-                    if (!uIPAddress.isEmpty() && uIPAddress.equalsIgnoreCase(ipAddress)) {
-                        matches.add(user.getName());
-                    }
-                }
-
-                if (matches.size() > 0) {
-                    sender.sendMessage(tl("matchingIPAddress"));
-                    sender.sendMessage(StringUtil.joinList(matches));
-                } else {
-                    sender.sendMessage(tl("noMatchingPlayers"));
-                }
-
-            }
-        });
-
-    }
-
-    @Override
-    protected List<String> getTabCompleteOptions(Server server, CommandSource sender, String commandLabel, String[] args) {
-        if (args.length == 1) {
-            return getPlayers(server, sender);
-        } else {
-            return Collections.emptyList();
-        }
-    }
-}

Essentials/src/com/earth2me/essentials/commands/Commandsell.java

@@ -1,113 +0,0 @@
-package com.earth2me.essentials.commands;
-
-import com.earth2me.essentials.Trade;
-import com.earth2me.essentials.User;
-import com.earth2me.essentials.utils.NumberUtil;
-import com.google.common.collect.Lists;
-import org.bukkit.Server;
-import org.bukkit.inventory.ItemStack;
-
-import java.math.BigDecimal;
-import java.util.Collections;
-import java.util.List;
-import java.util.Locale;
-import java.util.logging.Level;
-
-import static com.earth2me.essentials.I18n.tl;
-
-
-public class Commandsell extends EssentialsCommand {
-    public Commandsell() {
-        super("sell");
-    }
-
-    @Override
-    public void run(final Server server, final User user, final String commandLabel, final String[] args) throws Exception {
-        BigDecimal totalWorth = BigDecimal.ZERO;
-        String type = "";
-        if (args.length < 1) {
-            throw new NotEnoughArgumentsException();
-        }
-
-        if (args[0].equalsIgnoreCase("hand") && !user.isAuthorized("essentials.sell.hand")) {
-            throw new Exception(tl("sellHandPermission"));
-        } else if ((args[0].equalsIgnoreCase("inventory") || args[0].equalsIgnoreCase("invent") || args[0].equalsIgnoreCase("all")) && !user.isAuthorized("essentials.sell.bulk")) {
-            throw new Exception(tl("sellBulkPermission"));
-        }
-
-        List<ItemStack> is = ess.getItemDb().getMatching(user, args);
-        int count = 0;
-
-        boolean isBulk = is.size() > 1;
-
-        for (ItemStack stack : is) {
-            try {
-                if (stack.getAmount() > 0) {
-                    totalWorth = totalWorth.add(sellItem(user, stack, args, isBulk));
-                    stack = stack.clone();
-                    count++;
-                    for (ItemStack zeroStack : is) {
-                        if (zeroStack.isSimilar(stack)) {
-                            zeroStack.setAmount(0);
-                        }
-                    }
-                }
-            } catch (Exception e) {
-                if (!isBulk) {
-                    throw e;
-                }
-            }
-        }
-        if (count != 1) {
-            if (args[0].equalsIgnoreCase("blocks")) {
-                user.sendMessage(tl("totalWorthBlocks", type, NumberUtil.displayCurrency(totalWorth, ess)));
-            } else {
-                user.sendMessage(tl("totalWorthAll", type, NumberUtil.displayCurrency(totalWorth, ess)));
-            }
-        }
-    }
-
-    private BigDecimal sellItem(User user, ItemStack is, String[] args, boolean isBulkSell) throws Exception {
-        int amount = ess.getWorth().getAmount(ess, user, is, args, isBulkSell);
-        BigDecimal worth = ess.getWorth().getPrice(ess, is);
-
-        if (worth == null) {
-            throw new Exception(tl("itemCannotBeSold"));
-        }
-
-        if (amount <= 0) {
-            if (!isBulkSell) {
-                user.sendMessage(tl("itemSold", NumberUtil.displayCurrency(BigDecimal.ZERO, ess), BigDecimal.ZERO, is.getType().toString().toLowerCase(Locale.ENGLISH), NumberUtil.displayCurrency(worth, ess)));
-            }
-            return BigDecimal.ZERO;
-        }
-
-        BigDecimal result = worth.multiply(BigDecimal.valueOf(amount));
-
-        //TODO: Prices for Enchantments
-        final ItemStack ris = is.clone();
-        ris.setAmount(amount);
-        if (!user.getBase().getInventory().containsAtLeast(ris, amount)) {
-            // This should never happen.
-            throw new IllegalStateException("Trying to remove more items than are available.");
-        }
-        user.getBase().getInventory().removeItem(ris);
-        user.getBase().updateInventory();
-        Trade.log("Command", "Sell", "Item", user.getName(), new Trade(ris, ess), user.getName(), new Trade(result, ess), user.getLocation(), ess);
-        user.giveMoney(result);
-        user.sendMessage(tl("itemSold", NumberUtil.displayCurrency(result, ess), amount, is.getType().toString().toLowerCase(Locale.ENGLISH), NumberUtil.displayCurrency(worth, ess)));
-        logger.log(Level.INFO, tl("itemSoldConsole", user.getDisplayName(), is.getType().toString().toLowerCase(Locale.ENGLISH), NumberUtil.displayCurrency(result, ess), amount, NumberUtil.displayCurrency(worth, ess)));
-        return result;
-    }
-
-    @Override
-    protected List<String> getTabCompleteOptions(Server server, User user, String commandLabel, String[] args) {
-        if (args.length == 1) {
-            return getMatchingItems(args[0]);
-        } else if (args.length == 2) {
-            return Lists.newArrayList("1", "64");
-        } else {
-            return Collections.emptyList();
-        }
-    }
-}

Essentials/src/com/earth2me/essentials/commands/Commandsethome.java

@@ -1,75 +0,0 @@
-package com.earth2me.essentials.commands;
-
-import com.earth2me.essentials.User;
-import com.earth2me.essentials.utils.LocationUtil;
-import com.earth2me.essentials.utils.NumberUtil;
-import org.bukkit.Location;
-import org.bukkit.Server;
-
-import java.util.Locale;
-
-import static com.earth2me.essentials.I18n.tl;
-
-
-public class Commandsethome extends EssentialsCommand {
-    public Commandsethome() {
-        super("sethome");
-    }
-
-    @Override
-    public void run(final Server server, final User user, final String commandLabel, String[] args) throws Exception {
-        User usersHome = user;
-        String name = "home";
-        final Location location = user.getLocation();
-
-        if (args.length > 0) {
-            //Allowing both formats /sethome khobbits house | /sethome khobbits:house
-            final String[] nameParts = args[0].split(":");
-            if (nameParts[0].length() != args[0].length()) {
-                args = nameParts;
-            }
-
-            if (args.length < 2) {
-                name = args[0].toLowerCase(Locale.ENGLISH);
-            } else {
-                name = args[1].toLowerCase(Locale.ENGLISH);
-                if (user.isAuthorized("essentials.sethome.others")) {
-                    usersHome = getPlayer(server, args[0], true, true);
-                    if (usersHome == null) {
-                        throw new PlayerNotFoundException();
-                    }
-                }
-            }
-        }
-        if (checkHomeLimit(user, usersHome, name)) {
-            name = "home";
-        }
-        if ("bed".equals(name) || NumberUtil.isInt(name)) {
-            throw new NoSuchFieldException(tl("invalidHomeName"));
-        }
-
-        if (!ess.getSettings().isTeleportSafetyEnabled() && LocationUtil.isBlockUnsafeForUser(usersHome, location.getWorld(), location.getBlockX(), location.getBlockY(), location.getBlockZ())) {
-            throw new Exception(tl("unsafeTeleportDestination", location.getWorld().getName(), location.getBlockX(), location.getBlockY(), location.getBlockZ()));
-        }
-
-        usersHome.setHome(name, location);
-        user.sendMessage(tl("homeSet", user.getLocation().getWorld().getName(), user.getLocation().getBlockX(), user.getLocation().getBlockY(), user.getLocation().getBlockZ(), name));
-
-    }
-
-    private boolean checkHomeLimit(final User user, final User usersHome, String name) throws Exception {
-        if (!user.isAuthorized("essentials.sethome.multiple.unlimited")) {
-            int limit = ess.getSettings().getHomeLimit(user);
-            if (usersHome.getHomes().size() == limit && usersHome.getHomes().contains(name)) {
-                return false;
-            }
-            if (usersHome.getHomes().size() >= limit) {
-                throw new Exception(tl("maxHomes", ess.getSettings().getHomeLimit(user)));
-            }
-            if (limit == 1) {
-                return true;
-            }
-        }
-        return false;
-    }
-}

Essentials/src/com/earth2me/essentials/commands/Commandsetwarp.java

@@ -1,45 +0,0 @@
-package com.earth2me.essentials.commands;
-
-import com.earth2me.essentials.User;
-import com.earth2me.essentials.api.IWarps;
-import com.earth2me.essentials.utils.NumberUtil;
-import com.earth2me.essentials.utils.StringUtil;
-import net.ess3.api.InvalidWorldException;
-import org.bukkit.Location;
-import org.bukkit.Server;
-
-import static com.earth2me.essentials.I18n.tl;
-
-
-public class Commandsetwarp extends EssentialsCommand {
-    public Commandsetwarp() {
-        super("setwarp");
-    }
-
-    @Override
-    public void run(final Server server, final User user, final String commandLabel, final String[] args) throws Exception {
-        if (args.length < 1) {
-            throw new NotEnoughArgumentsException();
-        }
-
-        if (NumberUtil.isInt(args[0]) || args[0].isEmpty()) {
-            throw new NoSuchFieldException(tl("invalidWarpName"));
-        }
-
-        final Location loc = user.getLocation();
-        final IWarps warps = ess.getWarps();
-        Location warpLoc = null;
-
-        try {
-            warpLoc = warps.getWarp(args[0]);
-        } catch (WarpNotFoundException | InvalidWorldException ex) {
-        }
-
-        if (warpLoc == null || user.isAuthorized("essentials.warp.overwrite." + StringUtil.safeString(args[0]))) {
-            warps.setWarp(user, args[0], loc);
-        } else {
-            throw new Exception(tl("warpOverwrite"));
-        }
-        user.sendMessage(tl("warpSet", args[0]));
-    }
-}

Essentials/src/com/earth2me/essentials/commands/Commandskull.java

@@ -1,83 +0,0 @@
-package com.earth2me.essentials.commands;
-
-import com.earth2me.essentials.User;
-import com.earth2me.essentials.craftbukkit.InventoryWorkaround;
-import com.earth2me.essentials.utils.EnumUtil;
-import com.earth2me.essentials.utils.MaterialUtil;
-import com.google.common.collect.Lists;
-import org.bukkit.Material;
-import org.bukkit.Server;
-import org.bukkit.inventory.ItemStack;
-import org.bukkit.inventory.meta.SkullMeta;
-
-import java.util.Collections;
-import java.util.List;
-
-import static com.earth2me.essentials.I18n.tl;
-
-public class Commandskull extends EssentialsCommand {
-
-    private static final Material SKULL_ITEM = EnumUtil.getMaterial("PLAYER_HEAD", "SKULL_ITEM");
-
-    public Commandskull() {
-        super("skull");
-    }
-
-    @Override
-    protected void run(final Server server, final User user, final String commandLabel, final String[] args) throws Exception {
-        String owner;
-
-        if (args.length > 0 && user.isAuthorized("essentials.skull.others")) {
-            if (!args[0].matches("^[A-Za-z0-9_]+$")) {
-                throw new IllegalArgumentException(tl("alphaNames"));
-            }
-            owner = args[0];
-        } else {
-            owner = user.getName();
-        }
-
-        ItemStack itemSkull = user.getItemInHand();
-        SkullMeta metaSkull = null;
-        boolean spawn = false;
-
-        if (itemSkull != null && MaterialUtil.isPlayerHead(itemSkull.getType(), itemSkull.getDurability())) {
-            metaSkull = (SkullMeta) itemSkull.getItemMeta();
-        } else if (user.isAuthorized("essentials.skull.spawn")) {
-            itemSkull = new ItemStack(SKULL_ITEM, 1, (byte) 3);
-            metaSkull = (SkullMeta) itemSkull.getItemMeta();
-            spawn = true;
-        } else {
-            throw new Exception(tl("invalidSkull"));
-        }
-
-        if (metaSkull.hasOwner() && !user.isAuthorized("essentials.skull.modify")) {
-            throw new Exception(tl("noPermissionSkull"));
-        }
-
-        metaSkull.setDisplayName("§fSkull of " + owner);
-        metaSkull.setOwner(owner);
-
-        itemSkull.setItemMeta(metaSkull);
-
-        if (spawn) {
-            InventoryWorkaround.addItems(user.getBase().getInventory(), itemSkull);
-            user.sendMessage(tl("givenSkull", owner));
-        } else {
-            user.sendMessage(tl("skullChanged", owner));
-        }
-    }
-
-    @Override
-    protected List<String> getTabCompleteOptions(Server server, User user, String commandLabel, String[] args) {
-        if (args.length == 1) {
-            if (user.isAuthorized("essentials.skull.others")) {
-                return getPlayers(server, user);
-            } else {
-                return Lists.newArrayList(user.getName());
-            }
-        } else {
-            return Collections.emptyList();
-        }
-    }
-
-}

Essentials/src/com/earth2me/essentials/commands/Commandspawnmob.java

@@ -1,62 +0,0 @@
-package com.earth2me.essentials.commands;
-
-import com.earth2me.essentials.CommandSource;
-import com.earth2me.essentials.Mob;
-import com.earth2me.essentials.SpawnMob;
-import com.earth2me.essentials.User;
-import com.earth2me.essentials.utils.StringUtil;
-import org.bukkit.Server;
-
-import java.util.List;
-
-import static com.earth2me.essentials.I18n.tl;
-
-
-public class Commandspawnmob extends EssentialsCommand {
-    public Commandspawnmob() {
-        super("spawnmob");
-    }
-
-    @Override
-    public void run(final Server server, final User user, final String commandLabel, final String[] args) throws Exception {
-        if (args.length < 1) {
-            final String mobList = SpawnMob.mobList(user);
-            throw new NotEnoughArgumentsException(tl("mobsAvailable", mobList));
-        }
-
-        List<String> mobParts = SpawnMob.mobParts(args[0]);
-        List<String> mobData = SpawnMob.mobData(args[0]);
-
-        int mobCount = 1;
-        if (args.length >= 2) {
-            mobCount = Integer.parseInt(args[1]);
-        }
-
-        if (mobParts.size() > 1 && !user.isAuthorized("essentials.spawnmob.stack")) {
-            throw new Exception(tl("cannotStackMob"));
-        }
-
-        if (args.length >= 3) {
-            final User target = getPlayer(ess.getServer(), user, args, 2);
-            SpawnMob.spawnmob(ess, server, user.getSource(), target, mobParts, mobData, mobCount);
-            return;
-        }
-
-        SpawnMob.spawnmob(ess, server, user, mobParts, mobData, mobCount);
-    }
-
-    @Override
-    public void run(final Server server, final CommandSource sender, final String commandLabel, final String[] args) throws Exception {
-        if (args.length < 3) {
-            final String mobList = StringUtil.joinList(Mob.getMobList());
-            throw new NotEnoughArgumentsException(tl("mobsAvailable", mobList));
-        }
-
-        List<String> mobParts = SpawnMob.mobParts(args[0]);
-        List<String> mobData = SpawnMob.mobData(args[0]);
-        int mobCount = Integer.parseInt(args[1]);
-
-        final User target = getPlayer(ess.getServer(), args, 2, true, false);
-        SpawnMob.spawnmob(ess, server, sender, target, mobParts, mobData, mobCount);
-    }
-}