From c2d0d2b3c8e8f522e563646648b886c6faa9ab16 Mon Sep 17 00:00:00 2001
From: BenCodez <17074231+BenCodez@users.noreply.github.com>
Date: Fri, 9 Oct 2026 18:14:58 -0600
Subject: [PATCH 01/23] Add opt-in automation, usage charges and durable perk
lifecycle
---
AGENTS.md | 27 +
MCPerks/pom.xml | 20 +
.../com/bencodez/mcperks/MCPerksMain.java | 191 ++++-
.../mcperks/commands/CommandLoader.java | 163 +++-
.../mcperks/commands/PerkDiagnostics.java | 100 +++
.../mcperks/data/DurableFeatureFiles.java | 16 +
.../mcperks/data/FeatureFileOwnership.java | 47 ++
.../bencodez/mcperks/data/FeatureState.java | 244 ++++++
.../mcperks/data/LocalStatistics.java | 21 +
.../mcperks/data/OrderedServerDataFile.java | 73 ++
.../com/bencodez/mcperks/data/ServerData.java | 555 ++++++++++--
.../bencodez/mcperks/effects/AutoPlant.java | 45 +-
.../mcperks/listeners/EffectBatch.java | 18 +
.../mcperks/listeners/EffectListeners.java | 49 +-
.../mcperks/listeners/RefillPlan.java | 37 +
.../listeners/UsageEffectListener.java | 299 +++++++
.../listeners/compatability/McMMOEvents.java | 5 +-
.../compatability/RoseStackerListener.java | 3 +-
.../bencodez/mcperks/perk/BankedClock.java | 81 ++
.../bencodez/mcperks/perk/BankedPerks.java | 278 ++++++
.../com/bencodez/mcperks/perk/Effect.java | 14 +-
.../mcperks/perk/InteractionOptions.java | 27 +
.../java/com/bencodez/mcperks/perk/Perk.java | 153 +++-
.../bencodez/mcperks/perk/PerkHandler.java | 170 ++--
.../bencodez/mcperks/perk/QueuePlanner.java | 244 ++++++
.../mcperks/scheduling/OwnerTasks.java | 41 +
.../mcperks/userapi/UsageCharges.java | 198 +++++
.../userapi/UserStorageConfirmation.java | 23 +
MCPerks/src/main/resources/Config.yml | 6 +-
.../mcperks/commands/PerkDiagnosticsTest.java | 196 +++++
.../data/FeatureFileOwnershipTest.java | 75 ++
.../mcperks/data/FeatureStateFixture.java | 23 +
.../mcperks/data/FeatureStateTest.java | 235 ++++++
.../data/OrderedServerDataFileTest.java | 288 +++++++
.../data/ServerDataNativeMigrationTest.java | 378 +++++++++
.../mcperks/listeners/RefillPlanTest.java | 60 ++
.../listeners/UsageEffectListenerTest.java | 374 +++++++++
.../compatability/McMMOEventsTest.java | 68 ++
.../mcperks/perk/BankedClockTest.java | 62 ++
.../mcperks/perk/BankedPerksTest.java | 791 ++++++++++++++++++
.../mcperks/perk/ClearQueueCommandTest.java | 61 ++
.../mcperks/perk/PerkDecisionTest.java | 87 ++
.../mcperks/perk/PrecisionOptionsTest.java | 15 +
.../mcperks/perk/QueuePlannerTest.java | 635 ++++++++++++++
.../scheduling/BundledOwnerTaskHarness.java | 44 +
.../mcperks/scheduling/OwnerTaskHarness.java | 41 +
.../mcperks/scheduling/OwnerTasksTest.java | 89 ++
.../mcperks/userapi/UsageChargesFixture.java | 7 +
.../mcperks/userapi/UsageChargesTest.java | 197 +++++
.../userapi/UserStorageConfirmationTest.java | 49 ++
README.md | 256 +++++-
51 files changed, 6911 insertions(+), 268 deletions(-)
create mode 100644 MCPerks/src/main/java/com/bencodez/mcperks/commands/PerkDiagnostics.java
create mode 100644 MCPerks/src/main/java/com/bencodez/mcperks/data/DurableFeatureFiles.java
create mode 100644 MCPerks/src/main/java/com/bencodez/mcperks/data/FeatureFileOwnership.java
create mode 100644 MCPerks/src/main/java/com/bencodez/mcperks/data/FeatureState.java
create mode 100644 MCPerks/src/main/java/com/bencodez/mcperks/data/LocalStatistics.java
create mode 100644 MCPerks/src/main/java/com/bencodez/mcperks/data/OrderedServerDataFile.java
create mode 100644 MCPerks/src/main/java/com/bencodez/mcperks/listeners/EffectBatch.java
create mode 100644 MCPerks/src/main/java/com/bencodez/mcperks/listeners/RefillPlan.java
create mode 100644 MCPerks/src/main/java/com/bencodez/mcperks/listeners/UsageEffectListener.java
create mode 100644 MCPerks/src/main/java/com/bencodez/mcperks/perk/BankedClock.java
create mode 100644 MCPerks/src/main/java/com/bencodez/mcperks/perk/BankedPerks.java
create mode 100644 MCPerks/src/main/java/com/bencodez/mcperks/perk/InteractionOptions.java
create mode 100644 MCPerks/src/main/java/com/bencodez/mcperks/perk/QueuePlanner.java
create mode 100644 MCPerks/src/main/java/com/bencodez/mcperks/scheduling/OwnerTasks.java
create mode 100644 MCPerks/src/main/java/com/bencodez/mcperks/userapi/UsageCharges.java
create mode 100644 MCPerks/src/main/java/com/bencodez/mcperks/userapi/UserStorageConfirmation.java
create mode 100644 MCPerks/src/test/java/com/bencodez/mcperks/commands/PerkDiagnosticsTest.java
create mode 100644 MCPerks/src/test/java/com/bencodez/mcperks/data/FeatureFileOwnershipTest.java
create mode 100644 MCPerks/src/test/java/com/bencodez/mcperks/data/FeatureStateFixture.java
create mode 100644 MCPerks/src/test/java/com/bencodez/mcperks/data/FeatureStateTest.java
create mode 100644 MCPerks/src/test/java/com/bencodez/mcperks/data/OrderedServerDataFileTest.java
create mode 100644 MCPerks/src/test/java/com/bencodez/mcperks/data/ServerDataNativeMigrationTest.java
create mode 100644 MCPerks/src/test/java/com/bencodez/mcperks/listeners/RefillPlanTest.java
create mode 100644 MCPerks/src/test/java/com/bencodez/mcperks/listeners/UsageEffectListenerTest.java
create mode 100644 MCPerks/src/test/java/com/bencodez/mcperks/listeners/compatability/McMMOEventsTest.java
create mode 100644 MCPerks/src/test/java/com/bencodez/mcperks/perk/BankedClockTest.java
create mode 100644 MCPerks/src/test/java/com/bencodez/mcperks/perk/BankedPerksTest.java
create mode 100644 MCPerks/src/test/java/com/bencodez/mcperks/perk/ClearQueueCommandTest.java
create mode 100644 MCPerks/src/test/java/com/bencodez/mcperks/perk/PerkDecisionTest.java
create mode 100644 MCPerks/src/test/java/com/bencodez/mcperks/perk/PrecisionOptionsTest.java
create mode 100644 MCPerks/src/test/java/com/bencodez/mcperks/perk/QueuePlannerTest.java
create mode 100644 MCPerks/src/test/java/com/bencodez/mcperks/scheduling/BundledOwnerTaskHarness.java
create mode 100644 MCPerks/src/test/java/com/bencodez/mcperks/scheduling/OwnerTaskHarness.java
create mode 100644 MCPerks/src/test/java/com/bencodez/mcperks/scheduling/OwnerTasksTest.java
create mode 100644 MCPerks/src/test/java/com/bencodez/mcperks/userapi/UsageChargesFixture.java
create mode 100644 MCPerks/src/test/java/com/bencodez/mcperks/userapi/UsageChargesTest.java
create mode 100644 MCPerks/src/test/java/com/bencodez/mcperks/userapi/UserStorageConfirmationTest.java
diff --git a/AGENTS.md b/AGENTS.md
index ac6c3e5..d509d8f 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -35,6 +35,27 @@ The supported scope values are `ALL`, `PLAYER`, `TOWNY`, `FACTIONS`, and `PERMIS
7. Reward or command integration must preserve idempotency where the caller can retry and must not grant before required state is durably recorded.
8. Keep configuration keys, perk files, placeholders, permissions, aliases, and serialized user/server data backward compatible unless a migration is explicit and tested.
+9. Optional interaction effects use immutable options captured at load. Charge budgets belong to a player UUID and one
+ fixed effect, require durable asynchronous admission before gameplay, and remain spent after an uncertain effect or
+ crash. Never create per-reservation SQL keys or fetch perk files from gameplay listeners. Shared charge ownership is
+ rejected; legacy unlimited shared perks remain supported.
+10. Queue entries reserve existing entitlement without decrementing while waiting. Persist stable IDs and start fences
+ before consumption; limited queued activations require shared-runtime atomic user ownership and otherwise remain
+ waiting. Use confirmed asynchronous storage completion, consume one selected activation, and never replay
+ an uncertain start. Self cancellation checks ownership; pause and reordering are durable. Display unknown ETA when
+ eligibility or permanent/banked state prevents a reliable estimate.
+11. Banked personal time is an explicit optional mode, separate from legacy absolute expirations. Lifecycle checkpoints
+ consume online eligible elapsed time, including final disconnect/world/pause/reload/shutdown intervals; queries remain pure. Unsupported one-shot, periodic and persistent-effect
+ activation paths are rejected. Resuming a bank never grants entitlement or replays reward/command hooks. Retired
+ player or reload timer callbacks cannot remove effects from a newer session.
+ Nonpositive legacy reactivation timers remain disabled and supported. A bank replacement starts its elapsed/debit
+ ownership boundary only after durable publication; prior debit reservations cannot consume the replacement balance.
+ Grant publication must retain concurrent pause/eligibility transitions. Every acknowledged queue/bank state file
+ must remain within the same 3,000,000 serialized-byte recovery bound; capacity rejection preserves usable prior state and must precede irreversible activation consumption.
+ A clock first attached during an additive publication can debit only the pre-grant balance for that wait.
+12. Keep the ordered feature worker open through AdvancedCore final permission-data cleanup. Retire gameplay
+ admissions in onUnLoad, but seal/drain the file owner only after super.onDisable returns.
+
## Drop-in upgrade and compatibility contract
Treat compatibility as a release invariant for every new feature, refactor, fix, persistence change, configuration change, integration change, and dependency change. Unless the task explicitly says otherwise, an MCPerks upgrade must remain a **drop-in JAR replacement**: administrators replace the JAR and existing perks, timers, user/server state, configuration, commands, permissions, placeholders, and integrations continue working without manual migration steps.
@@ -53,6 +74,10 @@ For compatibility-sensitive changes, add regression coverage for established con
## Dependencies and packaging
+Startup defers native LastUpdated/version saves until strict ServerData reconciliation after predecessor drain. TimedPermissions become native-owned only after the actual AdvancedCore PermissionHandler restores the reconciled nodes through owner-scheduled native APIs; a generic empty YAML cache cannot clear recovered disk permissions. Compare the early native-handler baseline with current per-node state so successor revocations, renewals and new grants remain authoritative. Read only the bundled synchronized timedPermissionSnapshot/offlinePermissionSnapshot methods with exact schema checks; unsupported contracts fail initialization closed. Preserve pending offline nodes through the native final save without resurrecting revoked nodes. Successful bank replacement advances a FeatureState-owned debit epoch even for disconnected/reloaded/retired clocks; retained ownership is one scalar per bounded bank, never a retained list of session clocks.
+
+Ordered ServerData snapshots include a fixed leading format comment and stay within 4,000,000 encoded bytes including that comment. Unmarked native legacy YAML may migrate once after predecessor drain, with strict parsing and no symlink/unreadable-file bypass; consumed permissions and advisory history can yield the bounded format. An indispensable larger payload cannot migrate losslessly into this bounded file. Still-active oversized permission rows are conservatively checked before publishing a cleared snapshot, the original file stays intact, and initialization/final-save failures remain observable. Offline queued permission nodes have no native public snapshot API; the guarded bundled synchronized snapshot adapter preserves their pending native ownership. Future rows remain indispensable while that owner exists. Resolve excess active permissions on the prior version or reduce other indispensable payload before upgrading; do not add a supplemental persistence engine or silently discard those fields.
+
AdvancedCore is shaded and relocated. Before changing its version, shading, or API usage, inspect the actual dependency contract and downstream artifact. Avoid unpinned `LATEST` dependencies in reproducible release paths. Check that provided optional dependencies are not accidentally bundled and relocated libraries do not leak original packages or service metadata.
## Change and PR workflow
@@ -60,3 +85,5 @@ AdvancedCore is shaded and relocated. Before changing its version, shading, or A
Keep changes focused. Before any commit, push, PR update, review reply, or other remote change, run focused checks, the full Maven package build, fresh-artifact inspection, and `git diff --check`; then inspect the complete base-to-HEAD diff. Before committing local work, also inspect the staged changes and every relevant intended unstaged or untracked change as one effective final patch.
For substantive work, obtain a fresh source-read-only review. The implementation agent verifies and fixes accepted findings, reruns validation, and obtains a new review of the updated snapshot. Do not reuse an old clean verdict after changes, and do not merge without explicit authorization.
+
+Queue-enabled direct activation retains the queue start fence through asynchronous bank publication, the initial player-owner attachment attempt, and cooldown confirmation. Queued bank starts retain their existing fence through the same attachment handoff. Resumed or reconnected banks wait behind unrelated active perks without consuming waiting time; queue-disabled personal banks retain parallel behavior. The first attachment attempt may finish ineligible or retired while preserving the published bank for a later eligible resume; it does not mint time or replay activation hooks.
diff --git a/MCPerks/pom.xml b/MCPerks/pom.xml
index a737bce..4cfe23f 100644
--- a/MCPerks/pom.xml
+++ b/MCPerks/pom.xml
@@ -260,6 +260,15 @@
+ org.mockitomockito-core5.14.2test
+
+
+ org.junit.jupiter
+ junit-jupiter
+ 5.10.3
+ test
+
+
com.bencodez
advancedcore
LATEST
@@ -320,4 +329,15 @@
provided
+
+
+ tests
+ true
+
+ org.apache.maven.plugins
+ maven-surefire-plugin
+ 3.2.5
+
+
+
\ No newline at end of file
diff --git a/MCPerks/src/main/java/com/bencodez/mcperks/MCPerksMain.java b/MCPerks/src/main/java/com/bencodez/mcperks/MCPerksMain.java
index 8fa39b5..fe8a7b1 100644
--- a/MCPerks/src/main/java/com/bencodez/mcperks/MCPerksMain.java
+++ b/MCPerks/src/main/java/com/bencodez/mcperks/MCPerksMain.java
@@ -60,6 +60,19 @@
* The Class Main.
*/
public class MCPerksMain extends AdvancedCorePlugin {
+ private volatile int featureLifecycle;
+ private final com.bencodez.mcperks.data.LocalStatistics localStatistics = new com.bencodez.mcperks.data.LocalStatistics();
+ public com.bencodez.mcperks.data.LocalStatistics getLocalStatistics() { return localStatistics; }
+ private com.bencodez.mcperks.perk.BankedPerks bankedPerks;
+ public com.bencodez.mcperks.perk.BankedPerks getBankedPerks() { return bankedPerks; }
+ private com.bencodez.mcperks.data.FeatureState featureState;
+ private com.bencodez.mcperks.perk.QueuePlanner queuePlanner;
+ public com.bencodez.mcperks.data.FeatureState getFeatureState() { return featureState; }
+ public com.bencodez.mcperks.perk.QueuePlanner getQueuePlanner() { return queuePlanner; }
+ private com.bencodez.mcperks.userapi.UsageCharges usageCharges;
+ private com.bencodez.mcperks.listeners.UsageEffectListener usageEffects;
+ public com.bencodez.mcperks.userapi.UsageCharges getUsageCharges() { return usageCharges; }
+ public com.bencodez.mcperks.listeners.UsageEffectListener getUsageEffects() { return usageEffects; }
/** The plugin. */
public static MCPerksMain plugin;
@@ -137,21 +150,64 @@ public void loadListeners() {
*
* @see org.bukkit.plugin.java.JavaPlugin#onDisable()
*/
+ @Override
+ public void onDisable() {
+ try { super.onDisable(); }
+ finally {
+ // AdvancedCore permission cleanup performs its final ServerData save after onUnLoad.
+ if (featureState != null) featureState.close();
+ }
+ }
+
@Override
public void onUnLoad() {
+ featureLifecycle++;
+ if (queuePlanner != null) queuePlanner.retire();
+ if (bankedPerks != null) bankedPerks.retire();
+ if (usageEffects != null) usageEffects.retireAndClose();
+ else if (usageCharges != null) usageCharges.close();
for (Perk perk : getPerkHandler().getActivePerks()) {
- getMcperksServerData().saveOfflinePerk(perk);
+ if (bankedPerks != null && bankedPerks.attached(perk)) continue;
+ getMcperksServerData().saveOfflinePerk(perk);
perk.deactivatePerk(perk.getActivater());
}
+ getMcperksServerData().saveData();
HandlerList.unregisterAll(plugin);
plugin = null;
}
@Override
public void onPostLoad() {
- loadListeners();
+ int featureEpoch = ++featureLifecycle;
+ localStatistics.enabled(getConfigFile().getData().getBoolean("LocalStatistics.Enabled", false));
+ usageCharges = new com.bencodez.mcperks.userapi.UsageCharges(getDataFolder().toPath().resolve("usage-charges.dat"));
+ usageCharges.ready().exceptionally(error -> { getLogger().severe("Usage charge store unavailable; charged effects fail closed: " + error.getMessage()); return null; });
+ featureState = new com.bencodez.mcperks.data.FeatureState(getDataFolder().toPath().resolve("perk-features.dat"));
+ featureState.ready().exceptionally(error -> { getLogger().severe("Queue/bank store unavailable: " + error.getMessage()); return null; });
+ java.util.concurrent.CompletableFuture runtimeReady = mcperksServerData.initialize(featureState);
+ runtimeReady.exceptionally(error -> { getLogger().severe("ServerData startup reconciliation failed; queued activations remain unavailable"); return null; });
+ queuePlanner = new com.bencodez.mcperks.perk.QueuePlanner(this, featureState);
+ loadListeners();
perkHandler = new PerkHandler(this);
effectHandler = new EffectHandler(this);
+ usageEffects = new com.bencodez.mcperks.listeners.UsageEffectListener(this);
+ getServer().getPluginManager().registerEvents(usageEffects, this);
+ bankedPerks = new com.bencodez.mcperks.perk.BankedPerks(this, featureState);
+ getServer().getPluginManager().registerEvents(bankedPerks, this);
+ runtimeReady.thenRun(() -> {
+ if (featureEpoch != featureLifecycle || !isEnabled()) return;
+ getBukkitScheduler().runTask(this, () -> {
+ if (featureEpoch != featureLifecycle || !isEnabled()) return;
+ perkHandler.loadActivePerksConfirmed(this::restoreOfflinePerks).whenComplete((ignored, error) -> {
+ if (error != null) { getLogger().severe("Legacy perk restoration failed; queued starts and bank attachments remain unavailable: " + error.getMessage()); return; }
+ if (featureEpoch != featureLifecycle || !isEnabled()) return;
+ getBukkitScheduler().runTask(this, () -> {
+ if (featureEpoch != featureLifecycle || !isEnabled()) return;
+ for (Player player : Bukkit.getOnlinePlayers()) getBukkitScheduler().runTask(this, () -> bankedPerks.start(player), player);
+ queuePlanner.refreshLegacyView(); queuePlanner.check(); queuePlanner.startChecks();
+ });
+ });
+ }); });
commandLoader = new CommandLoader(this);
commandLoader.loadCommands();
@@ -172,48 +228,6 @@ public void onPostLoad() {
versionHandle = new Post123VersionHandle();
}
- getBukkitScheduler().runTaskAsynchronously(this, new Runnable() {
-
- @Override
- public void run() {
- if (getMcperksServerData().getData().isConfigurationSection("OfflinePerk")) {
- for (String uuid : getMcperksServerData().getData().getConfigurationSection("OfflinePerk")
- .getKeys(false)) {
- if (getMcperksServerData().getData().isConfigurationSection("OfflinePerk." + uuid)) {
- for (String perk : getMcperksServerData().getData()
- .getConfigurationSection("OfflinePerk." + uuid).getKeys(false)) {
-
- long timeLast = getMcperksServerData().getData()
- .getLong("OfflinePerk." + uuid + "." + perk + ".Experiaton");
- debug(uuid + "/" + perk + "/" + timeLast);
- Timestamp timestamp = null;
- if (timeLast > 0) {
- timestamp = new Timestamp(timeLast);
- timeLast = 0;
- }
- boolean activate = true;
- if (timestamp != null) {
- if (timestamp.after(new Timestamp(Calendar.getInstance().getTime().getTime()))) {
- // not activating
- activate = false;
- }
- }
- if (activate) {
- debug("Activating perk from shutdown " + perk + "/" + uuid + "/" + timeLast);
- getPerkHandler().activePerk(getPerkHandler().getPerk(perk),
- getMcperksUserManager().getMCPerksUser(UUID.fromString(uuid)),
- (int) timeLast, timestamp);
- }
-
- }
- }
- }
- }
-
- getMcperksServerData().getData().set("OfflinePerk", null);
- getMcperksServerData().saveData();
- }
- });
getJavascriptEngineRequests().add(new JavascriptPlaceholderRequest("MCPerks") {
@@ -476,13 +490,97 @@ public String placeHolder(OfflinePlayer p, String identifier) {
}
- @Override
- public void reload() {
+ private volatile com.bencodez.mcperks.data.OrderedServerDataFile orderedServerData;
+ @Override public com.bencodez.advancedcore.data.ServerData getServerDataFile() {
+ var original = super.getServerDataFile();
+ if (featureState == null && mcperksServerData != null && original != null)
+ mcperksServerData.observeNativePermissionSource(original.getData());
+ if (mcperksServerData == null || original == null || original.getData() == null) return original;
+ synchronized (mcperksServerData) {
+ if (orderedServerData == null) orderedServerData = new com.bencodez.mcperks.data.OrderedServerDataFile(this, original, mcperksServerData);
+ return orderedServerData;
+ }
+ }
+ @Override public com.bencodez.advancedcore.api.permissions.PermissionHandler getPermissionHandler() {
+ var handler = super.getPermissionHandler();
+ if (mcperksServerData != null && handler != null) mcperksServerData.observeNativePermissionHandler(handler);
+ return handler;
+ }
+ private void restoreOfflinePerks() {
+ if (getMcperksServerData().getData().isConfigurationSection("OfflinePerk")) {
+ for (String uuid : getMcperksServerData().getData().getConfigurationSection("OfflinePerk")
+ .getKeys(false)) {
+ if (getMcperksServerData().getData().isConfigurationSection("OfflinePerk." + uuid)) {
+ for (String perk : getMcperksServerData().getData()
+ .getConfigurationSection("OfflinePerk." + uuid).getKeys(false)) {
+
+ long timeLast = getMcperksServerData().getData()
+ .getLong("OfflinePerk." + uuid + "." + perk + ".Experiaton");
+ debug(uuid + "/" + perk + "/" + timeLast);
+ Timestamp timestamp = null;
+ if (timeLast > 0) {
+ timestamp = new Timestamp(timeLast);
+ timeLast = 0;
+ }
+ boolean activate = true;
+ if (timestamp != null) {
+ if (timestamp.after(new Timestamp(Calendar.getInstance().getTime().getTime()))) {
+ // not activating
+ activate = false;
+ }
+ }
+ var definition = getPerkHandler().getPerk(perk);
+ if (definition == null || !definition.isEnabled()) {
+ getLogger().warning("Skipping shutdown record for unavailable perk: " + perk);
+ continue;
+ }
+ if (activate) {
+ debug("Activating perk from shutdown " + perk + "/" + uuid + "/" + timeLast);
+ getPerkHandler().activePerk(definition,
+ getMcperksUserManager().getMCPerksUser(UUID.fromString(uuid)),
+ (int) timeLast, timestamp);
+ }
+
+ }
+ }
+ }
+ }
+
+ getMcperksServerData().clearOfflinePerks();
+ getMcperksServerData().saveData();
+ }
+
+ private final java.util.concurrent.atomic.AtomicBoolean reloadPending = new java.util.concurrent.atomic.AtomicBoolean();
+ @Override
+ public void reload() {
+ if (!reloadPending.compareAndSet(false, true)) return;
+ if (usageEffects != null) usageEffects.invalidate();
+ if (queuePlanner != null) queuePlanner.suspend();
+ // ServerData snapshots accepted before reload must publish before AdvancedCore reads its file.
+ var barrier = featureState == null ? java.util.concurrent.CompletableFuture.completedFuture(null) : featureState.runtimeStorage(() -> null);
+ barrier.whenComplete((ignored, error) -> {
+ if (error != null || !isEnabled()) {
+ reloadPending.set(false);
+ if (error != null) getLogger().warning("Reload postponed: pending ServerData publication could not drain");
+ if (queuePlanner != null) queuePlanner.resume();
+ return;
+ }
+ getBukkitScheduler().runTask(this, () -> {
+ try { reloadAfterDrain(); }
+ finally { reloadPending.set(false); if (queuePlanner != null) queuePlanner.resume(); }
+ });
+ });
+ }
+ private void reloadAfterDrain() {
+ if (usageEffects != null) usageEffects.invalidate();
+ if (queuePlanner != null) queuePlanner.invalidate();
configFile.reloadData();
+ localStatistics.enabled(getConfigFile().getData().getBoolean("LocalStatistics.Enabled", false));
perkSystemType = configFile.getPerkSystemType();
Lang.getInstance().reloadData();
mcperksServerData.reloadData();
getPerkHandler().reload();
+ if (bankedPerks != null) bankedPerks.reload();
commandLoader.loadTabComplete();
updateHook();
reloadAdvancedCore(true);
@@ -492,6 +590,7 @@ public void reload() {
* Setup files.
*/
private void setupFiles() {
+ orderedServerData = null;
configFile = new Config(this);
configFile.setup();
Lang.getInstance().setup(this);
diff --git a/MCPerks/src/main/java/com/bencodez/mcperks/commands/CommandLoader.java b/MCPerks/src/main/java/com/bencodez/mcperks/commands/CommandLoader.java
index 9d239e9..73d55e1 100644
--- a/MCPerks/src/main/java/com/bencodez/mcperks/commands/CommandLoader.java
+++ b/MCPerks/src/main/java/com/bencodez/mcperks/commands/CommandLoader.java
@@ -32,6 +32,7 @@
import com.bencodez.mcperks.perk.Effect;
import com.bencodez.mcperks.perk.Perk;
import com.bencodez.mcperks.userapi.MCPerksUser;
+import com.bencodez.mcperks.userapi.UsageCharges;
import com.bencodez.simpleapi.array.ArrayUtils;
import com.bencodez.simpleapi.command.TabCompleteHandle;
import com.bencodez.simpleapi.command.TabCompleteHandler;
@@ -141,7 +142,152 @@ public void loadCommand(CommandPerkAliases commandPerkAliases, String perk) {
}
- public void loadCommands() {
+ private void plannerReply(CommandSender sender, java.util.concurrent.CompletableFuture operation, String success) {
+ operation.whenComplete((result, error) -> {
+ Runnable reply = () -> {
+ sender.sendMessage(MessageAPI.colorize(error == null && !Boolean.FALSE.equals(result) ? success : "&cPlanner update failed or entry unavailable."));
+ plugin.getQueuePlanner().refreshLegacyView(); plugin.getQueuePlanner().check();
+ };
+ if (sender instanceof org.bukkit.entity.Player player) plugin.getBukkitScheduler().runTask(plugin, reply, player);
+ else plugin.getBukkitScheduler().runTask(plugin, reply);
+ });
+ }
+ private void loadClearQueueCommand() {
+ plugin.getCommands().add(
+ new CommandHandler(plugin, new String[] { "ClearQueue" }, "MCPerks.ClearQueue", "Clear Perk Queue") {
+
+ @Override
+ public void execute(CommandSender sender, String[] args) {
+ plannerReply(sender, plugin.getPerkHandler().clearQueueConfirmed(), "&cPerk Queue Cleared");
+ }
+ });
+ }
+ private void loadPlannerCommands() {
+ for (boolean other : new boolean[] { false, true }) {
+ plugin.getCommands().add(new CommandHandler(plugin, other ? new String[] { "Diagnose", "(player)" } : new String[] { "Diagnose" },
+ other ? "MCPerks.Diagnose.Other" : "MCPerks.Diagnose", "Explain actual MCPerks decisions") {
+ @Override public void execute(CommandSender sender, String[] args) {
+ org.bukkit.entity.Player target = other ? org.bukkit.Bukkit.getPlayerExact(args[1]) : sender instanceof org.bukkit.entity.Player p ? p : null;
+ if (target == null) { sendMessage(sender, "&cAn online player is required. Offline banked time is paused."); return; }
+ plugin.getBukkitScheduler().runTask(plugin, () -> new PerkDiagnostics(plugin).explain(sender, target), target);
+ }
+ });
+ }
+ plugin.getCommands().add(new CommandHandler(plugin, new String[] { "LocalStatistics" }, "MCPerks.LocalStatistics", "Read local aggregate counters") {
+ @Override public void execute(CommandSender sender, String[] args) { sendMessage(sender, "&b" + plugin.getLocalStatistics().summary()); }
+ });
+ plugin.getCommands().add(new CommandHandler(plugin, new String[] { "GetBankedTime", "(perk)" }, "MCPerks.BankedTime", "Read personal banked time") {
+ @Override public void execute(CommandSender sender, String[] args) {
+ if (!(sender instanceof org.bukkit.entity.Player player)) { sendMessage(sender, "&cPlayer only."); return; }
+ if (!plugin.getFeatureState().available()) { sendMessage(sender, "&cBanked state is unavailable."); return; }
+ var bank = plugin.getFeatureState().banks().get(new com.bencodez.mcperks.data.FeatureState.BankKey(player.getUniqueId(), args[1]));
+ sendMessage(sender, bank == null ? "&bNo banked grant. Legacy timers retain their absolute expiration." : "&bBanked: " + bank.milliseconds()/1000 + "s; paused=" + bank.paused());
+ }
+ });
+ plugin.getCommands().add(new CommandHandler(plugin, new String[] { "SetBankedTime", "(player)", "(perk)", "(seconds)" }, "MCPerks.SetBankedTime", "Set supported personal banked time") {
+ @Override public void execute(CommandSender sender, String[] args) {
+ Perk perk = plugin.getPerkHandler().getPerk(args[2]);
+ if (perk == null || !perk.getInteractionOptions().banked() || !com.bencodez.mcperks.perk.BankedPerks.supported(perk)) { sendMessage(sender, "&cEnable BankedTime for a supported PLAYER perk first."); return; }
+ try {
+ long milliseconds = Math.multiplyExact(Long.parseLong(args[3]), 1000L);
+ java.util.UUID owner = java.util.UUID.fromString(plugin.getMcperksUserManager().getMCPerksUser(args[1]).getUUID());
+ plannerReply(sender, plugin.getFeatureState().setBank(new com.bencodez.mcperks.data.FeatureState.BankKey(owner, perk.getPerk()), milliseconds)
+ .thenApply(bank -> { plugin.getBankedPerks().refresh(owner); return bank; }), "&aBanked time saved.");
+ } catch (IllegalArgumentException | ArithmeticException error) { sendMessage(sender, "&cUse a nonnegative time of at most one year."); }
+ }
+ });
+ for (boolean paused : new boolean[] { true, false }) {
+ plugin.getCommands().add(new CommandHandler(plugin, new String[] { paused ? "PauseBankedTime" : "ResumeBankedTime", "(perk)" }, "MCPerks.BankedTime", "Pause/resume a personal banked grant") {
+ @Override public void execute(CommandSender sender, String[] args) {
+ if (!(sender instanceof org.bukkit.entity.Player player)) { sendMessage(sender, "&cPlayer only."); return; }
+ var key = new com.bencodez.mcperks.data.FeatureState.BankKey(player.getUniqueId(), args[1]);
+ plannerReply(sender, plugin.getBankedPerks().pause(key, paused).thenApply(bank -> {
+ if (bank == null) throw new IllegalArgumentException("No banked grant"); plugin.getBankedPerks().refresh(player.getUniqueId()); return bank;
+ }), "&aBanked pause state saved.");
+ }
+ });
+ }
+ plugin.getCommands().add(new CommandHandler(plugin, new String[] { "Queue" }, "MCPerks.Queue", "Show the active and queued perks") {
+ @Override public void execute(CommandSender sender, String[] args) {
+ if (!plugin.getFeatureState().available()) sendMessage(sender, "&cQueue storage is unavailable. Entries below are the last confirmed start fences; admin review required.");
+ long now = System.currentTimeMillis();
+ for (Perk active : plugin.getPerkHandler().getActivePerks()) {
+ var bank = plugin.getBankedPerks().attached(active) ? plugin.getFeatureState().banks().get(new com.bencodez.mcperks.data.FeatureState.BankKey(java.util.UUID.fromString(active.getActivater().getUUID()), active.getPerk())) : null;
+ String remaining = bank != null ? bank.milliseconds()/1000 + " banked seconds" : active.getKnownExpiration() > 0 ? Math.max(0, active.getKnownExpiration()-now)/1000 + " seconds" : "unknown";
+ sendMessage(sender, "&bActive: " + active.getPerk() + " (remaining: " + remaining + ")");
+ }
+ int position = 1;
+ for (var entry : plugin.getFeatureState().queue()) {
+ if (position > 32) { sendMessage(sender, "&bFurther entries omitted; total " + plugin.getFeatureState().queue().size()); break; }
+ sendMessage(sender, "&b" + position++ + ". " + entry.perk() + " requester=" + entry.owner() + " id=" + entry.id() + " state=" + entry.stage() + " wait=" + Math.max(0, now-entry.admitted())/1000 + "s start=" + (plugin.getQueuePlanner().startUnavailable(entry) == null ? "eligible checks pending" : plugin.getQueuePlanner().startUnavailable(entry)) + " ETA=unknown");
+ }
+ sendMessage(sender, "&bQueue paused: " + plugin.getFeatureState().paused());
+ plugin.getQueuePlanner().estimatedWaits().thenAccept(estimates -> {
+ Runnable report = () -> estimates.forEach((id, seconds) -> sendMessage(sender, "&bEstimated start for " + id + ": " + seconds + "s"));
+ if (sender instanceof org.bukkit.entity.Player player) com.bencodez.mcperks.scheduling.OwnerTasks.run(plugin, player, report, () -> {});
+ else if (plugin.isEnabled()) plugin.getBukkitScheduler().runTask(plugin, report);
+ });
+ }
+ });
+ for (boolean staff : new boolean[] { false, true }) {
+ String command = staff ? "QueueRemove" : "CancelQueue";
+ plugin.getCommands().add(new CommandHandler(plugin, new String[] { command, "(id)" }, staff ? "MCPerks.Queue.Manage" : "MCPerks.CancelQueue", "Cancel a waiting queue entry") {
+ @Override public void execute(CommandSender sender, String[] args) {
+ if (!staff && !(sender instanceof org.bukkit.entity.Player)) { sendMessage(sender, "&cPlayer only."); return; }
+ try { java.util.UUID id = java.util.UUID.fromString(args[1]); java.util.UUID owner = sender instanceof org.bukkit.entity.Player player ? player.getUniqueId() : new java.util.UUID(0,0);
+ plannerReply(sender, plugin.getFeatureState().cancel(id, owner, staff), "&aQueue entry removed; consumed activations are not refunded.");
+ } catch (IllegalArgumentException error) { sendMessage(sender, "&cInvalid queue ID."); }
+ }
+ });
+ }
+ plugin.getCommands().add(new CommandHandler(plugin, new String[] { "QueuePause", "(boolean)" }, "MCPerks.Queue.Manage", "Pause/resume queued starts") {
+ @Override public void execute(CommandSender sender, String[] args) {
+ if (!args[1].equalsIgnoreCase("true") && !args[1].equalsIgnoreCase("false")) { sendMessage(sender, "&cUse true or false."); return; }
+ plannerReply(sender, plugin.getFeatureState().pauseQueue(Boolean.parseBoolean(args[1])), "&aQueue pause state saved.");
+ }
+ });
+ plugin.getCommands().add(new CommandHandler(plugin, new String[] { "QueueMove", "(id)", "(position)" }, "MCPerks.Queue.Manage", "Reorder a waiting queue entry") {
+ @Override public void execute(CommandSender sender, String[] args) {
+ try { int position = Integer.parseInt(args[2]); if (position < 1) throw new IllegalArgumentException();
+ plannerReply(sender, plugin.getFeatureState().move(java.util.UUID.fromString(args[1]), position), "&aQueue order saved.");
+ } catch (IllegalArgumentException error) { sendMessage(sender, "&cUse a queue ID and positive position."); }
+ }
+ });
+ }
+
+ private void loadUsageCommands() {
+ plugin.getCommands().add(new CommandHandler(plugin, new String[] { "GetUsageCharges", "(effect)" },
+ "MCPerks.GetUsageCharges", "Show a personal effect balance") {
+ @Override public void execute(CommandSender sender, String[] args) {
+ if (!(sender instanceof org.bukkit.entity.Player player)) { sendMessage(sender, "&cPlayer only."); return; }
+ if (!plugin.getUsageCharges().available()) { sendMessage(sender, "&cCharge state is unavailable."); return; }
+ try { UsageCharges.Kind kind = UsageCharges.Kind.valueOf(args[1]);
+ sendMessage(sender, "&b" + kind + " charges: " + plugin.getUsageCharges().get(player.getUniqueId(), kind));
+ } catch (IllegalArgumentException e) { sendMessage(sender, "&cUnknown charge effect."); }
+ }
+ });
+ for (boolean add : new boolean[] { false, true }) {
+ String command = add ? "AddUsageCharges" : "SetUsageCharges";
+ plugin.getCommands().add(new CommandHandler(plugin, new String[] { command, "(player)", "(effect)", "(number)" },
+ "MCPerks." + command, "Manage personal effect charges") {
+ @Override public void execute(CommandSender sender, String[] args) {
+ try {
+ UsageCharges.Kind kind = UsageCharges.Kind.valueOf(args[2]); int amount = Integer.parseInt(args[3]);
+ java.util.UUID owner = java.util.UUID.fromString(plugin.getMcperksUserManager().getMCPerksUser(args[1]).getUUID());
+ java.util.concurrent.CompletableFuture result = add ? plugin.getUsageCharges().add(owner, kind, amount)
+ : plugin.getUsageCharges().set(owner, kind, amount);
+ result.whenComplete((balance, error) -> {
+ Runnable reply = () -> sendMessage(sender, error == null ? "&b" + kind + " charges: " + balance : "&cCharge update failed.");
+ if (sender instanceof org.bukkit.entity.Player player) plugin.getBukkitScheduler().runTask(plugin, reply, player);
+ else plugin.getBukkitScheduler().runTask(plugin, reply);
+ });
+ } catch (IllegalArgumentException e) { sendMessage(sender, "&cUse a supported effect and nonnegative integer amount."); }
+ }
+ });
+ }
+ }
+
+ public void loadCommands() {
plugin.setCommands(new ArrayList());
commands = new HashMap();
@@ -396,15 +542,7 @@ public void execute(CommandSender sender, String[] args) {
}
});
- plugin.getCommands().add(
- new CommandHandler(plugin, new String[] { "ClearQueue" }, "MCPerks.ClearQueue", "Clear Perk Queue") {
-
- @Override
- public void execute(CommandSender sender, String[] args) {
- plugin.getPerkHandler().clearQueue();
- sender.sendMessage(MessageAPI.colorize("&cPerk Queue Cleared"));
- }
- });
+ loadClearQueueCommand();
plugin.getCommands().add(new CommandHandler(plugin, new String[] { "ActivatePerk", "(player)", "(perk)" },
"MCPerks.ActivatePerk", "Forcefly Activate Perk") {
@@ -726,7 +864,10 @@ public void execute(CommandSender sender, String[] args) {
sendMessage(sender, "&cSet activations to " + user.getActivations());
}
}
- });
+ });
+
+ loadUsageCommands();
+ loadPlannerCommands();
// load perk commands
for (Perk perk : plugin.getPerkHandler().getLoadedPerks().values()) {
diff --git a/MCPerks/src/main/java/com/bencodez/mcperks/commands/PerkDiagnostics.java b/MCPerks/src/main/java/com/bencodez/mcperks/commands/PerkDiagnostics.java
new file mode 100644
index 0000000..25d3128
--- /dev/null
+++ b/MCPerks/src/main/java/com/bencodez/mcperks/commands/PerkDiagnostics.java
@@ -0,0 +1,100 @@
+package com.bencodez.mcperks.commands;
+import java.util.*;
+import org.bukkit.Bukkit;
+import org.bukkit.entity.Player;
+import org.bukkit.command.CommandSender;
+import com.bencodez.mcperks.MCPerksMain;
+import com.bencodez.mcperks.perk.*;
+import com.bencodez.mcperks.effects.AutoPlant;
+/** Uses the same decisions and static policy helpers as the production paths. */
+public final class PerkDiagnostics {
+ private final MCPerksMain plugin;
+ public PerkDiagnostics(MCPerksMain plugin) { this.plugin = plugin; }
+ private record Stored(Perk perk, long cooldown, int used, int personalCredits, boolean retained, Perk activation, boolean alreadyActive) {}
+ public void explain(CommandSender sender, Player player) {
+ UUID owner = player.getUniqueId();
+ // Reload preserves active clones and their immutable gameplay options. Diagnose those
+ // grants rather than a replacement definition that no longer governs the action.
+ var retained = plugin.getPerkHandler().getActivePerks().stream()
+ .filter(perk -> perk.getEffectedPlayers().contains(owner.toString())).limit(32).toList();
+ Set retainedNames = new HashSet<>();
+ retained.forEach(perk -> retainedNames.add(perk.getPerk()));
+ var perks = java.util.stream.Stream.concat(retained.stream(),
+ plugin.getPerkHandler().getLoadedPerks().values().stream()
+ .filter(perk -> !retainedNames.contains(perk.getPerk())))
+ .distinct().limit(32).toList();
+ Map definitions = new HashMap<>();
+ for (Perk perk : perks) {
+ Perk configured = plugin.getPerkHandler().getLoadedPerks().get(perk.getPerk());
+ if (configured != null) definitions.put(perk.getPerk(), configured);
+ }
+ plugin.getFeatureState().storage(() -> {
+ var user = plugin.getMcperksUserManager().getMCPerksUser(owner);
+ List stored = new ArrayList<>();
+ for (Perk perk : perks) {
+ Perk activation = definitions.getOrDefault(perk.getPerk(), perk);
+ stored.add(new Stored(perk, Math.max(user.getPerkCoolDown(perk), plugin.getMcperksServerData().getData().getLong(perk.getPerk()+".CoolDown", 0)), user.getPerkTimesUsed(perk), user.getActivations(perk.getPerk()), retained.contains(perk), activation, activation.isPerkActive(user)));
+ }
+ return new Object[] { stored, user.getActivations(), user.isIgnorePerkEffects() };
+ }).whenComplete((result, error) -> {
+ if (!plugin.isEnabled()) return;
+ plugin.getBukkitScheduler().runTask(plugin, () -> {
+ if (!player.isOnline()) { deliver(sender, List.of("Player is offline; banked time is paused.")); return; }
+ if (error != null) { deliver(sender, List.of("Stored perk state unavailable; no diagnosis inferred.")); return; }
+ @SuppressWarnings("unchecked") List stored = (List) result[0];
+ List lines = new ArrayList<>(); lines.add("Perk decisions for " + player.getName() + "; world=" + player.getWorld().getName() + "; ignored=" + result[2]);
+ int permissionLimit = -1;
+ for (int i = plugin.getPerkHandler().getLoadedPerks().size(); i > 0; i--) if (player.hasPermission("MCPerks.Limit." + i)) { permissionLimit = i; break; }
+ boolean bypass = player.hasPermission("MCPerks.Perks.BypassCoolDown");
+ for (Stored data : stored) {
+ Perk perk = data.perk(); boolean permission = player.hasPermission("MCPerks." + perk.getPerk()) || player.hasPermission("MCPerks.AllPerks");
+ int personal = data.personalCredits() - plugin.getFeatureState().reserved(owner, "PerkActivations_" + perk.getPerk());
+ int global = (Integer) result[1] - plugin.getFeatureState().reserved(owner, "Activations");
+ // Activation can target a new definition while gameplay still uses its
+ // retained clone. Match runPerk's actual duplicate predicates for that request.
+ var bank = plugin.getFeatureState().banks().get(new com.bencodez.mcperks.data.FeatureState.BankKey(owner, perk.getPerk()));
+ boolean duplicate = !plugin.getConfigFile().getAllowDuplicatePerksActive()
+ && (data.alreadyActive() || bank != null && bank.milliseconds() > 0
+ && data.activation().getInteractionOptions().banked());
+ String reason = !permission ? "missing activation permission" : !perk.isNotInDisabledWorld(player.getWorld().getName()) ? "disabled world"
+ : duplicate ? "already active; duplicate activations disabled"
+ : !bypass && data.cooldown() > System.currentTimeMillis() ? "cooldown " + (data.cooldown()-System.currentTimeMillis())/1000 + "s"
+ : perk.getLimit() > 0 && data.used() >= perk.getLimit() ? "activation limit"
+ : plugin.getConfigFile().getLimitPermission() && permissionLimit >= 0
+ && plugin.getPerkHandler().getActivePerks().stream().filter(p -> p.getEffectedPlayers().contains(owner.toString())).count() >= permissionLimit ? "permission perk limit"
+ : plugin.getConfigFile().getLimitActivations() && personal <= 0 && global <= 0 ? "no unreserved activation" : "activation checks passed";
+ lines.add(perk.getPerk() + (data.retained() ? " (retained active grant)" : " (configured definition)") + ": " + reason);
+ for (Effect effect : perk.getEffects()) {
+ if (lines.size() >= 64) break;
+ var decision = plugin.getPerkHandler().effectDecision(effect, owner.toString(), player.getWorld().getName());
+ String detail = Boolean.TRUE.equals(result[2]) ? "; effects ignored by player" : "";
+ if (effect == Effect.VeinMining) {
+ var options = perk.getInteractionOptions(); String tool = player.getInventory().getItemInMainHand().getType().name();
+ if (options.veinTools().isEmpty() ? !tool.endsWith("_PICKAXE") : options.veinTools().stream().noneMatch(t -> t.equalsIgnoreCase(tool))) detail = "; tool not allowed";
+ } else if (effect == Effect.RightClickHarvest && !AutoPlant.allows(perk, player.getInventory().getItemInMainHand(), org.bukkit.Material.WHEAT)) detail = "; tool/enchantment/crop policy restricts harvest";
+ if (effect == Effect.AutoBlockRefill || effect == Effect.VeinMining || effect == Effect.RightClickHarvest) {
+ var kind = com.bencodez.mcperks.userapi.UsageCharges.Kind.valueOf(effect.name());
+ int charges = plugin.getUsageCharges().get(owner, kind);
+ detail += perk.getInteractionOptions().charged() ? perk.getPerkType() != PerkSystemType.PLAYER ? "; charge mode rejected for shared audience" : "; charges=" + (plugin.getUsageCharges().available() ? charges : "unavailable") : "; unlimited";
+ detail += "; successful units=" + plugin.getUsageCharges().successful(owner, kind);
+ }
+ lines.add(" " + effect + ": " + decision + detail);
+ }
+ if (bank != null) lines.add(" banked=" + bank.milliseconds()/1000 + "s; manual pause=" + bank.paused());
+ if (lines.size() >= 64) { lines.add("Further perk details omitted."); break; }
+ }
+ var recent = plugin.getUsageEffects().recentSkip(owner);
+ if (recent != null) lines.add("Latest recorded MCPerks skip: " + recent.effect() + " " + recent.reason() + "; " + Math.max(0, System.currentTimeMillis()-recent.time())/1000 + "s ago");
+ int index = 1; for (var entry : plugin.getFeatureState().queue()) {
+ if (entry.owner().equals(owner)) lines.add("Queue position=" + index + "; state=" + entry.stage() + "; start=" + plugin.getQueuePlanner().startUnavailable(entry) + "; ETA=unknown"); index++;
+ }
+ deliver(sender, lines);
+ }, player);
+ });
+ }
+ private void deliver(CommandSender sender, List lines) {
+ Runnable send = () -> { for (String line : lines) sender.sendMessage(line); };
+ if (sender instanceof Player player) plugin.getBukkitScheduler().runTask(plugin, send, player);
+ else plugin.getBukkitScheduler().runTask(plugin, send);
+ }
+}
diff --git a/MCPerks/src/main/java/com/bencodez/mcperks/data/DurableFeatureFiles.java b/MCPerks/src/main/java/com/bencodez/mcperks/data/DurableFeatureFiles.java
new file mode 100644
index 0000000..51181b0
--- /dev/null
+++ b/MCPerks/src/main/java/com/bencodez/mcperks/data/DurableFeatureFiles.java
@@ -0,0 +1,16 @@
+package com.bencodez.mcperks.data;
+import java.io.IOException;
+import java.nio.channels.FileChannel;
+import java.nio.file.*;
+/** Forces staged contents and atomic publication. A post-move error has an uncertain outcome. */
+public final class DurableFeatureFiles {
+ private DurableFeatureFiles() {}
+ @FunctionalInterface public interface Publisher { void publish(Path staged, Path file) throws IOException; }
+ public static void publish(Path staged, Path file) throws IOException {
+ try (FileChannel channel = FileChannel.open(staged, StandardOpenOption.WRITE)) { channel.force(true); }
+ Files.move(staged, file, StandardCopyOption.ATOMIC_MOVE, StandardCopyOption.REPLACE_EXISTING);
+ try (FileChannel channel = FileChannel.open(file.toAbsolutePath().getParent(), StandardOpenOption.READ)) { channel.force(true); }
+ catch (AccessDeniedException error) { if (!System.getProperty("os.name", "").startsWith("Windows")) throw error; }
+ catch (UnsupportedOperationException ignored) { /* Provider does not expose directory forcing. */ }
+ }
+}
diff --git a/MCPerks/src/main/java/com/bencodez/mcperks/data/FeatureFileOwnership.java b/MCPerks/src/main/java/com/bencodez/mcperks/data/FeatureFileOwnership.java
new file mode 100644
index 0000000..ef3312a
--- /dev/null
+++ b/MCPerks/src/main/java/com/bencodez/mcperks/data/FeatureFileOwnership.java
@@ -0,0 +1,47 @@
+package com.bencodez.mcperks.data;
+import java.nio.file.*;
+import java.nio.channels.*;
+import java.io.*;
+import java.util.*;
+import java.util.concurrent.*;
+/** Storage workers retain an OS lock through drain, including across plugin classloader replacement. */
+public final class FeatureFileOwnership {
+ private static final Map> owners = new HashMap<>();
+ private final Path path;
+ private final CompletableFuture predecessor, drained = new CompletableFuture<>();
+ private FileChannel channel;
+ private FileLock lock;
+ public FeatureFileOwnership(Path file) {
+ path = file.toAbsolutePath().normalize();
+ synchronized (owners) { predecessor = owners.put(path, drained); }
+ }
+ public synchronized void awaitPredecessor() {
+ if (predecessor != null) predecessor.join();
+ try {
+ Files.createDirectories(path.getParent());
+ Path guard = path.resolveSibling(path.getFileName() + ".lock");
+ channel = FileChannel.open(guard, StandardOpenOption.CREATE, StandardOpenOption.WRITE, LinkOption.NOFOLLOW_LINKS);
+ long deadline = System.nanoTime() + TimeUnit.SECONDS.toNanos(30);
+ while (lock == null) {
+ try { lock = channel.tryLock(); } catch (OverlappingFileLockException busy) { }
+ if (lock != null) return;
+ if (System.nanoTime() >= deadline) throw new IOException("Predecessor storage owner has not drained");
+ try { TimeUnit.MILLISECONDS.sleep(25); }
+ catch (InterruptedException interrupted) { Thread.currentThread().interrupt(); throw new IOException("Storage ownership interrupted", interrupted); }
+ }
+ } catch (IOException failure) {
+ try { if (channel != null) channel.close(); } catch (IOException cleanup) { failure.addSuppressed(cleanup); }
+ channel = null;
+ throw new UncheckedIOException(failure);
+ }
+ }
+ public synchronized void drained() {
+ if (drained.isDone()) return;
+ try {
+ if (channel != null) channel.close(); // Releases the lock before publishing drain completion.
+ lock = null; channel = null; drained.complete(null);
+ } catch (IOException failure) { drained.completeExceptionally(failure); }
+ synchronized (owners) { owners.remove(path, drained); }
+ // Keep the empty lock file: unlinking it could let another classloader lock a different inode.
+ }
+}
diff --git a/MCPerks/src/main/java/com/bencodez/mcperks/data/FeatureState.java b/MCPerks/src/main/java/com/bencodez/mcperks/data/FeatureState.java
new file mode 100644
index 0000000..19cb07c
--- /dev/null
+++ b/MCPerks/src/main/java/com/bencodez/mcperks/data/FeatureState.java
@@ -0,0 +1,244 @@
+package com.bencodez.mcperks.data;
+import java.io.*;
+import java.nio.file.*;
+import java.util.*;
+import java.util.concurrent.*;
+import java.util.function.Supplier;
+/** Bounded, ordered persistence for queue identities and opt-in personal banked time. */
+public final class FeatureState implements AutoCloseable {
+ private static final long MAX_FILE_BYTES = 3_000_000;
+ public enum Stage { WAITING, STARTING, UNCERTAIN }
+ public record QueueEntry(UUID id, UUID owner, String perk, long admitted, Stage stage, String credit) {
+ public QueueEntry withStage(Stage next) { return new QueueEntry(id, owner, perk, admitted, next, credit); }
+ }
+ public record BankKey(UUID owner, String perk) {}
+ public record Bank(long milliseconds, boolean paused) {}
+ private final Path file;
+ private final DurableFeatureFiles.Publisher publisher;
+ private final com.bencodez.mcperks.data.FeatureFileOwnership ownership;
+ private final ThreadPoolExecutor worker;
+ private volatile Thread ownerThread;
+ private volatile List queue = List.of();
+ private volatile Map banks = Map.of();
+ private final Object bankBoundaryLock = new Object();
+ // Banks are never removed and are capped at 10,000. Retain one epoch per replaced
+ // bank, rather than retaining every disconnected clock during a blocked publish.
+ private final ConcurrentHashMap bankReplacementVersions = new ConcurrentHashMap<>();
+ private volatile boolean paused, failed, ownershipFailed;
+ public record BankGrant(long elapsed, Runnable commit, Runnable rollback) {}
+ private volatile java.util.function.BiFunction bankGrantBoundary = (key, oldBalance) -> new BankGrant(0, () -> {}, () -> {});
+ private volatile java.util.function.Function bankReplacementBoundary = key -> new BankGrant(0, () -> {}, () -> {});
+ private final CompletableFuture ready;
+ public FeatureState(Path file) { this(file, DurableFeatureFiles::publish); }
+ FeatureState(Path file, DurableFeatureFiles.Publisher publisher) {
+ this.file = file; this.publisher = publisher;
+ ownership = new com.bencodez.mcperks.data.FeatureFileOwnership(file);
+ worker = new ThreadPoolExecutor(1, 1, 0, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<>(256), r -> {
+ Thread t = new Thread(r, "MCPerks-feature-store"); t.setDaemon(true); ownerThread = t; return t;
+ }, new ThreadPoolExecutor.AbortPolicy()) {
+ @Override protected void terminated() { ownership.drained(); }
+ };
+ ready = submit(() -> {
+ try { ownership.awaitPredecessor(); }
+ catch (RuntimeException | Error failure) { ownershipFailed = true; failed = true; throw failure; }
+ read(); return null;
+ });
+ }
+ public CompletableFuture ready() { return ready; }
+ public boolean available() { return ready.isDone() && !ready.isCompletedExceptionally() && !failed; }
+ public List queue() { return queue; }
+ public Map banks() { return banks; }
+ public long bankReplacementVersion(BankKey key) { return bankReplacementVersions.getOrDefault(key, 0L); }
+ /** Memory-only clock creation/reservation; never submit storage or perform I/O in this turn. */
+ public T bankCheckpoint(Supplier checkpoint) {
+ synchronized (bankBoundaryLock) { return checkpoint.get(); }
+ }
+ /** Register the clock boundary used when a grant is published on this ordered store. */
+ public void onBankGrant(java.util.function.BiFunction boundary) {
+ bankGrantBoundary = java.util.Objects.requireNonNull(boundary);
+ }
+ /** Replacements establish a new clock/debit ownership boundary after publication. */
+ public void onBankReplacement(java.util.function.Function boundary) {
+ bankReplacementBoundary = java.util.Objects.requireNonNull(boundary);
+ }
+ public boolean paused() { return paused; }
+ public int reserved(UUID owner, String credit) { return (int) queue.stream().filter(e -> e.owner.equals(owner) && e.credit.equals(credit)).count(); }
+ public CompletableFuture enqueue(UUID owner, String perk, String credit, int available) {
+ return submit(() -> {
+ if (queue.size() >= 256) throw new IllegalStateException("Queue capacity reached");
+ if (queue.stream().anyMatch(e -> e.owner.equals(owner))) throw new IllegalStateException("Player already queued");
+ if (!credit.isEmpty() && available <= reserved(owner, credit)) throw new IllegalStateException("Activation already reserved");
+ QueueEntry entry = new QueueEntry(UUID.randomUUID(), owner, boundedName(perk), System.currentTimeMillis(), Stage.WAITING, boundedCredit(credit));
+ var next = new ArrayList<>(queue); next.add(entry); publish(next, banks, paused); return entry;
+ });
+ }
+ /** Persist the irreversible start fence before consuming credit or applying effects. */
+ public CompletableFuture claim(UUID id) {
+ return submit(() -> {
+ if (paused || queue.isEmpty() || !queue.getFirst().id.equals(id) || queue.getFirst().stage != Stage.WAITING) return null;
+ var next = new ArrayList<>(queue); QueueEntry entry = next.getFirst().withStage(Stage.STARTING); next.set(0, entry);
+ publish(next, banks, paused); return entry;
+ });
+ }
+ public CompletableFuture cancel(UUID id, UUID owner, boolean staff) {
+ return submit(() -> {
+ var next = new ArrayList<>(queue);
+ boolean removed = next.removeIf(e -> e.id.equals(id) && (staff || e.owner.equals(owner)) && (e.stage == Stage.WAITING || staff && e.stage == Stage.UNCERTAIN));
+ if (removed) publish(next, banks, paused); return removed;
+ });
+ }
+ public CompletableFuture complete(UUID id) {
+ return submit(() -> { var next = new ArrayList<>(queue); next.removeIf(e -> e.id.equals(id) && e.stage == Stage.STARTING); publish(next, banks, paused); return null; });
+ }
+ public CompletableFuture uncertain(UUID id) {
+ return submit(() -> { var next = new ArrayList<>(queue); next.replaceAll(e -> e.id.equals(id) ? e.withStage(Stage.UNCERTAIN) : e); publish(next, banks, paused); return null; });
+ }
+ public CompletableFuture releaseClaim(UUID id) {
+ return submit(() -> { var next = new ArrayList<>(queue); next.replaceAll(e -> e.id.equals(id) && e.stage == Stage.STARTING ? e.withStage(Stage.WAITING) : e); publish(next, banks, paused); return null; });
+ }
+ public CompletableFuture move(UUID id, int position) {
+ return submit(() -> {
+ var next = new ArrayList<>(queue); QueueEntry selected = next.stream().filter(e -> e.id.equals(id) && e.stage == Stage.WAITING).findFirst().orElse(null);
+ if (selected == null || queue.stream().anyMatch(e -> e.stage == Stage.STARTING)) return false;
+ next.remove(selected); next.add(Math.max(0, Math.min(position - 1, next.size())), selected); publish(next, banks, paused); return true;
+ });
+ }
+ public CompletableFuture pauseQueue(boolean value) { return submit(() -> { publish(queue, banks, value); return null; }); }
+ public CompletableFuture clearWaiting() { return submit(() -> { publish(queue.stream().filter(e -> e.stage != Stage.WAITING).toList(), banks, paused); return null; }); }
+ public CompletableFuture setBank(BankKey key, long milliseconds) {
+ if (milliseconds < 0 || milliseconds > 31_536_000_000L) return CompletableFuture.failedFuture(new IllegalArgumentException("Banked time must be between zero and one year"));
+ return submit(() -> {
+ boundedName(key.perk); if (!banks.containsKey(key) && (banks.size() >= 10000 || banks.keySet().stream().filter(k -> k.owner.equals(key.owner)).count() >= 64)) throw new IllegalStateException("Bank capacity reached");
+ var next = new HashMap<>(banks); Bank bank = new Bank(milliseconds, false); next.put(key, bank);
+ BankGrant boundary = bankReplacementBoundary.apply(key);
+ try {
+ publish(queue, next, paused, () -> {
+ bankReplacementVersions.merge(key, 1L, Long::sum);
+ boundary.commit().run();
+ });
+ return bank;
+ }
+ catch (RuntimeException | Error failure) { boundary.rollback().run(); throw failure; }
+ });
+ }
+ public CompletableFuture addBank(BankKey key, long milliseconds) {
+ return storage(() -> { Bank bank = addBankOnWorker(key, milliseconds, () -> true);
+ if (bank == null) throw new IllegalStateException("Bank capacity reached"); return bank; });
+ }
+ /** Called only inside storage(): capacity and debit share this store's ordered ownership. */
+ public Bank addBankOnWorker(BankKey key, long milliseconds, java.util.function.BooleanSupplier debit) {
+ if (Thread.currentThread() != ownerThread) throw new IllegalStateException("Bank grant requires state worker ownership");
+ if (milliseconds < 1 || milliseconds > 31_536_000_000L) throw new IllegalArgumentException("Invalid bank grant");
+ boundedName(key.perk); Bank old = banks.get(key);
+ if (old == null && (banks.size() >= 10000 || banks.keySet().stream().filter(k -> k.owner.equals(key.owner)).count() >= 64)) return null;
+ long remaining = old == null ? 0 : old.milliseconds;
+ if (milliseconds > 31_536_000_000L - remaining) return null;
+ // Deterministic byte capacity must reject before an irreversible activation debit.
+ var capacityCandidate = new HashMap<>(banks);
+ capacityCandidate.put(key, new Bank(remaining + milliseconds, old != null && old.paused));
+ if (!fitsSerializedCapacity(queue, capacityCandidate, paused)) return null;
+ if (!debit.getAsBoolean()) return null;
+ BankGrant boundary = bankGrantBoundary.apply(key, remaining);
+ long elapsedBeforeGrant = Math.min(remaining, boundary.elapsed());
+ Bank bank = new Bank(remaining + milliseconds - elapsedBeforeGrant, old != null && old.paused);
+ var next = new HashMap<>(banks); next.put(key, bank);
+ try { publish(queue, next, paused, boundary.commit()); return bank; }
+ catch (RuntimeException | Error failure) { boundary.rollback().run(); throw failure; }
+ }
+ public CompletableFuture pauseBank(BankKey key, boolean value) {
+ return submit(() -> { Bank old = banks.get(key); if (old == null) return null; var next = new HashMap<>(banks);
+ Bank bank = new Bank(old.milliseconds, value); next.put(key, bank); publish(queue, next, paused); return bank; });
+ }
+ public CompletableFuture elapsed(BankKey key, long milliseconds) {
+ return elapsed(key, milliseconds, () -> true);
+ }
+ /** A delayed controller debit must still own the clock's published bank replacement. */
+ public CompletableFuture elapsed(BankKey key, long milliseconds, java.util.function.BooleanSupplier ownsReplacement) {
+ if (milliseconds < 0 || milliseconds > 31_536_000_000L) return CompletableFuture.failedFuture(new IllegalArgumentException("Invalid bank checkpoint"));
+ return submit(() -> { Bank old = banks.get(key); if (!ownsReplacement.getAsBoolean() || old == null || old.paused) return old; var next = new HashMap<>(banks);
+ Bank bank = new Bank(Math.max(0, old.milliseconds - milliseconds), false); next.put(key, bank); publish(queue, next, paused); return bank; });
+ }
+ /** Database confirmation runs on this ordered worker, never on a player/server owner. */
+ public CompletableFuture storage(Supplier work) { return submit(work); }
+ /** Independent legacy YAML uses the same ordered capacity, even if optional feature data is unreadable. */
+ public CompletableFuture runtimeStorage(Supplier work) { return submit(work, false); }
+ private CompletableFuture submit(Supplier operation) { return submit(operation, true); }
+ private CompletableFuture submit(Supplier operation, boolean requireFeatureData) {
+ var future = new CompletableFuture();
+ try { worker.execute(() -> {
+ if (ownershipFailed || requireFeatureData && failed) { future.completeExceptionally(new IllegalStateException("Feature store unavailable until restart")); return; }
+ try { future.complete(operation.get()); } catch (Throwable error) { future.completeExceptionally(error); }
+ }); } catch (RejectedExecutionException error) { future.completeExceptionally(error); }
+ return future;
+ }
+ private void publish(List entries, Map bankValues, boolean queuePaused) {
+ publish(entries, bankValues, queuePaused, () -> {});
+ }
+ private void publish(List entries, Map bankValues, boolean queuePaused, Runnable bankCommit) {
+ Path staged = null;
+ try {
+ Files.createDirectories(file.toAbsolutePath().getParent()); if (Files.isSymbolicLink(file)) throw new IOException("Feature file is a symlink");
+ staged = Files.createTempFile(file.toAbsolutePath().getParent(), ".feature-", ".tmp");
+ try (DataOutputStream out = new DataOutputStream(new BufferedOutputStream(Files.newOutputStream(staged)))) {
+ writeState(out, entries, bankValues, queuePaused);
+ }
+ // writeUTF uses modified UTF-8, so count the actual complete serialized bytes.
+ // Capacity rejection leaves the previous publication usable, unlike uncertain I/O failure.
+ if (Files.size(staged) > MAX_FILE_BYTES) throw new IllegalStateException("Feature state byte capacity reached");
+ publisher.publish(staged, file);
+ var confirmedQueue = List.copyOf(entries); var confirmedBanks = Map.copyOf(bankValues);
+ // No filesystem work occurs under this monitor. A late clock cannot be
+ // created/reserved between its committed boundary and balance exposure.
+ synchronized (bankBoundaryLock) {
+ bankCommit.run();
+ queue = confirmedQueue; banks = confirmedBanks; paused = queuePaused;
+ }
+ } catch (IOException error) { failed = true; throw new CompletionException(error); }
+ finally { if (staged != null) try { Files.deleteIfExists(staged); } catch (IOException ignored) {} }
+ }
+ private static void writeState(DataOutputStream out, List entries,
+ Map bankValues, boolean queuePaused) throws IOException {
+ out.writeInt(0x4d435032); out.writeBoolean(queuePaused); out.writeInt(entries.size());
+ for (QueueEntry entry : entries) { uuid(out, entry.id); uuid(out, entry.owner); out.writeUTF(entry.perk); out.writeLong(entry.admitted); out.writeInt(entry.stage.ordinal()); out.writeUTF(entry.credit); }
+ out.writeInt(bankValues.size());
+ for (var entry : bankValues.entrySet()) { uuid(out, entry.getKey().owner); out.writeUTF(entry.getKey().perk); out.writeLong(entry.getValue().milliseconds); out.writeBoolean(entry.getValue().paused); }
+ }
+ private static boolean fitsSerializedCapacity(List entries, Map bankValues,
+ boolean queuePaused) {
+ // The real serializer counts modified UTF-8 exactly without allocating a full snapshot.
+ var out = new DataOutputStream(java.io.OutputStream.nullOutputStream());
+ try { writeState(out, entries, bankValues, queuePaused); return out.size() <= MAX_FILE_BYTES; }
+ catch (IOException invalid) { throw new CompletionException(invalid); }
+ }
+ private void read() {
+ try {
+ if (Files.isSymbolicLink(file)) throw new IOException("Feature file is a symlink");
+ if (!Files.exists(file)) return; if (Files.size(file) > MAX_FILE_BYTES) throw new IOException("Oversized feature state");
+ var entries = new ArrayList(); var bankValues = new HashMap(); Set ids = new HashSet<>(), owners = new HashSet<>();
+ try (DataInputStream in = new DataInputStream(new BufferedInputStream(Files.newInputStream(file)))) {
+ if (in.readInt() != 0x4d435032) throw new IOException("Invalid feature state"); boolean queuePaused = in.readBoolean();
+ int count = count(in.readInt(), 256);
+ for (int i = 0; i < count; i++) {
+ UUID id = uuid(in), owner = uuid(in); String perk = boundedName(in.readUTF()); long admitted = in.readLong(); int stage = count(in.readInt(), Stage.values().length-1); String credit = boundedCredit(in.readUTF());
+ if (!ids.add(id) || !owners.add(owner) || admitted < 0) throw new IOException("Duplicate/invalid queue identity");
+ entries.add(new QueueEntry(id, owner, perk, admitted, stage == Stage.STARTING.ordinal() ? Stage.UNCERTAIN : Stage.values()[stage], credit));
+ }
+ int bankCount = count(in.readInt(), 10000); Map perOwner = new HashMap<>();
+ for (int i = 0; i < bankCount; i++) {
+ BankKey key = new BankKey(uuid(in), boundedName(in.readUTF()));
+ if (perOwner.merge(key.owner(), 1, Integer::sum) > 64) throw new IOException("Too many banks for one player");
+ long value = in.readLong(); boolean bankPaused = in.readBoolean();
+ if (value < 0 || value > 31_536_000_000L || bankValues.put(key, new Bank(value, bankPaused)) != null) throw new IOException("Invalid bank value");
+ }
+ if (in.read() != -1) throw new IOException("Trailing feature state"); queue = List.copyOf(entries); banks = Map.copyOf(bankValues); paused = queuePaused;
+ }
+ } catch (IOException | IllegalArgumentException error) { failed = true; throw new CompletionException(error); }
+ }
+ private static String boundedName(String name) { if (name == null || name.isEmpty() || name.length() > 128 || name.chars().anyMatch(c -> c < 32 || c == 127)) throw new IllegalArgumentException("Invalid perk name"); return name; }
+ private static String boundedCredit(String credit) { if (credit == null || credit.length() > 144 || !(credit.isEmpty() || credit.equals("Activations") || credit.startsWith("PerkActivations_") && validCreditName(credit.substring(16)))) throw new IllegalArgumentException("Invalid credit key"); return credit; }
+ private static boolean validCreditName(String name) { try { boundedName(name); return true; } catch (IllegalArgumentException invalid) { return false; } }
+ private static int count(int value, int maximum) throws IOException { if (value < 0 || value > maximum) throw new IOException("Invalid state count"); return value; }
+ private static void uuid(DataOutputStream out, UUID id) throws IOException { out.writeLong(id.getMostSignificantBits()); out.writeLong(id.getLeastSignificantBits()); }
+ private static UUID uuid(DataInputStream in) throws IOException { return new UUID(in.readLong(), in.readLong()); }
+ @Override public void close() { worker.shutdown(); }
+}
diff --git a/MCPerks/src/main/java/com/bencodez/mcperks/data/LocalStatistics.java b/MCPerks/src/main/java/com/bencodez/mcperks/data/LocalStatistics.java
new file mode 100644
index 0000000..c69125b
--- /dev/null
+++ b/MCPerks/src/main/java/com/bencodez/mcperks/data/LocalStatistics.java
@@ -0,0 +1,21 @@
+package com.bencodez.mcperks.data;
+import java.util.*;
+import java.util.concurrent.atomic.LongAdder;
+/** Local aggregate counts only: no external reporting, players, inventories, commands or locations. */
+public final class LocalStatistics {
+ private volatile boolean enabled;
+ public void enabled(boolean value) { enabled = value; }
+ private final LongAdder activations = new LongAdder(), queueStarts = new LongAdder(), queueWaitMillis = new LongAdder();
+ private final EnumMap skips = new EnumMap<>(Skip.class);
+ public enum Skip { INACTIVE, AUDIENCE, WORLD, PRECISION, BANKED, SHARED_CHARGES, DEPLETED, TOOL, MATERIAL, IMMATURE, SEED, INVENTORY_CHANGED, NATIVE_BREAK_DENIED, INTERACTION_DENIED, BUSY, STORAGE, UNCERTAIN }
+ public LocalStatistics() { for (Skip skip : Skip.values()) skips.put(skip, new LongAdder()); }
+ public void activation() { if (enabled) activations.increment(); }
+ public void queueStart(long waitMillis) { if (!enabled) return; queueStarts.increment(); queueWaitMillis.add(Math.max(0, Math.min(waitMillis, 31_536_000_000L))); }
+ public void skip(Skip reason) { if (enabled) skips.get(reason).increment(); }
+ public String summary() {
+ if (!enabled) return "LocalStatistics.Enabled is false; aggregate collection disabled.";
+ StringBuilder text = new StringBuilder("activations=").append(activations.sum()).append(", queued starts=").append(queueStarts.sum()).append(", queue wait seconds=").append(queueWaitMillis.sum()/1000);
+ for (Skip reason : Skip.values()) { long count = skips.get(reason).sum(); if (count > 0) text.append(", ").append(reason).append('=').append(count); }
+ return text.toString();
+ }
+}
diff --git a/MCPerks/src/main/java/com/bencodez/mcperks/data/OrderedServerDataFile.java b/MCPerks/src/main/java/com/bencodez/mcperks/data/OrderedServerDataFile.java
new file mode 100644
index 0000000..ba65568
--- /dev/null
+++ b/MCPerks/src/main/java/com/bencodez/mcperks/data/OrderedServerDataFile.java
@@ -0,0 +1,73 @@
+package com.bencodez.mcperks.data;
+
+import java.io.File;
+import org.bukkit.configuration.file.FileConfiguration;
+import org.bukkit.plugin.Plugin;
+import com.bencodez.mcperks.MCPerksMain;
+import com.bencodez.advancedcore.api.time.TimeType;
+
+/** Shares AdvancedCore's initialized YAML while keeping calendar and perk writes ordered together. */
+public final class OrderedServerDataFile extends com.bencodez.advancedcore.data.ServerData {
+ private final com.bencodez.advancedcore.data.ServerData delegate;
+ private final ServerData runtime;
+ private final TransitionFile transitions;
+ public OrderedServerDataFile(MCPerksMain plugin, com.bencodez.advancedcore.data.ServerData delegate, ServerData runtime) {
+ super(plugin); this.delegate = delegate; this.runtime = runtime; transitions = new TransitionFile(plugin);
+ // Native TimeChecker saves LastUpdated before onPostLoad creates FeatureState.
+ // Keep that mutation in memory until the original disk source is strictly reconciled.
+ if (plugin.getFeatureState() == null) runtime.deferNativeSaves(delegate.getData(), delegate.isJustCreated());
+ }
+ @Override public FileConfiguration getData() { return delegate.getData(); }
+ @Override public File getdFile() { return delegate.getdFile(); }
+ @Override public boolean isFailedToRead() { return delegate.isFailedToRead(); }
+ @Override public void saveData() { runtime.saveData(); }
+ // Only calendar callers share this monitor. Inherited mutation/rollback operates on a private
+ // view; gameplay never acquires this monitor or waits for calendar file publication.
+ private T calendar(java.util.function.Function operation) {
+ runtime.ready().join();
+ transitions.view = runtime.timeTransitionView();
+ try { return operation.apply(transitions); }
+ finally { transitions.view = null; }
+ }
+ private final class TransitionFile extends com.bencodez.advancedcore.data.ServerData {
+ private ServerData.TimeTransitionView view;
+ private TransitionFile(MCPerksMain plugin) { super(plugin); }
+ @Override public FileConfiguration getData() { return view.data(); }
+ @Override protected synchronized void saveTimeChangeTransitionData() {
+ // TimeChecker invokes this synchronous durability API off the gameplay owner.
+ runtime.confirmedTimeTransition(view).join();
+ }
+ }
+ @Override public synchronized TimeChangeTransitionState beginTimeChangeTransition(TimeType type, String period, String marker) {
+ return calendar(file -> file.beginTimeChangeTransition(type, period, marker));
+ }
+ @Override public synchronized TimeChangeTransitionState getPendingTimeChangeTransition(TimeType type) {
+ return calendar(file -> file.getPendingTimeChangeTransition(type));
+ }
+ @Override public synchronized void completeTimeChangeTransition(TimeChangeTransitionState transition) {
+ calendar(file -> { file.completeTimeChangeTransition(transition); return null; });
+ }
+ @Override public synchronized void failTimeChangeTransition(TimeChangeTransitionState transition) {
+ calendar(file -> { file.failTimeChangeTransition(transition); return null; });
+ }
+ @Override public synchronized boolean isPendingTimeChangeTransition(TimeChangeTransitionState transition) {
+ return calendar(file -> file.isPendingTimeChangeTransition(transition));
+ }
+ @Override public void reloadData() { runtime.reloadFrom(delegate); }
+ @Override public void setData(String path, Object value) { synchronized (runtime) { runtime.calendarEdited(path); super.setData(path, value); } }
+ @Override public void setData(FileConfiguration data) { synchronized (runtime) { runtime.calendarEdited(""); delegate.setData(data); } }
+ @Override public void setValue(String path, Object value) { synchronized (runtime) { runtime.calendarEdited(path); super.setValue(path, value); } }
+ @Override public void createSection(String path) { synchronized (runtime) { runtime.calendarEdited(path); super.createSection(path); } }
+ @Override public void setIgnoreTime(boolean value) { synchronized (runtime) { super.setIgnoreTime(value); } }
+ @Override public void setLastUpdated() { synchronized (runtime) { super.setLastUpdated(); } }
+ @Override public void setPluginVersion(Plugin plugin) { synchronized (runtime) { super.setPluginVersion(plugin); } }
+ @Override public void setPrevDay(int value) { synchronized (runtime) { runtime.calendarEdited("PrevDay"); super.setPrevDay(value); } }
+ @Override public void setPrevMonth(String value) { synchronized (runtime) { runtime.calendarEdited("Month"); super.setPrevMonth(value); } }
+ @Override public void setPrevWeekDay(int value) { synchronized (runtime) { runtime.calendarEdited("PrevWeek"); super.setPrevWeekDay(value); } }
+ @Override public long getLastUpdated() { synchronized (runtime) { return super.getLastUpdated(); } }
+ @Override public String getPluginVersion(Plugin plugin) { synchronized (runtime) { return super.getPluginVersion(plugin); } }
+ @Override public int getPrevDay() { synchronized (runtime) { return super.getPrevDay(); } }
+ @Override public String getPrevMonth() { synchronized (runtime) { return super.getPrevMonth(); } }
+ @Override public int getPrevWeekDay() { synchronized (runtime) { return super.getPrevWeekDay(); } }
+ @Override public boolean isIgnoreTime() { synchronized (runtime) { return super.isIgnoreTime(); } }
+}
diff --git a/MCPerks/src/main/java/com/bencodez/mcperks/data/ServerData.java b/MCPerks/src/main/java/com/bencodez/mcperks/data/ServerData.java
index 7eed851..883abb9 100644
--- a/MCPerks/src/main/java/com/bencodez/mcperks/data/ServerData.java
+++ b/MCPerks/src/main/java/com/bencodez/mcperks/data/ServerData.java
@@ -1,70 +1,505 @@
-/*
- *
- */
package com.bencodez.mcperks.data;
+import java.io.IOException;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.*;
+import java.util.*;
+import java.util.concurrent.*;
import org.bukkit.configuration.file.FileConfiguration;
-
import com.bencodez.mcperks.MCPerksMain;
import com.bencodez.mcperks.perk.Perk;
-// TODO: Auto-generated Javadoc
-/**
- * The Class ServerData.
- */
+/** Legacy runtime YAML. Owner mutations produce immutable, ordered worker snapshots. */
public class ServerData {
+ private final MCPerksMain plugin;
+ private final DurableFeatureFiles.Publisher publisher;
+ private CalendarUpdate pendingCalendar;
+ private volatile CompletableFuture initialization = CompletableFuture.completedFuture(null);
+ private boolean canonicalLoaded = true;
+ private boolean nativeTimedPermissionsObserved;
+ private boolean nativeStartupDeferred;
+ private String nativeStartupBaseline;
+ private boolean nativeCreatedEmptySource;
+ private Map> nativePermissionSource = Map.of();
+ private com.bencodez.advancedcore.api.permissions.PermissionHandler observedNativeHandler;
+ private Map nativePermissionBaseline = Map.of();
+ private RuntimeException nativePermissionSnapshotFailure;
+ /** Early native writes cannot overwrite a source that has not been strictly read. */
+ public synchronized void deferNativeSaves(FileConfiguration original, boolean justCreated) {
+ if (!nativeStartupDeferred) {
+ nativeStartupBaseline = original.saveToString();
+ nativeCreatedEmptySource = justCreated && original.getKeys(false).isEmpty();
+ nativeStartupDeferred = true; canonicalLoaded = false;
+ initialization = new CompletableFuture<>();
+ }
+ }
+ /** The plugin getter captures state before the first native grant/revoke/login call. */
+ public synchronized void observeNativePermissionHandler(com.bencodez.advancedcore.api.permissions.PermissionHandler handler) {
+ if (observedNativeHandler == null) {
+ observedNativeHandler = handler;
+ try { nativePermissionBaseline = nativePermissionSnapshot(handler); }
+ catch (RuntimeException failure) { nativePermissionSnapshotFailure = failure; }
+ }
+ }
+ private final java.util.concurrent.atomic.AtomicInteger pendingSnapshots = new java.util.concurrent.atomic.AtomicInteger();
+ private final ThreadLocal> activationWrites = new ThreadLocal<>();
+ public ServerData(MCPerksMain plugin) { this(plugin, DurableFeatureFiles::publish); }
+ ServerData(MCPerksMain plugin, DurableFeatureFiles.Publisher publisher) { this.plugin = plugin; this.publisher = publisher; }
- private MCPerksMain plugin;
-
- public ServerData(MCPerksMain plugin) {
- this.plugin = plugin;
- }
-
- public void addPerkHistory(String data) {
- String path = "PerkHistory." + plugin.getTimeChecker().getTime().getMonth().toString();
- getData().set(path, getData().getStringList(path).add(data));
- saveData();
- }
-
- /**
- * Gets the data.
- *
- * @return the data
- */
- public FileConfiguration getData() {
- return plugin.getServerDataFile().getData();
- }
-
- public long getPerkExperation(Perk perk) {
- return getData().getLong("Experation." + perk.getPerk());
- }
-
- /**
- * Reload data.
- */
- public void reloadData() {
- plugin.getServerDataFile().reloadData();
- }
-
- /**
- * Save data.
- */
- public void saveData() {
- plugin.getServerDataFile().saveData();
- }
-
- public void setPerkExperation(Perk perk, long time) {
- getData().set("Experation." + perk.getPerk(), time);
- saveData();
- }
-
- public void saveOfflinePerk(Perk perk) {
- if (perk.isLastForever()) {
- getData().set("OfflinePerk." + perk.getActivater().getUUID() + "." + perk.getPerk() + ".Experiaton", -1);
- } else {
- getData().set("OfflinePerk." + perk.getActivater().getUUID() + "." + perk.getPerk() + ".Experiaton",
- perk.getExperation(perk.getActivater()));
- }
- }
+ public CompletableFuture ready() { return initialization; }
+ public boolean isReady() { return initialization.isDone() && !initialization.isCompletedExceptionally(); }
+ /** Called by the early native-file hook before AdvancedCore constructs its handler. */
+ public synchronized void observeNativePermissionSource(FileConfiguration data) {
+ if (plugin.getPermissionHandler() == null && data != null) {
+ var section = data.getConfigurationSection("TimedPermissions");
+ if (!nativeTimedPermissionsObserved && section != null && !section.getKeys(false).isEmpty()) {
+ nativeTimedPermissionsObserved = true; nativePermissionSource = permissionRows(data);
+ }
+ }
+ }
+ // These are the scalar fields mutated by AdvancedCore's transition API, verified against its
+ // actual implementation. Copies/changes are bounded independently of perk/history contents.
+ private static final List CALENDAR_PATHS = calendarPaths();
+ private final long[] calendarEdits = new long[CALENDAR_PATHS.size()];
+ synchronized void calendarEdited(String path) {
+ for (int i = 0; i < CALENDAR_PATHS.size(); i++)
+ if (path.isEmpty() || CALENDAR_PATHS.get(i).equals(path) || CALENDAR_PATHS.get(i).startsWith(path + ".")) calendarEdits[i]++;
+ }
+ private static List calendarPaths() {
+ var paths = new ArrayList<>(List.of("PrevDay", "PrevWeek", "Month"));
+ for (var type : com.bencodez.advancedcore.api.time.TimeType.values())
+ for (String field : List.of("Id", "Period", "Marker", "Pending")) paths.add("TimeTransitions." + type.name() + "." + field);
+ return List.copyOf(paths);
+ }
+ record TimeTransitionView(FileConfiguration data, Map before) {}
+ synchronized TimeTransitionView timeTransitionView() {
+ try {
+ var copy = parse(getData().saveToString());
+ var before = new LinkedHashMap();
+ for (String path : CALENDAR_PATHS) before.put(path, snapshotValue(copy.get(path)));
+ return new TimeTransitionView(copy, Collections.unmodifiableMap(before));
+ } catch (org.bukkit.configuration.InvalidConfigurationException error) { throw new CompletionException(error); }
+ }
+ private static Object snapshotValue(Object value) {
+ if (value instanceof org.bukkit.configuration.ConfigurationSection section) return snapshotValue(tree(section));
+ if (value instanceof Map map) {
+ var copy = new LinkedHashMap(); map.forEach((key, child) -> copy.put(key, snapshotValue(child)));
+ return Collections.unmodifiableMap(copy);
+ }
+ if (value instanceof List list) return Collections.unmodifiableList(list.stream().map(ServerData::snapshotValue).toList());
+ if (value instanceof java.util.Date date) return date.toInstant();
+ return value;
+ }
+ private record CalendarChange(int field, long edit, Object after) {}
+ private static final class CalendarUpdate {
+ private final Map changes;
+ private volatile boolean published;
+ private CalendarUpdate(Map changes) { this.changes = Collections.unmodifiableMap(changes); }
+ private void apply(FileConfiguration data, long[] edits) {
+ changes.forEach((path, change) -> {
+ if (edits == null || edits[change.field()] == change.edit()) data.set(path, change.after());
+ });
+ }
+ }
+ /** Admit a private calendar mutation and immutable snapshot, then release ownership before waiting. */
+ synchronized CompletableFuture confirmedTimeTransition(TimeTransitionView view) {
+ if (!isReady()) return CompletableFuture.failedFuture(new IllegalStateException("ServerData initialization unavailable"));
+ try {
+ var changes = new LinkedHashMap();
+ for (int i = 0; i < CALENDAR_PATHS.size(); i++) {
+ String path = CALENDAR_PATHS.get(i); Object next = snapshotValue(view.data().get(path));
+ if (!Objects.equals(view.before().get(path), next)) changes.put(path, new CalendarChange(i, calendarEdits[i], next));
+ }
+ var update = new CalendarUpdate(changes);
+ var copy = parse(getData().saveToString()); update.apply(copy, null);
+ byte[] snapshot = snapshotBytes(copy);
+ pendingCalendar = update;
+ return publishSnapshot(snapshot, List.of(), null, null, update);
+ } catch (org.bukkit.configuration.InvalidConfigurationException | RuntimeException error) { return CompletableFuture.failedFuture(error); }
+ }
+ /** Reconcile the cache loaded by AdvancedCore before a prior feature worker finished shutdown. */
+ public synchronized CompletableFuture initialize(FeatureState state) {
+ String baseline = nativeStartupDeferred ? nativeStartupBaseline : getData().saveToString();
+ var nativePermissions = plugin.getPermissionHandler();
+ if (nativePermissions != null) observeNativePermissionHandler(nativePermissions);
+ Path file = plugin.getServerDataFile().getdFile().toPath();
+ CompletableFuture initialized = nativeStartupDeferred && !initialization.isDone()
+ ? initialization : new CompletableFuture<>();
+ initialization = initialized; canonicalLoaded = false;
+ state.runtimeStorage(() -> {
+ try {
+ if (nativePermissionSnapshotFailure != null) throw nativePermissionSnapshotFailure;
+ boolean nativeReadFailed = plugin.getServerDataFile().isFailedToRead();
+ boolean sourceExists = Files.exists(file, LinkOption.NOFOLLOW_LINKS);
+ var loaded = sourceExists ? readSnapshot(file) : parse(baseline);
+ // Early native saves are deferred: even malformed native empty fallbacks
+ // still face the unchanged regular-file check and strict disk parser.
+ // A native-created empty source may now contain a drained predecessor's
+ // valid snapshot; existing nonempty native read failures remain fatal.
+ if (nativeReadFailed && (!sourceExists || !loaded.getKeys(false).isEmpty() && !nativeCreatedEmptySource))
+ throw new IOException("Native ServerData could not be read");
+ return loaded;
+ } catch (IOException | org.bukkit.configuration.InvalidConfigurationException error) { throw new CompletionException(error); }
+ }).thenCompose(loaded -> reconcileNativePermissions(state, nativePermissions, loaded).thenCompose(ignored ->
+ state.runtimeStorage(() -> {
+ try { synchronized (ServerData.this) {
+ var old = parse(baseline); var current = parse(getData().saveToString());
+ var previousValues = tree(old); var currentValues = tree(current);
+ Set keys = new HashSet<>(previousValues.keySet()); keys.addAll(currentValues.keySet());
+ // Changes made while predecessor/owner work drained remain authoritative.
+ for (String key : keys) if (!Objects.equals(previousValues.get(key), currentValues.get(key)))
+ loaded.set(key, currentValues.get(key));
+ if (nativePermissions != null) {
+ requireNativeLifecycle(state, nativePermissions);
+ loaded.set("TimedPermissions", currentValues.get("TimedPermissions"));
+ }
+ getData().loadFromString(loaded.saveToString()); canonicalLoaded = true;
+ return persistSnapshot(List.of());
+ } } catch (org.bukkit.configuration.InvalidConfigurationException failure) { throw new CompletionException(failure); }
+ }).thenCompose(future -> future)))
+ .whenComplete((ignored, error) -> {
+ if (error == null) initialized.complete(null);
+ else {
+ for (Throwable cause = error; cause != null; cause = cause.getCause())
+ if (UNSUPPORTED_LEGACY.equals(cause.getMessage())) { plugin.getLogger().severe(UNSUPPORTED_LEGACY); break; }
+ initialized.completeExceptionally(error);
+ }
+ });
+ return initialized;
+ }
+ private static org.bukkit.configuration.file.YamlConfiguration parse(String text) throws org.bukkit.configuration.InvalidConfigurationException {
+ var yaml = new org.bukkit.configuration.file.YamlConfiguration(); yaml.loadFromString(text); return yaml;
+ }
+ private static final String SNAPSHOT_HEADER = "# MCPerks ordered ServerData v1\n";
+ private static final String UNSUPPORTED_LEGACY = "Legacy ServerData indispensable payload (including still-active TimedPermissions) exceeds four MB; original file retained. Revoke or expire excess timed permissions before upgrading, or reduce other indispensable legacy payload.";
+ private record NativePermissionNodes(Map timed, Map pending, Set permanent) {
+ private static final NativePermissionNodes EMPTY = new NativePermissionNodes(Map.of(), Map.of(), Set.of());
+ private Object value(String node) {
+ if (permanent.contains(node)) return "permanent";
+ if (timed.containsKey(node)) return List.of("timed", timed.get(node));
+ return pending.containsKey(node) ? List.of("pending", pending.get(node)) : null;
+ }
+ private Set keys() {
+ Set keys = new HashSet<>(timed.keySet()); keys.addAll(pending.keySet()); keys.addAll(permanent); return keys;
+ }
+ }
+ /** Only these exact synchronized native snapshot methods are accessed, with no field fallback. */
+ private static Map nativeSnapshot(com.bencodez.advancedcore.api.permissions.PlayerPermissionHandler handle, String method) {
+ try {
+ var getter = com.bencodez.advancedcore.api.permissions.PlayerPermissionHandler.class.getDeclaredMethod(method);
+ if (getter.getReturnType() != Map.class || !java.lang.reflect.Modifier.isSynchronized(getter.getModifiers())
+ || !getter.trySetAccessible()) throw new IllegalStateException("Unsupported native permission snapshot API: " + method);
+ Object result = getter.invoke(handle);
+ if (!(result instanceof Map values)) throw new IllegalStateException("Invalid native permission snapshot: " + method);
+ Map copy = new HashMap<>();
+ for (var entry : values.entrySet()) {
+ if (!(entry.getKey() instanceof String key) || !(entry.getValue() instanceof Long value))
+ throw new IllegalStateException("Invalid native permission snapshot entry: " + method);
+ copy.put(key, value);
+ }
+ return Map.copyOf(copy);
+ } catch (ReflectiveOperationException failure) { throw new IllegalStateException("Native permission snapshot unavailable: " + method, failure); }
+ }
+ private static Map nativePermissionSnapshot(com.bencodez.advancedcore.api.permissions.PermissionHandler handler) {
+ Map values = new HashMap<>();
+ handler.getPermsToAdd().forEach((owner, handle) -> values.put(owner, nativeNodes(handle)));
+ handler.getPerms().forEach((owner, handle) -> values.put(owner, nativeNodes(handle)));
+ return Map.copyOf(values);
+ }
+ private static NativePermissionNodes nativePermissionOwnerSnapshot(com.bencodez.advancedcore.api.permissions.PermissionHandler handler, UUID owner) {
+ var handle = handler.getPerms().get(owner);
+ if (handle == null) handle = handler.getPermsToAdd().get(owner);
+ return handle == null ? NativePermissionNodes.EMPTY : nativeNodes(handle);
+ }
+ private static NativePermissionNodes nativeNodes(com.bencodez.advancedcore.api.permissions.PlayerPermissionHandler handle) {
+ synchronized (handle) {
+ return new NativePermissionNodes(nativeSnapshot(handle, "timedPermissionSnapshot"),
+ nativeSnapshot(handle, "offlinePermissionSnapshot"), Set.copyOf(handle.getPersistentPermissions()));
+ }
+ }
+ private static Map> permissionRows(FileConfiguration data) {
+ Map> result = new HashMap<>();
+ var section = data.getConfigurationSection("TimedPermissions");
+ if (section != null) for (String owner : section.getKeys(false)) {
+ Map nodes = new HashMap<>();
+ for (String row : section.getStringList(owner)) {
+ String[] fields = row.split(java.util.regex.Pattern.quote("%line%"));
+ if (fields.length != 2) continue;
+ try {
+ long expiry = Long.parseLong(fields[1]);
+ // Match the native grant API's supported multi-node separator.
+ for (String node : fields[0].split(java.util.regex.Pattern.quote("|")))
+ if (!node.isEmpty()) nodes.put(node, expiry);
+ } catch (NumberFormatException ignored) { }
+ }
+ result.put(UUID.fromString(owner), Map.copyOf(nodes));
+ }
+ return Map.copyOf(result);
+ }
+ private void requireNativeLifecycle(FeatureState state, com.bencodez.advancedcore.api.permissions.PermissionHandler handler) {
+ if (!plugin.isEnabled() || plugin.getFeatureState() != state || plugin.getPermissionHandler() != handler
+ || handler.getTimer().isShutdown()) throw new IllegalStateException("Native permission lifecycle retired during reconciliation");
+ }
+ private CompletableFuture reconcileNativePermissions(FeatureState state,
+ com.bencodez.advancedcore.api.permissions.PermissionHandler handler, org.bukkit.configuration.file.YamlConfiguration loaded) {
+ if (handler == null) return CompletableFuture.completedFuture(null);
+ Map> recovered = permissionRows(loaded);
+ CompletableFuture result = new CompletableFuture<>();
+ try { plugin.getBukkitScheduler().runTask(plugin, () -> {
+ try {
+ requireNativeLifecycle(state, handler);
+ var current = nativePermissionSnapshot(handler);
+ Set owners = new HashSet<>(recovered.keySet()); owners.addAll(nativePermissionSource.keySet());
+ owners.addAll(current.keySet());
+ // Check the effective indispensable rows before any native effects or row clearing.
+ var projection = parse(loaded.saveToString()); projection.set("TimedPermissions", null);
+ long now = System.currentTimeMillis();
+ for (UUID owner : owners) {
+ var base = nativePermissionBaseline.getOrDefault(owner, NativePermissionNodes.EMPTY);
+ var live = current.getOrDefault(owner, NativePermissionNodes.EMPTY);
+ var source = nativePermissionSource.getOrDefault(owner, Map.of());
+ var disk = recovered.getOrDefault(owner, Map.of());
+ Set nodes = new HashSet<>(source.keySet()); nodes.addAll(disk.keySet()); nodes.addAll(live.keys());
+ List rows = new ArrayList<>();
+ for (String node : nodes) {
+ Long expiry = disk.get(node);
+ if (!Objects.equals(base.value(node), live.value(node))) {
+ expiry = live.timed().get(node);
+ if (live.pending().containsKey(node)) expiry = live.pending().get(node) > 0 ? Math.addExact(now, live.pending().get(node)) : null;
+ } else if (Objects.equals(source.get(node), expiry) && live.value(node) == null) expiry = null;
+ if (expiry != null && expiry > now && !live.permanent().contains(node)) rows.add(node + "%line%" + expiry);
+ }
+ if (!rows.isEmpty()) projection.set("TimedPermissions." + owner, rows);
+ }
+ try { snapshotBytes(projection); } catch (IllegalStateException unsupported) { throw new IllegalStateException(UNSUPPORTED_LEGACY, unsupported); }
+ reconcileNativeOwner(owners.iterator(), recovered, state, handler, result);
+ } catch (Throwable failure) { result.completeExceptionally(failure); }
+ }); } catch (RuntimeException failure) { result.completeExceptionally(failure); }
+ return result;
+ }
+ /** At most one global/entity callback is admitted at a time; no callback collection is retained. */
+ private void reconcileNativeOwner(Iterator owners, Map> recovered, FeatureState state,
+ com.bencodez.advancedcore.api.permissions.PermissionHandler handler, CompletableFuture result) {
+ if (!owners.hasNext()) { result.complete(null); return; }
+ UUID owner = owners.next();
+ try { plugin.getBukkitScheduler().runTask(plugin, () -> {
+ try {
+ requireNativeLifecycle(state, handler);
+ var player = org.bukkit.Bukkit.getPlayer(owner);
+ Runnable restore = () -> {
+ try {
+ requireNativeLifecycle(state, handler);
+ if (player != null && (!player.isValid() || org.bukkit.Bukkit.getPlayer(owner) != player))
+ throw new IllegalStateException("Native permission player owner changed");
+ var live = nativePermissionOwnerSnapshot(handler, owner);
+ var base = nativePermissionBaseline.getOrDefault(owner, NativePermissionNodes.EMPTY);
+ var source = nativePermissionSource.getOrDefault(owner, Map.of());
+ var disk = recovered.getOrDefault(owner, Map.of());
+ Set nodes = new HashSet<>(source.keySet()); nodes.addAll(disk.keySet());
+ for (String node : nodes) {
+ if (!Objects.equals(base.value(node), live.value(node)) || live.permanent().contains(node)) continue;
+ // Already-restored rows include subsequently expired/revoked initial nodes.
+ if (Objects.equals(source.get(node), disk.get(node))) continue;
+ if (player == null && (handler.getPerms().containsKey(owner) || org.bukkit.Bukkit.getPlayer(owner) != null))
+ throw new IllegalStateException("Native permission attached owner unavailable");
+ Long expiry = disk.get(node); long remaining = expiry == null ? 0 : expiry - System.currentTimeMillis();
+ if (remaining <= 0) handler.removePermission(owner, null, node);
+ else handler.addPermission(owner, node, com.bencodez.simpleapi.time.ParsedDuration.ofMillis(remaining));
+ }
+ reconcileNativeOwner(owners, recovered, state, handler, result);
+ } catch (Throwable failure) { result.completeExceptionally(failure); }
+ };
+ if (player == null) restore.run();
+ else com.bencodez.mcperks.scheduling.OwnerTasks.run(plugin, player, restore,
+ () -> result.completeExceptionally(new IllegalStateException("Native permission player owner retired")));
+ } catch (Throwable failure) { result.completeExceptionally(failure); }
+ }); } catch (RuntimeException failure) { result.completeExceptionally(failure); }
+ }
+ private static org.bukkit.configuration.file.YamlConfiguration readSnapshot(Path file)
+ throws IOException, org.bukkit.configuration.InvalidConfigurationException {
+ if (!Files.isRegularFile(file, LinkOption.NOFOLLOW_LINKS)) throw new IOException("Invalid ServerData file");
+ byte[] header = SNAPSHOT_HEADER.getBytes(StandardCharsets.UTF_8);
+ boolean ordered;
+ try (var input = Files.newInputStream(file)) { ordered = Arrays.equals(header, input.readNBytes(header.length)); }
+ if (ordered) {
+ // Count actual bytes again while reading, including a concurrent file growth.
+ try (var input = Files.newInputStream(file)) {
+ byte[] bytes = input.readNBytes(MAX_SNAPSHOT_BYTES + 1);
+ if (bytes.length > MAX_SNAPSHOT_BYTES) throw new IOException("Ordered ServerData exceeds four MB");
+ return parse(new String(bytes, StandardCharsets.UTF_8));
+ }
+ }
+ // A native legacy file has already been parsed by AdvancedCore. Admit that
+ // old format once, after predecessor drain, without inventing a larger legacy
+ // size ceiling. Reconciliation and advisory-history pruning must yield the
+ // bounded new format; indispensable oversized payloads leave this file intact.
+ var legacy = new org.bukkit.configuration.file.YamlConfiguration();
+ try (var reader = Files.newBufferedReader(file, StandardCharsets.UTF_8)) { legacy.load(reader); }
+ return legacy;
+ }
+ private static Map tree(org.bukkit.configuration.ConfigurationSection section) {
+ Map values = new HashMap<>();
+ for (String key : section.getKeys(false)) { Object value = section.get(key);
+ values.put(key, value instanceof org.bukkit.configuration.ConfigurationSection child ? tree(child) : value); }
+ return values;
+ }
+ public synchronized void addPerkHistory(String value) {
+ String path = "PerkHistory." + plugin.getTimeChecker().getTime().getMonth().toString();
+ var history = new ArrayList<>(getData().getStringList(path)); history.add(value);
+ // Bound each retained month's activation history, including when the optional file log is enabled.
+ getData().set(path, history.subList(Math.max(0, history.size() - 256), history.size()));
+ saveData();
+ }
+ public FileConfiguration getData() { return plugin.getServerDataFile().getData(); }
+ public synchronized long getPerkExperation(Perk perk) { return getData().getLong("Experation." + perk.getPerk()); }
+ public synchronized void setServerCooldown(String perk, long time) { getData().set(perk + ".CoolDown", time); }
+ public synchronized long getServerCooldown(String perk) { return getData().getLong(perk + ".CoolDown", 0); }
+ /** The caller drains the feature worker before reloading the legacy file. */
+ public synchronized void reloadData() { plugin.getServerDataFile().reloadData(); }
+ synchronized void reloadFrom(com.bencodez.advancedcore.data.ServerData file) {
+ // A new calendar/perk save may arrive after the reload drain but before its owner callback.
+ // Keep its authoritative live YAML rather than replacing it with the earlier disk version.
+ if (pendingSnapshots.get() == 0) file.reloadData();
+ }
+ public synchronized void saveData() {
+ if (activationWrites.get() != null) return;
+ if (!canonicalLoaded) {
+ if (initialization.isCompletedExceptionally()) plugin.getLogger().warning("ServerData persistence unavailable after startup reconciliation failure; original file retained");
+ return;
+ }
+ if (plugin.getFeatureState() == null) { plugin.getServerDataFile().saveData(); return; }
+ // Native final save omits still-offline relative reservations from its timed-only snapshot.
+ // Preserve those native-owned rows (and remove revoked ones) after its timer is retired.
+ var handler = plugin.getPermissionHandler();
+ if (handler != null && handler == observedNativeHandler && handler.getTimer().isShutdown()) {
+ try {
+ var snapshot = nativePermissionSnapshot(handler); long now = System.currentTimeMillis();
+ getData().set("TimedPermissions", null);
+ for (var owner : snapshot.entrySet()) {
+ Map timed = new HashMap<>(owner.getValue().timed());
+ owner.getValue().pending().forEach((node, duration) -> {
+ if (duration > 0) timed.put(node, Math.addExact(now, duration));
+ });
+ List rows = new ArrayList<>();
+ timed.forEach((node, expiry) -> { if (expiry > now) rows.add(node + "%line%" + expiry); });
+ if (!rows.isEmpty()) getData().set("TimedPermissions." + owner.getKey(), rows);
+ }
+ } catch (RuntimeException failure) {
+ plugin.getLogger().warning("ServerData persistence failed: native final permission snapshot unavailable: " + failure.getMessage()); return;
+ }
+ }
+ persistSnapshot(List.of()).exceptionally(error -> { plugin.getLogger().warning("ServerData persistence failed: " + error.getMessage()); return null; });
+ }
+ /** Gameplay stays on the caller's owner. No mutable YAML reaches the worker. */
+ public synchronized CompletableFuture confirmedActivation(Runnable gameplay) {
+ if (!isReady()) return CompletableFuture.failedFuture(new IllegalStateException("ServerData initialization unavailable"));
+ if (activationWrites.get() != null) throw new IllegalStateException("Nested activation persistence");
+ var writes = new ArrayList(); activationWrites.set(writes);
+ try { gameplay.run(); return persistSnapshot(List.copyOf(writes)); }
+ catch (Throwable error) { return CompletableFuture.failedFuture(error); }
+ finally { activationWrites.remove(); }
+ }
+ /** The callback must contain only an already captured log message and its file writer. */
+ public synchronized void activationLog(Runnable write) {
+ var batch = activationWrites.get();
+ if (batch != null) batch.add(write);
+ else plugin.getFeatureState().runtimeStorage(() -> { write.run(); return null; });
+ }
+ private static final int MAX_SNAPSHOT_BYTES = 4_000_000;
+ private static final int MAX_HISTORY_BYTES = 1_000_000;
+ private static byte[] snapshotBytes(FileConfiguration data) {
+ trimHistory(data, MAX_HISTORY_BYTES);
+ byte[] snapshot = encodedSnapshot(data);
+ if (snapshot.length > MAX_SNAPSHOT_BYTES && data.isConfigurationSection("PerkHistory")) {
+ // History is advisory. Reclaim it before rejecting an authoritative timer/calendar save.
+ var history = new org.bukkit.configuration.file.YamlConfiguration();
+ history.set("PerkHistory", tree(data.getConfigurationSection("PerkHistory")));
+ int historyBytes = history.saveToString().getBytes(StandardCharsets.UTF_8).length;
+ trimHistory(data, Math.max(0, historyBytes - (snapshot.length - MAX_SNAPSHOT_BYTES)));
+ snapshot = encodedSnapshot(data);
+ }
+ if (snapshot.length > MAX_SNAPSHOT_BYTES) throw new IllegalStateException("ServerData snapshot exceeds four MB");
+ return snapshot;
+ }
+ private static byte[] encodedSnapshot(FileConfiguration data) {
+ return (SNAPSHOT_HEADER + data.saveToString()).getBytes(StandardCharsets.UTF_8);
+ }
+ /** Keep complete recent entries in the existing monthly lists, using actual encoded YAML bytes. */
+ private static void trimHistory(FileConfiguration data, int budget) {
+ var section = data.getConfigurationSection("PerkHistory");
+ if (section == null) return;
+ var retained = new org.bukkit.configuration.file.YamlConfiguration();
+ var months = new ArrayList<>(section.getKeys(false));
+ if (months.isEmpty()) { data.set("PerkHistory", null); return; }
+ for (String month : months) {
+ var entries = section.getStringList(month);
+ retained.set("PerkHistory." + month, new ArrayList<>(entries.subList(Math.max(0, entries.size() - 256), entries.size())));
+ }
+ if (retained.saveToString().getBytes(StandardCharsets.UTF_8).length <= budget) {
+ data.createSection("PerkHistory", tree(retained.getConfigurationSection("PerkHistory"))); return;
+ }
+ retained = new org.bukkit.configuration.file.YamlConfiguration();
+ Collections.reverse(months);
+ // Prefer the last retained month, then fit suffixes of preceding months in the aggregate budget.
+ for (String month : months) {
+ var entries = section.getStringList(month);
+ String path = "PerkHistory." + month;
+ int low = 0, high = Math.min(256, entries.size());
+ while (low < high) {
+ int count = (low + high + 1) / 2;
+ retained.set(path, entries.subList(entries.size() - count, entries.size()));
+ if (retained.saveToString().getBytes(StandardCharsets.UTF_8).length <= budget) low = count;
+ else high = count - 1;
+ }
+ retained.set(path, low == 0 ? null : new ArrayList<>(entries.subList(entries.size() - low, entries.size())));
+ }
+ var history = retained.getConfigurationSection("PerkHistory");
+ if (history == null || history.getKeys(false).isEmpty()) data.set("PerkHistory", null);
+ else data.createSection("PerkHistory", tree(history));
+ }
+ private CompletableFuture persistSnapshot(List writes) {
+ // Serialization is confined to the mutation owner; publication alone runs on storage.
+ try { return publishSnapshot(snapshotBytes(getData()), writes, pendingCalendar, calendarEdits.clone(), null); }
+ catch (RuntimeException error) { return CompletableFuture.failedFuture(error); }
+ }
+ private CompletableFuture publishSnapshot(byte[] snapshot, List writes, CalendarUpdate overlay, long[] edits, CalendarUpdate commit) {
+ Path file = plugin.getServerDataFile().getdFile().toPath();
+ pendingSnapshots.incrementAndGet();
+ return plugin.getFeatureState().runtimeStorage(() -> {
+ Path staged = null;
+ try {
+ byte[] confirmed = snapshot;
+ // This turn follows the calendar publication. Rebase only its confirmed fields in
+ // a private worker YAML, never the live cache; failed transitions contribute nothing.
+ // Per-field edit fences preserve even a later explicit write of the same old value.
+ if (overlay != null && overlay.published) {
+ var copy = parse(new String(snapshot, StandardCharsets.UTF_8)); overlay.apply(copy, edits);
+ confirmed = snapshotBytes(copy);
+ }
+ Files.createDirectories(file.toAbsolutePath().getParent());
+ if (Files.isSymbolicLink(file)) throw new IOException("ServerData is a symlink");
+ staged = Files.createTempFile(file.toAbsolutePath().getParent(), ".server-data-", ".tmp");
+ Files.write(staged, confirmed); publisher.publish(staged, file);
+ if (commit != null) synchronized (ServerData.this) {
+ commit.apply(getData(), calendarEdits); commit.published = true;
+ if (pendingCalendar == commit) pendingCalendar = null;
+ }
+ for (Runnable write : writes) write.run();
+ return null;
+ } catch (IOException | org.bukkit.configuration.InvalidConfigurationException error) { throw new CompletionException(error); }
+ finally { if (staged != null) try { Files.deleteIfExists(staged); } catch (IOException ignored) {} }
+ }).whenComplete((ignored, error) -> {
+ pendingSnapshots.decrementAndGet();
+ if (commit != null) synchronized (ServerData.this) { if (pendingCalendar == commit) pendingCalendar = null; }
+ });
+ }
+ public synchronized void setPerkExperation(Perk perk, long time) {
+ getData().set("Experation." + perk.getPerk(), time); saveData();
+ }
+ public synchronized void clearOfflinePerks() { getData().set("OfflinePerk", null); }
+ public synchronized void saveOfflinePerk(Perk perk) {
+ getData().set("OfflinePerk." + perk.getActivater().getUUID() + "." + perk.getPerk() + ".Experiaton",
+ perk.isLastForever() ? -1 : perk.getExperation(perk.getActivater()));
+ }
}
diff --git a/MCPerks/src/main/java/com/bencodez/mcperks/effects/AutoPlant.java b/MCPerks/src/main/java/com/bencodez/mcperks/effects/AutoPlant.java
index a9a35e7..57b7119 100644
--- a/MCPerks/src/main/java/com/bencodez/mcperks/effects/AutoPlant.java
+++ b/MCPerks/src/main/java/com/bencodez/mcperks/effects/AutoPlant.java
@@ -29,28 +29,8 @@ public AutoPlant(MCPerksMain plugin, Player player, Block block, Perk perk, Bloc
if (!isFarmable(block)) {
return;
}
- ItemStack itemInHand = player.getInventory().getItemInMainHand();
- if (!perk.getWhitelistedTools().isEmpty()) {
- if (!perk.getWhitelistedTools().contains(itemInHand.getType())) {
- return;
- }
- }
- if (perk.getRequiredEnchants().size() > 0) {
- for (Entry enchants : perk.getRequiredEnchants().entrySet()) {
- if (itemInHand.getEnchantmentLevel(
- Enchantment.getByKey(NamespacedKey.minecraft(enchants.getKey()))) != enchants.getValue()) {
- return;
- }
- }
- }
- if (!perk.getWhitelistedBlocks().isEmpty()) {
- if (!perk.getWhitelistedBlocks().contains(block.getType())) {
- return;
- }
- }
- if (perk.getBlacklistedBlocks().contains(block.getType())) {
- return;
- }
+ ItemStack itemInHand = player.getInventory().getItemInMainHand();
+ if (!allows(perk, itemInHand, block.getType())) return;
Material seedBlockType = getSeedBlockType(block.getType());
Material seedItemType = getSeedItemType(block.getType());
@@ -74,6 +54,27 @@ public AutoPlant(MCPerksMain plugin, Player player, Block block, Perk perk, Bloc
PlayerManager.getInstance().damageItemInHand(player, 1);
}
}
+
+ public static Material seedFor(Material crop) {
+ return switch (crop) {
+ case WHEAT -> Material.WHEAT_SEEDS;
+ case POTATOES -> Material.POTATO;
+ case CARROTS -> Material.CARROT;
+ case BEETROOTS -> Material.BEETROOT_SEEDS;
+ case NETHER_WART -> Material.NETHER_WART;
+ default -> null;
+ };
+ }
+ @SuppressWarnings("deprecation")
+ public static boolean allows(Perk perk, ItemStack tool, Material crop) {
+ if (!perk.getWhitelistedTools().isEmpty() && !perk.getWhitelistedTools().contains(tool.getType())) return false;
+ for (Entry required : perk.getRequiredEnchants().entrySet()) {
+ Enchantment enchantment = Enchantment.getByKey(NamespacedKey.minecraft(required.getKey()));
+ if (enchantment == null || tool.getEnchantmentLevel(enchantment) != required.getValue()) return false;
+ }
+ return (perk.getWhitelistedBlocks().isEmpty() || perk.getWhitelistedBlocks().contains(crop))
+ && !perk.getBlacklistedBlocks().contains(crop);
+ }
private void plant(MCPerksMain plugin, Player player, Block block, Material seedType) {
Bukkit.getScheduler().runTaskLater(plugin, new Runnable() {
diff --git a/MCPerks/src/main/java/com/bencodez/mcperks/listeners/EffectBatch.java b/MCPerks/src/main/java/com/bencodez/mcperks/listeners/EffectBatch.java
new file mode 100644
index 0000000..b931ae0
--- /dev/null
+++ b/MCPerks/src/main/java/com/bencodez/mcperks/listeners/EffectBatch.java
@@ -0,0 +1,18 @@
+package com.bencodez.mcperks.listeners;
+import java.util.List;
+/** Production execution seam: each true result is one successful gameplay unit. */
+public final class EffectBatch {
+ @FunctionalInterface public interface Unit { boolean apply() throws Exception; }
+ public record Result(int successful, int unused) {}
+ private EffectBatch() {}
+ public static Result execute(List units, int budget) {
+ if (budget < 0 || budget > units.size()) throw new IllegalArgumentException("Invalid budget");
+ int successful = 0;
+ for (Unit unit : units) {
+ if (successful == budget) break;
+ try { if (unit.apply()) successful++; }
+ catch (Exception uncertain) { return new Result(successful, budget - successful - 1); }
+ }
+ return new Result(successful, budget - successful);
+ }
+}
diff --git a/MCPerks/src/main/java/com/bencodez/mcperks/listeners/EffectListeners.java b/MCPerks/src/main/java/com/bencodez/mcperks/listeners/EffectListeners.java
index c0fcdf5..ab84540 100644
--- a/MCPerks/src/main/java/com/bencodez/mcperks/listeners/EffectListeners.java
+++ b/MCPerks/src/main/java/com/bencodez/mcperks/listeners/EffectListeners.java
@@ -153,7 +153,8 @@ public void onBlockDropItem(BlockDropItemEvent event) {
if (plugin.getPerkHandler().effectActive(Effect.InstantSmelt, player.getUniqueId().toString(),
player.getWorld().getName())) {
for (Perk active : plugin.getPerkHandler().getActivePerks()) {
- if (active.getEffects().contains(Effect.InstantSmelt)) {
+ if (active.getEffects().contains(Effect.InstantSmelt) && plugin.getPerkHandler().effectAllowed(active,
+ Effect.InstantSmelt, player.getUniqueId().toString(), player.getWorld().getName())) {
ArrayList- toRemove = new ArrayList
- ();
for (Item item : event.getItems()) {
ItemStack smeltedItem = null;
@@ -213,6 +214,7 @@ private int getExperienceAmount(FurnaceRecipe recipe, int stackAmount) {
@EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
public void onBlockBreak(BlockBreakEvent event) {
Player player = event.getPlayer();
+ boolean nativeBreak = plugin.getUsageEffects() != null && plugin.getUsageEffects().isNativeBreak(player.getUniqueId());
if (!event.isCancelled()) {
for (BlockBreakEvent e : plugin.getEffectHandler().getBlockBreakEvents()) {
if (e.equals(event)) {
@@ -224,7 +226,7 @@ public void onBlockBreak(BlockBreakEvent event) {
Block blockBroken;
Collection var5;
- if (Tag.LOGS.isTagged(event.getBlock().getType())) {
+ if (!nativeBreak && Tag.LOGS.isTagged(event.getBlock().getType())) {
if (plugin.getPerkHandler().effectActive(Effect.TreeHarvest, player.getUniqueId().toString(),
player.getWorld().getName())) {
boolean found = false;
@@ -236,7 +238,8 @@ public void onBlockBreak(BlockBreakEvent event) {
}
}
- if (e != null && !found) {
+ if (e != null && !found && plugin.getPerkHandler().effectAllowed(active,
+ e, player.getUniqueId().toString(), player.getWorld().getName())) {
new TreeHarvestEffect(plugin, player, event.getBlock(), active);
found = true;
}
@@ -245,7 +248,7 @@ public void onBlockBreak(BlockBreakEvent event) {
}
}
- if (plugin.getPerkHandler().effectActive(Effect.AutoPlant, player.getUniqueId().toString(),
+ if (!nativeBreak && plugin.getPerkHandler().effectActive(Effect.AutoPlant, player.getUniqueId().toString(),
player.getWorld().getName())) {
boolean found = false;
for (Perk active : plugin.getPerkHandler().getActivePerks()) {
@@ -256,7 +259,8 @@ public void onBlockBreak(BlockBreakEvent event) {
}
}
- if (e != null && !found) {
+ if (e != null && !found && plugin.getPerkHandler().effectAllowed(active,
+ e, player.getUniqueId().toString(), player.getWorld().getName())) {
new AutoPlant(plugin, player, event.getBlock(), active, event);
found = true;
@@ -268,8 +272,9 @@ public void onBlockBreak(BlockBreakEvent event) {
if (plugin.getPerkHandler().effectActive(Effect.Fortune, player.getUniqueId().toString(),
player.getWorld().getName())) {
- for (Perk active : plugin.getPerkHandler().getActivePerks()) {
- if (active.getEffects().contains(Effect.Fortune)) {
+ for (Perk active : plugin.getPerkHandler().getActivePerks()) {
+ if (active.getEffects().contains(Effect.Fortune) && plugin.getPerkHandler().effectAllowed(active,
+ Effect.Fortune, player.getUniqueId().toString(), player.getWorld().getName())) {
FortuneEffect fe = new FortuneEffect(active);
blockBroken = event.getBlock();
@@ -289,8 +294,9 @@ public void onBlockBreak(BlockBreakEvent event) {
if (plugin.getPerkHandler().effectActive(Effect.Farmer, player.getUniqueId().toString(),
player.getWorld().getName())) {
- for (Perk active : plugin.getPerkHandler().getActivePerks()) {
- if (active.getEffects().contains(Effect.Farmer)) {
+ for (Perk active : plugin.getPerkHandler().getActivePerks()) {
+ if (active.getEffects().contains(Effect.Farmer) && plugin.getPerkHandler().effectAllowed(active,
+ Effect.Farmer, player.getUniqueId().toString(), player.getWorld().getName())) {
FarmerEffect fe1 = new FarmerEffect(active);
blockBroken = event.getBlock();
if (fe1.isFarmable(blockBroken)) {
@@ -305,7 +311,7 @@ public void onBlockBreak(BlockBreakEvent event) {
}
}
- if (plugin.getPerkHandler().effectActive(Effect.IncreaseMiningArea, player.getUniqueId().toString(),
+ if (!nativeBreak && plugin.getPerkHandler().effectActive(Effect.IncreaseMiningArea, player.getUniqueId().toString(),
player.getWorld().getName())) {
boolean found = false;
for (Perk active : plugin.getPerkHandler().getActivePerks()) {
@@ -316,7 +322,8 @@ public void onBlockBreak(BlockBreakEvent event) {
}
}
- if (e != null && !found) {
+ if (e != null && !found && plugin.getPerkHandler().effectAllowed(active,
+ e, player.getUniqueId().toString(), player.getWorld().getName())) {
blockBroken = event.getBlock();
BlockFace f = PlayerUtils.yawToFace(player.getLocation().getYaw(), false);
new IncreaseMiningArea(plugin, event, active, player, e.getModifier(), f);
@@ -353,7 +360,7 @@ public void onDisconnect(PlayerQuitEvent event) {
if (perk.getBossBar() != null) {
perk.getBossBar().removePlayer(player);
}
- if (plugin.getConfigFile().getDeactivateOnLogout()) {
+ if (plugin.getConfigFile().getDeactivateOnLogout() && (plugin.getBankedPerks() == null || !plugin.getBankedPerks().attached(perk))) {
if (perk.getActivater().getUUID().equals(player.getUniqueId().toString())) {
perk.deactivatePerk(perk.getActivater());
}
@@ -364,12 +371,19 @@ public void onDisconnect(PlayerQuitEvent event) {
}
+ private String killerIdentity(EntityDeathEvent event) {
+ org.bukkit.entity.Entity killer = plugin.getVersionHandle().hasDamageSourceMethod()
+ ? plugin.getVersionHandle().getCausingEntity(event) : event.getEntity().getKiller();
+ return killer instanceof Player ? killer.getUniqueId().toString() : null;
+ }
+
@SuppressWarnings("unchecked")
@EventHandler(ignoreCancelled = true)
public void onEntityDeath(EntityDeathEvent event) {
if (!(event.getEntity() instanceof Player) && !event.getEntityType().equals(EntityType.ARMOR_STAND)) {
for (Perk active : plugin.getPerkHandler().getActivePerks()) {
- if (active.getEffects().contains(Effect.IncreaseMobDrops)) {
+ if (active.getEffects().contains(Effect.IncreaseMobDrops) && plugin.getPerkHandler().effectAllowed(active, Effect.IncreaseMobDrops,
+ killerIdentity(event), event.getEntity().getWorld().getName())) {
boolean giveEffects = false;
if (active.getPerkType().equals(PerkSystemType.ALL)) {
giveEffects = true;
@@ -402,7 +416,8 @@ public void onEntityDeath(EntityDeathEvent event) {
}
for (Perk active : plugin.getPerkHandler().getActivePerks()) {
- if (active.getEffects().contains(Effect.DoubleExperience)) {
+ if (active.getEffects().contains(Effect.DoubleExperience) && plugin.getPerkHandler().effectAllowed(active, Effect.DoubleExperience,
+ killerIdentity(event), event.getEntity().getWorld().getName())) {
boolean giveEffects = false;
if (active.getPerkType().equals(PerkSystemType.ALL)) {
giveEffects = true;
@@ -428,7 +443,8 @@ public void onEntityDeath(EntityDeathEvent event) {
}
for (Perk active : plugin.getPerkHandler().getActivePerks()) {
- if (active.getEffects().contains(Effect.HeadDropper)) {
+ if (active.getEffects().contains(Effect.HeadDropper) && plugin.getPerkHandler().effectAllowed(active, Effect.HeadDropper,
+ killerIdentity(event), event.getEntity().getWorld().getName())) {
if (!active.getBlackedListedMobs().contains(event.getEntity().getType())) {
boolean giveEffects = false;
if (active.getPerkType().equals(PerkSystemType.ALL)) {
@@ -687,7 +703,8 @@ public void onPlayerMove(PlayerMoveEvent event) {
}
}
- if (e != null) {
+ if (e != null && plugin.getPerkHandler().effectAllowed(active, Effect.BoneMealAura,
+ player.getUniqueId().toString(), player.getWorld().getName())) {
new BoneMealAura().checkPlants(player, event.getTo(), (int) e.getModifier());
}
diff --git a/MCPerks/src/main/java/com/bencodez/mcperks/listeners/RefillPlan.java b/MCPerks/src/main/java/com/bencodez/mcperks/listeners/RefillPlan.java
new file mode 100644
index 0000000..44d4930
--- /dev/null
+++ b/MCPerks/src/main/java/com/bencodez/mcperks/listeners/RefillPlan.java
@@ -0,0 +1,37 @@
+package com.bencodez.mcperks.listeners;
+import org.bukkit.Material;
+import org.bukkit.inventory.EquipmentSlot;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.inventory.PlayerInventory;
+/** Captures and revalidates the exact hand, selected slot and matching source stack. */
+public final class RefillPlan implements EffectBatch.Unit {
+ private final PlayerInventory inventory;
+ private final int destination, source, selected;
+ private final EquipmentSlot hand;
+ private final ItemStack sourceBefore;
+ private RefillPlan(PlayerInventory inventory, EquipmentSlot hand, int source) {
+ this.inventory = inventory; this.hand = hand; this.source = source;
+ selected = inventory.getHeldItemSlot(); destination = hand == EquipmentSlot.OFF_HAND ? 40 : selected;
+ sourceBefore = inventory.getItem(source).clone();
+ }
+ public static RefillPlan capture(PlayerInventory inventory, EquipmentSlot hand, ItemStack placed) {
+ if (placed == null || placed.getAmount() != 1) return null;
+ int destination = hand == EquipmentSlot.OFF_HAND ? 40 : inventory.getHeldItemSlot();
+ for (int slot = 0; slot < 36; slot++) {
+ ItemStack item = inventory.getItem(slot);
+ if (slot != destination && item != null && item.getAmount() > 0 && item.isSimilar(placed)) return new RefillPlan(inventory, hand, slot);
+ }
+ return null;
+ }
+ @Override public boolean apply() {
+ if (hand == EquipmentSlot.HAND && inventory.getHeldItemSlot() != selected) return false;
+ ItemStack held = inventory.getItem(destination), item = inventory.getItem(source);
+ if (held != null && held.getType() != Material.AIR && held.getAmount() > 0) return false;
+ if (!sourceBefore.equals(item)) return false;
+ ItemStack replacement = item.clone(); replacement.setAmount(1);
+ ItemStack remainder = item.clone(); remainder.setAmount(remainder.getAmount() - 1);
+ inventory.setItem(source, remainder.getAmount() == 0 ? null : remainder);
+ inventory.setItem(destination, replacement);
+ return true;
+ }
+}
diff --git a/MCPerks/src/main/java/com/bencodez/mcperks/listeners/UsageEffectListener.java b/MCPerks/src/main/java/com/bencodez/mcperks/listeners/UsageEffectListener.java
new file mode 100644
index 0000000..3423a57
--- /dev/null
+++ b/MCPerks/src/main/java/com/bencodez/mcperks/listeners/UsageEffectListener.java
@@ -0,0 +1,299 @@
+package com.bencodez.mcperks.listeners;
+
+import java.lang.reflect.Method;
+import java.util.*;
+import java.util.concurrent.*;
+import java.util.concurrent.atomic.AtomicBoolean;
+import org.bukkit.*;
+import org.bukkit.block.*;
+import org.bukkit.block.data.Ageable;
+import org.bukkit.block.data.BlockData;
+import org.bukkit.entity.Player;
+import org.bukkit.event.*;
+import org.bukkit.event.block.*;
+import org.bukkit.event.player.*;
+import org.bukkit.inventory.*;
+import com.bencodez.mcperks.MCPerksMain;
+import com.bencodez.mcperks.scheduling.OwnerTasks;
+import com.bencodez.mcperks.data.LocalStatistics.Skip;
+import com.bencodez.mcperks.effects.AutoPlant;
+import com.bencodez.mcperks.perk.*;
+import com.bencodez.mcperks.perk.Effect;
+import com.bencodez.mcperks.userapi.UsageCharges;
+import com.bencodez.mcperks.userapi.UsageCharges.Kind;
+
+/** New automation effects. World/inventory access always runs on the player's owner. */
+public final class UsageEffectListener implements Listener {
+ private final MCPerksMain plugin;
+ private final UsageCharges ledger;
+ private final Set nativeBreaks = ConcurrentHashMap.newKeySet();
+ private final Map pending = new ConcurrentHashMap<>();
+ private static final class Batch {
+ final AtomicBoolean invoked = new AtomicBoolean();
+ final CompletableFuture settled = new CompletableFuture<>();
+ volatile Runnable cancel = () -> invoked.compareAndSet(false, true);
+ }
+ public record RecentSkip(Effect effect, Skip reason, long time) {}
+ private final Map recentSkips = new ConcurrentHashMap<>();
+ public RecentSkip recentSkip(UUID owner) { return recentSkips.get(owner); }
+ private void skip(Player player, Effect effect, Skip reason) {
+ noteSkip(player.getUniqueId(), effect, reason);
+ }
+ private synchronized void noteSkip(UUID owner, Effect effect, Skip reason) {
+ if (recentSkips.size() < 256 || recentSkips.containsKey(owner)) recentSkips.put(owner, new RecentSkip(effect, reason, System.currentTimeMillis()));
+ plugin.getLocalStatistics().skip(reason);
+ }
+ private volatile int generation;
+ private volatile boolean retired;
+ private final Method ownedRegion;
+ public UsageEffectListener(MCPerksMain plugin) {
+ this.plugin = plugin;
+ this.ledger = plugin.getUsageCharges();
+ Method method = null;
+ try { method = Bukkit.class.getMethod("isOwnedByCurrentRegion", Location.class); } catch (ReflectiveOperationException ignored) {}
+ ownedRegion = method;
+ }
+ public void invalidate() { generation++; }
+ public synchronized CompletableFuture retire() {
+ retired = true; invalidate();
+ List batches = List.copyOf(pending.values());
+ batches.forEach(batch -> batch.cancel.run());
+ return CompletableFuture.allOf(batches.stream().map(batch -> batch.settled).toArray(CompletableFuture[]::new));
+ }
+ /** Seal admissions, release callbacks proved unused, then close their original ledger without owner waits. */
+ public CompletableFuture retireAndClose() {
+ return retire().whenComplete((ignored, error) -> ledger.close());
+ }
+ public boolean isNativeBreak(UUID player) { return nativeBreaks.contains(player); }
+ @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true) public void sneak(PlayerToggleSneakEvent event) {
+ if (event.isCancelled()) return;
+ Player player = event.getPlayer();
+ OwnerTasks.run(plugin, player, () -> plugin.getPerkHandler().setPrecisionSneaking(player.getUniqueId(), player.isSneaking()),
+ () -> plugin.getPerkHandler().setPrecisionSneaking(player.getUniqueId(), false));
+ }
+ @EventHandler public void join(PlayerJoinEvent event) { plugin.getQueuePlanner().check(); }
+ @EventHandler public void quit(PlayerQuitEvent event) { plugin.getPerkHandler().setPrecisionSneaking(event.getPlayer().getUniqueId(), false); recentSkips.remove(event.getPlayer().getUniqueId()); }
+
+ private Perk eligible(Player player, Effect effect) {
+ return eligible(player, effect, candidate -> true);
+ }
+ private Perk eligible(Player player, Effect effect, java.util.function.Predicate context) {
+ if (retired || !plugin.isEnabled()) return null;
+ plugin.getPerkHandler().setPrecisionSneaking(player.getUniqueId(), player.isSneaking());
+ var decision = plugin.getPerkHandler().effectDecision(effect, player.getUniqueId().toString(), player.getWorld().getName());
+ if (decision != PerkHandler.Decision.ACTIVE) {
+ skip(player, effect, switch (decision) {
+ case OUTSIDE_AUDIENCE -> Skip.AUDIENCE; case DISABLED_WORLD -> Skip.WORLD; case PRECISION_SUPPRESSED -> Skip.PRECISION;
+ case BANKED_PAUSED -> Skip.BANKED; default -> Skip.INACTIVE;
+ }); return null;
+ }
+ Perk chargedCandidate = null;
+ for (Perk perk : plugin.getPerkHandler().getActivePerks()) {
+ if (!perk.getEffects().contains(effect) || !perk.getEffectedPlayers().contains(player.getUniqueId().toString())
+ || !perk.isNotInDisabledWorld(player.getWorld().getName())
+ || (plugin.getBankedPerks() != null && !plugin.getBankedPerks().available(perk)) || !context.test(perk)) continue;
+ if (charged(perk) && perk.getPerkType() != PerkSystemType.PLAYER) { skip(player, effect, Skip.SHARED_CHARGES); continue; } // No stable shared charge owner.
+ // Prefer a matching unlimited grant. Its gameplay does not depend on optional
+ // charge storage, and a reservation on another grant cannot hide it later.
+ if (!charged(perk)) return perk;
+ if (chargedCandidate == null) chargedCandidate = perk;
+ }
+ return chargedCandidate;
+ }
+ private boolean charged(Perk perk) {
+ return perk.getInteractionOptions().charged();
+ }
+ private boolean owns(Player player, Block block) {
+ if (!player.getWorld().equals(block.getWorld()) || !block.getWorld().isChunkLoaded(block.getX() >> 4, block.getZ() >> 4)) return false;
+ if (!plugin.getBukkitScheduler().getFoliaLib().isFolia()) return true;
+ if (ownedRegion == null) return false;
+ try { return Boolean.TRUE.equals(ownedRegion.invoke(null, block.getLocation())); }
+ catch (ReflectiveOperationException e) { return false; }
+ }
+ private boolean matchesTool(Player player, ItemStack expected) { return player.getInventory().getItemInMainHand().equals(expected); }
+ private void later(Player player, Runnable action) {
+ int version = generation;
+ if (!retired) OwnerTasks.run(plugin, player, () -> {
+ if (!retired && version == generation && plugin.isEnabled()) action.run();
+ }, () -> {});
+ }
+
+ @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
+ public void refill(BlockPlaceEvent event) {
+ Player player = event.getPlayer(); Perk perk = eligible(player, Effect.AutoBlockRefill);
+ if (perk == null || player.getGameMode() != GameMode.SURVIVAL || event.getItemInHand().getAmount() != 1) return;
+ RefillPlan plan = RefillPlan.capture(player.getInventory(), event.getHand(), event.getItemInHand());
+ if (plan == null) return;
+ later(player, () -> run(player, perk, Kind.AutoBlockRefill, List.of(() -> {
+ if (event.isCancelled() || eligible(player, Effect.AutoBlockRefill, candidate -> candidate == perk) != perk || player.getGameMode() != GameMode.SURVIVAL) return false;
+ boolean applied = plan.apply(); if (!applied) skip(player, Effect.AutoBlockRefill, Skip.INVENTORY_CHANGED); return applied;
+ })));
+ }
+
+ private record Point(int x, int y, int z) {}
+ private static final int[][] NEIGHBORS = { {1,0,0}, {-1,0,0}, {0,1,0}, {0,-1,0}, {0,0,1}, {0,0,-1} };
+ @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
+ public void vein(BlockBreakEvent event) {
+ Player player = event.getPlayer();
+ if (nativeBreaks.contains(player.getUniqueId()) || player.getGameMode() != GameMode.SURVIVAL) return;
+ Block origin = event.getBlock(); Material ore = origin.getType();
+ Material selectedTool = player.getInventory().getItemInMainHand().getType();
+ Perk perk = eligible(player, Effect.VeinMining, candidate -> {
+ var options = candidate.getInteractionOptions();
+ return allowed(options.veinMaterials(), ore) && (options.veinTools().isEmpty()
+ ? selectedTool.name().endsWith("_PICKAXE") : allowed(options.veinTools(), selectedTool));
+ });
+ if (perk == null) return;
+ if (!(ore.name().endsWith("_ORE") || ore == Material.ANCIENT_DEBRIS) || origin.hasMetadata("Placed")) return;
+ var data = perk.getInteractionOptions();
+ if (!allowed(data.veinMaterials(), ore)) { skip(player, Effect.VeinMining, Skip.MATERIAL); return; }
+ ItemStack tool = player.getInventory().getItemInMainHand().clone();
+ int toolSlot = player.getInventory().getHeldItemSlot();
+ List tools = data.veinTools();
+ if (tools.isEmpty() ? !tool.getType().name().endsWith("_PICKAXE") : !allowed(tools, tool.getType())) { skip(player, Effect.VeinMining, Skip.TOOL); return; }
+ int maximum = data.veinBlocks();
+ int distance = data.veinDistance();
+ if (!owns(player, origin)) return;
+ List blocks = connected(player, origin, ore, maximum, distance);
+ if (blocks.isEmpty()) return;
+ List units = new ArrayList<>();
+ for (Block block : blocks) units.add(() -> {
+ if (player.getGameMode() != GameMode.SURVIVAL || event.isCancelled() || !owns(player, origin) || origin.getType() == ore || eligible(player, Effect.VeinMining, candidate -> candidate == perk) != perk
+ || !matchesTool(player, tool, toolSlot) || !owns(player, block) || block.getType() != ore || block.hasMetadata("Placed")
+ || player.getLocation().distanceSquared(block.getLocation()) > 256) return false;
+ boolean broken = nativeBreak(player, block); if (!broken) skip(player, Effect.VeinMining, Skip.NATIVE_BREAK_DENIED); return broken;
+ });
+ later(player, () -> run(player, perk, Kind.VeinMining, units));
+ }
+ private boolean matchesTool(Player player, ItemStack expected, int selectedSlot) {
+ if (player.getInventory().getHeldItemSlot() != selectedSlot) return false;
+ ItemStack actual = player.getInventory().getItemInMainHand();
+ if (actual == null || actual.getType() != expected.getType()) return false;
+ var actualMeta = actual.getItemMeta(); var expectedMeta = expected.getItemMeta();
+ // Native breaks change only durability. All other metadata identifies the admitted tool.
+ if (actualMeta instanceof org.bukkit.inventory.meta.Damageable damage) damage.setDamage(0);
+ if (expectedMeta instanceof org.bukkit.inventory.meta.Damageable damage) damage.setDamage(0);
+ return Objects.equals(actualMeta, expectedMeta);
+ }
+ private List connected(Player player, Block origin, Material ore, int maximum, int distance) {
+ List found = new ArrayList<>(); Set visited = new HashSet<>(); ArrayDeque queue = new ArrayDeque<>();
+ Point start = new Point(origin.getX(), origin.getY(), origin.getZ()); queue.add(start);
+ while (!queue.isEmpty() && found.size() < maximum - 1 && visited.size() < 512) {
+ Point p = queue.remove(); if (!visited.add(p)) continue;
+ if (Math.abs(p.x-start.x) > distance || Math.abs(p.y-start.y) > distance || Math.abs(p.z-start.z) > distance
+ || p.y < origin.getWorld().getMinHeight() || p.y >= origin.getWorld().getMaxHeight()) continue;
+ // Check coordinates before obtaining a Block; never load/access an adjacent unloaded chunk.
+ if (!origin.getWorld().isChunkLoaded(p.x >> 4, p.z >> 4)) continue;
+ if (plugin.getBukkitScheduler().getFoliaLib().isFolia() && ((p.x >> 4) != (start.x >> 4) || (p.z >> 4) != (start.z >> 4))) continue;
+ Block b = origin.getWorld().getBlockAt(p.x, p.y, p.z);
+ if (!owns(player, b) || b.getType() != ore || b.hasMetadata("Placed")) continue;
+ if (!p.equals(start)) found.add(b);
+ for (int[] offset : NEIGHBORS) queue.add(new Point(p.x+offset[0], p.y+offset[1], p.z+offset[2]));
+ }
+ return found;
+ }
+ @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
+ public void harvest(PlayerInteractEvent event) {
+ if (event.getAction() != Action.RIGHT_CLICK_BLOCK || event.getHand() != EquipmentSlot.HAND || event.getClickedBlock() == null
+ || !interactionAllowed(event)) return;
+ Player player = event.getPlayer(); Block block = event.getClickedBlock();
+ Perk perk = eligible(player, Effect.RightClickHarvest, candidate -> allowed(candidate.getInteractionOptions().crops(), block.getType())
+ && AutoPlant.allows(candidate, player.getInventory().getItemInMainHand(), block.getType()));
+ if (perk == null || player.getGameMode() != GameMode.SURVIVAL || !owns(player, block)) return;
+ Material crop = block.getType(); Material seed = AutoPlant.seedFor(crop);
+ if (seed == null || !(block.getBlockData() instanceof Ageable age) || age.getAge() != age.getMaximumAge()
+ || !allowed(perk.getInteractionOptions().crops(), crop)
+ || !AutoPlant.allows(perk, player.getInventory().getItemInMainHand(), crop)) return;
+ int seedSlot = -1;
+ for (int i = 0; i < 36; i++) { ItemStack item = player.getInventory().getItem(i); if (item != null && item.getType() == seed && item.getAmount() > 0) { seedSlot = i; break; } }
+ if (seedSlot < 0) { skip(player, Effect.RightClickHarvest, Skip.SEED); return; }
+ int slot = seedSlot; ItemStack seedBefore = player.getInventory().getItem(slot).clone();
+ ItemStack tool = player.getInventory().getItemInMainHand().clone();
+ int toolSlot = player.getInventory().getHeldItemSlot(); BlockData before = block.getBlockData().clone();
+ later(player, () -> {
+ // Final interaction protection is distinct from native block-break protection.
+ if (!interactionAllowed(event)) { skip(player, Effect.RightClickHarvest, Skip.INTERACTION_DENIED); return; }
+ run(player, perk, Kind.RightClickHarvest, List.of(() -> {
+ if (player.getGameMode() != GameMode.SURVIVAL || !interactionAllowed(event) || eligible(player, Effect.RightClickHarvest, candidate -> candidate == perk) != perk || !owns(player, block) || !before.equals(block.getBlockData())
+ || player.getLocation().distanceSquared(block.getLocation()) > 36
+ || player.getInventory().getHeldItemSlot() != toolSlot || !matchesTool(player, tool) || !seedBefore.equals(player.getInventory().getItem(slot))) return false;
+ // Reserve the replant seed before native break callbacks can change inventory.
+ ItemStack remainder = seedBefore.clone(); remainder.setAmount(remainder.getAmount() - 1);
+ player.getInventory().setItem(slot, remainder.getAmount() == 0 ? null : remainder);
+ boolean broken = nativeBreak(player, block);
+ if (!broken) {
+ skip(player, Effect.RightClickHarvest, Skip.NATIVE_BREAK_DENIED);
+ // Restore only into the unchanged slot; otherwise give the exact seed through normal inventory/drop handling.
+ ItemStack current = player.getInventory().getItem(slot);
+ if ((remainder.getAmount() == 0 && (current == null || current.getType() == Material.AIR)) || remainder.equals(current)) player.getInventory().setItem(slot, seedBefore);
+ else { ItemStack returned = seedBefore.clone(); returned.setAmount(1);
+ for (ItemStack overflow : player.getInventory().addItem(returned).values()) player.getWorld().dropItemNaturally(player.getLocation(), overflow); }
+ return false;
+ }
+ if (block.getType() != Material.AIR) throw new IllegalStateException("Harvest replacement changed by another listener");
+ Ageable replanted = (Ageable) before.clone(); replanted.setAge(0); block.setBlockData(replanted);
+ return true;
+ }));
+ });
+ }
+ @SuppressWarnings("deprecation")
+ private static boolean interactionAllowed(PlayerInteractEvent event) {
+ return !event.isCancelled() && event.useInteractedBlock() != Event.Result.DENY && event.useItemInHand() != Event.Result.DENY;
+ }
+ private boolean nativeBreak(Player player, Block block) {
+ nativeBreaks.add(player.getUniqueId());
+ try { return player.breakBlock(block); } finally { nativeBreaks.remove(player.getUniqueId()); }
+ }
+ private static boolean allowed(List values, Material material) { return values.isEmpty() || values.stream().anyMatch(v -> v.equalsIgnoreCase(material.name())); }
+ private synchronized boolean admitPending(String key, Batch batch) {
+ return !retired && pending.size() < 256 && pending.putIfAbsent(key, batch) == null;
+ }
+ private void settle(String key, Batch batch) {
+ pending.remove(key, batch); batch.settled.complete(null);
+ }
+ private void run(Player player, Perk perk, Kind kind, List units) {
+ if (player.getGameMode() != GameMode.SURVIVAL) return;
+ String key = player.getUniqueId() + ":" + kind;
+ Batch batch = new Batch();
+ if (!admitPending(key, batch)) { skip(player, Effect.valueOf(kind.name()), Skip.BUSY); return; }
+ int version = generation;
+ boolean charge = charged(perk);
+ CompletableFuture admission = charge
+ ? ledger.reserve(player.getUniqueId(), kind, units.size()) : CompletableFuture.completedFuture(null);
+ admission.whenComplete((reservation, error) -> {
+ if (error != null || (charge && reservation == null)) {
+ noteSkip(player.getUniqueId(), Effect.valueOf(kind.name()), error == null ? Skip.DEPLETED : Skip.STORAGE);
+ settle(key, batch); return;
+ }
+ Runnable release = () -> {
+ CompletableFuture completion = charge ? ledger.finish(reservation, 0, reservation.units()) : CompletableFuture.completedFuture(null);
+ completion.whenComplete((ignored, failure) -> settle(key, batch));
+ };
+ Runnable cancel = () -> { if (batch.invoked.compareAndSet(false, true)) release.run(); };
+ batch.cancel = cancel;
+ // Retirement may have claimed cancellation before the reservation finished publishing.
+ if (batch.invoked.get()) { release.run(); return; }
+ Runnable execute = () -> {
+ if (!batch.invoked.compareAndSet(false, true)) return;
+ try {
+ int budget = charge ? reservation.units() : units.size();
+ EffectBatch.Result result = retired || version != generation || !player.isOnline() || player.getGameMode() != GameMode.SURVIVAL
+ ? new EffectBatch.Result(0, budget) : EffectBatch.execute(units.stream().map(unit -> () -> retired || version != generation || player.getGameMode() != GameMode.SURVIVAL ? false : unit.apply()).toList(), budget);
+ CompletableFuture completion = charge ? ledger.finish(reservation, result.successful(), result.unused())
+ : ledger.record(player.getUniqueId(), kind, result.successful());
+ if (result.successful() + result.unused() < budget) skip(player, Effect.valueOf(kind.name()), Skip.UNCERTAIN);
+ completion.whenComplete((ignored, failure) -> {
+ if (failure != null) plugin.getLogger().warning(charge
+ ? "Usage completion could not be persisted; reserved charges remain spent"
+ : "Usage statistics could not be persisted; gameplay completed");
+ if (charge) settle(key, batch);
+ });
+ // Best-effort statistics must never retain an unlimited gameplay admission.
+ if (!charge) settle(key, batch);
+ } catch (Throwable failure) { settle(key, batch); plugin.getLogger().warning("Usage callback failed; reservation remains spent"); }
+ };
+ if (retired || !plugin.isEnabled()) cancel.run();
+ else OwnerTasks.run(plugin, player, execute, cancel);
+ });
+ }
+}
diff --git a/MCPerks/src/main/java/com/bencodez/mcperks/listeners/compatability/McMMOEvents.java b/MCPerks/src/main/java/com/bencodez/mcperks/listeners/compatability/McMMOEvents.java
index 0681b8d..9d7be53 100644
--- a/MCPerks/src/main/java/com/bencodez/mcperks/listeners/compatability/McMMOEvents.java
+++ b/MCPerks/src/main/java/com/bencodez/mcperks/listeners/compatability/McMMOEvents.java
@@ -27,8 +27,9 @@ public void onMcMMOPlayerXpGainEvent(McMMOPlayerXpGainEvent event) {
if (plugin.getPerkHandler().effectActive(Effect.McmmoXP, player.getUniqueId().toString(),
player.getWorld().getName())) {
for (Perk active : plugin.getPerkHandler().getActivePerks()) {
- if (active.getEffects().contains(Effect.McmmoXP)
- && active.getEffectedPlayers().contains(player.getUniqueId().toString())) {
+ if (active.getEffects().contains(Effect.McmmoXP)
+ && plugin.getPerkHandler().effectAllowed(active, Effect.McmmoXP,
+ player.getUniqueId().toString(), player.getWorld().getName())) {
if (active.isNotInDisabledWorld(player.getWorld().getName())) {
ArrayList skills = active.getMcmmoSkills();
boolean boost = false;
diff --git a/MCPerks/src/main/java/com/bencodez/mcperks/listeners/compatability/RoseStackerListener.java b/MCPerks/src/main/java/com/bencodez/mcperks/listeners/compatability/RoseStackerListener.java
index 5f51b36..7f8e847 100644
--- a/MCPerks/src/main/java/com/bencodez/mcperks/listeners/compatability/RoseStackerListener.java
+++ b/MCPerks/src/main/java/com/bencodez/mcperks/listeners/compatability/RoseStackerListener.java
@@ -83,7 +83,8 @@ public void onDropStack(PreDropStackedItemsEvent event) {
if (plugin.getPerkHandler().effectActive(Effect.InstantSmelt, player.getUniqueId().toString(),
player.getWorld().getName())) {
for (Perk active : plugin.getPerkHandler().getActivePerks()) {
- if (active.getEffects().contains(Effect.InstantSmelt)) {
+ if (active.getEffects().contains(Effect.InstantSmelt) && plugin.getPerkHandler().effectAllowed(active,
+ Effect.InstantSmelt, player.getUniqueId().toString(), player.getWorld().getName())) {
for (ItemStack item : items) {
ItemStack smeltedItem = null;
Iterator recipeIterator = plugin.getServer().recipeIterator();
diff --git a/MCPerks/src/main/java/com/bencodez/mcperks/perk/BankedClock.java b/MCPerks/src/main/java/com/bencodez/mcperks/perk/BankedClock.java
new file mode 100644
index 0000000..69dd95f
--- /dev/null
+++ b/MCPerks/src/main/java/com/bencodez/mcperks/perk/BankedClock.java
@@ -0,0 +1,81 @@
+package com.bencodez.mcperks.perk;
+/** Explicit lifecycle clock; queries do not checkpoint or consume time. */
+public final class BankedClock {
+ private long previous;
+ private boolean eligible;
+ private boolean grantInProgress;
+ private long pendingMilliseconds;
+ private long replacement;
+ private final java.util.function.LongSupplier publishedReplacement;
+ public BankedClock() { this(() -> 0); }
+ BankedClock(java.util.function.LongSupplier publishedReplacement) { this.publishedReplacement = publishedReplacement; }
+ public record Debit(long milliseconds, long replacement, long publication) {}
+ /** Capture debit ownership together with its elapsed-time reservation. */
+ public synchronized Debit reserveCheckpoint(long monotonicNanos, boolean nowEligible,
+ java.util.function.LongSupplier confirmedMilliseconds) {
+ return new Debit(checkpoint(monotonicNanos, nowEligible, confirmedMilliseconds), replacement, publishedReplacement.getAsLong());
+ }
+ private long elapsed(long monotonicNanos) {
+ return eligible && previous != 0 ? Math.max(0, (monotonicNanos - previous) / 1_000_000) : 0;
+ }
+ public synchronized long checkpoint(long monotonicNanos, boolean nowEligible) {
+ return checkpoint(monotonicNanos, nowEligible, () -> Long.MAX_VALUE);
+ }
+ public synchronized long checkpoint(long monotonicNanos, boolean nowEligible,
+ java.util.function.LongSupplier confirmedMilliseconds) {
+ if (grantInProgress) { eligible = nowEligible; return 0; }
+ long elapsed = Math.min(elapsed(monotonicNanos), Math.max(0, confirmedMilliseconds.getAsLong() - pendingMilliseconds));
+ pendingMilliseconds = Math.min(31_536_000_000L, pendingMilliseconds + elapsed);
+ previous = monotonicNanos; eligible = nowEligible; return elapsed;
+ }
+ /**
+ * Move the elapsed-time boundary to a grant publication. The caller
+ * persists the returned debit as part of the same bank publication.
+ */
+ public synchronized com.bencodez.mcperks.data.FeatureState.BankGrant prepareGrant(long monotonicNanos, long oldBalance,
+ java.util.function.LongSupplier committedTime) {
+ // A prior checkpoint may already be awaiting its worker debit. That
+ // debit is still charged against the published balance, so only the
+ // unreserved portion of the old balance can cover this interval.
+ long elapsed = Math.min(elapsed(monotonicNanos),
+ Math.max(0, oldBalance - pendingMilliseconds));
+ grantInProgress = true;
+ return new com.bencodez.mcperks.data.FeatureState.BankGrant(elapsed,
+ () -> commitGrant(committedTime.getAsLong()), this::rollbackGrant);
+ }
+ private synchronized void commitGrant(long monotonicNanos) { previous = monotonicNanos; grantInProgress = false; }
+ /** A clock first attached during publication can spend only the pre-grant balance. */
+ public synchronized Debit rebaseLateGrant(long monotonicNanos, long oldBalance) {
+ long elapsed = Math.min(elapsed(monotonicNanos), Math.max(0, oldBalance - pendingMilliseconds));
+ pendingMilliseconds += elapsed;
+ previous = monotonicNanos;
+ return new Debit(elapsed, replacement, publishedReplacement.getAsLong());
+ }
+ private synchronized void rollbackGrant() { grantInProgress = false; }
+ /** Replacement discards earlier elapsed reservations only once its new balance is published. */
+ public synchronized com.bencodez.mcperks.data.FeatureState.BankGrant prepareReplacement(
+ java.util.function.LongSupplier committedTime) {
+ grantInProgress = true;
+ return new com.bencodez.mcperks.data.FeatureState.BankGrant(0,
+ () -> commitReplacement(committedTime.getAsLong()), this::rollbackGrant);
+ }
+ private synchronized void commitReplacement(long monotonicNanos) {
+ replacement++; pendingMilliseconds = 0; commitGrant(monotonicNanos);
+ }
+ public synchronized boolean owns(Debit debit) {
+ return debit.replacement() == replacement && debit.publication() == publishedReplacement.getAsLong();
+ }
+ public synchronized void acknowledge(Debit debit) {
+ if (owns(debit)) acknowledge(debit.milliseconds());
+ }
+ /** Called only after the matching debit has been published by the storage worker. */
+ public synchronized void acknowledge(long milliseconds) {
+ pendingMilliseconds = Math.max(0, pendingMilliseconds - milliseconds);
+ }
+ /** Read the confirmed balance under the same monitor as acknowledgement, without mutation. */
+ public synchronized long remaining(java.util.function.LongSupplier confirmedMilliseconds, long now) {
+ if (grantInProgress) return 0;
+ return Math.max(0, confirmedMilliseconds.getAsLong() - pendingMilliseconds - elapsed(now));
+ }
+ public synchronized void pause() { previous = 0; eligible = false; }
+}
diff --git a/MCPerks/src/main/java/com/bencodez/mcperks/perk/BankedPerks.java b/MCPerks/src/main/java/com/bencodez/mcperks/perk/BankedPerks.java
new file mode 100644
index 0000000..d6adbc1
--- /dev/null
+++ b/MCPerks/src/main/java/com/bencodez/mcperks/perk/BankedPerks.java
@@ -0,0 +1,278 @@
+package com.bencodez.mcperks.perk;
+import java.util.*;
+import java.util.concurrent.*;
+import org.bukkit.Bukkit;
+import org.bukkit.entity.Player;
+import org.bukkit.event.*;
+import org.bukkit.event.player.*;
+import com.bencodez.mcperks.MCPerksMain;
+import com.bencodez.mcperks.scheduling.OwnerTasks;
+import com.bencodez.mcperks.data.FeatureState;
+import com.bencodez.mcperks.data.FeatureState.BankKey;
+import com.bencodez.mcperks.userapi.MCPerksUser;
+/** Online/eligible personal time. Suspension never repeats activation/reward hooks. */
+public final class BankedPerks implements Listener {
+ private final MCPerksMain plugin;
+ private final FeatureState state;
+ private final Map attached = new ConcurrentHashMap<>();
+ private final Map clocks = new ConcurrentHashMap<>();
+ private final Set pausing = ConcurrentHashMap.newKeySet();
+ private final java.util.function.LongSupplier monotonic;
+ private final Map sessions = new ConcurrentHashMap<>();
+ private final Map ticking = new ConcurrentHashMap<>();
+ private final java.util.concurrent.atomic.AtomicLong tickIds = new java.util.concurrent.atomic.AtomicLong();
+ private volatile int generation;
+ private volatile boolean retired;
+ // Per-perk admission also covers a server-wide cooldown shared by different players.
+ private final Set directAdmissions = ConcurrentHashMap.newKeySet();
+ public synchronized boolean beginDirect(Perk perk) {
+ return !retired && directAdmissions.size() < 256 && directAdmissions.add(perk.getPerk());
+ }
+ public void finishDirect(Perk perk) { directAdmissions.remove(perk.getPerk()); }
+ public boolean hasEntitlement(UUID owner, Perk perk) {
+ var bank = state.banks().get(new BankKey(owner, perk.getPerk()));
+ return bank != null && bank.milliseconds() > 0;
+ }
+ private static final Set UNSUPPORTED = EnumSet.of(Effect.Commands, Effect.GlobalCommands, Effect.Rewards,
+ Effect.CureHunger, Effect.CureSpells, Effect.HealAll, Effect.RandomToolRepair, Effect.ToolRepair,
+ Effect.ArmorRepair, Effect.RandomArmorRepair, Effect.AllRepair, Effect.RandomAllRepair,
+ Effect.Fly, Effect.DoubleJump, Effect.DoubleJumpUp, Effect.Potions, Effect.TempPermission, Effect.IncreaseMaxHealth, Effect.IncreaseStrength, Effect.IncreaseLuck, Effect.MoveSpeed);
+ public BankedPerks(MCPerksMain plugin, FeatureState state) { this(plugin, state, System::nanoTime); }
+ BankedPerks(MCPerksMain plugin, FeatureState state, java.util.function.LongSupplier monotonic) {
+ this.plugin = plugin; this.state = state; this.monotonic = monotonic;
+ state.onBankGrant((key, oldBalance) -> {
+ BankedClock clock = clocks.get(key);
+ FeatureState.BankGrant boundary = clock == null ? new FeatureState.BankGrant(0, () -> {}, () -> {})
+ : clock.prepareGrant(monotonic.getAsLong(), oldBalance, monotonic);
+ return new FeatureState.BankGrant(boundary.elapsed(), () -> {
+ boundary.commit().run();
+ BankedClock current = clocks.get(key);
+ if (current != null && current != clock) {
+ var debit = current.rebaseLateGrant(monotonic.getAsLong(), Math.max(0, oldBalance - boundary.elapsed()));
+ if (debit.milliseconds() > 0) state.elapsed(key, debit.milliseconds(), () -> current.owns(debit))
+ .thenRun(() -> current.acknowledge(debit));
+ }
+ }, boundary.rollback());
+ });
+ state.onBankReplacement(key -> {
+ BankedClock clock = clocks.get(key);
+ FeatureState.BankGrant boundary = clock == null ? new FeatureState.BankGrant(0, () -> {}, () -> {})
+ : clock.prepareReplacement(monotonic);
+ return new FeatureState.BankGrant(0, () -> {
+ boundary.commit().run();
+ // A player can attach/reconnect while this worker's publication is blocked.
+ BankedClock current = clocks.get(key);
+ if (current != null && current != clock) current.prepareReplacement(monotonic).commit().run();
+ }, boundary.rollback());
+ });
+ }
+ public String grantUnavailable(UUID owner, Perk perk, int seconds) {
+ if (!state.available()) return "bank storage unavailable";
+ if (!supported(perk) || seconds < 1) return "unsupported banked perk";
+ if ((long) seconds * 1000 > 31_536_000_000L) return "bank grant exceeds one year";
+ BankKey key = new BankKey(owner, perk.getPerk());
+ if (!state.banks().containsKey(key) && (state.banks().size() >= 10000 || state.banks().keySet().stream().filter(k -> k.owner().equals(owner)).count() >= 64)) return "bank capacity reached";
+ var old = state.banks().get(key);
+ if (old != null && (long) seconds * 1000 > 31_536_000_000L - old.milliseconds()) return "bank capacity reached";
+ return null;
+ }
+ public static boolean supported(Perk perk) { return perk.getPerkType() == PerkSystemType.PLAYER && perk.getReActivateEffectsTimer() <= 0 && Collections.disjoint(perk.getEffects(), UNSUPPORTED); }
+ public CompletableFuture grant(MCPerksUser user, Perk perk, int seconds) {
+ return publishGrant(user, perk, seconds).thenRun(() -> granted(user, perk));
+ }
+ public CompletableFuture grantConfirmed(MCPerksUser user, Perk perk, int seconds) {
+ if (!plugin.getConfigFile().getPerkQue()) return grant(user, perk, seconds);
+ return publishGrant(user, perk, seconds).thenCompose(ignored -> grantedConfirmed(user, perk));
+ }
+ private CompletableFuture publishGrant(MCPerksUser user, Perk perk, int seconds) {
+ String unavailable = grantUnavailable(UUID.fromString(user.getUUID()), perk, seconds);
+ if (unavailable != null) return CompletableFuture.failedFuture(new IllegalArgumentException(unavailable));
+ BankKey key = new BankKey(UUID.fromString(user.getUUID()), perk.getPerk());
+ return state.addBank(key, Math.multiplyExact((long) seconds, 1000));
+ }
+ /** Attach only a grant that the state worker already published; never adds time a second time. */
+ public void granted(MCPerksUser user, Perk perk) {
+ plugin.getLocalStatistics().activation();
+ Player player = Bukkit.getPlayer(UUID.fromString(user.getUUID()));
+ if (player != null) OwnerTasks.run(plugin, player, () -> start(player), () -> stopSession(player));
+ }
+ public CompletableFuture grantedConfirmed(MCPerksUser user, Perk perk) {
+ var attachment = new CompletableFuture();
+ plugin.getLocalStatistics().activation();
+ Player player = Bukkit.getPlayer(UUID.fromString(user.getUUID()));
+ if (player == null) attachment.complete(null);
+ else OwnerTasks.run(plugin, player, () -> start(player, attachment), () -> { stopSession(player); attachment.complete(null); });
+ return attachment;
+ }
+ public synchronized void start(Player player) {
+ start(player, null);
+ }
+ private static void settled(CompletableFuture attachment) { if (attachment != null) attachment.complete(null); }
+ private synchronized void start(Player player, CompletableFuture attachment) {
+ UUID owner = player.getUniqueId();
+ if (retired || !player.isOnline() || Bukkit.getPlayer(owner) != player) { settled(attachment); return; }
+ if (state.banks().entrySet().stream().noneMatch(e -> e.getKey().owner().equals(owner) && e.getValue().milliseconds() > 0)) { settled(attachment); return; }
+ Long current = ticking.get(owner);
+ if (current != null) {
+ // A grant to an already ticking owner gets one attachment attempt, not a second timer loop.
+ if (attachment != null) pulse(player, generation, current, attachment, false);
+ return;
+ }
+ long token = tickIds.incrementAndGet();
+ if (!plugin.getPerkHandler().isRestorationReady() || !state.available() || ticking.size() >= 256 || ticking.putIfAbsent(player.getUniqueId(), token) != null) { settled(attachment); return; }
+ sessions.put(owner, player);
+ pulse(player, generation, token, attachment, true);
+ }
+ @EventHandler public void join(PlayerJoinEvent event) { start(event.getPlayer()); }
+ @EventHandler public synchronized void world(PlayerChangedWorldEvent event) {
+ UUID owner = event.getPlayer().getUniqueId();
+ if (sessions.get(owner) != event.getPlayer()) return;
+ for (BankKey key : List.copyOf(clocks.keySet())) if (key.owner().equals(owner)) suspend(key);
+ start(event.getPlayer());
+ }
+ @EventHandler public void quit(PlayerQuitEvent event) { stopSession(event.getPlayer()); }
+ public void refresh(UUID owner) {
+ Player player = Bukkit.getPlayer(owner); if (player != null) OwnerTasks.run(plugin, player, () -> {
+ synchronized (BankedPerks.this) {
+ if (Bukkit.getPlayer(owner) != player || !player.isOnline()) return;
+ for (BankKey key : List.copyOf(attached.keySet())) if (key.owner().equals(owner)) {
+ var bank = state.banks().get(key); if (bank == null || bank.paused() || bank.milliseconds() == 0) suspend(key);
+ }
+ start(player);
+ }
+ }, () -> stopSession(player));
+ }
+ private record Context(MCPerksUser user, boolean ignored) {}
+ private void pulse(Player player, int version, long token) {
+ pulse(player, version, token, null, true);
+ }
+ private void pulse(Player player, int version, long token, CompletableFuture attachment, boolean repeat) {
+ UUID owner = player.getUniqueId();
+ if (retired || version != generation || !Objects.equals(ticking.get(owner), token)) { settled(attachment); return; }
+ if (!player.isOnline()) { stopIfCurrent(owner, token); settled(attachment); return; }
+ var ownedBanks = state.banks().entrySet().stream().filter(e -> e.getKey().owner().equals(owner)).limit(64).toList();
+ if (ownedBanks.stream().noneMatch(e -> e.getValue().milliseconds() > 0)) { stopIfCurrent(owner, token); settled(attachment); return; }
+ // User ignore state can require SQL. Fetch on the bounded feature worker before returning to owner.
+ state.storage(() -> { MCPerksUser user = plugin.getMcperksUserManager().getMCPerksUser(owner); return new Context(user, user.isIgnorePerkEffects()); }).whenComplete((context, readError) -> {
+ if (retired || version != generation || !Objects.equals(ticking.get(owner), token) || !plugin.isEnabled()) { settled(attachment); return; }
+ OwnerTasks.run(plugin, player, () -> {
+ try { synchronized (BankedPerks.this) {
+ if (retired || version != generation || !Objects.equals(ticking.get(owner), token)) { settled(attachment); return; }
+ if (!player.isOnline()) { stopIfCurrent(owner, token); settled(attachment); return; }
+ List> checkpoints = new ArrayList<>();
+ for (var entry : ownedBanks) {
+ BankKey key = entry.getKey(); Perk perk = plugin.getPerkHandler().getPerk(key.perk()); var bank = state.banks().get(key);
+ boolean eligible = plugin.getPerkHandler().isRestorationReady() && state.available() && !pausing.contains(key) && readError == null && context != null && !context.ignored() && bank != null && !bank.paused() && bank.milliseconds() > 0
+ && withinActiveLimit(context.user(), key) && perk != null && perk.getInteractionOptions().banked() && supported(perk) && perk.isNotInDisabledWorld(player.getWorld().getName())
+ && plugin.getPerkHandler().getActivePerks().stream().noneMatch(active -> !attached.containsValue(active) && active.getPerk().equals(key.perk()) && active.getEffectedPlayers().contains(owner.toString()));
+ if (eligible) eligible = plugin.getQueuePlanner().attachBank(key, attached.get(key), () -> {
+ if (!attached.containsKey(key)) attach(key, perk, context.user());
+ });
+ ClockDebit checkpoint = reserve(key, eligible, true);
+ BankedClock clock = checkpoint.clock(); BankedClock.Debit debit = checkpoint.debit();
+ long elapsed = debit.milliseconds();
+ if (elapsed > 0) checkpoints.add(debitElapsed(key, clock, debit));
+ if (!eligible) { suspend(key); continue; }
+ if (elapsed > 0) checkpoints.add(state.storage(() -> state.banks().get(key)).whenComplete((updated, error) -> {
+ if (!retired && version == generation && Objects.equals(ticking.get(owner), token) && plugin.isEnabled()) OwnerTasks.run(plugin, player, () -> {
+ synchronized (BankedPerks.this) {
+ if (retired || version != generation || !Objects.equals(ticking.get(owner), token)) return;
+ if (error != null || updated == null || updated.paused() || updated.milliseconds() == 0) suspend(key);
+ }
+ }, () -> stopIfCurrent(owner, token));
+ }));
+ }
+ CompletableFuture.allOf(checkpoints.toArray(CompletableFuture[]::new)).whenComplete((ignored, failure) -> {
+ settled(attachment);
+ if (failure != null) { stopIfCurrent(owner, token); return; }
+ if (repeat && !retired && plugin.isEnabled()) OwnerTasks.later(plugin, player, () -> pulse(player, version, token), () -> stopIfCurrent(owner, token), 20);
+ });
+ } } catch (RuntimeException failure) {
+ if (attachment != null) attachment.completeExceptionally(failure);
+ stopIfCurrent(owner, token);
+ }
+ }, () -> { stopIfCurrent(owner, token); settled(attachment); });
+ });
+ }
+ /** Recheck on the player owner at attachment, after asynchronous grants and manual resume. */
+ private boolean withinActiveLimit(MCPerksUser user, BankKey key) {
+ if (!plugin.getConfigFile().getLimitPermission()) return true;
+ int limit = user.getPerkLimit();
+ return limit == -1 || user.getActivePerks() + (attached.containsKey(key) ? 0 : 1) <= limit;
+ }
+ private void attach(BankKey key, Perk source, MCPerksUser user) {
+ Perk clone = source.clone(); clone.setActivater(user);
+ clone.getEffectedPlayers().clear(); clone.getEffectedPlayers().add(key.owner().toString()); clone.setActive(true);
+ attached.put(key, clone); plugin.getPerkHandler().getActivePerks().add(clone);
+ // Only reversible persistent effects are eligible; command/reward effects are rejected at load/grant.
+ // Supported effects are read by gameplay listeners; there is no activation hook to replay.
+ }
+ private void suspend(BankKey key) {
+ checkpoint(key);
+ Perk perk = attached.remove(key); if (perk == null) return;
+ perk.setActive(false);
+ plugin.getPerkHandler().getActivePerks().remove(perk); plugin.getQueuePlanner().check();
+ }
+ private CompletableFuture checkpoint(BankKey key) {
+ ClockDebit checkpoint = reserve(key, false, false);
+ if (checkpoint == null || checkpoint.debit().milliseconds() == 0) return CompletableFuture.completedFuture(null);
+ return debitElapsed(key, checkpoint.clock(), checkpoint.debit());
+ }
+ private record ClockDebit(BankedClock clock, BankedClock.Debit debit) {}
+ private ClockDebit reserve(BankKey key, boolean eligible, boolean create) {
+ return state.bankCheckpoint(() -> {
+ BankedClock clock = create ? clocks.computeIfAbsent(key, k -> new BankedClock(() -> state.bankReplacementVersion(k))) : clocks.get(key);
+ if (clock == null) return null;
+ var debit = clock.reserveCheckpoint(monotonic.getAsLong(), eligible, () -> {
+ var current = state.banks().get(key); return current == null ? 0 : current.milliseconds();
+ });
+ return new ClockDebit(clock, debit);
+ });
+ }
+ private CompletableFuture debitElapsed(BankKey key, BankedClock clock, BankedClock.Debit debit) {
+ return state.elapsed(key, debit.milliseconds(), () -> clock.owns(debit)).thenRun(() -> clock.acknowledge(debit));
+ }
+ public synchronized CompletableFuture pause(BankKey key, boolean paused) {
+ pausing.add(key); suspend(key);
+ return state.pauseBank(key, paused).whenComplete((bank, error) -> { pausing.remove(key); if (error == null) refresh(key.owner()); });
+ }
+ public synchronized boolean deactivate(Perk perk) {
+ BankKey key = attached.entrySet().stream().filter(e -> e.getValue() == perk).map(Map.Entry::getKey).findFirst().orElse(null);
+ if (key == null) return false;
+ pause(key, true); return true;
+ }
+ private synchronized void stopSession(Player player) { if (sessions.get(player.getUniqueId()) == player) stop(player.getUniqueId()); }
+ private synchronized void stopIfCurrent(UUID owner, long token) { if (Objects.equals(ticking.get(owner), token)) stop(owner); }
+ private synchronized void stop(UUID owner) {
+ ticking.remove(owner); sessions.remove(owner); for (BankKey key : List.copyOf(clocks.keySet())) if (key.owner().equals(owner)) suspend(key);
+ clocks.keySet().removeIf(key -> key.owner().equals(owner));
+ }
+ public synchronized void reload() {
+ Set owners = new HashSet<>(ticking.keySet());
+ for (BankKey key : clocks.keySet()) owners.add(key.owner());
+ generation++; ticking.clear(); sessions.clear();
+ for (BankKey key : List.copyOf(clocks.keySet())) suspend(key);
+ clocks.clear();
+ for (UUID owner : owners) {
+ Player player = Bukkit.getPlayer(owner);
+ if (player != null) OwnerTasks.run(plugin, player, () -> start(player), () -> stopSession(player));
+ }
+ }
+ public synchronized void retire() {
+ retired = true; generation++; ticking.clear(); sessions.clear();
+ for (BankKey key : List.copyOf(clocks.keySet())) suspend(key);
+ clocks.clear(); attached.clear();
+ }
+ public boolean available(Perk perk) {
+ if (!attached.containsValue(perk)) return true;
+ UUID owner = UUID.fromString(perk.getActivater().getUUID());
+ if (!state.available() || !ticking.containsKey(owner)) return false;
+ BankKey key = new BankKey(owner, perk.getPerk());
+ BankedClock clock = clocks.get(key);
+ return clock != null && clock.remaining(() -> {
+ var bank = state.banks().get(key);
+ return bank == null || bank.paused() ? 0 : bank.milliseconds();
+ }, monotonic.getAsLong()) > 0;
+ }
+ public boolean attached(Perk perk) { return attached.containsValue(perk); }
+}
diff --git a/MCPerks/src/main/java/com/bencodez/mcperks/perk/Effect.java b/MCPerks/src/main/java/com/bencodez/mcperks/perk/Effect.java
index 5eb9598..58e0193 100644
--- a/MCPerks/src/main/java/com/bencodez/mcperks/perk/Effect.java
+++ b/MCPerks/src/main/java/com/bencodez/mcperks/perk/Effect.java
@@ -113,7 +113,19 @@ public enum Effect {
AllRepair,
- RandomAllRepair;
+ RandomAllRepair,
+
+ /** Refills a depleted held block stack from matching inventory items. */
+ AutoBlockRefill,
+
+ /** Mines a bounded connected group of configured blocks. */
+ VeinMining,
+
+ /** Harvests mature crops on right click and replants when possible. */
+ RightClickHarvest,
+
+ /** Suppresses configured MCPerks effects while sneaking. */
+ PrecisionMode;
public static Effect fromString(String str) {
for (Effect eff : values()) {
diff --git a/MCPerks/src/main/java/com/bencodez/mcperks/perk/InteractionOptions.java b/MCPerks/src/main/java/com/bencodez/mcperks/perk/InteractionOptions.java
new file mode 100644
index 0000000..fd3a340
--- /dev/null
+++ b/MCPerks/src/main/java/com/bencodez/mcperks/perk/InteractionOptions.java
@@ -0,0 +1,27 @@
+package com.bencodez.mcperks.perk;
+import java.util.List;
+import org.bukkit.configuration.file.FileConfiguration;
+/** Immutable options captured at perk load, never fetched from disk by a gameplay listener. */
+public record InteractionOptions(boolean charged, boolean banked, int veinBlocks, int veinDistance, List veinMaterials,
+ List veinTools, List crops, List precisionTargets) {
+ public InteractionOptions {
+ veinMaterials = List.copyOf(veinMaterials); veinTools = List.copyOf(veinTools);
+ crops = List.copyOf(crops); precisionTargets = List.copyOf(precisionTargets);
+ for (String target : precisionTargets) {
+ Effect effect = java.util.Arrays.stream(Effect.values()).filter(candidate -> candidate.name().equalsIgnoreCase(target))
+ .findFirst().orElseThrow(() -> new IllegalArgumentException("Unknown PrecisionMode target: " + target));
+ if (java.util.Set.of(Effect.Fly, Effect.DoubleJump, Effect.DoubleJumpUp, Effect.Potions, Effect.TempPermission,
+ Effect.IncreaseMaxHealth, Effect.IncreaseStrength, Effect.IncreaseLuck, Effect.MoveSpeed,
+ Effect.Commands, Effect.GlobalCommands, Effect.Rewards, Effect.CureHunger, Effect.CureSpells, Effect.HealAll,
+ Effect.RandomToolRepair, Effect.ToolRepair, Effect.ArmorRepair, Effect.RandomArmorRepair, Effect.AllRepair, Effect.RandomAllRepair, Effect.PrecisionMode).contains(effect))
+ throw new IllegalArgumentException("PrecisionMode target is not an action effect: " + target);
+ }
+ }
+ public static InteractionOptions read(FileConfiguration config) {
+ return new InteractionOptions(config.getBoolean("UsageCharges.Enabled", false), config.getBoolean("BankedTime.Enabled", false),
+ Math.max(1, Math.min(64, config.getInt("VeinMining.MaxBlocks", 16))),
+ Math.max(1, Math.min(16, config.getInt("VeinMining.MaxDistance", 8))),
+ config.getStringList("VeinMining.Materials"), config.getStringList("VeinMining.Tools"),
+ config.getStringList("RightClickHarvest.Crops"), config.getStringList("PrecisionMode.TargetEffects"));
+ }
+}
diff --git a/MCPerks/src/main/java/com/bencodez/mcperks/perk/Perk.java b/MCPerks/src/main/java/com/bencodez/mcperks/perk/Perk.java
index ec83550..32c8682 100644
--- a/MCPerks/src/main/java/com/bencodez/mcperks/perk/Perk.java
+++ b/MCPerks/src/main/java/com/bencodez/mcperks/perk/Perk.java
@@ -76,7 +76,7 @@ public class Perk {
private boolean active;
- private long experation;
+ private volatile long experation;
private ArrayList specialDrops;
@@ -143,8 +143,11 @@ public class Perk {
@Getter
private boolean clearModifiers;
+ @Getter private InteractionOptions interactionOptions;
+
public Perk(Perk perk) {
this.perk = perk.perk;
+ interactionOptions = perk.interactionOptions;
name = perk.name;
description = perk.description;
time = perk.time;
@@ -190,6 +193,7 @@ public Perk(Perk perk) {
*/
public Perk(String perk) {
this.perk = perk;
+ interactionOptions = InteractionOptions.read(ConfigPerks.getInstance().getData(perk));
setPriority(ConfigPerks.getInstance().getPerkPriority(perk));
name = ConfigPerks.getInstance().getPerkName(perk);
description = ConfigPerks.getInstance().getPerkDescription(perk).replace("%TimeLasts%", "" + getTime());
@@ -380,6 +384,7 @@ public Perk clone() {
}
public synchronized void deactivatePerk(MCPerksUser user) {
+ if (plugin.getBankedPerks() != null && plugin.getBankedPerks().deactivate(this)) return;
setExperation(user, 0);
setActive(false);
// Main.plugin.getEffectHandler().deactivate(this);
@@ -429,16 +434,34 @@ public void run() {
}
- public void execute(MCPerksUser user, int length) {
- user.setPerkCoolDown(this, MiscUtils.getInstance().addSeconds(new Date(), getCoolDown()).getTime());
- if (getServerWideCoolDown() > 0) {
- setServerCoolDownTime(MiscUtils.getInstance().addSeconds(new Date(), getServerWideCoolDown()).getTime());
- }
- activatePerk(user, length);
- }
+ public void execute(MCPerksUser user, int length) {
+ executeConfirmed(user, length).exceptionally(error -> { plugin.getLogger().warning("Perk execution could not be confirmed: " + getPerk()); return null; });
+ }
+ public java.util.concurrent.CompletableFuture executeConfirmed(MCPerksUser user, int length) {
+ if (!plugin.getMcperksServerData().isReady()) return java.util.concurrent.CompletableFuture.failedFuture(new IllegalStateException("ServerData initialization unavailable"));
+ if (getInteractionOptions().banked()) return plugin.getBankedPerks().grantConfirmed(user, this, length)
+ .thenCompose(ignored -> confirmCooldown(user));
+ return plugin.getMcperksServerData().confirmedActivation(() -> {
+ recordCooldown(user);
+ activatePerk(user, length);
+ }).thenCompose(ignored -> com.bencodez.mcperks.userapi.UserStorageConfirmation.confirm(plugin, user));
+ }
+ public java.util.concurrent.CompletableFuture executePublishedBank(MCPerksUser user) {
+ return plugin.getMcperksServerData().confirmedActivation(() -> recordCooldown(user))
+ .thenCompose(ignored -> plugin.getBankedPerks().grantedConfirmed(user, this))
+ .thenCompose(ignored -> com.bencodez.mcperks.userapi.UserStorageConfirmation.confirm(plugin, user));
+ }
+ private java.util.concurrent.CompletableFuture confirmCooldown(MCPerksUser user) {
+ return plugin.getMcperksServerData().confirmedActivation(() -> recordCooldown(user))
+ .thenCompose(ignored -> com.bencodez.mcperks.userapi.UserStorageConfirmation.confirm(plugin, user));
+ }
+ private void recordCooldown(MCPerksUser user) {
+ user.setPerkCoolDown(this, MiscUtils.getInstance().addSeconds(new Date(), getCoolDown()).getTime());
+ if (getServerWideCoolDown() > 0) setServerCoolDownTime(MiscUtils.getInstance().addSeconds(new Date(), getServerWideCoolDown()).getTime());
+ }
public void setServerCoolDownTime(long time) {
- MCPerksMain.plugin.getMcperksServerData().getData().set(getPerk() + ".CoolDown", time);
+ MCPerksMain.plugin.getMcperksServerData().setServerCooldown(getPerk(), time);
}
public void forcePerk(String name) {
@@ -507,6 +530,9 @@ public ArrayList getEffects() {
return effects;
}
+ /** Last expiration published with the active grant; reading does not touch user storage. */
+ public long getKnownExpiration() { return experation; }
+
public long getExperation(MCPerksUser user) {
if (getPerkType().equals(PerkSystemType.ALL)) {
experation = MCPerksMain.plugin.getMcperksServerData().getPerkExperation(this);
@@ -748,20 +774,40 @@ public boolean isNotInDisabledWorld(String world) {
}
public void runPerk(MCPerksUser user) {
-
- if (user.isInWorld(disabledWorlds)) {
+ boolean banked = getInteractionOptions().banked();
+ var controller = banked ? plugin.getBankedPerks() : null;
+ if (banked && !controller.beginDirect(this)) {
+ user.sendMessage("&cA bank grant for this perk is still being confirmed; no activation consumed."); return;
+ }
+ boolean handedOff = false;
+ try { handedOff = runPerkAdmitted(user, controller); }
+ finally { if (banked && !handedOff) controller.finishDirect(this); }
+ }
+
+ private boolean runPerkAdmitted(MCPerksUser user, BankedPerks controller) {
+ if (!plugin.getMcperksServerData().isReady() || !plugin.getPerkHandler().isRestorationReady()) {
+ user.sendMessage("&cPerk runtime state is unavailable; no activation consumed."); return false;
+ }
+ if ((plugin.getConfigFile().getPerkQue() || plugin.getConfigFile().getLimitActivations() || getInteractionOptions().banked()) && !plugin.getFeatureState().available()) {
+ user.sendMessage("&cPerk entitlement state is unavailable; no activation consumed."); return false;
+ }
+
+ if (getInteractionOptions().banked() && (!BankedPerks.supported(this) || getTime() <= 0)) {
+ user.sendMessage("&cThis perk is not supported in banked mode; no activation consumed."); return false;
+ }
+ if (user.isInWorld(disabledWorlds)) {
user.sendMessage(Lang.getInstance().getDisabledWorlds());
- return;
+ return false;
}
- if (isPerkActive(user) && !plugin.getConfigFile().getAllowDuplicatePerksActive()) {
+ if ((isPerkActive(user) || getInteractionOptions().banked() && plugin.getBankedPerks().hasEntitlement(UUID.fromString(user.getUUID()), this)) && !plugin.getConfigFile().getAllowDuplicatePerksActive()) {
user.sendMessage(ConfigPerks.getInstance().getPerkAlreayActive(perk));
- return;
+ return false;
}
if (!checkTimesUsed(user)) {
user.sendMessage(ConfigPerks.getInstance().getPerkLimitReached(perk));
- return;
+ return false;
}
long coolDownTime = user.getPerkCoolDown(plugin.getPerkHandler().getPerk(perk));
@@ -777,47 +823,70 @@ public void runPerk(MCPerksUser user) {
if (!checkCoolDown(user)) {
user.sendMessage(ConfigPerks.getInstance().getPerkInCoolDown(perk), "cooldown", coolDown);
- return;
+ return false;
}
if (!checkServerWideCoolDown(user)) {
user.sendMessage(ConfigPerks.getInstance().getPerkInCoolDown(perk), "cooldown", coolDown);
- return;
+ return false;
}
if (plugin.getConfigFile().getLimitPermission()) {
if (user.getPerkLimit() != -1) {
if (user.getActivePerks() + 1 > user.getPerkLimit()) {
user.sendMessage(ConfigPerks.getInstance().getPerkLimitReached(perk));
- return;
+ return false;
}
}
}
- boolean globalActivation = true;
-
- if (plugin.getConfigFile().getLimitActivations()) {
- boolean passed = false;
-
- if (user.getActivations(getPerk()) > 0) {
- globalActivation = false;
- passed = true;
- user.addActivation(getPerk(), -1);
- }
-
- if (user.getActivations() > 0) {
- globalActivation = true;
- passed = true;
- user.addActivation(-1);
- }
-
- if (!passed) {
- user.sendMessage(ConfigPerks.getInstance().getPerkLimitReached(perk));
- return;
- }
- }
-
- runPerkPerk(user, globalActivation);
+ if (getInteractionOptions().banked() && plugin.getConfigFile().getLimitActivations()) {
+ plugin.getPerkHandler().addQue(user, this); return false;
+ }
+ if (plugin.getConfigFile().getPerkQue() && (!plugin.getPerkHandler().getActivePerks().isEmpty() || plugin.getFeatureState().paused()
+ || !plugin.getFeatureState().queue().isEmpty() || plugin.getQueuePlanner().isStarting() || plugin.getQueuePlanner().hasAdmissions() || plugin.getQueuePlanner().hasDirectStart())) {
+ plugin.getPerkHandler().addQue(user, this); return false;
+ }
+ java.util.UUID directOwner = java.util.UUID.fromString(user.getUUID());
+ boolean queueOwned = plugin.getConfigFile().getPerkQue();
+ if (queueOwned && !plugin.getQueuePlanner().beginDirect(directOwner, this)) {
+ plugin.getPerkHandler().addQue(user, this); return false;
+ }
+ boolean globalActivation = true;
+ try { if (plugin.getConfigFile().getLimitActivations()) {
+ java.util.UUID owner = java.util.UUID.fromString(user.getUUID());
+ if (user.getActivations(getPerk()) - plugin.getFeatureState().reserved(owner, "PerkActivations_" + getPerk()) > 0) {
+ globalActivation = false; user.addActivation(getPerk(), -1);
+ } else if (user.getActivations() - plugin.getFeatureState().reserved(owner, "Activations") > 0) {
+ user.addActivation(-1);
+ } else {
+ if (queueOwned) plugin.getQueuePlanner().finishDirect(directOwner, this);
+ user.sendMessage(ConfigPerks.getInstance().getPerkLimitReached(perk)); return false;
+ }
+ } } catch (RuntimeException failure) {
+ if (queueOwned) plugin.getQueuePlanner().finishDirect(directOwner, this);
+ throw failure;
+ }
+
+ if (getInteractionOptions().banked()) {
+ try {
+ executeConfirmed(user, getTime()).whenComplete((ignored, error) -> {
+ controller.finishDirect(this);
+ if (queueOwned) plugin.getQueuePlanner().finishDirect(directOwner, this);
+ if (error != null) plugin.getLogger().warning("Bank grant could not be confirmed: " + getPerk());
+ });
+ } catch (RuntimeException failure) {
+ if (queueOwned) plugin.getQueuePlanner().finishDirect(directOwner, this);
+ throw failure;
+ }
+ return true;
+ }
+ if (queueOwned) {
+ try {
+ executeConfirmed(user, getTime()).whenComplete((ignored, error) -> plugin.getQueuePlanner().finishDirect(directOwner, this));
+ } catch (RuntimeException failure) { plugin.getQueuePlanner().finishDirect(directOwner, this); throw failure; }
+ } else runPerkPerk(user, globalActivation);
+ return false;
}
diff --git a/MCPerks/src/main/java/com/bencodez/mcperks/perk/PerkHandler.java b/MCPerks/src/main/java/com/bencodez/mcperks/perk/PerkHandler.java
index a12c7b1..a9a315c 100644
--- a/MCPerks/src/main/java/com/bencodez/mcperks/perk/PerkHandler.java
+++ b/MCPerks/src/main/java/com/bencodez/mcperks/perk/PerkHandler.java
@@ -63,7 +63,9 @@ public class PerkHandler {
/** The main. */
private MCPerksMain plugin;
- private Timer timer = new Timer();
+ private Timer timer = new Timer();
+ private volatile java.util.concurrent.CompletableFuture restoration = new java.util.concurrent.CompletableFuture<>();
+ public boolean isRestorationReady() { var current = restoration; return current.isDone() && !current.isCompletedExceptionally(); }
public Map invPerks = new HashMap();
@@ -84,14 +86,19 @@ public PerkHandler(MCPerksMain plugin) {
e.printStackTrace();
}
}
- loadEnabledPerks(true);
+ loadEnabledPerks(false);
if (plugin.getConfigFile().getLogActivation()) {
activationLog = new Logger(plugin, new File(plugin.getDataFolder(), "ActivationLog.txt"));
}
}
+ PerkHandler(MCPerksMain plugin, List initial) {
+ this.plugin = plugin; activePerks.addAll(initial); restoration.complete(null);
+ }
+
public void activePerk(Perk perk, MCPerksUser user, int length, Timestamp timestamp) {
final Perk clone = perk.clone();
+ plugin.getLocalStatistics().activation();
clone.setActivater(user);
clone.getEffectedPlayers().clear();
ArrayList times = new ArrayList();
@@ -441,16 +448,17 @@ public void run() {
{
String str = new SimpleDateFormat("EEE, d MMM yyyy HH:mm").format(Calendar.getInstance().getTime());
- activationLog
- .logToFile(str + " Activated perk " + perk.getName() + " by " + clone.getActivater().getPlayerName()
- + ". Affected users: " + ArrayUtils.makeStringList(clone.getEffectedPlayers())
- + ". Lasted for " + length + " Perk type: " + clone.getPerkType().toString());
+ String message = str + " Activated perk " + perk.getName() + " by " + clone.getActivater().getPlayerName()
+ + ". Affected users: " + ArrayUtils.makeStringList(clone.getEffectedPlayers())
+ + ". Lasted for " + length + " Perk type: " + clone.getPerkType().toString();
+ Logger writer = activationLog;
+ plugin.getMcperksServerData().activationLog(() -> writer.logToFile(message));
}
}
public void addQue(MCPerksUser user, Perk perk) {
- que.put(user, perk);
- }
+ plugin.getQueuePlanner().enqueue(user, perk);
+ }
/**
* Adds the to list.
@@ -462,20 +470,13 @@ private void addToList(String key, Perk p) {
loadedPerks.put(key, p);
}
- public void checkQue() {
- if (!que.isEmpty() && activePerks.size() == 0) {
- for (Entry entry : que.entrySet()) {
- entry.getValue().runPerk(entry.getKey());
- que.remove(entry.getKey());
- return;
- }
+ public void checkQue() { plugin.getQueuePlanner().check(); }
- }
- }
-
- public void clearQueue() {
- que.clear();
- }
+ public void clearQueue() { clearQueueConfirmed(); }
+ /** Completion means the waiting entries were durably removed; legacy void API remains additive. */
+ public java.util.concurrent.CompletableFuture clearQueueConfirmed() {
+ return plugin.getFeatureState().clearWaiting().thenRun(() -> plugin.getQueuePlanner().refreshLegacyView());
+ }
public void copyPerks() throws IOException {
File file = new File(plugin.getDataFolder(), "Perks");
@@ -512,27 +513,50 @@ public void copyPerks() throws IOException {
}
}
- public boolean effectActive(Effect effect, String uuid, String world) {
- ListIterator it = activePerks.listIterator();
- while (it.hasNext()) {
- Perk perk = it.next();
- if (perk.getEffects().contains(effect)) {
- if (uuid == null || perk.getEffectedPlayers().contains(uuid)) {
- // plugin.debug("Effect active, " + effect.toString() + " for " + uuid);
- if (perk.isNotInDisabledWorld(world)) {
- return true;
- }
- }
- }
- }
- return false;
- }
-
- public double effectActiveModifier(Effect effect, String uuid, int defaultValue, String world) {
+ private final java.util.concurrent.ConcurrentHashMap precisionSneaking = new java.util.concurrent.ConcurrentHashMap<>();
+ public void setPrecisionSneaking(UUID owner, boolean sneaking) {
+ if (sneaking) precisionSneaking.put(owner, true); else precisionSneaking.remove(owner);
+ }
+ private boolean precisionSuppresses(Effect effect, String uuid, String world) {
+ if (uuid == null || !precisionSneaking.containsKey(UUID.fromString(uuid)) || effect == Effect.PrecisionMode) return false;
+ for (Perk perk : activePerks) {
+ if (!perk.getEffects().contains(Effect.PrecisionMode) || !perk.getEffectedPlayers().contains(uuid) || !perk.isNotInDisabledWorld(world)
+ || (plugin.getBankedPerks() != null && !plugin.getBankedPerks().available(perk))) continue;
+ List targets = perk.getInteractionOptions().precisionTargets();
+ if (targets.isEmpty()) {
+ if (effect == Effect.AutoBlockRefill || effect == Effect.VeinMining || effect == Effect.RightClickHarvest) return true;
+ } else if (targets.stream().anyMatch(target -> effect.name().equalsIgnoreCase(target))) return true;
+ }
+ return false;
+ }
+
+ public boolean effectAllowed(Perk perk, Effect effect, String uuid, String world) {
+ return (uuid == null || perk.getEffectedPlayers().contains(uuid))
+ && perk.isNotInDisabledWorld(world) && !precisionSuppresses(effect, uuid, world)
+ && (plugin.getBankedPerks() == null || plugin.getBankedPerks().available(perk));
+ }
+
+ public enum Decision { ACTIVE, INACTIVE, OUTSIDE_AUDIENCE, DISABLED_WORLD, PRECISION_SUPPRESSED, BANKED_PAUSED }
+ public Decision effectDecision(Effect effect, String uuid, String world) {
+ if (precisionSuppresses(effect, uuid, world)) return Decision.PRECISION_SUPPRESSED;
+ Decision decision = Decision.INACTIVE;
+ for (Perk perk : activePerks) {
+ if (!perk.getEffects().contains(effect)) continue;
+ if (uuid != null && !perk.getEffectedPlayers().contains(uuid)) { decision = Decision.OUTSIDE_AUDIENCE; continue; }
+ if (!perk.isNotInDisabledWorld(world)) { decision = Decision.DISABLED_WORLD; continue; }
+ if (plugin.getBankedPerks() != null && !plugin.getBankedPerks().available(perk)) { decision = Decision.BANKED_PAUSED; continue; }
+ return Decision.ACTIVE;
+ }
+ return decision;
+ }
+ public boolean effectActive(Effect effect, String uuid, String world) { return effectDecision(effect, uuid, world) == Decision.ACTIVE; }
+
+ public double effectActiveModifier(Effect effect, String uuid, int defaultValue, String world) {
+ if (precisionSuppresses(effect, uuid, world)) return defaultValue;
ListIterator it = activePerks.listIterator();
while (it.hasNext()) {
Perk perk = it.next();
- if (perk.getEffects().contains(effect)) {
+ if (perk.getEffects().contains(effect) && (plugin.getBankedPerks() == null || plugin.getBankedPerks().available(perk))) {
if (uuid == null || perk.getEffectedPlayers().contains(uuid)) {
// plugin.debug("Effect active, " + effect.toString() + " for " + uuid);
@@ -587,32 +611,43 @@ public Perk getActivePerk(MCPerksUser user, Perk p) {
return p;
}
- public void loadActivePerks() {
- Bukkit.getScheduler().runTaskAsynchronously(plugin, new Runnable() {
-
- @Override
- public void run() {
- ArrayList users = new ArrayList();
- for (String uuid : plugin.getUserManager().getAllUUIDs()) {
- MCPerksUser user = plugin.getMcperksUserManager().getMCPerksUser(UUID.fromString(uuid));
- user.userDataFetechMode(UserDataFetchMode.NO_CACHE);
- users.add(user);
- }
- for (Perk perk : getLoadedPerks().values()) {
- for (MCPerksUser user : users) {
- user.userDataFetechMode(UserDataFetchMode.NO_CACHE);
- if (perk.getExperation(user) < 0) {
- perk.activatePerk(user, perk.getTime());
- } else {
- perk.scheduleDeactivation(user);
- }
-
- }
- }
- }
- });
- }
-
+ public void loadActivePerks() { loadActivePerksConfirmed(() -> {}); }
+
+ /** Completes only after legacy active state and the caller's shutdown records are restored. */
+ public synchronized java.util.concurrent.CompletableFuture loadActivePerksConfirmed(Runnable shutdownRecords) {
+ var completed = new java.util.concurrent.CompletableFuture();
+ restoration = completed;
+ try {
+ plugin.getBukkitScheduler().runTaskAsynchronously(plugin, () -> {
+ try {
+ requireCurrentRestoration(completed);
+ var users = new ArrayList();
+ for (String uuid : plugin.getUserManager().getAllUUIDs()) {
+ requireCurrentRestoration(completed);
+ MCPerksUser user = plugin.getMcperksUserManager().getMCPerksUser(UUID.fromString(uuid));
+ user.userDataFetechMode(UserDataFetchMode.NO_CACHE); users.add(user);
+ }
+ for (Perk perk : List.copyOf(getLoadedPerks().values())) {
+ for (MCPerksUser user : users) {
+ requireCurrentRestoration(completed);
+ user.userDataFetechMode(UserDataFetchMode.NO_CACHE);
+ if (perk.getExperation(user) < 0) perk.activatePerk(user, perk.getTime());
+ else perk.scheduleDeactivation(user);
+ }
+ }
+ requireCurrentRestoration(completed);
+ shutdownRecords.run();
+ completed.complete(null);
+ } catch (Throwable error) { completed.completeExceptionally(error); }
+ });
+ } catch (RuntimeException error) { completed.completeExceptionally(error); }
+ return completed;
+ }
+ private void requireCurrentRestoration(java.util.concurrent.CompletableFuture completed) {
+ if (restoration != completed || plugin.getPerkHandler() != this || !plugin.isEnabled())
+ throw new IllegalStateException("Legacy restoration lifecycle retired");
+ }
+
/**
* Load enabled perks.
*
@@ -670,6 +705,11 @@ public void loadInvPerks() {
public void loadPerk(String perkName) {
try {
Perk perk = new Perk(perkName);
+ if (perk.getInteractionOptions().banked() && !BankedPerks.supported(perk)) plugin.getLogger().warning("Perk " + perkName + ": unsupported banked scope/effects; banked grants will be rejected");
+ if (perk.getInteractionOptions().charged()
+ && perk.getPerkType() != PerkSystemType.PLAYER) {
+ plugin.getLogger().warning("Perk " + perkName + ": usage charges require PLAYER scope; charged automation is disabled for this shared audience");
+ }
if (perk.isEnabled()) {
plugin.debug("Loading perk: " + perk.getName() + " : " + perk.getPerkType().toString() + " effects: "
+ perk.listEffects());
diff --git a/MCPerks/src/main/java/com/bencodez/mcperks/perk/QueuePlanner.java b/MCPerks/src/main/java/com/bencodez/mcperks/perk/QueuePlanner.java
new file mode 100644
index 0000000..b0d4a83
--- /dev/null
+++ b/MCPerks/src/main/java/com/bencodez/mcperks/perk/QueuePlanner.java
@@ -0,0 +1,244 @@
+package com.bencodez.mcperks.perk;
+import java.util.*;
+import java.util.concurrent.atomic.AtomicBoolean;
+import org.bukkit.Bukkit;
+import org.bukkit.entity.Player;
+import com.bencodez.mcperks.MCPerksMain;
+import com.bencodez.mcperks.data.FeatureState;
+import com.bencodez.mcperks.data.FeatureState.QueueEntry;
+import com.bencodez.mcperks.userapi.MCPerksUser;
+import com.bencodez.mcperks.scheduling.OwnerTasks;
+/** Durable start fencing around the existing perk and activation models. */
+public final class QueuePlanner {
+ private final MCPerksMain plugin;
+ private final FeatureState state;
+ private final AtomicBoolean starting = new AtomicBoolean();
+ private FeatureState.BankKey directStart, startingBank;
+ private volatile boolean retired, suspended;
+ public void suspend() { suspended = true; invalidate(); }
+ public void resume() { suspended = false; check(); }
+ private volatile int generation;
+ public void invalidate() { generation++; }
+ public QueuePlanner(MCPerksMain plugin, FeatureState state) { this.plugin = plugin; this.state = state; }
+ public void startChecks() {
+ if (!retired && plugin.isEnabled()) plugin.getBukkitScheduler().runTaskLater(plugin, () -> { try { check(); } finally { startChecks(); } }, 1);
+ }
+ public void retire() { retired = true; }
+ public boolean isStarting() { return starting.get(); }
+ public synchronized boolean hasDirectStart() { return directStart != null; }
+ public synchronized boolean beginDirect(UUID owner, Perk perk) {
+ if (retired || suspended || starting.get() || directStart != null || hasAdmissions()
+ || state.paused() || !state.queue().isEmpty() || !plugin.getPerkHandler().getActivePerks().isEmpty()) return false;
+ directStart = new FeatureState.BankKey(owner, perk.getPerk());
+ return true;
+ }
+ public void finishDirect(UUID owner, Perk perk) {
+ synchronized (this) {
+ if (Objects.equals(directStart, new FeatureState.BankKey(owner, perk.getPerk()))) directStart = null;
+ }
+ check();
+ }
+ /** Hold the existing queue fence through the actual active-list insertion. */
+ public synchronized boolean attachBank(FeatureState.BankKey key, Perk current, Runnable attach) {
+ if (plugin.getConfigFile().getPerkQue()) {
+ if (directStart != null && !directStart.equals(key) || starting.get() && !key.equals(startingBank)
+ || plugin.getPerkHandler().getActivePerks().stream().anyMatch(active -> active != current)) return false;
+ }
+ attach.run();
+ return true;
+ }
+ private record Credit(String key, int available) {}
+ private final Set admissions = java.util.concurrent.ConcurrentHashMap.newKeySet();
+ private synchronized boolean admit(UUID owner) { return !retired && admissions.size() < 256 && admissions.add(owner); }
+ public boolean hasAdmissions() { return !admissions.isEmpty(); }
+ public void enqueue(MCPerksUser user, Perk perk) {
+ UUID owner = UUID.fromString(user.getUUID());
+ if (!state.available()) { user.sendMessage("&cQueue state is unavailable; no activation consumed."); return; }
+ if (perk.getInteractionOptions().banked() && plugin.getBankedPerks().grantUnavailable(owner, perk, perk.getTime()) != null) { user.sendMessage("&cBank grant is unavailable; no activation consumed."); return; }
+ if (!admit(owner)) return;
+ state.storage(() -> {
+ if (!plugin.getConfigFile().getLimitActivations()) return new Credit("", Integer.MAX_VALUE);
+ int personal = user.getActivations(perk.getPerk());
+ if (personal - state.reserved(owner, "PerkActivations_" + perk.getPerk()) > 0) return new Credit("PerkActivations_" + perk.getPerk(), personal);
+ return new Credit("Activations", user.getActivations());
+ }).thenCompose(credit -> state.enqueue(owner, perk.getPerk(), credit.key(), credit.available())).whenComplete((entry, error) -> {
+ admissions.remove(owner);
+ reply(owner, () -> user.sendMessage(error == null ? "&aPerk queued. Entry: " + entry.id() : "&cPerk could not be queued; no activation consumed."));
+ if (error == null) { refreshLegacyView(); check(); }
+ });
+ }
+
+ public void refreshLegacyView() {
+ if (retired) return;
+ state.storage(() -> {
+ Map snapshot = new LinkedHashMap<>();
+ for (QueueEntry entry : state.queue()) {
+ Perk perk = plugin.getPerkHandler().getPerk(entry.perk());
+ if (perk != null) snapshot.put(plugin.getMcperksUserManager().getMCPerksUser(entry.owner()), perk);
+ }
+ if (!retired && plugin.isEnabled()) plugin.getBukkitScheduler().runTask(plugin, () -> {
+ synchronized (plugin.getPerkHandler().que) { plugin.getPerkHandler().que.clear(); plugin.getPerkHandler().que.putAll(snapshot); }
+ });
+ return null;
+ });
+ }
+ public void check() {
+ if (retired || suspended || !plugin.getPerkHandler().isRestorationReady() || !plugin.isEnabled() || !state.available() || state.paused() || !plugin.getPerkHandler().getActivePerks().isEmpty()) return;
+ List snapshot = state.queue();
+ synchronized (this) {
+ if (snapshot.isEmpty() || directStart != null || !plugin.getPerkHandler().getActivePerks().isEmpty() || !starting.compareAndSet(false, true)) return;
+ startingBank = new FeatureState.BankKey(snapshot.getFirst().owner(), snapshot.getFirst().perk());
+ }
+ try {
+ QueueEntry entry = snapshot.getFirst();
+ if (entry.stage() != FeatureState.Stage.WAITING) { starting.set(false); return; }
+ reply(entry.owner(), () -> prepare(entry), () -> starting.set(false));
+ // Offline players are deliberately left queued; next login/expiry checks again.
+ if (Bukkit.getPlayer(entry.owner()) == null) starting.set(false);
+ } catch (RuntimeException failure) {
+ starting.set(false);
+ throw failure;
+ }
+ }
+ private void prepare(QueueEntry entry) {
+ int version = generation;
+ Player player = Bukkit.getPlayer(entry.owner()); Perk perk = plugin.getPerkHandler().getPerk(entry.perk());
+ if (retired || suspended || player == null || perk == null || startUnavailable(entry) != null || !canStart(player, perk)) { starting.set(false); return; }
+ boolean bypassCooldown = player.hasPermission("MCPerks.Perks.BypassCoolDown");
+ java.util.concurrent.atomic.AtomicReference resolvedUser = new java.util.concurrent.atomic.AtomicReference<>();
+ state.claim(entry.id()).whenComplete((claimed, failure) -> {
+ if (failure != null || claimed == null) { starting.set(false); return; }
+ if (retired) { starting.set(false); return; }
+ state.storage(() -> {
+ if (retired || suspended || version != generation) return Confirmation.INELIGIBLE;
+ MCPerksUser user = plugin.getMcperksUserManager().getMCPerksUser(claimed.owner()); resolvedUser.set(user);
+ if (!storedEligible(user, perk, bypassCooldown, System.currentTimeMillis())) return Confirmation.INELIGIBLE;
+ if (perk.getInteractionOptions().banked()) {
+ if (plugin.getBankedPerks().grantUnavailable(claimed.owner(), perk, perk.getTime()) != null) return Confirmation.INELIGIBLE;
+ if (state.addBankOnWorker(new FeatureState.BankKey(claimed.owner(), perk.getPerk()),
+ Math.multiplyExact((long) perk.getTime(), 1000), () -> debit(claimed)) == null) return Confirmation.INELIGIBLE;
+ } else if (!debit(claimed)) return Confirmation.INELIGIBLE;
+ if (!claimed.credit().isEmpty()) {
+ // Atomic SQL commit retires the old cache. Populate its canonical successor off the owner
+ // before legacy activation reads ignore/expiration state on the game thread.
+ var manager = plugin.getUserManager().getDataManager();
+ manager.cacheUser(claimed.owner());
+ if (manager.getPublishedCache(claimed.owner()) == null) throw new IllegalStateException("Activation cache publication unavailable after debit");
+ }
+ return Confirmation.CONFIRMED;
+ }).whenComplete((confirmed, debitError) -> {
+ if (confirmed == Confirmation.INELIGIBLE) {
+ state.releaseClaim(claimed.id()).whenComplete((ignored, error) -> starting.set(false)); return;
+ }
+ if (debitError != null || confirmed != Confirmation.CONFIRMED) {
+ state.uncertain(claimed.id()); starting.set(false);
+ reply(claimed.owner(), () -> { if (resolvedUser.get() != null) resolvedUser.get().sendMessage("&cQueued start requires review: activation persistence could not be confirmed. Entry " + claimed.id()); });
+ return;
+ }
+ AtomicBoolean executed = new AtomicBoolean();
+ reply(claimed.owner(), () -> {
+ if (!executed.compareAndSet(false, true)) return;
+ try {
+ Player current = Bukkit.getPlayer(claimed.owner());
+ if (retired || suspended || version != generation || current == null || !canStart(current, perk)) { state.uncertain(claimed.id()); starting.set(false); return; }
+ (perk.getInteractionOptions().banked() ? perk.executePublishedBank(resolvedUser.get()) : perk.executeConfirmed(resolvedUser.get(), perk.getTime())).whenComplete((nothing, executionError) -> {
+ starting.set(false);
+ if (executionError != null) state.uncertain(claimed.id());
+ else { plugin.getLocalStatistics().queueStart(System.currentTimeMillis() - claimed.admitted()); state.complete(claimed.id()).whenComplete((ignored, error) -> { if (error != null) plugin.getLogger().warning("Queue completion persistence failed; start fence prevents replay"); else { refreshLegacyView(); check(); } }); }
+ });
+ } catch (Throwable uncertain) { state.uncertain(claimed.id()); starting.set(false); }
+ }, () -> { state.uncertain(claimed.id()); starting.set(false); });
+ if (Bukkit.getPlayer(claimed.owner()) == null) { state.uncertain(claimed.id()); starting.set(false); }
+ });
+ });
+ }
+ private enum Confirmation { CONFIRMED, INELIGIBLE, UNCERTAIN }
+ private boolean canStart(Player player, Perk perk) {
+ return plugin.getPerkHandler().isRestorationReady() && plugin.getPerkHandler().getActivePerks().isEmpty() && perk.isNotInDisabledWorld(player.getWorld().getName());
+ }
+ private boolean storedEligible(MCPerksUser user, Perk perk, boolean bypass, long now) {
+ if (!plugin.getMcperksServerData().isReady()) return false;
+ long cooldown = Math.max(user.getPerkCoolDown(perk), plugin.getMcperksServerData().getServerCooldown(perk.getPerk()));
+ return (bypass || cooldown <= now) && (perk.getLimit() <= 0 || user.getPerkTimesUsed(perk) < perk.getLimit());
+ }
+ /** Advisory read on the storage worker; actual consumption still uses the atomic debit. */
+ private boolean creditAvailable(QueueEntry entry) {
+ if (entry.credit().isEmpty()) return true;
+ var manager = plugin.getUserManager().getDataManager();
+ if (!manager.hasSharedRuntime()) return false;
+ boolean available = manager.withAtomicUserTransaction(entry.owner(), plugin.getStorageType(), Map.of(), transaction ->
+ transaction.readRow().stream().filter(column -> column.getName().equals(entry.credit()))
+ .findFirst().map(column -> column.getValue().getInt() > 0).orElse(false));
+ // Even read-only transactions retire the canonical cache on successful completion.
+ manager.cacheUser(entry.owner());
+ if (manager.getPublishedCache(entry.owner()) == null) throw new IllegalStateException("Activation cache publication unavailable after inspection");
+ return available;
+ }
+ private boolean debit(QueueEntry entry) {
+ if (entry.credit().isEmpty()) return true;
+ var manager = plugin.getUserManager().getDataManager();
+ // Shared runtimes expose actual transactional completion. Unsupported stores fail closed.
+ if (manager.hasSharedRuntime()) {
+ return manager.withAtomicUserTransaction(entry.owner(), plugin.getStorageType(), Map.of(), transaction -> {
+ int current = transaction.readRow().stream().filter(column -> column.getName().equals(entry.credit())).findFirst().map(column -> column.getValue().getInt()).orElse(0);
+ if (current < 1) return false;
+ transaction.writeValues(Map.of(entry.credit(), new com.bencodez.simpleapi.sql.data.DataValueInt(current - 1)));
+ return true;
+ });
+ }
+ throw new IllegalStateException("Transactional activation ownership unavailable");
+ }
+ public String startUnavailable(QueueEntry entry) {
+ if (!state.available()) return "feature storage unavailable";
+ if (!plugin.getPerkHandler().isRestorationReady()) return "legacy perk restoration unavailable";
+ if (!entry.credit().isEmpty() && !plugin.getUserManager().getDataManager().hasSharedRuntime()) return "transactional activation storage unavailable";
+ Perk perk = plugin.getPerkHandler().getPerk(entry.perk());
+ if (perk == null) return "perk definition unavailable";
+ if (perk.getInteractionOptions().banked()) return plugin.getBankedPerks().grantUnavailable(entry.owner(), perk, perk.getTime());
+ return null;
+ }
+ /** Estimated waits only when every predecessor has a finite absolute duration and known eligibility. */
+ public java.util.concurrent.CompletableFuture> estimatedWaits() {
+ List entries = state.queue().stream().limit(32).toList();
+ List active = List.copyOf(plugin.getPerkHandler().getActivePerks());
+ long now = System.currentTimeMillis(), initial = 0;
+ if (!plugin.getPerkHandler().isRestorationReady() || !state.available() || state.paused() || starting.get()) return java.util.concurrent.CompletableFuture.completedFuture(Map.of());
+ for (Perk perk : active) {
+ if (perk.getInteractionOptions().banked() || perk.isLastForever() || perk.getKnownExpiration() <= 0) return java.util.concurrent.CompletableFuture.completedFuture(Map.of());
+ initial = Math.max(initial, Math.max(0, perk.getKnownExpiration() - now));
+ }
+ List> checks = new ArrayList<>();
+ for (QueueEntry entry : entries) {
+ var eligible = new java.util.concurrent.CompletableFuture(); checks.add(eligible);
+ Perk perk = plugin.getPerkHandler().getPerk(entry.perk());
+ if (entry.stage() != FeatureState.Stage.WAITING || startUnavailable(entry) != null || perk == null || perk.getInteractionOptions().banked() || perk.getTime() <= 0) { eligible.complete(false); continue; }
+ Player player = Bukkit.getPlayer(entry.owner());
+ OwnerTasks.run(plugin, player, () -> {
+ boolean world = perk.isNotInDisabledWorld(player.getWorld().getName());
+ boolean bypass = player.hasPermission("MCPerks.Perks.BypassCoolDown");
+ // Starts wait until every active perk ends; the existing positive per-player cap then permits one start.
+ if (!world) { eligible.complete(false); return; }
+ state.storage(() -> {
+ var user = plugin.getMcperksUserManager().getMCPerksUser(entry.owner());
+ return storedEligible(user, perk, bypass, now) && creditAvailable(entry);
+ }).whenComplete((value, error) -> eligible.complete(error == null && Boolean.TRUE.equals(value)));
+ }, () -> eligible.complete(false));
+ }
+ long base = initial;
+ return java.util.concurrent.CompletableFuture.allOf(checks.toArray(java.util.concurrent.CompletableFuture[]::new)).thenApply(ignored -> {
+ if (!state.available() || state.paused() || !state.queue().stream().limit(32).toList().equals(entries) || !List.copyOf(plugin.getPerkHandler().getActivePerks()).equals(active)) return Map.of();
+ Map result = new HashMap<>(); long wait = base;
+ for (int i = 0; i < entries.size(); i++) {
+ if (!checks.get(i).join()) break;
+ result.put(entries.get(i).id(), wait / 1000);
+ wait += (long) plugin.getPerkHandler().getPerk(entries.get(i).perk()).getTime() * 1000;
+ }
+ return Map.copyOf(result);
+ });
+ }
+ private void reply(UUID owner, Runnable task) { reply(owner, task, () -> {}); }
+ private void reply(UUID owner, Runnable task, Runnable dropped) {
+ if (retired || !plugin.isEnabled()) { dropped.run(); return; }
+ OwnerTasks.run(plugin, Bukkit.getPlayer(owner), task, dropped);
+ }
+}
diff --git a/MCPerks/src/main/java/com/bencodez/mcperks/scheduling/OwnerTasks.java b/MCPerks/src/main/java/com/bencodez/mcperks/scheduling/OwnerTasks.java
new file mode 100644
index 0000000..24db288
--- /dev/null
+++ b/MCPerks/src/main/java/com/bencodez/mcperks/scheduling/OwnerTasks.java
@@ -0,0 +1,41 @@
+package com.bencodez.mcperks.scheduling;
+
+import java.util.concurrent.atomic.AtomicBoolean;
+import org.bukkit.entity.Player;
+import com.bencodez.mcperks.MCPerksMain;
+import com.bencodez.simpleapi.folialib.enums.EntityTaskResult;
+
+/** Retired/rejected entity tasks complete their admission without touching game state. */
+public final class OwnerTasks {
+ private OwnerTasks() {}
+ public static void run(MCPerksMain plugin, Player player, Runnable action, Runnable retired) {
+ AtomicBoolean decided = new AtomicBoolean();
+ Runnable unavailable = () -> { if (decided.compareAndSet(false, true)) retired.run(); };
+ if (!plugin.isEnabled() || player == null) { unavailable.run(); return; }
+ try {
+ plugin.getBukkitScheduler().getFoliaLib().getImpl().runAtEntityWithFallback(player,
+ task -> { if (decided.compareAndSet(false, true)) action.run(); }, unavailable)
+ .whenComplete((result, error) -> { if (error != null || result != EntityTaskResult.SUCCESS) unavailable.run(); });
+ } catch (RuntimeException failure) { unavailable.run(); }
+ }
+ public static void later(MCPerksMain plugin, Player player, Runnable action, Runnable retired, long ticks) {
+ AtomicBoolean decided = new AtomicBoolean();
+ Runnable unavailable = () -> { if (decided.compareAndSet(false, true)) retired.run(); };
+ if (!plugin.isEnabled() || player == null) { unavailable.run(); return; }
+ try {
+ var folia = plugin.getBukkitScheduler().getFoliaLib();
+ Runnable onOwner = () -> {
+ if (!plugin.isEnabled() || !player.isValid()) { unavailable.run(); return; }
+ if (decided.compareAndSet(false, true)) action.run();
+ };
+ // The bundled Spigot implementation's entity-delay overloads recurse (Paper inherits
+ // them). Its synchronous runLater uses Bukkit runTaskLater; check retirement there,
+ // on the server owner. Folia must retain the moving entity's scheduler and fallback.
+ var task = folia.isFolia()
+ ? folia.getImpl().runAtEntityLater(player, onOwner, unavailable, ticks)
+ : folia.getImpl().runLater(onOwner, ticks);
+ if (task == null) unavailable.run();
+ } catch (RuntimeException failure) { unavailable.run(); }
+ }
+
+}
diff --git a/MCPerks/src/main/java/com/bencodez/mcperks/userapi/UsageCharges.java b/MCPerks/src/main/java/com/bencodez/mcperks/userapi/UsageCharges.java
new file mode 100644
index 0000000..1057d63
--- /dev/null
+++ b/MCPerks/src/main/java/com/bencodez/mcperks/userapi/UsageCharges.java
@@ -0,0 +1,198 @@
+package com.bencodez.mcperks.userapi;
+
+import java.io.*;
+import java.nio.file.*;
+import java.util.*;
+import java.util.concurrent.*;
+import java.util.function.Supplier;
+
+/** Ordered durable personal charge ledger. No Bukkit or SQL access occurs on its worker. */
+public final class UsageCharges implements AutoCloseable {
+ public enum Kind { AutoBlockRefill, VeinMining, RightClickHarvest }
+ public record Reservation(UUID id, UUID owner, Kind kind, int units) {}
+ private record Account(int[] remaining, long[] successful) {
+ Account copy() { return new Account(remaining.clone(), successful.clone()); }
+ }
+ private static final int MAX_ACCOUNTS = 10000, MAX_RESERVATIONS = 256, MAX_ORDINARY_OPERATIONS = 257, MAGIC = 0x4d435031;
+ private final Path file;
+ private final com.bencodez.mcperks.data.DurableFeatureFiles.Publisher publisher;
+ private final com.bencodez.mcperks.data.FeatureFileOwnership ownership;
+ private final ThreadPoolExecutor worker;
+ private volatile Map accounts = Map.of();
+ private volatile Map reservations = Map.of();
+ // Keep the existing ordinary queue budget (one running + 256 waiting). Existing
+ // durable identities each own a separate settlement slot on the same worker.
+ private final Semaphore ordinarySlots = new Semaphore(MAX_ORDINARY_OPERATIONS);
+ private final Map> settlements = new HashMap<>();
+ private volatile boolean failed;
+ private final CompletableFuture ready;
+
+ public UsageCharges(Path file) { this(file, com.bencodez.mcperks.data.DurableFeatureFiles::publish); }
+ UsageCharges(Path file, com.bencodez.mcperks.data.DurableFeatureFiles.Publisher publisher) {
+ this.file = file; this.publisher = publisher;
+ ownership = new com.bencodez.mcperks.data.FeatureFileOwnership(file);
+ worker = new ThreadPoolExecutor(1, 1, 0, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<>(MAX_ORDINARY_OPERATIONS + MAX_RESERVATIONS - 1), r -> {
+ Thread t = new Thread(r, "MCPerks-charge-store"); t.setDaemon(true); return t;
+ }, new ThreadPoolExecutor.AbortPolicy()) {
+ @Override protected void terminated() { ownership.drained(); }
+ };
+ ready = submit(() -> {
+ try { ownership.awaitPredecessor(); }
+ catch (RuntimeException | Error failure) { failed = true; throw failure; }
+ read(); return null;
+ });
+ }
+ public CompletableFuture ready() { return ready; }
+ public boolean available() { return ready.isDone() && !ready.isCompletedExceptionally() && !failed; }
+ public int get(UUID owner, Kind kind) {
+ Account account = accounts.get(owner); return account == null ? 0 : account.remaining[kind.ordinal()];
+ }
+ public long successful(UUID owner, Kind kind) {
+ Account account = accounts.get(owner); return account == null ? 0 : account.successful[kind.ordinal()];
+ }
+ public CompletableFuture set(UUID owner, Kind kind, int amount) {
+ if (amount < 0) return CompletableFuture.failedFuture(new IllegalArgumentException("Negative charge balance"));
+ return mutate(owner, kind, amount, false);
+ }
+ public CompletableFuture add(UUID owner, Kind kind, int amount) {
+ if (amount < 0) return CompletableFuture.failedFuture(new IllegalArgumentException("Negative charge amount"));
+ return mutate(owner, kind, amount, true);
+ }
+ private CompletableFuture mutate(UUID owner, Kind kind, int amount, boolean add) {
+ return submit(() -> {
+ Map next = copyAccounts(); Account a = account(next, owner);
+ a.remaining[kind.ordinal()] = add ? (int) Math.min(Integer.MAX_VALUE,
+ (long) a.remaining[kind.ordinal()] + amount) : amount;
+ publish(next, reservations); return a.remaining[kind.ordinal()];
+ });
+ }
+ /** Reserves up to the available budget, durably, before any irreversible effect. */
+ public CompletableFuture reserve(UUID owner, Kind kind, int requested) {
+ if (requested < 1 || requested > 64) return CompletableFuture.failedFuture(new IllegalArgumentException("Invalid budget"));
+ return submit(() -> {
+ if (reservations.size() >= MAX_RESERVATIONS) throw new IllegalStateException("Charge reservation capacity reached");
+ int units = Math.min(get(owner, kind), requested);
+ if (units == 0) return null;
+ Map next = copyAccounts(); Account a = account(next, owner);
+ a.remaining[kind.ordinal()] -= units;
+ Reservation reservation = new Reservation(UUID.randomUUID(), owner, kind, units);
+ Map pending = new HashMap<>(reservations); pending.put(reservation.id(), reservation);
+ publish(next, pending); return reservation;
+ });
+ }
+ /** Refund only units proved not to have had an effect. Uncertain units stay spent. */
+ public CompletableFuture finish(Reservation reservation, int successful, int unused) {
+ if (reservation == null || successful < 0 || unused < 0 || (long) successful + unused > reservation.units())
+ return CompletableFuture.failedFuture(new IllegalArgumentException("Invalid completion"));
+ synchronized (settlements) {
+ CompletableFuture existing = settlements.get(reservation.id());
+ // Only an exact live durable token can admit settlement. Duplicate callbacks
+ // share the first completion rather than occupying another queue/waiter slot.
+ if (!reservation.equals(reservations.get(reservation.id()))) return CompletableFuture.completedFuture(null);
+ if (existing != null) return existing;
+ CompletableFuture future = new CompletableFuture<>();
+ settlements.put(reservation.id(), future);
+ try { worker.execute(() -> {
+ try {
+ if (failed) throw new IllegalStateException("Charge store unavailable until restart");
+ if (reservation.equals(reservations.get(reservation.id()))) {
+ Map next = copyAccounts(); Account a = account(next, reservation.owner());
+ int index = reservation.kind().ordinal();
+ a.remaining[index] = (int) Math.min(Integer.MAX_VALUE, (long) a.remaining[index] + unused);
+ a.successful[index] = saturatingAdd(a.successful[index], successful);
+ Map pending = new HashMap<>(reservations); pending.remove(reservation.id());
+ publish(next, pending);
+ }
+ future.complete(null);
+ } catch (Throwable error) { future.completeExceptionally(error); }
+ finally { synchronized (settlements) { settlements.remove(reservation.id(), future); } }
+ }); } catch (RejectedExecutionException error) {
+ settlements.remove(reservation.id(), future); future.completeExceptionally(error);
+ }
+ return future;
+ }
+ }
+ public CompletableFuture record(UUID owner, Kind kind, int successful) {
+ if (successful < 0 || successful > 64) return CompletableFuture.failedFuture(new IllegalArgumentException("Invalid count"));
+ if (successful == 0) return CompletableFuture.completedFuture(null);
+ return submit(() -> {
+ Map next = copyAccounts(); Account a = account(next, owner);
+ a.successful[kind.ordinal()] = saturatingAdd(a.successful[kind.ordinal()], successful);
+ publish(next, reservations); return null;
+ });
+ }
+ private static long saturatingAdd(long old, int amount) { return old > Long.MAX_VALUE - amount ? Long.MAX_VALUE : old + amount; }
+ private Account account(Map next, UUID owner) {
+ Account a = next.get(Objects.requireNonNull(owner));
+ if (a == null) {
+ if (next.size() >= MAX_ACCOUNTS) throw new IllegalStateException("Charge account capacity reached");
+ a = new Account(new int[Kind.values().length], new long[Kind.values().length]); next.put(owner, a);
+ }
+ return a;
+ }
+ private Map copyAccounts() {
+ Map result = new HashMap<>(); accounts.forEach((id, a) -> result.put(id, a.copy())); return result;
+ }
+ private CompletableFuture submit(Supplier operation) {
+ CompletableFuture future = new CompletableFuture<>();
+ if (!ordinarySlots.tryAcquire()) return CompletableFuture.failedFuture(new RejectedExecutionException("Charge operation capacity reached"));
+ try { worker.execute(() -> {
+ try {
+ if (failed) throw new IllegalStateException("Charge store unavailable until restart");
+ future.complete(operation.get());
+ } catch (Throwable error) { future.completeExceptionally(error); }
+ finally { ordinarySlots.release(); }
+ }); } catch (RejectedExecutionException e) { ordinarySlots.release(); future.completeExceptionally(e); }
+ return future;
+ }
+ private void publish(Map next, Map pending) {
+ Path staged = null;
+ try {
+ Files.createDirectories(file.toAbsolutePath().getParent());
+ if (Files.isSymbolicLink(file)) throw new IOException("Charge file is a symlink");
+ staged = Files.createTempFile(file.toAbsolutePath().getParent(), ".charges-", ".tmp");
+ try (DataOutputStream out = new DataOutputStream(new BufferedOutputStream(Files.newOutputStream(staged)))) {
+ out.writeInt(MAGIC); out.writeInt(next.size());
+ for (Map.Entry entry : next.entrySet()) {
+ writeUuid(out, entry.getKey());
+ for (int i = 0; i < Kind.values().length; i++) { out.writeInt(entry.getValue().remaining[i]); out.writeLong(entry.getValue().successful[i]); }
+ }
+ out.writeInt(pending.size());
+ for (Reservation r : pending.values()) { writeUuid(out, r.id()); writeUuid(out, r.owner()); out.writeInt(r.kind().ordinal()); out.writeInt(r.units()); }
+ }
+ publisher.publish(staged, file);
+ accounts = Collections.unmodifiableMap(next); reservations = Collections.unmodifiableMap(pending);
+ } catch (IOException e) {
+ failed = true; throw new CompletionException(e); // publication may be uncertain; freeze all future effects
+ } finally { if (staged != null) try { Files.deleteIfExists(staged); } catch (IOException ignored) {} }
+ }
+ private void read() {
+ try {
+ if (Files.isSymbolicLink(file)) throw new IOException("Charge file is a symlink");
+ if (!Files.exists(file)) return;
+ if (Files.size(file) > 2_000_000) throw new IOException("Oversized charge ledger");
+ Map recovered = new HashMap<>();
+ try (DataInputStream in = new DataInputStream(new BufferedInputStream(Files.newInputStream(file)))) {
+ if (in.readInt() != MAGIC) throw new IOException("Invalid charge ledger version");
+ int count = bounded(in.readInt(), MAX_ACCOUNTS);
+ for (int i = 0; i < count; i++) {
+ UUID id = readUuid(in); Account a = new Account(new int[3], new long[3]);
+ for (int j = 0; j < 3; j++) { a.remaining[j] = in.readInt(); a.successful[j] = in.readLong(); if (a.remaining[j] < 0 || a.successful[j] < 0) throw new IOException("Invalid counters"); }
+ if (recovered.put(id, a) != null) throw new IOException("Duplicate account");
+ }
+ int countReservations = bounded(in.readInt(), MAX_RESERVATIONS); Set ids = new HashSet<>();
+ for (int i = 0; i < countReservations; i++) {
+ UUID id = readUuid(in), owner = readUuid(in); int kind = in.readInt(), units = in.readInt();
+ if (!ids.add(id) || !recovered.containsKey(owner) || kind < 0 || kind >= 3 || units < 1 || units > 64) throw new IOException("Invalid reservation");
+ }
+ if (in.read() != -1) throw new IOException("Trailing charge ledger data");
+ }
+ // Recovery never refunds possibly executed gameplay. Old tokens cannot authorize callbacks.
+ accounts = Collections.unmodifiableMap(recovered); reservations = Map.of();
+ } catch (IOException e) { failed = true; throw new CompletionException(e); }
+ }
+ private static int bounded(int value, int max) throws IOException { if (value < 0 || value > max) throw new IOException("Invalid ledger count"); return value; }
+ private static void writeUuid(DataOutputStream out, UUID id) throws IOException { out.writeLong(id.getMostSignificantBits()); out.writeLong(id.getLeastSignificantBits()); }
+ private static UUID readUuid(DataInputStream in) throws IOException { return new UUID(in.readLong(), in.readLong()); }
+ @Override public void close() { worker.shutdown(); } // Drain queued writes without blocking an owner thread.
+}
diff --git a/MCPerks/src/main/java/com/bencodez/mcperks/userapi/UserStorageConfirmation.java b/MCPerks/src/main/java/com/bencodez/mcperks/userapi/UserStorageConfirmation.java
new file mode 100644
index 0000000..add7345
--- /dev/null
+++ b/MCPerks/src/main/java/com/bencodez/mcperks/userapi/UserStorageConfirmation.java
@@ -0,0 +1,23 @@
+package com.bencodez.mcperks.userapi;
+
+import java.util.UUID;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.TimeUnit;
+import com.bencodez.mcperks.MCPerksMain;
+
+/** Confirms the canonical user cache on storage, including writes staged by owner-thread setters. */
+public final class UserStorageConfirmation {
+ private UserStorageConfirmation() {}
+ public static CompletableFuture confirm(MCPerksMain plugin, MCPerksUser user) {
+ var confirmed = new CompletableFuture();
+ plugin.getFeatureState().runtimeStorage(() -> {
+ var cache = plugin.getUserManager().getDataManager().getCache(UUID.fromString(user.getUUID()));
+ if (cache == null) throw new IllegalStateException("Activation user cache unavailable");
+ // The callback follows the actual exclusive flush, not its scheduling or a timed guess.
+ cache.flushChangesAndRun(() -> confirmed.complete(null));
+ return null;
+ }).whenComplete((ignored, error) -> { if (error != null) confirmed.completeExceptionally(error); });
+ // A deferred backend that cannot report failure must retain the uncertain start fence.
+ return confirmed.orTimeout(30, TimeUnit.SECONDS);
+ }
+}
diff --git a/MCPerks/src/main/resources/Config.yml b/MCPerks/src/main/resources/Config.yml
index 6b190fe..dfd589f 100644
--- a/MCPerks/src/main/resources/Config.yml
+++ b/MCPerks/src/main/resources/Config.yml
@@ -224,4 +224,8 @@ JavascriptEngine:
# Enables the JavaScript command.
# This only controls command access/registration, not whether JavaScript support itself is enabled.
# Legacy option: EnableJavascriptCommand
- CommandEnabled: false
\ No newline at end of file
+ CommandEnabled: false
+
+# Optional local, aggregate-only counters. No external reporting. Counters reset on restart.
+LocalStatistics:
+ Enabled: false
diff --git a/MCPerks/src/test/java/com/bencodez/mcperks/commands/PerkDiagnosticsTest.java b/MCPerks/src/test/java/com/bencodez/mcperks/commands/PerkDiagnosticsTest.java
new file mode 100644
index 0000000..8947236
--- /dev/null
+++ b/MCPerks/src/test/java/com/bencodez/mcperks/commands/PerkDiagnosticsTest.java
@@ -0,0 +1,196 @@
+package com.bencodez.mcperks.commands;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.Mockito.*;
+import java.nio.file.Path;
+import java.util.*;
+import java.util.concurrent.*;
+import org.bukkit.World;
+import org.bukkit.command.CommandSender;
+import org.bukkit.configuration.file.YamlConfiguration;
+import org.bukkit.entity.Player;
+import org.junit.jupiter.api.io.TempDir;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.ValueSource;
+import com.bencodez.mcperks.MCPerksMain;
+import com.bencodez.mcperks.data.FeatureState;
+import com.bencodez.mcperks.data.ServerData;
+import com.bencodez.mcperks.perk.*;
+import com.bencodez.mcperks.userapi.*;
+import com.bencodez.simpleapi.scheduler.BukkitScheduler;
+
+class PerkDiagnosticsTest {
+ @TempDir Path directory;
+
+ private Perk perk(String name, UUID owner, boolean charged, Effect effect) {
+ Perk perk = mock(Perk.class);
+ when(perk.getPerk()).thenReturn(name);
+ when(perk.getPerkType()).thenReturn(PerkSystemType.PLAYER);
+ when(perk.getEffectedPlayers()).thenReturn(new ArrayList<>(List.of(owner.toString())));
+ when(perk.getEffects()).thenReturn(new ArrayList<>(List.of(effect)));
+ when(perk.isNotInDisabledWorld(anyString())).thenReturn(true);
+ when(perk.getInteractionOptions()).thenReturn(new InteractionOptions(charged, false, 16, 8,
+ List.of(), List.of(), List.of(), List.of()));
+ return perk;
+ }
+
+ @ParameterizedTest @ValueSource(booleans = {true, false})
+ void explainUsesRetainedGameplayOptionsAfterReloadAndStaysReadOnly(boolean retainedCharged) throws Exception {
+ UUID owner = UUID.randomUUID(), other = UUID.randomUUID();
+ try (FeatureState state = new FeatureState(directory.resolve("features.dat"));
+ UsageCharges charges = new UsageCharges(directory.resolve("charges.dat"))) {
+ state.ready().get(5, TimeUnit.SECONDS); charges.ready().get(5, TimeUnit.SECONDS);
+ charges.set(owner, UsageCharges.Kind.AutoBlockRefill, 7).get(5, TimeUnit.SECONDS);
+ MCPerksMain plugin = mock(MCPerksMain.class);
+ when(plugin.isEnabled()).thenReturn(true);
+ when(plugin.getFeatureState()).thenReturn(state); when(plugin.getUsageCharges()).thenReturn(charges);
+ when(plugin.getConfigFile()).thenReturn(mock(com.bencodez.mcperks.configs.Config.class));
+ ServerData server = mock(ServerData.class); when(server.getData()).thenReturn(new YamlConfiguration());
+ when(plugin.getMcperksServerData()).thenReturn(server);
+ UserManager users = mock(UserManager.class); MCPerksUser user = mock(MCPerksUser.class);
+ when(users.getMCPerksUser(owner)).thenReturn(user); when(plugin.getMcperksUserManager()).thenReturn(users);
+ Perk retained = perk("refill", owner, retainedCharged, Effect.AutoBlockRefill);
+ // Reload can change both options and the effect list; the running clone is authoritative.
+ Perk reloaded = perk("refill", owner, !retainedCharged, Effect.NoFallDamage);
+ Perk unrelated = perk("other", other, true, Effect.AutoBlockRefill);
+ Perk configuredOther = perk("other", owner, false, Effect.NoFallDamage);
+ PerkHandler handler = mock(PerkHandler.class);
+ when(handler.getActivePerks()).thenReturn(new CopyOnWriteArrayList<>(List.of(retained, unrelated)));
+ when(handler.getLoadedPerks()).thenReturn(Map.of("refill", reloaded, "other", configuredOther));
+ when(handler.effectDecision(any(), anyString(), anyString())).thenReturn(PerkHandler.Decision.ACTIVE);
+ when(plugin.getPerkHandler()).thenReturn(handler);
+ var effects = mock(com.bencodez.mcperks.listeners.UsageEffectListener.class);
+ when(plugin.getUsageEffects()).thenReturn(effects);
+ Player player = mock(Player.class); when(player.getUniqueId()).thenReturn(owner);
+ when(player.isOnline()).thenReturn(true); when(player.getName()).thenReturn("Tester");
+ World world = mock(World.class); when(world.getName()).thenReturn("world"); when(player.getWorld()).thenReturn(world);
+ when(player.hasPermission(anyString())).thenReturn(true);
+ CommandSender sender = mock(CommandSender.class);
+ BukkitScheduler scheduler = mock(BukkitScheduler.class); when(plugin.getBukkitScheduler()).thenReturn(scheduler);
+ BlockingQueue ownerTasks = new LinkedBlockingQueue<>(), replies = new LinkedBlockingQueue<>();
+ doAnswer(i -> { ownerTasks.add(i.getArgument(1)); return null; }).when(scheduler)
+ .runTask(eq(plugin), any(Runnable.class), eq(player));
+ doAnswer(i -> { replies.add(i.getArgument(1)); return null; }).when(scheduler)
+ .runTask(eq(plugin), any(Runnable.class));
+ List messages = new ArrayList<>();
+ doAnswer(i -> { messages.add(i.getArgument(0)); return null; }).when(sender).sendMessage(anyString());
+ new PerkDiagnostics(plugin).explain(sender, player);
+ Runnable render = Objects.requireNonNull(ownerTasks.poll(5, TimeUnit.SECONDS));
+ verify(player, never()).getWorld(); verify(sender, never()).sendMessage(anyString());
+ render.run(); Objects.requireNonNull(replies.poll(5, TimeUnit.SECONDS)).run();
+ assertTrue(messages.stream().anyMatch(s -> s.startsWith("refill (retained active grant)")));
+ assertFalse(messages.stream().anyMatch(s -> s.startsWith("refill (configured definition)")));
+ assertTrue(messages.stream().anyMatch(s -> s.startsWith("other (configured definition)")));
+ String refill = messages.stream().filter(s -> s.startsWith(" AutoBlockRefill:")).findFirst().orElseThrow();
+ assertTrue(refill.contains(retainedCharged ? "charges=7" : "unlimited"), refill);
+ assertFalse(refill.contains(retainedCharged ? "unlimited" : "charges="), refill);
+ verify(reloaded, never()).getInteractionOptions();
+ assertEquals(7, charges.get(owner, UsageCharges.Kind.AutoBlockRefill));
+ assertEquals(0, charges.successful(owner, UsageCharges.Kind.AutoBlockRefill));
+ assertTrue(state.queue().isEmpty()); assertTrue(state.banks().isEmpty());
+ verify(user, never()).setActivations(anyInt()); verify(server, never()).saveData();
+ }
+ }
+ private enum DuplicateCase { OWN_PERSONAL, OTHER_PERSONAL, GLOBAL_RETAINED, PAUSED_BANK, ZERO_BANK, LEGACY_WITH_OLD_BANK }
+ private static java.util.stream.Stream duplicateCases() {
+ return Arrays.stream(DuplicateCase.values()).flatMap(kind -> java.util.stream.Stream.of(false, true)
+ .map(allowed -> org.junit.jupiter.params.provider.Arguments.of(kind, allowed)));
+ }
+
+ @ParameterizedTest @org.junit.jupiter.params.provider.MethodSource("duplicateCases")
+ void explainMatchesProductionDuplicateChecksForRetainedGrantsAndBanks(DuplicateCase kind, boolean allowed) throws Exception {
+ UUID owner = UUID.randomUUID(), other = UUID.randomUUID();
+ Path file = directory.resolve("duplicates.dat"); MCPerksMain previous = MCPerksMain.plugin;
+ try (FeatureState state = new FeatureState(file); UsageCharges charges = new UsageCharges(directory.resolve("duplicate-charges.dat"))) {
+ state.ready().get(5, TimeUnit.SECONDS); charges.ready().get(5, TimeUnit.SECONDS);
+ MCPerksMain plugin = mock(MCPerksMain.class); MCPerksMain.plugin = plugin;
+ when(plugin.isEnabled()).thenReturn(true); when(plugin.getFeatureState()).thenReturn(state);
+ when(plugin.getUsageCharges()).thenReturn(charges);
+ var config = mock(com.bencodez.mcperks.configs.Config.class, CALLS_REAL_METHODS);
+ var configData = new YamlConfiguration(); configData.set("LimitActivations", true);
+ // Exercise the actual optional configuration getter, including its disabled default.
+ if (allowed || kind == DuplicateCase.OWN_PERSONAL) configData.set("DuplicatePerksActive", allowed);
+ doReturn(configData).when(config).getData(); when(plugin.getConfigFile()).thenReturn(config);
+ assertEquals(allowed, config.getAllowDuplicatePerksActive());
+ ServerData server = mock(ServerData.class); when(server.getData()).thenReturn(new YamlConfiguration());
+ when(server.isReady()).thenReturn(true); when(plugin.getMcperksServerData()).thenReturn(server);
+ MCPerksUser user = mock(MCPerksUser.class), foreign = mock(MCPerksUser.class);
+ when(user.getUUID()).thenReturn(owner.toString()); when(user.getPlayerName()).thenReturn("Tester");
+ when(user.getActivations()).thenReturn(5); when(user.getActivations("passive")).thenReturn(7);
+ when(foreign.getUUID()).thenReturn(other.toString()); when(foreign.getPlayerName()).thenReturn("Other");
+ UserManager users = mock(UserManager.class); when(users.getMCPerksUser(owner)).thenReturn(user);
+ when(plugin.getMcperksUserManager()).thenReturn(users);
+ PerkHandler handler = mock(PerkHandler.class); when(plugin.getPerkHandler()).thenReturn(handler);
+ when(handler.isRestorationReady()).thenReturn(true);
+ var active = new CopyOnWriteArrayList(); when(handler.getActivePerks()).thenReturn(active);
+ when(handler.effectDecision(any(), anyString(), anyString())).thenReturn(PerkHandler.Decision.ACTIVE);
+ var banked = new BankedPerks(plugin, state); when(plugin.getBankedPerks()).thenReturn(banked);
+ boolean bankMode = kind == DuplicateCase.PAUSED_BANK || kind == DuplicateCase.ZERO_BANK;
+ var yaml = new YamlConfiguration();
+ yaml.loadFromString("Enabled: true\nPerkType: PLAYER\nTimeLasts: 10\nEffects: [NoFallDamage]\nBankedTime:\n Enabled: " + bankMode + "\n");
+ var perkConfig = mock(com.bencodez.mcperks.configs.ConfigPerks.class, CALLS_REAL_METHODS);
+ doReturn(yaml).when(perkConfig).getData("passive");
+ doReturn(new ArrayList()).when(perkConfig).getPerkDisabledWorlds("passive");
+ doReturn("duplicate blocked").when(perkConfig).getPerkAlreayActive("passive");
+ try (var configs = mockStatic(com.bencodez.mcperks.configs.ConfigPerks.class)) {
+ configs.when(com.bencodez.mcperks.configs.ConfigPerks::getInstance).thenReturn(perkConfig);
+ Perk definition = new Perk("passive");
+ when(handler.getLoadedPerks()).thenReturn(Map.of("passive", definition));
+ when(handler.getPerk("passive")).thenReturn(definition);
+ boolean retained = kind == DuplicateCase.OWN_PERSONAL || kind == DuplicateCase.GLOBAL_RETAINED;
+ if (retained || kind == DuplicateCase.OTHER_PERSONAL) {
+ Perk clone = new Perk(definition); clone.setActivater(kind == DuplicateCase.OWN_PERSONAL ? user : foreign);
+ clone.getEffectedPlayers().add((retained ? owner : other).toString()); clone.setActive(true);
+ if (kind == DuplicateCase.GLOBAL_RETAINED) {
+ var type = Perk.class.getDeclaredField("perkType"); type.setAccessible(true); type.set(clone, PerkSystemType.ALL);
+ }
+ active.add(clone);
+ }
+ var key = new FeatureState.BankKey(owner, "passive");
+ if (kind == DuplicateCase.PAUSED_BANK || kind == DuplicateCase.ZERO_BANK || kind == DuplicateCase.LEGACY_WITH_OLD_BANK) {
+ state.setBank(key, kind == DuplicateCase.ZERO_BANK ? 0 : 10000).get(5, TimeUnit.SECONDS);
+ state.pauseBank(key, true).get(5, TimeUnit.SECONDS);
+ }
+ boolean productionDuplicate = (definition.isPerkActive(user) || definition.getInteractionOptions().banked()
+ && banked.hasEntitlement(owner, definition)) && !allowed;
+ assertEquals(!allowed && (kind == DuplicateCase.OWN_PERSONAL || kind == DuplicateCase.GLOBAL_RETAINED
+ || kind == DuplicateCase.PAUSED_BANK), productionDuplicate);
+ byte[] before = java.nio.file.Files.exists(file) ? java.nio.file.Files.readAllBytes(file) : null;
+ Player player = mock(Player.class); when(player.getUniqueId()).thenReturn(owner);
+ when(player.isOnline()).thenReturn(true); when(player.getName()).thenReturn("Tester");
+ World world = mock(World.class); when(world.getName()).thenReturn("world"); when(player.getWorld()).thenReturn(world);
+ when(player.hasPermission(anyString())).thenReturn(true);
+ CommandSender sender = mock(CommandSender.class);
+ var effects = mock(com.bencodez.mcperks.listeners.UsageEffectListener.class); when(plugin.getUsageEffects()).thenReturn(effects);
+ BukkitScheduler scheduler = mock(BukkitScheduler.class); when(plugin.getBukkitScheduler()).thenReturn(scheduler);
+ BlockingQueue ownerTasks = new LinkedBlockingQueue<>(), replies = new LinkedBlockingQueue<>();
+ doAnswer(i -> { ownerTasks.add(i.getArgument(1)); return null; }).when(scheduler)
+ .runTask(eq(plugin), any(Runnable.class), eq(player));
+ doAnswer(i -> { replies.add(i.getArgument(1)); return null; }).when(scheduler).runTask(eq(plugin), any(Runnable.class));
+ List messages = new ArrayList<>(); doAnswer(i -> { messages.add(i.getArgument(0)); return null; })
+ .when(sender).sendMessage(anyString());
+ new PerkDiagnostics(plugin).explain(sender, player);
+ Runnable render = Objects.requireNonNull(ownerTasks.poll(5, TimeUnit.SECONDS));
+ verify(player, never()).getWorld(); verify(sender, never()).sendMessage(anyString());
+ render.run(); Objects.requireNonNull(replies.poll(5, TimeUnit.SECONDS)).run();
+ String activation = messages.stream().filter(line -> line.startsWith("passive (")).findFirst().orElseThrow();
+ assertTrue(activation.contains(retained ? "retained active grant" : "configured definition"), activation);
+ assertTrue(activation.contains(productionDuplicate ? "already active; duplicate activations disabled" : "activation checks passed"), activation);
+ assertEquals(before == null, !java.nio.file.Files.exists(file));
+ if (before != null) assertArrayEquals(before, java.nio.file.Files.readAllBytes(file));
+ assertEquals(0, charges.get(owner, UsageCharges.Kind.AutoBlockRefill));
+ assertEquals(0, charges.successful(owner, UsageCharges.Kind.AutoBlockRefill));
+ verify(user, never()).setActivations(anyInt()); verify(user, never()).addActivation(anyInt());
+ verify(user, never()).addActivation(anyString(), anyInt()); verify(server, never()).saveData();
+ // The rejected production request reaches the identical predicate without
+ // consuming credits or scheduling an effect. Allowed requests remain read-only here.
+ if (productionDuplicate) {
+ definition.runPerk(user); verify(user).sendMessage("duplicate blocked");
+ verify(user, never()).addActivation(anyInt()); verify(user, never()).addActivation(anyString(), anyInt());
+ if (before != null) assertArrayEquals(before, java.nio.file.Files.readAllBytes(file));
+ }
+ }
+ } finally { MCPerksMain.plugin = previous; }
+ }
+
+}
diff --git a/MCPerks/src/test/java/com/bencodez/mcperks/data/FeatureFileOwnershipTest.java b/MCPerks/src/test/java/com/bencodez/mcperks/data/FeatureFileOwnershipTest.java
new file mode 100644
index 0000000..fdde767
--- /dev/null
+++ b/MCPerks/src/test/java/com/bencodez/mcperks/data/FeatureFileOwnershipTest.java
@@ -0,0 +1,75 @@
+package com.bencodez.mcperks.data;
+import static org.junit.jupiter.api.Assertions.*;
+import java.net.URLClassLoader;
+import java.nio.file.*;
+import java.util.concurrent.*;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
+class FeatureFileOwnershipTest {
+ @TempDir Path root;
+ @Test void freshClassloadersCannotReadOrPublishUntilPredecessorReleasesItsOsLock() throws Exception {
+ var url = FeatureFileOwnership.class.getProtectionDomain().getCodeSource().getLocation();
+ try (var first = new URLClassLoader(new java.net.URL[] {url}, ClassLoader.getPlatformClassLoader());
+ var second = new URLClassLoader(new java.net.URL[] {url}, ClassLoader.getPlatformClassLoader())) {
+ var a = first.loadClass(FeatureFileOwnership.class.getName()); var b = second.loadClass(FeatureFileOwnership.class.getName());
+ assertNotSame(a,b); Path file=root.resolve("balances.dat");
+ var old=a.getConstructor(Path.class).newInstance(file); var next=b.getConstructor(Path.class).newInstance(file);
+ a.getMethod("awaitPredecessor").invoke(old);
+ var entered=new CountDownLatch(1);
+ var successor=CompletableFuture.runAsync(() -> {
+ entered.countDown();
+ try { b.getMethod("awaitPredecessor").invoke(next); assertEquals("old-drained",Files.readString(file)); Files.writeString(file,"successor-acknowledged"); }
+ catch(Exception error) { throw new CompletionException(error); }
+ });
+ try {
+ assertTrue(entered.await(5,TimeUnit.SECONDS));
+ assertThrows(TimeoutException.class,()->successor.get(100,TimeUnit.MILLISECONDS));
+ assertFalse(Files.exists(file));
+ Files.writeString(file,"old-drained"); a.getMethod("drained").invoke(old);
+ successor.get(5,TimeUnit.SECONDS); assertEquals("successor-acknowledged",Files.readString(file));
+ a.getMethod("drained").invoke(old); assertEquals("successor-acknowledged",Files.readString(file));
+ } finally { a.getMethod("drained").invoke(old); b.getMethod("drained").invoke(next); }
+ }
+ }
+ @Test void lockGuardSymlinkIsRejectedWithoutReadingItsTarget() throws Exception {
+ Path file=root.resolve("features.dat"), target=root.resolve("other"); Files.writeString(target,"untouched");
+ Files.createSymbolicLink(root.resolve("features.dat.lock"),target);
+ var owner=new FeatureFileOwnership(file);
+ try { assertThrows(java.io.UncheckedIOException.class,owner::awaitPredecessor); assertEquals("untouched",Files.readString(target)); }
+ finally { owner.drained(); }
+ }
+ @Test void ownershipFailureFreezesFeatureAndLegacyPublicationWithoutOverwritingExistingState() throws Exception {
+ Path file = root.resolve("features.dat"); var key = new FeatureState.BankKey(java.util.UUID.randomUUID(), "vein");
+ try (var seed = new FeatureState(file)) { seed.setBank(key, 9000).get(5, TimeUnit.SECONDS); }
+ byte[] original = Files.readAllBytes(file);
+ Files.deleteIfExists(root.resolve("features.dat.lock"));
+ Path unrelated = root.resolve("unrelated"); Files.writeString(unrelated, "do not touch");
+ Files.createSymbolicLink(root.resolve("features.dat.lock"), unrelated);
+ try (var state = new FeatureState(file)) {
+ assertThrows(ExecutionException.class, () -> state.ready().get(5, TimeUnit.SECONDS)); assertFalse(state.available());
+ assertThrows(ExecutionException.class, () -> state.setBank(key, 1).get(5, TimeUnit.SECONDS));
+ assertThrows(ExecutionException.class, () -> state.enqueue(key.owner(), "vein", "", 0).get(5, TimeUnit.SECONDS));
+ var invoked = new java.util.concurrent.atomic.AtomicBoolean();
+ assertThrows(ExecutionException.class, () -> state.runtimeStorage(() -> { invoked.set(true); return null; }).get(5, TimeUnit.SECONDS));
+ assertFalse(invoked.get()); assertArrayEquals(original, Files.readAllBytes(file));
+ assertEquals("do not touch", Files.readString(unrelated));
+ }
+ }
+ @Test void ownershipFailureFreezesChargeGrantsReservationsAndUnlimitedStatistics() throws Exception {
+ Path file = root.resolve("charges.dat"); var owner = java.util.UUID.randomUUID();
+ var kind = com.bencodez.mcperks.userapi.UsageCharges.Kind.VeinMining;
+ try (var seed = new com.bencodez.mcperks.userapi.UsageCharges(file)) { seed.set(owner, kind, 12).get(5, TimeUnit.SECONDS); }
+ byte[] original = Files.readAllBytes(file); Files.deleteIfExists(root.resolve("charges.dat.lock"));
+ Path unrelated = root.resolve("unrelated-charge"); Files.writeString(unrelated, "do not touch");
+ Files.createSymbolicLink(root.resolve("charges.dat.lock"), unrelated);
+ try (var state = new com.bencodez.mcperks.userapi.UsageCharges(file)) {
+ assertThrows(ExecutionException.class, () -> state.ready().get(5, TimeUnit.SECONDS)); assertFalse(state.available());
+ assertThrows(ExecutionException.class, () -> state.set(owner, kind, 1).get(5, TimeUnit.SECONDS));
+ assertThrows(ExecutionException.class, () -> state.add(owner, kind, 1).get(5, TimeUnit.SECONDS));
+ assertThrows(ExecutionException.class, () -> state.reserve(owner, kind, 1).get(5, TimeUnit.SECONDS));
+ assertThrows(ExecutionException.class, () -> state.record(owner, kind, 1).get(5, TimeUnit.SECONDS));
+ assertArrayEquals(original, Files.readAllBytes(file)); assertEquals("do not touch", Files.readString(unrelated));
+ }
+ }
+
+}
diff --git a/MCPerks/src/test/java/com/bencodez/mcperks/data/FeatureStateFixture.java b/MCPerks/src/test/java/com/bencodez/mcperks/data/FeatureStateFixture.java
new file mode 100644
index 0000000..be8c41c
--- /dev/null
+++ b/MCPerks/src/test/java/com/bencodez/mcperks/data/FeatureStateFixture.java
@@ -0,0 +1,23 @@
+package com.bencodez.mcperks.data;
+import java.nio.file.Path;
+public final class FeatureStateFixture {
+ private FeatureStateFixture() {}
+ public static FeatureState create(Path file, DurableFeatureFiles.Publisher publisher) { return new FeatureState(file, publisher); }
+ /** Delay the real controller commit, retaining its original elapsed/rollback behavior. */
+ @SuppressWarnings("unchecked")
+ public static void beforeBankCommit(FeatureState state, Runnable before) throws ReflectiveOperationException {
+ var grantField = FeatureState.class.getDeclaredField("bankGrantBoundary"); grantField.setAccessible(true);
+ var replacementField = FeatureState.class.getDeclaredField("bankReplacementBoundary"); replacementField.setAccessible(true);
+ var grants = (java.util.function.BiFunction) grantField.get(state);
+ var replacements = (java.util.function.Function) replacementField.get(state);
+ state.onBankGrant((key, balance) -> wrap(grants.apply(key, balance), before));
+ state.onBankReplacement(key -> wrap(replacements.apply(key), before));
+ }
+ private static FeatureState.BankGrant wrap(FeatureState.BankGrant actual, Runnable before) {
+ return new FeatureState.BankGrant(actual.elapsed(), () -> { before.run(); actual.commit().run(); }, actual.rollback());
+ }
+ public static boolean ownsBankBoundary(FeatureState state) throws ReflectiveOperationException {
+ var lock = FeatureState.class.getDeclaredField("bankBoundaryLock"); lock.setAccessible(true);
+ return Thread.holdsLock(lock.get(state));
+ }
+}
diff --git a/MCPerks/src/test/java/com/bencodez/mcperks/data/FeatureStateTest.java b/MCPerks/src/test/java/com/bencodez/mcperks/data/FeatureStateTest.java
new file mode 100644
index 0000000..058cadf
--- /dev/null
+++ b/MCPerks/src/test/java/com/bencodez/mcperks/data/FeatureStateTest.java
@@ -0,0 +1,235 @@
+package com.bencodez.mcperks.data;
+import static org.junit.jupiter.api.Assertions.*;
+import java.nio.file.*;
+import java.util.*;
+import java.util.concurrent.*;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.ValueSource;
+class FeatureStateTest {
+ @TempDir Path directory;
+ private static T await(CompletableFuture future) throws Exception { return future.get(5, TimeUnit.SECONDS); }
+ /** Real wire fixture avoids thousands of unrelated O(n) atomic publications in a boundary test. */
+ private static String unicodeBankFixture(Path file) throws Exception {
+ String name = "\uD83D\uDE00".repeat(62); // 124 UTF-16 code units, 372 modified UTF-8 bytes.
+ try (var out = new java.io.DataOutputStream(new java.io.BufferedOutputStream(Files.newOutputStream(file)))) {
+ out.writeInt(0x4d435032); out.writeBoolean(false); out.writeInt(0); out.writeInt(7518);
+ for (int i = 1; i <= 7518; i++) {
+ out.writeLong(0); out.writeLong(i); out.writeUTF(name); out.writeLong(5000); out.writeBoolean(false);
+ }
+ }
+ assertEquals(2_999_695, Files.size(file)); return name;
+ }
+ @Test void serializedBankCapacityRejectsBeforeTheActivationDebit() throws Exception {
+ Path file = directory.resolve("bank-admission.dat");
+ String name = "\uD83D\uDE00".repeat(62);
+ try (var out = new java.io.DataOutputStream(new java.io.BufferedOutputStream(Files.newOutputStream(file)))) {
+ out.writeInt(0x4d435032); out.writeBoolean(false); out.writeInt(0); out.writeInt(7516);
+ for (int i = 1; i <= 7516; i++) {
+ out.writeLong(0); out.writeLong(i); out.writeUTF(name); out.writeLong(5000); out.writeBoolean(false);
+ }
+ }
+ assertEquals(2_998_897, Files.size(file));
+ UUID owner = new UUID(0, 9000); var debits = new java.util.concurrent.atomic.AtomicInteger();
+ try (var state = new FeatureState(file)) {
+ await(state.ready());
+ var entry = await(state.enqueue(owner, name, "PerkActivations_" + name, 1));
+ assertEquals(2_999_705, Files.size(file));
+ await(state.claim(entry.id())); byte[] before = Files.readAllBytes(file);
+ var result = await(state.storage(() -> state.addBankOnWorker(new FeatureState.BankKey(owner, name),
+ 10000, () -> { debits.incrementAndGet(); return true; })));
+ assertNull(result); assertEquals(0, debits.get()); assertTrue(state.available());
+ assertFalse(state.banks().containsKey(new FeatureState.BankKey(owner, name)));
+ assertArrayEquals(before, Files.readAllBytes(file));
+ // The real planner releases this deterministic rejection, preserving unused entitlement.
+ await(state.releaseClaim(entry.id()));
+ assertEquals(FeatureState.Stage.WAITING, state.queue().getFirst().stage());
+ assertEquals(1, state.reserved(owner, "PerkActivations_" + name));
+ }
+ try (var recovered = new FeatureState(file)) {
+ await(recovered.ready()); assertTrue(recovered.available());
+ assertEquals(FeatureState.Stage.WAITING, recovered.queue().getFirst().stage());
+ assertEquals(7516, recovered.banks().size());
+ }
+ }
+ @ParameterizedTest @ValueSource(ints = {1, 2, 3})
+ void actualSerializedPublicationAcceptsBelowAndAtByteLimitAndRejectsAboveIt(int padding) throws Exception {
+ Path file = directory.resolve("unicode.dat"); String legacyName = unicodeBankFixture(file);
+ String name = "\uD83D\uDE00".repeat(46) + "x".repeat(padding);
+ var key = new FeatureState.BankKey(new UUID(0, 8000), name);
+ byte[] previous = Files.readAllBytes(file);
+ try (var state = new FeatureState(file)) {
+ await(state.ready()); assertEquals(7518, state.banks().size());
+ if (padding <= 2) {
+ await(state.setBank(key, 6000)); assertEquals(2_999_998L + padding, Files.size(file));
+ await(state.pauseQueue(true)); // Another publication at this exact size remains valid.
+ assertTrue(state.available());
+ byte[] accepted = Files.readAllBytes(file);
+ assertThrows(ExecutionException.class, () -> await(state.enqueue(UUID.randomUUID(), "overflow", "", 0)));
+ assertArrayEquals(accepted, Files.readAllBytes(file)); assertTrue(state.queue().isEmpty());
+ } else {
+ assertThrows(ExecutionException.class, () -> await(state.setBank(key, 6000)));
+ assertFalse(state.banks().containsKey(key)); assertArrayEquals(previous, Files.readAllBytes(file));
+ // Capacity rejection does not disable safety/lifecycle updates of existing entries.
+ await(state.pauseBank(new FeatureState.BankKey(new UUID(0, 1), legacyName), true));
+ }
+ assertTrue(state.available());
+ try (var files = Files.list(directory)) { assertFalse(files.anyMatch(path -> path.getFileName().toString().startsWith(".feature-"))); }
+ }
+ try (var recovered = new FeatureState(file)) {
+ await(recovered.ready()); assertTrue(recovered.available());
+ assertEquals(padding <= 2 ? 7519 : 7518, recovered.banks().size());
+ if (padding <= 2) assertEquals(new FeatureState.Bank(6000, false), recovered.banks().get(key));
+ else assertTrue(recovered.banks().get(new FeatureState.BankKey(new UUID(0, 1), legacyName)).paused());
+ }
+ }
+ @Test void oversizedRecoveryStillFailsClosedAtTheUnchangedByteBound() throws Exception {
+ Path file = directory.resolve("oversized.dat"); unicodeBankFixture(file);
+ try (var state = new FeatureState(file)) {
+ await(state.setBank(new FeatureState.BankKey(new UUID(0, 8000), "\uD83D\uDE00".repeat(46) + "xx"), 6000));
+ assertEquals(3_000_000, Files.size(file));
+ }
+ Files.write(file, new byte[] {0}, StandardOpenOption.APPEND);
+ try (var state = new FeatureState(file)) {
+ assertThrows(ExecutionException.class, () -> await(state.ready()));
+ assertFalse(state.available()); assertTrue(state.banks().isEmpty());
+ assertThrows(ExecutionException.class, () -> await(state.pauseQueue(true)));
+ assertEquals(3_000_001, Files.size(file));
+ }
+ }
+ @Test void queueOwnershipPauseReorderAndRestartAreDurable() throws Exception {
+ Path file = directory.resolve("feature.dat"); UUID a = UUID.randomUUID(), b = UUID.randomUUID(); FeatureState.QueueEntry first, second;
+ try (FeatureState state = new FeatureState(file)) {
+ first = await(state.enqueue(a, "Old perk.v1", "Activations", 2)); second = await(state.enqueue(b, "vein", "", 0));
+ assertFalse(await(state.cancel(first.id(), b, false))); await(state.pauseQueue(true)); assertNull(await(state.claim(first.id())));
+ assertTrue(await(state.move(second.id(), 1))); assertEquals(second.id(), state.queue().getFirst().id());
+ assertThrows(ExecutionException.class, () -> await(state.enqueue(a, "vein", "Activations", 2)));
+ }
+ try (FeatureState state = new FeatureState(file)) {
+ await(state.ready()); assertTrue(state.paused()); assertEquals(List.of(second.id(), first.id()), state.queue().stream().map(FeatureState.QueueEntry::id).toList());
+ assertTrue(await(state.cancel(first.id(), a, false))); assertFalse(await(state.cancel(first.id(), a, false))); assertEquals(0, state.reserved(a, "Activations"));
+ }
+ }
+ @Test void startFenceIsSingleUseAndUncertainRestartNeverReplaysOrRefundsCredits() throws Exception {
+ Path file = directory.resolve("feature.dat"); UUID owner = UUID.randomUUID(); FeatureState.QueueEntry entry;
+ try (FeatureState state = new FeatureState(file)) {
+ entry = await(state.enqueue(owner, "vein", "Activations", 1)); assertNotNull(await(state.claim(entry.id())));
+ assertNull(await(state.claim(entry.id()))); assertFalse(await(state.cancel(entry.id(), owner, false)));
+ }
+ try (FeatureState state = new FeatureState(file)) {
+ await(state.ready()); assertEquals(FeatureState.Stage.UNCERTAIN, state.queue().getFirst().stage()); assertNull(await(state.claim(entry.id())));
+ assertEquals(1, state.reserved(owner, "Activations")); assertFalse(await(state.cancel(entry.id(), owner, false)));
+ assertTrue(await(state.cancel(entry.id(), UUID.randomUUID(), true))); // explicit staff removal, no DB credit refund
+ }
+ }
+ @Test void queueCapacityReclaimedByCancellationAndFailedPublicationNeverClaims() throws Exception {
+ Path file = directory.resolve("feature.dat");
+ try (FeatureState state = new FeatureState(file)) {
+ FeatureState.QueueEntry first = null;
+ for (int i = 0; i < 256; i++) { var entry = await(state.enqueue(UUID.randomUUID(), "vein", "", 0)); if (first == null) first = entry; }
+ assertThrows(ExecutionException.class, () -> await(state.enqueue(UUID.randomUUID(), "vein", "", 0)));
+ assertTrue(await(state.cancel(first.id(), first.owner(), false))); await(state.enqueue(UUID.randomUUID(), "vein", "", 0));
+ var head = state.queue().getFirst(); Files.delete(file); Files.createDirectory(file);
+ assertThrows(ExecutionException.class, () -> await(state.claim(head.id())));
+ assertEquals(FeatureState.Stage.WAITING, state.queue().getFirst().stage());
+ }
+ }
+ @Test void bankedLifecyclePersistsPauseAndRemainingWithoutChangingLegacyExpiration() throws Exception {
+ Path file = directory.resolve("feature.dat"); var key = new FeatureState.BankKey(UUID.randomUUID(), "vein");
+ try (FeatureState state = new FeatureState(file)) {
+ await(state.addBank(key, 10000)); await(state.elapsed(key, 3000)); await(state.pauseBank(key, true)); await(state.elapsed(key, 3000));
+ await(state.addBank(key, 2000)); assertEquals(new FeatureState.Bank(9000, true), state.banks().get(key));
+ }
+ try (FeatureState state = new FeatureState(file)) {
+ await(state.ready()); assertEquals(new FeatureState.Bank(9000, true), state.banks().get(key));
+ await(state.pauseBank(key, false)); await(state.elapsed(key, 15000)); assertEquals(0, state.banks().get(key).milliseconds());
+ assertTrue(state.queue().isEmpty());
+ }
+ }
+ @Test void malformedStateIsUnknownAndDoesNotErasePurchasedTime() throws Exception {
+ Path file = directory.resolve("feature.dat"); Files.writeString(file, "not a ledger");
+ try (FeatureState state = new FeatureState(file)) {
+ assertThrows(ExecutionException.class, () -> await(state.ready())); assertThrows(ExecutionException.class, () -> await(state.setBank(new FeatureState.BankKey(UUID.randomUUID(), "vein"), 5000)));
+ assertEquals("not a ledger", Files.readString(file));
+ }
+ }
+ @Test void successorWaitsOffOwnerUntilPriorLifecycleDrainsAndReadsItsFinalPublishedState() throws Exception {
+ Path file=directory.resolve("features.dat"); var key=new FeatureState.BankKey(UUID.randomUUID(),"passive");
+ CountDownLatch entered=new CountDownLatch(1), release=new CountDownLatch(1);
+ FeatureState old=new FeatureState(file); await(old.ready());
+ old.storage(() -> { entered.countDown(); try { if (!release.await(5,TimeUnit.SECONDS)) throw new IllegalStateException("timeout"); } catch (InterruptedException e) { Thread.currentThread().interrupt(); throw new IllegalStateException(e); } return null; });
+ assertTrue(entered.await(5,TimeUnit.SECONDS)); var write=old.setBank(key,5000); old.close();
+ try (FeatureState successor=new FeatureState(file)) {
+ assertFalse(successor.ready().isDone()); release.countDown(); await(write); await(successor.ready());
+ assertEquals(5000,successor.banks().get(key).milliseconds());
+ } finally { release.countDown(); old.close(); }
+ }
+
+ @Test void bankCapacityRejectsOverflowWithoutSilentTruncationAndSerializesConcurrentSetWithDebit() throws Exception {
+ var key=new FeatureState.BankKey(UUID.randomUUID(),"passive"); long limit=31_536_000_000L;
+ try(FeatureState state=new FeatureState(directory.resolve("features.dat"))) {
+ await(state.setBank(key,limit)); await(state.pauseBank(key,true));
+ assertThrows(ExecutionException.class,()->await(state.addBank(key,1)));
+ var debits=new java.util.concurrent.atomic.AtomicInteger();
+ assertNull(await(state.storage(()->state.addBankOnWorker(key,1,()->{ debits.incrementAndGet(); return true; }))));
+ assertEquals(new FeatureState.Bank(limit,true),state.banks().get(key)); assertEquals(0,debits.get());
+ await(state.setBank(key,limit-1000));
+ var replacement=new java.util.concurrent.atomic.AtomicReference>();
+ assertEquals(limit,await(state.storage(()->state.addBankOnWorker(key,1000,()->{
+ debits.incrementAndGet(); replacement.set(state.setBank(key,1234)); return true;
+ }))).milliseconds());
+ await(replacement.get()); assertEquals(1234,state.banks().get(key).milliseconds()); assertEquals(1,debits.get());
+ assertThrows(IllegalStateException.class,()->state.addBankOnWorker(key,1,()->true));
+ }
+ try(FeatureState state=new FeatureState(directory.resolve("features.dat"))) {
+ await(state.ready()); assertEquals(1234,state.banks().get(key).milliseconds());
+ }
+ }
+
+ @Test void failedGrantPublicationRollsBackClockWithoutMintingTime() throws Exception {
+ var fail = new java.util.concurrent.atomic.AtomicBoolean();
+ var clock = new com.bencodez.mcperks.perk.BankedClock();
+ var time = new java.util.concurrent.atomic.AtomicLong(1_000_000_000L);
+ var key = new FeatureState.BankKey(java.util.UUID.randomUUID(), "passive");
+ try (var store = new FeatureState(directory.resolve("grant.dat"), (staged,file) -> {
+ if (fail.get()) throw new java.io.IOException("fixture grant publication failed");
+ DurableFeatureFiles.publish(staged,file);
+ })) {
+ await(store.setBank(key,10000)); clock.checkpoint(time.get(),true);
+ store.onBankGrant((k,balance) -> clock.prepareGrant(time.get(),balance,time::get));
+ time.addAndGet(2_000_000_000L); fail.set(true);
+ assertThrows(java.util.concurrent.ExecutionException.class, () -> await(store.addBank(key,10000)));
+ assertEquals(10000,store.banks().get(key).milliseconds());
+ assertEquals(8000,clock.remaining(() -> store.banks().get(key).milliseconds(),time.get()));
+ assertFalse(store.available());
+ }
+ }
+ @Test void delayedGrantPublishesBeforeRebasingAndPreservesEarlierBoundedDebit() throws Exception {
+ var clock = new com.bencodez.mcperks.perk.BankedClock();
+ var time = new java.util.concurrent.atomic.AtomicLong(1_000_000_000L);
+ var block = new java.util.concurrent.atomic.AtomicBoolean();
+ var entered = new java.util.concurrent.CountDownLatch(1); var release = new java.util.concurrent.CountDownLatch(1);
+ var key = new FeatureState.BankKey(java.util.UUID.randomUUID(), "passive");
+ try (var store = new FeatureState(directory.resolve("delayed-grant.dat"), (staged,file) -> {
+ if (block.get()) { entered.countDown(); try { if (!release.await(5,java.util.concurrent.TimeUnit.SECONDS)) throw new java.io.IOException("fixture timeout"); }
+ catch (InterruptedException e) { Thread.currentThread().interrupt(); throw new java.io.IOException(e); } }
+ DurableFeatureFiles.publish(staged,file);
+ })) {
+ await(store.setBank(key,1000)); clock.checkpoint(time.get(),true);
+ time.addAndGet(2_000_000_000L);
+ long debit = clock.checkpoint(time.get(),true,() -> store.banks().get(key).milliseconds());
+ assertEquals(1000,debit);
+ store.onBankGrant((k,balance) -> clock.prepareGrant(time.get(),balance,time::get));
+ block.set(true); var grant = store.addBank(key,10000); assertTrue(entered.await(5,java.util.concurrent.TimeUnit.SECONDS));
+ assertEquals(0,clock.remaining(() -> store.banks().get(key).milliseconds(),time.get()));
+ time.addAndGet(5_000_000_000L); assertEquals(0,clock.checkpoint(time.get(),true,() -> store.banks().get(key).milliseconds()));
+ var pendingDebit = store.elapsed(key,debit).thenRun(() -> clock.acknowledge(debit));
+ release.countDown(); await(grant); pendingDebit.get(5,java.util.concurrent.TimeUnit.SECONDS);
+ assertEquals(10000,store.banks().get(key).milliseconds());
+ time.addAndGet(1_000_000_000L);
+ assertEquals(9000,clock.remaining(() -> store.banks().get(key).milliseconds(),time.get()));
+ } finally { release.countDown(); }
+ }
+
+}
diff --git a/MCPerks/src/test/java/com/bencodez/mcperks/data/OrderedServerDataFileTest.java b/MCPerks/src/test/java/com/bencodez/mcperks/data/OrderedServerDataFileTest.java
new file mode 100644
index 0000000..a7c9738
--- /dev/null
+++ b/MCPerks/src/test/java/com/bencodez/mcperks/data/OrderedServerDataFileTest.java
@@ -0,0 +1,288 @@
+package com.bencodez.mcperks.data;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.Mockito.*;
+import java.io.IOException;
+import java.nio.file.*;
+import java.util.*;
+import java.util.concurrent.*;
+import java.util.concurrent.atomic.*;
+import java.util.logging.Logger;
+import org.bukkit.Bukkit;
+import org.bukkit.configuration.file.YamlConfiguration;
+import org.junit.jupiter.api.*;
+import org.junit.jupiter.api.io.TempDir;
+import com.bencodez.advancedcore.api.time.TimeType;
+import com.bencodez.advancedcore.data.ServerData.TimeChangeTransitionState;
+import com.bencodez.mcperks.MCPerksMain;
+import com.bencodez.mcperks.perk.Perk;
+
+class OrderedServerDataFileTest {
+ @TempDir Path directory;
+ private MCPerksMain plugin;
+ private com.bencodez.advancedcore.data.ServerData original;
+ private ServerData runtime;
+ private OrderedServerDataFile ordered;
+ private FeatureState state;
+ private Perk perk;
+ private final AtomicReference publication = new AtomicReference<>(DurableFeatureFiles::publish);
+ private final ExecutorService calendar = Executors.newSingleThreadExecutor(task -> {
+ Thread thread = new Thread(task, "test-calendar"); thread.setDaemon(true); return thread;
+ });
+ private static T await(CompletableFuture future) throws Exception { return future.get(5, TimeUnit.SECONDS); }
+ @BeforeEach void setup() throws Exception {
+ if (Bukkit.getServer() == null) {
+ var server = mock(org.bukkit.Server.class); when(server.getLogger()).thenReturn(Logger.getLogger("test")); Bukkit.setServer(server);
+ }
+ plugin = mock(MCPerksMain.class); when(plugin.getDataFolder()).thenReturn(directory.toFile());
+ when(plugin.getLogger()).thenReturn(Logger.getLogger("test"));
+ original = mock(com.bencodez.advancedcore.data.ServerData.class);
+ var live = spy(new YamlConfiguration()); live.set("PrevDay", 8);
+ when(original.getData()).thenReturn(live); when(original.getdFile()).thenReturn(directory.resolve("ServerData.yml").toFile());
+ state = new FeatureState(directory.resolve("features.dat")); await(state.ready()); when(plugin.getFeatureState()).thenReturn(state);
+ runtime = new ServerData(plugin, (staged, file) -> {
+ assertFalse(Thread.holdsLock(runtime), "file I/O must not own the runtime monitor");
+ publication.get().publish(staged, file);
+ });
+ when(plugin.getMcperksServerData()).thenReturn(runtime);
+ try (var constructors = mockConstruction(com.bencodez.simpleapi.scheduler.BukkitScheduler.class)) {
+ ordered = new OrderedServerDataFile(plugin, original, runtime);
+ }
+ when(plugin.getServerDataFile()).thenReturn(ordered);
+ perk = mock(Perk.class); when(perk.getPerk()).thenReturn("legacy");
+ // All live serialization and mutations must keep their existing owner. Worker rebasing
+ // uses freshly parsed private YAML; it cannot evade this assertion with a shared cache.
+ doAnswer(call -> { assertTrue(Thread.holdsLock(runtime)); return call.callRealMethod(); }).when(live).saveToString();
+ doAnswer(call -> { assertTrue(Thread.holdsLock(runtime)); return call.callRealMethod(); }).when(live).set(anyString(), any());
+ await(runtime.initialize(state));
+ }
+ @AfterEach void close() { state.close(); calendar.shutdownNow(); }
+ private CompletableFuture begin() {
+ return CompletableFuture.supplyAsync(() -> ordered.beginTimeChangeTransition(TimeType.DAY, "2026-10-09", "9"), calendar);
+ }
+ private CompletableFuture complete(TimeChangeTransitionState transition) {
+ return CompletableFuture.runAsync(() -> ordered.completeTimeChangeTransition(transition), calendar);
+ }
+ private YamlConfiguration disk() { return YamlConfiguration.loadConfiguration(directory.resolve("ServerData.yml").toFile()); }
+ private CompletableFuture ownerSnapshot(long expiration) throws Exception {
+ // Waiting for this outer future checks monitor responsiveness, without waiting for storage.
+ return await(CompletableFuture.supplyAsync(() -> runtime.confirmedActivation(() -> {
+ assertNotEquals("MCPerks-feature-store", Thread.currentThread().getName());
+ runtime.setPerkExperation(perk, expiration); runtime.setServerCooldown("legacy", expiration + 1);
+ })));
+ }
+ private final class Gate implements AutoCloseable {
+ private final CountDownLatch entered = new CountDownLatch(1), release = new CountDownLatch(1);
+ private final AtomicBoolean first = new AtomicBoolean(true);
+ private Gate(boolean fail) {
+ publication.set((staged, file) -> {
+ if (first.compareAndSet(true, false)) {
+ entered.countDown();
+ try { if (!release.await(5, TimeUnit.SECONDS)) throw new IOException("test publication timeout"); }
+ catch (InterruptedException error) { Thread.currentThread().interrupt(); throw new IOException(error); }
+ if (fail) throw new IOException("calendar publication rejected");
+ }
+ DurableFeatureFiles.publish(staged, file);
+ });
+ }
+ private void entered() throws Exception { assertTrue(entered.await(5, TimeUnit.SECONDS)); }
+ @Override public void close() { release.countDown(); }
+ }
+ @Test void confirmedBeginAndCompletionRebaseLaterPerkSnapshotsWithoutBlockingOwner() throws Exception {
+ CompletableFuture