add code

src/main/java/sh/okx/rankup/ranks/Prestige.java

@@ -0,0 +1,4 @@
+package sh.okx.rankup.ranks;
+
+public class Prestige {
+}

src/main/java/sh/okx/rankup/ranks/Rank.java

@@ -0,0 +1,138 @@
+package sh.okx.rankup.ranks;
+
+import lombok.AccessLevel;
+import lombok.Getter;
+import lombok.RequiredArgsConstructor;
+import org.bukkit.Bukkit;
+import org.bukkit.configuration.ConfigurationSection;
+import org.bukkit.entity.Player;
+import sh.okx.rankup.Rankup;
+import sh.okx.rankup.messages.MessageBuilder;
+import sh.okx.rankup.messages.Variable;
+import sh.okx.rankup.ranks.requirements.Requirement;
+
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.function.BinaryOperator;
+
+@RequiredArgsConstructor(access = AccessLevel.PRIVATE)
+public class Rank {
+  private final Rankup plugin;
+  @Getter
+  private final String name;
+  @Getter
+  private final String next;
+  @Getter
+  private final String rank;
+  private final Set<Requirement> requirements;
+  private final BinaryOperator<Boolean> reducer;
+  private final List<String> commands;
+
+  public static Rank deserialize(Rankup plugin, ConfigurationSection section) {
+    String rank = section.getString("rank");
+
+    Set<Requirement> requirements = new HashSet<>();
+    BinaryOperator<Boolean> reducer = null;
+    ConfigurationSection requirementsSection = section.getConfigurationSection("requirements");
+    if(requirementsSection != null) {
+      for (Map.Entry<String, Object> entry : requirementsSection.getValues(false).entrySet()) {
+        String name = entry.getKey();
+        double amount = Double.parseDouble(String.valueOf(entry.getValue()));
+
+        Requirement requirement = plugin.getRequirementRegistry().newRequirement(name, amount);
+        if (requirement == null) {
+          plugin.getLogger().warning("Unknown requirement " + name);
+        } else {
+          requirements.add(requirement);
+        }
+      }
+
+      String operation = section.getString("operation");
+      if (operation == null) {
+        operation = "and";
+      }
+      switch (operation) {
+        case "and":
+          reducer = (a, b) -> a && b;
+          break;
+        case "or":
+          reducer = (a, b) -> a || b;
+          break;
+        case "xor":
+          reducer = (a, b) -> (a && !b) || (b && !a);
+          break;
+        case "none":
+          reducer = (a, b) -> !a && !b;
+          break;
+        default:
+          throw new IllegalArgumentException("Invalid operation type for rank " + rank);
+      }
+    }
+
+    return new Rank(plugin,
+        section.getName(),
+        section.getString("next"),
+        rank,
+        requirements,
+        reducer,
+        section.getStringList("commands"));
+  }
+
+  public boolean checkRequirements(Player player) {
+    return requirements.stream()
+        .map(requirement -> requirement.check(player))
+        .reduce(reducer)
+        .orElse(true);
+  }
+
+  public boolean isInRank(Player player) {
+    String[] groups = plugin.getPermissions().getPlayerGroups(player);
+    for (String group : groups) {
+      if(group.equalsIgnoreCase(rank)) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  public boolean isLastRank() {
+    return next == null;
+  }
+
+  public Requirement getRequirement(String name) {
+    for(Requirement requirement : requirements) {
+      if(requirement.getName().equalsIgnoreCase(name)) {
+        return requirement;
+      }
+    }
+    return null;
+  }
+
+  public void applyRequirements(Player player) {
+    for(Requirement requirement : requirements) {
+      requirement.apply(player);
+    }
+  }
+
+  public void runCommands(Player player, Rank nextRank) {
+    for (String command : commands) {
+      Bukkit.dispatchCommand(Bukkit.getConsoleSender(), new MessageBuilder(command)
+          .replace(Variable.PLAYER, player.getName())
+          .replace(Variable.OLD_RANK, rank)
+          .replace(Variable.OLD_RANK_NAME, name)
+          .replace(Variable.RANK, nextRank.rank)
+          .replace(Variable.RANK_NAME, nextRank.name)
+          .toString());
+    }
+  }
+
+  @Override
+  public boolean equals(Object o) {
+    if(!(o instanceof Rank)) {
+      return false;
+    }
+    return ((Rank) o).name.equals(name);
+  }
+}

src/main/java/sh/okx/rankup/ranks/Rankups.java

@@ -0,0 +1,80 @@
+package sh.okx.rankup.ranks;
+
+import lombok.Getter;
+import org.bukkit.configuration.ConfigurationSection;
+import org.bukkit.configuration.file.FileConfiguration;
+import org.bukkit.entity.Player;
+import sh.okx.rankup.Rankup;
+
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+
+public class Rankups {
+  @Getter
+  private final FileConfiguration config;
+  private final Set<Rank> ranks = new HashSet<>();
+
+  public Rankups(Rankup plugin, FileConfiguration config) {
+    this.config = config;
+    for (Map.Entry<String, Object> entry : config.getValues(false).entrySet()) {
+      ConfigurationSection rankSection = (ConfigurationSection) entry.getValue();
+      ranks.add(Rank.deserialize(plugin, rankSection));
+    }
+  }
+
+  public Rank getFirstRank() {
+    OUTER:
+    for(Rank rank : ranks) {
+      // see if anything ranks up to this
+      for(Rank rank0 : ranks) {
+        if(!rank0.isLastRank() && rank0.getNext().equals(rank.getName())) {
+          continue OUTER;
+        }
+      }
+      // nothing ranks up to this
+      return rank;
+    }
+    return null;
+  }
+
+  public Rank getRank(String name) {
+    for(Rank rank : ranks) {
+      if(rank.getName().equals(name)) {
+        return rank;
+      }
+    }
+    return null;
+  }
+
+  public Rank getRank(Player player) {
+    return ranks.stream()
+        .filter(rank -> rank.isInRank(player))
+        .findFirst()
+        .orElse(null);
+  }
+
+  public Rank nextRank(Rank rank) {
+    if(rank.isLastRank()) {
+      return null;
+    }
+
+    for(Rank nextRank : ranks) {
+      if (rank.getNext().equalsIgnoreCase(nextRank.getName())) {
+        return nextRank;
+      }
+    }
+    // this shouldn't happen but whatever
+    return null;
+  }
+
+//  public boolean hasNext(Rank start, Rank rank) {
+//    while(!start.isLastRank()) {
+//      start = nextRank(rank);
+//      if(start.equals(rank)) {
+//        return true;
+//      }
+//    }
+//    return false;
+//  }
+}

src/main/java/sh/okx/rankup/ranks/requirements/MoneyRequirement.java

@@ -0,0 +1,38 @@
+package sh.okx.rankup.ranks.requirements;
+
+import net.milkbowl.vault.economy.Economy;
+import org.bukkit.entity.Player;
+import sh.okx.rankup.Rankup;
+
+public class MoneyRequirement extends Requirement {
+  public MoneyRequirement(Rankup plugin, String name) {
+    super(plugin, name);
+  }
+
+  protected MoneyRequirement(Requirement clone) {
+    super(clone);
+  }
+
+  @Override
+  public boolean check(Player player) {
+    Economy economy = plugin.getEconomy();
+    double balance = economy.getBalance(player);
+    return balance >= amount;
+  }
+
+  @Override
+  public void apply(Player player) {
+    Economy economy = plugin.getEconomy();
+    economy.withdrawPlayer(player, amount);
+  }
+
+  @Override
+  public double getRemaining(Player player) {
+    return Math.max(0, amount - plugin.getEconomy().getBalance(player));
+  }
+
+  @Override
+  public Requirement clone() {
+    return new MoneyRequirement(this);
+  }
+}

src/main/java/sh/okx/rankup/ranks/requirements/PlaytimeHoursRequirement.java

@@ -0,0 +1,37 @@
+package sh.okx.rankup.ranks.requirements;
+
+import org.bukkit.Statistic;
+import org.bukkit.entity.Player;
+import sh.okx.rankup.Rankup;
+
+public class PlaytimeHoursRequirement extends Requirement {
+  private static final int TICKS_PER_HOUR = 20 * 60 * 60;
+
+  public PlaytimeHoursRequirement(Rankup plugin, String name) {
+    super(plugin, name);
+  }
+
+  protected PlaytimeHoursRequirement(Requirement clone) {
+    super(clone);
+  }
+
+  @Override
+  public boolean check(Player player) {
+    return player.getStatistic(Statistic.PLAY_ONE_MINUTE) * TICKS_PER_HOUR >= amount;
+  }
+
+  @Override
+  public void apply(Player player) {
+    // well, we can't really take hours of playtime away, can we?
+  }
+
+  @Override
+  public double getRemaining(Player player) {
+    return amount - (player.getStatistic(Statistic.PLAY_ONE_MINUTE) * TICKS_PER_HOUR);
+  }
+
+  @Override
+  public Requirement clone() {
+    return new PlaytimeHoursRequirement(this);
+  }
+}

src/main/java/sh/okx/rankup/ranks/requirements/Requirement.java

@@ -0,0 +1,55 @@
+package sh.okx.rankup.ranks.requirements;
+
+import lombok.Getter;
+import lombok.Setter;
+import org.bukkit.entity.Player;
+import sh.okx.rankup.Rankup;
+
+public abstract class Requirement implements Cloneable {
+  protected Rankup plugin;
+  @Getter
+  protected String name;
+  @Getter
+  @Setter
+  protected double amount;
+
+  public Requirement(Rankup plugin, String name) {
+    this.plugin = plugin;
+    this.name = name;
+  }
+
+  protected Requirement(Requirement clone) {
+    if(clone != null) {
+      this.plugin = clone.plugin;
+      this.name = clone.name;
+      this.amount = clone.amount;
+    }
+  }
+
+  /**
+   * Check if a player meets this requirement
+   * @param player the player to check
+   * @return true if they meet the requirement, false otherwise
+   */
+  public abstract boolean check(Player player);
+
+  /**
+   * Apply the effect of this requirement to the player.
+   * For money, this could be taking money away from the player.
+   * You can assume that <code>Requirement#check(Player)</code> has been called,
+   * and has returned true immediately prior to this.
+   * @param player the player to take from
+   */
+  public abstract void apply(Player player);
+
+  /**
+   * Get the remaining amount needed for <code>Requirement#check(Player)</code> to yield true.
+   * This is not required and is only used in placeholders.
+   * @param player the player to find the remaining amount of
+   * @return the remaining amount needed. Should be non-negative.
+   */
+  public double getRemaining(Player player) {
+    return amount;
+  }
+  public abstract Requirement clone();
+}

src/main/java/sh/okx/rankup/ranks/requirements/RequirementRegistry.java

@@ -0,0 +1,23 @@
+package sh.okx.rankup.ranks.requirements;
+
+import java.util.HashSet;
+import java.util.Set;
+
+public class RequirementRegistry {
+  private Set<Requirement> requirements = new HashSet<>();
+
+  public void addRequirement(Requirement requirement) {
+    requirements.add(requirement);
+  }
+
+  public Requirement newRequirement(String name, double amount) {
+    for(Requirement requirement : requirements) {
+      if(requirement.getName().equalsIgnoreCase(name)) {
+        Requirement newRequirement = requirement.clone();
+        newRequirement.setAmount(amount);
+        return newRequirement;
+      }
+    }
+    return null;
+  }
+}

src/main/java/sh/okx/rankup/ranks/requirements/XpLevelRequirement.java

@@ -0,0 +1,40 @@
+package sh.okx.rankup.ranks.requirements;
+
+import org.bukkit.entity.Player;
+import sh.okx.rankup.Rankup;
+
+public class XpLevelRequirement extends Requirement {
+  public XpLevelRequirement(Rankup plugin, String name) {
+    super(plugin, name);
+  }
+
+  protected XpLevelRequirement(Requirement clone) {
+    super(clone);
+  }
+
+  @Override
+  public void setAmount(double amount) {
+    // experience level should be a whole number
+    super.setAmount(Math.round(amount));
+  }
+
+  @Override
+  public boolean check(Player player) {
+    return player.getLevel() >= amount;
+  }
+
+  @Override
+  public void apply(Player player) {
+    player.setLevel(player.getLevel() - (int) amount);
+  }
+
+  @Override
+  public double getRemaining(Player player) {
+    return Math.max(0, amount - player.getLevel());
+  }
+
+  @Override
+  public Requirement clone() {
+    return new XpLevelRequirement(this);
+  }
+}