Reorganizes docs.

Updated Gradle CI workflow to use newer action versions and added project version extraction step.

.env.example

@@ -0,0 +1,26 @@
+# Configuration for tools/*.sh. Values are read as KEY=value data, not executed.
+# Unquoted values may contain spaces; matching outer quotes are removed.
+
+# Paper server
+PAPER_VERSION=26.2
+PAPER_BUILD=129
+PAPER_USER_AGENT="majinnaibu-plugin-dev/1.0 (https://github.com/majinnaibu)"
+JAVA_OPTS="-Xms2G -Xmx2G"
+STOP_TIMEOUT=60
+MINECRAFT_SERVER_JAR=paper-26.2-129.jar
+
+# Relative paths are resolved from the project root; ~/ is expanded.
+MINECRAFT_SERVER_PATH=./server
+MINECRAFT_BACKUP_PATH=./backups
+
+# Modrinth publishing
+# Release version is read from Gradle and checked against the jar's plugin.yml.
+MODRINTH_TOKEN=
+MODRINTH_PROJECT_ID=5NYwxysp
+# Optional Markdown override; empty generates notes from commits since the last tag.
+MODRINTH_CHANGELOG=
+MODRINTH_GAME_VERSIONS=26.2,26.3
+MODRINTH_LOADERS=paper
+MODRINTH_VERSION_TYPE=
+MODRINTH_DEPENDENCIES=
+MODRINTH_FILE=

.github/workflows/gradle.yml

@@ -0,0 +1,59 @@
+name: Java CI with Gradle
+
+on:
+  push:
+    branches: [ "develop" ]
+  pull_request:
+    branches: [ "develop" ]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+
+    steps:
+      - uses: actions/checkout@v7
+
+      - name: Set up JDK 25
+        uses: actions/setup-java@v6
+        with:
+          java-version: '25'
+          distribution: 'temurin'
+
+      - name: Setup Gradle 9.8.0
+        uses: gradle/actions/setup-gradle@v5
+        with:
+          gradle-version: '9.8.0'
+          cache-read-only: ${{ github.ref != 'refs/heads/develop' }}
+
+      - name: Run Unit Tests
+        run: ./gradlew test
+
+      - name: Upload Test Report
+        if: always()
+        uses: actions/upload-artifact@v7
+        with:
+          name: ScoreKeeper-test-report
+          path: |
+            build/reports/tests/test
+            build/test-results/test
+          if-no-files-found: ignore
+          retention-days: 14
+
+      - name: Build with Gradle Wrapper
+        run: ./tools/build-plugin.sh
+
+      - name: Extract Project Version
+        id: project_info
+        run: |
+          VERSION=$(./gradlew properties --no-daemon -q | awk -F ': ' '$1 == "version" {print $2}')
+          echo "version=$VERSION" >> $GITHUB_OUTPUT
+
+      - name: Upload Plugin Artifact
+        uses: actions/upload-artifact@v7
+        with:
+          name: ScoreKeeper-${{ steps.project_info.outputs.version }}
+          path: build/libs/*.jar
+          if-no-files-found: error
+          retention-days: 14

.gitignore

@@ -1,3 +1,8 @@
 .gradle/
 build/
 target/
+.worktrees/
+bin/
+/backups/
+/server/
+.env

.vscode/settings.json

@@ -3,5 +3,8 @@
     "editor.formatOnSave": true
   },
   "java.configuration.updateBuildConfiguration": "interactive",
-    "java.compile.nullAnalysis.mode": "automatic"
+  "java.compile.nullAnalysis.mode": "automatic",
+  "chat.tools.terminal.autoApprove": {
+    "printf": true
+  }
 }

CONTRIBUTING.md

@@ -12,9 +12,9 @@ Setup our project folder.
 ```bash
 PROJECTS_DIR="$HOME/Projects"
 MINECRAFT_SERVER_PATH="$PROJECTS_DIR/MCServer"
-# Set this to the latest download url on the Paper downloads page [https://papermc.io/downloads](https://papermc.io/downloads) and update the jar name.
+# Use Paper 26.2 or 26.3 only. The project helper scripts resolve the configured Paper build.
-MINECRAFT_SERVER_DOWNLOAD_URI="https://fill-data.papermc.io/v1/objects/fb73c7e310215016955617ab957022d9e1d47aeba206df3a98c5ecb43756527c/paper-1.21.8-25.jar"
+MINECRAFT_SERVER_DOWNLOAD_URI=""
-MINECRAFT_SERVER_JAR="paper-1.21.8-25.jar"
+MINECRAFT_SERVER_JAR="paper-26.2-129.jar"
 mkdir -p "$MINECRAFT_SERVER_PATH"
 # Keep this shell open we will use these variables later.
 ```
@@ -23,9 +23,9 @@ mkdir -p "$MINECRAFT_SERVER_PATH"
 ```powershell
 $projectsDir="$HOME\Projects"
 $minecraftServerDir="$projectsDir\MCServer"
-# Set this to the latest download url on the Paper downloads page [https://papermc.io/downloads](https://papermc.io/downloads) and update the jar name.
+# Use Paper 26.2 or 26.3 only. The project helper scripts resolve the configured Paper build.
-$minecraftServerDownloadUri="https://fill-data.papermc.io/v1/objects/fb73c7e310215016955617ab957022d9e1d47aeba206df3a98c5ecb43756527c/paper-1.21.8-25.jar"
+$minecraftServerDownloadUri=""
-$minecraftServerJar="paper-1.21.8-25.jar"
+$minecraftServerJar="paper-26.2-129.jar"
 New-Item -Type Directory $projectsDir
 New-Item -Type Directory $minecraftServerDir
 # Keep this shell open we will use these variables later.
@@ -34,18 +34,18 @@ New-Item -Type Directory $minecraftServerDir
 ## Install the JDK
 **Linux / WSL**
 ```bash
-apt install openjdk-21-jdk
+apt install openjdk-25-jdk
 ```
 
 **macOS**
 ```zsh
-brew install --cask microsoft-openjdk@21
+brew install --cask microsoft-openjdk@25
 ```
 
 **Windows**
 From Powershell
 ```powershell
-winget install --id Microsoft.OpenJDK.21 --source winget
+winget install --id Microsoft.OpenJDK.25 --source winget
 ```
 
 ## Setup a PaperMC Server
@@ -108,7 +108,7 @@ Our scripts depend on two environment variables. You can set them each time you
 To set them for the current session run these commands. To set for every new session add these commands to your `.bashrc` or `.zshrc` file.
 ```bash
 MINECRAFT_SERVER_PATH="$HOME/Projects/MCServer"
-MINECRAFT_SERVER_JAR="paper-1.21.8-25.jar"
+MINECRAFT_SERVER_JAR="paper-26.2-129.jar"
 ```
 
 **Windows**
@@ -116,13 +116,13 @@ MINECRAFT_SERVER_JAR="paper-1.21.8-25.jar"
 To set them for a single session run these commands.
 ```powershell
 $env:MINECRAFT_SERVER_PATH = "$HOME\Projects\MCServer"
-$env:MINECRAFT_SERVER_JAR = "paper-1.21.8-25.jar"
+$env:MINECRAFT_SERVER_JAR = "paper-26.2-129.jar"
 ```
 
 If you want them available in all of your powershell sessions you can set them permanently like this.
 ```powershell
 [Environment]::SetEnvironmentVariable("MINECRAFT_SERVER_PATH", "$HOME\Projects\MCServer", "User")
-[Environment]::SetEnvironmentVariable("MINECRAFT_SERVER_JAR", "paper-1.21.8-25.jar", "User")
+[Environment]::SetEnvironmentVariable("MINECRAFT_SERVER_JAR", "paper-26.2-129.jar", "User")
 ```
 
 ### Start-Server.ps1 and start-server.sh

README.md

@@ -1,23 +1,48 @@
 # ScoreKeeper Plugin
 
+[![Java CI with Gradle](https://github.com/headhunter45/ScoreKeeper/actions/workflows/gradle.yml/badge.svg)](https://github.com/headhunter45/ScoreKeeper/actions/workflows/gradle.yml)
+
+ScoreKeeper supports Paper 26.2 and 26.3 only. Bukkit and Spigot servers are not supported.
+
 ## Running
 
 ### Commands
 
-* `/score-get [playerName]` - Displays the player's score.
+For commands with an optional player name, players can omit it to target themselves. Console and RCON must provide a player name for score get/add/subtract/reset commands.
-* `/score-add [playerName] <amount>` - Add amount points to the player's score.
-* `/score-subtract [playerName] <amount>` - Subtracts amount points from the player's score.
-* `/score-reset [playerName]` - Resets the player's score to 0.
-* `/score-archive [playerName]` - Saves the player's score to a "High Scores" table and resets their current score to 0.
 
-NOTES:
+* `/score-get [playerName]` - Displays the target player's score in their active bucket.
-* All commands will use the executing player in place of [playerName] if it is omitted.
+* `/score-add <amount>` - Adds an amount to your score in your active bucket.
-* Permissions support is coming AFTER I get archive to work.
+* `/score-add <playerName> <amount>` - Adds an amount to the target player's score.
-* The commands aside from get are intended for admins and whatnot as some other plugin should be using the methods instead of letting player's execute commands.
+* `/score-subtract <amount>` - Subtracts an amount from your score in your active bucket.
+* `/score-subtract <playerName> <amount>` - Subtracts an amount from the target player's score.
+* `/score-reset [playerName]` - Resets the target player's score in their active bucket to that bucket's initial value.
+* `/score-archive` - Archives and resets your score in your active bucket.
+* `/score-archive <playerName>` - Archives and resets the target player's score in their active bucket.
+* `/score-archive all` - Archives and resets scores in every bucket.
+* `/score-archive bucket <bucketId>` - Archives and resets every score in one bucket.
+* `/score-archive-list` - Lists saved archive IDs, newest first.
+* `/score-archive-list <archiveId>` - Displays the saved scores in one archive.
+* `/score-bucket` - Displays your active bucket.
+* `/score-bucket <bucketId>` - Switches your active bucket.
+* `/score-bucket create <id> <singular> <plural> <initialValue> [reporting]` - Creates a bucket. Reporting is `admin`, `global`, `player`, or `none` and defaults to `none`.
+* `/score-bucket <playerName> <bucketId>` - Switches a player's active bucket.
+* `/score-bucket all <bucketId>` - Changes the server's default bucket and clears individual bucket assignments.
+* `/score-run start <bucketId> <topN> <reset:true|false> target <score>` - Starts a run that ends when a score reaches the target.
+* `/score-run start <bucketId> <topN> <reset:true|false> duration <time>` - Starts a timed run. Use a positive number followed by lowercase `s`, `m`, `h`, `d`, or `w` (for example, `4h`).
+* `/score-run start <bucketId> <topN> <reset:true|false> until-disabled` - Starts a run with no automatic end.
+* `/score-run stop <bucketId>` - Ends an active run.
+
+The `scorekeeper.admin` permission (default: operators) is required for archive commands, bucket creation/administration, and high-score run management. Score get/add/subtract/reset and archive-list commands currently have no permission checks; add, subtract, and reset can target any online player.
+
+When a player's active bucket changes, they are told the bucket name and their current score with its singular or plural unit.
+
+Bucket reporting defaults to `none`; `admin` notifies operators and score admins, `global` notifies all online players, and `player` notifies only the scored player. Other plugins can create buckets with `createBucket(id, singular, plural, initialValue, reporting)` and use the bucket-aware score methods. Existing score methods operate on the player's active bucket. Bucket definitions, reporting policies, assignments, and scores are saved in `plugins/ScoreKeeper/scores.yml`; archives are saved separately in `plugins/ScoreKeeper/archives.yml`.
+
+Other plugins can start runs with `startTargetScoreRun`, `startTimedScoreRun`, or `startUntilDisabledScoreRun`, and end one with `stopHighScoreRun`. During a run, players receive their own score changes, while changes by current top-`n` players are reported globally. Finished runs publish a deterministic score-ordered table and each online player's place; reset runs restore the pre-run bucket scores.
 
 ## Development
 
 See [CONTRIBUTING.md](CONTRIBUTING.md) for development environment setup instructions.
 
 Tooling note:
-* Gradle is configured with Java Toolchains and will automatically download a Java 21 JDK when needed during builds.
+* Gradle is configured with Java Toolchains and will automatically download an appropriate JDK when needed during builds.

TODO.md

@@ -1,17 +1,17 @@
-# Migration TODOs for Paper Modernization
+## Tasks
 
-- [x] Switch all player score storage to use UUID instead of Player as the key
+|  ID   |  Status  | Title |
-- [x] Update logger usage to use getLogger() from JavaPlugin
+|:-----:|:--------:|:------|
-- [x] Remove or modernize any old/deprecated event registration (use @EventHandler and registerEvents)
+| SK-01 |  Done    | Save scores between server launches. |
-- [x] Review and update player lookup logic to use getPlayerExact or handle case sensitivity
+| SK-02 |  Done    | Allow tracking scores by bucket. An admin or other plugin should be able to create types of scores with named other than points. { id: "Bread", singular: "loaf", plural: "loaves", initialValue: 0 } Each player's score will be tracked in a bucket by id. Players may be all switched to a bucket or individually switched. |\
-- [x] Ensure all commands are properly defined in plugin.yml
+| SK-03 |  Done    | Add optional score reporting to buckets with these four values. { id: "Bread", singular: "loaf", plural: "loaves", initialValue: 0, reporting:"admin|global|player|none" } admin means ops/admin only, global means everyone on the server, player means only tell the player, and none means don't report changes.
-- [x] Initialize Gradle build system
+| SK-04 |  Done    | Tell a player when their bucket changes. Something like "You are now tracking ${id}. You have ${score} ${plural or singular depending in score}." |
-- [x] Set project metadata in build.gradle
+| SK-05 |  Done    | Enable high score runs for a bucket. Admins or pugins should be able to start a run on a certain kind of score. The top n (configurable) players will have their scores reported globally for this bucket and the individual player will have their score reported to them when it changes. Scores will be optionally reset to their initialValue with the old score for this bucket saved. High score runs will have a lifetime of a target high score, a time like 4 hours or 1 week, or until-disabled. When the high score run is finished all players will be messaged a table with the top n places and their scores along with the individual user's place and score. The scores will be reset to their previous values if they were reset to their initialValue at the beginning otherwise they will be left alone. |
-- [x] Add repositories and dependencies
+| SK-06 |  Done    | Score archiving. Scores either all or within a given bucket should be able to be archived and reset to their initial value. The archived scores should be able to be listed via a command. |
-- [x] Configure Java version
+| SK-07 |  Done    | Replace 'net.researchgate.release' with org.danilopianini.git-sensitive-semantic-versioning' for our versioning in our build.gradle file. Turn org.gradle.configuration-cache back on after this. Our current version is 0.2.1-SNAPSHOT. Use that as our default or 0.2.1 and tag the commit to update to 0.2.2. |
-- [x] Ensure resource handling for plugin.yml
+| SK-08 |  Ready   | Add JUnit 5 test infrastructure and keep the default Gradle `test` task server-free. Use an in-memory Paper test harness such as MockBukkit for plugin lifecycle and Bukkit/Paper behavior; use Mockito only for narrow API boundaries where a harness is unnecessary. |
-- [x] Add Gradle plugins as needed (e.g., Shadow)
+| SK-09 |  Ready   | Add fast unit tests for score and bucket rules: bucket validation and duplicate IDs, initial values, UUID-isolated scores, default and per-player bucket selection, and add/subtract/reset behavior. Keep domain rules independent of a running Minecraft server. |
-- [x] Update .gitignore for Gradle
+| SK-10 |  Ready   | Test YAML persistence and archives using temporary plugin data directories: score/bucket/assignment round trips, active-run state, archive contents and resets, legacy score loading, and malformed or unknown stored entries. |
-- [x] Remove Maven files
+| SK-11 |  Ready   | Test command validation and dispatch, reporting policies and messages, bucket-switch messages, and high-score run ranking/lifecycle (top-N ordering, ties, target/duration/manual finish, and score restoration). Use a controllable clock and in-memory scheduler where needed. |
-- [x] Update documentation and scripts
+| SK-12 |  Ready   | Add a separate Gradle `integrationTest` source set/task only for behavior that needs a real Paper server, such as loading the built plugin jar, verifying actual command registration/dispatch, and persistence across a server restart. Run it only when explicitly requested; keep it out of the normal `test` and `build` tasks. |
-- [x] Test the Gradle build
+| SK-13 |  Ready   | Add a an option to `/score-get` to get the score for a specific bucket. |

build.gradle

@@ -1,13 +1,18 @@
 plugins {
-    id 'com.diffplug.spotless' version '6.22.0'
+    id 'com.diffplug.spotless' version '8.10.3'
     id 'java-library'
     id 'maven-publish'
-    id 'net.researchgate.release' version '3.1.0'
+    id 'org.danilopianini.git-sensitive-semantic-versioning' version '7.0.24'
 }
 
 group = 'com.majinnaibu.minecraft.plugins'
 description = "ScoreKeeper"
 
+gitSemVer {
+    minimumVersion.set('0.2.1')
+    versionPrefix.set('v')
+}
+
 tasks.withType(JavaCompile).configureEach {
 	options.encoding = 'UTF-8'
     // options.compilerArgs << "-Xlint:deprecation"
@@ -18,19 +23,35 @@ tasks.withType(Javadoc).configureEach {
 }
 
 dependencies {
-    compileOnly 'io.papermc.paper:paper-api:1.21.7-R0.1-SNAPSHOT'
+    compileOnly 'io.papermc.paper:paper-api:26.2.build.129-stable'
 }
 
 java {
     toolchain {
-        languageVersion = JavaLanguageVersion.of(21)
+        // Paper 26.1+ requires Java 25.
+        languageVersion = JavaLanguageVersion.of(25)
     }
 }
 
+tasks.named('wrapper') {
+    gradleVersion = '9.8.0'
+    distributionType = Wrapper.DistributionType.BIN
+    distributionBase = Wrapper.PathBase.PROJECT
+    distributionPath = '.gradle/wrapper/dists'
+    archiveBase = Wrapper.PathBase.PROJECT
+    archivePath = '.gradle/wrapper/dists'
+}
+
+tasks.named('updateDaemonJvm') {
+    languageVersion = JavaLanguageVersion.of(25)
+}
+
+def pluginVersion = project.version.toString()
+
 processResources {
-    inputs.property "version", project.version
+    inputs.property "version", pluginVersion
     filesMatching('plugin.yml') {
-        expand(project.properties)
+        expand(version: pluginVersion)
     }
 }
 
@@ -42,17 +63,6 @@ publishing {
     }
 }
 
-release {
-    buildTasks.addAll(['spotlessCheck', 'build'])
-    failOnSnapshotDependencies = true
-    ignoredSnapshotDependencies = [
-        "io.papermc.paper:paper-api"
-    ]
-    revertOnFail = true
-    tagTemplate = 'v$version'
-    versionPropertyFile = 'gradle.properties'
-}
-
 repositories {        
      mavenCentral()
      maven { url = 'https://repo.papermc.io/repository/maven-public/' }
@@ -60,7 +70,7 @@ repositories {
 
 spotless {
     java {
-        googleJavaFormat()
+        googleJavaFormat('1.36.1')
         importOrder 'java', 'javax', 'com', 'net', 'org', ''
         licenseHeaderFile 'config/license-header.txt'
         target 'src/**/*.java'

docs/domain-score-tracking.md

@@ -0,0 +1,365 @@
+# ScoreKeeper — Score-Tracking & "High-Score Table" Domain Analysis
+
+> **Scope of this document:** the domain logic that tracks player scores and (intended) the
+> high-score table. Written for a new team member who must understand the scoring system
+> *without opening the source*. Every claim below is traced to a file/line so it can be
+> re-verified.
+>
+> **Bottom line up front (read this first):** ScoreKeeper currently tracks **live scores
+> only, in memory, for the running server session**. It has **no persistence** and **no
+> high-score table**. The high-score table is *described as a planned feature* in the
+> README and is where the `/score-archive` command is *intended* to land scores, but
+> **that code path is an unimplemented stub today.** There is no sorting, no tie-breaking,
+> no entry cap, no decay, and no scoring formula/weighting anywhere in the codebase.
+> This is a greenfield/early-stage domain — the write-up documents the *real* state and
+> flags the gap, because documenting features that don't exist as if they did would mislead
+> the next engineer.
+
+---
+
+## 0. How to read the rest of this doc against the task's four questions
+
+The task asks for (1) the score-entry data model + persistence format, (2) how scores are
+recorded, (3) the high-score-table algorithm, and (4) scoring formulas/weighting.
+For each question the answer is: **the mechanism that exists vs. the mechanism the project
+intends**, so readers never conflate the two.
+
+| # | Question | Short answer |
+|---|----------|--------------|
+| 1 | Score-entry data model & persistence | Live score = `UUID -> int` in a `HashMap`. **No persistence** (load/save are `TODO` stubs). |
+| 2 | How scores are recorded | **Manual, event-free:** the *administrator* runs a command. No game events, no timers. |
+| 3 | High-score-table algorithm | **Not implemented.** No sort/tie-break/cap/decay. Only an aspirational `/score-archive`. |
+| 4 | Scoring formulas / weighting | **None.** Scores are plain integer accumulators; no weighting, no decay, no bonuses. |
+
+---
+
+## 1. The score-entry data model & persistence  *(task Q1)*
+
+### 1.1 What a "score entry" actually is (current reality)
+
+The entire live-score domain is **one field** in the plugin's entry-point class:
+
+- **File:** `src/main/java/com/majinnaibu/minecraft/plugins/scorekeeper/ScoreKeeperPlugin.java:38`
+- **Declaration:** `private final HashMap<UUID, Integer> _playerScores = new HashMap<UUID, Integer>();`
+
+That is the whole model:
+
+| Aspect | Value |
+|--------|-------|
+| Record shape | A single `Integer` (the score), keyed by a player's `UUID`. |
+| Key type | `java.util.UUID` — the player's `UniqueId`, *not* the name string. |
+| Value type | `int` (Java `Integer`), autoboxed into the map. |
+| Container | one `java.util.HashMap` on the plugin instance. |
+| Uniqueness | one entry per `UUID`. A player can have exactly one live score at a time. |
+| Default for a new player | `0` — see §3.1 ("first-time player" edge case). |
+
+There is **no `Score`/`ScoreEntry`/`PlayerStats` value class**, no timestamp, no
+name stored alongside the score (name is looked up from the live server only — see §2.3),
+and no secondary index.
+
+### 1.2 Persistence format: **none exists**
+
+Persistence is *intended* but *not built*. Three concrete stubs prove this:
+
+1. **On disable (server stop):** `ScoreKeeperPlugin.java:46-49` `onDisable()` logs
+   *"Unable to save scores to file. This feature is not implemented yet."* — the map
+   is **discarded** on shutdown; nothing is written.
+2. **On enable (server start):** `ScoreKeeperPlugin.java:59-60` `onEnable()` logs
+   *"Unable to load scores from file. This feature is not implemented yet."* — the map
+   always starts **empty** `{}` every server start.
+3. **Archive:** `ScoreKeeperPlugin.java:72-74` `archiveScore(Player)` logs
+   *"Unable to archive score for <name>."* and returns — the "save to high-score table"
+   action is a no-op.
+
+So there is **no SQLite, no JSON, no YAML, no flat file, no config.yml**. The only file on
+disk that concerns scores is `plugin.yml` (the command manifest — it lists the commands but
+stores no scores). A grep of the whole tree for `sql / json / yaml / saveResource /
+YamlConfiguration / File / Files. / Gson / Jackson` finds **zero hits** other than the
+TODO/log strings.
+
+**Persistence format today = "in RAM only, lost on server restart."**
+
+> Implication for a new engineer: any "who's the top player" question answered *across
+> restarts* is impossible today. Scores reset to the map being empty on every server boot.
+
+---
+
+## 2. How scores are recorded  *(task Q2)*
+
+### 2.1 The recording model is **manual and command-driven — no events, no timers**
+
+Scores move only when an administrator (or console/RCON) **types a command**. There is:
+
+- **No** `implements Listener`, no `@EventHandler`, no `registerEvents(...)`, no
+  `getServer().getPluginManager().registerEvents(...)`.
+- **No** scheduler: no `getScheduler()`, no `runTask`, no `Timer`.
+- **No** automatic hook to game events (e.g. a player killing a mob or reaching a goal
+  awards points automatically — *nothing like that exists*).
+
+A grep for `EventListener|@EventHandler|Listener|Scheduler|runTask` across `src/` returns
+**zero**.
+
+So "scoring" happens **on demand**, by a person, via one of the four mutating commands:
+
+| Command | Effect on the map | Source |
+|---------|-------------------|--------|
+| `/score-add [player] <amount>` | `score += amount` | `ScoreKeeperPlugin.addScore` `:67-70` |
+| `/score-subtract [player] <amount>` | `score -= amount` | `ScoreKeeperPlugin.subtractScore` `:88-91` |
+| `/score-reset [player]` | `score = 0` | `ScoreKeeperPlugin.resetScore` `:80-82` |
+| `/score-archive [player]` | **intended** to snapshot to a high-score table and reset to 0; **actually a no-op** | `ScoreKeeperPlugin.archiveScore` `:72-74` |
+
+`/score-get [player]` is read-only (returns the score, §2.4).
+
+### 2.2 The add/subtract primitives (the only real "write" path)
+
+Both funnel through one private setter:
+
+```
+addScore(player, n)    ->  old = getPlayerScore(player); setPlayerScore(player, old + n)   :67-70
+subtractScore(player,n)->  old = getPlayerScore(player); setPlayerScore(player, old - n)   :88-91
+setScore(player, s)    ->  setPlayerScore(player, s)                                       :84-86
+resetScore(player)     ->  setPlayerScore(player, 0)                                        :80-82
+setPlayerScore(p, v)   ->  _playerScores.put(p.getUniqueId(), v)                            :108-110
+```
+
+Notes a new engineer must internalize:
+
+- **Read-modify-write.** `addScore`/`subtractScore` read the current value, compute, write
+  back in two map operations. (There is no concurrency control — see §5 risks.)
+- **`int` math.** Values are Java `int`; a score can go **negative** (there is no floor at
+  0 — `/score-subtract 50` on a 10-score yields `-40`), and can overflow `int` only after
+  `~2.1e9` points, which is not a practical concern.
+- **No validation of the direction.** The only validation is *syntactic*: the amount must
+  parse as an integer (see §2.3).
+
+### 2.3 Command surface (who/what is allowed to record a score)
+
+Every command executor lives in `src/main/java/.../scorekeeper/commands/` and shares one
+shape: parse args, resolve the target player, call the `ScoreKeeperPlugin` method, return
+`true` (consumed). Two behavioral details matter:
+
+- **Self-target default:** if a *player* runs a command and omits the name, they target
+  *themselves*: `targetPlayer = (Player) sender`. (e.g. `ScoreGetCommand.java:44`,
+  `ScoreAddCommand.java:48`, `ScoreResetCommand.java:47-49`.)
+- **RCON/console path:** if the sender is **not** a player (console/RCON), a player name
+  is **required** — omitting it prints usage instead of acting
+  (`ScoreGetCommand.java:46-48`, `ScoreAddCommand.java:45-47`,
+  `ScoreResetCommand.java:44-46`).
+- **Name resolution:** `getServer().getPlayerExact(name)` — **exact, case-sensitive**
+  lookup by the *currently online* name (`ScoreGetCommand.java:50`,
+  `ScoreAddCommand.java:57`, `ScoreResetCommand.java:50`). A name that is not online
+  yields `null` → "Can't find a player with that name". Note the *map key is a UUID*, but
+  *lookup by name only works while that player is online* — you cannot change an offline
+  player's score by name today.
+- **No permission nodes anywhere.** `plugin.yml` declares no `permission:`/`permissions:`
+  and the code checks none. The README's note ("the commands aside from get are intended
+  for admins … Permissions support is coming") is **intent, not enforcement** — a vanilla
+  player can run `/score-add` today.
+
+### 2.4 Reading a score (`/score-get`)
+
+`ScoreGetCommand.java:38-84` → `ScoreKeeperPlugin.getScore(player)` → `getPlayerScore(player)`
+(`ScoreKeeperPlugin.java:76-78, 100-106`). It returns the live integer (0 for a known-but-
+unwritten player, which also *materializes* a 0 entry, see §3.1). Output formatting
+("Your score is N" vs. "PLAYER's score is N") depends only on whether the sender is the
+target or not — it carries no ranking or table.
+
+---
+
+## 3. The high-score-table algorithm  *(task Q3)*
+
+### 3.1 What exists: **nothing. It is aspirational.**
+
+There is **no high-score table, no ranking structure, no sort, no tie-break rule, no max
+entry count, and no decay/rotation** anywhere in the codebase. The task's premise ("the
+high-score table") reflects the **product intent** in the README, not the **code**. Concretely:
+
+- The README (`README.md:11`) says `/score-archive` *"Saves the player's score to a
+  'High Scores' table and resets their current score to 0."*
+- The manifest (`plugin.yml:18-20`) declares `/score-archive` with that very description.
+- But the command is a stub: `ScoreArchiveCommand.java:37-39` (`onCommand` body) replies
+   *"archive command unimplemented"*, and the underlying `archiveScore`
+  (`ScoreKeeperPlugin.java:72-74`) only logs and returns — it neither writes a table nor
+  resets anything.
+
+Therefore the "algorithm" is: **no-op.** A new engineer asked to "implement the high-score
+table" is starting from zero; the design questions in §3.2 are **open**, not answered by code.
+
+### 3.2 Open design questions the table must settle (no code today decides these)
+
+Since no implementation exists, these are *decisions to be made*, recorded here so the
+implementation task doesn't reinvent the debate:
+
+- **Storage/persistence format.** The load/save TODOs (`:47`, `:59`) say "to file";
+  `plugin.yml`/Bukkit convention favors YAML (`YamlConfiguration`), but JSON/SQLite are all
+  viable. **Unchosen.** Persisting to `data/` via `getDataFolder()` is the idiomatic Bukkit
+  path.
+- **What an entry is.** Today a live score is just `{uuid -> int}`. A high-score entry
+  likely needs **player name + score + (timestamp?) + (date earned?)**. Name is *not*
+  currently stored with the score, so a durable table must capture the name at archive
+  time (a UUID-only entry can't render a leaderboard without the name being resolvable).
+- **Sorting / ordering.** Almost certainly **descending by score**.
+- **Tie-breaking.** Undefined. Candidate rules: by *score only*; by *earliest* archived
+  first (stable, time-ordered); by *name* (alphabetical); or "first to reach that score."
+- **Max entries / cap.** Undefined. A leaderboard needs a cap (e.g. top 10 / top 30);
+  today there is no cap because there is no table.
+- **Decay / rotation / time window.** None, and none described in docs — so the safe
+  default is **"scores are permanent, no decay."**
+- **Reset semantics on archive.** README promises archive *resets to 0* *and* records.
+  `ScoreArchiveCommand` must decide: does archiving also reset? Does it allow multi-entries
+  (a player appearing more than once) or one row per player? All open.
+
+### 3.3 Full lifecycle of a score: creation → (intended) display on the high-score table
+
+This is the acceptance-criterion walk-through. Each stage is marked **[REAL]** (in code now)
+or **[GAP]** (intended, not built).
+
+1. **Player joins / acts** — a score *doesn't* exist yet. First interaction with the map is
+   lazy (see stage 4a). **[REAL]**
+2. **Admin records a score** — `admin: /score-add Alice 10`. Parsed in `ScoreAddCommand`,
+   routed to `addScore`. The first time this runs for Alice, `getPlayerScore` **creates**
+   her entry at 0 and returns it; then `10` is written. **[REAL]**
+3. **Score accumulates** — later `/score-add Alice 5` → 15; `/score-subtract Alice 2` → 13;
+   `/score-reset Alice` → 0. All in the in-memory map, live only. **[REAL]**
+4. **Read** — `/score-get Alice` → "Alice's score is 13". No ranking shown. **[REAL]**
+5. **Server restart** — `onDisable` *cannot* save (stub), `onEnable` *cannot* load (stub);
+   the map is **lost**. Alice's 13 is gone; every score starts empty again. **[REAL] —
+   this is the current data-loss reality.**
+6. **Intended: archive to the high-score table** — `admin: /score-archive Alice` should
+   freeze Alice's 13 into a durable, sorted leaderboard and reset her live score to 0, so
+   it survives restarts. **[GAP]** — currently returns "archive command unimplemented".
+7. **Intended: display on the high-score table** — a command (not yet built) renders the
+   capped, sorted list. **[GAP]** — no such command, no structure to render.
+
+**Edge cases (explicitly, per the acceptance criteria):**
+
+- **First-time player / first write.** A player has no map entry until `getPlayerScore` is
+  called, which **inserts `0` on first access** (`ScoreKeeperPlugin.java:100-106`). So a
+  first `/score-add X 10` yields **10, not** `10 - 0` ambiguity, and a first `/score-subtract
+  X 3` yields **−3** (no minimum-0 clamp). A first `/score-get X` returns **0** and
+  *materializes* the entry at 0. This `get-or-create-0` behavior is the de-facto "first-time
+  player" rule. **[REAL]**
+- **Ties.** **Undefined** because no table exists. When the table is built, decide a
+  tie-break (§3.2). No code today can observe or sort ties — `HashMap` gives no order. **[GAP]**
+- **Table full.** **Undefined** because no cap exists. When a cap is introduced, decide
+  what happens to the displaced entry: drop it, or "rotate" it into overflow. No code
+  today enforces a maximum. **[GAP]**
+- **Offline / unknown name.** `getPlayerExact(name)` returns `null` for anyone not
+  currently online or any misspelling → the command prints "Can't find a player with that
+  name" and changes nothing. You **cannot** archive or reset an *offline* player by name
+  today; by-UUID writes (if a future table stores names+UUIDs) would fix that. **[REAL]**
+- **Negative / large scores.** No clamp; negatives allowed, `int` overflow only near
+  ~2.1 billion. **[REAL]**
+- **Double-spawn / relogin.** Keyed by `UUID`, **not name**, so a name change or two
+  players sharing a name can't collide on the *live* map; but a *name* is never stored,
+  so a future table that only persists the UUID can later fail to render a name.
+
+---
+
+## 4. Scoring formulas & weighting  *(task Q4)*
+
+**None.** There is:
+
+- No formula, no multiplier, no combo/bonus/streak logic.
+- No weighting between action types.
+- No time-based decay or "points per game" normalization.
+
+Scores are **pure integer accumulators**: `score = Σ(adds) − Σ(subtracts)` over the session,
+resettable to 0 by `/score-reset` (intended: on `/score-archive`). The only "arithmetic" in
+the code is the `+`/`−` in `addScore`/`subtractScore` and the `0` floor written by
+`resetScore`. `int` semantics apply (wrapping overflow; no checked arithmetic). Any
+formula/weighting is a **future-design** decision, not encoded today.
+
+---
+
+## 5. Data-flow diagram (text)
+
+```
+   ADMINISTRATOR / CONSOLE / RCON        (no game events, no scheduler, no auto-scoring)
+        │  types a command
+        ▼
+  ┌─────────────────────────────┐
+  │  command executors          │  commands/Score*Command.java
+  │  parse args + resolve player│  getPlayerExact(name)  ── must be ONLINE (name→UUID)
+  │  (self-target if player)    │  no permission checks
+  └──────────────┬──────────────┘
+                 │ calls
+                 ▼
+  ┌───────────────────────────────────────────────┐
+  │  ScoreKeeperPlugin (entry point; plugin.yml main)│
+  │                                                 │
+  │  addScore / subtractScore / resetScore / setScore │  read-modify-write on...
+  │  getScore (read)               archiveScore (STUB)│
+  └──────────────┬───────────────────────┬──────────┘
+                 │ read-modify-write       │ (intended: snapshot→table, reset 0)
+                 ▼                        ▼
+   live map: HashMap<UUID, int>            ╳ NOT IMPLEMENTED
+   "score entry = one int per UUID"        high-score table:
+   default 0, no clamp, in RAM only       ─ no structure, no sort,
+        │                                  ─ no persistence,
+        ├─ READ: /score-get → "N"          ─ no cap/decay
+        │
+        └─ LIFECYCLE:
+            onEnable  :  load from file  → TODO (stays {} ; lost on restart)
+            onDisable :  save to file    → TODO (map discarded at shutdown)
+
+   PERSISTENCE:  none  │  SCORE FORMULA: none  │  EVENTS/TIMERS: none  │
+   PERMISSIONS: none  │  HIGH-SCORE TABLE: aspirational stub only
+```
+
+---
+
+## 6. Quick reference — "where to look first"
+
+| I want to understand… | Go to |
+|-----------------------|-------|
+| The entire live data model | `ScoreKeeperPlugin.java:38` (one `HashMap<UUID,Integer>`) |
+| How a score changes | `addScore`/`subtractScore`/`resetScore`/`setScore` `:67-91` |
+| How a score is read | `getScore` `:76-78` → `getPlayerScore` `:100-106` (note get-or-create-0) |
+| The "high-score table" | **Doesn't exist** — see `archiveScore` stub `:72-74`; design open in §3.2 |
+| Persistence (save/load) | `onDisable` `:46-49`, `onEnable` `:59-60` — both `TODO`, not built |
+| Command behaviors | `commands/Score*Command.java` (self-target default; RCON requires a name; exact online-name lookup) |
+| What's declared/intended but not wired | `plugin.yml:18-20` (`/score-archive`), `README.md:11`, `README.md` notes |
+| Build/runtime target | `build.gradle` (paper-api 1.21.7, Java 21), `plugin.yml` (`api-version: 1.21`) |
+
+---
+
+## 7. Risks a new engineer should know (correctness gaps in the *current* live domain)
+
+These are real, not future-work — flagging because the doc's job is to prevent a new
+developer from assuming the system is more mature than it is:
+
+1. **Data loss on restart.** No save/load (`:47`, `:59`). Every server boot wipes all
+   scores. Any "leaderboard across sessions" is broken by design.
+2. **No permissions.** Anyplayer can self-add points. README says this is by intent
+   ("coming after I get archive to work") but it is not enforced.
+3. **Race condition on add/subtract.** `read → compute → write` is not atomic and the
+   `HashMap` is not thread-safe; concurrent command executions could lose an update.
+   (Low likelihood today since commands are serial on one thread, but it's a latent bug for
+   any async/event-driven scoring that gets added.)
+4. **No minimum-0 / no validation of amount sign.** Subtracts produce negatives freely.
+5. **Name lookups are online-only & exact.** Can't target offline players by name;
+   case-sensitive; "Alice" ≠ "alice".
+6. **No high-score table.** The flagship advertised feature (`/score-archive` → "High
+   Scores" table) is a no-op; a new engineer must not expect ranking/persistence to work.
+
+---
+
+## 8. Summary for the synthesizer (`Project.md` § "domain model & scoring logic")
+
+Distilled, code-grounded, and honest:
+
+- **Model:** one `int` per player `UUID`, held in `ScoreKeeperPlugin._playerScores`
+  (`HashMap`), default `0`.
+- **Recording:** manual, admin-driven commands; **no events/timers**; no permission guard.
+- **Persistence:** **none** — load/save are `TODO`; scores are lost on restart.
+- **High-score table:** **does not exist** — `/score-archive` is a stub; sorting/tie-break/
+  cap/decay are **undecided design items** (listed in §3.2).
+- **Formula/weighting:** **none** — plain `int` accumulation.
+- **Lifecycle:** create-on-first-access (0) → add/subtract/reset (live only) → read via
+  `/score-get` → *intended* archive+reset + table display **not built** → lost on restart.
+- **Edge cases:** first-time/first-write ⇒ 0-or-delta, no floor; ties/table-full ⇒ undefined
+  (no table yet); offline/unknown name ⇒ "can't find", unchanged.
+
+Everything below the "high-score table" line of the README is **future work**, and the
+write-up's job is to make that boundary explicit so the next team member isn't misled.

docs/human-tests.md

@@ -0,0 +1,55 @@
+# ScoreKeeper Human Testing
+
+Use this checklist on a disposable Paper 26.2 or 26.3 server. ScoreKeeper stores data in its plugin folder and interacts with online players, command senders, and scheduled high-score runs; a passing build alone does not verify these in-game workflows.
+
+## Test Setup
+
+- Use Java 25 or newer and a backed-up test server. Keep the server log available throughout testing.
+- Create at least two test players: one operator/admin and one ordinary player. Use a console or RCON session for console-sender cases.
+- Before each run, preserve `plugins/ScoreKeeper/scores.yml` and `archives.yml`, or use a fresh test server. Archive, reset, and bucket-wide commands intentionally change scores.
+- Record command sender, arguments, expected and observed messages, and score values before and after each operation.
+
+## Human Checklist
+
+### Startup and score commands
+
+- Start Paper and confirm ScoreKeeper enables, registers every documented command, and loads existing data without errors.
+- As a player, run `/score-get`, `/score-add`, `/score-subtract`, and `/score-reset`; check the displayed values and the configured initial value. Repeat with console/RCON, supplying a player name where required.
+- Try zero, negative, very large, missing, and non-numeric amounts. Confirm invalid input is handled clearly and does not unexpectedly alter a score.
+- Use two players to verify each player's score is independent. Change a player's Minecraft name if practical, then confirm their score remains associated with their UUID.
+- Check singular/plural unit labels at values of 1, 0, and multiple units, and confirm messages show the correct bucket and value.
+
+### Buckets and reporting
+
+- Create a test bucket with a nonzero initial value and distinctive singular/plural labels. Verify invalid IDs, blank labels, and duplicate IDs are rejected cleanly.
+- Switch one player to the bucket, add and subtract points, and confirm other players remain in their own active bucket. Switch back and verify the original score is unchanged.
+- Change the server-wide default with `/score-bucket all <bucketId>`. Confirm individual assignments are cleared, online players receive the appropriate change notice, and new players use the new default.
+- For each reporting policy (`none`, `player`, `admin`, `global`), change a score and verify exactly the intended audience receives the report. Test with an operator, a `scorekeeper.admin` player, an ordinary player, and the scored player.
+- Exercise bucket creation, switching, and administration as authorized and unauthorized senders. The README says archive, bucket administration, and run management require `scorekeeper.admin`; verify the behavior on the target server.
+- Note that the README says score get/add/subtract/reset currently have no permission checks and can target any online player. Confirm that exposure is acceptable for the server before enabling these commands publicly.
+
+### Archives
+
+- Archive one player's active-bucket score, then inspect `/score-archive-list` and `/score-archive-list <archiveId>`. Confirm the saved value and bucket are correct and the live score returns to that bucket's initial value.
+- Repeat for `/score-archive bucket <bucketId>` and `/score-archive all`. Confirm only the selected bucket or all buckets are archived and reset as requested.
+- Check archive IDs are listed newest first, then restart and confirm archives and their contents remain available.
+- Try an unknown archive ID or bucket ID and verify a useful failure without unrelated scores being changed.
+
+### High-score runs
+
+- Start a target-score run and a timed run using a test bucket and at least three players. Confirm the run starts with the requested top-N and reset setting.
+- Change scores for players inside and outside the current top-N. Verify individual score-change messages and global reporting for current top-N players match the run behavior.
+- End runs by reaching the target, expiration, and `/score-run stop`. Also start an `until-disabled` run and stop it manually.
+- Check final ranking order, ties, each online player's reported place, and the displayed top-N cutoff.
+- With reset enabled, verify scores begin at the bucket initial value and pre-run scores are restored after completion. With reset disabled, confirm scores remain as earned.
+- Restart while a run is active. Confirm the run and reset snapshot survive, timed runs expire at the intended time, and stopping or completing the run produces one final result rather than duplicate results.
+
+### Persistence and upgrades
+
+- Restart after changing scores, bucket definitions, reporting policies, the default bucket, and per-player bucket assignments. Verify all values and assignments persist.
+- Test a clean data folder and an existing/older `scores.yml` or `archives.yml` on a backed-up server. Confirm startup handles defaults, known legacy data, and malformed or unknown entries without silently corrupting valid data.
+- Check saved files after a clean shutdown and after a forced test restart; distinguish expected last-save behavior from data loss.
+
+## Automated Coverage
+
+There are currently no Java test sources or test dependencies in this project, and no integration-test source set. The Gradle `test` task therefore does not currently exercise ScoreKeeper behavior. All scenarios above should be treated as unverified until tested in-game; the “Ready” test tasks in `TODO.md` describe work that has not yet been added.

docs/modrinth-description.md

@@ -0,0 +1,49 @@
+**ScoreKeeper Plugin**
+
+ScoreKeeper tracks player scores in configurable buckets. Use it for event points, competitions, or other server-side scoring systems, and integrate it with other plugins through the public API.
+
+## Commands
+
+Players can omit an optional player name to target themselves. Console and RCON must provide a player name for score get/add/subtract/reset commands.
+
+* `/score-get [playerName]` - Displays the target player's score in their active bucket.
+* `/score-add <amount>` - Adds an amount to your score in your active bucket.
+* `/score-add <playerName> <amount>` - Adds an amount to the target player's score.
+* `/score-subtract <amount>` - Subtracts an amount from your score in your active bucket.
+* `/score-subtract <playerName> <amount>` - Subtracts an amount from the target player's score.
+* `/score-reset [playerName]` - Resets the target player's active-bucket score to that bucket's initial value.
+* `/score-archive` - Archives and resets your score in your active bucket.
+* `/score-archive <playerName>` - Archives and resets the target player's score in their active bucket.
+* `/score-archive all` - Archives and resets scores in every bucket.
+* `/score-archive bucket <bucketId>` - Archives and resets every score in one bucket.
+* `/score-archive-list` - Lists saved archive IDs, newest first.
+* `/score-archive-list <archiveId>` - Displays the saved scores in one archive.
+* `/score-bucket` - Displays your active bucket.
+* `/score-bucket <bucketId>` - Switches your active bucket.
+* `/score-bucket create <id> <singular> <plural> <initialValue> [reporting]` - Creates a bucket. Reporting can be `admin`, `global`, `player`, or `none` (default).
+* `/score-bucket <playerName> <bucketId>` - Switches a player's active bucket.
+* `/score-bucket all <bucketId>` - Changes the server's default bucket and clears individual bucket assignments.
+* `/score-run start <bucketId> <topN> <reset:true|false> target <score>` - Starts a run that ends when a score reaches the target.
+* `/score-run start <bucketId> <topN> <reset:true|false> duration <time>` - Starts a timed run. Use a positive number and lowercase `s`, `m`, `h`, `d`, or `w`, such as `4h`.
+* `/score-run start <bucketId> <topN> <reset:true|false> until-disabled` - Starts a run with no automatic end.
+* `/score-run stop <bucketId>` - Ends an active run.
+
+## Permissions
+
+The `scorekeeper.admin` permission (default: operators) is required for archive commands, bucket creation/administration, and high-score run management. Score get/add/subtract/reset and archive-list commands currently have no permission checks; add, subtract, and reset can target any online player.
+
+## Features
+
+* Create score buckets with custom singular/plural labels, initial values, and reporting policies.
+* Reporting can notify operators/admins, everyone online, only the scored player, or nobody.
+* Start target-score, timed, or until-disabled high-score runs with configurable top-N standings and optional score resets.
+* Archive player, bucket, or all-bucket scores; archived scores reset to their bucket's initial value.
+* Persist bucket definitions, assignments, scores, active runs, and archives in the plugin's data folder.
+
+## API
+
+Other plugins can create buckets with `createBucket(id, singular, plural, initialValue, reporting)`, use bucket-aware score methods, and start or stop high-score runs with `startTargetScoreRun`, `startTimedScoreRun`, `startUntilDisabledScoreRun`, and `stopHighScoreRun`.
+
+## Compatibility
+
+Built exclusively for Paper 26.2 and 26.3 with the Paper API and Adventure APIs. Bukkit and Spigot servers are not supported.

docs/modrinth.json

@@ -0,0 +1,13 @@
+{
+  "name": "Score Keeper",
+  "url": "https://modrinth.com/plugin/scorekeeper",
+  "summary": "Track player scores in configurable buckets with custom reporting, high-score runs, and archives. Includes in-game commands and an API for other plugins.",
+  "visibility": "public",
+  "links": {
+    "issueTracker": "https://github.com/headhunter45/ScoreKeeper/issues",
+    "sourceCode": "https://github.com/headhunter45/ScoreKeeper",
+    "wikiPage": null,
+    "discordInvite": null,
+    "donationLinks": []
+  }
+}

docs/plugin-integration-and-event-wiring.md

@@ -0,0 +1,166 @@
+# ScoreKeeper — Plugin Integration & Event/Command Reference
+
+> Analysis for the ScoreKeeper codebase. Scope: how the plugin hooks into the
+> Minecraft (Paper) server runtime — event listeners, command registrations,
+> scheduled/tick logic, and inter-plugin/API surface — with a table mapping each
+> trigger → handler class → effect on score data.
+>
+> Platform: **Paper** (`io.papermc.paper:paper-api:1.21.7-R0.1-SNAPSHOT`), Java 21,
+> Gradle. Main class: `com.majinnaibu.minecraft.plugins.scorekeeper.ScoreKeeperPlugin`.
+
+---
+
+## 1. TL;DR for a new developer
+
+ScoreKeeper is almost entirely **command-driven**. It registers **no Bukkit event
+listeners**, declares **no `@EventHandler` methods, no `Listener` implementations,
+and calls `getPluginManager().registerEvents(...)` nowhere**. It also schedules
+**no timed tasks** (no `BukkitScheduler`/`BukkitRunnable`/tick logic).
+
+The only things that touch score state are **five console/chat commands**
+(`score-get`, `score-add`, `score-subtract`, `score-reset`, `score-archive`).
+Score state lives in an **in-memory `HashMap<UUID, Integer>`** and is **not
+persisted** — `onEnable`/`onDisable` have `TODO` stubs, so data is lost on restart.
+
+There is a **`highscore` / high-score table in the project name and the task
+prompt, but no such command or logic exists yet** — it is unimplemented.
+
+---
+
+## 2. Event listeners (Bukkit/Adventure)
+
+**None.** The plugin listens to no server events. Confirmed by absence of any of:
+`@EventHandler`, `implements Listener`, `registerEvents(`, `PlayerJoinEvent`,
+`PlayerQuitEvent`, `PlayerDeathEvent`, or any other event import/registration.
+
+| Server event | Handler | Effect on score data |
+|---|---|---|
+| PlayerJoin | *none* | none |
+| PlayerQuit | *none* | none |
+| PlayerDeath | *none* | none |
+| (all other Bukkit events) | *none* | none |
+| Custom/plugin-injected events | *none* | none |
+
+**Implication:** nothing about a player's score changes as a result of gameplay
+events (joining, quitting, dying, scoring points in-game, etc.). The only way
+score data changes is through the commands in §3.
+
+---
+
+## 3. Command registrations & permissions
+
+Commands are declared in `src/main/resources/plugin.yml` (no `aliases`, no
+`permissions:` block, and no per-command `permission:` — so **every command is
+available to every sender with no permission gating**). Each is wired to an
+executor in `ScoreKeeperPlugin.onEnable()`.
+
+Argument-resolution idiom shared by every handler:
+`boolean rcon = !(sender instanceof Player);` — an RCON caller has no self
+context, so the "target = self" shortcut is unavailable and a `<playerName>`
+must be supplied.
+
+`<playerName>` is resolved with `server.getPlayerExact(name)` — an **exact,
+case-sensitive lookup of currently-online players only**. Score operations
+therefore apply to **online players**, and an unknown/offline name yields a
+"Can't find a player with that name" error (except where noted).
+
+### Reference table — command → handler class → effect on score data
+
+| Trigger (command) | Usage | Handler class | Delegates to | Effect on score data |
+|---|---|---|---|---|
+| `score-get` | `/score-get [player]` | `ScoreGetCommand` | `ScoreKeeperPlugin.getScore(Player)` → `getPlayerScore` | **Read only.** Returns the player's current score. Side effect: lazily registers the player at `0` if unseen. No persistent change. |
+| `score-add` | `/score-add [player] <amount>` | `ScoreAddCommand` | `ScoreKeeperPlugin.addScore(Player,int)` | `score = old + amount` (integer `amount` in `[1..]`). |
+| `score-subtract` | `/score-subtract [player] <amount>` | `ScoreSubtractCommand` | `ScoreKeeperPlugin.subtractScore(Player,int)` | `score = old - amount` (can go negative). |
+| `score-reset` | `/score-reset [player]` | `ScoreResetCommand` | `ScoreKeeperPlugin.resetScore(Player)` | `score = 0` (writes 0; key created if absent). |
+| `score-archive` | `/score-archive [player]` | `ScoreArchiveCommand` | *nothing* | **No state change.** Handler prints `"archive command unimplemented"`. It does **not** call `ScoreKeeperPlugin.archiveScore(...)` — see §5. |
+
+### Command behaviour details
+
+- **Sender vs. target.** Single-arg form means "operate on the invoking player"
+  (`split.length == 1` → `targetPlayer = sender`). Two-arg form means
+  `<playerName> <amount>` (add/subtract) or `<playerName>` (get/reset). For an
+  RCON sender, the single-arg form is treated as missing a target and prints
+  usage instead.
+- **Amount parsing.** `score-add`/`score-subtract` require an integer
+  `amount`; a non-integer prints `"amount must be an integer"`.
+- **Error/usage messaging.** `echoError` (red) and `echoUsage` (colour-coded)
+  differ between player and RCON call sites (`/score-add` vs `score-add`).
+  All handlers `return true` (command handled).
+- **Permissions.** None declared → no operator/permission requirement; any
+  player or RCON can run them.
+
+---
+
+## 4. Scheduled tasks / tick-based logic
+
+**None.** Confirmed by absence of `getScheduler()`, `runTask`,
+`BukkitRunnable`, `BukkitTask`, `scheduleSync*`, or any periodic/repeating
+logic. ScoreKeeper runs no background or tick-driven work.
+
+---
+
+## 5. Inter-plugin dependencies & API exposure
+
+- **Declared dependencies:** plugin.yml has no `depend`, `softdepend`, `load`,
+  or `load-before` → **no declared inter-plugin coupling**.
+- **Build dependency:** the only third-party dependency is
+  `io.papermc.paper:paper-api` (marked `compileOnly`, and explicitly ignored as a
+  snapshot by the release plugin). No other plugin/API is referenced.
+- **Public API surface.** `ScoreKeeperPlugin` is a plain `JavaPlugin` exposing
+  `public` methods that other plugins *could* call if they hold a reference:
+  - `void addScore(Player, int)`
+  - `void subtractScore(Player, int)`
+  - `int getScore(Player)`
+  - `void setScore(Player, int)` — **public but used by no command** (internal
+    write path; the only writer not reachable via a command).
+  - `void resetScore(Player)`
+  - `void archiveScore(Player)` — **public but called by nothing**; it only logs
+    a warning. The `/score-archive` command does **not** invoke it.
+  - `void sendMessage(CommandSender, Component)`, `logInfo/logWarning/logError`
+- **No formal service registration.** There is no `registerService`/`asService`
+  (ServiceLoader), no dedicated API artifact, and no `api:` block in plugin.yml.
+  Exposure is by **public method surface only** — informal and not discoverable
+  by other plugins.
+- **Persistence (unimplemented).** `onEnable` logs a warning that load-from-file
+  is unimplemented; `onDisable` logs that save-to-file is unimplemented. The
+  `HashMap<UUID,Integer>` is the sole state store and is **forgotten on restart**.
+
+---
+
+## 6. Lifecycle
+
+| Hook | What it does |
+|---|---|
+| `onEnable()` | Wires the five `score-*` command executors; logs the "load not implemented" warning and an enable log line. |
+| `onDisable()` | Logs the "save not implemented" warning. **All in-memory scores are lost on shutdown.** |
+
+---
+
+## 7. State model (quick reference)
+
+- **Store:** `private HashMap<UUID,Integer> _playerScores` on `ScoreKeeperPlugin`
+  (one map field for the whole plugin).
+- **Keying:** by `Player.getUniqueId()` (UUID), so scores are per-player and
+  survive name changes *within a single server run*; lost on restart.
+- **Lazy init:** any read (including `get`/`score-get`) auto-creates the key at `0`.
+- **Writers:** `addScore`, `subtractScore`, `resetScore`, `setScore`, all funneled
+  through `setPlayerScore(player, value)`.
+- **Concurrency:** plain `HashMap`; safe today only because command dispatch
+  runs on the server's main thread. Not thread-safe for off-thread use.
+
+---
+
+## 8. "Which server trigger causes which state change" — summary
+
+| Trigger | State change |
+|---|---|
+| `/score-add [player] <amount>` | `_playerScores[uuid] += amount` |
+| `/score-subtract [player] <amount>` | `_playerScores[uuid] -= amount` |
+| `/score-reset [player]` | `_playerScores[uuid] = 0` |
+| `/score-get [player]` | none (reads; lazily registers at 0) |
+| `/score-archive [player]` | none (not implemented) |
+| Any Minecraft/Bukkit event (join/quit/death/etc.) | **none — no listeners exist** |
+| Server tick / scheduled task | **none — no scheduler exists** |
+| Server enable | no data change (registration + log only) |
+| Server disable | in-memory scores discarded (no persistence) |
+| `addScore`/`subtractScore`/`setScore`/`archiveScore` via the public API | same table where called; only reachable by code holding a plugin reference, not by in-game events or commands (except add/subtract/reset which do have commands) |

docs/project-description.json

@@ -0,0 +1,23 @@
+{
+  "id": "scorekeeper",
+  "title": "ScoreKeeper",
+  "description": "A reusable Paper 26.2/26.3 scoring engine with named buckets, custom reporting, persistent archives, high-score runs, player commands, and a public API for companion plugins.",
+  "docId": "ScoreKeeper",
+  "image": {
+    "url": "https://image.pollinations.ai/prompt/pixel%20art%20Minecraft%20server%20scoreboard%20with%20a%20glowing%20diamond%20and%20number%20counters%2C%20clean%20square%20game%20plugin%20thumbnail%2C%20no%20text",
+    "alt": "Pixel art scoreboard with a diamond for the ScoreKeeper Minecraft plugin",
+    "prompt": "Pixel art Minecraft server scoreboard with a glowing diamond and number counters, clean square game plugin thumbnail, no text",
+    "width": 1024,
+    "height": 1024,
+    "backgroundClassName": "bg-surface"
+  },
+  "url": "/projects/scorekeeper",
+  "tags": [],
+  "source": {
+    "type": "",
+    "url": ""
+  },
+  "feedback": {
+    "url": ""
+  }
+}

docs/project-description.md

@@ -0,0 +1,12 @@
+# ScoreKeeper
+
+ScoreKeeper is a reusable scoring engine for Paper 26.2 and 26.3. It gives events, competitions, and companion plugins a shared language for points: named buckets can have custom singular/plural labels, initial values, reporting policies, archives, and high-score runs.
+
+The plugin is both a player-facing command system and an extension point. Administrators can start target-based, timed, or manually stopped score runs, while other plugins can create buckets, award points, archive results, and build richer game loops through the public API. Scores, assignments, runs, and archives persist across server restarts. Bukkit and Spigot servers are not supported.
+
+## Engineering Notes
+
+- Built with Gradle and Java 25 for modern Paper.
+- Uses UUID-based player identity and YAML-backed persistence.
+- Includes server-free JUnit coverage for domain rules, commands, reporting, archives, and lifecycle behavior.
+- Designed as the scoring foundation used by companion plugins such as MobScores.

docs/project-reference.md

@@ -0,0 +1,280 @@
+# ScoreKeeper — Project Reference
+
+> **For a developer joining the team cold.** Read top-to-bottom in ~8 minutes;
+> you'll know where to look and what's real vs. planned on day one.
+
+---
+
+## 1. What is ScoreKeeper?
+
+ScoreKeeper is a **Paper Minecraft plugin** (Java 25, Paper/Adventure APIs) that manages player
+score tracking. It exposes five in-game/console commands (`/score-get`, `/score-add`,
+`/score-subtract`, `/score-reset`, `/score-archive`) for manual score manipulation — no events,
+no timers, no automation.
+
+**State of the project:** live in-memory scores work today; the \"high-score table\" advertised
+in the README name and `/score-archive` description is **not implemented**. Persistence, ranking,
+and scoring formulas are all **future scope**. See §4 for the gap between *what exists* and
+*what is planned*.
+
+---
+
+## 2. Tech Stack & Build
+
+| Item | Value |
+|------|-------|
+| Language | Java 21 (Gradle auto-downloads toolchain) |
+| Runtime target | Paper 26.2 and 26.3 |
+| Build tool | Gradle 8.14.3 (`gradlew`) |
+| Linting | Spotless (`googleJavaFormat()` + license header from `config/license-header.txt`) |
+| Versioning | `org.danilopianini.git-sensitive-semantic-versioning`; minimum version `0.2.1`; reads `vX.Y.Z` tags |
+| External deps | **None at runtime.** The Paper API is `compileOnly` only. |
+| CI/release entry point | Run `./gradlew spotlessCheck build`, tag the release commit (for example, `git tag -a v0.2.2 -m "Release v0.2.2"`), then rebuild to produce the stable release artifact |
+
+### Build quickly
+
+```bash
+./gradlew build          # compiles, runs tests (none yet)
+./gradlew spotlessApply  # format to project style
+./gradlew assemble       # produces jar in build/libs/
+```
+
+Drop the resulting jar onto a Paper server's `plugins/` directory.
+
+---
+
+## 3. Architecture Overview
+
+### Directory layout
+
+```
+├── src/main/java/com/majinnaibu/minecraft/plugins/scorekeeper/
+│   ├── ScoreKeeperPlugin.java        ← entry point, onEnable/onDisable, score CRUD core
+│   └── commands/
+│       ├── ScoreGetCommand.java      → /score-get [player]
+│       ├── ScoreAddCommand.java      → /score-add [player] <amount>
+│       ├── ScoreSubtractCommand.java → /score-subtract [player] <amount>
+│       ├── ScoreResetCommand.java    → /score-reset [player]
+│       └── ScoreArchiveCommand.java  → /score-archive [player] (stub)
+├── src/main/resources/
+│   └── plugin.yml                    ← command manifest + main-class declare
+├── tools/bash/ & tools/powershell/  ← dev helper scripts
+├── config/license-header.txt         ← Spotless license header
+├── build.gradle                      ← Gradle build config (above)
+├── gradle.properties                 ← version, group coordinates
+├── CONTRIBUTING.md                   ← dev env setup
+└── README.md                         ← user-facing command reference + notes
+```
+
+### Data flow (text diagram)
+
+```
+ADMIN / CONSOLE / RCON ──▶ types a /score-* command
+                              │
+                              ▼
+                 ┌──────────────────────┐
+                 │ 5× Score*Command.java│   executors parse args,
+                 │ resolves target      │   resolvePlayerExact(name) (online-only)
+                 └──────────┬───────────┘
+                            │ calls
+                            ▼
+              ┌──────────────────────────────┐
+              │  ScoreKeeperPlugin            │
+              │                                │
+              │  addScore / subtractScore     │  read-modify-write
+              │  resetScore / setScore        │
+              │  getScore (read)              │
+              │  archiveScore (STUB — no-op) │
+              └──────────┬───────────────────┘
+                         │
+                         ▼
+               HashMap<UUID, Integer>   ← in RAM only
+                 _playerScores          ← ScoreKeeperPlugin:38
+```
+
+**Key architectural facts:**
+
+- **Single class owns everything.** `ScoreKeeperPlugin` holds the scores map, score CRUD
+  methods, logging helpers (logWarning/logInfo/logError), and the Adventure component builder
+  for chat color. There is no service layer or boundary separation.
+- **No event listeners.** Zero `@EventHandler`/`Listener` registrations across the codebase.
+  Game events (join, death, kill) do not affect scores. Only manual commands change state.
+- **No scheduler or tick logic.** No periodic tasks, no countdowns, no automated scoring.
+- **No permission nodes.** Every command is available to every sender (player, console, RCON).
+
+### File: ScoreKeeperPlugin.java (`ScoreKeeperPlugin`)
+
+- `main` class in `plugin.yml` (Paper plugin entry point)
+- `HashMap<UUID, Integer> _playerScores` at line 38 — the sole score store
+- `onEnable()` (line 52): wires five command executors, logs \"load not implemented\" warning
+- `onDisable()` (line 46): logs \"save not implemented\" warning — scores lost on shutdown
+- Score CRUD methods: `addScore`, `subtractScore`, `resetScore`, `setScore`, `getScore`,
+  `archiveScore` (lines 67–91, 76–86, 72–74)
+- Private helpers: `getPlayerScore(Player)` (get-or-create at 0), `setPlayerScore(Player,int)`
+
+---
+
+## 4. Domain Model & Scoring Logic
+
+### 4.1 What exists today (REAL — in code)
+
+| Aspect | Detail | Source |
+|--------|--------|--------|
+| Score model | Single `int` per player, keyed by UUID | `ScoreKeeperPlugin:38` |
+| Storage container | `HashMap<UUID, Integer>` on plugin instance | same file |
+| Default value | `0` — lazy-created on first map access | `getPlayerScore:100-106` |
+| Live only | **No persistence.** Scores erased on server restart | `onEnable:59`, `onDisable:47` |
+| Scoring direction | Any integer (negatives allowed, no floor) | add/subtract are raw `+`/`-` |
+| Recording method | Manual commands only — `/score-add`, `/score-subtract` | command executors |
+| Auto-scoring | **None** — no events, no timers | proven by grep across src/ |
+| Permissions | **None declared.** All commands open to all senders | `plugin.yml`, no permission guard in code |
+
+### 4.2 Open Score Lifecycle (what exists + what is planned)
+
+```
+Stage  1. First access — getPlayerScore() auto-creates key at 0   [REAL]
+         2. Admin runs /score-add player N or /score-subtract       [REAL]
+         3. Player accumulates points over the session             [REAL]
+         4. Read via /score-get (read-only, lazily registers)      [REAL]
+         5. Server restart — scores LOST on shutdown               [REAL]
+         6. Intended: /score-archive freezes score → table        [GAP ✓ not built]
+         7. Intended: high-score table display command            [GAP ✓ not built]
+```
+
+### 4.3 The "high-score table" — status
+
+| Feature | Status | Details |
+|---------|--------|---------|
+| `/score-archive` | **Stub** | Command prints \"archive command unimplemented\"; `archiveScore()` method only logs, never writes a table or resets the player's score |
+| Persistence (save) | **Not built** | `onDisable()` is a TODO stub — map discarded at shutdown |
+| Persistence (load) | **Not built** | `onEnable()` is a TODO stub — map always starts empty `{}` |
+| Sorting / ranking | **Not coded** | No sort, no tie-breaking, no entry cap, no decay logic exists |
+| Scoring formulas | **Not coded** | Scores are plain integer accumulators (`Σ(adds) − Σ(subtracts)`) |
+
+**Design decisions to be made (none answered by code today):**
+
+- Storage format for the table (YAML per Bukkit convention; JSON? SQLite?)
+- What an entry looks like (name + score + timestamp? name is not stored with score today)
+- Sort order and tie-breaking strategy
+- Max entries / leaderboard cap
+- Whether `/score-archive` also resets the live score (README says it does)
+
+---
+
+## 5. Plugin Integration & Reference Table
+
+### 5.1 Command → Handler → Effect on score data
+
+| Trigger | Usage | Handler | Effect |
+|---------|-------|---------|--------|
+| `/score-get [player]` | Self or other | `ScoreGetCommand.java:38-84`, delegated to `getScore → getPlayerScore` | **Read-only.** Returns integer. Lazily creates entry at `0` if unseen. |
+| `/score-add [player] <N>` | Self (omit name) or target others | `ScoreAddCommand.java` | `score += N`. Amount must parse as int. No direction validation (negative N still adds). |
+| `/score-subtract [player] <N>` | Same | `ScoreSubtractCommand.java` | `score -= N`. No minimum clamping; negatives freely produced. |
+| `/score-reset [player]` | Same | `ScoreResetCommand.java` | `score = 0`. Key created at `0` if absent. |
+| `/score-archive [player]` | Same | `ScoreArchiveCommand.java` | **No-op.** Prints \"archive command unimplemented\". Does NOT call the `archiveScore()` method. |
+
+### 5.2 Shared behavior details
+
+Every executor follows this pattern:
+
+1. Parse arguments — if `split.length == 1` and sender is a player, target = self (RCON/console
+   requires an explicit `<playerName>` or prints usage).
+2. Resolve target player via `server.getPlayerExact(name)` — **exact, case-sensitive, online-only.**
+3. Call the corresponding `ScoreKeeperPlugin` method.
+4. Echo color-coded result; return `true`.
+
+### 5.3 Inter-plugin / public API surface
+
+`ScoreKeeperPlugin` exposes these public methods that other plugins *could* call if they hold a reference
+(but there is **no formal service registration**):
+
+| Method | Visibility | Called by commands? | Notes |
+|--------|------------|---------------------|-------|
+| `addScore(Player, int)` | `public` | Yes (`/score-add`) | Read-modify-write on `_playerScores` |
+| `subtractScore(Player, int)` | `public` | Yes (`/score-subtract`) | Same pattern |
+| `getScore(Player)` | `public` | Yes (`/score-get`) | Wrapper around `getPlayerScore` |
+| `setScore(Player, int)` | `public` | **No** | Internal write path only; not hooked to any command |
+| `resetScore(Player)` | `public` | Yes (`/score-reset`) | Sets to `0` |
+| `archiveScore(Player)` | `public` | **No** | Only logs a warning; never called by the archive command |
+
+### 5.4 Concurrency note
+
+The map is a plain `HashMap`. Safe because Paper dispatches commands on the server's single main
+thread — but it is **not safe for off-thread use**. Any future event-driven scoring that runs
+asynchronously could corrupt state via non-atomic read-modify-write.
+
+---
+
+## 6. Configuration Reference
+
+| File | Format | Purpose |
+|------|--------|---------|
+| `plugin.yml` | YAML (Bukkit manifest) | Declares main class, api-version, five commands + descriptions/usage strings |
+| `build.gradle` | Gradle Kotlin (Groovy DSL) | Dependencies, task config, release/spotless settings |
+| `gradle.properties` | Properties | Project version and group coordinates (for Maven publishing) |
+| **No `config.yml`** | — | ScoreKeeper has **no player-editable configuration**. |
+| **No `permissions:` block** | — | No permission nodes declared; all commands are open. Plans say \"permissions coming after archive works.\" |
+
+---
+
+## 7. Running & Testing Locally
+
+### Build
+
+```bash
+./gradlew assemble           # produces ScoreKeeper.jar in build/libs/
+```
+
+### Run locally (Paper server)
+
+1. Download Paper 26.2 or 26.3 from `https://papermc.io`
+2. Copy the built jar into `plugins/`
+3. Start the server, verify onEnable logs:
+   ```
+   [ScoreKeeper] ScoreKeeper version X.Y.Z is enabled.
+   [ScoreKeeper] Unable to load scores from file. This feature is not implemented yet.
+   ```
+
+### Commands (in-game or via RCON/console)
+
+| Test scenario | Command | Expected output |
+|--------------|---------|-----------------|
+| Check own score | `/score-get` | \"Your score is 0\" (creates entry at 0) |
+| Add points to self | `/score-add 10` | \"You gained 10 points! Now have 10.\" |
+| Subtract from self | `/score-subtract 5` | \"You lost 5 points! Now have 5.\" |
+| Check another player | `/score-get PlayerName` | \"PlayerName's score is N.\" (must be online) |
+| Reset own score | `/score-reset` | \"Your score has been reset to 0.\" |
+| Archive (stub) | `/score-archive` | \"archive command unimplemented\" |
+
+### Tests
+
+- **No unit/integration tests exist yet.** `./gradlew test` runs an empty suite. Consider
+  adding tests for `ScoreKeeperPlugin`'s private `Player` score state mocking in a future task.
+
+---
+
+## 8. Where to Look First
+
+| I want to understand… | Go to |
+|----------------------|-------|
+| The entire live data model | `ScoreKeeperPlugin:38` — one `HashMap<UUID, Integer>` field |
+| How scores change (write path) | `addScore(/:67-70)`, `subtractScore(/:88-91)`, `setPlayerScore(/:108-110)` |
+| How a player is looked up | `getPlayerExact(name)` online only — see any `*Command.java` line ~50 |
+| First-time-player behavior | `getPlayerScore(/:100-106)` — auto-inserts `0` on first access |
+| High-score / archive table | **Does not exist.** See `archiveScore(/:72-74)` stub; design decisions in §4.3 |
+| Persistence (save/load) | `onDisable(/:47)`, `onEnable(/:59)` — both TODO, nothing writes to disk |
+| What's declared/intended but not wired | `plugin.yml:18-20` (`/score-archive`), `README.md:11` and README notes |
+| Command implementations | `commands/Score*Command.java` (all 5 handlers) |
+| Build/runtime config | `build.gradle`, `plugin.yml`, `gradle.properties` |
+| Dev env / CONTRIBUTING | `CONTRIBUTING.md` |
+---
+
+## Appendix: Risk Summary
+
+| # | Issue | Impact | Section |
+|---|-------|--------|---------|
+| 1 | **Data loss on restart** — no save/load implemented | Every server boot wipes all scores (§4.1) | §4.1 |
+| 2 | **No permissions** — any player can self-add points | Integrity of scoring is unenforceable today (§5.2) | §5.2 |
+| 3 | **Race condition on add/subtract** — non-atomic read-modify-write on plain `HashMap` | Corrupt state if future event-driven scoring runs async (§5.4) | §5.4 |
+| 4 | **No `int` overflow safety** — Java wrapping semantics apply | Undetectable score corruption near ±2.1 billion | §4.1 |
+| 5 | **Name lookups online-only & case-sensitive** | Can't target offline players; \"Alice\" ≠ \"alice\" (§5.2) | §5.2 |

gradle.properties

@@ -1,3 +1,5 @@
-version=0.2.2-SNAPSHOT
+org.gradle.configuration-cache=true
+org.gradle.daemon=true
 org.gradle.java.installations.auto-download=true
-
+org.gradle.java.installations.auto-detect=false
+org.gradle.java.installations.fromEnv=JAVA_HOME

gradle/wrapper/gradle-wrapper.properties

@@ -1,7 +1,8 @@
-distributionBase=GRADLE_USER_HOME
+distributionBase=PROJECT
-distributionPath=wrapper/dists
+distributionPath=.gradle/wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-8.14.3-bin.zip
+distributionSha256Sum=bafd5ce9cfaea0fbccfdc8439a1ac42fbd4cd9c89dc9a988228d8a2639a58e6c
+distributionUrl=https\://services.gradle.org/distributions/gradle-9.8.0-bin.zip
 networkTimeout=10000
 validateDistributionUrl=true
-zipStoreBase=GRADLE_USER_HOME
+zipStoreBase=PROJECT
-zipStorePath=wrapper/dists
+zipStorePath=.gradle/wrapper/dists

settings.gradle

@@ -1,5 +1,5 @@
 plugins {
-	id 'org.gradle.toolchains.foojay-resolver-convention' version '0.9.0'
+	id 'org.gradle.toolchains.foojay-resolver-convention' version '1.0.0'
 }
 
 rootProject.name = 'ScoreKeeper'

src/main/java/com/majinnaibu/minecraft/plugins/scorekeeper/ScoreBucket.java

@@ -0,0 +1,71 @@
+/*
+This file is part of Score Keeper.
+
+Score Keeper is free software: you can redistribute it and/or modify
+it under the terms of the GNU Affero General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+Score Keeper is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Affero General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License
+along with Score Keeper. If not, see <https://www.gnu.org/licenses/agpl-3.0.txt>.
+*/
+
+package com.majinnaibu.minecraft.plugins.scorekeeper;
+
+public final class ScoreBucket {
+  private final String _id;
+  private final String _singular;
+  private final String _plural;
+  private final int _initialValue;
+  private final ScoreReporting _reporting;
+
+  public ScoreBucket(String id, String singular, String plural, int initialValue) {
+    this(id, singular, plural, initialValue, ScoreReporting.NONE);
+  }
+
+  public ScoreBucket(
+      String id, String singular, String plural, int initialValue, ScoreReporting reporting) {
+    if (id == null || !id.matches("[A-Za-z0-9_-]+")) {
+      throw new IllegalArgumentException("Bucket ID must contain only letters, numbers, _ or -");
+    }
+    if (singular == null || singular.isBlank()) {
+      throw new IllegalArgumentException("Bucket singular label cannot be blank");
+    }
+    if (plural == null || plural.isBlank()) {
+      throw new IllegalArgumentException("Bucket plural label cannot be blank");
+    }
+    if (reporting == null) {
+      throw new IllegalArgumentException("Bucket reporting policy cannot be null");
+    }
+    _id = id;
+    _singular = singular;
+    _plural = plural;
+    _initialValue = initialValue;
+    _reporting = reporting;
+  }
+
+  public String getId() {
+    return _id;
+  }
+
+  public String getSingular() {
+    return _singular;
+  }
+
+  public String getPlural() {
+    return _plural;
+  }
+
+  public int getInitialValue() {
+    return _initialValue;
+  }
+
+  public ScoreReporting getReporting() {
+    return _reporting;
+  }
+}

src/main/java/com/majinnaibu/minecraft/plugins/scorekeeper/ScoreKeeperPlugin.java

@@ -17,25 +17,45 @@ along with ScoreKeeper. If not, see <https://www.gnu.org/licenses/agpl-3.0.txt>.
 
 package com.majinnaibu.minecraft.plugins.scorekeeper;
 
-import java.util.HashMap;
+import java.io.File;
+import java.io.IOException;
+import java.time.Duration;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Locale;
+import java.util.Map;
+import java.util.Objects;
 import java.util.UUID;
 import java.util.logging.Level;
 
 import com.majinnaibu.minecraft.plugins.scorekeeper.commands.ScoreAddCommand;
 import com.majinnaibu.minecraft.plugins.scorekeeper.commands.ScoreArchiveCommand;
+import com.majinnaibu.minecraft.plugins.scorekeeper.commands.ScoreArchiveListCommand;
+import com.majinnaibu.minecraft.plugins.scorekeeper.commands.ScoreBucketCommand;
 import com.majinnaibu.minecraft.plugins.scorekeeper.commands.ScoreGetCommand;
 import com.majinnaibu.minecraft.plugins.scorekeeper.commands.ScoreResetCommand;
+import com.majinnaibu.minecraft.plugins.scorekeeper.commands.ScoreRunCommand;
 import com.majinnaibu.minecraft.plugins.scorekeeper.commands.ScoreSubtractCommand;
 
 import net.kyori.adventure.text.Component;
 import net.kyori.adventure.text.format.NamedTextColor;
 
 import org.bukkit.command.CommandSender;
+import org.bukkit.configuration.ConfigurationSection;
+import org.bukkit.configuration.file.YamlConfiguration;
 import org.bukkit.entity.Player;
 import org.bukkit.plugin.java.JavaPlugin;
 
 public class ScoreKeeperPlugin extends JavaPlugin {
-  private final HashMap<UUID, Integer> _playerScores = new HashMap<UUID, Integer>();
+  private final Map<String, ScoreBucket> _buckets = new LinkedHashMap<>();
+  private final Map<String, Map<UUID, Integer>> _bucketScores = new LinkedHashMap<>();
+  private final Map<UUID, String> _playerBuckets = new LinkedHashMap<>();
+  private final Map<String, HighScoreRun> _highScoreRuns = new LinkedHashMap<>();
+  private final Map<String, ScoreArchive> _scoreArchives = new LinkedHashMap<>();
+  private String _defaultBucketId = "points";
   public final String _logPrefix = "[ScoreKeeper] ";
   public final Component _messagePrefix =
       Component.text("[")
@@ -44,20 +64,60 @@ public class ScoreKeeperPlugin extends JavaPlugin {
 
   @Override
   public void onDisable() {
-    // TODO: save score data to file
+    YamlConfiguration scores = new YamlConfiguration();
-    logWarning("Unable to save scores to file. This feature is not implemented yet.");
+    scores.set("version", 3);
+    scores.set("default-bucket", _defaultBucketId);
+    for (ScoreBucket bucket : _buckets.values()) {
+      String path = "buckets." + bucket.getId();
+      scores.set(path + ".singular", bucket.getSingular());
+      scores.set(path + ".plural", bucket.getPlural());
+      scores.set(path + ".initial-value", bucket.getInitialValue());
+      scores.set(path + ".reporting", bucket.getReporting().name().toLowerCase());
+      for (var entry : _bucketScores.get(bucket.getId()).entrySet()) {
+        scores.set(path + ".scores." + entry.getKey(), entry.getValue());
+      }
+    }
+    for (var entry : _playerBuckets.entrySet()) {
+      scores.set("player-buckets." + entry.getKey(), entry.getValue());
+    }
+    for (HighScoreRun run : _highScoreRuns.values()) {
+      String path = "high-score-runs." + run.bucketId;
+      scores.set(path + ".top-n", run.topN);
+      scores.set(path + ".reset-scores", run.resetScores);
+      scores.set(path + ".lifetime", run.lifetime.name().toLowerCase(Locale.ROOT));
+      scores.set(path + ".target-score", run.targetScore);
+      scores.set(path + ".expires-at", run.expiresAtMillis);
+      for (var entry : run.previousScores.entrySet()) {
+        scores.set(path + ".previous-scores." + entry.getKey(), entry.getValue());
+      }
+    }
+    try {
+      scores.save(new File(getDataFolder(), "scores.yml"));
+    } catch (IOException ex) {
+      logError(ex);
+    }
+    saveArchives();
   }
 
   @Override
   public void onEnable() {
-    getCommand("score-get").setExecutor(new ScoreGetCommand(this));
+    Objects.requireNonNull(getCommand("score-get")).setExecutor(new ScoreGetCommand(this));
-    getCommand("score-add").setExecutor(new ScoreAddCommand(this));
+    Objects.requireNonNull(getCommand("score-add")).setExecutor(new ScoreAddCommand(this));
-    getCommand("score-subtract").setExecutor(new ScoreSubtractCommand(this));
+    Objects.requireNonNull(getCommand("score-subtract"))
-    getCommand("score-reset").setExecutor(new ScoreResetCommand(this));
+        .setExecutor(new ScoreSubtractCommand(this));
-    getCommand("score-archive").setExecutor(new ScoreArchiveCommand(this));
+    Objects.requireNonNull(getCommand("score-reset")).setExecutor(new ScoreResetCommand(this));
+    Objects.requireNonNull(getCommand("score-archive")).setExecutor(new ScoreArchiveCommand(this));
+    Objects.requireNonNull(getCommand("score-archive-list"))
+        .setExecutor(new ScoreArchiveListCommand(this));
+    Objects.requireNonNull(getCommand("score-bucket")).setExecutor(new ScoreBucketCommand(this));
+    Objects.requireNonNull(getCommand("score-run")).setExecutor(new ScoreRunCommand(this));
 
-    // TODO: load score data from file
+    _buckets.put("points", new ScoreBucket("points", "point", "points", 0));
-    logWarning("Unable to load scores from file. This feature is not " + "implemented yet.");
+    _bucketScores.put("points", new LinkedHashMap<>());
+    loadScores();
+    loadArchives();
+    checkHighScoreRuns();
+    getServer().getScheduler().runTaskTimer(this, this::checkHighScoreRuns, 20L, 20L);
 
     logInfo(
         getPluginMeta().getName() + " version " + getPluginMeta().getVersion() + " is enabled.");
@@ -65,48 +125,673 @@ public class ScoreKeeperPlugin extends JavaPlugin {
 
   // region Commands
   public void addScore(Player player, int amount) {
-    int oldScore = getPlayerScore(player);
+    addScore(player, getPlayerBucket(player), amount);
-    setPlayerScore(player, oldScore + amount);
+  }
+
+  public void addScore(Player player, String bucketId, int amount) {
+    setScore(player, bucketId, getScore(player, bucketId) + amount);
   }
 
   public void archiveScore(Player player) {
-    logWarning("Unable to archive score for " + player.getName() + ".");
+    archivePlayerScore(player);
+  }
+
+  public String archivePlayerScore(Player player) {
+    String bucketId = getPlayerBucket(player);
+    return createScoreArchive(
+        "player " + player.getName() + " in " + bucketId, List.of(bucketId), player);
+  }
+
+  public String archiveBucketScores(String bucketId) {
+    requireBucket(bucketId);
+    return createScoreArchive("bucket " + bucketId, List.of(bucketId), null);
+  }
+
+  public String archiveAllScores() {
+    return createScoreArchive("all buckets", new ArrayList<>(_buckets.keySet()), null);
+  }
+
+  public List<ScoreArchive> getScoreArchives() {
+    return List.copyOf(_scoreArchives.values());
+  }
+
+  public ScoreArchive getScoreArchive(String archiveId) {
+    return _scoreArchives.get(archiveId);
   }
 
   public int getScore(Player player) {
-    return getPlayerScore(player);
+    return getScore(player, getPlayerBucket(player));
+  }
+
+  public int getScore(Player player, String bucketId) {
+    ScoreBucket bucket = requireBucket(bucketId);
+    return _bucketScores
+        .get(bucketId)
+        .computeIfAbsent(player.getUniqueId(), uuid -> bucket.getInitialValue());
   }
 
   public void resetScore(Player player) {
-    setPlayerScore(player, 0);
+    resetScore(player, getPlayerBucket(player));
+  }
+
+  public void resetScore(Player player, String bucketId) {
+    setScore(player, bucketId, requireBucket(bucketId).getInitialValue());
   }
 
   public void setScore(Player player, int score) {
-    setPlayerScore(player, score);
+    setScore(player, getPlayerBucket(player), score);
+  }
+
+  public void setScore(Player player, String bucketId, int score) {
+    ScoreBucket bucket = requireBucket(bucketId);
+    int oldScore = getScore(player, bucketId);
+    _bucketScores.get(bucketId).put(player.getUniqueId(), score);
+    if (oldScore != score) {
+      HighScoreRun run = _highScoreRuns.get(bucketId);
+      if (run == null) {
+        reportScoreChange(player, bucket, score);
+      } else {
+        reportHighScoreRunChange(player, bucket, run, score);
+        if (run.lifetime == HighScoreLifetime.TARGET_SCORE && score >= run.targetScore) {
+          finishHighScoreRun(bucketId);
+        }
+      }
+    }
   }
 
   public void subtractScore(Player player, int amount) {
-    int oldScore = getPlayerScore(player);
+    subtractScore(player, getPlayerBucket(player), amount);
-    setPlayerScore(player, oldScore - amount);
+  }
+
+  public void subtractScore(Player player, String bucketId, int amount) {
+    setScore(player, bucketId, getScore(player, bucketId) - amount);
+  }
+
+  public ScoreBucket createBucket(String id, String singular, String plural, int initialValue) {
+    return createBucket(id, singular, plural, initialValue, ScoreReporting.NONE);
+  }
+
+  public ScoreBucket createBucket(
+      String id, String singular, String plural, int initialValue, ScoreReporting reporting) {
+    ScoreBucket bucket = new ScoreBucket(id, singular, plural, initialValue, reporting);
+    if (_buckets.containsKey(id)) {
+      throw new IllegalArgumentException("A score bucket with ID " + id + " already exists");
+    }
+    _buckets.put(id, bucket);
+    _bucketScores.put(id, new LinkedHashMap<>());
+    return bucket;
+  }
+
+  public ScoreBucket getBucket(String bucketId) {
+    return _buckets.get(bucketId);
+  }
+
+  public Map<String, ScoreBucket> getBuckets() {
+    return Map.copyOf(_buckets);
+  }
+
+  public String getPlayerBucket(Player player) {
+    return _playerBuckets.getOrDefault(player.getUniqueId(), _defaultBucketId);
+  }
+
+  public void switchPlayerBucket(Player player, String bucketId) {
+    ScoreBucket bucket = requireBucket(bucketId);
+    UUID playerId = player.getUniqueId();
+    String previousBucketId = getPlayerBucket(player);
+    if (bucketId.equals(_defaultBucketId)) {
+      _playerBuckets.remove(playerId);
+    } else {
+      _playerBuckets.put(playerId, bucketId);
+    }
+    if (!previousBucketId.equals(bucketId)) {
+      sendBucketChangeMessage(player, bucket);
+    }
+  }
+
+  public void switchAllPlayers(String bucketId) {
+    requireBucket(bucketId);
+    Map<UUID, String> previousBuckets = new LinkedHashMap<>();
+    for (Player player : getServer().getOnlinePlayers()) {
+      previousBuckets.put(Objects.requireNonNull(player).getUniqueId(), getPlayerBucket(player));
+    }
+    _defaultBucketId = bucketId;
+    _playerBuckets.clear();
+    ScoreBucket bucket = requireBucket(bucketId);
+    for (Player player : getServer().getOnlinePlayers()) {
+      if (!bucketId.equals(previousBuckets.get(Objects.requireNonNull(player).getUniqueId()))) {
+        sendBucketChangeMessage(player, bucket);
+      }
+    }
+  }
+
+  public void startTargetScoreRun(String bucketId, int topN, boolean resetScores, int targetScore) {
+    ScoreBucket bucket = requireBucket(bucketId);
+    if (resetScores && targetScore <= bucket.getInitialValue()) {
+      throw new IllegalArgumentException("Target score must exceed the bucket's initial value");
+    }
+    startHighScoreRun(bucketId, topN, resetScores, HighScoreLifetime.TARGET_SCORE, targetScore, 0L);
+  }
+
+  public void startTimedScoreRun(
+      String bucketId, int topN, boolean resetScores, Duration duration) {
+    if (duration == null || duration.isNegative() || duration.isZero()) {
+      throw new IllegalArgumentException("Run duration must be positive");
+    }
+    long durationMillis;
+    long expiresAtMillis;
+    try {
+      durationMillis = duration.toMillis();
+      expiresAtMillis = Math.addExact(System.currentTimeMillis(), durationMillis);
+    } catch (ArithmeticException ex) {
+      throw new IllegalArgumentException("Run duration is too large", ex);
+    }
+    if (durationMillis <= 0) {
+      throw new IllegalArgumentException("Run duration must be at least one millisecond");
+    }
+    startHighScoreRun(bucketId, topN, resetScores, HighScoreLifetime.DURATION, 0, expiresAtMillis);
+  }
+
+  public void startUntilDisabledScoreRun(String bucketId, int topN, boolean resetScores) {
+    startHighScoreRun(bucketId, topN, resetScores, HighScoreLifetime.UNTIL_DISABLED, 0, 0L);
+  }
+
+  public void stopHighScoreRun(String bucketId) {
+    if (!_highScoreRuns.containsKey(bucketId)) {
+      throw new IllegalArgumentException("No high-score run is active for bucket " + bucketId);
+    }
+    finishHighScoreRun(bucketId);
+  }
+
+  public boolean hasActiveHighScoreRun(String bucketId) {
+    return _highScoreRuns.containsKey(bucketId);
   }
 
   // endregion
 
   // region Utiilty Methods
   public void sendMessage(CommandSender reciever, Component message) {
-    reciever.sendMessage(_messagePrefix.append(message));
+    reciever.sendMessage(_messagePrefix.append(Objects.requireNonNull(message)));
   }
 
-  private int getPlayerScore(Player player) {
+  private ScoreBucket requireBucket(String bucketId) {
-    UUID uuid = player.getUniqueId();
+    ScoreBucket bucket = _buckets.get(bucketId);
-    if (!_playerScores.containsKey(uuid)) {
+    if (bucket == null) {
-      _playerScores.put(uuid, 0);
+      throw new IllegalArgumentException("Unknown score bucket: " + bucketId);
     }
-    return _playerScores.get(uuid);
+    return bucket;
   }
 
-  private void setPlayerScore(Player player, int score) {
+  private void sendBucketChangeMessage(Player player, ScoreBucket bucket) {
-    _playerScores.put(player.getUniqueId(), score);
+    int score = getScore(player, bucket.getId());
+    String unit = score == 1 ? bucket.getSingular() : bucket.getPlural();
+    sendMessage(
+        player,
+        Component.text(
+            "You are now tracking " + bucket.getId() + ". You have " + score + " " + unit + "."));
+  }
+
+  private String createScoreArchive(String scope, List<String> bucketIds, Player player) {
+    for (String bucketId : bucketIds) {
+      if (_highScoreRuns.containsKey(bucketId)) {
+        throw new IllegalArgumentException(
+            "Stop the active high-score run for " + bucketId + " before archiving it");
+      }
+    }
+
+    Map<String, Map<UUID, Integer>> archivedScores = new LinkedHashMap<>();
+    UUID playerId = player == null ? null : player.getUniqueId();
+    for (String bucketId : bucketIds) {
+      ScoreBucket bucket = requireBucket(bucketId);
+      Map<UUID, Integer> bucketScores = _bucketScores.get(bucketId);
+      if (playerId == null) {
+        archivedScores.put(bucketId, new LinkedHashMap<>(bucketScores));
+        bucketScores.replaceAll((uuid, score) -> bucket.getInitialValue());
+      } else {
+        int score = getScore(player, bucketId);
+        archivedScores.put(bucketId, Map.of(playerId, score));
+        bucketScores.put(playerId, bucket.getInitialValue());
+      }
+    }
+
+    String archiveId = UUID.randomUUID().toString();
+    _scoreArchives.put(
+        archiveId, new ScoreArchive(archiveId, scope, System.currentTimeMillis(), archivedScores));
+    return archiveId;
+  }
+
+  private void startHighScoreRun(
+      String bucketId,
+      int topN,
+      boolean resetScores,
+      HighScoreLifetime lifetime,
+      int targetScore,
+      long expiresAtMillis) {
+    ScoreBucket bucket = requireBucket(bucketId);
+    if (topN < 1) {
+      throw new IllegalArgumentException("Top N must be at least 1");
+    }
+    if (_highScoreRuns.containsKey(bucketId)) {
+      throw new IllegalArgumentException("A high-score run is already active for " + bucketId);
+    }
+
+    Map<UUID, Integer> bucketScores = _bucketScores.get(bucketId);
+    Map<UUID, Integer> previousScores = resetScores ? new LinkedHashMap<>(bucketScores) : Map.of();
+    if (resetScores) {
+      bucketScores.replaceAll((playerId, score) -> bucket.getInitialValue());
+    }
+    _highScoreRuns.put(
+        bucketId,
+        new HighScoreRun(
+            bucketId, topN, resetScores, lifetime, targetScore, expiresAtMillis, previousScores));
+    checkHighScoreRuns();
+  }
+
+  private void checkHighScoreRuns() {
+    long now = System.currentTimeMillis();
+    List<String> finishedRuns = new ArrayList<>();
+    for (HighScoreRun run : _highScoreRuns.values()) {
+      boolean expired = run.lifetime == HighScoreLifetime.DURATION && now >= run.expiresAtMillis;
+      boolean targetReached =
+          run.lifetime == HighScoreLifetime.TARGET_SCORE
+              && _bucketScores.get(run.bucketId).values().stream()
+                  .anyMatch(score -> score >= run.targetScore);
+      if (expired || targetReached) {
+        finishedRuns.add(run.bucketId);
+      }
+    }
+    for (String bucketId : finishedRuns) {
+      finishHighScoreRun(bucketId);
+    }
+  }
+
+  private void reportHighScoreRunChange(
+      Player player, ScoreBucket bucket, HighScoreRun run, int score) {
+    String message = scoreMessage(player.getName(), bucket, score);
+    sendMessage(player, Component.text(Objects.requireNonNull(message)));
+    List<ScoreEntry> standings = getRankedScores(bucket.getId());
+    for (int place = 0; place < Math.min(run.topN, standings.size()); place++) {
+      if (standings.get(place).playerId.equals(player.getUniqueId())) {
+        for (Player recipient : getServer().getOnlinePlayers()) {
+          if (recipient != player) {
+            sendMessage(recipient, Component.text(Objects.requireNonNull(message)));
+          }
+        }
+        return;
+      }
+    }
+  }
+
+  private void finishHighScoreRun(String bucketId) {
+    HighScoreRun run = _highScoreRuns.remove(bucketId);
+    if (run == null) {
+      return;
+    }
+
+    ScoreBucket bucket = requireBucket(bucketId);
+    List<ScoreEntry> standings = getRankedScores(bucketId);
+    StringBuilder table =
+        new StringBuilder("High-score run for ").append(bucketId).append(" finished.");
+    int places = Math.min(run.topN, standings.size());
+    if (places == 0) {
+      table.append("\nNo scores were recorded.");
+    }
+    for (int place = 0; place < places; place++) {
+      ScoreEntry entry = standings.get(place);
+      table
+          .append("\n")
+          .append(place + 1)
+          .append(". ")
+          .append(entry.playerName)
+          .append(" - ")
+          .append(entry.score)
+          .append(" ")
+          .append(scoreUnit(bucket, entry.score));
+    }
+
+    if (run.resetScores) {
+      Map<UUID, Integer> bucketScores = _bucketScores.get(bucketId);
+      bucketScores.clear();
+      bucketScores.putAll(run.previousScores);
+    }
+    logInfo(table.toString().replace('\n', ' '));
+    for (Player player : getServer().getOnlinePlayers()) {
+      ScoreEntry personalEntry = null;
+      int personalPlace = -1;
+      for (int place = 0; place < standings.size(); place++) {
+        if (standings.get(place).playerId.equals(Objects.requireNonNull(player).getUniqueId())) {
+          personalEntry = standings.get(place);
+          personalPlace = place + 1;
+          break;
+        }
+      }
+      int personalScore = personalEntry == null ? bucket.getInitialValue() : personalEntry.score;
+      String personalResult =
+          personalPlace < 0
+              ? "Your place: unranked; score: "
+                  + personalScore
+                  + " "
+                  + scoreUnit(bucket, personalScore)
+              : "Your place: "
+                  + personalPlace
+                  + "; score: "
+                  + personalScore
+                  + " "
+                  + scoreUnit(bucket, personalScore);
+      sendMessage(player, Component.text(table + "\n" + personalResult));
+    }
+  }
+
+  private List<ScoreEntry> getRankedScores(String bucketId) {
+    List<ScoreEntry> standings = new ArrayList<>();
+    for (var entry : _bucketScores.get(bucketId).entrySet()) {
+      String playerName = getServer().getOfflinePlayer(entry.getKey()).getName();
+      if (playerName == null || playerName.isBlank()) {
+        playerName = entry.getKey().toString();
+      }
+      standings.add(new ScoreEntry(entry.getKey(), playerName, entry.getValue()));
+    }
+    standings.sort(
+        Comparator.comparingInt((ScoreEntry entry) -> entry.score)
+            .reversed()
+            .thenComparing(entry -> entry.playerName, String.CASE_INSENSITIVE_ORDER)
+            .thenComparing(entry -> entry.playerId.toString()));
+    return standings;
+  }
+
+  private String scoreMessage(String playerName, ScoreBucket bucket, int score) {
+    return playerName
+        + "'s "
+        + bucket.getId()
+        + " score is now "
+        + score
+        + " "
+        + scoreUnit(bucket, score)
+        + ".";
+  }
+
+  private String scoreUnit(ScoreBucket bucket, int score) {
+    return score == 1 ? bucket.getSingular() : bucket.getPlural();
+  }
+
+  private void loadScores() {
+    File scoreFile = new File(getDataFolder(), "scores.yml");
+    if (!scoreFile.isFile()) {
+      return;
+    }
+
+    YamlConfiguration scores = YamlConfiguration.loadConfiguration(scoreFile);
+    ConfigurationSection bucketSection = scores.getConfigurationSection("buckets");
+    if (bucketSection == null) {
+      loadLegacyScores(scores);
+      return;
+    }
+
+    _buckets.clear();
+    _bucketScores.clear();
+    for (String id : bucketSection.getKeys(false)) {
+      try {
+        ScoreReporting reporting =
+            parseReporting(bucketSection.getString(id + ".reporting", "none"), id);
+        createBucket(
+            id,
+            bucketSection.getString(id + ".singular", id),
+            bucketSection.getString(id + ".plural", id),
+            bucketSection.getInt(id + ".initial-value"),
+            reporting);
+      } catch (IllegalArgumentException ex) {
+        logWarning("Ignoring invalid score bucket " + id + ": " + ex.getMessage());
+      }
+    }
+    if (!_buckets.containsKey("points")) {
+      createBucket("points", "point", "points", 0);
+    }
+    _defaultBucketId = scores.getString("default-bucket", "points");
+    if (!_buckets.containsKey(_defaultBucketId)) {
+      logWarning("Unknown default score bucket; using points instead.");
+      _defaultBucketId = "points";
+    }
+
+    for (String id : _buckets.keySet()) {
+      ConfigurationSection bucketScores =
+          scores.getConfigurationSection("buckets." + id + ".scores");
+      if (bucketScores != null) {
+        loadPlayerScores(bucketScores, _bucketScores.get(id));
+      }
+    }
+    ConfigurationSection playerBuckets = scores.getConfigurationSection("player-buckets");
+    if (playerBuckets != null) {
+      for (String key : playerBuckets.getKeys(false)) {
+        try {
+          UUID playerId = UUID.fromString(key);
+          String bucketId = playerBuckets.getString(key);
+          if (_buckets.containsKey(bucketId) && !bucketId.equals(_defaultBucketId)) {
+            _playerBuckets.put(playerId, bucketId);
+          }
+        } catch (IllegalArgumentException ex) {
+          logWarning("Ignoring invalid player bucket UUID: " + key);
+        }
+      }
+    }
+    loadHighScoreRuns(scores);
+  }
+
+  private void loadArchives() {
+    File archiveFile = new File(getDataFolder(), "archives.yml");
+    if (!archiveFile.isFile()) {
+      return;
+    }
+    YamlConfiguration archives = YamlConfiguration.loadConfiguration(archiveFile);
+    ConfigurationSection archiveSection = archives.getConfigurationSection("archives");
+    if (archiveSection == null) {
+      return;
+    }
+    for (String archiveId : archiveSection.getKeys(false)) {
+      String path = "archives." + archiveId;
+      Map<String, Map<UUID, Integer>> bucketScores = new LinkedHashMap<>();
+      ConfigurationSection buckets = archives.getConfigurationSection(path + ".buckets");
+      if (buckets != null) {
+        for (String bucketId : buckets.getKeys(false)) {
+          Map<UUID, Integer> playerScores = new LinkedHashMap<>();
+          ConfigurationSection savedScores =
+              archives.getConfigurationSection(path + ".buckets." + bucketId + ".scores");
+          if (savedScores != null) {
+            loadPlayerScores(savedScores, playerScores);
+          }
+          bucketScores.put(bucketId, playerScores);
+        }
+      }
+      _scoreArchives.put(
+          archiveId,
+          new ScoreArchive(
+              archiveId,
+              archives.getString(path + ".scope", "unknown"),
+              archives.getLong(path + ".created-at"),
+              bucketScores));
+    }
+  }
+
+  private void saveArchives() {
+    YamlConfiguration archives = new YamlConfiguration();
+    for (ScoreArchive archive : _scoreArchives.values()) {
+      String path = "archives." + archive.getId();
+      archives.set(path + ".scope", archive.getScope());
+      archives.set(path + ".created-at", archive.getCreatedAtMillis());
+      for (var bucketEntry : archive.getBucketScores().entrySet()) {
+        for (var scoreEntry : bucketEntry.getValue().entrySet()) {
+          archives.set(
+              path + ".buckets." + bucketEntry.getKey() + ".scores." + scoreEntry.getKey(),
+              scoreEntry.getValue());
+        }
+      }
+    }
+    try {
+      archives.save(new File(getDataFolder(), "archives.yml"));
+    } catch (IOException ex) {
+      logError(ex);
+    }
+  }
+
+  private void loadLegacyScores(YamlConfiguration scores) {
+    loadPlayerScores(scores, _bucketScores.get("points"));
+  }
+
+  private void loadPlayerScores(ConfigurationSection scores, Map<UUID, Integer> target) {
+    for (String key : scores.getKeys(false)) {
+      try {
+        target.put(UUID.fromString(key), scores.getInt(key));
+      } catch (IllegalArgumentException ex) {
+        logWarning("Ignoring score with invalid player UUID: " + key);
+      }
+    }
+  }
+
+  private ScoreReporting parseReporting(String value, String bucketId) {
+    try {
+      return ScoreReporting.fromString(value);
+    } catch (IllegalArgumentException ex) {
+      logWarning("Ignoring invalid reporting policy for bucket " + bucketId + "; using none.");
+      return ScoreReporting.NONE;
+    }
+  }
+
+  private void loadHighScoreRuns(YamlConfiguration scores) {
+    ConfigurationSection runs = scores.getConfigurationSection("high-score-runs");
+    if (runs == null) {
+      return;
+    }
+    for (String bucketId : runs.getKeys(false)) {
+      if (!_buckets.containsKey(bucketId)) {
+        logWarning("Ignoring high-score run for unknown bucket " + bucketId + ".");
+        continue;
+      }
+      try {
+        String path = "high-score-runs." + bucketId;
+        int topN = scores.getInt(path + ".top-n");
+        if (topN < 1) {
+          throw new IllegalArgumentException("Top N must be at least 1");
+        }
+        HighScoreLifetime lifetime =
+            HighScoreLifetime.valueOf(
+                scores.getString(path + ".lifetime", "until_disabled").toUpperCase(Locale.ROOT));
+        Map<UUID, Integer> previousScores = new LinkedHashMap<>();
+        ConfigurationSection savedScores =
+            scores.getConfigurationSection(path + ".previous-scores");
+        if (savedScores != null) {
+          loadPlayerScores(savedScores, previousScores);
+        }
+        _highScoreRuns.put(
+            bucketId,
+            new HighScoreRun(
+                bucketId,
+                topN,
+                scores.getBoolean(path + ".reset-scores"),
+                lifetime,
+                scores.getInt(path + ".target-score"),
+                scores.getLong(path + ".expires-at"),
+                previousScores));
+      } catch (IllegalArgumentException ex) {
+        logWarning(
+            "Ignoring invalid high-score run for bucket " + bucketId + ": " + ex.getMessage());
+      }
+    }
+  }
+
+  private void reportScoreChange(Player player, ScoreBucket bucket, int score) {
+    ScoreReporting reporting = bucket.getReporting();
+    if (reporting == ScoreReporting.NONE) {
+      return;
+    }
+
+    String text = scoreMessage(player.getName(), bucket, score);
+    Component message = Component.text(Objects.requireNonNull(text));
+    if (reporting == ScoreReporting.PLAYER) {
+      sendMessage(player, message);
+    } else if (reporting == ScoreReporting.GLOBAL) {
+      for (Player recipient : getServer().getOnlinePlayers()) {
+        sendMessage(recipient, message);
+      }
+    } else if (reporting == ScoreReporting.ADMIN) {
+      logInfo(text);
+      for (Player recipient : getServer().getOnlinePlayers()) {
+        if (Objects.requireNonNull(recipient).isOp()
+            || recipient.hasPermission("scorekeeper.admin")) {
+          sendMessage(recipient, message);
+        }
+      }
+    }
+  }
+
+  private enum HighScoreLifetime {
+    TARGET_SCORE,
+    DURATION,
+    UNTIL_DISABLED
+  }
+
+  private static final class HighScoreRun {
+    private final String bucketId;
+    private final int topN;
+    private final boolean resetScores;
+    private final HighScoreLifetime lifetime;
+    private final int targetScore;
+    private final long expiresAtMillis;
+    private final Map<UUID, Integer> previousScores;
+
+    private HighScoreRun(
+        String bucketId,
+        int topN,
+        boolean resetScores,
+        HighScoreLifetime lifetime,
+        int targetScore,
+        long expiresAtMillis,
+        Map<UUID, Integer> previousScores) {
+      this.bucketId = bucketId;
+      this.topN = topN;
+      this.resetScores = resetScores;
+      this.lifetime = lifetime;
+      this.targetScore = targetScore;
+      this.expiresAtMillis = expiresAtMillis;
+      this.previousScores = new LinkedHashMap<>(previousScores);
+    }
+  }
+
+  private record ScoreEntry(UUID playerId, String playerName, int score) {}
+
+  public static final class ScoreArchive {
+    private final String _id;
+    private final String _scope;
+    private final long _createdAtMillis;
+    private final Map<String, Map<UUID, Integer>> _bucketScores;
+
+    private ScoreArchive(
+        String id,
+        String scope,
+        long createdAtMillis,
+        Map<String, Map<UUID, Integer>> bucketScores) {
+      _id = id;
+      _scope = scope;
+      _createdAtMillis = createdAtMillis;
+      Map<String, Map<UUID, Integer>> copiedScores = new LinkedHashMap<>();
+      for (var entry : bucketScores.entrySet()) {
+        copiedScores.put(entry.getKey(), Map.copyOf(entry.getValue()));
+      }
+      _bucketScores = Collections.unmodifiableMap(copiedScores);
+    }
+
+    public String getId() {
+      return _id;
+    }
+
+    public String getScope() {
+      return _scope;
+    }
+
+    public long getCreatedAtMillis() {
+      return _createdAtMillis;
+    }
+
+    public Map<String, Map<UUID, Integer>> getBucketScores() {
+      return _bucketScores;
+    }
   }
 
   // endregion

src/main/java/com/majinnaibu/minecraft/plugins/scorekeeper/ScoreReporting.java

@@ -0,0 +1,38 @@
+/*
+This file is part of Score Keeper.
+
+Score Keeper is free software: you can redistribute it and/or modify
+it under the terms of the GNU Affero General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+Score Keeper is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Affero General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License
+along with Score Keeper. If not, see <https://www.gnu.org/licenses/agpl-3.0.txt>.
+*/
+
+package com.majinnaibu.minecraft.plugins.scorekeeper;
+
+import java.util.Locale;
+
+public enum ScoreReporting {
+  ADMIN,
+  GLOBAL,
+  PLAYER,
+  NONE;
+
+  public static ScoreReporting fromString(String value) {
+    if (value == null) {
+      throw new IllegalArgumentException("Reporting policy cannot be null");
+    }
+    try {
+      return valueOf(value.toUpperCase(Locale.ROOT));
+    } catch (IllegalArgumentException ex) {
+      throw new IllegalArgumentException("Reporting must be admin, global, player or none", ex);
+    }
+  }
+}

src/main/java/com/majinnaibu/minecraft/plugins/scorekeeper/commands/ScoreAddCommand.java

@@ -17,6 +17,8 @@ along with ScoreKeeper. If not, see <https://www.gnu.org/licenses/agpl-3.0.txt>.
 
 package com.majinnaibu.minecraft.plugins.scorekeeper.commands;
 
+import java.util.Objects;
+
 import com.majinnaibu.minecraft.plugins.scorekeeper.ScoreKeeperPlugin;
 
 import net.kyori.adventure.text.Component;
@@ -76,7 +78,8 @@ public class ScoreAddCommand implements CommandExecutor {
   }
 
   private void echoError(CommandSender sender, boolean rcon, String string) {
-    _plugin.sendMessage(sender, Component.text(string).color(NamedTextColor.RED));
+    _plugin.sendMessage(
+        sender, Component.text(Objects.requireNonNull(string)).color(NamedTextColor.RED));
   }
 
   private void echoUsage(CommandSender sender, boolean rcon) {

src/main/java/com/majinnaibu/minecraft/plugins/scorekeeper/commands/ScoreArchiveCommand.java

@@ -17,13 +17,17 @@ along with ScoreKeeper. If not, see <https://www.gnu.org/licenses/agpl-3.0.txt>.
 
 package com.majinnaibu.minecraft.plugins.scorekeeper.commands;
 
+import java.util.Objects;
+
 import com.majinnaibu.minecraft.plugins.scorekeeper.ScoreKeeperPlugin;
 
 import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.format.NamedTextColor;
 
 import org.bukkit.command.Command;
 import org.bukkit.command.CommandExecutor;
 import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
 
 public class ScoreArchiveCommand implements CommandExecutor {
   private final ScoreKeeperPlugin _plugin;
@@ -34,7 +38,46 @@ public class ScoreArchiveCommand implements CommandExecutor {
 
   @Override
   public boolean onCommand(CommandSender sender, Command command, String label, String[] split) {
-    _plugin.sendMessage(sender, Component.text("archive command unimplemented"));
+    if (!sender.hasPermission("scorekeeper.admin")) {
+      sendError(sender, "You do not have permission to archive scores");
       return true;
     }
+
+    try {
+      String archiveId;
+      if (split.length == 1 && split[0].equalsIgnoreCase("all")) {
+        archiveId = _plugin.archiveAllScores();
+      } else if (split.length == 2 && split[0].equalsIgnoreCase("bucket")) {
+        archiveId = _plugin.archiveBucketScores(split[1]);
+      } else if (split.length == 0 && sender instanceof Player player) {
+        archiveId = _plugin.archivePlayerScore(player);
+      } else if (split.length == 1) {
+        Player target = _plugin.getServer().getPlayerExact(split[0]);
+        if (target == null) {
+          sendError(sender, "Can't find a player with that name");
+          return true;
+        }
+        archiveId = _plugin.archivePlayerScore(target);
+      } else {
+        sendUsage(sender);
+        return true;
+      }
+      _plugin.sendMessage(sender, Component.text("Saved score archive " + archiveId + "."));
+    } catch (IllegalArgumentException ex) {
+      sendError(sender, ex.getMessage());
+    }
+    return true;
+  }
+
+  private void sendError(CommandSender sender, String message) {
+    _plugin.sendMessage(
+        sender, Component.text(Objects.requireNonNull(message)).color(NamedTextColor.RED));
+  }
+
+  private void sendUsage(CommandSender sender) {
+    _plugin.sendMessage(
+        sender,
+        Component.text("Usage: /score-archive [playerName|all] | /score-archive bucket <bucketId>")
+            .color(NamedTextColor.YELLOW));
+  }
 }

src/main/java/com/majinnaibu/minecraft/plugins/scorekeeper/commands/ScoreArchiveListCommand.java

@@ -0,0 +1,131 @@
+/*
+This file is part of Score Keeper.
+
+Score Keeper is free software: you can redistribute it and/or modify
+it under the terms of the GNU Affero General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+Score Keeper is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Affero General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License
+along with Score Keeper. If not, see <https://www.gnu.org/licenses/agpl-3.0.txt>.
+*/
+
+package com.majinnaibu.minecraft.plugins.scorekeeper.commands;
+
+import java.time.Instant;
+import java.util.Comparator;
+import java.util.Map;
+import java.util.UUID;
+
+import com.majinnaibu.minecraft.plugins.scorekeeper.ScoreBucket;
+import com.majinnaibu.minecraft.plugins.scorekeeper.ScoreKeeperPlugin;
+
+import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.format.NamedTextColor;
+
+import org.bukkit.OfflinePlayer;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandExecutor;
+import org.bukkit.command.CommandSender;
+
+public class ScoreArchiveListCommand implements CommandExecutor {
+  private final ScoreKeeperPlugin _plugin;
+
+  public ScoreArchiveListCommand(ScoreKeeperPlugin plugin) {
+    _plugin = plugin;
+  }
+
+  @Override
+  public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
+    if (args.length == 0) {
+      var archives = _plugin.getScoreArchives();
+      if (archives.isEmpty()) {
+        _plugin.sendMessage(sender, Component.text("No score archives have been saved."));
+      } else {
+        archives.stream()
+            .sorted(
+                Comparator.comparingLong(
+                        (ScoreKeeperPlugin.ScoreArchive archive) -> archive.getCreatedAtMillis())
+                    .reversed())
+            .forEach(
+                archive ->
+                    _plugin.sendMessage(
+                        sender,
+                        Component.text(
+                            archive.getId()
+                                + " | "
+                                + archive.getScope()
+                                + " | "
+                                + Instant.ofEpochMilli(archive.getCreatedAtMillis()))));
+      }
+      return true;
+    }
+
+    if (args.length != 1) {
+      sendUsage(sender);
+      return true;
+    }
+    ScoreKeeperPlugin.ScoreArchive archive = _plugin.getScoreArchive(args[0]);
+    if (archive == null) {
+      _plugin.sendMessage(
+          sender,
+          Component.text("No score archive exists with ID " + args[0] + ".")
+              .color(NamedTextColor.RED));
+      return true;
+    }
+
+    _plugin.sendMessage(
+        sender,
+        Component.text(
+            "Archive "
+                + archive.getId()
+                + " ("
+                + archive.getScope()
+                + ", "
+                + Instant.ofEpochMilli(archive.getCreatedAtMillis())
+                + ")"));
+    for (var bucketEntry : archive.getBucketScores().entrySet()) {
+      ScoreBucket bucket = _plugin.getBucket(bucketEntry.getKey());
+      _plugin.sendMessage(sender, Component.text("Bucket " + bucketEntry.getKey() + ":"));
+      bucketEntry.getValue().entrySet().stream()
+          .sorted(
+              Map.Entry.<UUID, Integer>comparingByValue()
+                  .reversed()
+                  .thenComparing(entry -> entry.getKey().toString()))
+          .forEach(
+              entry ->
+                  _plugin.sendMessage(
+                      sender,
+                      Component.text(
+                          displayName(entry.getKey())
+                              + " - "
+                              + entry.getValue()
+                              + " "
+                              + scoreUnit(bucket, entry.getValue()))));
+    }
+    return true;
+  }
+
+  private String displayName(UUID playerId) {
+    OfflinePlayer player = _plugin.getServer().getOfflinePlayer(playerId);
+    return player.getName() == null ? playerId.toString() : player.getName();
+  }
+
+  private String scoreUnit(ScoreBucket bucket, int score) {
+    if (bucket == null) {
+      return "scores";
+    }
+    return score == 1 ? bucket.getSingular() : bucket.getPlural();
+  }
+
+  private void sendUsage(CommandSender sender) {
+    _plugin.sendMessage(
+        sender,
+        Component.text("Usage: /score-archive-list [archiveId]").color(NamedTextColor.YELLOW));
+  }
+}

src/main/java/com/majinnaibu/minecraft/plugins/scorekeeper/commands/ScoreBucketCommand.java

@@ -0,0 +1,138 @@
+/*
+This file is part of Score Keeper.
+
+Score Keeper is free software: you can redistribute it and/or modify
+it under the terms of the GNU Affero General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+Score Keeper is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Affero General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License
+along with Score Keeper. If not, see <https://www.gnu.org/licenses/agpl-3.0.txt>.
+*/
+
+package com.majinnaibu.minecraft.plugins.scorekeeper.commands;
+
+import java.util.Objects;
+
+import com.majinnaibu.minecraft.plugins.scorekeeper.ScoreBucket;
+import com.majinnaibu.minecraft.plugins.scorekeeper.ScoreKeeperPlugin;
+import com.majinnaibu.minecraft.plugins.scorekeeper.ScoreReporting;
+
+import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.format.NamedTextColor;
+
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandExecutor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+public class ScoreBucketCommand implements CommandExecutor {
+  private final ScoreKeeperPlugin _plugin;
+
+  public ScoreBucketCommand(ScoreKeeperPlugin plugin) {
+    _plugin = plugin;
+  }
+
+  @Override
+  public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
+    if (args.length == 0) {
+      if (sender instanceof Player player) {
+        String bucketId = _plugin.getPlayerBucket(player);
+        ScoreBucket bucket = _plugin.getBucket(bucketId);
+        _plugin.sendMessage(
+            sender,
+            Component.text(
+                "You are tracking " + bucket.getId() + " (" + bucket.getPlural() + ")."));
+      } else {
+        sendUsage(sender);
+      }
+      return true;
+    }
+
+    if ((args.length == 5 || args.length == 6) && args[0].equalsIgnoreCase("create")) {
+      if (!requireAdmin(sender)) {
+        return true;
+      }
+      try {
+        ScoreReporting reporting =
+            args.length == 6 ? ScoreReporting.fromString(args[5]) : ScoreReporting.NONE;
+        _plugin.createBucket(args[1], args[2], args[3], Integer.parseInt(args[4]), reporting);
+        _plugin.sendMessage(sender, Component.text("Created score bucket " + args[1] + "."));
+      } catch (IllegalArgumentException ex) {
+        sendError(sender, ex.getMessage());
+      }
+      return true;
+    }
+
+    if (args.length == 1 && sender instanceof Player player) {
+      switchPlayerBucket(sender, player, args[0]);
+      return true;
+    }
+
+    if (args.length == 2) {
+      if (!requireAdmin(sender)) {
+        return true;
+      }
+      if (args[0].equalsIgnoreCase("all")) {
+        try {
+          _plugin.switchAllPlayers(args[1]);
+          _plugin.sendMessage(
+              sender, Component.text("All players are now tracking " + args[1] + "."));
+        } catch (IllegalArgumentException ex) {
+          sendError(sender, ex.getMessage());
+        }
+        return true;
+      }
+
+      Player target = _plugin.getServer().getPlayerExact(args[0]);
+      if (target == null) {
+        sendError(sender, "Can't find a player with that name");
+      } else {
+        switchPlayerBucket(sender, target, args[1]);
+      }
+      return true;
+    }
+
+    sendUsage(sender);
+    return true;
+  }
+
+  private void switchPlayerBucket(CommandSender sender, Player target, String bucketId) {
+    try {
+      _plugin.switchPlayerBucket(target, bucketId);
+      if (sender != target) {
+        _plugin.sendMessage(
+            sender, Component.text(target.getName() + " is now tracking " + bucketId + "."));
+      }
+    } catch (IllegalArgumentException ex) {
+      sendError(sender, ex.getMessage());
+    }
+  }
+
+  private boolean requireAdmin(CommandSender sender) {
+    if (sender.hasPermission("scorekeeper.admin")) {
+      return true;
+    }
+    sendError(sender, "You do not have permission to manage score buckets");
+    return false;
+  }
+
+  private void sendError(CommandSender sender, String message) {
+    _plugin.sendMessage(
+        sender, Component.text(Objects.requireNonNull(message)).color(NamedTextColor.RED));
+  }
+
+  private void sendUsage(CommandSender sender) {
+    _plugin.sendMessage(
+        sender,
+        Component.text(
+                "Usage: /score-bucket [bucketId] | create <id> <singular> <plural> <initialValue>"
+                    + " | <player|all> <bucketId>")
+            .color(NamedTextColor.YELLOW));
+  }
+}

src/main/java/com/majinnaibu/minecraft/plugins/scorekeeper/commands/ScoreGetCommand.java

@@ -17,6 +17,8 @@ along with ScoreKeeper. If not, see <https://www.gnu.org/licenses/agpl-3.0.txt>.
 
 package com.majinnaibu.minecraft.plugins.scorekeeper.commands;
 
+import java.util.Objects;
+
 import com.majinnaibu.minecraft.plugins.scorekeeper.ScoreKeeperPlugin;
 
 import net.kyori.adventure.text.Component;
@@ -84,7 +86,8 @@ public class ScoreGetCommand implements CommandExecutor {
   }
 
   private void echoError(CommandSender sender, boolean rcon, String string) {
-    _plugin.sendMessage(sender, Component.text(string).color(NamedTextColor.RED));
+    _plugin.sendMessage(
+        sender, Component.text(Objects.requireNonNull(string)).color(NamedTextColor.RED));
   }
 
   private void echoUsage(CommandSender sender, boolean rcon) {

src/main/java/com/majinnaibu/minecraft/plugins/scorekeeper/commands/ScoreResetCommand.java

@@ -17,6 +17,8 @@ along with ScoreKeeper. If not, see <https://www.gnu.org/licenses/agpl-3.0.txt>.
 
 package com.majinnaibu.minecraft.plugins.scorekeeper.commands;
 
+import java.util.Objects;
+
 import com.majinnaibu.minecraft.plugins.scorekeeper.ScoreKeeperPlugin;
 
 import net.kyori.adventure.text.Component;
@@ -62,7 +64,8 @@ public class ScoreResetCommand implements CommandExecutor {
   }
 
   private void echoError(CommandSender sender, boolean rcon, String string) {
-    _plugin.sendMessage(sender, Component.text(string).color(NamedTextColor.RED));
+    _plugin.sendMessage(
+        sender, Component.text(Objects.requireNonNull(string)).color(NamedTextColor.RED));
   }
 
   private void echoUsage(CommandSender sender, boolean rcon) {

src/main/java/com/majinnaibu/minecraft/plugins/scorekeeper/commands/ScoreRunCommand.java

@@ -0,0 +1,125 @@
+/*
+This file is part of Score Keeper.
+
+Score Keeper is free software: you can redistribute it and/or modify
+it under the terms of the GNU Affero General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+Score Keeper is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Affero General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License
+along with Score Keeper. If not, see <https://www.gnu.org/licenses/agpl-3.0.txt>.
+*/
+
+package com.majinnaibu.minecraft.plugins.scorekeeper.commands;
+
+import java.time.Duration;
+import java.util.Objects;
+
+import com.majinnaibu.minecraft.plugins.scorekeeper.ScoreKeeperPlugin;
+
+import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.format.NamedTextColor;
+
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandExecutor;
+import org.bukkit.command.CommandSender;
+
+public class ScoreRunCommand implements CommandExecutor {
+  private final ScoreKeeperPlugin _plugin;
+
+  public ScoreRunCommand(ScoreKeeperPlugin plugin) {
+    _plugin = plugin;
+  }
+
+  @Override
+  public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
+    if (!sender.hasPermission("scorekeeper.admin")) {
+      sendError(sender, "You do not have permission to manage high-score runs");
+      return true;
+    }
+
+    if (args.length == 2 && args[0].equalsIgnoreCase("stop")) {
+      try {
+        _plugin.stopHighScoreRun(args[1]);
+      } catch (IllegalArgumentException ex) {
+        sendError(sender, ex.getMessage());
+      }
+      return true;
+    }
+
+    if (args.length < 5 || !args[0].equalsIgnoreCase("start")) {
+      sendUsage(sender);
+      return true;
+    }
+
+    String bucketId = args[1];
+    try {
+      int topN = Integer.parseInt(args[2]);
+      boolean resetScores = parseBoolean(args[3]);
+      String lifetime = args[4].toLowerCase();
+      if (lifetime.equals("target") && args.length == 6) {
+        _plugin.startTargetScoreRun(bucketId, topN, resetScores, Integer.parseInt(args[5]));
+      } else if (lifetime.equals("duration") && args.length == 6) {
+        _plugin.startTimedScoreRun(bucketId, topN, resetScores, parseDuration(args[5]));
+      } else if (lifetime.equals("until-disabled") && args.length == 5) {
+        _plugin.startUntilDisabledScoreRun(bucketId, topN, resetScores);
+      } else {
+        sendUsage(sender);
+        return true;
+      }
+      _plugin.sendMessage(sender, Component.text("Started a high-score run for " + bucketId + "."));
+    } catch (IllegalArgumentException ex) {
+      sendError(sender, ex.getMessage());
+    }
+    return true;
+  }
+
+  private boolean parseBoolean(String value) {
+    if (value.equalsIgnoreCase("true")) {
+      return true;
+    }
+    if (value.equalsIgnoreCase("false")) {
+      return false;
+    }
+    throw new IllegalArgumentException("Reset scores must be true or false");
+  }
+
+  private Duration parseDuration(String value) {
+    if (!value.matches("[0-9]+[smhdw]")) {
+      throw new IllegalArgumentException(
+          "Duration must use seconds, minutes, hours, days or weeks (e.g. 4h)");
+    }
+    long amount = Long.parseLong(value.substring(0, value.length() - 1));
+    try {
+      return switch (value.charAt(value.length() - 1)) {
+        case 's' -> Duration.ofSeconds(amount);
+        case 'm' -> Duration.ofMinutes(amount);
+        case 'h' -> Duration.ofHours(amount);
+        case 'd' -> Duration.ofDays(amount);
+        case 'w' -> Duration.ofDays(Math.multiplyExact(amount, 7));
+        default -> throw new IllegalArgumentException("Unsupported duration unit");
+      };
+    } catch (ArithmeticException ex) {
+      throw new IllegalArgumentException("Duration is too large", ex);
+    }
+  }
+
+  private void sendError(CommandSender sender, String message) {
+    _plugin.sendMessage(
+        sender, Component.text(Objects.requireNonNull(message)).color(NamedTextColor.RED));
+  }
+
+  private void sendUsage(CommandSender sender) {
+    _plugin.sendMessage(
+        sender,
+        Component.text(
+                "Usage: /score-run start <bucket> <topN> <reset:true|false> "
+                    + "<target <score>|duration <time>|until-disabled> | /score-run stop <bucket>")
+            .color(NamedTextColor.YELLOW));
+  }
+}

src/main/java/com/majinnaibu/minecraft/plugins/scorekeeper/commands/ScoreSubtractCommand.java

@@ -17,6 +17,8 @@ along with ScoreKeeper. If not, see <https://www.gnu.org/licenses/agpl-3.0.txt>.
 
 package com.majinnaibu.minecraft.plugins.scorekeeper.commands;
 
+import java.util.Objects;
+
 import com.majinnaibu.minecraft.plugins.scorekeeper.ScoreKeeperPlugin;
 
 import net.kyori.adventure.text.Component;
@@ -76,7 +78,8 @@ public class ScoreSubtractCommand implements CommandExecutor {
   }
 
   private void echoError(CommandSender sender, boolean rcon, String string) {
-    _plugin.sendMessage(sender, Component.text(string).color(NamedTextColor.RED));
+    _plugin.sendMessage(
+        sender, Component.text(Objects.requireNonNull(string)).color(NamedTextColor.RED));
   }
 
   private void echoUsage(CommandSender sender, boolean rcon) {

src/main/resources/plugin.yml

@@ -1,7 +1,7 @@
 name: ScoreKeeper
 main: com.majinnaibu.minecraft.plugins.scorekeeper.ScoreKeeperPlugin
 version: ${version}
-api-version: 1.21
+api-version: '26.2'
 commands:
     score-get:
         description: Displays the player's score.
@@ -18,4 +18,17 @@ commands:
     score-archive:
         description: Archives and resets the player's score
         usage: /score-archive [playername]
+    score-archive-list:
+        description: Lists saved score archives or displays one archive.
+        usage: /score-archive-list [archiveId]
+    score-bucket:
+        description: Selects or manages score buckets.
+        usage: /score-bucket [bucketId] | create <id> <singular> <plural> <initialValue> [admin|global|player|none] | <player|all> <bucketId>
+    score-run:
+        description: Starts or stops a high-score run.
+        usage: /score-run start <bucket> <topN> <reset:true|false> <target <score>|duration <time>|until-disabled> | /score-run stop <bucket>
+permissions:
+    scorekeeper.admin:
+        description: Allows managing score buckets.
+        default: op
         

tools/backup-server.sh

@@ -0,0 +1,103 @@
+#!/usr/bin/env bash
+# Backs up plugins, config, worlds, and settings from MINECRAFT_SERVER_PATH
+# to MINECRAFT_BACKUP_PATH/backup-<timestamp>[-label].tar.bz2.
+#
+# Usage: backup-server.sh [-f|--force] [label]
+#   -f  Back up even if the server is running (worlds may be inconsistent).
+
+set -euo pipefail
+
+TOOLS_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+PROJECT_ROOT="$(cd "$TOOLS_DIR/.." && pwd)"
+if [[ ! -r "$PROJECT_ROOT/.env" ]]; then
+  echo "Error: $PROJECT_ROOT/.env is missing or unreadable. Copy .env.example to .env and set its values." >&2
+  exit 1
+fi
+load_project_env() {
+  local env_line env_key env_value first_char last_char
+  while IFS= read -r env_line || [[ -n "$env_line" ]]; do
+    env_line="${env_line%$'\r'}"
+    [[ "$env_line" =~ ^[[:space:]]*(#|$) ]] && continue
+    [[ "$env_line" == *=* ]] || continue
+
+    env_key="${env_line%%=*}"
+    env_value="${env_line#*=}"
+    env_key="${env_key#"${env_key%%[![:space:]]*}"}"
+    env_key="${env_key%"${env_key##*[![:space:]]}"}"
+    [[ "$env_key" =~ ^[A-Za-z_][A-Za-z0-9_]*$ ]] || continue
+    env_value="${env_value#"${env_value%%[![:space:]]*}"}"
+    env_value="${env_value%"${env_value##*[![:space:]]}"}"
+
+    if (( ${#env_value} >= 2 )); then
+      first_char="${env_value:0:1}"
+      last_char="${env_value:$((${#env_value} - 1)):1}"
+      if [[ "$first_char" == "$last_char" && ( "$first_char" == '"' || "$first_char" == "'" ) ]]; then
+        env_value="${env_value:1:$((${#env_value} - 2))}"
+      fi
+    fi
+
+    if [[ -z "${!env_key:-}" ]]; then
+      export "$env_key=$env_value"
+    fi
+  done < "$PROJECT_ROOT/.env"
+}
+load_project_env
+
+MINECRAFT_SERVER_PATH="${MINECRAFT_SERVER_PATH:-MCServer}"
+MINECRAFT_SERVER_PATH="${MINECRAFT_SERVER_PATH/#\~/$HOME}"
+[[ "$MINECRAFT_SERVER_PATH" == /* ]] || MINECRAFT_SERVER_PATH="$PROJECT_ROOT/$MINECRAFT_SERVER_PATH"
+MINECRAFT_BACKUP_PATH="${MINECRAFT_BACKUP_PATH:-backups}"
+MINECRAFT_BACKUP_PATH="${MINECRAFT_BACKUP_PATH/#\~/$HOME}"
+[[ "$MINECRAFT_BACKUP_PATH" == /* ]] || MINECRAFT_BACKUP_PATH="$PROJECT_ROOT/$MINECRAFT_BACKUP_PATH"
+
+FORCE=false
+LABEL=""
+for arg in "$@"; do
+  case "$arg" in
+    -f|--force) FORCE=true ;;
+    -h|--help) sed -n '2,7p' "$0"; exit 0 ;;
+    -*) echo "Unknown option: $arg" >&2; exit 1 ;;
+    *) LABEL="$arg" ;;
+  esac
+done
+
+[[ -d "$MINECRAFT_SERVER_PATH" ]] || { echo "Error: $MINECRAFT_SERVER_PATH does not exist." >&2; exit 1; }
+
+if pgrep -f "java.*paper-.*\.jar" >/dev/null && ! $FORCE; then
+  echo "Error: the server is running. Stop it first (tools/stop-server.sh) or pass --force." >&2
+  exit 1
+fi
+
+cd "$MINECRAFT_SERVER_PATH"
+shopt -s nullglob
+
+ITEMS=()
+[[ -d plugins ]] && ITEMS+=(plugins)
+[[ -d config ]] && ITEMS+=(config)
+for dir in */; do
+  dir="${dir%/}"
+  [[ -f "$dir/level.dat" ]] && ITEMS+=("$dir")
+done
+for f in *.yml *.yaml *.json *.properties eula.txt; do
+  ITEMS+=("$f")
+done
+
+if (( ${#ITEMS[@]} == 0 )); then
+  echo "Error: nothing to back up in $MINECRAFT_SERVER_PATH." >&2
+  exit 1
+fi
+
+# Keep labels filename-safe.
+LABEL="${LABEL//[^A-Za-z0-9._-]/_}"
+NAME="backup-$(date +%Y%m%d-%H%M%S)${LABEL:+-$LABEL}.tar.bz2"
+mkdir -p "$MINECRAFT_BACKUP_PATH"
+ARCHIVE="$MINECRAFT_BACKUP_PATH/$NAME"
+
+echo "Backing up: ${ITEMS[*]}"
+trap 'rm -f "$ARCHIVE.part"' EXIT
+tar --exclude 'plugins/.paper-remapped' --exclude '*/session.lock' \
+  -cjf "$ARCHIVE.part" "${ITEMS[@]}"
+mv "$ARCHIVE.part" "$ARCHIVE"
+trap - EXIT
+
+echo "Created $ARCHIVE ($(du -h "$ARCHIVE" | awk '{print $1}'))"

tools/bash/build-plugin.sh

@@ -1,10 +0,0 @@
-#!/usr/bin/env bash
-set -e
-
-# Find project root (two directories above this script)
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-PROJECT_ROOT="$(cd "$SCRIPT_DIR/../.." && pwd)"
-
-cd "$PROJECT_ROOT"
-
-./gradlew build 

tools/bash/deploy-plugin.sh

@@ -1,25 +0,0 @@
-#!/usr/bin/env bash
-set -e
-
-if [[ -z "$MINECRAFT_SERVER_PATH" ]]; then
-  echo "Error: MINECRAFT_SERVER_PATH environment variable is not set."
-  exit 1
-fi
-
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-PROJECT_ROOT="$(cd "$SCRIPT_DIR/../.." && pwd)"
-
-PLUGIN_JAR=$(ls -t "$PROJECT_ROOT"/build/libs/*.jar 2>/dev/null | head -n1)
-if [[ ! -f "$PLUGIN_JAR" ]]; then
-  echo "Error: No plugin jar found in $PROJECT_ROOT/build/libs. Build the plugin first."
-  exit 1
-fi
-
-# Optional: Warn if jar is older than any source file
-if find "$PROJECT_ROOT/src/main/java" "$PROJECT_ROOT/src/main/resources" -type f -newer "$PLUGIN_JAR" | grep -q .; then
-  echo "Warning: The built plugin jar is older than some source files. Consider rebuilding."
-fi
-
-mkdir -p "$MINECRAFT_SERVER_PATH/plugins"
-cp "$PLUGIN_JAR" "$MINECRAFT_SERVER_PATH/plugins/"
-echo "Deployed $PLUGIN_JAR to $MINECRAFT_SERVER_PATH/plugins/" 

tools/bash/start-server.sh

@@ -1,27 +0,0 @@
-#!/usr/bin/env bash
-
-set -e
-
-# Check required environment variables
-if [[ -z "$MINECRAFT_SERVER_PATH" || -z "$MINECRAFT_SERVER_JAR" ]]; then
-  echo "Error: MINECRAFT_SERVER_PATH and MINECRAFT_SERVER_JAR must be set."
-  exit 1
-fi
-
-cd "$MINECRAFT_SERVER_PATH"
-
-# Find running server process (java with the server jar)
-SERVER_PID=$(pgrep -f "java.*$MINECRAFT_SERVER_JAR" || true)
-
-if [[ -n "$SERVER_PID" ]]; then
-  echo "Minecraft server is running (PID: $SERVER_PID). Stopping it..."
-  kill "$SERVER_PID"
-  sleep 5
-else
-  echo "Minecraft server is not running."
-fi
-
-# Start the server (in a detached screen session)
-pushd "${MINECRAFT_SERVER_PATH}"
-java -jar "${MINECRAFT_SERVER_JAR}"
-popd

tools/bash/stop-server.sh

@@ -1,21 +0,0 @@
-#!/usr/bin/env bash
-
-set -e
-
-if [[ -z "$MINECRAFT_SERVER_PATH" || -z "$MINECRAFT_SERVER_JAR" ]]; then
-  echo "Error: MINECRAFT_SERVER_PATH and MINECRAFT_SERVER_JAR must be set."
-  exit 1
-fi
-
-cd "$MINECRAFT_SERVER_PATH"
-
-SERVER_PID=$(pgrep -f "java.*$MINECRAFT_SERVER_JAR" || true)
-
-if [[ -n "$SERVER_PID" ]]; then
-  echo "Minecraft server is running (PID: $SERVER_PID). Stopping it..."
-  kill "$SERVER_PID"
-  sleep 5
-  echo "Minecraft server stopped."
-else
-  echo "Minecraft server is not running."
-fi

tools/build-plugin.sh

@@ -0,0 +1,44 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+PROJECT_ROOT="$(cd "$SCRIPT_DIR/.." && pwd)"
+
+export GRADLE_USER_HOME="${GRADLE_USER_HOME:-$PROJECT_ROOT/.gradle/user-home}"
+mkdir -p "$GRADLE_USER_HOME/jdks"
+
+ensure_java_25() {
+  local version="25"
+  local os arch archive java_bin actual_home
+
+  case "$(uname -s)" in
+    Darwin) os="mac" ;;
+    Linux) os="linux" ;;
+    *) echo "Unsupported OS: $(uname -s)" >&2; exit 1 ;;
+  esac
+
+  case "$(uname -m)" in
+    arm64|aarch64) arch="aarch64" ;;
+    x86_64|amd64) arch="x64" ;;
+    *) echo "Unsupported architecture: $(uname -m)" >&2; exit 1 ;;
+  esac
+
+  java_bin=$(find "$GRADLE_USER_HOME/jdks" -path '*/bin/java' -type f 2>/dev/null | head -n 1 || true)
+  if [[ -z "$java_bin" ]]; then
+    echo "Downloading Temurin JDK $version into $GRADLE_USER_HOME/jdks..."
+    archive="$GRADLE_USER_HOME/jdks/temurin-$version.tar.gz"
+    curl -fsSL "https://api.adoptium.net/v3/binary/latest/$version/ga/${os}/${arch}/jdk/hotspot/normal/eclipse" -o "$archive"
+    tar -xzf "$archive" -C "$GRADLE_USER_HOME/jdks"
+    rm -f "$archive"
+    java_bin=$(find "$GRADLE_USER_HOME/jdks" -path '*/bin/java' -type f 2>/dev/null | head -n 1 || true)
+  fi
+
+  [[ -n "$java_bin" ]] || { echo "Error: could not locate installed JDK 25." >&2; exit 1; }
+  actual_home="$(dirname "$(dirname "$java_bin")")"
+  export JAVA_HOME="$actual_home"
+  export PATH="$JAVA_HOME/bin:$PATH"
+}
+
+ensure_java_25
+cd "$PROJECT_ROOT"
+./gradlew build "$@"

tools/deploy-plugin.sh

@@ -0,0 +1,63 @@
+#!/usr/bin/env bash
+set -e
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+PROJECT_ROOT="$(cd "$SCRIPT_DIR/.." && pwd)"
+
+if [[ ! -r "$PROJECT_ROOT/.env" ]]; then
+  echo "Error: $PROJECT_ROOT/.env is missing or unreadable. Copy .env.example to .env and set its values." >&2
+  exit 1
+fi
+load_project_env() {
+  local env_line env_key env_value first_char last_char
+  while IFS= read -r env_line || [[ -n "$env_line" ]]; do
+    env_line="${env_line%$'\r'}"
+    [[ "$env_line" =~ ^[[:space:]]*(#|$) ]] && continue
+    [[ "$env_line" == *=* ]] || continue
+
+    env_key="${env_line%%=*}"
+    env_value="${env_line#*=}"
+    env_key="${env_key#"${env_key%%[![:space:]]*}"}"
+    env_key="${env_key%"${env_key##*[![:space:]]}"}"
+    [[ "$env_key" =~ ^[A-Za-z_][A-Za-z0-9_]*$ ]] || continue
+    env_value="${env_value#"${env_value%%[![:space:]]*}"}"
+    env_value="${env_value%"${env_value##*[![:space:]]}"}"
+
+    if (( ${#env_value} >= 2 )); then
+      first_char="${env_value:0:1}"
+      last_char="${env_value:$((${#env_value} - 1)):1}"
+      if [[ "$first_char" == "$last_char" && ( "$first_char" == '"' || "$first_char" == "'" ) ]]; then
+        env_value="${env_value:1:$((${#env_value} - 2))}"
+      fi
+    fi
+
+    if [[ -z "${!env_key:-}" ]]; then
+      export "$env_key=$env_value"
+    fi
+  done < "$PROJECT_ROOT/.env"
+}
+load_project_env
+
+MINECRAFT_SERVER_PATH="${MINECRAFT_SERVER_PATH:-MCServer}"
+MINECRAFT_SERVER_PATH="${MINECRAFT_SERVER_PATH/#\~/$HOME}"
+[[ "$MINECRAFT_SERVER_PATH" == /* ]] || MINECRAFT_SERVER_PATH="$PROJECT_ROOT/$MINECRAFT_SERVER_PATH"
+
+if [[ -z "$MINECRAFT_SERVER_PATH" ]]; then
+  echo "Error: MINECRAFT_SERVER_PATH environment variable is not set."
+  exit 1
+fi
+
+PLUGIN_JAR=$(ls -t "$PROJECT_ROOT"/build/libs/*.jar 2>/dev/null | grep -v -- '-all\.jar$' | head -n1)
+if [[ ! -f "$PLUGIN_JAR" ]]; then
+  echo "Error: No plugin jar found in $PROJECT_ROOT/build/libs. Build the plugin first."
+  exit 1
+fi
+
+# Optional: Warn if jar is older than any source file
+if find "$PROJECT_ROOT/src/main/java" "$PROJECT_ROOT/src/main/resources" -type f -newer "$PLUGIN_JAR" | grep -q .; then
+  echo "Warning: The built plugin jar is older than some source files. Consider rebuilding."
+fi
+
+mkdir -p "$MINECRAFT_SERVER_PATH/plugins"
+cp "$PLUGIN_JAR" "$MINECRAFT_SERVER_PATH/plugins/"
+echo "Deployed $PLUGIN_JAR to $MINECRAFT_SERVER_PATH/plugins/" 

tools/publish-local.sh

@@ -0,0 +1,44 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+PROJECT_ROOT="$(cd "$SCRIPT_DIR/.." && pwd)"
+
+export GRADLE_USER_HOME="${GRADLE_USER_HOME:-$PROJECT_ROOT/.gradle/user-home}"
+mkdir -p "$GRADLE_USER_HOME/jdks"
+
+ensure_java_25() {
+  local version="25"
+  local os arch archive java_bin actual_home
+
+  case "$(uname -s)" in
+    Darwin) os="mac" ;;
+    Linux) os="linux" ;;
+    *) echo "Unsupported OS: $(uname -s)" >&2; exit 1 ;;
+  esac
+
+  case "$(uname -m)" in
+    arm64|aarch64) arch="aarch64" ;;
+    x86_64|amd64) arch="x64" ;;
+    *) echo "Unsupported architecture: $(uname -m)" >&2; exit 1 ;;
+  esac
+
+  java_bin=$(find "$GRADLE_USER_HOME/jdks" -path '*/bin/java' -type f 2>/dev/null | head -n 1 || true)
+  if [[ -z "$java_bin" ]]; then
+    echo "Downloading Temurin JDK $version into $GRADLE_USER_HOME/jdks..."
+    archive="$GRADLE_USER_HOME/jdks/temurin-$version.tar.gz"
+    curl -fsSL "https://api.adoptium.net/v3/binary/latest/$version/ga/${os}/${arch}/jdk/hotspot/normal/eclipse" -o "$archive"
+    tar -xzf "$archive" -C "$GRADLE_USER_HOME/jdks"
+    rm -f "$archive"
+    java_bin=$(find "$GRADLE_USER_HOME/jdks" -path '*/bin/java' -type f 2>/dev/null | head -n 1 || true)
+  fi
+
+  [[ -n "$java_bin" ]] || { echo "Error: could not locate installed JDK 25." >&2; exit 1; }
+  actual_home="$(dirname "$(dirname "$java_bin")")"
+  export JAVA_HOME="$actual_home"
+  export PATH="$JAVA_HOME/bin:$PATH"
+}
+
+ensure_java_25
+cd "$PROJECT_ROOT"
+./gradlew publishToMavenLocal "$@"

tools/publish-modrinth.sh

@@ -0,0 +1,169 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+PROJECT_ROOT="$(cd "$SCRIPT_DIR/.." && pwd)"
+
+if [[ ! -r "$PROJECT_ROOT/.env" ]]; then
+  echo "Error: $PROJECT_ROOT/.env is missing or unreadable. Copy .env.example to .env and set its values." >&2
+  exit 1
+fi
+load_project_env() {
+  local env_line env_key env_value first_char last_char
+  while IFS= read -r env_line || [[ -n "$env_line" ]]; do
+    env_line="${env_line%$'\r'}"
+    [[ "$env_line" =~ ^[[:space:]]*(#|$) ]] && continue
+    [[ "$env_line" == *=* ]] || continue
+
+    env_key="${env_line%%=*}"
+    env_value="${env_line#*=}"
+    env_key="${env_key#"${env_key%%[![:space:]]*}"}"
+    env_key="${env_key%"${env_key##*[![:space:]]}"}"
+    [[ "$env_key" =~ ^[A-Za-z_][A-Za-z0-9_]*$ ]] || continue
+    env_value="${env_value#"${env_value%%[![:space:]]*}"}"
+    env_value="${env_value%"${env_value##*[![:space:]]}"}"
+
+    if (( ${#env_value} >= 2 )); then
+      first_char="${env_value:0:1}"
+      last_char="${env_value:$((${#env_value} - 1)):1}"
+      if [[ "$first_char" == "$last_char" && ( "$first_char" == '"' || "$first_char" == "'" ) ]]; then
+        env_value="${env_value:1:$((${#env_value} - 2))}"
+      fi
+    fi
+
+    if [[ -z "${!env_key:-}" ]]; then
+      export "$env_key=$env_value"
+    fi
+  done < "$PROJECT_ROOT/.env"
+}
+load_project_env
+
+# Required env:
+#   MODRINTH_TOKEN
+#   MODRINTH_PROJECT_ID (project ID or slug)
+#   MODRINTH_GAME_VERSIONS (optional comma-separated list; defaults to 1.21 through 1.21.7)
+#   MODRINTH_LOADERS (optional, comma-separated, default paper)
+#   MODRINTH_CHANGELOG (optional)
+# Optional:
+#   MODRINTH_DEPENDENCIES (optional JSON array or a single JSON string)
+#   MODRINTH_FILE (optional path to the jar; defaults to build/libs/*.jar)
+
+MODRINTH_TOKEN="${MODRINTH_TOKEN:-}"
+MODRINTH_PROJECT_ID="${MODRINTH_PROJECT_ID:-5NYwxysp}"
+generate_changelog() {
+  local current_tag previous_tag range commits
+  current_tag=$(git -C "$PROJECT_ROOT" describe --tags --exact-match HEAD 2>/dev/null || true)
+  if [[ -n "$current_tag" ]]; then
+    previous_tag=$(git -C "$PROJECT_ROOT" describe --tags --abbrev=0 "${current_tag}^" 2>/dev/null || true)
+    range="${previous_tag:+$previous_tag..}$current_tag"
+  else
+    previous_tag=$(git -C "$PROJECT_ROOT" describe --tags --abbrev=0 2>/dev/null || true)
+    range="${previous_tag:+$previous_tag..}HEAD"
+  fi
+  commits=$(git -C "$PROJECT_ROOT" log --no-merges --format='- %s (%h)' "$range" 2>/dev/null || true)
+  if [[ -z "$commits" ]]; then
+    commits='- No commit messages found for this release.'
+  fi
+  printf '%s\n\n%s\n' "## What's Changed" "$commits"
+}
+MODRINTH_CHANGELOG="${MODRINTH_CHANGELOG:-$(generate_changelog)}"
+MODRINTH_GAME_VERSIONS="${MODRINTH_GAME_VERSIONS:-26.2,26.3}"
+MODRINTH_LOADERS="${MODRINTH_LOADERS:-paper}"
+MODRINTH_VERSION_TYPE="${MODRINTH_VERSION_TYPE:-}"
+MODRINTH_FILE="${MODRINTH_FILE:-}"
+MODRINTH_DEPENDENCIES="${MODRINTH_DEPENDENCIES:-}"
+
+MODRINTH_VERSION=$(
+  "$PROJECT_ROOT/gradlew" -q -p "$PROJECT_ROOT" properties --property version \
+    | sed -n 's/^version: //p'
+)
+if [[ -z "$MODRINTH_VERSION" ]]; then
+  echo "Error: could not determine the project version from Gradle." >&2
+  exit 1
+fi
+if [[ -z "$MODRINTH_VERSION_TYPE" ]]; then
+  if [[ "$MODRINTH_VERSION" == *-* ]]; then
+    MODRINTH_VERSION_TYPE="beta"
+  else
+    MODRINTH_VERSION_TYPE="release"
+  fi
+fi
+case "$MODRINTH_VERSION_TYPE" in
+  release|beta|alpha) ;;
+  *) echo "Error: MODRINTH_VERSION_TYPE must be release, beta, or alpha." >&2; exit 1 ;;
+esac
+MODRINTH_VERSION_NAME="ScoreKeeper $MODRINTH_VERSION"
+
+if [[ -n "$MODRINTH_FILE" && "$MODRINTH_FILE" != /* ]]; then
+  MODRINTH_FILE="$PROJECT_ROOT/$MODRINTH_FILE"
+fi
+
+if [[ -z "$MODRINTH_TOKEN" ]]; then
+  echo "Error: MODRINTH_TOKEN is not set in $PROJECT_ROOT/.env" >&2
+  exit 1
+fi
+if [[ -z "$MODRINTH_FILE" ]]; then
+  MODRINTH_FILE=$(ls -t "$PROJECT_ROOT"/build/libs/*.jar 2>/dev/null | grep -v -- '-all\.jar$' | head -n1 || true)
+fi
+if [[ -z "$MODRINTH_FILE" || ! -f "$MODRINTH_FILE" ]]; then
+  echo "Error: no jar found for Modrinth upload. Build the project first or set MODRINTH_FILE." >&2
+  exit 1
+fi
+if ! command -v unzip >/dev/null; then
+  echo "Error: 'unzip' is required to verify the plugin version in the jar." >&2
+  exit 1
+fi
+JAR_VERSION=$(unzip -p "$MODRINTH_FILE" plugin.yml 2>/dev/null | sed -n 's/^version: //p' | head -n1 || true)
+if [[ -z "$JAR_VERSION" ]]; then
+  echo "Error: could not read the plugin version from $MODRINTH_FILE." >&2
+  exit 1
+fi
+if [[ "$JAR_VERSION" != "$MODRINTH_VERSION" ]]; then
+  echo "Error: jar version $JAR_VERSION does not match Gradle version $MODRINTH_VERSION. Rebuild the plugin and retry." >&2
+  exit 1
+fi
+
+csv_to_json_array() {
+  jq -cn --arg csv "$1" '$csv | split(",") | map(gsub("^\\s+|\\s+$"; "")) | map(select(length > 0))'
+}
+MODRINTH_GAME_VERSIONS_JSON=$(csv_to_json_array "$MODRINTH_GAME_VERSIONS")
+MODRINTH_LOADERS_JSON=$(csv_to_json_array "$MODRINTH_LOADERS")
+if [[ -n "$MODRINTH_DEPENDENCIES" ]]; then
+  if ! MODRINTH_DEPENDENCIES_JSON=$(jq -ce 'if type == "array" then . else error("dependencies must be a JSON array") end' <<<"$MODRINTH_DEPENDENCIES"); then
+    echo "Error: MODRINTH_DEPENDENCIES must be a JSON array." >&2
+    exit 1
+  fi
+else
+  MODRINTH_DEPENDENCIES_JSON='[]'
+fi
+
+MODRINTH_DATA=$(jq -cn \
+  --arg project_id "$MODRINTH_PROJECT_ID" \
+  --arg name "$MODRINTH_VERSION_NAME" \
+  --arg version_number "$MODRINTH_VERSION" \
+  --arg version_type "$MODRINTH_VERSION_TYPE" \
+  --arg changelog "$MODRINTH_CHANGELOG" \
+  --argjson featured false \
+  --argjson dependencies "$MODRINTH_DEPENDENCIES_JSON" \
+  --argjson game_versions "$MODRINTH_GAME_VERSIONS_JSON" \
+  --argjson loaders "$MODRINTH_LOADERS_JSON" \
+  '{project_id: $project_id, name: $name, version_number: $version_number, version_type: $version_type, featured: $featured, changelog: $changelog, dependencies: $dependencies, game_versions: $game_versions, loaders: $loaders, file_parts: ["file"], primary_file: "file"}')
+
+CURL_ARGS=(
+  -X POST "https://api.modrinth.com/v2/version"
+  -H "Authorization: $MODRINTH_TOKEN"
+  -F "data=$MODRINTH_DATA;type=application/json"
+  -F "file=@$MODRINTH_FILE"
+)
+
+HTTP_RESPONSE=$(curl -sS -w $'\n%{http_code}' "${CURL_ARGS[@]}")
+HTTP_STATUS="${HTTP_RESPONSE##*$'\n'}"
+HTTP_BODY="${HTTP_RESPONSE%$'\n'*}"
+if [[ "$HTTP_STATUS" != 2?? ]]; then
+  echo "Error: Modrinth API returned HTTP $HTTP_STATUS:" >&2
+  if ! printf '%s\n' "$HTTP_BODY" | jq -r '.description // .error // .' >&2; then
+    printf '%s\n' "$HTTP_BODY" >&2
+  fi
+  exit 1
+fi
+printf '%s\n' "$HTTP_BODY" | jq .

tools/restore-server.sh

@@ -0,0 +1,107 @@
+#!/usr/bin/env bash
+# Restores a backup made by backup-server.sh into MINECRAFT_SERVER_PATH.
+# Each top-level item in the archive (plugins, config, worlds, settings) is
+# replaced; a "pre-restore" backup of the current state is taken first.
+#
+# Usage: restore-server.sh [-y|--yes] [--no-backup] [backup-file|name]
+#   Defaults to the newest backup in MINECRAFT_BACKUP_PATH.
+
+set -euo pipefail
+
+TOOLS_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+PROJECT_ROOT="$(cd "$TOOLS_DIR/.." && pwd)"
+if [[ ! -r "$PROJECT_ROOT/.env" ]]; then
+  echo "Error: $PROJECT_ROOT/.env is missing or unreadable. Copy .env.example to .env and set its values." >&2
+  exit 1
+fi
+load_project_env() {
+  local env_line env_key env_value first_char last_char
+  while IFS= read -r env_line || [[ -n "$env_line" ]]; do
+    env_line="${env_line%$'\r'}"
+    [[ "$env_line" =~ ^[[:space:]]*(#|$) ]] && continue
+    [[ "$env_line" == *=* ]] || continue
+
+    env_key="${env_line%%=*}"
+    env_value="${env_line#*=}"
+    env_key="${env_key#"${env_key%%[![:space:]]*}"}"
+    env_key="${env_key%"${env_key##*[![:space:]]}"}"
+    [[ "$env_key" =~ ^[A-Za-z_][A-Za-z0-9_]*$ ]] || continue
+    env_value="${env_value#"${env_value%%[![:space:]]*}"}"
+    env_value="${env_value%"${env_value##*[![:space:]]}"}"
+
+    if (( ${#env_value} >= 2 )); then
+      first_char="${env_value:0:1}"
+      last_char="${env_value:$((${#env_value} - 1)):1}"
+      if [[ "$first_char" == "$last_char" && ( "$first_char" == '"' || "$first_char" == "'" ) ]]; then
+        env_value="${env_value:1:$((${#env_value} - 2))}"
+      fi
+    fi
+
+    if [[ -z "${!env_key:-}" ]]; then
+      export "$env_key=$env_value"
+    fi
+  done < "$PROJECT_ROOT/.env"
+}
+load_project_env
+
+MINECRAFT_SERVER_PATH="${MINECRAFT_SERVER_PATH:-MCServer}"
+MINECRAFT_SERVER_PATH="${MINECRAFT_SERVER_PATH/#\~/$HOME}"
+[[ "$MINECRAFT_SERVER_PATH" == /* ]] || MINECRAFT_SERVER_PATH="$PROJECT_ROOT/$MINECRAFT_SERVER_PATH"
+MINECRAFT_BACKUP_PATH="${MINECRAFT_BACKUP_PATH:-backups}"
+MINECRAFT_BACKUP_PATH="${MINECRAFT_BACKUP_PATH/#\~/$HOME}"
+[[ "$MINECRAFT_BACKUP_PATH" == /* ]] || MINECRAFT_BACKUP_PATH="$PROJECT_ROOT/$MINECRAFT_BACKUP_PATH"
+
+ASSUME_YES=false
+SAFETY_BACKUP=true
+ARCHIVE=""
+for arg in "$@"; do
+  case "$arg" in
+    -y|--yes) ASSUME_YES=true ;;
+    --no-backup) SAFETY_BACKUP=false ;;
+    -h|--help) sed -n '2,8p' "$0"; exit 0 ;;
+    -*) echo "Unknown option: $arg" >&2; exit 1 ;;
+    *) ARCHIVE="$arg" ;;
+  esac
+done
+
+if [[ -z "$ARCHIVE" ]]; then
+  ARCHIVE=$(ls -t "$MINECRAFT_BACKUP_PATH"/backup-*.tar.bz2 2>/dev/null | head -n1 || true)
+  [[ -n "$ARCHIVE" ]] || { echo "Error: no backups found in $MINECRAFT_BACKUP_PATH." >&2; exit 1; }
+elif [[ ! -f "$ARCHIVE" && -f "$MINECRAFT_BACKUP_PATH/$ARCHIVE" ]]; then
+  ARCHIVE="$MINECRAFT_BACKUP_PATH/$ARCHIVE"
+fi
+[[ -f "$ARCHIVE" ]] || { echo "Error: backup not found: $ARCHIVE" >&2; exit 1; }
+ARCHIVE="$(cd "$(dirname "$ARCHIVE")" && pwd)/$(basename "$ARCHIVE")"
+
+if pgrep -f "java.*paper-.*\.jar" >/dev/null; then
+  echo "Error: the server is running. Stop it first (tools/stop-server.sh)." >&2
+  exit 1
+fi
+
+ENTRIES=$(tar -tjf "$ARCHIVE")
+if grep -qE '^/|(^|/)\.\.(/|$)' <<<"$ENTRIES"; then
+  echo "Error: archive contains absolute or '..' paths; refusing to restore." >&2
+  exit 1
+fi
+TOP_LEVEL=$(sed -E 's#^\./##; s#/.*##' <<<"$ENTRIES" | { grep -vE '^\.?$' || true; } | sort -u)
+[[ -n "$TOP_LEVEL" ]] || { echo "Error: backup is empty." >&2; exit 1; }
+
+echo "Restore $(basename "$ARCHIVE") into $MINECRAFT_SERVER_PATH"
+echo "These items will be replaced:"
+sed 's/^/  /' <<<"$TOP_LEVEL"
+if ! $ASSUME_YES; then
+  read -r -p "Continue? [y/N] " reply
+  [[ "$reply" =~ ^[Yy]$ ]] || { echo "Aborted."; exit 1; }
+fi
+
+mkdir -p "$MINECRAFT_SERVER_PATH"
+if $SAFETY_BACKUP && [[ -n "$(ls -A "$MINECRAFT_SERVER_PATH")" ]]; then
+  "$TOOLS_DIR/backup-server.sh" pre-restore
+fi
+
+while IFS= read -r item; do
+  rm -rf "${MINECRAFT_SERVER_PATH:?}/$item"
+done <<<"$TOP_LEVEL"
+
+tar -xjf "$ARCHIVE" -C "$MINECRAFT_SERVER_PATH"
+echo "Restored $(basename "$ARCHIVE")."

tools/start-server.sh

@@ -0,0 +1,131 @@
+#!/usr/bin/env bash
+# Downloads (if missing) and runs a Paper server via the Fill v3 API.
+# Server settings come from the project .env file.
+#
+# Env vars:
+#   JAVA_OPTS              Extra JVM args (default: -Xms2G -Xmx2G)
+
+set -euo pipefail
+
+TOOLS_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+PROJECT_ROOT="$(cd "$TOOLS_DIR/.." && pwd)"
+if [[ ! -r "$PROJECT_ROOT/.env" ]]; then
+  echo "Error: $PROJECT_ROOT/.env is missing or unreadable. Copy .env.example to .env and set its values." >&2
+  exit 1
+fi
+load_project_env() {
+  local env_line env_key env_value first_char last_char
+  while IFS= read -r env_line || [[ -n "$env_line" ]]; do
+    env_line="${env_line%$'\r'}"
+    [[ "$env_line" =~ ^[[:space:]]*(#|$) ]] && continue
+    [[ "$env_line" == *=* ]] || continue
+
+    env_key="${env_line%%=*}"
+    env_value="${env_line#*=}"
+    env_key="${env_key#"${env_key%%[![:space:]]*}"}"
+    env_key="${env_key%"${env_key##*[![:space:]]}"}"
+    [[ "$env_key" =~ ^[A-Za-z_][A-Za-z0-9_]*$ ]] || continue
+    env_value="${env_value#"${env_value%%[![:space:]]*}"}"
+    env_value="${env_value%"${env_value##*[![:space:]]}"}"
+
+    if (( ${#env_value} >= 2 )); then
+      first_char="${env_value:0:1}"
+      last_char="${env_value:$((${#env_value} - 1)):1}"
+      if [[ "$first_char" == "$last_char" && ( "$first_char" == '"' || "$first_char" == "'" ) ]]; then
+        env_value="${env_value:1:$((${#env_value} - 2))}"
+      fi
+    fi
+
+    if [[ -z "${!env_key:-}" ]]; then
+      export "$env_key=$env_value"
+    fi
+  done < "$PROJECT_ROOT/.env"
+}
+load_project_env
+
+PAPER_VERSION="${PAPER_VERSION:-}"
+PAPER_BUILD="${PAPER_BUILD:-}"
+MINECRAFT_SERVER_JAR="${MINECRAFT_SERVER_JAR:-}"
+MINECRAFT_SERVER_PATH="${MINECRAFT_SERVER_PATH:-MCServer}"
+MINECRAFT_SERVER_PATH="${MINECRAFT_SERVER_PATH/#\~/$HOME}"
+[[ "$MINECRAFT_SERVER_PATH" == /* ]] || MINECRAFT_SERVER_PATH="$PROJECT_ROOT/$MINECRAFT_SERVER_PATH"
+
+[[ -n "$PAPER_VERSION" ]] || { echo "Error: PAPER_VERSION is not set (see .env)." >&2; exit 1; }
+
+PAPER_PROJECT="paper"
+JAVA_OPTS="${JAVA_OPTS:--Xms2G -Xmx2G}"
+FILL_API="https://fill.papermc.io/v3/projects/${PAPER_PROJECT}/versions/${PAPER_VERSION}"
+# Fill requires a non-generic User-Agent with contact info.
+USER_AGENT="${PAPER_USER_AGENT:-majinnaibu-plugin-dev/1.0 (https://github.com/majinnaibu)}"
+
+for cmd in curl jq java shasum; do
+  command -v "$cmd" >/dev/null || { echo "Error: '$cmd' is required." >&2; exit 1; }
+done
+
+api_get() {
+  curl -fsSL -H "User-Agent: $USER_AGENT" "$1"
+}
+
+mkdir -p "$MINECRAFT_SERVER_PATH"
+cd "$MINECRAFT_SERVER_PATH"
+
+JAR_BUILD="${MINECRAFT_SERVER_JAR:-}"
+JAR_BUILD="${JAR_BUILD#paper-"$PAPER_VERSION"-}"; JAR_BUILD="${JAR_BUILD%.jar}"
+if [[ -z "$PAPER_BUILD" && "$JAR_BUILD" =~ ^[0-9]+$ ]]; then
+  PAPER_BUILD="$JAR_BUILD"
+fi
+
+if [[ -z "$PAPER_BUILD" ]]; then
+  echo "Resolving latest stable build for Paper $PAPER_VERSION..."
+  PAPER_BUILD=$(api_get "$FILL_API/builds" \
+    | jq -r 'map(select(.channel == "STABLE")) | max_by(.id) | .id // empty') || true
+  if [[ -z "$PAPER_BUILD" ]]; then
+    # Offline or no stable build: fall back to the newest local jar for this version.
+    for f in paper-"$PAPER_VERSION"-*.jar; do
+      b="${f#paper-"$PAPER_VERSION"-}"; b="${b%.jar}"
+      [[ "$b" =~ ^[0-9]+$ ]] && (( b > ${PAPER_BUILD:-0} )) && PAPER_BUILD="$b"
+    done
+    [[ -n "$PAPER_BUILD" ]] || { echo "Error: no stable build found for $PAPER_VERSION." >&2; exit 1; }
+    echo "Could not resolve from API; using local build $PAPER_BUILD."
+  fi
+fi
+
+EXPECTED_JAR="paper-${PAPER_VERSION}-${PAPER_BUILD}.jar"
+if [[ -n "${MINECRAFT_SERVER_JAR:-}" && "$MINECRAFT_SERVER_JAR" != "$EXPECTED_JAR" ]]; then
+  echo "Error: MINECRAFT_SERVER_JAR=$MINECRAFT_SERVER_JAR does not match PAPER_VERSION/PAPER_BUILD ($EXPECTED_JAR)." >&2
+  exit 1
+fi
+MINECRAFT_SERVER_JAR="$EXPECTED_JAR"
+
+if [[ ! -f "$MINECRAFT_SERVER_JAR" ]]; then
+  echo "Downloading $MINECRAFT_SERVER_JAR..."
+  BUILD_JSON=$(api_get "$FILL_API/builds/$PAPER_BUILD")
+  DOWNLOAD_URL=$(jq -r '.downloads."server:default".url // empty' <<<"$BUILD_JSON")
+  EXPECTED_SHA=$(jq -r '.downloads."server:default".checksums.sha256 // empty' <<<"$BUILD_JSON")
+  [[ -n "$DOWNLOAD_URL" ]] || { echo "Error: no download for $PAPER_VERSION build $PAPER_BUILD." >&2; exit 1; }
+
+  TMP_JAR="$MINECRAFT_SERVER_JAR.part"
+  trap 'rm -f "$TMP_JAR"' EXIT
+  curl -fL --progress-bar -H "User-Agent: $USER_AGENT" -o "$TMP_JAR" "$DOWNLOAD_URL"
+
+  ACTUAL_SHA=$(shasum -a 256 "$TMP_JAR" | awk '{print $1}')
+  if [[ -n "$EXPECTED_SHA" && "$ACTUAL_SHA" != "$EXPECTED_SHA" ]]; then
+    echo "Error: checksum mismatch (expected $EXPECTED_SHA, got $ACTUAL_SHA)." >&2
+    exit 1
+  fi
+  mv "$TMP_JAR" "$MINECRAFT_SERVER_JAR"
+  trap - EXIT
+fi
+
+export MINECRAFT_SERVER_PATH MINECRAFT_SERVER_JAR
+
+"$TOOLS_DIR/stop-server.sh"
+
+if ! grep -qs '^eula=true' eula.txt; then
+  echo "Note: accept the EULA by setting eula=true in $MINECRAFT_SERVER_PATH/eula.txt (server will exit until then)."
+fi
+
+echo "Starting $MINECRAFT_SERVER_JAR in $MINECRAFT_SERVER_PATH..."
+# shellcheck disable=SC2086
+exec java $JAVA_OPTS -jar "$MINECRAFT_SERVER_JAR" --nogui
+

tools/stop-server.sh

@@ -0,0 +1,34 @@
+#!/usr/bin/env bash
+# Stops any running Paper server (java process running a paper-*.jar).
+
+set -euo pipefail
+
+STOP_TIMEOUT="${STOP_TIMEOUT:-60}"
+
+SERVER_PIDS=$(pgrep -f "java.*paper-.*\.jar" || true)
+
+if [[ -z "$SERVER_PIDS" ]]; then
+  echo "Minecraft server is not running."
+  exit 0
+fi
+
+for pid in $SERVER_PIDS; do
+  echo "Stopping Minecraft server (PID: $pid)..."
+  # SIGTERM lets Paper run its shutdown hook and save worlds.
+  kill "$pid"
+done
+
+for ((i = 0; i < STOP_TIMEOUT; i++)); do
+  remaining=""
+  for pid in $SERVER_PIDS; do
+    kill -0 "$pid" 2>/dev/null && remaining="$remaining $pid"
+  done
+  if [[ -z "$remaining" ]]; then
+    echo "Minecraft server stopped."
+    exit 0
+  fi
+  sleep 1
+done
+
+echo "Server did not stop within ${STOP_TIMEOUT}s; forcing:$remaining"
+kill -9 $remaining