1 files changed, 82 insertions, 0 deletions

diff --git a/src/ch/epfl/xblast/server/PlayerPriorityManager.java b/src/ch/epfl/xblast/server/PlayerPriorityManager.java
new file mode 100644
index 0000000..ce6e12a
--- /dev/null
+++ b/src/ch/epfl/xblast/server/PlayerPriorityManager.java
@@ -0,0 +1,82 @@
+package ch.epfl.xblast.server;
+
+import ch.epfl.xblast.Lists;
+import ch.epfl.xblast.PlayerID;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.Map;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+
+/**
+ * The player priority manager providing a sequential priority conflict resolution method.
+ *
+ * @author Pacien TRAN-GIRARD (261948)
+ */
+public final class PlayerPriorityManager {
+
+    /**
+     * The list of player priority order permutations.
+     */
+    private static final List<List<PlayerID>> PLAYER_PRIORITY_ORDERS = buildPlayerPriorityOrderList();
+
+    private PlayerPriorityManager() {
+        // Static class
+    }
+
+    /**
+     * Builds and returns the player priority order permutations.
+     *
+     * @return the list of player priority orders
+     */
+    private static List<List<PlayerID>> buildPlayerPriorityOrderList() {
+        return Lists.permutations(Arrays.asList(PlayerID.values()));
+    }
+
+    /**
+     * Returns the current player priority order permutation.
+     *
+     * @param ticks the current GameState ticks
+     * @return the player priority order
+     */
+    private static List<PlayerID> getCurrentPlayerPriorityOrder(int ticks) {
+        int priorityIndex = ticks % PLAYER_PRIORITY_ORDERS.size();
+        return PLAYER_PRIORITY_ORDERS.get(priorityIndex);
+    }
+
+    /**
+     * Resolves a conflict according to the current priority order.
+     *
+     * @param claimants the list of claimants
+     * @param ticks     the current GameState ticks
+     * @return the highest priority player
+     */
+    private static PlayerID resolveConflict(List<PlayerID> claimants, int ticks) {
+        if (claimants == null || claimants.isEmpty()) return null;
+
+        return getCurrentPlayerPriorityOrder(ticks).stream()
+                .filter(claimants::contains)
+                .findFirst().orElse(null);
+    }
+
+    /**
+     * Resolves a conflict according to the current priority order.
+     *
+     * @param claimants the list of claimants
+     * @param ticks     the current GameState ticks
+     * @return the highest priority player
+     */
+    public static Player resolvePlayerConflict(List<Player> claimants, int ticks) {
+        if (claimants == null || claimants.isEmpty()) return null;
+
+        Map<PlayerID, Player> claimantsMap = claimants.stream()
+                .collect(Collectors.toMap(Player::id, Function.identity()));
+
+        List<PlayerID> claimantsIDs = claimants.stream()
+                .map(Player::id).collect(Collectors.toList());
+
+        return claimantsMap.get(resolveConflict(claimantsIDs, ticks));
+    }
+
+}