refactor: own per-character focus in RPCharacters

README.md

@@ -11,6 +11,7 @@ Beyond a name and appearance, characters have traits, professions, injuries, and
 - **Character profiles** — create and switch between characters, with race, traits, descriptions, and website-connected creation.
 - **Roleplay conversation** — use local speech, whispers, shouts, actions, and out-of-character channels, with speech bubbles and channel preferences.
 - **Identity and disguise** — show character identities in social interactions and support masks and alternate personas.
+- **Character focus** — a shared, regenerating per-character resource used by Research and Magic.
 - **Progression and rolls** — bring professions, attributes, and dice rolls into character gameplay.
 - **Injuries and recovery** — represent injuries and prosthetics, with related treatment and progression systems.
 - **Consequences and investigation** — support lethal or nonlethal PvP, graves, and discoverable clues left in the world.

src/main/java/net/tfminecraft/rpcharacters/RPCharacters.java

@@ -109,6 +109,7 @@
 
 public class RPCharacters extends JavaPlugin{
 	public static RPCharacters plugin;
+	private net.tfminecraft.rpcharacters.focus.FocusModule focusModule;
 
 	private final CommandManager commandManager = new CommandManager();
 	private static final PlayerManager playerManager = new PlayerManager();
@@ -231,6 +232,11 @@ public void onEnable() {
 		GraveManager.get().loadAll();
 		MailRecipientDirectory.scanFromDisk();
 		loadPlayers();
+		focusModule = new net.tfminecraft.rpcharacters.focus.FocusModule(this);
+		focusModule.start();
+		var focusCommand = new net.tfminecraft.rpcharacters.focus.FocusCommand(this);
+		getCommand("focus").setExecutor(focusCommand);
+		getCommand("focus").setTabCompleter(focusCommand);
 		startManagers();
 		getCommand(commandManager.cmd1).setExecutor(commandManager);
 		getCommand("rpcharacter").setTabCompleter(new CommandTabCompleter());
@@ -253,6 +259,7 @@ public void onEnable() {
 	}
 	@Override
 	public void onDisable() {
+		if (focusModule != null) focusModule.shutdown();
 		ChatRecipientResolverRegistry.unregister(
 				net.tfminecraft.rpcharacters.party.PartyManager.PARTY_RESOLVER_ID);
 		net.tfminecraft.rpcharacters.ingest.CharacterIngestService.stopPeriodicPull();
@@ -490,11 +497,21 @@ public void createConfigs() {
 	}
 
 	public void reload() {
+		reloadWithFocusStatus();
+	}
+
+	private boolean reloadWithFocusStatus() {
 		loadConfigs();
+		boolean focusReloaded = reloadFocusConfig();
+		if (!focusReloaded) {
+			getLogger().warning("Focus did not reload; see the preceding focus error. "
+					+ "Continuing the other RPCharacters reload steps.");
+		}
 		LastSolidTracker.get().start();
 		ProfessionCommandHandler.reapplyActiveCharacterPerms();
 		// Catalog + pending pull already run inside loadConfigs(); also refresh website sheets.
 		net.tfminecraft.rpcharacters.ingest.RosterSyncService.pushAllOnlineAsync();
+		return focusReloaded;
 	}
 
 	public void reloadConfigs(CommandSender sender) {
@@ -504,10 +521,14 @@ public void reloadConfigs(CommandSender sender) {
 			RPTexts.sendPrefixed(sender, RPTexts.WARN + "Reloading configs...");
 		}
 		try {
-			reload();
-			getLogger().info("Config reload complete (catalog + online roster sync kicked).");
+			boolean focusReloaded = reloadWithFocusStatus();
+			getLogger().info(focusReloaded
+					? "Config reload complete (catalog + online roster sync kicked)."
+					: "Other configs reloaded (catalog + online roster sync kicked); focus did not reload.");
 			if (sender != null) {
-				RPTexts.sendPrefixed(sender, RPTexts.WARN + "Reloading complete!");
+				RPTexts.sendPrefixed(sender, RPTexts.WARN + (focusReloaded
+						? "Reloading complete!"
+						: "Other configs reloaded; focus did not reload. Check console for the focus error."));
 			}
 		} catch (Exception e) {
 			getLogger().severe("Config reload failed: " + e.getMessage());
@@ -518,6 +539,15 @@ public void reloadConfigs(CommandSender sender) {
 		}
 	}
 
+	/** Character focus; null when startup fails. */
+	public static net.tfminecraft.rpcharacters.focus.FocusService getFocusService() {
+		return plugin == null || plugin.focusModule == null ? null : plugin.focusModule.getService();
+	}
+
+	public boolean reloadFocusConfig() {
+		return focusModule != null && focusModule.reloadConfig();
+	}
+
 	public static PlayerManager getPlayerManager() {
 		return playerManager;
 	}

src/main/java/net/tfminecraft/rpcharacters/focus/FocusAttributes.java

@@ -0,0 +1,24 @@
+package net.tfminecraft.rpcharacters.focus;
+
+import org.bukkit.entity.Player;
+
+import net.Indyuce.mmocore.api.player.PlayerData;
+
+final class FocusAttributes {
+
+    private FocusAttributes() {}
+
+    static double getTotal(Player player, String mmocoreId) {
+        if (player == null || mmocoreId == null || mmocoreId.isBlank()) {
+            return 0;
+        }
+        if (player.getServer().getPluginManager().getPlugin("MMOCore") == null) {
+            return 0;
+        }
+        try {
+            return PlayerData.get(player).getAttributes().getInstance(mmocoreId).getTotal();
+        } catch (Exception ex) {
+            return 0;
+        }
+    }
+}

src/main/java/net/tfminecraft/rpcharacters/focus/FocusCommand.java

@@ -0,0 +1,69 @@
+package net.tfminecraft.rpcharacters.focus;
+
+import java.util.List;
+import java.util.Locale;
+
+import org.bukkit.Bukkit;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandExecutor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.command.TabCompleter;
+import org.bukkit.entity.Player;
+
+import net.tfminecraft.rpcharacters.RPCharacters;
+
+public final class FocusCommand implements CommandExecutor, TabCompleter {
+    public static final String PERMISSION = "rpchar.focus.admin";
+    private final RPCharacters plugin;
+
+    public FocusCommand(RPCharacters plugin) {
+        this.plugin = plugin;
+    }
+
+    @Override
+    public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
+        if (!sender.hasPermission(PERMISSION)) {
+            sender.sendMessage("You do not have permission to use this command.");
+            return true;
+        }
+        if (args.length == 1 && args[0].equalsIgnoreCase("reload")) {
+            boolean loaded = plugin.reloadFocusConfig();
+            sender.sendMessage(loaded ? "Focus configuration reloaded."
+                    : "Focus configuration did not reload. Check console for the configuration error.");
+            return true;
+        }
+        if (args.length == 2 && args[0].equalsIgnoreCase("restore")) {
+            Player target = Bukkit.getPlayerExact(args[1]);
+            if (target == null) {
+                sender.sendMessage("Player not found: " + args[1]);
+                return true;
+            }
+            FocusService focus = RPCharacters.getFocusService();
+            if (focus == null || !focus.restore(target)) {
+                sender.sendMessage("Could not restore focus for " + target.getName()
+                        + ". Check their active character and the focus service in console.");
+                return true;
+            }
+            sender.sendMessage("Restored focus for " + target.getName() + " ("
+                    + focus.getPoints(target) + "/" + focus.getMax() + ").");
+            return true;
+        }
+        sender.sendMessage("Usage: /focus restore <player> | /focus reload");
+        return true;
+    }
+
+    @Override
+    public List<String> onTabComplete(CommandSender sender, Command command, String alias, String[] args) {
+        if (!sender.hasPermission(PERMISSION)) return List.of();
+        if (args.length == 1) {
+            return List.of("restore", "reload").stream()
+                    .filter(value -> value.startsWith(args[0].toLowerCase(Locale.ROOT))).toList();
+        }
+        if (args.length == 2 && args[0].equalsIgnoreCase("restore")) {
+            String prefix = args[1].toLowerCase(Locale.ROOT);
+            return Bukkit.getOnlinePlayers().stream().map(Player::getName)
+                    .filter(name -> name.toLowerCase(Locale.ROOT).startsWith(prefix)).sorted().toList();
+        }
+        return List.of();
+    }
+}

src/main/java/net/tfminecraft/rpcharacters/focus/FocusConfig.java

@@ -0,0 +1,25 @@
+package net.tfminecraft.rpcharacters.focus;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public final class FocusConfig {
+
+    public static int max = 150;
+    public static int basePerHour = 10;
+    public static long regenIntervalTicks = 72000L;
+    public static boolean offlineRegen = true;
+    public static final List<RegenBonus> regenBonuses = new ArrayList<>();
+
+    private FocusConfig() {}
+
+    public static final class RegenBonus {
+        public final String mmocoreId;
+        public final double extraPerHourPerPoint;
+
+        public RegenBonus(String mmocoreId, double extraPerHourPerPoint) {
+            this.mmocoreId = mmocoreId;
+            this.extraPerHourPerPoint = extraPerHourPerPoint;
+        }
+    }
+}

src/main/java/net/tfminecraft/rpcharacters/focus/FocusConfigLoader.java

@@ -0,0 +1,46 @@
+package net.tfminecraft.rpcharacters.focus;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.Map;
+
+import org.bukkit.configuration.InvalidConfigurationException;
+import org.bukkit.configuration.file.FileConfiguration;
+import org.bukkit.configuration.file.YamlConfiguration;
+
+import net.tfminecraft.rpcharacters.RPCharacters;
+
+public final class FocusConfigLoader {
+
+    private FocusConfigLoader() {}
+
+    public static boolean load(File file) {
+        return load(file, RPCharacters.plugin.getLogger());
+    }
+
+    static boolean load(File file, java.util.logging.Logger logger) {
+        FileConfiguration config = new YamlConfiguration();
+        try {
+            config.load(file);
+        } catch (IOException | InvalidConfigurationException ex) {
+            logger.severe("[RPCharacters] Failed to load focus.yml: " + ex.getMessage());
+            return false;
+        }
+        FocusConfig.max = Math.max(1, config.getInt("max", FocusConfig.max));
+        FocusConfig.basePerHour = config.getInt("base_per_hour", FocusConfig.basePerHour);
+        FocusConfig.regenIntervalTicks = Math.max(1L, config.getLong("regen_interval_ticks", FocusConfig.regenIntervalTicks));
+        FocusConfig.offlineRegen = config.getBoolean("offline_regen", FocusConfig.offlineRegen);
+        FocusConfig.regenBonuses.clear();
+        for (Map<?, ?> map : config.getMapList("regen_bonuses")) {
+            String id = map.get("mmocore_id") != null ? String.valueOf(map.get("mmocore_id")) : "";
+            double extra = 0;
+            if (map.get("extra_per_hour_per_point") instanceof Number number) {
+                extra = number.doubleValue();
+            }
+            if (!id.isBlank()) {
+                FocusConfig.regenBonuses.add(new FocusConfig.RegenBonus(id, extra));
+            }
+        }
+        return true;
+    }
+}

src/main/java/net/tfminecraft/rpcharacters/focus/FocusData.java

@@ -0,0 +1,95 @@
+package net.tfminecraft.rpcharacters.focus;
+
+public final class FocusData {
+
+    private String characterId;
+    private String ownerUuid;
+    private int points;
+    private long lastRegenMs;
+
+    public FocusData() {}
+
+    public static FocusData createNew(String characterId, String ownerUuid) {
+        FocusData data = new FocusData();
+        data.characterId = characterId;
+        data.ownerUuid = ownerUuid;
+        data.points = FocusConfig.max;
+        data.lastRegenMs = System.currentTimeMillis();
+        return data;
+    }
+
+    public String getCharacterId() {
+        return characterId;
+    }
+
+    public void setCharacterId(String characterId) {
+        this.characterId = characterId;
+    }
+
+    public String getOwnerUuid() {
+        return ownerUuid;
+    }
+
+    public void setOwnerUuid(String ownerUuid) {
+        this.ownerUuid = ownerUuid;
+    }
+
+    public int getPoints() {
+        return points;
+    }
+
+    public void setPoints(int points) {
+        this.points = clamp(points);
+    }
+
+    public long getLastRegenMs() {
+        return lastRegenMs;
+    }
+
+    public void setLastRegenMs(long lastRegenMs) {
+        this.lastRegenMs = lastRegenMs;
+    }
+
+    public int applyRegenForElapsed(double hourlyRate, long intervalMs, long nowMs) {
+        if (intervalMs <= 0 || hourlyRate <= 0) {
+            return 0;
+        }
+        if (points >= FocusConfig.max) {
+            lastRegenMs = nowMs;
+            return 0;
+        }
+        long elapsed = nowMs - lastRegenMs;
+        if (elapsed < intervalMs) {
+            return 0;
+        }
+        long intervals = elapsed / intervalMs;
+        double msPerHour = 3_600_000.0;
+        int perInterval = Math.max(1, (int) Math.round(hourlyRate * intervalMs / msPerHour));
+        int newPoints = Math.min(points + (int) intervals * perInterval, FocusConfig.max);
+        int added = newPoints - points;
+        points = newPoints;
+        lastRegenMs += intervals * intervalMs;
+        return added;
+    }
+
+    public boolean trySpend(int amount) {
+        if (amount <= 0) {
+            return true;
+        }
+        if (points < amount) {
+            return false;
+        }
+        points -= amount;
+        return true;
+    }
+
+    public void grant(int amount) {
+        if (amount > 0) {
+            points = clamp(points + amount);
+        }
+    }
+
+    private static int clamp(int value) {
+        return Math.min(Math.max(0, value), FocusConfig.max);
+    }
+}

src/main/java/net/tfminecraft/rpcharacters/focus/FocusListener.java

@@ -0,0 +1,34 @@
+package net.tfminecraft.rpcharacters.focus;
+
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.player.PlayerQuitEvent;
+
+import net.tfminecraft.rpcharacters.lifecycle.CharacterActivatedEvent;
+
+public final class FocusListener implements Listener {
+
+    private final FocusService service;
+
+    public FocusListener(FocusService service) {
+        this.service = service;
+    }
+
+    @EventHandler
+    public void onCharacterActivated(CharacterActivatedEvent event) {
+        Player owner = event.getOwner();
+        if (owner == null || event.getCharacter() == null) {
+            return;
+        }
+        if (event.getPrevious() != null) {
+            service.savePrevious(owner, event.getPrevious());
+        }
+        service.activate(owner, event.getCharacter());
+    }
+
+    @EventHandler
+    public void onQuit(PlayerQuitEvent event) {
+        service.deactivate(event.getPlayer());
+    }
+}