updated pom to define compiler settings in properties, updated spigot and papi dependencies, updated spigot dependency to be provided

.gitignore

@@ -12,8 +12,6 @@ local.properties
 .loadpath
 .recommenders
 
-/.idea/
-
 # External tool builders
 .externalToolBuilders/
 
@@ -116,7 +114,7 @@ fabric.properties
 ### Intellij Patch ###
 # Comment Reason: https://github.com/joeblau/gitignore.io/issues/186#issuecomment-215987721
 
-*.iml
+# *.iml
 # modules.xml
 # .idea/misc.xml
 # *.ipr
@@ -124,22 +122,6 @@ fabric.properties
 # Sonarlint plugin
 .idea/sonarlint
 
-### VS Code ###
-.vscode/
-
-### Gradle ###
-.gradle/
-gradle-app.setting
-!gradle/wrapper/gradle-wrapper.jar
-!gradle/wrapper/gradle-wrapper.properties
-
-### OS/Logs ###
-*.log
-hs_err_pid*
-Thumbs.db
-Desktop.ini
-.DS_Store
-
 ### Maven ###
 target/
 pom.xml.tag
@@ -161,14 +143,4 @@ nbbuild/
 dist/
 nbdist/
 .nb-gradle/
-nbactions.xml
-
-### Piggy's Debugging Shit ###
-server/
-gradlew.bat
-gradlew
-gradle/wrapper/gradle-wrapper.jar
-libs/HytaleServer.jar
-libs/papiHytale.jar
-
-gradle/wrapper/gradle-wrapper.properties
+nbactions.xml

build.gradle

@@ -1,46 +0,0 @@
-plugins {
-    id 'java'
-}
-
-group = 'at.helpch.papi.expansion.player'
-version = '1.0.5'
-description = 'PlaceholderAPI expansion for Hytale player placeholders'
-
-repositories {
-    mavenCentral()
-    mavenLocal()
-
-    maven {
-        url = uri("https://repo.codemc.io/repository/hytale/")
-    }
-
-    maven {
-        url = uri("https://repo.helpch.at/releases")
-    }
-}
-
-java {
-    sourceCompatibility = JavaVersion.VERSION_1_8
-    targetCompatibility = JavaVersion.VERSION_1_8
-    withSourcesJar()
-}
-
-
-dependencies {
-    compileOnly("com.hypixel.hytale:Server:2026.01.17-4b0f30090")
-    compileOnly("at.helpch:placeholderapi-hytale:1.0.0")
-}
-
-tasks.withType(JavaCompile).configureEach {
-    options.encoding = 'UTF-8'
-}
-
-tasks.named('jar') {
-    archiveBaseName.set('PAPI-Expansion-Player')
-    manifest {
-        attributes(
-            'Implementation-Title': project.name,
-            'Implementation-Version': project.version
-        )
-    }
-}

pom.xml

@@ -0,0 +1,65 @@
+<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>1.7.2</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>http://repo.extendedclip.com/content/repositories/placeholderapi/</url>
+        </repository>
+    </repositories>
+
+
+    <dependencies>
+        <dependency>
+            <groupId>org.spigotmc</groupId>
+            <artifactId>spigot-api</artifactId>
+            <version>1.16.1-R0.1-SNAPSHOT</version>
+            <scope>provided</scope>
+        </dependency>
+        <dependency>
+            <groupId>me.clip</groupId>
+            <artifactId>placeholderapi</artifactId>
+            <version>2.10.6</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>${name}</finalName>
+                    <archive>
+                        <manifest>
+                            <addDefaultImplementationEntries>true</addDefaultImplementationEntries>
+                            <addDefaultSpecificationEntries>true</addDefaultSpecificationEntries>
+                        </manifest>
+                    </archive>
+                </configuration>
+            </plugin>
+        </plugins>
+    </build>
+</project>

settings.gradle

@@ -1 +0,0 @@
-rootProject.name = 'hyplayer-expansion'

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

@@ -1,203 +0,0 @@
-package at.helpch.papi.expansion.player;
-
-import at.helpch.placeholderapi.PlaceholderAPIPlugin;
-import at.helpch.placeholderapi.expansion.PlaceholderExpansion;
-import com.hypixel.hytale.component.Ref;
-import com.hypixel.hytale.component.Store;
-import com.hypixel.hytale.server.core.entity.entities.Player;
-import com.hypixel.hytale.server.core.modules.entitystats.EntityStatMap;
-import com.hypixel.hytale.server.core.modules.entitystats.asset.DefaultEntityStatTypes;
-import com.hypixel.hytale.server.core.universe.PlayerRef;
-import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
-import com.hypixel.hytale.server.core.universe.world.worldgen.provider.IWorldGenProvider;
-import java.lang.reflect.Field;
-import java.lang.reflect.Method;
-
-public final class PlayerExpansion extends PlaceholderExpansion {
-  public String getIdentifier() {
-    return "Player";
-  }
-
-  public String getAuthor() {
-    return "HelpChat";
-  }
-
-  public String getVersion() {
-    return "1.0.5";
-  }
-
-  public String onPlaceholderRequest(PlayerRef player, String identifier) {
-    if (player == null)
-      return "";
-
-    switch (identifier) {
-      case "uuid":
-        return player.getUuid().toString();
-      case "username":
-        return player.getUsername();
-      case "language":
-        return player.getLanguage();
-      case "world_uuid":
-        return player.getWorldUuid().toString();
-      case "x":
-        return String.valueOf(player.getTransform().getPosition().getX());
-      case "y":
-        return String.valueOf(player.getTransform().getPosition().getY());
-      case "z":
-        return String.valueOf(player.getTransform().getPosition().getZ());
-      case "yaw":
-        return String.valueOf(player.getHeadRotation().getYaw());
-      case "pitch":
-        return String.valueOf(player.getHeadRotation().getPitch());
-    }
-
-    Ref<EntityStore> ref = player.getReference();
-
-    if (ref == null || !ref.isValid())
-      return null;
-
-    Store<EntityStore> store = ref.getStore();
-    Player p = (Player) store.getComponent(ref, Player.getComponentType());
-    EntityStatMap stats = (EntityStatMap) store.getComponent(ref, EntityStatMap.getComponentType());
-
-    if (p == null)
-      return null;
-
-    switch (identifier) {
-      case "has_played_before":
-        return bool(!p.isFirstSpawn());
-      case "name":
-        return p.getDisplayName();
-      case "gamemode":
-        return p.getGameMode().name();
-      case "world":
-        return p.getWorld().getName();
-      case "world_displayname":
-        String displayName = p.getWorld().getWorldConfig().getDisplayName();
-        if (displayName == null) {
-          return p.getWorld().getName();
-        }
-        return displayName;
-      case "world_worldgen_type":
-        return worldGenType(p.getWorld().getWorldConfig().getWorldGenProvider());
-      case "world_worldgen_name":
-        return worldGenName(p.getWorld().getWorldConfig().getWorldGenProvider());
-      case "biome":
-        return p.getWorldMapTracker().getCurrentBiomeName();
-      case "item_in_hand":
-        return String.valueOf(p.getInventory().getActiveHotbarItem().getItemId());
-      case "item_in_hand_quantity":
-        return String.valueOf(p.getInventory().getActiveHotbarItem().getQuantity());
-      case "item_in_hand_durability":
-        return String.valueOf(p.getInventory().getActiveHotbarItem().getDurability());
-      case "item_in_hand_broken":
-        return bool(p.getInventory().getActiveHotbarItem().isBroken());
-      case "item_in_hand_unbreakable":
-        return bool(p.getInventory().getActiveHotbarItem().isUnbreakable());
-      case "current_fall_distance":
-        return String.valueOf(p.getCurrentFallDistance());
-      case "view_radius":
-        return String.valueOf(p.getViewRadius());
-      case "client_view_radius":
-        return String.valueOf(p.getClientViewRadius());
-      case "since_last_spawn_nanos":
-        return String.valueOf(p.getSinceLastSpawnNanos());
-      case "mount_entity_id":
-        return String.valueOf(p.getMountEntityId());
-      case "is_collidable":
-        return bool(p.isCollidable());
-      case "health":
-        return String.valueOf(stats.get(DefaultEntityStatTypes.getHealth()).get());
-      case "health_max":
-        return String.valueOf(stats.get(DefaultEntityStatTypes.getHealth()).getMax());
-      case "health_min":
-        return String.valueOf(stats.get(DefaultEntityStatTypes.getHealth()).getMin());
-      case "ammo":
-        return String.valueOf(stats.get(DefaultEntityStatTypes.getAmmo()).get());
-      case "ammo_max":
-        return String.valueOf(stats.get(DefaultEntityStatTypes.getAmmo()).getMax());
-      case "ammo_min":
-        return String.valueOf(stats.get(DefaultEntityStatTypes.getAmmo()).getMin());
-      case "stamina":
-        return String.valueOf(stats.get(DefaultEntityStatTypes.getStamina()).get());
-      case "stamina_max":
-        return String.valueOf(stats.get(DefaultEntityStatTypes.getStamina()).getMax());
-      case "stamina_min":
-        return String.valueOf(stats.get(DefaultEntityStatTypes.getStamina()).getMin());
-      case "mana":
-        return String.valueOf(stats.get(DefaultEntityStatTypes.getMana()).get());
-      case "mana_max":
-        return String.valueOf(stats.get(DefaultEntityStatTypes.getMana()).getMax());
-      case "mana_min":
-        return String.valueOf(stats.get(DefaultEntityStatTypes.getMana()).getMin());
-      case "oxygen":
-        return String.valueOf(stats.get(DefaultEntityStatTypes.getOxygen()).get());
-      case "oxygen_max":
-        return String.valueOf(stats.get(DefaultEntityStatTypes.getOxygen()).getMax());
-      case "oxygen_min":
-        return String.valueOf(stats.get(DefaultEntityStatTypes.getOxygen()).getMin());
-      case "signature_energy":
-        return String.valueOf(stats.get(DefaultEntityStatTypes.getSignatureEnergy()).get());
-      case "signature_energy_max":
-        return String.valueOf(stats.get(DefaultEntityStatTypes.getSignatureEnergy()).getMax());
-      case "signature_energy_min":
-        return String.valueOf(stats.get(DefaultEntityStatTypes.getSignatureEnergy()).getMin());
-    }
-    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);
-    }
-    return null;
-  }
-
-  public String bool(boolean b) {
-    return b ? PlaceholderAPIPlugin.instance().configManager().config().booleanValue().trueValue()
-        : PlaceholderAPIPlugin.instance().configManager().config().booleanValue().falseValue();
-  }
-
-  private String worldGenType(IWorldGenProvider provider) {
-    if (provider == null)
-      return null;
-
-    try {
-      Field idField = provider.getClass().getField("ID");
-      Object id = idField.get(null);
-      if (id instanceof String)
-        return (String) id;
-    } catch (Exception ignored) {
-    }
-
-    String simpleName = provider.getClass().getSimpleName();
-    if (simpleName.endsWith("WorldGenProvider"))
-      return simpleName.substring(0, simpleName.length() - "WorldGenProvider".length());
-
-    return simpleName;
-  }
-
-  private String worldGenName(IWorldGenProvider provider) {
-    if (provider == null)
-      return null;
-
-    try {
-      Method getName = provider.getClass().getMethod("getName");
-      Object value = getName.invoke(provider);
-      if (value instanceof String)
-        return (String) value;
-    } catch (Exception ignored) {
-    }
-
-    try {
-      Field nameField = provider.getClass().getDeclaredField("name");
-      nameField.setAccessible(true);
-      Object value = nameField.get(provider);
-      if (value instanceof String)
-        return (String) value;
-    } catch (Exception ignored) {
-    }
-
-    return null;
-  }
-}

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

@@ -0,0 +1,315 @@
+/*
+ *
+ * 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 java.util.HashMap;
+import java.util.Map;
+import java.util.Optional;
+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.enchantments.Enchantment;
+import org.bukkit.entity.Player;
+
+import java.util.Date;
+
+import static com.extendedclip.papi.expansion.player.PlayerUtil.*;
+
+public class PlayerExpansion extends PlaceholderExpansion implements Configurable {
+
+    private final String VERSION = getClass().getPackage().getImplementationVersion();
+
+    private String low, medium, high;
+
+    @Override
+    public String getIdentifier() {
+        return "player";
+    }
+
+    @Override
+    public String getAuthor() {
+        return "clip";
+    }
+
+    @Override
+    public String getVersion() {
+        return VERSION;
+    }
+
+    @Override
+    public Map<String, Object> getDefaults() {
+        Map<String, Object> defaults = new HashMap<>();
+        defaults.put("ping_color.high", "&a");
+        defaults.put("ping_color.medium", "&e");
+        defaults.put("ping_color.low", "&c");
+        return defaults;
+    }
+
+    public String onRequest(OfflinePlayer player, String identifier) {
+        high = this.getString("ping_color.high", "&a");
+        medium = this.getString("ping_color.medium", "&e");
+        low = this.getString("ping_color.low", "&c");
+
+        if (identifier.startsWith("ping_")) {
+            if (identifier.split("ping_").length > 1) {
+                identifier = identifier.split("ping_")[1];
+                Player t = Bukkit.getPlayer(identifier);
+                if (t != null) {
+                    return getPing(t);
+                }
+            }
+            return "0";
+        }
+        if (identifier.startsWith("colored_ping_")) {
+            if (identifier.split("colored_ping_").length > 1) {
+                identifier = identifier.split("colored_ping_")[1];
+                Player t = Bukkit.getPlayer(identifier);
+                if (t != null) {
+                    int p = Integer.valueOf(getPing(t));
+                    return ChatColor.translateAlternateColorCodes('&', p > 100 ? low : p >= 50 ? medium : high) + getPing(t);
+                }
+            }
+            return "0";
+        }
+
+        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();
+
+        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("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";
+        }
+
+        switch (identifier) {
+            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 "locale":
+                return p.getLocale();
+            case "gamemode":
+                return p.getGameMode().name();
+            case "direction":
+                return getCardinalDirection(p);
+            case "world":
+                return p.getWorld().getName();
+            case "x":
+                return String.valueOf(p.getLocation().getBlockX());
+            case "y":
+                return String.valueOf(p.getLocation().getBlockY());
+            case "z":
+                return String.valueOf(p.getLocation().getBlockZ());
+            case "biome":
+                return String.valueOf(p.getLocation().getBlock().getBiome());
+            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 "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 "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_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 "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_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_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_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 "ping":
+                return getPing(p);
+            case "colored_ping":
+                int ping = Integer.valueOf(getPing(p));
+                return ChatColor.translateAlternateColorCodes('&', ping > 100 ? low : ping >= 50 ? medium : high) + getPing(p);
+            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());
+        }
+        // return null for unknown placeholders
+        return null;
+    }
+
+    public String bool(boolean b) {
+        return b ? PlaceholderAPIPlugin.booleanTrue() : PlaceholderAPIPlugin.booleanFalse();
+    }
+
+}

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

@@ -0,0 +1,162 @@
+package com.extendedclip.papi.expansion.player;
+
+import org.bukkit.Bukkit;
+import org.bukkit.Material;
+import org.bukkit.entity.Player;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.inventory.PlayerInventory;
+
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.text.ParseException;
+import java.text.SimpleDateFormat;
+import java.util.Locale;
+
+/*
+ *
+ * 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 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;
+  public static final double ticksPerSecond = 1000d / 60d / 60d;
+  private static final SimpleDateFormat twentyFour = new SimpleDateFormat("HH:mm", Locale.ENGLISH);
+  private static final SimpleDateFormat twelve = new SimpleDateFormat("h:mm aa", Locale.ENGLISH);
+
+  public static String getPing(Player p) {
+    try {
+      Method getHandleMethod = p.getClass().getDeclaredMethod("getHandle", new Class[0]);
+      Object nmsplayer = getHandleMethod.invoke(p, new Object[0]);
+      Field pingField = nmsplayer.getClass().getDeclaredField("ping");
+      return String.valueOf(pingField.getInt(nmsplayer));
+    } catch (Exception e) {
+      e.printStackTrace();
+    }
+    return "0";
+  }
+
+  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 String getCardinalDirection(Player player) {
+    double rotation = player.getLocation().getYaw() - 180.0F;
+    if (rotation < 0.0D) {
+      rotation += 360.0D;
+    }
+    if ((0.0D <= rotation) && (rotation < 22.5D)) {
+      return "N";
+    }
+    if ((22.5D <= rotation) && (rotation < 67.5D)) {
+      return "NE";
+    }
+    if ((67.5D <= rotation) && (rotation < 112.5D)) {
+      return "E";
+    }
+    if ((112.5D <= rotation) && (rotation < 157.5D)) {
+      return "SE";
+    }
+    if ((157.5D <= rotation) && (rotation < 202.5D)) {
+      return "S";
+    }
+    if ((202.5D <= rotation) && (rotation < 247.5D) || (rotation <= -119.33) && (rotation > -179)) {
+      return "SW";
+    }
+    if ((247.5D <= rotation) && (rotation < 292.5D) || (rotation <= -59.66) && (rotation > -119.33)) {
+      return "W";
+    }
+    if ((292.5D <= rotation) && (rotation < 337.5D) || (rotation <= -0.0) && (rotation > -59.66)) {
+      return "NW";
+    }
+    if ((337.5D <= rotation) && (rotation < 360.0D)) {
+      return "N";
+    }
+    return "";
+  }
+
+  public static ItemStack itemInHand(Player p) {
+    try {
+      return p.getInventory().getItemInMainHand();
+    } catch (NoSuchMethodError e) {
+      return p.getInventory().getItemInHand();
+    }
+  }
+
+    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;
+    }
+}