Fix PlaytimeCommand and Timer not shown

- Fix Status Color Bug
- Add /playtime
- Add /timer

.vscode/tasks.json

@@ -0,0 +1,15 @@
+{
+    "version": "2.0.0",
+    "tasks": [
+        {
+            "label": "build",
+            "command": "mvn",
+            "args": [
+                "clean",
+                "package"
+            ],
+            "type": "shell",
+            "problemMatcher": []
+        }
+    ]
+}

README.md

@@ -0,0 +1,8 @@
+# D7 Server Lite
+D7ServerUtil in a more stable Version
+
+Version 1.17.1+
+# Building
+```bash
+mvn clean package
+```

pom.xml

@@ -11,8 +11,8 @@
 
 	<properties>
 		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
-		<maven.compiler.source>1.7</maven.compiler.source>
-		<maven.compiler.target>1.7</maven.compiler.target>
+		<maven.compiler.source>1.8</maven.compiler.source>
+		<maven.compiler.target>1.8</maven.compiler.target>
 	</properties>
 
 	<repositories>

src/main/java/de/npid7/serverlite/Commands/D7Command.java

@@ -0,0 +1,114 @@
+package de.npid7.serverlite.Commands;
+
+import de.npid7.serverlite.Configs.PluginConfig;
+import de.npid7.serverlite.D7ServerLite;
+import org.bukkit.Bukkit;
+import org.bukkit.ChatColor;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandExecutor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+public class D7Command implements CommandExecutor {
+  private void printUsage(CommandSender sender) {
+    sender.sendMessage("Verwendung: ");
+    sender.sendMessage("/d7 config reload -> Läd Config nau");
+    sender.sendMessage("/d7 config save -> Speichert die Config");
+    sender.sendMessage("/d7 wordlist add <word>");
+    sender.sendMessage("/d7 wordlist remove <word>");
+    sender.sendMessage("/d7 status <playername> set <status> <color> (color ist optional)");
+    sender.sendMessage("/d7 status <playername> remove -> Entfernt einem Spieler den Status");
+  }
+  @Override
+  public boolean onCommand(CommandSender sender, Command command, String s, String[] strings) {
+    if (!sender.hasPermission("d7.d7")) {
+      sender.sendMessage(ChatColor.RED.toString() + "This is an admin command!");
+      return false;
+    }
+    if (strings.length < 2 || strings.length > 5) {
+      printUsage(sender);
+      return false;
+    }
+    if (strings[0].equals("config")) {
+      if (strings.length != 2) {
+        printUsage(sender);
+        return false;
+      }
+      if (strings[1].equals("reload")) {
+        D7ServerLite.getInst().getPluginConfig().Load();
+        sender.sendMessage(ChatColor.GREEN.toString() + "Config neu geladen!");
+        return false;
+      } else if (strings[1].equals("save")) {
+        D7ServerLite.getInst().getPluginConfig().Save();
+        sender.sendMessage(ChatColor.GREEN.toString() + "Config gespeichert!");
+        return false;
+      } else {
+        sender.sendMessage(
+            ChatColor.RED.toString() + strings[1] + " ist kein subcommand von config!");
+        return false;
+      }
+    } else if (strings[0].equals("wordlist")) {
+      if (strings.length != 3) {
+        printUsage(sender);
+        return false;
+      }
+      PluginConfig pcfg = D7ServerLite.getInst().getPluginConfig();
+      if (strings[1].equals("add")) {
+        if (!pcfg.getWordBlacklist().add(strings[2])) {
+          sender.sendMessage(ChatColor.RED.toString() + "Wort ist bereits in der Liste!");
+        } else {
+          sender.sendMessage(ChatColor.GREEN.toString() + "Wort hinzugefügt!");
+        }
+        pcfg.Save();
+        return false;
+      } else if (strings[1].equals("remove")) {
+        if (!pcfg.getWordBlacklist().remove(strings[2])) {
+          sender.sendMessage(ChatColor.RED.toString() + "Wort nicht gefunden!");
+        } else {
+          sender.sendMessage(ChatColor.GREEN.toString() + "Wort entfernt!");
+        }
+        pcfg.Save();
+        return false;
+      }
+    } else if (strings[0].equals("status")) {
+      if (strings.length < 3 || strings.length > 5) {
+        printUsage(sender);
+        return false;
+      }
+      if (strings[2].equals("remove")) {
+        Player pl = Bukkit.getPlayer(strings[1]);
+        if (pl == null) {
+          sender.sendMessage(ChatColor.RED.toString() + "Player existiert nicht!");
+          return false;
+        }
+        D7ServerLite.getInst().getPlayerConfig().setStatus(pl.getUniqueId(), "");
+        D7ServerLite.getInst().getPlayerConfig().Save();
+        sender.sendMessage(ChatColor.GREEN.toString() + "Status entfernt von " + pl.getName());
+        return false;
+      } else if (strings[2].equals("set")) {
+        Player pl = Bukkit.getPlayer(strings[1]);
+        if (pl == null) {
+          sender.sendMessage(ChatColor.RED.toString() + "Player existiert nicht!");
+          return false;
+        }
+        String status = strings[3];
+        String color = ChatColor.WHITE.toString();
+        if (strings.length == 5) {
+          for (ChatColor c : ChatColor.values()) {
+            if (c.isColor() && c.name().equals(strings[4])) {
+              color = c.toString();
+            }
+          }
+        }
+        if (D7ServerLite.getInst().getPluginConfig().getWordBlacklist().find(status) != null) {
+          sender.sendMessage(ChatColor.RED.toString() + "Dieser Status ist nicht erlaubt!");
+          return false;
+        }
+        D7ServerLite.getInst().getPlayerConfig().setStatus(pl.getUniqueId(), color + status);
+        D7ServerLite.getInst().getPlayerConfig().Save();
+        sender.sendMessage(ChatColor.GREEN.toString() + "Status gesetzt für " + pl.getName());
+      }
+    }
+    return false;
+  }
+}

src/main/java/de/npid7/serverlite/Commands/PlaytimeCommand.java

@@ -0,0 +1,56 @@
+package de.npid7.serverlite.Commands;
+
+import de.npid7.serverlite.Helpers.Spielzeit;
+import org.bukkit.Bukkit;
+import org.bukkit.ChatColor;
+import org.bukkit.OfflinePlayer;
+import org.bukkit.Statistic;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandExecutor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+public class PlaytimeCommand implements CommandExecutor {
+  private void makeMessage(OfflinePlayer pl, Player exec) {
+    if (pl == null) {
+      return;
+    }
+    exec.sendMessage("- " + ChatColor.GOLD.toString() + "PLAYTIME: ");
+    exec.sendMessage(
+        "- " + ChatColor.GRAY.toString() + "Player: " + ChatColor.WHITE.toString() + pl.getName());
+    // exec.sendMessage("- First Join: ");
+    int playtime = Spielzeit.getHours(pl.getStatistic(Statistic.TOTAL_WORLD_TIME));
+    String str = "Stunden";
+    if (playtime == 1) {
+      str = "Stunde";
+    }
+    exec.sendMessage("- " + ChatColor.GRAY.toString() + "Spielzeit: " + ChatColor.GREEN.toString()
+        + playtime + str);
+    exec.sendMessage("- " + ChatColor.GRAY.toString()
+        + "Detailierte Spielzeit: " + ChatColor.GREEN.toString()
+        + Spielzeit.formatTicks(pl.getStatistic(Statistic.TOTAL_WORLD_TIME)));
+    exec.sendMessage("- " + ChatColor.GRAY.toString() + "Du hast den Server "
+        + ChatColor.GREEN.toString() + (pl.getStatistic(Statistic.LEAVE_GAME) + 1)
+        + ChatColor.GRAY.toString() + " mal betreten.");
+  }
+
+  @Override
+  public boolean onCommand(CommandSender sender, Command command, String s, String[] strings) {
+    if (strings.length != 0) {
+      if (!sender.hasPermission("d7.d7")) {
+        sender.sendMessage(
+            ChatColor.RED.toString() + "Nur Admins dürfen /plytime auf spieler anwenden");
+        return false;
+      }
+      OfflinePlayer pl = Bukkit.getOfflinePlayer(strings[0]);
+      if (pl == null) {
+        sender.sendMessage(ChatColor.RED.toString() + "Der Spieler existiert nicht!");
+        return false;
+      }
+      makeMessage(pl, (Player) sender);
+    } else {
+      makeMessage(Bukkit.getOfflinePlayer(((Player) sender).getUniqueId()), (Player) sender);
+    }
+    return false;
+  }
+}

src/main/java/de/npid7/serverlite/Commands/StatusCommand.java

@@ -0,0 +1,69 @@
+package de.npid7.serverlite.Commands;
+
+import de.npid7.serverlite.Configs.PlayerConfig;
+import de.npid7.serverlite.D7ServerLite;
+import org.bukkit.ChatColor;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandExecutor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+public class StatusCommand implements CommandExecutor {
+  @Override
+  public boolean onCommand(CommandSender sender, Command command, String s, String[] strings) {
+    if (strings.length < 1 || strings.length > 3) {
+      sender.sendMessage("Verwendung: /status <status/custom/remove>");
+      return false;
+    }
+    String str = "";
+    String color = ChatColor.WHITE.toString(); // Default to White
+    boolean is_def = false;
+    for (String st : D7ServerLite.getInst().getPluginConfig().getDefaultStatusList()) {
+      if (strings[0].equals(st)) {
+        str = strings[0];
+        is_def = true;
+      }
+    }
+    if (is_def) {
+      // Leave empty
+    } else if (strings[0].equals("custom")) {
+      if (strings.length < 2) {
+        sender.sendMessage("Verwendung: /status custom <status> <color>");
+        return false;
+      }
+      if (strings[1].length() > 10) {
+        sender.sendMessage(ChatColor.RED.toString() + "Maximale länge ist 10 Zeichen!");
+        return false;
+      }
+      str = strings[1];
+      if (strings.length == 3) {
+        for (ChatColor c : ChatColor.values()) {
+          if (c.isColor() && c.name().equals(strings[2])) {
+            color = c.toString();
+          }
+        }
+      }
+    } else if (strings[0].equals("remove")) {
+      PlayerConfig pcfg = D7ServerLite.getInst().getPlayerConfig();
+      pcfg.setStatus(((Player) sender).getUniqueId(), "");
+      pcfg.Save();
+      return false;
+    } else {
+      sender.sendMessage(
+          ChatColor.RED.toString() + "Was auch immer du versuchst... lass es einfach!");
+      return false;
+    }
+    if (D7ServerLite.getInst().getPluginConfig().getWordBlacklist().find(str) != null) {
+      sender.sendMessage(ChatColor.RED.toString() + "Dieser Status ist nicht erlaubt!");
+      return false;
+    }
+    // Fix defined status whitre here
+    if (is_def) {
+      color = "";
+    }
+    PlayerConfig pcfg = D7ServerLite.getInst().getPlayerConfig();
+    pcfg.setStatus(((Player) sender).getUniqueId(), color + str);
+    pcfg.Save();
+    return false;
+  }
+}

src/main/java/de/npid7/serverlite/Commands/TimerCommand.java

@@ -0,0 +1,30 @@
+package de.npid7.serverlite.Commands;
+
+import org.bukkit.ChatColor;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandExecutor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+import de.npid7.serverlite.D7ServerLite;
+
+public class TimerCommand implements CommandExecutor {
+    @Override
+    public boolean onCommand(CommandSender sender, Command command, String s, String[] strings) {
+        if (strings.length != 1) {
+            sender.sendMessage(ChatColor.RED.toString() + "kein argument definiert!");
+            return false;
+        }
+        if (strings[0].equals("show")) {
+            D7ServerLite.getInst().getPlayerConfig().setTimer(((Player) sender).getUniqueId(), true);
+            D7ServerLite.getInst().getPlayerConfig().Save();
+        } else if (strings[0].equals("hide")) {
+            D7ServerLite.getInst().getPlayerConfig().setTimer(((Player) sender).getUniqueId(), true);
+            D7ServerLite.getInst().getPlayerConfig().Save();
+        } else {
+            sender.sendMessage(ChatColor.RED.toString() + "argument nicht erlaubt!");
+            return false;
+        }
+        return false;
+    }
+}

src/main/java/de/npid7/serverlite/Configs/PlayerConfig.java

@@ -0,0 +1,135 @@
+package de.npid7.serverlite.Configs;
+
+import com.google.gson.Gson;
+import com.google.gson.GsonBuilder;
+import com.google.gson.JsonElement;
+import com.google.gson.JsonObject;
+import com.google.gson.JsonParser;
+import java.io.File;
+import java.io.FileReader;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.UUID;
+
+public class PlayerConfig {
+  File file = null;
+  int cfg_version = 1;
+
+  public static class PlayerEntry {
+    public String status = "";
+    public String name = "";
+    public boolean timer = false;
+
+    public PlayerEntry() {
+    }
+
+    public PlayerEntry(String s, String n, boolean t) {
+      status = s;
+      name = n;
+      timer = t;
+    }
+  }
+
+  HashMap<UUID, PlayerEntry> player_map = new HashMap<>();
+
+  public PlayerConfig(String path) {
+    file = new File(path);
+    Load();
+  }
+
+  public boolean Load() {
+    if (!file.exists()) {
+      return false;
+    }
+    try {
+      FileReader r = new FileReader(file);
+      JsonParser prs = new JsonParser();
+      JsonObject js = prs.parse(r).getAsJsonObject();
+      r.close();
+      int pver = js.get("version").getAsInt();
+      player_map.clear();
+      // Load Data
+      for (Map.Entry<String, JsonElement> e : js.entrySet()) {
+        if (e.getKey().equals("version")) {
+          continue;
+        }
+        UUID key = UUID.fromString(e.getKey());
+        PlayerEntry pe = new PlayerEntry();
+        pe.name = e.getValue().getAsJsonObject().get("name").getAsString();
+        pe.status = e.getValue().getAsJsonObject().get("status").getAsString();
+        if (pver >= 1) {
+          pe.timer = e.getValue().getAsJsonObject().get("timer").getAsBoolean();
+        }
+        player_map.put(key, pe);
+      }
+      if (pver != cfg_version) {
+        // Use PVER to update Config
+        Save();
+        return false;
+      }
+    } catch (IOException e) {
+      e.printStackTrace();
+      return true;
+    }
+    return false;
+  }
+
+  public boolean Save() {
+    JsonObject js = new JsonObject();
+    js.addProperty("version", cfg_version);
+    for (Map.Entry<UUID, PlayerEntry> e : player_map.entrySet()) {
+      JsonObject o = new JsonObject();
+      o.addProperty("name", e.getValue().name);
+      o.addProperty("status", e.getValue().status);
+      o.addProperty("timer", e.getValue().timer);
+      js.add(e.getKey().toString(), o);
+    }
+    try {
+      FileWriter w = new FileWriter(file);
+      Gson g = new GsonBuilder().setPrettyPrinting().create();
+      g.toJson(js, w);
+      w.close();
+    } catch (IOException e) {
+      e.printStackTrace();
+      return true;
+    }
+    return false;
+  }
+
+  public PlayerEntry Find(UUID ref) {
+    if (player_map.containsKey(ref)) {
+      return player_map.get(ref);
+    }
+    return null;
+  }
+
+  public void Add(UUID k, PlayerEntry e) {
+    player_map.put(k, e);
+  }
+
+  public String getStatus(UUID ref) {
+    return this.player_map.get(ref).status;
+  }
+
+  public void setStatus(UUID ref, String value) {
+    this.player_map.get(ref).status = value;
+  }
+
+  public String getName(UUID ref) {
+    return this.player_map.get(ref).name;
+  }
+
+  public void setName(UUID ref, String value) {
+    this.player_map.get(ref).name = value;
+  }
+
+  public boolean getTimer(UUID ref) {
+    return this.player_map.get(ref).timer;
+  }
+
+  public void setTimer(UUID ref, boolean value) {
+    this.player_map.get(ref).timer = value;
+  }
+}

src/main/java/de/npid7/serverlite/Configs/PluginConfig.java

@@ -0,0 +1,144 @@
+package de.npid7.serverlite.Configs;
+
+import com.google.gson.Gson;
+import com.google.gson.GsonBuilder;
+import com.google.gson.JsonArray;
+import com.google.gson.JsonElement;
+import com.google.gson.JsonObject;
+import com.google.gson.JsonParser;
+import de.npid7.serverlite.Helpers.Wordlist;
+import java.io.File;
+import java.io.FileReader;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Vector;
+import org.bukkit.ChatColor;
+
+public class PluginConfig {
+  File file = null;
+
+  int cfg_version = 0;
+  Wordlist wordBlacklist = new Wordlist();
+
+  String defaultStatus = "";
+  // Maybe the name is missleading but i refer to the docs for that
+  Vector<String> defaultStatusList = new Vector<>();
+  HashMap<String, String> tablistStatusColors = new HashMap<>();
+
+  public PluginConfig(String path) {
+    file = new File(path);
+    Load();
+  }
+
+  public boolean Load() {
+    tablistStatusColors.clear();
+    if (!file.exists()) {
+      CreateNew(0);
+      return false;
+    }
+    try {
+      FileReader r = new FileReader(file);
+      JsonParser prs = new JsonParser();
+      JsonObject js = prs.parse(r).getAsJsonObject();
+      r.close();
+      int pver = js.get("version").getAsInt();
+      if (pver != cfg_version) {
+        // Use PVER to not create a complete new config
+        CreateNew(pver);
+        return false;
+      }
+      wordBlacklist.fromJsonArray(js.get("word_blacklist").getAsJsonArray());
+      defaultStatus = js.get("default_status").getAsString();
+      JsonArray default_status = js.get("default_status_list").getAsJsonArray();
+      defaultStatusList.clear();
+      for (JsonElement e : default_status) {
+        defaultStatusList.add(e.getAsString());
+      }
+      JsonObject color_map =
+          js.get("tablist").getAsJsonObject().get("status_colors").getAsJsonObject();
+      for (Map.Entry<String, JsonElement> e : color_map.entrySet()) {
+        tablistStatusColors.put(e.getKey(), color_map.get(e.getKey()).getAsString());
+      }
+    } catch (IOException e) {
+      e.printStackTrace();
+      return true;
+    }
+    return false;
+  }
+
+  public boolean Save() {
+    JsonObject js = new JsonObject();
+    js.addProperty("version", cfg_version);
+    js.add("word_blacklist", wordBlacklist.toJsonArray());
+    JsonObject tablist = new JsonObject();
+    JsonObject color_table = new JsonObject();
+    for (Map.Entry<String, String> e : tablistStatusColors.entrySet()) {
+      color_table.addProperty(e.getKey(), e.getValue());
+    }
+    tablist.add("status_colors", color_table);
+    JsonArray default_status = new JsonArray();
+    for (String s : defaultStatusList) {
+      default_status.add(s);
+    }
+    js.addProperty("default_status", defaultStatus);
+    js.add("default_status_list", default_status);
+    js.add("tablist", tablist);
+    try {
+      FileWriter w = new FileWriter(file);
+      Gson g = new GsonBuilder().setPrettyPrinting().create();
+      g.toJson(js, w);
+      w.close();
+    } catch (IOException e) {
+      e.printStackTrace();
+      return true;
+    }
+    return false;
+  }
+
+  void CreateNew(int prev_ver) {
+    if (prev_ver < 1) {
+      wordBlacklist.add("ADMIN");
+      wordBlacklist.add("HOST");
+      wordBlacklist.add("MOD");
+      wordBlacklist.add("TEAM");
+      wordBlacklist.add("STAFF");
+      wordBlacklist.add("OWNER");
+      wordBlacklist.add("MODERATOR");
+      defaultStatus = "";
+      defaultStatusList.add("Online");
+      defaultStatusList.add("AFK");
+      defaultStatusList.add("Beschäftigt");
+      tablistStatusColors.put("D7", ChatColor.GOLD.toString());
+      tablistStatusColors.put("Online", ChatColor.GREEN.toString());
+      tablistStatusColors.put("AFK", ChatColor.GOLD.toString());
+      tablistStatusColors.put("Beschäftigt", ChatColor.RED.toString());
+    }
+    // Make sure default latest plugin config version is set
+    cfg_version = 0;
+    this.Save();
+  }
+
+  public Wordlist getWordBlacklist() {
+    return this.wordBlacklist;
+  }
+
+  public String getDefaultStatus() {
+    return this.defaultStatus;
+  }
+  public void setDefaultStatus(String value) {
+    this.defaultStatus = value;
+  }
+
+  public Vector<String> getDefaultStatusList() {
+    return this.defaultStatusList;
+  }
+
+  public String getStatusColor(String s) {
+    if (tablistStatusColors.containsKey(s)) {
+      return tablistStatusColors.get(s);
+    }
+    return null;
+  }
+}

src/main/java/de/npid7/serverlite/D7ServerLite.java

@@ -1,35 +1,79 @@
 package de.npid7.serverlite;
 
-import java.util.logging.Logger;
+import de.npid7.serverlite.Commands.D7Command;
+import de.npid7.serverlite.Commands.PlaytimeCommand;
+import de.npid7.serverlite.Commands.StatusCommand;
+import de.npid7.serverlite.Commands.TimerCommand;
+import de.npid7.serverlite.Configs.PlayerConfig;
+import de.npid7.serverlite.Configs.PluginConfig;
+import de.npid7.serverlite.Listeners.JoinListener;
+import de.npid7.serverlite.TabCompleters.D7Completer;
+import de.npid7.serverlite.TabCompleters.PlaytimeCompleter;
+import de.npid7.serverlite.TabCompleters.StatusCompleter;
+import de.npid7.serverlite.TabCompleters.TimerCompleter;
+import de.npid7.serverlite.Tasks.TablistTask;
 
 import org.bukkit.Bukkit;
 import org.bukkit.plugin.java.JavaPlugin;
 
-import de.npid7.serverlite.Helpers.Spielzeit;
-import de.npid7.serverlite.Tasks.TablistTask;
-
 /*
  * d7serverlite java plugin
  */
 public class D7ServerLite extends JavaPlugin {
+  // Declare static Instance To access with getInst();
+  // using this to access Configs from this Class
   private static D7ServerLite inst;
 
+  // declare TablistTask and Configs
   private TablistTask tablistUpdater;
+  private PluginConfig pluginConfig;
+  private PlayerConfig playerConfig;
 
+  // Override onLoad to set static inst to this class
   @Override
   public void onLoad() {
     inst = this;
   }
 
+  // Override on Enabel to init the Plugin
   @Override
   public void onEnable() {
+    // Create Data Folder
+    if (!getDataFolder().exists()) {
+      getDataFolder().mkdirs();
+    }
+    // Init Configs
+    pluginConfig = new PluginConfig(getDataFolder() + "/config.json");
+    playerConfig = new PlayerConfig(getDataFolder() + "/player_config.json");
+    // Run Tablist Updater
     tablistUpdater = new TablistTask();
+    // declare commands
+    getCommand("status").setExecutor(new StatusCommand());
+    getCommand("status").setTabCompleter(new StatusCompleter());
+    getCommand("d7").setExecutor(new D7Command());
+    getCommand("d7").setTabCompleter(new D7Completer());
+    getCommand("timer").setExecutor(new TimerCommand());
+    getCommand("timer").setTabCompleter(new TimerCompleter());
+    getCommand("playtime").setExecutor(new PlaytimeCommand());
+    getCommand("playtime").setTabCompleter(new PlaytimeCompleter());
+
+    // Register onJoin Event to generate PlayerConfigEntry
+    Bukkit.getPluginManager().registerEvents(new JoinListener(), this);
   }
 
-  @Override
-  public void onDisable() {}
+  /**
+   * Getters declared below
+   */
 
   public static D7ServerLite getInst() {
     return inst;
   }
+
+  public PluginConfig getPluginConfig() {
+    return this.pluginConfig;
+  }
+
+  public PlayerConfig getPlayerConfig() {
+    return this.playerConfig;
+  }
 }

src/main/java/de/npid7/serverlite/Helpers/Spielzeit.java

@@ -19,7 +19,7 @@ public class Spielzeit {
     }
     return timers;
   }
-  
+
   public static int getHours(int ticks) {
     int time = ticks / 20;
     return time / 3600;

src/main/java/de/npid7/serverlite/Helpers/Wordlist.java

@@ -0,0 +1,69 @@
+package de.npid7.serverlite.Helpers;
+
+import com.google.gson.JsonArray;
+import com.google.gson.JsonElement;
+import com.google.gson.JsonObject;
+import java.util.Map;
+import java.util.Vector;
+
+public class Wordlist {
+  Vector<String> wordlist = new Vector<>();
+
+  public Wordlist() {}
+
+  public void fromJsonArray(JsonArray a) {
+    if (a == null) {
+      return;
+    }
+    for (JsonElement e : a) {
+      wordlist.add(e.getAsString());
+    }
+  }
+
+  public JsonArray toJsonArray() {
+    JsonArray a = new JsonArray();
+    for (String s : wordlist) {
+      a.add(s);
+    }
+    return a;
+  }
+
+  public boolean add(String s) {
+    // wra -> With rights allowed
+    if (find(s) != null) {
+      return false;
+    }
+    wordlist.add(s);
+    return true;
+  }
+
+  public boolean remove(String s) {
+    String e = find(s);
+    if (e == null) {
+      return false;
+    }
+    wordlist.remove(e);
+    return true;
+  }
+
+  public String find(String word) {
+    for (String s : wordlist) {
+      if (s.equalsIgnoreCase(word)) {
+        return s;
+      }
+    }
+    return null;
+  }
+
+  public boolean isAllowed(String word) {
+    String w = find(word);
+    if (w != null) {
+      return false;
+    }
+    return true;
+  }
+
+  public Vector<String> getList() {
+    return wordlist;
+  }
+}

src/main/java/de/npid7/serverlite/Listeners/JoinListener.java

@@ -0,0 +1,21 @@
+package de.npid7.serverlite.Listeners;
+
+import de.npid7.serverlite.Configs.PlayerConfig;
+import de.npid7.serverlite.D7ServerLite;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.player.PlayerJoinEvent;
+
+public class JoinListener implements Listener {
+  @EventHandler
+  public void onJoin(PlayerJoinEvent event) {
+    Player player = event.getPlayer();
+    if (D7ServerLite.getInst().getPlayerConfig().Find(player.getUniqueId()) == null) {
+      D7ServerLite.getInst().getPlayerConfig().Add(player.getUniqueId(),
+          new PlayerConfig.PlayerEntry(
+              D7ServerLite.getInst().getPluginConfig().getDefaultStatus(), player.getName(), false));
+      D7ServerLite.getInst().getPlayerConfig().Save();
+    }
+  }
+}

src/main/java/de/npid7/serverlite/TabCompleters/D7Completer.java

@@ -0,0 +1,62 @@
+package de.npid7.serverlite.TabCompleters;
+
+import de.npid7.serverlite.D7ServerLite;
+import java.util.ArrayList;
+import java.util.List;
+import org.bukkit.Bukkit;
+import org.bukkit.ChatColor;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.command.TabCompleter;
+import org.bukkit.entity.Player;
+
+public class D7Completer implements TabCompleter {
+  @Override
+  public List<String> onTabComplete(
+      CommandSender sender, Command command, String alias, String[] args) {
+    List<String> completions = new ArrayList<>();
+    if (command.getName().equals("d7")) {
+      if (!sender.hasPermission("d7.d7")) {
+        return completions;
+      }
+      if (args.length == 1) {
+        completions.add("config");
+        completions.add("status");
+        completions.add("wordlist");
+      } else if (args.length == 2) {
+        if (args[0].equals("config")) {
+          completions.add("reload");
+          completions.add("save");
+        } else if (args[0].equals("status")) {
+          for (Player pl : Bukkit.getOnlinePlayers()) {
+            completions.add(pl.getName());
+          }
+        } else if (args[0].equals("wordlist")) {
+          completions.add("add");
+          completions.add("remove");
+        }
+      } else if (args.length == 3) {
+        if (args[0].equals("status")) {
+          completions.add("remove");
+          completions.add("set");
+        } else if (args[0].equals("wordlist")) {
+          if (args[1].equals("remove")) {
+            for (String s : D7ServerLite.getInst().getPluginConfig().getWordBlacklist().getList()) {
+              completions.add(s);
+            }
+          }
+        }
+      } else if (args.length == 5) {
+        if (args[2].equals("set")) {
+          for (ChatColor c : ChatColor.values()) {
+            if (c.isColor()) {
+              completions.add(c.name());
+            }
+          }
+        }
+      }
+    }
+
+    return completions;
+  }
+}

src/main/java/de/npid7/serverlite/TabCompleters/PlaytimeCompleter.java

@@ -0,0 +1,26 @@
+package de.npid7.serverlite.TabCompleters;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.bukkit.Bukkit;
+import org.bukkit.OfflinePlayer;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.command.TabCompleter;
+
+public class PlaytimeCompleter implements TabCompleter {
+    @Override
+    public List<String> onTabComplete(
+            CommandSender sender, Command command, String alias, String[] args) {
+        List<String> completions = new ArrayList<>();
+        if (command.getName().equalsIgnoreCase("playtime")) {
+            if (sender.hasPermission("d7.d7")) {
+                for (OfflinePlayer pl : Bukkit.getOfflinePlayers()) {
+                    completions.add(pl.getName());
+                }
+            }
+        }
+        return completions;
+    }
+}

src/main/java/de/npid7/serverlite/TabCompleters/StatusCompleter.java

@@ -0,0 +1,35 @@
+package de.npid7.serverlite.TabCompleters;
+
+import de.npid7.serverlite.D7ServerLite;
+import java.util.ArrayList;
+import java.util.List;
+import org.bukkit.ChatColor;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.command.TabCompleter;
+
+public class StatusCompleter implements TabCompleter {
+  @Override
+  public List<String> onTabComplete(
+      CommandSender sender, Command command, String alias, String[] args) {
+    List<String> completions = new ArrayList<>();
+    if (command.getName().equalsIgnoreCase("status")) {
+      if (args.length == 1) {
+        for (String s : D7ServerLite.getInst().getPluginConfig().getDefaultStatusList()) {
+          completions.add(s);
+        }
+        completions.add("custom");
+        completions.add("remove");
+      } else if (args.length == 3) {
+        if (args[0].equals("custom")) {
+          for (ChatColor c : ChatColor.values()) {
+            if (c.isColor()) {
+              completions.add(c.name());
+            }
+          }
+        }
+      }
+    }
+    return completions;
+  }
+}

src/main/java/de/npid7/serverlite/TabCompleters/TimerCompleter.java

@@ -0,0 +1,21 @@
+package de.npid7.serverlite.TabCompleters;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.command.TabCompleter;
+
+public class TimerCompleter implements TabCompleter {
+    @Override
+    public List<String> onTabComplete(
+            CommandSender sender, Command command, String alias, String[] args) {
+        List<String> completions = new ArrayList<>();
+        if (command.getName().equalsIgnoreCase("timer")) {
+            completions.add("show");
+            completions.add("hide");
+        }
+        return completions;
+    }
+}

src/main/java/de/npid7/serverlite/Tasks/TablistTask.java

@@ -3,6 +3,8 @@ package de.npid7.serverlite.Tasks;
 import de.npid7.serverlite.D7ServerLite;
 import de.npid7.serverlite.Helpers.Spielzeit;
 import net.md_5.bungee.api.ChatColor;
+import net.md_5.bungee.api.ChatMessageType;
+import net.md_5.bungee.api.chat.TextComponent;
 import org.bukkit.Bukkit;
 import org.bukkit.Statistic;
 import org.bukkit.entity.Player;
@@ -55,6 +57,27 @@ public class TablistTask {
           + ChatColor.DARK_GRAY.toString() + ": " + ChatColor.GREEN.toString() + playtime + str
           + "\n");
       pl.setPlayerListFooter("\n");
+      String body = "";
+      String status = D7ServerLite.getInst().getPlayerConfig().getStatus(pl.getUniqueId());
+      if (!status.equals("")) {
+        body += "[";
+        String color = D7ServerLite.getInst().getPluginConfig().getStatusColor(status);
+        if (color == null) {
+          color = ChatColor.WHITE.toString();
+        }
+        body += color;
+        body += status;
+        body += ChatColor.WHITE.toString();
+        body += "] ";
+      }
+      body += ChatColor.WHITE.toString() + pl.getDisplayName();
+      body += " " + ChatColor.RED.toString() + pl.getStatistic(Statistic.DEATHS);
+      pl.setPlayerListName(body);
+      if (D7ServerLite.getInst().getPlayerConfig().getTimer(pl.getUniqueId())) {
+        pl.spigot().sendMessage(ChatMessageType.ACTION_BAR,
+            new TextComponent(ChatColor.GOLD.toString()
+                + Spielzeit.formatTicks(pl.getStatistic(Statistic.TOTAL_WORLD_TIME))));
+      }
     }
   }
 

src/main/resources/plugin.yml

@@ -1,4 +1,15 @@
 name: D7SerevrLite
 main: de.npid7.serverlite.D7ServerLite
 version: 1.0
-api-version: 1.17
+api-version: 1.17
+
+commands:
+  status:
+    description: Play Status Command
+  d7:
+    description: Admin Command Interface
+    permission: d7.d7
+  timer:
+    description: Display Timer in Actionbar
+  playtime:
+    description: Display your Playtime