Free the first subclass after a class move, add per-character class pick admin

src/main/java/net/tfminecraft/rpcharacters/classpick/ClassPickAdminCommand.java

@@ -0,0 +1,172 @@
+package net.tfminecraft.rpcharacters.classpick;
+
+import java.time.Instant;
+import java.util.List;
+import java.util.Locale;
+import java.util.logging.Logger;
+
+import org.bukkit.Bukkit;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+import net.tfminecraft.rpcharacters.RPCharacters;
+import net.tfminecraft.rpcharacters.creation.Stage;
+import net.tfminecraft.rpcharacters.creation.StageEditLock;
+import net.tfminecraft.rpcharacters.creation.StageRevisions;
+import net.tfminecraft.rpcharacters.identity.DisplayIdentityService;
+import net.tfminecraft.rpcharacters.managers.PlayerManager;
+import net.tfminecraft.rpcharacters.objects.PlayerData;
+import net.tfminecraft.rpcharacters.objects.RPCharacter;
+import net.tfminecraft.rpcharacters.paidchange.PaidChangeRule;
+import net.tfminecraft.rpcharacters.paidchange.PaidChangeService;
+import net.tfminecraft.rpcharacters.utils.AgeFormatter;
+import net.tfminecraft.rpcharacters.utils.RPTexts;
+
+/**
+ * {@code /rpcharacter admin classpicks <player> [reset|freesubclass|paid <count>]}: staff read or
+ * change the class pick state of the character another online player is playing.
+ * <ul>
+ * <li>no action: show the class, the free window, the paid change count and what picks cost;</li>
+ * <li>{@code reset}: what {@code resetclasses} does, for this character only. Its class stage
+ * window starts again now, paid change prices start over and its next subclass is free;</li>
+ * <li>{@code freesubclass}: only make the next subclass pick free;</li>
+ * <li>{@code paid <count>}: set how many paid class changes it has made, which picks the next
+ * price from the class paid-change rule.</li>
+ * </ul>
+ * The class itself is never changed. Uses the {@code resetclasses} permission.
+ */
+public final class ClassPickAdminCommand {
+
+	public static final String SUBCOMMAND = "classpicks";
+	public static final List<String> ACTIONS = List.of("reset", "freesubclass", "paid");
+	static final String USAGE = "Usage: /rpcharacter admin classpicks <player> [reset|freesubclass|paid <count>]";
+
+	private static final Logger LOG = Logger.getLogger("RPCharacters");
+
+	private ClassPickAdminCommand() {}
+
+	public static boolean canUse(CommandSender sender) {
+		return ClassPickReset.canUse(sender);
+	}
+
+	public static boolean handle(CommandSender sender, String[] args, int index) {
+		if (!canUse(sender)) {
+			RPTexts.send(sender, RPTexts.ERROR + "You do not have permission to use this command.");
+			return true;
+		}
+		if (args.length <= index || args.length > index + 3) {
+			RPTexts.send(sender, RPTexts.ERROR + USAGE);
+			return true;
+		}
+		Player target = Bukkit.getPlayerExact(args[index]);
+		PlayerData data = target == null ? null : PlayerManager.get(target);
+		RPCharacter character = data == null ? null : data.getActiveCharacter();
+		if (character == null) {
+			RPTexts.send(sender, RPTexts.ERROR + (target == null ? "No online player called " : "No active character for ")
+					+ RPTexts.WARN + args[index] + RPTexts.ERROR + ".");
+			return true;
+		}
+		Stage stage = ClassPickService.classStage();
+		PaidChangeRule rule = PaidChangeService.ruleFor(stage);
+		String who = RPTexts.MUTED + "Character " + RPTexts.WARN + DisplayIdentityService.resolveCharacterName(character)
+				+ RPTexts.MUTED + " (" + target.getName() + ")";
+		if (args.length == index + 1) {
+			sendInfo(sender, who, character, stage, rule);
+			return true;
+		}
+		String action = args[index + 1].toLowerCase(Locale.ROOT);
+		boolean paid = action.equals("paid");
+		if (!ACTIONS.contains(action) || paid != (args.length == index + 3)) {
+			RPTexts.send(sender, RPTexts.ERROR + USAGE);
+			return true;
+		}
+		if (character.getPendingClassPick() != null || character.getPendingPaidChange() != null) {
+			RPTexts.send(sender, who + RPTexts.ERROR + " has a class payment still being settled. Try again in a moment.");
+			return true;
+		}
+		String done;
+		switch (action) {
+			case "reset" -> {
+				if (stage == null) {
+					RPTexts.send(sender, RPTexts.ERROR + "There is no class stage in stages.yml to reset.");
+					return true;
+				}
+				reset(character, stage, rule, Instant.now().getEpochSecond());
+				done = " can change class and subclass for free " + window(stage) + ", paid change prices start over"
+						+ " and the next subclass is free.";
+			}
+			case "freesubclass" -> {
+				character.setSubclassPicked(false);
+				done = " gets its next subclass pick for free.";
+			}
+			default -> {
+				if (rule == null) {
+					RPTexts.send(sender, RPTexts.ERROR + "There is no class paid-change rule in config.yml, so class"
+							+ " changes always cost " + ClassPickService.priceText(ClassPickService.settings().changeCost()) + ".");
+					return true;
+				}
+				Integer count = parseCount(args[index + 2]);
+				if (count == null) {
+					RPTexts.send(sender, RPTexts.ERROR + "The count must be a whole number from 0 up.");
+					return true;
+				}
+				character.setPaidChangeCount(rule.getStageId(), count);
+				done = " has " + count + " paid class changes. The next paid change costs "
+						+ ClassPickService.priceText(rule.costAfter(count)) + ".";
+			}
+		}
+		RPCharacters.getPlayerManager().savePlayer(target);
+		LOG.info("[RPCharacters] " + sender.getName() + " ran classpicks " + action
+				+ (paid ? " " + args[index + 2] : "") + " for " + target.getName() + " (character " + character.getId() + ").");
+		RPTexts.send(sender, who + RPTexts.SUCCESS + done);
+		if (!target.equals(sender) && !action.equals("paid")) {
+			RPTexts.sendPrefixed(target, RPTexts.SUCCESS + (action.equals("reset")
+					? "Staff reset your class picks: class and subclass changes are free " + window(stage) + "."
+					: "Staff made your next subclass pick free."));
+		}
+		return true;
+	}
+
+	/** One character's {@code resetclasses}: a fresh class window from now, no paid changes, a free subclass. */
+	static void reset(RPCharacter character, Stage stage, PaidChangeRule rule, long nowEpochSeconds) {
+		String key = StageRevisions.key(stage);
+		character.setStageRevision(key, Math.max(stage.getRevision(), character.getStageRevision(key)), nowEpochSeconds);
+		character.setPaidChangeCount(key, 0);
+		if (rule != null) {
+			character.setPaidChangeCount(rule.getStageId(), 0);
+		}
+		character.setSubclassPicked(false);
+	}
+
+	private static void sendInfo(CommandSender sender, String who, RPCharacter character, Stage stage, PaidChangeRule rule) {
+		String className = character.hasMMOClass() ? character.getMMOClass() : "none";
+		RPTexts.send(sender, who + RPTexts.MUTED + ": class " + RPTexts.WARN + className);
+		long freeFor = stage == null ? 0L : StageEditLock.lockRemainingMs(stage, character);
+		boolean open = stage != null && StageEditLock.canEdit(stage, character);
+		RPTexts.send(sender, RPTexts.MUTED + "Free class changes: " + RPTexts.WARN + (!open ? "no, window closed"
+				: freeFor > 0 ? "for " + AgeFormatter.formatCountdown(freeFor) : "always"));
+		RPTexts.send(sender, RPTexts.MUTED + "Next subclass pick free: " + RPTexts.WARN
+				+ (ClassPickService.freeSubclassOpen(character) ? "yes" : "no"));
+		if (rule == null) {
+			RPTexts.send(sender, RPTexts.MUTED + "Class changes cost: " + RPTexts.WARN
+					+ ClassPickService.priceText(ClassPickService.settings().changeCost()));
+			return;
+		}
+		int paid = character.getPaidChangeCount(rule.getStageId());
+		RPTexts.send(sender, RPTexts.MUTED + "Paid class changes: " + RPTexts.WARN + paid + RPTexts.MUTED
+				+ ", next paid change costs " + RPTexts.WARN + ClassPickService.priceText(rule.costAfter(paid)));
+	}
+
+	private static String window(Stage stage) {
+		return stage.getLockTimeMs() < 0 ? "always" : "for " + AgeFormatter.formatCountdown(stage.getLockTimeMs());
+	}
+
+	private static Integer parseCount(String token) {
+		try {
+			int count = Integer.parseInt(token);
+			return count < 0 ? null : count;
+		} catch (NumberFormatException e) {
+			return null;
+		}
+	}
+}

src/main/java/net/tfminecraft/rpcharacters/classpick/ClassPickService.java

@@ -40,9 +40,11 @@
 
 /**
  * Class and subclass picks for the active character, in place of MMOCore class points. A
- * character's first class and first subclass are free. Other picks are class changes, priced like
- * the class creation stage: free while its lock window is open, then the class paid-change rule
- * (change-cost when there is no rule). Infinite points make every pick free.
+ * character's first class is free, and so is its first subclass after each base class pick: a
+ * move to another class costs one class change, not a second one for its subclass. Other picks
+ * are class changes, priced like the class creation stage: free while its lock window is open,
+ * then the class paid-change rule (change-cost when there is no rule). Infinite points make every
+ * pick free.
  */
 public final class ClassPickService {
 
@@ -157,18 +159,31 @@ public static PlayerClass subclassOf(RPCharacter character, PlayerClass base) {
 				: null;
 	}
 
-	/** Free for the first class, the first subclass in the current class family, and on infinite points. */
+	/** Free for the first class, a free subclass pick in the current class family, and on infinite points. */
 	public static BigDecimal price(RPCharacter character, Option option) {
 		if (settings.infinitePoints() || !character.hasMMOClass()) {
 			return BigDecimal.ZERO;
 		}
-		if (option.isSubclass() && !character.hasPickedSubclass()
+		if (option.isSubclass() && freeSubclassOpen(character)
 				&& option.base().getId().equalsIgnoreCase(baseClassId(character))) {
 			return BigDecimal.ZERO;
 		}
 		return changePrice(character);
 	}
 
+	/**
+	 * True while the character's next subclass pick is free: it has never picked one, staff reset
+	 * its picks, or it is on a base class now. A character only gets back to a base class through
+	 * a class change, so a later subclass of that class must not be priced as a second change.
+	 */
+	public static boolean freeSubclassOpen(RPCharacter character) {
+		if (!character.hasPickedSubclass()) {
+			return true;
+		}
+		Option current = option(character.getMMOClass());
+		return current == null || !current.isSubclass();
+	}
+
 	/** The character's class, or the base class of its subclass. */
 	private static String baseClassId(RPCharacter character) {
 		Option current = option(character.getMMOClass());
@@ -295,14 +310,19 @@ private static boolean hold(UUID owner, RPCharacter character, String targetClas
 	/** Counts a kept paid pick and clears its hold. */
 	private static void countPaid(RPCharacter character) {
 		character.setPendingClassPick(null);
-		character.setPaidClassPicks(character.getPaidClassPicks() + 1);
+		character.setPaidClassPicks(saturatedIncrement(character.getPaidClassPicks()));
 		PaidChangeRule rule = PaidChangeService.ruleFor(classStage());
 		if (rule != null) {
 			// Shared with paid class-stage edits, so the next change costs the next price.
-			character.setPaidChangeCount(rule.getStageId(), character.getPaidChangeCount(rule.getStageId()) + 1);
+			// Saturates, so a staff-set maximum never wraps back to the first price.
+			character.setPaidChangeCount(rule.getStageId(), saturatedIncrement(character.getPaidChangeCount(rule.getStageId())));
 		}
 	}
 
+	private static int saturatedIncrement(int count) {
+		return count == Integer.MAX_VALUE ? count : count + 1;
+	}
+
 	/**
 	 * Settles a paid pick left held by a crash or a failed refund. A debit that never applied is
 	 * dropped; a pick whose class stuck (and was not marked for refund) is kept and counted;
@@ -403,7 +423,7 @@ public static List<String> pricingLore(RPCharacter character, String heading) {
 			lines.add(RPTexts.MUTED + "Class picks: " + RPTexts.WARN + "Free");
 			return lines;
 		}
-		if (!character.hasPickedSubclass()) {
+		if (freeSubclassOpen(character)) {
 			lines.add(RPTexts.MUTED + "First subclass: " + RPTexts.WARN + "Free");
 		}
 		Stage stage = classStage();

src/main/java/net/tfminecraft/rpcharacters/managers/CommandManager.java

@@ -16,6 +16,7 @@
 import net.Indyuce.mmocore.api.player.profess.PlayerClass;
 import net.tfminecraft.rpcharacters.Cache;
 import net.tfminecraft.rpcharacters.classpick.ClassPickGui;
+import net.tfminecraft.rpcharacters.classpick.ClassPickAdminCommand;
 import net.tfminecraft.rpcharacters.classpick.ClassPickReset;
 import net.tfminecraft.rpcharacters.loaders.ChatLoader;
 import net.tfminecraft.rpcharacters.loaders.TraitLoader;
@@ -85,6 +86,10 @@ public boolean onCommand(CommandSender sender, Command cmd, String label, String
 				&& args[1].equalsIgnoreCase(ClassPickReset.SUBCOMMAND)) {
 			return ClassPickReset.handle(sender, args, 2);
 		}
+		if (args.length >= 2 && args[0].equalsIgnoreCase("admin")
+				&& args[1].equalsIgnoreCase(ClassPickAdminCommand.SUBCOMMAND)) {
+			return ClassPickAdminCommand.handle(sender, args, 2);
+		}
 		if (args.length >= 2 && args[0].equalsIgnoreCase("admin")
 				&& args[1].equalsIgnoreCase(PrisonSwitch.SUBCOMMAND)) {
 			return PrisonSwitch.handle(sender, args, 2);
@@ -758,7 +763,7 @@ private static boolean handleAdmin(CommandSender sender, String[] args) {
 			return true;
 		}
 		if (args.length < 2) {
-			RPTexts.send(sender, RPTexts.ERROR + "Usage: /rpcharacter admin <injure|permakill|strikes|tutorial|resetclasses|carryexp|prison|hide> ...");
+			RPTexts.send(sender, RPTexts.ERROR + "Usage: /rpcharacter admin <injure|permakill|strikes|tutorial|resetclasses|classpicks|carryexp|prison|hide> ...");
 			return true;
 		}
 		if (args[1].equalsIgnoreCase("injure")) {
@@ -777,7 +782,7 @@ private static boolean handleAdmin(CommandSender sender, String[] args) {
 		if (args[1].equalsIgnoreCase(net.tfminecraft.rpcharacters.mmocore.CarriedExperience.SUBCOMMAND)) {
 			return net.tfminecraft.rpcharacters.mmocore.CarriedExperience.handle(sender, args, 2);
 		}
-		RPTexts.send(sender, RPTexts.ERROR + "Usage: /rpcharacter admin <injure|permakill|strikes|tutorial|resetclasses|carryexp|prison|hide> ...");
+		RPTexts.send(sender, RPTexts.ERROR + "Usage: /rpcharacter admin <injure|permakill|strikes|tutorial|resetclasses|classpicks|carryexp|prison|hide> ...");
 		return true;
 	}
 

src/main/java/net/tfminecraft/rpcharacters/utils/CommandTabCompleter.java

@@ -16,6 +16,7 @@
 import org.bukkit.entity.Player;
 
 import net.tfminecraft.rpcharacters.Cache;
+import net.tfminecraft.rpcharacters.classpick.ClassPickAdminCommand;
 import net.tfminecraft.rpcharacters.classpick.ClassPickReset;
 import net.tfminecraft.rpcharacters.enums.Status;
 import net.tfminecraft.rpcharacters.loaders.TraitLoader;
@@ -109,6 +110,10 @@ public List<String> onTabComplete(CommandSender sender, Command cmd, String labe
 				&& ClassPickReset.canUse(sender)) {
 			return filter(List.of("confirm"), args[2]);
 		}
+		if (sub.equals("admin") && args.length >= 3 && args[1].equalsIgnoreCase(ClassPickAdminCommand.SUBCOMMAND)
+				&& ClassPickAdminCommand.canUse(sender)) {
+			return completeClassPicks(args);
+		}
 		if (sub.equals("admin") && args.length >= 3 && args[1].equalsIgnoreCase(PrisonSwitch.SUBCOMMAND)
 				&& PrisonSwitch.canUse(sender)) {
 			return completePrison(args);
@@ -182,6 +187,7 @@ public List<String> onTabComplete(CommandSender sender, Command cmd, String labe
 				}
 				if (ClassPickReset.canUse(sender)) {
 					completions.add(ClassPickReset.SUBCOMMAND);
+					completions.add(ClassPickAdminCommand.SUBCOMMAND);
 				}
 				if (HiddenCharacterAdminCommand.canUse(sender)) {
 					completions.add(HiddenCharacterAdminCommand.SUBCOMMAND);
@@ -326,6 +332,24 @@ public List<String> onTabComplete(CommandSender sender, Command cmd, String labe
 		return Collections.emptyList();
 	}
 
+	/** {@code /rpcharacter admin classpicks <player> [reset|freesubclass|paid <count>]}. */
+	private List<String> completeClassPicks(String[] args) {
+		if (args.length == 3) {
+			List<String> names = new ArrayList<>();
+			for (Player online : Bukkit.getOnlinePlayers()) {
+				names.add(online.getName());
+			}
+			return filter(names, args[2]);
+		}
+		if (args.length == 4) {
+			return filter(ClassPickAdminCommand.ACTIONS, args[3]);
+		}
+		if (args.length == 5 && args[3].equalsIgnoreCase("paid")) {
+			return filter(List.of("0", "1", "2"), args[4]);
+		}
+		return Collections.emptyList();
+	}
+
 	/** {@code /rpcharacter admin hide <player> [on|off]}. */
 	private List<String> completeHide(String[] args) {
 		String last = args[args.length - 1];