fix: update version in main class as well

Add %player_list_name% placeholder

.gitignore

@@ -1,2 +1,151 @@
+### Eclipse ###
+
+.metadata
+bin/
+tmp/
+*.tmp
+*.bak
+*.swp
+*~.nib
+local.properties
+.settings/
+.loadpath
+.recommenders
+
+/.idea/
+
+# External tool builders
+.externalToolBuilders/
+
+# Locally stored "Eclipse launch configurations"
+*.launch
+
+# PyDev specific (Python IDE for Eclipse)
+*.pydevproject
+
+# CDT-specific (C/C++ Development Tooling)
+.cproject
+
+# Java annotation processor (APT)
+.factorypath
+
+# PDT-specific (PHP Development Tools)
+.buildpath
+
+# sbteclipse plugin
+.target
+
+# Tern plugin
+.tern-project
+
+# TeXlipse plugin
+.texlipse
+
+# STS (Spring Tool Suite)
+.springBeans
+
+# Code Recommenders
+.recommenders/
+
+# Scala IDE specific (Scala & Java development for Eclipse)
+.cache-main
+.scala_dependencies
+.worksheet
+
+### Eclipse Patch ###
+# Eclipse Core
+.project
+
+# JDT-specific (Eclipse Java Development Tools)
+.classpath
+
+### Intellij ###
+# Covers JetBrains IDEs: IntelliJ, RubyMine, PhpStorm, AppCode, PyCharm, CLion, Android Studio and Webstorm
+# Reference: https://intellij-support.jetbrains.com/hc/en-us/articles/206544839
+
+# User-specific stuff:
+.idea/**/workspace.xml
+.idea/**/tasks.xml
+.idea/dictionaries
+
+# Sensitive or high-churn files:
+.idea/**/dataSources/
+.idea/**/dataSources.ids
+.idea/**/dataSources.xml
+.idea/**/dataSources.local.xml
+.idea/**/sqlDataSources.xml
+.idea/**/dynamic.xml
+.idea/**/uiDesigner.xml
+
+# Gradle:
+.idea/**/gradle.xml
+.idea/**/libraries
+
+# CMake
+cmake-build-debug/
+
+# Mongo Explorer plugin:
+.idea/**/mongoSettings.xml
+
+## File-based project format:
+*.iws
+
+## Plugin-specific files:
+
+# IntelliJ
+/out/
+
+# mpeltonen/sbt-idea plugin
+.idea_modules/
+
+# JIRA plugin
+atlassian-ide-plugin.xml
+
+# Cursive Clojure plugin
+.idea/replstate.xml
+
+# Ruby plugin and RubyMine
+/.rakeTasks
+
+# Crashlytics plugin (for Android Studio and IntelliJ)
+com_crashlytics_export_strings.xml
+crashlytics.properties
+crashlytics-build.properties
+fabric.properties
+
+### Intellij Patch ###
+# Comment Reason: https://github.com/joeblau/gitignore.io/issues/186#issuecomment-215987721
+
+*.iml
+# modules.xml
+# .idea/misc.xml
+# *.ipr
+
+# Sonarlint plugin
+.idea/sonarlint
+
+### Maven ###
+target/
+pom.xml.tag
+pom.xml.releaseBackup
+pom.xml.versionsBackup
+pom.xml.next
+release.properties
+dependency-reduced-pom.xml
+buildNumber.properties
+.mvn/timing.properties
+
+# Avoid ignoring Maven wrapper jar file (.jar files are usually ignored)
+!/.mvn/wrapper/maven-wrapper.jar
+
+### NetBeans ###
+nbproject/private/
 build/
-out/
+nbbuild/
+dist/
+nbdist/
+.nb-gradle/
+nbactions.xml
+
+### Piggy's Debugging Shit ###
+server/

build.gradle

@@ -1,3 +0,0 @@
-dependencies {
-    compileOnly project(":common")
-}

pom.xml

@@ -0,0 +1,62 @@
+<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>
+
+  <groupId>com.extendedclip.papi.expansion.player</groupId>
+  <artifactId>player-expansion</artifactId>
+  <version>2.0.5</version>
+
+  <name>PAPI-Expansion-Player</name>
+  <description>PlaceholderAPI expansion for player placeholders</description>
+
+    <properties>
+        <maven.compiler.source>1.8</maven.compiler.source>
+        <maven.compiler.target>1.8</maven.compiler.target>
+        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+    </properties>
+
+    <repositories>
+        <repository>
+            <id>spigot-repo</id>
+            <url>https://hub.spigotmc.org/nexus/content/repositories/snapshots/</url>
+        </repository>
+        <repository>
+            <id>placeholderapi</id>
+            <url>https://repo.extendedclip.com/content/repositories/placeholderapi/</url>
+        </repository>
+    </repositories>
+
+
+    <dependencies>
+        <dependency>
+            <groupId>org.spigotmc</groupId>
+            <artifactId>spigot-api</artifactId>
+            <version>1.20-R0.1-SNAPSHOT</version>
+            <scope>provided</scope>
+        </dependency>
+        <dependency>
+         <groupId>me.clip</groupId>
+          <artifactId>placeholderapi</artifactId>
+          <version>2.11.3</version>
+         <scope>provided</scope>
+        </dependency>
+    </dependencies>
+
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-jar-plugin</artifactId>
+                <version>2.3.2</version>
+                <configuration>
+                    <finalName>${project.name}</finalName>
+                    <archive>
+                        <manifest>
+                            <addDefaultImplementationEntries>true</addDefaultImplementationEntries>
+                            <addDefaultSpecificationEntries>true</addDefaultSpecificationEntries>
+                        </manifest>
+                    </archive>
+                </configuration>
+            </plugin>
+        </plugins>
+    </build>
+</project>

src/main/java/at/helpch/placeholderapi/expansion/player/PlayerExpansion.java

@@ -1,49 +0,0 @@
-package at.helpch.placeholderapi.expansion.player;
-
-import at.helpch.placeholderapi.api.expansion.Expansion;
-import at.helpch.placeholderapi.api.expansion.ExpansionDescription;
-import at.helpch.placeholderapi.api.expansion.Platform;
-import at.helpch.placeholderapi.api.expansion.placeholder.Placeholder;
-import at.helpch.placeholderapi.api.expansion.placeholder.PlaceholderContext;
-import at.helpch.placeholderapi.api.player.Player;
-import at.helpch.placeholderapi.api.player.keyable.key.PlayerKeys;
-import at.helpch.placeholderapi.api.server.Server;
-import at.helpch.placeholderapi.expansion.time.TimeFormatter;
-import at.helpch.placeholderapi.expansion.time.file.Config;
-import com.google.inject.Inject;
-import org.jetbrains.annotations.NotNull;
-
-import java.sql.Time;
-import java.util.function.Function;
-
-@ExpansionDescription(
-        name = "Player",
-        version = "2.0.0",
-        identifier = "player",
-        authors = "HelpChat",
-        platforms = {Platform.BUKKIT, Platform.SPONGE, Platform.NUKKIT}
-)
-public final class PlayerExpansion extends Expansion {
-
-    private final TimeFormatter timeFormatter;
-    private final Config config;
-
-    @Inject
-    public PlayerExpansion(@NotNull final Config config) {
-        this.config = config;
-
-        // TODO: instantiate a single TimeFormatted through out the project, with a main config
-        this.timeFormatter = new TimeFormatter(config);
-    }
-
-    @Override
-    public void enable() {
-
-    }
-
-    @Placeholder("name")
-    private String name(final PlaceholderContext context) {
-        return context.getPlayer().get(PlayerKeys.NAME).orElse("");
-    }
-
-}

src/main/java/com/extendedclip/papi/expansion/player/PlayerExpansion.java

@@ -0,0 +1,489 @@
+/*
+ *
+ * Player-Expansion
+ * Copyright (C) 2018 Ryan McCarthy
+ *
+ * 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.extendedclip.papi.expansion.player;
+
+import me.clip.placeholderapi.PlaceholderAPIPlugin;
+import me.clip.placeholderapi.expansion.Configurable;
+import me.clip.placeholderapi.expansion.PlaceholderExpansion;
+import org.bukkit.Bukkit;
+import org.bukkit.ChatColor;
+import org.bukkit.Material;
+import org.bukkit.OfflinePlayer;
+import org.bukkit.World;
+import org.bukkit.enchantments.Enchantment;
+import org.bukkit.entity.Player;
+import org.bukkit.potion.PotionEffectType;
+
+import java.util.*;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+import static com.extendedclip.papi.expansion.player.PlayerUtil.durability;
+import static com.extendedclip.papi.expansion.player.PlayerUtil.format12;
+import static com.extendedclip.papi.expansion.player.PlayerUtil.format24;
+import static com.extendedclip.papi.expansion.player.PlayerUtil.getBiome;
+import static com.extendedclip.papi.expansion.player.PlayerUtil.getCapitalizedBiome;
+import static com.extendedclip.papi.expansion.player.PlayerUtil.getEmptySlots;
+import static com.extendedclip.papi.expansion.player.PlayerUtil.getDirection;
+import static com.extendedclip.papi.expansion.player.PlayerUtil.getTotalExperience;
+import static com.extendedclip.papi.expansion.player.PlayerUtil.getXZDirection;
+import static com.extendedclip.papi.expansion.player.PlayerUtil.itemInHand;
+
+public final class PlayerExpansion extends PlaceholderExpansion implements Configurable {
+    private String low;
+    private String medium;
+    private String high;
+
+    private int mediumValue;
+    private int highValue;
+
+    private String north;
+    private String northEast;
+    private String east;
+    private String southEast;
+    private String south;
+    private String southWest;
+    private String west;
+    private String northWest;
+
+    @Override
+    public String getIdentifier() {
+        return "player";
+    }
+
+    @Override
+    public String getAuthor() {
+        return "clip";
+    }
+
+    @Override
+    public String getVersion() {
+        return "2.0.5";
+    }
+
+    @Override
+    public Map<String, Object> getDefaults() {
+        Map<String, Object> defaults = new HashMap<>();
+        defaults.put("ping_color.high", "&c");
+        defaults.put("ping_color.medium", "&e");
+        defaults.put("ping_color.low", "&a");
+        defaults.put("ping_value.medium", 50);
+        defaults.put("ping_value.high", 100);
+        defaults.put("direction.north", "N");
+        defaults.put("direction.north_east", "NE");
+        defaults.put("direction.east", "E");
+        defaults.put("direction.south_east", "SE");
+        defaults.put("direction.south", "S");
+        defaults.put("direction.south_west", "SW");
+        defaults.put("direction.west", "W");
+        defaults.put("direction.north_west", "NW");
+        return defaults;
+    }
+
+    @Override
+    public String onRequest(OfflinePlayer player, String identifier) {
+
+        final boolean targetedPing = identifier.startsWith("ping_");
+        final boolean targetedColoredPing = identifier.startsWith("colored_ping_");
+        if (targetedPing || targetedColoredPing) {
+            final Player target = Bukkit.getPlayer(identifier.substring(targetedPing ? 5 : 13)); // yes, I know, magic value
+
+            return target == null ? "0" : retrievePing(target, targetedColoredPing);
+        }
+
+        if (player == null) {
+            return "";
+        }
+
+        // offline placeholders
+        switch (identifier) {
+            case "name":
+                return player.getName();
+            case "uuid":
+                return player.getUniqueId().toString();
+            case "has_played_before":
+                return bool(player.hasPlayedBefore());
+            case "online":
+                return bool(player.isOnline());
+            case "is_whitelisted":
+                return bool(player.isWhitelisted());
+            case "is_banned":
+                return bool(player.isBanned());
+            case "is_op":
+                return bool(player.isOp());
+            case "first_played":
+            case "first_join":
+                return String.valueOf(player.getFirstPlayed());
+            case "first_played_formatted":
+            case "first_join_date":
+                return PlaceholderAPIPlugin.getDateFormat().format(new Date(player.getFirstPlayed()));
+            case "last_played":
+            case "last_join":
+                return String.valueOf(player.getLastPlayed());
+            case "last_played_formatted":
+            case "last_join_date":
+                return PlaceholderAPIPlugin.getDateFormat().format(new Date(player.getLastPlayed()));
+            case "bed_x":
+                return player.getBedSpawnLocation() != null ? String.valueOf(player.getBedSpawnLocation().getX()) : "";
+            case "bed_y":
+                return player.getBedSpawnLocation() != null ? String.valueOf(player.getBedSpawnLocation().getY()) : "";
+            case "bed_z":
+                return player.getBedSpawnLocation() != null ? String.valueOf(player.getBedSpawnLocation().getZ()) : "";
+            case "bed_world":
+                return player.getBedSpawnLocation() != null ? player.getBedSpawnLocation().getWorld()
+                        .getName() : "";
+
+        }
+
+        // online placeholders
+        if (!player.isOnline()) {
+            return "";
+        }
+
+        Player p = player.getPlayer();
+
+        // to get rid of IDE warnings
+        if (p == null) {
+            return "";
+        }
+
+        if (identifier.startsWith("has_permission_")) {
+            if (identifier.split("has_permission_").length > 1) {
+                String perm = identifier.split("has_permission_")[1];
+                return bool(p.hasPermission(perm));
+            }
+            return bool(false);
+        }
+
+        if (identifier.startsWith("has_potioneffect_")) {
+            if (identifier.split("has_potioneffect_").length > 1) {
+                String effect = identifier.split("has_potioneffect_")[1];
+                PotionEffectType potion = PotionEffectType.getByName(effect);
+                return bool(p.hasPotionEffect(potion));
+            }
+        }
+
+        if (identifier.startsWith("item_in_hand_level_")) {
+            if (identifier.split("item_in_hand_level_").length > 1) {
+                String enchantment = identifier.split("item_in_hand_level_")[1];
+                return String.valueOf(itemInHand(p).getEnchantmentLevel(Enchantment.getByName(enchantment)));
+            }
+            return "0";
+        }
+        if (identifier.startsWith("item_in_offhand_level_")) {
+            if (identifier.split("item_in_offhand_level_").length > 1) {
+                String enchantment = identifier.split("item_in_offhand_level_")[1];
+                return String.valueOf(p.getInventory().getItemInOffHand().getEnchantmentLevel(Enchantment.getByName(enchantment)));
+            }
+            return "0";
+        }
+
+        if (identifier.startsWith("locale")) {
+            String localeStr = PlayerUtil.getLocale(p);
+            String localeStrISO = localeStr.replace("_", "-");
+
+            switch (identifier) {
+                case "locale":
+                    return localeStr;
+                case "locale_country":
+                    Locale locale = Locale.forLanguageTag(localeStrISO);
+                    if (locale == null)
+                        return "";
+                    return locale.getCountry();
+                case "locale_display_country":
+                    locale = Locale.forLanguageTag(localeStrISO);
+                    if (locale == null)
+                        return "";
+                    return locale.getDisplayCountry();
+                case "locale_display_name":
+                    locale = Locale.forLanguageTag(localeStrISO);
+                    if (locale == null)
+                        return "";
+                    return locale.getDisplayName();
+                case "locale_short":
+                    return localeStr.substring(0, localeStr.indexOf("_"));
+            }
+        }
+
+        switch (identifier) {
+            case "absorption": {
+                if (VersionHelper.HAS_ABSORPTION_METHODS) {
+                    return Integer.toString((int) p.getAbsorptionAmount());
+                } else {
+                    return "-1";
+                }
+            }
+            case "has_empty_slot":
+                return bool(p.getInventory().firstEmpty() > -1);
+            case "empty_slots":
+                return String.valueOf(getEmptySlots(p));
+            case "server":
+            case "servername":
+                return "now available in the server expansion";
+            case "displayname":
+                return p.getDisplayName();
+            case "list_name":
+                return p.getPlayerListName();
+            case "gamemode":
+                return p.getGameMode().name();
+            case "direction":
+                switch (getDirection(p)) {
+                    case NORTH:
+                        return north;
+                    case NORTH_EAST:
+                        return northEast;
+                    case EAST:
+                        return east;
+                    case SOUTH_EAST:
+                        return southEast;
+                    case SOUTH:
+                        return south;
+                    case SOUTH_WEST:
+                        return southWest;
+                    case WEST:
+                        return west;
+                    case NORTH_WEST:
+                        return northWest;
+                }
+                return "";
+            case "direction_xz":
+                return getXZDirection(p);
+            case "world":
+                return p.getWorld().getName();
+            case "world_type":
+                World.Environment environment = p.getWorld().getEnvironment();
+                if (environment == World.Environment.NETHER) {
+                    return "Nether";
+                } else if (environment == World.Environment.THE_END) {
+                    return "The End";
+                } else if (environment == World.Environment.NORMAL) {
+                    return "Overworld";
+                }
+                return "";
+            case "x":
+                return String.valueOf(p.getLocation().getBlockX());
+            case "x_long":
+                return String.valueOf(p.getLocation().getX());
+            case "y":
+                return String.valueOf(p.getLocation().getBlockY());
+            case "y_long":
+                return String.valueOf(p.getLocation().getY());
+            case "z":
+                return String.valueOf(p.getLocation().getBlockZ());
+            case "z_long":
+                return String.valueOf(p.getLocation().getZ());
+            case "yaw":
+                return String.valueOf(p.getLocation().getYaw());
+            case "pitch":
+                return String.valueOf(p.getLocation().getPitch());
+            case "biome":
+                return getBiome(p);
+            case "biome_capitalized":
+                return getCapitalizedBiome(p);
+            case "light_level":
+                return String.valueOf(p.getLocation().getBlock().getLightLevel());
+            case "ip":
+                return p.getAddress().getAddress().getHostAddress();
+            case "allow_flight":
+                return bool(p.getAllowFlight());
+            case "can_pickup_items":
+                return bool(p.getCanPickupItems());
+            case "compass_x":
+                return p.getCompassTarget() != null ? String.valueOf(p.getCompassTarget().getBlockX()) : "";
+            case "compass_y":
+                return p.getCompassTarget() != null ? String.valueOf(p.getCompassTarget().getBlockY()) : "";
+            case "compass_z":
+                return p.getCompassTarget() != null ? String.valueOf(p.getCompassTarget().getBlockZ()) : "";
+            case "compass_world":
+                return p.getCompassTarget() != null ? p.getCompassTarget().getWorld().getName() : "";
+            case "block_underneath":
+                return String.valueOf(p.getLocation().clone().subtract(0, 1, 0).getBlock().getType());
+            case "custom_name":
+                return p.getCustomName() != null ? p.getCustomName() : p.getName();
+            case "exp":
+                return String.valueOf(p.getExp());
+            case "current_exp":
+                return String.valueOf(getTotalExperience(p));
+            case "total_exp":
+                return String.valueOf(p.getTotalExperience());
+            case "exp_to_level":
+                return String.valueOf(p.getExpToLevel());
+            case "level":
+                return String.valueOf(p.getLevel());
+            case "fly_speed":
+                return String.valueOf(p.getFlySpeed());
+            case "food_level":
+                return String.valueOf(p.getFoodLevel());
+            case "health":
+                return String.valueOf(p.getHealth());
+            case "health_rounded":
+                return String.valueOf(Math.round(p.getHealth()));
+            case "health_scale":
+                return String.valueOf(p.getHealthScale());
+            case "has_health_boost":
+                return bool(p.hasPotionEffect(PotionEffectType.HEALTH_BOOST));
+            case "health_boost": {
+                if (p.getHealthScale() > 20) {
+                    return Double.toString(p.getHealthScale() - 20);
+                } else {
+                    return "0";
+                }
+            }
+            case "item_in_hand":
+                return String.valueOf(itemInHand(p).getType());
+            case "item_in_hand_name":
+                return itemInHand(p).getType() != Material.AIR && itemInHand(p).getItemMeta().hasDisplayName() ? itemInHand(p).getItemMeta().getDisplayName() : "";
+            case "item_in_hand_data":
+                return itemInHand(p).getType() != Material.AIR ? String.valueOf(itemInHand(p).getDurability()) : "0";
+            case "item_in_hand_durability":
+                return String.valueOf(durability(itemInHand(p)));
+            case "item_in_offhand":
+                return String.valueOf(p.getInventory().getItemInOffHand().getType());
+            case "item_in_offhand_name":
+                return p.getInventory().getItemInOffHand().getType() != Material.AIR && p.getInventory().getItemInOffHand().getItemMeta().hasDisplayName() ? p.getInventory().getItemInOffHand().getItemMeta().getDisplayName() : "";
+            case "item_in_offhand_data":
+                return p.getInventory().getItemInOffHand().getType() != Material.AIR ? String.valueOf(p.getInventory().getItemInOffHand().getDurability()) : "0";
+            case "item_in_offhand_durability":
+                return String.valueOf(durability(p.getInventory().getItemInOffHand()));
+            case "last_damage":
+                return String.valueOf(p.getLastDamage());
+            case "max_health":
+                return String.valueOf(p.getMaxHealth());
+            case "max_health_rounded":
+                return String.valueOf(Math.round(p.getMaxHealth()));
+            case "max_air":
+                return String.valueOf(p.getMaximumAir());
+            case "max_no_damage_ticks":
+                return String.valueOf(p.getMaximumNoDamageTicks());
+            case "no_damage_ticks":
+                return String.valueOf(p.getNoDamageTicks());
+            case "armor_helmet_name":
+                return Optional.ofNullable(p.getInventory().getHelmet()).map(a -> a.getItemMeta().getDisplayName()).orElse("");
+            case "armor_helmet_data":
+                return p.getInventory().getHelmet() != null ? String.valueOf(p.getInventory().getHelmet().getDurability()) : "0";
+            case "armor_helmet_durability":
+                return String.valueOf(durability(p.getInventory().getHelmet()));
+            case "armor_chestplate_name":
+                return Optional.ofNullable(p.getInventory().getChestplate()).map(a -> a.getItemMeta().getDisplayName()).orElse("");
+            case "armor_chestplate_data":
+                return p.getInventory().getChestplate() != null ? String.valueOf(p.getInventory().getChestplate().getDurability()) : "0";
+            case "armor_chestplate_durability":
+                return String.valueOf(durability(p.getInventory().getChestplate()));
+            case "armor_leggings_name":
+                return Optional.ofNullable(p.getInventory().getLeggings()).map(a -> a.getItemMeta().getDisplayName()).orElse("");
+            case "armor_leggings_data":
+                return p.getInventory().getLeggings() != null ? String.valueOf(p.getInventory().getLeggings().getDurability()) : "0";
+            case "armor_leggings_durability":
+                return String.valueOf(durability(p.getInventory().getLeggings()));
+            case "armor_boots_name":
+                return Optional.ofNullable(p.getInventory().getBoots()).map(a -> a.getItemMeta().getDisplayName()).orElse("");
+            case "armor_boots_data":
+                return p.getInventory().getBoots() != null ? String.valueOf(p.getInventory().getBoots().getDurability()) : "0";
+            case "armor_boots_durability":
+                return String.valueOf(durability(p.getInventory().getBoots()));
+            case "ping":
+                return retrievePing(p, false);
+            case "colored_ping":
+                return retrievePing(p, true);
+            case "time":
+                return String.valueOf(p.getPlayerTime());
+            case "time_offset":
+                return String.valueOf(p.getPlayerTimeOffset());
+            case "remaining_air":
+                return String.valueOf(p.getRemainingAir());
+            case "saturation":
+                return String.valueOf(p.getSaturation());
+            case "sleep_ticks":
+                return String.valueOf(p.getSleepTicks());
+            case "thunder_duration":
+                return String.valueOf(p.getWorld().getThunderDuration());
+            case "ticks_lived":
+                return String.valueOf(p.getTicksLived());
+            case "seconds_lived":
+                return String.valueOf(p.getTicksLived() / 20);
+            case "minutes_lived":
+                return String.valueOf((p.getTicksLived() / 20) / 60);
+            case "walk_speed":
+                return String.valueOf(p.getWalkSpeed());
+            case "weather_duration":
+                return String.valueOf(p.getWorld().getWeatherDuration());
+            case "world_time":
+                return String.valueOf(p.getWorld().getTime());
+            case "world_time_12":
+                return format12(p.getWorld().getTime());
+            case "world_time_24":
+                return format24(p.getWorld().getTime());
+            case "is_flying":
+                return bool(p.isFlying());
+            case "is_sleeping":
+                return bool(p.isSleeping());
+            case "is_conversing":
+                return bool(p.isConversing());
+            case "is_dead":
+                return bool(p.isDead());
+            case "is_sneaking":
+                return bool(p.isSneaking());
+            case "is_sprinting":
+                return bool(p.isSprinting());
+            case "is_leashed":
+                return bool(p.isLeashed());
+            case "is_inside_vehicle":
+                return bool(p.isInsideVehicle());
+        }
+        // return null for unknown placeholders
+        return null;
+    }
+
+    @Override
+    public boolean register() {
+        low = this.getString("ping_color.low", "&a");
+        medium = this.getString("ping_color.medium", "&e");
+        high = this.getString("ping_color.high", "&c");
+        mediumValue = this.getInt("ping_value.medium", 50);
+        highValue = this.getInt("ping_value.high", 100);
+        north = this.getString("direction.north", "N");
+        northEast = this.getString("direction.north_east", "NE");
+        east = this.getString("direction.east", "E");
+        southEast = this.getString("direction.south_east", "SE");
+        south = this.getString("direction.south", "S");
+        southWest = this.getString("direction.south_west", "SW");
+        west = this.getString("direction.west", "W");
+        northWest = this.getString("direction.north_west", "NW");
+
+
+        return super.register();
+    }
+
+    public String bool(boolean b) {
+        return b ? PlaceholderAPIPlugin.booleanTrue() : PlaceholderAPIPlugin.booleanFalse();
+    }
+
+
+    private String retrievePing(final Player player, final boolean colored) {
+        final int ping = PlayerUtil.getPing(player);
+        if (!colored) {
+            return String.valueOf(ping);
+        }
+
+        return ChatColor.translateAlternateColorCodes('&', ping > highValue ? high : ping > mediumValue ? medium : low) + ping;
+    }
+
+}

src/main/java/com/extendedclip/papi/expansion/player/PlayerUtil.java

@@ -0,0 +1,247 @@
+package com.extendedclip.papi.expansion.player;
+
+import org.bukkit.Bukkit;
+import org.bukkit.Material;
+import org.bukkit.block.BlockFace;
+import org.bukkit.entity.Player;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.inventory.PlayerInventory;
+
+import java.lang.reflect.Field;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.text.ParseException;
+import java.text.SimpleDateFormat;
+import java.util.Locale;
+import java.util.function.Function;
+
+/*
+ *
+ * Player-Expansion
+ * Copyright (C) 2018 Ryan McCarthy
+ *
+ * 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/>.
+ *
+ *
+ */
+public final class PlayerUtil {
+
+    public static final int ticksAtMidnight = 18000;
+    public static final int ticksPerDay = 24000;
+    public static final int ticksPerHour = 1000;
+    public static final double ticksPerMinute = 1000d / 60d;
+    private static final SimpleDateFormat twentyFour = new SimpleDateFormat("HH:mm", Locale.ENGLISH);
+    private static final SimpleDateFormat twelve = new SimpleDateFormat("h:mm aa", Locale.ENGLISH);
+    private static final BlockFace[] radial = { BlockFace.NORTH, BlockFace.NORTH_EAST, BlockFace.EAST, BlockFace.SOUTH_EAST, BlockFace.SOUTH, BlockFace.SOUTH_WEST, BlockFace.WEST, BlockFace.NORTH_WEST };
+
+    private PlayerUtil() { }
+
+    private static final Function<Player, Integer> PLAYER_GET_PING = new Function<Player, Integer>() {
+
+        private Field ping;
+        private Method getHandle;
+
+        @Override
+        public Integer apply(final Player player) {
+            if (ping == null) {
+                try {
+                    cacheReflection(player);
+                } catch (InvocationTargetException | NoSuchMethodException | IllegalAccessException | NoSuchFieldException ex) {
+                    ex.printStackTrace();
+                }
+            }
+
+            try {
+                return ping.getInt(getHandle.invoke(player));
+            } catch (final IllegalAccessException | InvocationTargetException ex) {
+                ex.printStackTrace();
+            }
+            return -1;
+        }
+
+
+        private void cacheReflection(final Player player) throws NoSuchFieldException, NoSuchMethodException, InvocationTargetException, IllegalAccessException {
+            getHandle = player.getClass().getDeclaredMethod("getHandle");
+            getHandle.setAccessible(true);
+
+            final Object entityPlayer = getHandle.invoke(player);
+
+            String pingFieldName;
+            if (VersionHelper.IS_1_20_OR_NEWER) {
+                pingFieldName = "f";
+            } else if (VersionHelper.IS_1_17_OR_NEWER) {
+                pingFieldName = "e";
+            } else {
+                pingFieldName = "ping";
+            }
+
+            ping = entityPlayer.getClass().getDeclaredField(pingFieldName);
+            ping.setAccessible(true);
+        }
+    };
+
+    private static final Function<Player, String> PLAYER_GET_LOCALE = new Function<Player, String>() {
+
+        private Field locale;
+        private Method getHandle;
+
+        @Override
+        public String apply(final Player player) {
+            if (locale == null) {
+                try {
+                    cacheReflection(player);
+                } catch (InvocationTargetException | NoSuchMethodException | IllegalAccessException | NoSuchFieldException ex) {
+                    ex.printStackTrace();
+                }
+            }
+
+            try {
+                final Object entityPlayer = getHandle.invoke(player);
+                return (String) locale.get(entityPlayer);
+            } catch (final IllegalAccessException | InvocationTargetException ex) {
+                ex.printStackTrace();
+            }
+            return "en_US";
+        }
+
+
+        private void cacheReflection(final Player player) throws NoSuchFieldException, NoSuchMethodException, InvocationTargetException, IllegalAccessException {
+            getHandle = player.getClass().getDeclaredMethod("getHandle");
+            getHandle.setAccessible(true);
+
+            final Object entityPlayer = getHandle.invoke(player);
+
+            locale = entityPlayer.getClass().getField("locale");
+        }
+    };
+
+
+    public static int getPing(final Player player) {
+        return PLAYER_GET_PING.apply(player);
+    }
+
+    public static String getLocale(final Player player) {
+        return PLAYER_GET_LOCALE.apply(player);
+    }
+
+    public static String format12(long ticks) {
+        try {
+            return twelve.format(twentyFour.parse(ticksToTime(ticks)));
+        } catch (ParseException e) {
+            return ticksToTime(ticks);
+        }
+    }
+
+    public static String format24(long ticks) {
+        return ticksToTime(ticks);
+    }
+
+    private static String ticksToTime(long ticks) {
+        ticks = ticks - ticksAtMidnight + ticksPerDay;
+        long hours = ticks / ticksPerHour;
+        ticks -= hours * ticksPerHour;
+        long mins = (long) Math.floor(ticks / ticksPerMinute);
+        if (hours >= 24) {
+            hours = hours - 24;
+        }
+        return (hours < 10 ? "0" + hours : hours) + ":" + (mins < 10 ? "0" + mins : mins);
+    }
+
+    public static BlockFace getDirection(Player player) {
+        return radial[Math.round(player.getLocation().getYaw() / 45f) & 0x7].getOppositeFace();
+    }
+
+    public static String getXZDirection(Player player) {
+        double rotation = player.getLocation().getYaw();
+        if (rotation < 0.0D) {
+            rotation += 360.0D;
+        }
+
+        if (Math.abs(rotation) <= 45 || Math.abs(rotation - 360) <= 45) {
+            return "+Z";
+        } else if (Math.abs(rotation - 90) <= 45) {
+            return "-X";
+        } else if (Math.abs(rotation - 180) <= 45) {
+            return "-Z";
+        } else if (Math.abs(rotation - 270) <= 45) {
+            return "+X";
+        }
+
+        return "";
+    }
+
+    public static ItemStack itemInHand(Player p) {
+        try {
+            return p.getInventory().getItemInMainHand();
+        } catch (NoSuchMethodError e) {
+            return p.getInventory().getItemInHand();
+        }
+    }
+
+    public static int durability(ItemStack item) {
+        return item != null ? item.getType().getMaxDurability() - item.getDurability() : 0;
+    }
+
+    public static int getEmptySlots(Player p) {
+        int slots = 0;
+        PlayerInventory inv = p.getInventory();
+        for (ItemStack is : inv.getContents()) {
+            if (is == null) slots++;
+        }
+
+        if (!Bukkit.getBukkitVersion().contains("1.7") && !Bukkit.getBukkitVersion().contains("1.8")) {
+            if (inv.getItemInOffHand() == null || inv.getItemInOffHand().getType() == Material.AIR) slots--;
+            if (inv.getHelmet() == null) slots--;
+            if (inv.getChestplate() == null) slots--;
+            if (inv.getLeggings() == null) slots--;
+            if (inv.getBoots() == null) slots--;
+        }
+        return slots;
+    }
+
+    private static int getExperienceAtLevel(int level) {
+        if (level <= 15) {
+            return (level << 1) + 7;
+        }
+        if (level <= 30) {
+            return (level * 5) - 38;
+        }
+        return (level * 9) - 158;
+    }
+
+    public static int getTotalExperience(Player player) {
+        int experience = Math.round(getExperienceAtLevel(player.getLevel()) * player.getExp());
+        int currentLevel = player.getLevel();
+        while (currentLevel > 0) {
+            currentLevel--;
+            experience += getExperienceAtLevel(currentLevel);
+        }
+        if (experience < 0) {
+            experience = 0;
+        }
+        return experience;
+    }
+
+    public static String getBiome(Player p) {
+        return String.valueOf(p.getLocation().getBlock().getBiome());
+    }
+
+    public static String getCapitalizedBiome(Player p) {
+        String[] biomeWords = getBiome(p).split("_");
+        for (int i = 0; i < biomeWords.length; i++) {
+            biomeWords[i] = biomeWords[i].substring(0, 1).toUpperCase() + biomeWords[i].substring(1).toLowerCase();
+        }
+        return String.join(" ", biomeWords);
+    }
+}

src/main/java/com/extendedclip/papi/expansion/player/VersionHelper.java

@@ -0,0 +1,57 @@
+package com.extendedclip.papi.expansion.player;
+
+import com.google.common.primitives.Ints;
+import org.bukkit.Bukkit;
+
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+/**
+ * @author Matt (<a href="https://github.com/ipsk">@ipsk</a>)
+ */
+public final class VersionHelper {
+
+    private static final int VERSION = getCurrentVersion();
+
+    /**
+     * <a href="https://docs.docdex.helpch.at/1.15/org/bukkit/entity/Damageable.html#getAbsorptionAmount--">
+     * Damageable#getAbsorptionAmount
+     * </a>
+     */
+    public static final boolean HAS_ABSORPTION_METHODS = VERSION >= 1_15_0;
+
+    public static final boolean IS_1_17_OR_NEWER = VERSION >= 1_17_0;
+
+    public static final boolean IS_1_20_OR_NEWER = VERSION >= 1_20_0;
+
+    private VersionHelper() { }
+
+    /**
+     * Gets the current server version
+     *
+     * @return A protocol like number representing the version, for example 1.16.5 - 1165
+     */
+    private static int getCurrentVersion() {
+        // No need to cache since will only run once
+        final Matcher matcher = Pattern.compile("(?<version>\\d+\\.\\d+)(?<patch>\\.\\d+)?").matcher(Bukkit.getBukkitVersion());
+        final StringBuilder stringBuilder = new StringBuilder();
+
+        if (matcher.find()) {
+            final String patch = matcher.group("patch");
+
+            stringBuilder
+                    .append(matcher.group("version").replace(".", ""))
+                    .append((patch == null) ? "0" : patch.replace(".", ""));
+        }
+
+        final Integer version = Ints.tryParse(stringBuilder.toString());
+
+        // Should never fail
+        if (version == null) {
+            throw new IllegalArgumentException("Could not retrieve server version!");
+        }
+
+        return version;
+    }
+
+}