implement auto resource world wipe

.github/workflows/plugin-resourcewipe-tests.yml

@@ -0,0 +1,23 @@
+name: Plugin ResourceWipe Tests
+
+on:
+  push:
+    paths:
+      - 'plugins/plugin-resourcewipe/**'
+  pull_request:
+    paths:
+      - 'plugins/plugin-resourcewipe/**'
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Set up JDK 21
+        uses: actions/setup-java@v4
+        with:
+          java-version: '21'
+          distribution: 'temurin'
+      - name: Build & test plugin module
+        run: |
+          ./gradlew :plugins:plugin-resourcewipe:test -x :folia-api:compileJava -x :folia-api:compileKotlin --no-daemon

.gitignore

@@ -14,3 +14,5 @@ build
 /paper-api-generator
 
 .idea/
+
+.DS_Store

AGENTS.md

@@ -0,0 +1,130 @@
+**Agents Guide**
+- Purpose: short, actionable instructions for automated coding agents operating in this repo
+- Location: run all commands from repository root; use `./gradlew` (wrapper) to ensure the correct Gradle/JDK/tooling
+
+- Important: this repository is a multi-module Kotlin/Java Gradle project (Paper/Folia fork). The build uses Java toolchain 21; tests and run tasks expect JDK 21.
+
+- Quick commands
+  - Build everything: `./gradlew build` (use `--parallel` for faster builds where appropriate)
+  - Run checks only: `./gradlew check`
+  - Run tests for a specific subproject: `./gradlew :plugins:plugin-islands:test`
+  - Skip tests while building: `./gradlew build -x test`
+  - Run a development server (Folia): `./gradlew :folia-server:runDevServer`
+  - Run an assembled server: `./gradlew :folia-server:runServer`
+  - List available tasks: `./gradlew tasks --all`
+  - Note: `:folia-server:runServer` and `:folia-server:runDevServer` are configured to depend on plugin shadow JAR tasks (see root `build.gradle.kts` `gradle.projectsEvaluated` block). When run, generated plugin JARs are passed to the server via `--add-plugin` arguments.
+
+- Running a single test (recommended way)
+  - Run a single test class in a subproject (Gradle + JUnit 5):
+
+    ```bash
+    ./gradlew :plugins:plugin-islands:test --tests "net.azisaba.vanilife.islands.portal.HologramSpawnerTest"
+    ```
+
+  - Run a single test method:
+
+    ```bash
+    ./gradlew :plugins:plugin-islands:test --tests "net.azisaba.vanilife.islands.portal.HologramSpawnerTest.testSpawnHologram"
+    ```
+
+  - Notes:
+    - Use the fully qualified class name. Surround the `--tests` pattern with quotes to avoid shell expansion.
+    - Gradle's `--tests` supports patterns/wildcards (e.g. `*Hologram*`).
+    - Some projects (notably `:folia-server`) configure `useJUnitPlatform { excludeTags("Slow") }` in their `test` task. By default slow tests will be skipped there.
+    - If a test task adds JVM agents (mockito agent for Java 21) or other `jvmArgumentProviders`, the task configuration will inject them automatically — prefer the Gradle task above over running tests with raw `java`.
+    - For example, `:folia-server` and `:folia-api` register a `mockitoAgent` configuration and use a `MockitoAgentProvider` added to `tasks.test`'s `jvmArgumentProviders`, so `-javaagent:` arguments are injected automatically (see `folia-server/build.gradle.kts` and `folia-api/build.gradle.kts`).
+
+- Debugging tests
+  - Run with stacktrace and verbose logging: add `--stacktrace --info` or `--debug` to your Gradle command.
+  - IDE: use IntelliJ's Run gutter for quick single-test execution and debugging.
+
+- Lint & formatting
+  - There is no enforced ktlint/detekt/spotless configuration in repository root. The project uses Kotlin and Java; prefer the Kotlin official style and IntelliJ formatter.
+  - Note: there is no enforced ktlint/detekt/spotless Gradle configuration, but an IDE ktlint configuration file exists at `.idea/ktlint-plugin.xml` (IDE-level only; not enforced by the build).
+  - Recommended (not yet configured): add `ktlint` and `detekt` and wire them into `./gradlew check`.
+  - Import rules: avoid wildcard imports (`*`), group and order imports sensibly (standard library -> third party -> project), and keep imports alphabetized inside groups.
+
+- Code Style Guidelines (applies to Kotlin & Java plugin code)
+  - Language & tooling
+    - Kotlin is the primary language for plugin code under `plugins/`.
+    - Java code exists (server/upstream). Keep Java changes idiomatic to the surrounding code style.
+    - Use the Gradle wrapper `./gradlew` and Java toolchain (Java 21) defined by the build scripts.
+
+  - Formatting
+    - Use 4-space indentation.
+    - Opening brace on same line (Kotlin default style).
+    - Keep lines reasonably short (wrap at ~120 chars).
+    - Use the IDE formatter or a project ktlint configuration if added.
+
+  - Imports
+    - No wildcard imports. Be explicit.
+    - Group imports with a blank line between standard library (kotlin/java), third-party (org/, com/, io/), and project-local packages (`net.azisaba.*`).
+    - Keep imports alphabetized within each group.
+
+  - Naming
+    - Packages: lower case dot-separated (already `net.azisaba.vanilife.*`).
+    - Classes/objects: UpperCamelCase.
+    - Functions / properties: lowerCamelCase.
+    - Constants (public `const val`): UPPER_SNAKE_CASE inside companion objects or top-level objects.
+    - Test class names: `<Thing>Test` for unit tests and `*TestSuite` for suites.
+
+  - Types & nullability (Kotlin)
+    - Prefer `val` over `var`. Use `var` only when mutation is required.
+    - Prefer explicit return types for public functions and members; internal/private functions may omit when obvious.
+    - Embrace Kotlin nullability: prefer `?.`, `?:`, `let`, and `requireNotNull` where appropriate; avoid unchecked platform-type assumptions when interacting with Java APIs.
+
+  - Error handling & logging
+    - Do not use `e.printStackTrace()` in plugin code. Instead, log contextual information and the exception.
+      - Example (preferred): `plugin.logger.log(Level.SEVERE, "Failed to update hologram UUID in repository", e)`
+    - Catch the most specific exception possible. Avoid catching `Throwable` unless you need to guard a boundary and explicitly document why.
+    - Do not swallow exceptions silently. Log and either handle or rethrow.
+    - Avoid leaking secrets into logs.
+
+  - Coroutines & concurrency
+    - This project uses coroutines and Folia region dispatchers in plugin code (see `plugin.launch(plugin.regionDispatcher(loc))`).
+    - When interacting with Folia/async server internals, schedule actions on the correct dispatcher (region/world thread) rather than running blocking logic on caller threads.
+    - Prefer structured concurrency: tie coroutine lifecycles to plugin lifecycle where appropriate and close resources explicitly.
+
+  - Dependency Injection
+    - Use Koin for DI as in plugin Main classes. Start/stop the `KoinApplication` in `onEnable`/`onDisable` and keep registrations minimal and explicit.
+
+  - Public API & documentation
+    - Add KDoc to public API surface. Keep comments for non-obvious algorithms only.
+    - Avoid TODOs without ticket/issue references.
+
+  - Tests
+    - Use JUnit 5 (junit-jupiter); tests are configured with `useJUnitPlatform()` in server modules.
+    - Tag slow/integration tests with `@Tag("Slow")` and be mindful that `:folia-server:test` excludes that tag by default.
+    - Keep tests hermetic when possible (mock external services). The build already wires a Mockito javaagent for certain test tasks.
+
+- Git / commits
+  - Follow existing commit message style in the repo (conventional-ish: `fix(module): short description`).
+  - Do not rewrite or amend commits unless explicitly required and coordinated with repo owners.
+
+- Files and locations that matter (quick map)
+  - Root build: `build.gradle.kts`
+  - Version catalog: `gradle/libs.versions.toml`
+  - Folia/server project: `:folia-server` (tasks: `runServer`, `runDevServer`, `test`)
+  - Plugins live under `plugins/` (e.g. `:plugins:plugin-islands`, `:plugins:plugin-npc`)
+
+- Cursor/Copilot rules
+  - Cursor rules (.cursor/rules/ or .cursorrules): none found in repo.
+  - Copilot instructions (.github/copilot-instructions.md): none found in repo.
+
+- Troubleshooting hints
+  - If tests warn `SLF4J(W): Defaulting to no-operation (NOP) logger implementation` add a test logging binding (e.g. `org.slf4j:slf4j-simple`) to the test runtime or configure logger inside tests.
+  - If Gradle fails with a JDK mismatch, ensure JDK 21 is used or rely on `./gradlew` which uses the configured Java toolchain.
+  - If a test hangs, run the test class directly from IntelliJ with debugger to inspect threads, or rerun Gradle test with `--debug` and `--stacktrace`.
+
+- If you change formatting or static analysis rules
+  1. Add the tool (ktlint/detekt/spotless) to the Gradle build and wire into `check`.
+  2. Update this `AGENTS.md` with the exact commands for CI and local runs.
+
+Appendix: Example single-test invocations (copy/paste)
+
+  - Class
+    `./gradlew :plugins:plugin-islands:test --tests "net.azisaba.vanilife.islands.portal.HologramSpawnerTest"`
+  - Method
+    `./gradlew :plugins:plugin-islands:test --tests "net.azisaba.vanilife.islands.portal.HologramSpawnerTest.testSpawnHologram"`
+
+If anything in this document is unclear or you need a change to tooling (add ktlint/detekt, configure CI linting, or add a recommended gradle task), update this file and add a short PR explaining why.

build.gradle.kts

@@ -1,10 +1,18 @@
+import com.github.jengelman.gradle.plugins.shadow.tasks.ShadowJar
+import io.papermc.paperweight.tasks.RebuildGitPatches
 import org.gradle.api.tasks.testing.logging.TestExceptionFormat
 import org.gradle.api.tasks.testing.logging.TestLogEvent
-import io.papermc.paperweight.tasks.RebuildGitPatches
 
 plugins {
-    java // TODO java launcher tasks
-    id("io.papermc.paperweight.patcher") version "2.0.0-beta.19"
+    java // ToDo java launcher tasks
+    alias(libs.plugins.kotlin)
+    alias(libs.plugins.paperweight.patcher)
+    alias(libs.plugins.serialization) apply false
+    alias(libs.plugins.shadow) apply false
+}
+
+repositories {
+    mavenCentral()
 }
 
 paperweight {
@@ -30,11 +38,15 @@ paperweight {
     }
 }
 
-val paperMavenPublicUrl = "https://repo.papermc.io/repository/maven-public/"
+val kotlinx = libs.kotlinx
+val packed = libs.packed
+val jnoise = libs.jnoise
 
 subprojects {
     apply(plugin = "java-library")
     apply(plugin = "maven-publish")
+    apply(plugin = "org.jetbrains.kotlin.jvm")
+    apply(plugin = "org.jetbrains.kotlin.plugin.serialization")
 
     extensions.configure<JavaPluginExtension> {
         toolchain {
@@ -44,11 +56,16 @@ subprojects {
 
     repositories {
         mavenCentral()
-        maven(paperMavenPublicUrl)
+        maven("https://repo.azisaba.net/repository/maven-public/")
+        maven("https://repo.azisaba.net/repository/maven-snapshots/")
+        maven("https://repo.papermc.io/repository/maven-public/")
+        maven("https://repo.codemc.io/repository/maven-releases/")
+        maven("https://maven.pvphub.me/tofaa")
     }
 
     dependencies {
-        "testRuntimeOnly"("org.junit.platform:junit-platform-launcher")
+        compileOnly(kotlin("stdlib"))
+        compileOnly(kotlinx.coroutines.core)
     }
 
     tasks.withType<AbstractArchiveTask>().configureEach {
@@ -90,6 +107,29 @@ allprojects {
     }
 }
 
+project(":folia-server") {
+    dependencies {
+        implementation(kotlin("stdlib"))
+        implementation(kotlinx.coroutines.core)
+        implementation(jnoise.pipeline)
+        implementation(packed.core)
+        implementation(packed.resource)
+        implementation(packed.server)
+    }
+}
+
+configure(subprojects.filter { it.path.startsWith(":plugins:") }) {
+    apply(plugin = "com.gradleup.shadow")
+
+    dependencies {
+        compileOnly(project(":folia-api"))
+    }
+
+    tasks.named<ShadowJar>("shadowJar") {
+        archiveClassifier.set("")
+    }
+}
+
 tasks.register("printMinecraftVersion") {
     doLast {
         println(providers.gradleProperty("mcVersion").get().trim())
@@ -101,3 +141,19 @@ tasks.register("printPaperVersion") {
         println(project.version)
     }
 }
+
+gradle.projectsEvaluated {
+    val pluginProjects = subprojects.filter { it.path.startsWith(":plugins:") }
+    val pluginShadowJarTasks = pluginProjects.map { it.tasks.named<ShadowJar>("shadowJar") }
+
+    listOf("runServer", "runDevServer").forEach { taskName ->
+        (findProject(":folia-server")?.tasks?.findByName(taskName) as? JavaExec)?.apply {
+            dependsOn(pluginShadowJarTasks)
+            doFirst {
+                pluginShadowJarTasks.forEach { shadowJarTask ->
+                    args("--add-plugin", shadowJarTask.get().archiveFile.get().asFile.absolutePath)
+                }
+            }
+        }
+    }
+}

docker/compose.test.yaml

@@ -0,0 +1,30 @@
+services:
+  postgres-test-db:
+    image: postgres:16-alpine
+    container_name: aetheria-postgres-test
+    environment:
+      POSTGRES_USER: test
+      POSTGRES_PASSWORD: test
+      POSTGRES_DB: testdb
+      TZ: Asia/Tokyo
+    ports:
+      - "15432:5432"
+
+    command: >
+      postgres
+      -c fsync=off
+      -c synchronous_commit=off
+      -c full_page_writes=off
+      -c checkpoint_timeout=30min
+      -c max_wal_size=2GB
+
+    tmpfs:
+      - /var/lib/postgresql/data
+
+    healthcheck:
+      test: ["CMD-SHELL", "pg_isready -U test -d testdb"]
+      interval: 2s
+      timeout: 2s
+      retries: 30
+
+    restart: unless-stopped