Add orders

gameserver/src/main/java/brainwine/gameserver/GameServer.java

@@ -5,6 +5,7 @@
 import java.util.Queue;
 import java.util.concurrent.ConcurrentLinkedQueue;
 
+import brainwine.gameserver.order.OrderManager;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 
@@ -47,6 +48,7 @@ public GameServer() {
         CommandManager.init();
         GameConfiguration.init();
         AchievementManager.loadAchievements();
+        OrderManager.loadOrders();
         EntityRegistry.init();
         EntityManager.loadEntitySpawns();
         GrowthManager.loadGrowthData();

gameserver/src/main/java/brainwine/gameserver/achievement/HuntingAchievement.java

@@ -21,10 +21,6 @@ public HuntingAchievement(@JacksonInject("title") String title) {
 
     @Override
     public int getProgress(Player player) {
-        return player.getStatistics().getKills().entrySet().stream()
-                .filter(entry -> entry.getKey().getGroup() == group)
-                .map(Entry::getValue)
-                .reduce(Integer::sum)
-                .orElse(0);
+        return player.getStatistics().getKills(group);
     }
 }

gameserver/src/main/java/brainwine/gameserver/command/OrderCommand.java

@@ -0,0 +1,54 @@
+package brainwine.gameserver.command;
+
+import brainwine.gameserver.dialog.Dialog;
+import brainwine.gameserver.dialog.DialogSection;
+import brainwine.gameserver.dialog.input.DialogSelectInput;
+import brainwine.gameserver.order.Order;
+import brainwine.gameserver.order.OrderManager;
+import brainwine.gameserver.player.NotificationType;
+import brainwine.gameserver.player.Player;
+import brainwine.gameserver.server.messages.EntityChangeMessage;
+import brainwine.gameserver.server.messages.EventMessage;
+
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+@CommandInfo(name = "order", description = "Shows a prompt where you can update your displayed order icon.")
+public class OrderCommand extends Command {
+    @Override
+    public void execute(CommandExecutor executor, String[] args) {
+        if(!(executor instanceof Player)) {
+            executor.notify("Only players can update their order icon.", NotificationType.SYSTEM);
+        }
+        Player player = (Player)executor;
+
+        List<String> orderKeys = player.getOrders().entrySet().stream()
+                .filter(e -> e.getValue() > 0)
+                .map(Map.Entry::getKey)
+                .collect(Collectors.toList());
+
+        final Map<Order, Integer> orders = OrderManager.getOrders(player);
+        List<String> options = orders.keySet().stream().map(Order::getTitle).collect(Collectors.toList());
+        options.add("None");
+
+        Dialog dialog = new Dialog()
+                .setTitle("Change the Order displayed by your name")
+                .addSection(new DialogSection()
+                        .setInput(new DialogSelectInput().setOptions(options).setKey("order"))
+                );
+
+        player.showDialog(dialog, ans -> {
+            if(ans.length == 0 || "cancel".equals(ans[0]) || !(ans[0] instanceof String)) return;
+            String newValue = "None".equals(ans[0]) ? null : (String)ans[0];
+            player.setDisplayedOrder(OrderManager.getOrderKeyFromTitle(newValue));
+            player.sendMessage(new EventMessage("playerIconDidChange", player.getIconEmoji()));
+            player.sendMessageToPeers(new EntityChangeMessage(player.getId(), player.getStatusConfig()));
+        });
+    }
+
+    @Override
+    public String getUsage(CommandExecutor executor) {
+        return "/order";
+    }
+}

gameserver/src/main/java/brainwine/gameserver/order/Order.java

@@ -0,0 +1,70 @@
+package brainwine.gameserver.order;
+
+import brainwine.gameserver.dialog.DialogHelper;
+import brainwine.gameserver.player.NotificationType;
+import brainwine.gameserver.player.Player;
+import com.fasterxml.jackson.annotation.JsonIgnore;
+import com.fasterxml.jackson.annotation.JsonProperty;
+
+import java.util.List;
+
+public class Order {
+    @JsonIgnore
+    private String title;
+    @JsonProperty("induction_message")
+    private String inductionMessage;
+    @JsonProperty("advancement_message")
+    private String advancementMessage;
+    @JsonProperty
+    private String key;
+    @JsonProperty
+    private boolean hidden;
+    @JsonProperty
+    private List<OrderTier> tiers;
+
+    public void advance(Player player) {
+        final int initialLevel = player.getOrders().getOrDefault(key, 0);
+        int currentLevel = initialLevel;
+
+        while(currentLevel < tiers.size()) {
+            int previousLevel = currentLevel;
+            currentLevel = advanceOnce(player, currentLevel);
+            if(previousLevel == currentLevel) break;
+        }
+
+        if(currentLevel > initialLevel && !hidden) {
+            String title, message, peerMessage;
+            if(initialLevel == 0) {
+                title = OrderManager.getInductionTitle();
+                message = inductionMessage + " " + title;
+                peerMessage = player.getName() + " " + OrderManager.getPeerInductionMessage() + " " + title;
+            } else {
+                title = OrderManager.getAdvancementTitle();
+                message = advancementMessage + " " + title;
+                peerMessage = player.getName() + " " + OrderManager.getPeerAdvancementMessage() + " " + title;
+            }
+
+            player.showDialog(DialogHelper.messageDialog(title, message));
+            player.notifyPeers(peerMessage, NotificationType.SYSTEM);
+        }
+    }
+
+    public int advanceOnce(Player player, int currentLevel) {
+        if (currentLevel == tiers.size()) return currentLevel;
+        OrderTier nextTier = tiers.get(currentLevel);
+        player.getOrders().put(key, nextTier.satisfies(player) ? currentLevel + 1 : currentLevel);
+        return player.getOrders().get(key);
+    }
+
+    public String getKey() {
+        return key;
+    }
+
+    public String getTitle() {
+        return title;
+    }
+
+    public void setTitle(String title) {
+        this.title = title;
+    }
+}

gameserver/src/main/java/brainwine/gameserver/order/OrderManager.java

@@ -0,0 +1,92 @@
+package brainwine.gameserver.order;
+
+import brainwine.gameserver.GameConfiguration;
+import brainwine.gameserver.player.Player;
+import brainwine.gameserver.util.MapHelper;
+import brainwine.shared.JsonHelper;
+import com.fasterxml.jackson.core.type.TypeReference;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+import java.io.IOException;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+import static brainwine.shared.LogMarkers.SERVER_MARKER;
+
+public class OrderManager {
+    private static Map<String, Order> orders = new HashMap<>();
+    private static Map<String, Order> ordersByTitle = new HashMap<>();
+    private static String inductionTitle = "You've been inducted into an Order!";
+    private static String advancementTitle = "You've advanced in an Order!";
+    private static String peerInductionMessage = "has been inducted into the";
+    private static String peerAdvancementMessage = "has advanced within the";
+    private static final Logger logger = LogManager.getLogger();
+
+    private OrderManager() {}
+
+    public static void loadOrders() {
+        try {
+            Map<String, Object> ordersMap = new HashMap<>(MapHelper.getMap(GameConfiguration.getBaseConfig(), "orders"));
+            Map<String, String> common = MapHelper.getMap(ordersMap, "all");
+
+            if (common != null) {
+                inductionTitle = MapHelper.getString(common, "induction_title", inductionTitle);
+                advancementTitle = MapHelper.getString(common, "advancement_title", advancementTitle);
+                peerInductionMessage = MapHelper.getString(common, "peer_induction_message", peerInductionMessage);
+                peerAdvancementMessage = MapHelper.getString(common, "peer_advancement_message", peerAdvancementMessage);
+            }
+
+            ordersMap.remove("all");
+
+            ordersByTitle.putAll(JsonHelper.readValue(ordersMap, new TypeReference<Map<String, Order>>() {}));
+
+            for(Map.Entry<String, Order> orderPair : ordersByTitle.entrySet()) {
+                orderPair.getValue().setTitle(orderPair.getKey());
+                orders.put(orderPair.getValue().getKey(), orderPair.getValue());
+            }
+        } catch (IOException e) {
+            logger.error(SERVER_MARKER, "Failed to load orders", e);
+        }
+    }
+
+    public static void advance(Player player) {
+        for(Order order : orders.values()) {
+            order.advance(player);
+        }
+    }
+
+    public static Map<String, Order> getOrders() {
+        return Collections.unmodifiableMap(orders);
+    }
+
+    public static Map<Order, Integer> getOrders(Player player) {
+        return player.getOrders().entrySet().stream()
+                .filter(e -> e.getValue() > 0 && orders.containsKey(e.getKey()))
+                .collect(Collectors.toMap(e -> orders.get(e.getKey()), Map.Entry::getValue));
+    }
+
+    public static String getOrderKeyFromTitle(String title) {
+        Order order = ordersByTitle.get(title);
+
+        return order == null ? null : order.getKey();
+    }
+
+    public static String getInductionTitle() {
+        return inductionTitle;
+    }
+
+    public static String getAdvancementTitle() {
+        return advancementTitle;
+    }
+
+    public static String getPeerInductionMessage() {
+        return peerInductionMessage;
+    }
+
+    public static String getPeerAdvancementMessage() {
+        return peerAdvancementMessage;
+    }
+}

gameserver/src/main/java/brainwine/gameserver/order/OrderTier.java

@@ -0,0 +1,63 @@
+package brainwine.gameserver.order;
+
+import brainwine.gameserver.entity.EntityGroup;
+import brainwine.gameserver.entity.EntityRegistry;
+import brainwine.gameserver.player.Player;
+import com.fasterxml.jackson.annotation.JsonProperty;
+
+import java.util.Map;
+
+public class OrderTier {
+    @JsonProperty
+    private Map<String, Integer> requirements;
+
+    public boolean satisfies(Player player) {
+        for(String requirement : requirements.keySet()) {
+            int compare = Integer.MAX_VALUE;
+            switch(requirement) {
+                case "level":
+                    compare = player.getLevel();
+                    break;
+                case "progress/chunks explored":
+                    compare = player.getStatistics().getAreasExplored();
+                    break;
+                case "progress/teleporters discovered":
+                    compare = player.getStatistics().getTeleporterDiscoveries();
+                    break;
+                case "progress/creatures killed":
+                    compare = player.getStatistics().getTotalKills();
+                    break;
+                case "players_killed":
+                    // TODO: related to KillerAchievement
+                    break;
+                case "progress/dungeons raided":
+                    compare = player.getStatistics().getDungeonsRaided();
+                    break;
+                case "progress/automata killed":
+                    compare = player.getStatistics().getKills(EntityGroup.AUTOMATA);
+                    break;
+                case "progress/supernatural killed":
+                    compare = player.getStatistics().getKills(EntityGroup.SUPERNATURAL);
+                    break;
+                case "progress/inhibitors activated":
+                    // TODO: related to InsurrectionAchievement
+                    break;
+                case "progress/brains killed":
+                    compare = player.getStatistics().getKills(EntityGroup.BRAINS);
+                    break;
+                case "brain_lords_killed":
+                    compare = player.getStatistics().getKills(EntityRegistry.getEntityConfig("brains/large"));
+                    break;
+                case "crowns_spent":
+                    compare = player.getStatistics().getCrownsSpent();
+                    break;
+            }
+
+            if(compare < requirements.get(requirement)) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+}