feat(classes): add tyrant class assignment

src/main/java/games/dmg/spigottyrant/BukkitOnlinePlayerDirectory.java

@@ -0,0 +1,17 @@
+package games.dmg.spigottyrant;
+
+import java.util.UUID;
+import org.bukkit.Bukkit;
+import org.bukkit.entity.Player;
+
+public final class BukkitOnlinePlayerDirectory implements OnlinePlayerDirectory {
+    @Override
+    public Player findByName(String name) {
+        return Bukkit.getPlayerExact(name);
+    }
+
+    @Override
+    public Player findById(UUID playerId) {
+        return Bukkit.getPlayer(playerId);
+    }
+}

src/main/java/games/dmg/spigottyrant/ClassAssignmentMessages.java

@@ -0,0 +1,18 @@
+package games.dmg.spigottyrant;
+
+public final class ClassAssignmentMessages {
+    private ClassAssignmentMessages() {
+    }
+
+    public static String loginReminder(PlayerState player) {
+        return switch (player.tyrantClass()) {
+            case ASSASSIN -> "Class: ASSASSIN. Use your Assassin Cloak; double-jump while "
+                + "airborne. Use /tyrant item to recover ready class items.";
+            case FIXER -> "Class: FIXER. Use your Fixer's Wrench to activate your boost. "
+                + "Use /tyrant item to recover ready class items.";
+            case TAMER -> "Class: TAMER. Use your Tamer's Lead to capture mobs. "
+                + "Use /tyrant item to recover ready class items.";
+            case NONE -> "";
+        };
+    }
+}

src/main/java/games/dmg/spigottyrant/ClassAssignmentResult.java

@@ -0,0 +1,16 @@
+package games.dmg.spigottyrant;
+
+import java.util.Map;
+import java.util.Optional;
+import java.util.UUID;
+
+public record ClassAssignmentResult(
+    Map<UUID, PlayerState> players,
+    ClassAssignmentStatus status,
+    Optional<UUID> previousHolderId
+) {
+    public ClassAssignmentResult {
+        players = Map.copyOf(players);
+        previousHolderId = previousHolderId == null ? Optional.empty() : previousHolderId;
+    }
+}

src/main/java/games/dmg/spigottyrant/ClassAssignmentService.java

@@ -0,0 +1,129 @@
+package games.dmg.spigottyrant;
+
+import java.time.Instant;
+import java.util.EnumMap;
+import java.util.EnumSet;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Optional;
+import java.util.Set;
+import java.util.UUID;
+
+public final class ClassAssignmentService {
+    public ClassAssignmentResult assign(
+        GameState game,
+        Map<UUID, PlayerState> players,
+        UUID assignerId,
+        UUID targetId,
+        TyrantClass tyrantClass,
+        Instant now
+    ) {
+        ClassAssignmentStatus rejected = rejection(
+            game, players, assignerId, targetId, tyrantClass, now
+        );
+        if (rejected != null) {
+            return new ClassAssignmentResult(players, rejected, Optional.empty());
+        }
+
+        Map<UUID, PlayerState> updated = new HashMap<>(players);
+        Optional<UUID> previousHolder = players.values().stream()
+            .filter(player -> player.tyrantClass() == tyrantClass)
+            .map(PlayerState::playerId)
+            .filter(playerId -> !playerId.equals(targetId))
+            .findFirst();
+        previousHolder.ifPresent(playerId -> updated.put(
+            playerId,
+            withClass(updated.get(playerId), TyrantClass.NONE)
+        ));
+        updated.put(targetId, withClass(updated.get(targetId), tyrantClass));
+        return new ClassAssignmentResult(
+            updated,
+            ClassAssignmentStatus.ASSIGNED,
+            previousHolder
+        );
+    }
+
+    public Map<UUID, PlayerState> clearAll(Map<UUID, PlayerState> players) {
+        Map<UUID, PlayerState> updated = new HashMap<>();
+        for (PlayerState player : players.values()) {
+            updated.put(player.playerId(), withClass(player, TyrantClass.NONE));
+        }
+        return Map.copyOf(updated);
+    }
+
+    private static ClassAssignmentStatus rejection(
+        GameState game,
+        Map<UUID, PlayerState> players,
+        UUID assignerId,
+        UUID targetId,
+        TyrantClass tyrantClass,
+        Instant now
+    ) {
+        if (game.lifecycle() != GameLifecycle.RUNNING) {
+            return ClassAssignmentStatus.GAME_NOT_RUNNING;
+        }
+        if (game.tyrantId().isEmpty() || !game.tyrantId().orElseThrow().equals(assignerId)) {
+            return ClassAssignmentStatus.NOT_TYRANT;
+        }
+        if (tyrantClass == null || tyrantClass == TyrantClass.NONE) {
+            return ClassAssignmentStatus.INVALID_CLASS;
+        }
+        if (!game.purchases().contains(unlockFor(tyrantClass))) {
+            return ClassAssignmentStatus.CLASS_NOT_UNLOCKED;
+        }
+        PlayerState target = players.get(targetId);
+        if (target == null) {
+            return ClassAssignmentStatus.UNKNOWN_PLAYER;
+        }
+        if (targetId.equals(assignerId)) {
+            return ClassAssignmentStatus.TARGET_IS_TYRANT;
+        }
+        if (target.optedOutUntil().filter(until -> until.isAfter(now)).isPresent()) {
+            return ClassAssignmentStatus.TARGET_OPTED_OUT;
+        }
+        return null;
+    }
+
+    private static TyrantUnlock unlockFor(TyrantClass tyrantClass) {
+        return switch (tyrantClass) {
+            case ASSASSIN -> TyrantUnlock.ASSASSIN;
+            case FIXER -> TyrantUnlock.FIXER;
+            case TAMER -> TyrantUnlock.TAMER;
+            case NONE -> throw new IllegalArgumentException("NONE is not assignable");
+        };
+    }
+
+    private static PlayerState withClass(PlayerState player, TyrantClass tyrantClass) {
+        Map<Ability, Instant> cooldowns = new EnumMap<>(Ability.class);
+        cooldowns.putAll(player.cooldownEnds());
+        Set<Ability> readyItems = EnumSet.noneOf(Ability.class);
+        readyItems.addAll(player.readyAbilityItems());
+        for (Ability ability : abilitiesFor(player.tyrantClass())) {
+            cooldowns.remove(ability);
+            readyItems.remove(ability);
+        }
+        return new PlayerState(
+            player.playerId(),
+            player.latestName(),
+            player.lastLogin(),
+            player.optedOutUntil(),
+            tyrantClass,
+            player.followerOf(),
+            cooldowns,
+            readyItems,
+            player.capturedMobs()
+        );
+    }
+
+    private static Set<Ability> abilitiesFor(TyrantClass tyrantClass) {
+        return switch (tyrantClass) {
+            case ASSASSIN -> Set.of(
+                Ability.ASSASSIN_INVISIBILITY,
+                Ability.ASSASSIN_DOUBLE_JUMP
+            );
+            case FIXER -> Set.of(Ability.FIXER_BOOST);
+            case TAMER -> Set.of(Ability.TAMER_CAPTURE);
+            case NONE -> Set.of();
+        };
+    }
+}

src/main/java/games/dmg/spigottyrant/ClassAssignmentStatus.java

@@ -0,0 +1,12 @@
+package games.dmg.spigottyrant;
+
+public enum ClassAssignmentStatus {
+    ASSIGNED,
+    GAME_NOT_RUNNING,
+    NOT_TYRANT,
+    CLASS_NOT_UNLOCKED,
+    INVALID_CLASS,
+    UNKNOWN_PLAYER,
+    TARGET_IS_TYRANT,
+    TARGET_OPTED_OUT
+}

src/main/java/games/dmg/spigottyrant/OnlinePlayerDirectory.java

@@ -0,0 +1,10 @@
+package games.dmg.spigottyrant;
+
+import java.util.UUID;
+import org.bukkit.entity.Player;
+
+public interface OnlinePlayerDirectory {
+    Player findByName(String name);
+
+    Player findById(UUID playerId);
+}

src/main/java/games/dmg/spigottyrant/PlayerJoinListener.java

@@ -0,0 +1,33 @@
+package games.dmg.spigottyrant;
+
+import java.time.Clock;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.player.PlayerJoinEvent;
+
+public final class PlayerJoinListener implements Listener {
+    private final TyrantStateManager stateManager;
+    private final Clock clock;
+
+    public PlayerJoinListener(TyrantStateManager stateManager, Clock clock) {
+        this.stateManager = stateManager;
+        this.clock = clock;
+    }
+
+    @EventHandler
+    public void onJoin(PlayerJoinEvent event) {
+        PlayerState player = stateManager.updatePlayer(
+            event.getPlayer().getUniqueId(),
+            event.getPlayer().getName(),
+            current -> new PlayerState(
+                current.playerId(), current.latestName(), java.util.Optional.of(clock.instant()),
+                current.optedOutUntil(), current.tyrantClass(), current.followerOf(),
+                current.cooldownEnds(), current.readyAbilityItems(), current.capturedMobs()
+            )
+        );
+        String reminder = ClassAssignmentMessages.loginReminder(player);
+        if (!reminder.isEmpty()) {
+            event.getPlayer().sendMessage(reminder);
+        }
+    }
+}

src/main/java/games/dmg/spigottyrant/SpigotTyrantPlugin.java

@@ -1,6 +1,7 @@
 package games.dmg.spigottyrant;
 
 import java.io.IOException;
+import java.time.Clock;
 import java.util.Map;
 import java.util.Objects;
 import java.util.logging.Level;
@@ -28,6 +29,10 @@ public final class SpigotTyrantPlugin extends JavaPlugin {
 
         Objects.requireNonNull(getCommand("tyrant"), "Missing tyrant command metadata")
             .setExecutor(new TyrantCommand(stateManager, new TyrantProgressionService()));
+        getServer().getPluginManager().registerEvents(
+            new PlayerJoinListener(stateManager, Clock.systemUTC()),
+            this
+        );
         getServer().getScheduler().runTaskTimer(this, stateManager::saveIfDirty, 600L, 600L);
         getLogger().info("Spigot Tyrant enabled.");
     }

src/main/java/games/dmg/spigottyrant/TyrantCommand.java

@@ -1,5 +1,6 @@
 package games.dmg.spigottyrant;
 
+import java.time.Clock;
 import java.util.Locale;
 import org.bukkit.ChatColor;
 import org.bukkit.command.Command;
@@ -10,13 +11,35 @@ import org.bukkit.entity.Player;
 public final class TyrantCommand implements CommandExecutor {
     private final TyrantStateManager stateManager;
     private final TyrantProgressionService progression;
+    private final ClassAssignmentService assignments;
+    private final OnlinePlayerDirectory onlinePlayers;
+    private final Clock clock;
 
     public TyrantCommand(
         TyrantStateManager stateManager,
         TyrantProgressionService progression
+    ) {
+        this(
+            stateManager,
+            progression,
+            new ClassAssignmentService(),
+            new BukkitOnlinePlayerDirectory(),
+            Clock.systemUTC()
+        );
+    }
+
+    TyrantCommand(
+        TyrantStateManager stateManager,
+        TyrantProgressionService progression,
+        ClassAssignmentService assignments,
+        OnlinePlayerDirectory onlinePlayers,
+        Clock clock
     ) {
         this.stateManager = stateManager;
         this.progression = progression;
+        this.assignments = assignments;
+        this.onlinePlayers = onlinePlayers;
+        this.clock = clock;
     }
 
     @Override
@@ -38,7 +61,15 @@ public final class TyrantCommand implements CommandExecutor {
             buy(player, arguments[1]);
             return true;
         }
-        player.sendMessage(ChatColor.YELLOW + "Usage: /tyrant choices | /tyrant buy <unlock>");
+        if (arguments.length == 3 && arguments[0].equalsIgnoreCase("assign")) {
+            assign(player, arguments[1], arguments[2]);
+            return true;
+        }
+        player.sendMessage(
+            ChatColor.YELLOW
+                + "Usage: /tyrant choices | /tyrant buy <unlock> | "
+                + "/tyrant assign <class> <player>"
+        );
         return true;
     }
 
@@ -79,8 +110,53 @@ public final class TyrantCommand implements CommandExecutor {
         } else {
             player.sendMessage(
                 ChatColor.RED + "Could not purchase " + unlock.name() + ": "
-                    + result[0].status().name().toLowerCase(Locale.ROOT).replace('_', ' ')
+                    + readable(result[0].status())
             );
         }
     }
+
+    private void assign(Player tyrant, String requestedClass, String targetName) {
+        TyrantClass tyrantClass;
+        try {
+            tyrantClass = TyrantClass.valueOf(requestedClass.toUpperCase(Locale.ROOT));
+        } catch (IllegalArgumentException exception) {
+            tyrant.sendMessage(ChatColor.RED + "Unknown class. Use assassin, fixer, or tamer.");
+            return;
+        }
+        Player target = onlinePlayers.findByName(targetName);
+        if (target == null) {
+            tyrant.sendMessage(ChatColor.RED + "That player must be online.");
+            return;
+        }
+        stateManager.player(target.getUniqueId(), target.getName());
+        ClassAssignmentResult result = assignments.assign(
+            stateManager.game(),
+            stateManager.players(),
+            tyrant.getUniqueId(),
+            target.getUniqueId(),
+            tyrantClass,
+            clock.instant()
+        );
+        if (result.status() != ClassAssignmentStatus.ASSIGNED) {
+            tyrant.sendMessage(
+                ChatColor.RED + "Could not assign " + tyrantClass.name() + ": "
+                    + readable(result.status())
+            );
+            return;
+        }
+        stateManager.replacePlayers(result.players());
+        stateManager.saveIfDirty();
+        result.previousHolderId().map(onlinePlayers::findById).ifPresent(previous ->
+            previous.sendMessage(ChatColor.YELLOW + "You are no longer the "
+                + tyrantClass.name() + ".")
+        );
+        target.sendMessage(ChatColor.GREEN + "You are now the " + tyrantClass.name() + ".");
+        tyrant.sendMessage(
+            ChatColor.GREEN + "Assigned " + tyrantClass.name() + " to " + target.getName() + "."
+        );
+    }
+
+    private static String readable(Enum<?> status) {
+        return status.name().toLowerCase(Locale.ROOT).replace('_', ' ');
+    }
 }

src/main/java/games/dmg/spigottyrant/TyrantStateManager.java

@@ -64,6 +64,12 @@ public final class TyrantStateManager {
         return changed;
     }
 
+    public void replacePlayers(Map<UUID, PlayerState> replacement) {
+        players.clear();
+        players.putAll(replacement);
+        dirty = true;
+    }
+
     public GameState updateGame(UnaryOperator<GameState> update) {
         game = update.apply(game);
         dirty = true;

src/main/resources/plugin.yml

@@ -7,4 +7,4 @@ author: dmg.games
 commands:
   tyrant:
     description: View and use Spigot Tyrant game features.
-    usage: /tyrant [choices|buy <unlock>]
+    usage: /tyrant [choices|buy <unlock>|assign <class> <player>]