Merge pull request 'Test Backporting' (#343) from test/backporting into main

Reviewed-on: #343

.gitea/workflows/backport-commoncore.yml

@@ -0,0 +1,201 @@
+name: Backport CommonCore
+
+on:
+  pull_request:
+    types: [closed]
+    branches:
+      - main
+
+permissions:
+  contents: write
+  issues: write
+  pull-requests: write
+
+jobs:
+  backport:
+    name: Backport CommonCore changes
+    runs-on: ubuntu-latest
+    if: ${{ github.event.pull_request.merged == true && github.event.pull_request.base.ref == 'main' }}
+    steps:
+      - name: Checkout sources
+        uses: actions/checkout@v6
+        with:
+          ref: main
+          fetch-depth: 0
+          token: ${{ secrets.GITEA_TOKEN }}
+
+      - name: Create version branch backports
+        shell: bash
+        env:
+          GITEA_TOKEN: ${{ secrets.GITEA_TOKEN }}
+        run: |
+          set -euo pipefail
+
+          api() {
+            local method="$1"
+            local path="$2"
+            local body="${3:-}"
+
+            if [[ -n "$body" ]]; then
+              curl --fail --silent --show-error \
+                -X "$method" \
+                -H "Authorization: token ${GITEA_TOKEN}" \
+                -H "Accept: application/json" \
+                -H "Content-Type: application/json" \
+                --data "$body" \
+                "${GITHUB_API_URL}${path}"
+            else
+              curl --fail --silent --show-error \
+                -X "$method" \
+                -H "Authorization: token ${GITEA_TOKEN}" \
+                -H "Accept: application/json" \
+                "${GITHUB_API_URL}${path}"
+            fi
+          }
+
+          repo_path="/repos/${GITHUB_REPOSITORY}"
+          pr_number="$(jq -r '.number' "$GITHUB_EVENT_PATH")"
+          pr_title="$(jq -r '.pull_request.title // ""' "$GITHUB_EVENT_PATH")"
+          event_commit="$(jq -r '.pull_request.merge_commit_sha // .pull_request.merged_commit_id // .commit_id // env.GITHUB_SHA' "$GITHUB_EVENT_PATH")"
+
+          commoncore_files=()
+          page=1
+          while true; do
+            response="$(api GET "${repo_path}/pulls/${pr_number}/files?page=${page}&limit=50")"
+            count="$(jq 'length' <<< "$response")"
+            while IFS= read -r file; do
+              [[ -n "$file" ]] && commoncore_files+=("$file")
+            done < <(jq -r '.[] | (.filename // .path // .name // "") | select(startswith("CommonCore/"))' <<< "$response")
+
+            [[ "$count" -lt 50 ]] && break
+            page=$((page + 1))
+          done
+
+          if [[ "${#commoncore_files[@]}" -eq 0 ]]; then
+            echo "PR #${pr_number} did not change CommonCore/; nothing to backport."
+            exit 0
+          fi
+
+          echo "PR #${pr_number} changed CommonCore files:"
+          printf '  - %s\n' "${commoncore_files[@]}"
+
+          pr_commits=()
+          page=1
+          while true; do
+            response="$(api GET "${repo_path}/pulls/${pr_number}/commits?page=${page}&limit=50")"
+            count="$(jq 'length' <<< "$response")"
+            while IFS= read -r commit; do
+              [[ -n "$commit" ]] && pr_commits+=("$commit")
+            done < <(jq -r '.[] | .sha // .id // empty' <<< "$response")
+
+            [[ "$count" -lt 50 ]] && break
+            page=$((page + 1))
+          done
+
+          source_commits=("$event_commit")
+          if [[ "${#pr_commits[@]}" -gt 1 ]]; then
+            for commit in "${pr_commits[@]}"; do
+              if [[ "$commit" == "$event_commit" ]]; then
+                source_commits=("${pr_commits[@]}")
+                break
+              fi
+            done
+          fi
+
+          echo "Using source commit plan:"
+          printf '  - %s\n' "${source_commits[@]}"
+
+          git config --global user.name "SteamWar Backport Bot"
+          git config --global user.email "backport-bot@steamwar.de"
+          git fetch origin '+refs/heads/*:refs/remotes/origin/*'
+
+          for commit in "${source_commits[@]}"; do
+            git cat-file -e "${commit}^{commit}"
+          done
+
+          mapfile -t version_branches < <(
+            git for-each-ref --format='%(refname:short)' refs/remotes/origin/version |
+              sed 's#^origin/##' |
+              sort -u
+          )
+
+          if [[ "${#version_branches[@]}" -eq 0 ]]; then
+            echo "No origin/version/* branches found; nothing to backport."
+            exit 0
+          fi
+
+          failures=()
+          for target_branch in "${version_branches[@]}"; do
+            safe_target="$(sed -E 's#[^A-Za-z0-9._-]+#-#g; s#^-+##; s#-+$##' <<< "$target_branch")"
+            head_branch="backport/pr-${pr_number}-to-${safe_target}"
+
+            existing_pr="$(api GET "${repo_path}/pulls?state=open&base_branch=$(jq -rn --arg value "$target_branch" '$value|@uri')&limit=50" |
+              jq -r --arg head "$head_branch" '.[] | select(.head.ref == $head) | .number' |
+              head -n 1)"
+
+            if [[ -n "$existing_pr" ]]; then
+              echo "Backport PR #${existing_pr} already exists for ${target_branch}; leaving it unchanged."
+              continue
+            fi
+
+            echo "Creating ${head_branch} from ${target_branch}"
+            git checkout -B "$head_branch" "origin/${target_branch}"
+
+            for commit in "${source_commits[@]}"; do
+              cherry_pick_args=(-x)
+              if [[ "$(git rev-list --parents -n 1 "$commit" | wc -w)" -gt 2 ]]; then
+                cherry_pick_args=(-x -m 1)
+              fi
+
+              if git cherry-pick "${cherry_pick_args[@]}" "$commit"; then
+                continue
+              fi
+
+              if [[ -z "$(git status --porcelain)" ]]; then
+                echo "Cherry-pick of ${commit} produced no changes; skipping it."
+                git cherry-pick --skip || true
+                continue
+              fi
+
+              git cherry-pick --abort || true
+              failures+=("${target_branch}: cherry-pick of ${commit} failed")
+              break
+            done
+
+            if [[ "${failures[*]:-}" == *"${target_branch}:"* ]]; then
+              git checkout main
+              continue
+            fi
+
+            if git diff --quiet "origin/${target_branch}" HEAD; then
+              echo "${target_branch} already contains the change; no PR needed."
+              git checkout main
+              continue
+            fi
+
+            if [[ "${#source_commits[@]}" -eq 1 ]]; then
+              source_text="Source commit: \`${source_commits[0]}\`"
+            else
+              source_text="Source commits:"
+              for commit in "${source_commits[@]}"; do
+                source_text="${source_text} \`${commit}\`"
+              done
+            fi
+
+            description="Automated backport of #${pr_number} to ${target_branch} because the source PR changed CommonCore/. Source PR: ${GITHUB_SERVER_URL}/${GITHUB_REPOSITORY}/pulls/${pr_number}. ${source_text}. This PR will be merged automatically by the Pull Request Build workflow after a successful build."
+
+            git push \
+              -o "topic=${head_branch}" \
+              -o "title=Backport #${pr_number} to ${target_branch}: ${pr_title}" \
+              -o "description=${description}" \
+              -o "force-push" \
+              origin "HEAD:refs/for/${target_branch}"
+            echo "Created backport PR from ${head_branch} to ${target_branch}."
+            git checkout main
+          done
+
+          if [[ "${#failures[@]}" -gt 0 ]]; then
+            echo "Backport failures:"
+            printf '  - %s\n' "${failures[@]}"
+            exit 1
+          fi

.gitea/workflows/build.yml

@@ -0,0 +1,132 @@
+name: Deploy
+
+on:
+  push:
+    branches:
+      - main
+      - version/*
+
+jobs:
+  build:
+    name: Build
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout sources
+        uses: actions/checkout@v6
+      - name: Setup Java 8
+        uses: actions/setup-java@v5
+        with:
+          distribution: 'temurin'
+          java-version: 8
+      - name: Setup Java 11
+        uses: actions/setup-java@v5
+        with:
+          distribution: 'temurin'
+          java-version: 11
+      - name: Setup Java 17
+        uses: actions/setup-java@v5
+        with:
+          distribution: 'temurin'
+          java-version: 17
+      - name: Setup Java
+        uses: actions/setup-java@v5
+        with:
+          distribution: 'temurin'
+          java-version: 21
+      - name: Setup Gradle
+        uses: gradle/actions/setup-gradle@v6
+      - name: Setup Maven Repository
+        env:
+          SW_MAVEN_CREDENTIALS: ${{ secrets.SW_MAVEN_CREDENTIALS }}
+        run: |
+          echo "$SW_MAVEN_CREDENTIALS" > steamwar.properties
+      - name: Build with Gradle
+        run: ./gradlew build --no-daemon
+
+      - name: Stage deploy artifacts
+        shell: bash
+        run: |
+          set -euo pipefail
+
+          rm -rf deploy
+          mkdir -p deploy
+
+          cp "BauSystem/build/libs/BauSystem-all.jar" "deploy/BauSystem.jar"
+          cp "LegacyBauSystem/build/libs/LegacyBauSystem.jar" "deploy/BauSystem-1.12.jar"
+          cp "FightSystem/build/libs/FightSystem-all.jar" "deploy/FightSystem.jar"
+          cp "KotlinCore/build/libs/KotlinCore-all.jar" "deploy/KotlinCore.jar"
+          cp "TNTLeague/build/libs/TNTLeague.jar" "deploy/TNTLeague.jar"
+          cp "LobbySystem/build/libs/LobbySystem.jar" "deploy/LobbySystem.jar"
+          cp "MissileWars/build/libs/MissileWars.jar" "deploy/MissileWars.jar"
+          cp "Realtime/build/libs/Realtime.jar" "deploy/RealTime.jar"
+          cp "SchematicSystem/build/libs/SchematicSystem-all.jar" "deploy/SchematicSystem.jar"
+          cp "SpigotCore/build/libs/SpigotCore-all.jar" "deploy/SpigotCore.jar"
+          cp "Teamserver/build/libs/Teamserver.jar" "deploy/Builder.jar"
+          cp "TowerRun/build/libs/TowerRun.jar" "deploy/TowerRun.jar"
+          cp "VelocityCore/Persistent/build/libs/Persistent.jar" "deploy/PersistentVelocityCore.jar"
+          cp "VelocityCore/Dependencies/build/libs/Dependencies-all.jar" "deploy/DependenciesVelocityCore.jar"
+          cp "VelocityCore/build/libs/VelocityCore-all.jar" "deploy/VelocityCore.jar"
+          cp "WebsiteBackend/build/libs/WebsiteBackend-all.jar" "deploy/website-api.jar"
+
+      - name: Upload deploy artifacts
+        uses: actions/upload-artifact@v3
+        with:
+          name: steamwar-jars
+          path: deploy/
+
+  deploy:
+    name: Deploy
+    runs-on: ubuntu-latest
+    needs: build
+    steps:
+      - name: Download deploy artifacts
+        uses: actions/download-artifact@v3
+        with:
+          name: steamwar-jars
+          path: deploy
+
+      - name: Resolve deploy target
+        id: target
+        shell: bash
+        run: |
+          set -euo pipefail
+
+          if [[ "${GITHUB_REF_NAME}" == "main" ]]; then
+            echo "path=/jars/current" >> "$GITHUB_OUTPUT"
+          elif [[ "${GITHUB_REF_NAME}" == version/* ]]; then
+            version="${GITHUB_REF_NAME#version/}"
+            if [[ ! "$version" =~ ^[A-Za-z0-9._-]+$ ]]; then
+              echo "Unsupported version branch name: ${GITHUB_REF_NAME}" >&2
+              exit 1
+            fi
+            echo "path=/jars/${version}" >> "$GITHUB_OUTPUT"
+          else
+            echo "Unsupported deployment branch: ${GITHUB_REF_NAME}" >&2
+            exit 1
+          fi
+
+      - name: Upload jars with scp
+        shell: bash
+        env:
+          DEPLOY_HOST: ${{ secrets.DEPLOY_HOST }}
+          DEPLOY_USER: ${{ secrets.DEPLOY_USER }}
+          DEPLOY_PORT: ${{ secrets.DEPLOY_PORT }}
+          DEPLOY_SSH_KEY: ${{ secrets.DEPLOY_SSH_KEY }}
+          DEPLOY_PATH: ${{ steps.target.outputs.path }}
+        run: |
+          set -euo pipefail
+
+          : "${DEPLOY_HOST:?Missing DEPLOY_HOST secret}"
+          : "${DEPLOY_USER:?Missing DEPLOY_USER secret}"
+          : "${DEPLOY_SSH_KEY:?Missing DEPLOY_SSH_KEY secret}"
+
+          port="${DEPLOY_PORT:-22}"
+
+          mkdir -p ~/.ssh
+          chmod 700 ~/.ssh
+          echo "$DEPLOY_SSH_KEY" > ~/.ssh/deploy_key
+          chmod 600 ~/.ssh/deploy_key
+          ssh-keyscan -p "$port" "$DEPLOY_HOST" >> ~/.ssh/known_hosts
+
+          ssh -i ~/.ssh/deploy_key -p "$port" "${DEPLOY_USER}@${DEPLOY_HOST}" "mkdir -p '$DEPLOY_PATH'"
+          scp -i ~/.ssh/deploy_key -P "$port" deploy/* "${DEPLOY_USER}@${DEPLOY_HOST}:$DEPLOY_PATH/"

.gitea/workflows/pull-request-build.yml

@@ -0,0 +1,72 @@
+name: Pull Request Build
+
+on:
+  pull_request:
+
+jobs:
+  build:
+    name: Build
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout sources
+        uses: actions/checkout@v6
+      - name: Setup Java 8
+        uses: actions/setup-java@v5
+        with:
+          distribution: 'temurin'
+          java-version: 8
+      - name: Setup Java 11
+        uses: actions/setup-java@v5
+        with:
+          distribution: 'temurin'
+          java-version: 11
+      - name: Setup Java 17
+        uses: actions/setup-java@v5
+        with:
+          distribution: 'temurin'
+          java-version: 17
+      - name: Setup Java
+        uses: actions/setup-java@v5
+        with:
+          distribution: 'temurin'
+          java-version: 21
+      - name: Setup Gradle
+        uses: gradle/actions/setup-gradle@v6
+      - name: Setup Maven Repository
+        env:
+          SW_MAVEN_CREDENTIALS: ${{ secrets.SW_MAVEN_CREDENTIALS }}
+        run: |
+          echo "$SW_MAVEN_CREDENTIALS" > steamwar.properties
+      - name: Build with Gradle
+        run: ./gradlew build --no-daemon
+
+  merge-backport:
+    name: Merge backport
+    runs-on: ubuntu-latest
+    needs: build
+    if: ${{ startsWith(github.event.pull_request.base.ref, 'version/') && startsWith(github.event.pull_request.head.ref, 'backport/pr-') }}
+    permissions:
+      contents: write
+      issues: write
+      pull-requests: write
+    steps:
+      - name: Merge successful backport PR
+        shell: bash
+        env:
+          GITEA_TOKEN: ${{ secrets.GITEA_TOKEN }}
+        run: |
+          set -euo pipefail
+
+          pr_number="$(jq -r '.number' "$GITHUB_EVENT_PATH")"
+          target_branch="$(jq -r '.pull_request.base.ref' "$GITHUB_EVENT_PATH")"
+          payload="$(jq -n \
+            --arg title "Merge backport #${pr_number} into ${target_branch}" \
+            '{Do: "merge", MergeTitleField: $title, MergeMessageField: "Automatic CommonCore backport after successful build.", delete_branch_after_merge: true}')"
+
+          curl --fail --silent --show-error \
+            -X POST \
+            -H "Authorization: token ${GITEA_TOKEN}" \
+            -H "Accept: application/json" \
+            -H "Content-Type: application/json" \
+            --data "$payload" \
+            "${GITHUB_API_URL}/repos/${GITHUB_REPOSITORY}/pulls/${pr_number}/merge"

.gitignore

@@ -21,4 +21,4 @@ lib
 /WebsiteBackend/logs
 /WebsiteBackend/skins
 /WebsiteBackend/config.json
-/WebsiteBackend/sessions
+/WebsiteBackend/sessions

BauSystem/BauSystem_Main/src/de/steamwar/bausystem/features/region/TNTListener.java

@@ -67,11 +67,7 @@ public class TNTListener implements Listener, ScoreboardElement {
 
     @EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
     public void onExplode(EntityExplodeEvent event) {
-        if (!(event.getEntity() instanceof TNTPrimed)) {
+        explode(event.blockList(), event.getEntity() instanceof TNTPrimed);
-            event.blockList().clear();
-            return;
-        }
-        explode(event.blockList(), true);
     }
 
     @Override

BauSystem/BauSystem_Main/src/de/steamwar/bausystem/features/tracer/rendering/ViewFlag.java

@@ -198,6 +198,16 @@ public abstract class ViewFlag {
         }
     };
 
+    public static ViewFlag HIGHLIGHT = new ViewFlag(true, false, "highlight", "h") {
+        @Override
+        public void modify(REntityServer server, List<TraceEntity> entities) {
+            for (TraceEntity entity : entities) {
+                entity.setGlowing(true);
+            }
+        }
+
+    };
+
     /**
      * Name of the flag
      */

CLI/build.gradle.kts

@@ -0,0 +1,32 @@
+plugins {
+    steamwar.kotlin
+    application
+}
+
+kotlin {
+    jvmToolchain(21)
+}
+
+java {
+    sourceCompatibility = JavaVersion.VERSION_21
+    targetCompatibility = JavaVersion.VERSION_21
+}
+
+application {
+    mainClass.set("de.steamwar.MainKt")
+    applicationName = "sw"
+}
+
+dependencies {
+    implementation(project(":CommonCore:SQL"))
+
+    implementation("com.github.ajalt.clikt:clikt:5.0.3")
+    implementation("com.github.ajalt.mordant:mordant:3.0.2")
+    implementation(libs.logback)
+    implementation("org.mariadb.jdbc:mariadb-java-client:3.3.1")
+
+    implementation(libs.exposedCore)
+    implementation(libs.exposedDao)
+    implementation(libs.exposedJdbc)
+    implementation(libs.exposedTime)
+}

CLI/src/Main.kt

@@ -0,0 +1,22 @@
+package de.steamwar
+
+import com.github.ajalt.clikt.core.main
+import com.github.ajalt.clikt.core.subcommands
+import de.steamwar.commands.SteamWar
+import de.steamwar.commands.database.DatabaseCommand
+import de.steamwar.commands.database.InfoCommand
+import de.steamwar.commands.database.ResetCommand
+import de.steamwar.commands.dev.DevCommand
+import de.steamwar.commands.profiler.ProfilerCommand
+import de.steamwar.commands.user.UserCommand
+import de.steamwar.commands.user.UserInfoCommand
+import de.steamwar.commands.user.UserSearchCommand
+
+fun main(args: Array<String>) = SteamWar()
+    .subcommands(
+        DatabaseCommand().subcommands(InfoCommand(), ResetCommand()),
+        UserCommand().subcommands(UserInfoCommand(), UserSearchCommand()),
+        DevCommand(),
+        ProfilerCommand()
+    )
+    .main(args)

CLI/src/commands/SteamWar.kt

@@ -0,0 +1,10 @@
+package de.steamwar.commands
+
+import com.github.ajalt.clikt.core.CliktCommand
+import com.github.ajalt.mordant.rendering.TextStyles
+
+class SteamWar: CliktCommand(name = "sw") {
+    override fun run() {
+        echo(TextStyles.bold("SteamWar-CLI"))
+    }
+}

CLI/src/commands/database/DatabaseCommand.kt

@@ -0,0 +1,22 @@
+package de.steamwar.commands.database
+
+import com.github.ajalt.clikt.core.CliktCommand
+import com.github.ajalt.clikt.core.CliktError
+import com.github.ajalt.clikt.core.Context
+import com.github.ajalt.clikt.core.findOrSetObject
+import com.github.ajalt.clikt.parameters.options.flag
+import com.github.ajalt.clikt.parameters.options.option
+import de.steamwar.db.Database
+
+class DatabaseCommand: CliktCommand(name = "db") {
+    val useProduction by option().flag()
+    val db by findOrSetObject { Database }
+
+    override fun help(context: Context): String = "Run database commands"
+
+    override fun run() {
+        if (!useProduction && db.database == "production") {
+            throw CliktError("You should not use the production database!")
+        }
+    }
+}

CLI/src/commands/database/InfoCommand.kt

@@ -0,0 +1,25 @@
+package de.steamwar.commands.database
+
+import com.github.ajalt.clikt.core.CliktCommand
+import com.github.ajalt.clikt.core.requireObject
+import com.github.ajalt.mordant.table.table
+import de.steamwar.db.Database
+import de.steamwar.db.execute
+import de.steamwar.db.useDb
+
+class InfoCommand: CliktCommand() {
+    val db by requireObject<Database>()
+
+    override fun run() = useDb {
+        val tables = execute("SHOW TABLES") { it.getString(1) }
+
+        echo(
+            table {
+                header { row("Name") }
+                body {
+                    tables.map { row(it) }
+                }
+            }
+        )
+    }
+}

CLI/src/commands/database/ResetCommand.kt

@@ -0,0 +1,33 @@
+package de.steamwar.commands.database
+
+import com.github.ajalt.clikt.core.CliktCommand
+import com.github.ajalt.clikt.core.CliktError
+import com.github.ajalt.clikt.core.requireObject
+import com.github.ajalt.mordant.rendering.TextColors
+import com.github.ajalt.mordant.rendering.TextStyles
+import de.steamwar.db.Database
+import de.steamwar.db.execute
+import de.steamwar.db.useDb
+import java.io.File
+
+class ResetCommand: CliktCommand() {
+    val db by requireObject<Database>()
+
+    override fun run() = useDb {
+        val schemaFile = File("/var/Schema.sql")
+        if (!schemaFile.exists()) {
+            throw CliktError("Schema file not found!")
+        }
+
+        val schema = schemaFile.readText()
+
+        val tables = execute("SHOW TABLES;") { it.getString(1) }
+        for (table in tables) {
+            execute("DROP TABLE IF EXISTS $table;") { }
+        }
+
+        execute(schema) { }
+
+        echo(TextColors.brightGreen(TextStyles.bold("Database reset!")))
+    }
+}

CLI/src/commands/dev/DevCommand.kt

@@ -0,0 +1,179 @@
+package de.steamwar.commands.dev
+
+import com.github.ajalt.clikt.core.CliktCommand
+import com.github.ajalt.clikt.core.CliktError
+import com.github.ajalt.clikt.core.Context
+import com.github.ajalt.clikt.parameters.arguments.argument
+import com.github.ajalt.clikt.parameters.arguments.help
+import com.github.ajalt.clikt.parameters.arguments.multiple
+import com.github.ajalt.clikt.parameters.options.default
+import com.github.ajalt.clikt.parameters.options.defaultLazy
+import com.github.ajalt.clikt.parameters.options.flag
+import com.github.ajalt.clikt.parameters.options.help
+import com.github.ajalt.clikt.parameters.options.option
+import com.github.ajalt.clikt.parameters.types.file
+import com.github.ajalt.clikt.parameters.types.long
+import com.github.ajalt.clikt.parameters.types.path
+import com.sun.security.auth.module.UnixSystem
+import java.io.File
+import kotlin.io.path.absolute
+import kotlin.io.path.absolutePathString
+
+const val LOG4J_CONFIG = """<?xml version="1.0" encoding="UTF-8"?>
+<Configuration status="WARN" packages="com.mojang.util">
+    <Appenders>
+        <Console name="WINDOWS_COMPAT" target="SYSTEM_OUT"></Console>
+        <Queue name="TerminalConsole">
+            <PatternLayout pattern="[%d{HH:mm:ss} %level]: %msg{nolookups}%n" />
+        </Queue>
+        <RollingRandomAccessFile name="File" fileName="$\{'sys:logPath'}/latest.log" filePattern="$\{'sys:logPath'}/%d{yyyy.MM.dd}.log.gz">
+            <PatternLayout pattern="[%d{HH:mm:ss}] [%t/%level]: %msg{nolookups}%n" />
+            <Policies>
+                <TimeBasedTriggeringPolicy />
+            </Policies>
+            <DefaultRolloverStrategy max="7"/>
+        </RollingRandomAccessFile>
+    </Appenders>
+    <Loggers>
+        <Root level="info">
+            <filters>
+                <MarkerFilter marker="NETWORK_PACKETS" onMatch="DENY" onMismatch="NEUTRAL" />
+            </filters>
+            <AppenderRef ref="WINDOWS_COMPAT" level="info"/>
+            <AppenderRef ref="File"/>
+            <AppenderRef ref="TerminalConsole" level="info"/>
+        </Root>
+    </Loggers>
+</Configuration>"""
+
+class DevCommand : CliktCommand("dev") {
+    override fun help(context: Context): String = "Start a dev Server"
+
+    override val treatUnknownOptionsAsArgs = true
+
+    val server by argument().help("Server Template")
+    val port by option("--port").long().defaultLazy { UnixSystem().uid + 1010 }.help("Port for Server")
+    val world by option("--world", "-w").path(canBeFile = false).help("User World")
+    val plugins by option("--plugins", "-p").path(true, canBeFile = false).help("Plugin Dir")
+    val profile by option().flag().help("Add Profiling Arguments")
+    val forceUpgrade by option().flag().help("Force Upgrade")
+    val jar by option().file(true, canBeDir = false).help("Jar File")
+    val jvm by option().file(true, canBeDir = false).help("Java Executable")
+    val jvmArgs by argument().multiple()
+
+    override val printHelpOnEmptyArgs = true
+
+    val workingDir = File("").absoluteFile
+    val log4jConfig = File(workingDir, "log4j2.xml")
+
+    override fun run() {
+        val args = mutableListOf<String>()
+
+        val serverDirectory = File(workingDir, server)
+        val serverDir =
+            if (serverDirectory.exists() && serverDirectory.isDirectory) serverDirectory else File(workingDir, server)
+
+        if (isVelocity(server)) {
+            runServer(args, jvmArgs, listOf(jar?.absolutePath ?: File("/jar/Velocity.jar").absolutePath), serverDir)
+        } else {
+            setLogConfig(args)
+            val version = findVersion(server) ?: throw CliktError("Unknown Server Version")
+            val worldFile = world?.absolute()?.toFile() ?: File(serverDir, "devtempworld")
+            val jarFile = jar?.absolutePath ?: additionalVersions[server]?.let { supportedVersionJars[it] } ?: supportedVersionJars[version]
+            ?: throw CliktError("Unknown Server Version")
+
+            if (!worldFile.exists()) {
+                val templateFile = File(serverDir, "Bauwelt")
+                if (!templateFile.exists()) {
+                    throw CliktError("World Template not found!")
+                }
+                templateFile.copyRecursively(worldFile)
+            }
+
+            val devFile = File("/configs/DevServer/${System.getProperty("user.name")}.$port.$version")
+            if (System.getProperty("user.name") != "minecraft") {
+                devFile.createNewFile()
+            }
+
+            runServer(
+                args, jvmArgs, listOf(
+                    jarFile,
+                    *(if (forceUpgrade) arrayOf("-forceUpgrade") else arrayOf()),
+                    "--port", port.toString(),
+                    "--level-name", worldFile.name,
+                    "--world-dir", workingDir.absolutePath,
+                    "--nogui",
+                    *(if (plugins != null) arrayOf("--plugins", plugins!!.absolutePathString()) else arrayOf())
+                ), serverDir
+            )
+
+            try {
+                devFile.delete()
+            } catch (_: Exception) { /* ignored */ }
+        }
+    }
+
+    val jvmDefaultParams = arrayOf(
+        "-Xmx1G",
+        "-Xgc:excessiveGCratio=80",
+        "-Xsyslog:none",
+        "-Xtrace:none",
+        "-Xnoclassgc",
+        "-Xdisableexplicitgc",
+        "-XX:+AlwaysPreTouch",
+        "-XX:+CompactStrings",
+        "-XX:-HeapDumpOnOutOfMemory",
+        "-XX:+ExitOnOutOfMemoryError"
+    )
+
+    val jvmArgOverrides = arrayOf("--add-opens", "java.base/jdk.internal.misc=ALL-UNNAMED")
+
+    val supportedVersionJars = mapOf(
+        8 to "/jars/paper-1.8.8.jar",
+        9 to "/jars/spigot-1.9.4.jar",
+        10 to "/jars/paper-1.10.2.jar",
+        12 to "/jars/spigot-1.12.2.jar",
+        14 to "/jars/spigot-1.14.4.jar",
+        15 to "/jars/spigot-1.15.2.jar",
+        18 to "/jars/paper-1.18.2.jar",
+        19 to "/jars/paper-1.19.3.jar",
+        20 to "/jars/paper-1.20.1.jar",
+        21 to "/jars/paper-1.21.6.jar"
+    )
+
+    val additionalVersions = mapOf(
+        "Tutorial" to 15,
+        "Lobby" to 20
+    )
+
+    fun findVersion(server: String): Int? = server.dropWhile { !it.isDigit() }.toIntOrNull()
+
+    fun isJava8(server: String): Boolean = findVersion(server)?.let { it <= 10 } ?: false
+
+    fun isVelocity(server: String): Boolean = server.endsWith("Velocity")
+
+    fun setLogConfig(args: MutableList<String>) {
+        args += "-DlogPath=${workingDir.absolutePath}/logs"
+        args += "-Dlog4j.configurationFile=${log4jConfig.absolutePath}"
+
+        if (!log4jConfig.exists()) {
+            log4jConfig.writeText(LOG4J_CONFIG)
+        }
+    }
+
+    fun runServer(args: List<String>, jvmArgs: List<String>, cmd: List<String>, serverDir: File) {
+        val process = ProcessBuilder(
+            jvm?.absolutePath ?: if (isJava8(server)) "/usr/lib/jvm/openj9-8/bin/java" else "java",
+            *jvmArgs.toTypedArray(),
+            *args.toTypedArray(),
+            *jvmDefaultParams,
+            *(if (isJava8(server)) arrayOf() else jvmArgOverrides),
+            *(if (profile) arrayOf("-javaagent:/jars/LixfelsProfiler.jar=start") else arrayOf()),
+            "-Xshareclasses:nonfatal,name=$server",
+            "-jar",
+            *cmd.toTypedArray()
+        ).directory(serverDir).inheritIO().start()
+        Runtime.getRuntime().addShutdownHook(Thread { if (process.isAlive) process.destroyForcibly() })
+        process.waitFor()
+    }
+}

CLI/src/commands/profiler/ProfilerCommand.kt

@@ -0,0 +1,42 @@
+package de.steamwar.commands.profiler
+
+import com.github.ajalt.clikt.core.CliktCommand
+import com.github.ajalt.clikt.core.Context
+import com.github.ajalt.clikt.parameters.arguments.argument
+import com.github.ajalt.clikt.parameters.arguments.help
+import com.github.ajalt.clikt.parameters.arguments.optional
+import com.github.ajalt.clikt.parameters.options.default
+import com.github.ajalt.clikt.parameters.options.option
+import com.github.ajalt.clikt.parameters.types.int
+
+const val SPARK = "/jars/spark.jar"
+
+class ProfilerCommand: CliktCommand("profiler") {
+    val pid by argument().help("Process id").int().optional()
+    val port by option("--port", "-p").int().default(8543)
+
+    override fun run() {
+        if (pid != null) {
+            ProcessBuilder()
+                .command("java", "-jar", SPARK, pid.toString(), "port=$port")
+                .start()
+                .waitFor()
+
+            Thread.sleep(1000)
+
+            ProcessBuilder()
+                .command("ssh", "-o", "StrictHostKeyChecking=no", "-o", "UserKnownHostsFile=/dev/null", "-p", port.toString(), "spark@localhost")
+                .inheritIO()
+                .start()
+                .waitFor()
+        } else {
+            ProcessBuilder()
+                .command("java", "-jar", SPARK)
+                .inheritIO()
+                .start()
+                .waitFor()
+        }
+    }
+
+    override fun help(context: Context): String = "Start a profiler"
+}

CLI/src/commands/user/UserCommand.kt

@@ -0,0 +1,9 @@
+package de.steamwar.commands.user
+
+import com.github.ajalt.clikt.core.CliktCommand
+import com.github.ajalt.clikt.core.Context
+
+class UserCommand: CliktCommand("user") {
+    override fun run() = Unit
+    override fun help(context: Context): String = "User related commands"
+}

CLI/src/commands/user/UserInfoCommand.kt

@@ -0,0 +1,65 @@
+package de.steamwar.commands.user
+
+import com.github.ajalt.clikt.core.CliktCommand
+import com.github.ajalt.clikt.core.CliktError
+import com.github.ajalt.clikt.parameters.arguments.argument
+import com.github.ajalt.clikt.parameters.arguments.help
+import com.github.ajalt.mordant.table.table
+import de.steamwar.db.findUser
+import de.steamwar.db.useDb
+import de.steamwar.sql.Punishment
+import de.steamwar.sql.SessionTable
+import de.steamwar.sql.SteamwarUser
+import de.steamwar.sql.Team
+import org.jetbrains.exposed.v1.core.eq
+import org.jetbrains.exposed.v1.jdbc.selectAll
+import java.time.Duration
+
+class UserInfoCommand : CliktCommand("info") {
+    val userId by argument().help("Id, Name, UUID or DiscordId")
+    val user by lazy { findUser(userId) ?: throw CliktError("User not found") }
+
+    override val printHelpOnEmptyArgs = true
+
+    override fun run() = useDb {
+        val sessions =
+            SessionTable.selectAll().where { SessionTable.userId eq user.id.value }
+                .map { it[SessionTable.startTime] to it[SessionTable.endTime] }
+
+        val totalPlayed = sessions.sumOf { Duration.between(it.first, it.second).toMinutes() } / 60.0
+        val firstJoin = sessions.minByOrNull { it.first }?.first
+        val lastJoin = sessions.maxByOrNull { it.second }?.second
+
+        val punishments = Punishment.getAllPunishmentsOfPlayer(user.id.value)
+
+        echo(
+            table {
+                body {
+                    row("Name", user.userName)
+                    row("UUID", user.uuid)
+                    row("Team", Team.byId(user.team).teamName)
+                    row("Leader", user.leader)
+                    row("Locale", user.locale)
+                    row("Beigetreten am", firstJoin)
+                    row("Zuletzt gesehen am", lastJoin)
+                    row("Spielzeit", totalPlayed.toString() + "h")
+                    row("Punishments", if (punishments.isEmpty()) "Keine" else table {
+                        header { row("Typ", "Ersteller", "Von", "Bis", "Grund") }
+                        body {
+                            punishments.map {
+                                row(
+                                    it.type,
+                                    SteamwarUser.byId(it.punisher)?.userName ?: it.punisher,
+                                    it.startTime.toString(),
+                                    if (it.perma) "Perma" else it.endTime.toString(),
+                                    it.reason
+                                )
+                            }
+                        }
+                    })
+                }
+            }
+        )
+
+    }
+}

CLI/src/commands/user/UserSearchCommand.kt

@@ -0,0 +1,42 @@
+package de.steamwar.commands.user
+
+import com.github.ajalt.clikt.core.CliktCommand
+import com.github.ajalt.clikt.core.Context
+import com.github.ajalt.clikt.parameters.arguments.argument
+import com.github.ajalt.clikt.parameters.arguments.help
+import com.github.ajalt.mordant.table.table
+import de.steamwar.db.joinedOr
+import de.steamwar.db.useDb
+import de.steamwar.sql.SteamwarUser
+import de.steamwar.sql.SteamwarUserTable
+import de.steamwar.sql.Team
+import org.jetbrains.exposed.v1.core.eq
+import org.jetbrains.exposed.v1.core.like
+
+class UserSearchCommand : CliktCommand("search") {
+    val query by argument().help("Name, Id, UUID or DiscordId")
+
+    override val printHelpOnEmptyArgs = true
+
+    override fun help(context: Context): String = "Search for users"
+
+    override fun run() = useDb {
+        val users = SteamwarUser.find {
+            joinedOr(
+                SteamwarUserTable.username like "%$query%",
+                SteamwarUserTable.uuid like "%$query%",
+                query.toLongOrNull()?.let { SteamwarUserTable.discordId eq it },
+                query.toIntOrNull()?.let { SteamwarUserTable.id eq it }
+            )
+        }
+
+        val teams = mutableMapOf<Int, Team>()
+
+        echo(table {
+            header { row("Id", "Username", "UUID", "Team", "DiscordId") }
+            body {
+                users.map { row(it.id.value, it.userName, it.uuid, teams.computeIfAbsent(it.team) { teamId -> Team.byId(teamId) }.teamName, it.discordId) }
+            }
+        })
+    }
+}

CLI/src/db/Database.kt

@@ -0,0 +1,84 @@
+package de.steamwar.db
+
+import com.github.ajalt.clikt.core.BaseCliktCommand
+import com.github.ajalt.clikt.core.CliktError
+import de.steamwar.sql.SteamwarUser
+import de.steamwar.sql.SteamwarUserTable
+import org.jetbrains.exposed.v1.core.Expression
+import org.jetbrains.exposed.v1.core.Op
+import org.jetbrains.exposed.v1.core.eq
+import org.jetbrains.exposed.v1.core.or
+import org.jetbrains.exposed.v1.jdbc.Database
+import org.jetbrains.exposed.v1.jdbc.JdbcTransaction
+import org.jetbrains.exposed.v1.jdbc.transactions.transaction
+import java.io.File
+import java.sql.ResultSet
+import java.util.Properties
+
+object Database {
+    lateinit var host: String
+    lateinit var port: String
+    lateinit var database: String
+    lateinit var db: Database
+
+    fun ensureConnected() {
+        if (::db.isInitialized) {
+            return
+        }
+        val config = File(System.getProperty("user.home"), "mysql.properties")
+
+        if (!config.exists()) {
+            throw CliktError("Config file not found!")
+        }
+
+        val props = Properties();
+
+        props.load(config.inputStream())
+
+        host = props.getProperty("host")
+        port = props.getProperty("port")
+        database = props.getProperty("database")
+
+        val username = props.getProperty("user")
+        val password = props.getProperty("password")
+
+        val url = "jdbc:mariadb://$host:$port/$database"
+
+        db = Database.connect(url, driver = "org.mariadb.jdbc.Driver", user = username, password = password)
+        return
+    }
+}
+
+fun <T: BaseCliktCommand<T>> BaseCliktCommand<T>.findUser(query: String): SteamwarUser? = transaction {
+    SteamwarUser.find { joinedOr(query.toIntOrNull()?.let { SteamwarUserTable.id eq it }, (SteamwarUserTable.username eq query), SteamwarUserTable.uuid eq query, query.toLongOrNull()?.let { SteamwarUserTable.discordId eq it }) }
+        .firstOrNull()
+        ?.let { return@transaction it }
+}
+
+fun joinedOr(vararg expressions: Expression<Boolean>?): Op<Boolean> =
+    expressions.filterNotNull().reduce { acc, expression -> acc or expression } as Op<Boolean>
+
+
+fun <T> JdbcTransaction.execute(sql: String, transform: (ResultSet) -> T): List<T> {
+    val result = mutableListOf<T>()
+    exec(sql) { rs ->
+        while (rs.next()) {
+            result += transform(rs)
+        }
+    }
+    return result
+}
+
+fun <T> JdbcTransaction.executeSingle(sql: String, transform: (ResultSet) -> T): T? {
+    return execute(sql) { rs ->
+        if (!rs.next()) {
+            return@execute null
+        }
+        transform(rs)
+    }.single()
+}
+
+fun useDb(statement: JdbcTransaction.() -> Unit) {
+    de.steamwar.db.Database.ensureConnected()
+    transaction(de.steamwar.db.Database.db, statement)
+}

CLI/src/logback.xml

@@ -0,0 +1,11 @@
+<configuration>
+    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
+        <encoder>
+            <pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n</pattern>
+        </encoder>
+    </appender>
+
+    <root level="WARN">
+        <appender-ref ref="STDOUT" />
+    </root>
+</configuration>

CommonCore/SQL/src/de/steamwar/ImplementationProvider.java

@@ -1,7 +1,7 @@
 /*
  *   This file is a part of the SteamWar software.
  *
- *   Copyright (C) 2025 SteamWar.de-Serverteam
+ *   Copyright (C) 2026 SteamWar.de-Serverteam
  *
  *   This program is free software: you can redistribute it and/or modify
  *   it under the terms of the GNU Affero General Public License as published by

CommonCore/SQL/src/de/steamwar/sql/AuditLog.kt

@@ -1,7 +1,7 @@
 /*
  *   This file is a part of the SteamWar software.
  *
- *   Copyright (C) 2025 SteamWar.de-Serverteam
+ *   Copyright (C) 2026 SteamWar.de-Serverteam
  *
  *   This program is free software: you can redistribute it and/or modify
  *   it under the terms of the GNU Affero General Public License as published by
@@ -28,11 +28,11 @@ import org.jetbrains.exposed.v1.javatime.timestamp
 import java.time.Instant
 
 object AuditLogTable: IntIdTable("AuditLog", "AuditLogId") {
-    val time = timestamp("Time")
+    val time = timestamp("Time").index()
-    val server = varchar("ServerName", 255)
+    val server = varchar("ServerName", 255).index()
-    val serverOwner = reference("ServerOwner", SteamwarUserTable).nullable()
+    val serverOwner = reference("ServerOwner", SteamwarUserTable).nullable().index()
-    val actor = reference("Actor", SteamwarUserTable)
+    val actor = reference("Actor", SteamwarUserTable).index()
-    val action = enumerationByName("ActionType", 255, AuditLog.Type::class)
+    val action = enumerationByName("ActionType", 255, AuditLog.Type::class).index()
     val actionText = text("ActionText")
 }
 

CommonCore/SQL/src/de/steamwar/sql/BannedUserIPs.kt

@@ -1,7 +1,7 @@
 /*
  *   This file is a part of the SteamWar software.
  *
- *   Copyright (C) 2025 SteamWar.de-Serverteam
+ *   Copyright (C) 2026 SteamWar.de-Serverteam
  *
  *   This program is free software: you can redistribute it and/or modify
  *   it under the terms of the GNU Affero General Public License as published by
@@ -33,8 +33,8 @@ import java.sql.Timestamp
 import java.time.Instant
 
 object BannedUserIPsTable: CompositeIdTable("BannedUserIPs") {
-    val userId = reference("UserID", SteamwarUserTable)
+    val userId = reference("UserID", SteamwarUserTable).index()
-    val timestamp = timestamp("Timestamp")
+    val timestamp = timestamp("Timestamp").index()
     val ip = varchar("IP", 45).entityId()
 
     init {

CommonCore/SQL/src/de/steamwar/sql/BauweltMember.kt

@@ -32,8 +32,8 @@ import org.jetbrains.exposed.v1.jdbc.insertIgnore
 import java.util.*
 
 object BauweltMemberTable: CompositeIdTable("BauweltMember") {
-    val bauweltId = reference("BauweltID", SteamwarUserTable)
+    val bauweltId = reference("BauweltID", SteamwarUserTable).index()
-    val memberId = reference("MemberID", SteamwarUserTable)
+    val memberId = reference("MemberID", SteamwarUserTable).index()
     val build = bool("Build")
     val worldEdit = bool("WorldEdit")
     val world = bool("World")

CommonCore/SQL/src/de/steamwar/sql/CheckedSchematic.kt

@@ -20,6 +20,7 @@
 package de.steamwar.sql
 
 import de.steamwar.sql.internal.useDb
+import org.jetbrains.exposed.v1.core.ReferenceOption
 import org.jetbrains.exposed.v1.core.SortOrder
 import org.jetbrains.exposed.v1.core.and
 import org.jetbrains.exposed.v1.core.dao.id.CompositeID
@@ -34,19 +35,23 @@ import org.jetbrains.exposed.v1.jdbc.insertIgnore
 import java.sql.Timestamp
 
 object CheckedSchematicTable: CompositeIdTable("CheckedSchematic") {
-    val nodeId = optReference("NodeId", SchematicNodeTable)
+    val nodeId = optReference("NodeId", SchematicNodeTable, onDelete = ReferenceOption.SET_NULL, onUpdate = ReferenceOption.SET_NULL).index()
-    val nodeOwner = reference("NodeOwner", SteamwarUserTable)
+    val nodeOwner = reference("NodeOwner", SteamwarUserTable).index()
-    val nodeName = varchar("NodeName", 64).entityId()
+    val nodeName = varchar("NodeName", 64).entityId().index()
-    val validator = reference("Validator", SteamwarUserTable)
+    val validator = reference("Validator", SteamwarUserTable).index()
-    val startTime = timestamp("StartTime").entityId()
+    val startTime = timestamp("StartTime").entityId().index()
     val endTime = timestamp("EndTime")
     val declineReason = text("DeclineReason")
-    val seen = bool("Seen")
+    val seen = bool("Seen").index()
     val nodeType = varchar("NodeType", 16)
 
     init {
         addIdColumn(nodeOwner)
         addIdColumn(nodeName)
+
+        index(false, nodeOwner, endTime)
+        index(false, startTime, endTime, nodeName)
+        index(false, seen, nodeOwner, startTime)
     }
 }
 

CommonCore/SQL/src/de/steamwar/sql/Event.kt

@@ -36,8 +36,8 @@ import java.time.Instant
 object EventTable : IntIdTable("Event", "EventId") {
     val name = varchar("EventName", 100).uniqueIndex()
     val deadline = timestamp("Deadline")
-    val start = timestamp("Start")
+    val start = timestamp("Start").index()
-    val end = timestamp("End")
+    val end = timestamp("End").index()
     val maxPlayers = integer("MaximumTeamMembers")
     val schemType = varchar("SchemType", 16).nullable()
     val publicsOnly = bool("PublicSchemsOnly")

CommonCore/SQL/src/de/steamwar/sql/EventFight.kt

@@ -33,17 +33,17 @@ import java.time.Instant
 import java.util.*
 
 object EventFightTable : IntIdTable("EventFight", "FightID") {
-    val eventId = reference("EventID", EventTable)
+    val eventId = reference("EventID", EventTable).index()
-    val startTime = timestamp("StartTime")
+    val startTime = timestamp("StartTime").index()
     val gamemode = text("Spielmodus")
     val map = text("Map")
-    val groupId = optReference("GroupId", EventGroupTable)
+    val groupId = optReference("GroupId", EventGroupTable).index()
-    val teamBlue = reference("TeamBlue", TeamTable)
+    val teamBlue = reference("TeamBlue", TeamTable).index()
-    val teamRed = reference("TeamRed", TeamTable)
+    val teamRed = reference("TeamRed", TeamTable).index()
     val spectatePort = integer("SpectatePort").nullable()
     val bestOf = integer("BestOf")
     val ergebnis = integer("Ergebnis")
-    val fight = optReference("Fight", FightTable)
+    val fight = optReference("Fight", FightTable).index()
 }
 
 class EventFight(id: EntityID<Int>) : IntEntity(id), Comparable<EventFight> {

CommonCore/SQL/src/de/steamwar/sql/EventGroup.kt

@@ -34,6 +34,10 @@ object EventGroupTable : IntIdTable("EventGroup", "Id") {
     val pointsPerWin = integer("PointsPerWin").default(3)
     val pointsPerLoss = integer("PointsPerLoss").default(0)
     val pointsPerDraw = integer("PointsPerDraw").default(1)
+
+    init {
+        uniqueIndex(event, name)
+    }
 }
 
 class EventGroup(id: EntityID<Int>) : IntEntity(id) {
@@ -90,7 +94,7 @@ class EventGroup(id: EntityID<Int>) : IntEntity(id) {
         set(value) {
             groupPointsPerDraw = value
         }
-    val dependents by lazy { EventRelation.getGroupRelations(this).toList() }
+    val dependents by lazy { EventRelation.getGroupRelations(this) }
     val lastFight by lazy { Optional.ofNullable(fights.maxByOrNull { it.startTime }) }
 
     fun getId() = id.value

CommonCore/SQL/src/de/steamwar/sql/EventRelation.kt

@@ -29,7 +29,7 @@ import org.jetbrains.exposed.v1.dao.IntEntityClass
 import org.jetbrains.exposed.v1.jdbc.select
 
 object EventRelationTable : IntIdTable("EventRelation") {
-    val fightId = reference("FightId", EventFightTable)
+    val fightId = reference("FightId", EventFightTable).index()
     val fightTeam = enumeration("FightTeam", EventRelation.FightTeam::class)
     val fromType = enumeration("FromType", EventRelation.FromType::class)
     val fromId = integer("FromId")
@@ -51,11 +51,11 @@ class EventRelation(id: EntityID<Int>) : IntEntity(id) {
 
         @JvmStatic
         fun getFightRelations(fight: EventFight) =
-            useDb { find { (EventRelationTable.fromId eq fight.id.value) and (EventRelationTable.fromType eq FromType.FIGHT) } }
+            useDb { find { (EventRelationTable.fromId eq fight.id.value) and (EventRelationTable.fromType eq FromType.FIGHT) }.toList() }
 
         @JvmStatic
         fun getGroupRelations(group: EventGroup) =
-            useDb { find { (EventRelationTable.fromId eq group.id.value) and (EventRelationTable.fromType eq FromType.GROUP) } }
+            useDb { find { (EventRelationTable.fromId eq group.id.value) and (EventRelationTable.fromType eq FromType.GROUP) }.toList() }
 
         @JvmStatic
         fun create(fight: EventFight, fightTeam: FightTeam, fromType: FromType, fromId: Int, fromPlace: Int) = useDb {

CommonCore/SQL/src/de/steamwar/sql/Fight.kt

@@ -34,14 +34,14 @@ import org.jetbrains.exposed.v1.jdbc.update
 import java.sql.Timestamp
 
 object FightTable : IntIdTable("Fight", "FightId") {
-    val gamemode = varchar("Gamemode", 30)
+    val gamemode = varchar("Gamemode", 30).index()
     val server = text("Server")
     val startTime = timestamp("StartTime")
     val duration = integer("Duration")
-    val blueLeader = reference("BlueLeader", SteamwarUserTable)
+    val blueLeader = reference("BlueLeader", SteamwarUserTable).index()
-    val redLeader = reference("RedLeader", SteamwarUserTable)
+    val redLeader = reference("RedLeader", SteamwarUserTable).index()
-    val blueSchem = optReference("BlueSchem", SchematicNodeTable, onDelete = ReferenceOption.SET_NULL)
+    val blueSchem = optReference("BlueSchem", SchematicNodeTable, onDelete = ReferenceOption.SET_NULL).index()
-    val redSchem = optReference("RedSchem", SchematicNodeTable, onDelete = ReferenceOption.SET_NULL)
+    val redSchem = optReference("RedSchem", SchematicNodeTable, onDelete = ReferenceOption.SET_NULL).index()
     val win = enumeration("Win", Fight.WinningTeam::class)
     val winCondition = varchar("WinCondition", 100)
     val replayAvailable = bool("ReplayAvailable")

CommonCore/SQL/src/de/steamwar/sql/FightPlayer.kt

@@ -30,7 +30,7 @@ import org.jetbrains.exposed.v1.jdbc.insertIgnore
 
 object FightPlayerTable : CompositeIdTable("FightPlayer") {
     val fightId = reference("FightId", FightTable)
-    val userId = reference("UserId", SteamwarUserTable)
+    val userId = reference("UserId", SteamwarUserTable).index()
     val team = integer("Team")
     val kit = varchar("Kit", 64)
     val kills = integer("Kills")

CommonCore/SQL/src/de/steamwar/sql/GameModeConfig.java

@@ -1,7 +1,7 @@
 /*
  *   This file is a part of the SteamWar software.
  *
- *   Copyright (C) 2025 SteamWar.de-Serverteam
+ *   Copyright (C) 2026 SteamWar.de-Serverteam
  *
  *   This program is free software: you can redistribute it and/or modify
  *   it under the terms of the GNU Affero General Public License as published by

CommonCore/SQL/src/de/steamwar/sql/IgnoreSystem.kt

@@ -30,8 +30,8 @@ import org.jetbrains.exposed.v1.dao.CompositeEntityClass
 import java.util.*
 
 object IgnoreSystemTable: CompositeIdTable("IgnoredPlayers") {
-    val ignorer = reference("Ignorer", SteamwarUserTable)
+    val ignorer = reference("Ignorer", SteamwarUserTable).index()
-    val ignored = reference("Ignored", SteamwarUserTable)
+    val ignored = reference("Ignored", SteamwarUserTable).index()
 
     override val primaryKey = PrimaryKey(ignorer, ignored)
 

CommonCore/SQL/src/de/steamwar/sql/NodeData.kt

@@ -35,7 +35,7 @@ import java.io.InputStream
 import java.util.zip.GZIPInputStream
 
 object NodeDataTable: CompositeIdTable("NodeData") {
-    val nodeId = reference("NodeId", SchematicNodeTable)
+    val nodeId = reference("NodeId", SchematicNodeTable).index()
     val createdAt = timestamp("CreatedAt").defaultExpression(CurrentTimestamp).entityId()
     val nodeFormat = enumeration("NodeFormat", NodeData.SchematicFormat::class)
     val schemData = blob("SchemData")

CommonCore/SQL/src/de/steamwar/sql/NodeDownload.kt

@@ -20,6 +20,7 @@
 package de.steamwar.sql
 
 import de.steamwar.sql.internal.useDb
+import org.jetbrains.exposed.v1.core.ReferenceOption
 import org.jetbrains.exposed.v1.core.dao.id.EntityID
 import org.jetbrains.exposed.v1.core.dao.id.IdTable
 import org.jetbrains.exposed.v1.core.eq
@@ -32,8 +33,8 @@ import java.sql.Timestamp
 import java.time.Instant
 
 object NodeDownloadTable: IdTable<Int>("NodeDownload") {
-    override val id = reference("NodeId", SchematicNodeTable).uniqueIndex()
+    override val id = reference("NodeId", SchematicNodeTable, onDelete = ReferenceOption.CASCADE).uniqueIndex()
-    val link = varchar("Link", 255)
+    val link = varchar("Link", 255).uniqueIndex()
     val timestamp = timestamp("Timestamp").defaultExpression(CurrentTimestamp)
 }
 

CommonCore/SQL/src/de/steamwar/sql/NodeMember.kt

@@ -20,6 +20,7 @@
 package de.steamwar.sql
 
 import de.steamwar.sql.internal.useDb
+import org.jetbrains.exposed.v1.core.ReferenceOption
 import org.jetbrains.exposed.v1.core.and
 import org.jetbrains.exposed.v1.core.dao.id.CompositeID
 import org.jetbrains.exposed.v1.core.dao.id.CompositeIdTable
@@ -32,9 +33,9 @@ import java.util.*
 import kotlin.jvm.optionals.getOrNull
 
 object NodeMemberTable : CompositeIdTable("NodeMember") {
-    val node = reference("NodeId", SchematicNodeTable)
+    val node = reference("NodeId", SchematicNodeTable, onDelete = ReferenceOption.CASCADE, onUpdate = ReferenceOption.CASCADE).index()
-    val userId = reference("UserId", SteamwarUserTable)
+    val userId = reference("UserId", SteamwarUserTable).index()
-    val parentNode = optReference("ParentId", SchematicNodeTable)
+    val parentNode = optReference("ParentId", SchematicNodeTable).index()
 
     override val primaryKey = PrimaryKey(node, userId)
 

CommonCore/SQL/src/de/steamwar/sql/PersonalKit.kt

@@ -41,6 +41,7 @@ object PersonalKitTable: CompositeIdTable("PersonalKit") {
 
     init {
         addIdColumn(userId)
+        index(false, userId, gamemode)
     }
 }
 

CommonCore/SQL/src/de/steamwar/sql/Punishment.kt

@@ -34,12 +34,16 @@ import java.util.function.Consumer
 
 object PunishmentTable : IntIdTable("Punishments", "PunishmentId") {
     val userId = reference("UserId", SteamwarUserTable)
-    val punisher = reference("Punisher", SteamwarUserTable)
+    val punisher = reference("Punisher", SteamwarUserTable).index()
     val type = enumerationByName("Type", 32, Punishment.PunishmentType::class)
     val startTime = timestamp("StartTime")
     val endTime = timestamp("EndTime")
     val perma = bool("Perma")
     val reason = text("Reason")
+
+    init {
+        index(false, userId, type)
+    }
 }
 
 class Punishment(id: EntityID<Int>) : IntEntity(id) {

CommonCore/SQL/src/de/steamwar/sql/Referee.kt

@@ -30,7 +30,7 @@ import org.jetbrains.exposed.v1.dao.CompositeEntityClass
 
 object RefereeTable: CompositeIdTable("Referee") {
     val eventId = reference("EventId", EventTable)
-    val userId = reference("UserId", SteamwarUserTable)
+    val userId = reference("UserId", SteamwarUserTable).index()
 
     override val primaryKey = PrimaryKey(eventId, userId)
 

CommonCore/SQL/src/de/steamwar/sql/SchematicNode.kt

@@ -34,13 +34,17 @@ import java.util.*
 import java.util.function.Consumer
 
 object SchematicNodeTable : IntIdTable("SchematicNode", "NodeId") {
-    val owner = reference("NodeOwner", SteamwarUserTable)
+    val owner = reference("NodeOwner", SteamwarUserTable).index()
     val name = varchar("NodeName", 64)
-    val parent = optReference("ParentNode", SchematicNodeTable)
+    val parent = optReference("ParentNode", SchematicNodeTable).index()
     val lastUpdate = timestamp("LastUpdate").defaultExpression(CurrentTimestamp)
     val item = text("NodeItem")
-    val type = varchar("NodeType", 16).nullable()
+    val type = varchar("NodeType", 16).nullable().index()
     val config = integer("Config")
+
+    init {
+        uniqueIndex(parent, owner, name)
+    }
 }
 
 class SchematicNode(id: EntityID<Int>) : IntEntity(id) {

CommonCore/SQL/src/de/steamwar/sql/Script.kt

@@ -28,9 +28,13 @@ import org.jetbrains.exposed.v1.dao.IntEntity
 import org.jetbrains.exposed.v1.dao.IntEntityClass
 
 object ScriptTable: IntIdTable("Script") {
-    val userId = reference("UserId", SteamwarUserTable)
+    val userId = reference("UserId", SteamwarUserTable).index()
     val name = varchar("Name", 64)
     val code = text("Code")
+
+    init {
+        uniqueIndex(userId, name)
+    }
 }
 
 class Script(id: EntityID<Int>) : IntEntity(id) {

CommonCore/SQL/src/de/steamwar/sql/Session.kt

@@ -28,7 +28,7 @@ import org.jetbrains.exposed.v1.jdbc.insert
 import java.sql.Timestamp
 
 object SessionTable: Table("Session") {
-    val userId = reference("UserId", SteamwarUserTable)
+    val userId = reference("UserId", SteamwarUserTable).index()
     val startTime = timestamp("StartTime")
     val endTime = timestamp("EndTime").defaultExpression(CurrentTimestamp)
 }

CommonCore/SQL/src/de/steamwar/sql/SteamwarUser.kt

@@ -37,15 +37,15 @@ import javax.crypto.SecretKeyFactory
 import javax.crypto.spec.PBEKeySpec
 
 object SteamwarUserTable : IntIdTable("UserData", "id") {
-    val uuid = varchar("UUID", 36)
+    val uuid = varchar("UUID", 36).uniqueIndex()
-    val username = varchar("UserName", 32)
+    val username = varchar("UserName", 32).index()
-    val team = reference("Team", TeamTable)
+    val team = reference("Team", TeamTable).index()
     val leader = bool("Leader")
     val locale = varchar("Locale", 16).nullable()
     val manualLocale = bool("ManualLocale")
     val bedrock = bool("Bedrock")
     val password = text("Password").nullable()
-    val discordId = long("DiscordId").nullable()
+    val discordId = long("DiscordId").nullable().uniqueIndex()
 }
 
 class SteamwarUser(id: EntityID<Int>): IntEntity(id) {

CommonCore/SQL/src/de/steamwar/sql/Team.kt

@@ -28,9 +28,9 @@ import org.jetbrains.exposed.v1.dao.IntEntityClass
 import org.jetbrains.exposed.v1.jdbc.select
 
 object TeamTable : IntIdTable("Team", "TeamID") {
-    val kuerzel = varchar("TeamKuerzel", 10)
+    val kuerzel = varchar("TeamKuerzel", 10).index()
     val color = char("TeamColor", 1).default("8")
-    val name = varchar("TeamName", 16)
+    val name = varchar("TeamName", 16).index()
     val deleted = bool("TeamDeleted").default(false)
 }
 

CommonCore/SQL/src/de/steamwar/sql/TeamTeilnahme.kt

@@ -32,8 +32,8 @@ import org.jetbrains.exposed.v1.jdbc.deleteWhere
 import org.jetbrains.exposed.v1.jdbc.insertIgnore
 
 object TeamTeilnahmeTable : CompositeIdTable("TeamTeilnahme") {
-    val teamId = reference("teamId", TeamTable)
+    val teamId = reference("teamId", TeamTable).index()
-    val eventId = reference("eventId", EventTable)
+    val eventId = reference("eventId", EventTable).index()
     val placement = integer("Placement").nullable()
 
     override val primaryKey = PrimaryKey(teamId, eventId)

CommonCore/SQL/src/de/steamwar/sql/Token.kt

@@ -33,10 +33,10 @@ import java.sql.Timestamp
 import java.util.*
 
 object TokenTable: IntIdTable("Token") {
-    val name = varchar("Name", 64)
+    val name = varchar("Name", 64).uniqueIndex()
-    val owner = reference("Owner", SteamwarUserTable)
+    val owner = reference("Owner", SteamwarUserTable).index()
     val created = timestamp("Created").defaultExpression(CurrentTimestamp)
-    val hash = varchar("Hash", 88)
+    val hash = varchar("Hash", 88).uniqueIndex()
 }
 
 class Token(id: EntityID<Int>): IntEntity(id) {

CommonCore/SQL/src/de/steamwar/sql/UserPerm.kt

@@ -28,7 +28,7 @@ import org.jetbrains.exposed.v1.jdbc.insert
 import org.jetbrains.exposed.v1.jdbc.selectAll
 
 object UserPermTable: Table("UserPerm") {
-    val user = reference("User", SteamwarUserTable.id)
+    val user = reference("User", SteamwarUserTable.id).index()
     val perm = enumerationByName("Perm", 32, UserPerm::class)
 
     override val primaryKey = PrimaryKey(user, perm)

CommonCore/SQL/src/de/steamwar/sql/internal/KotlinDatabase.kt

@@ -67,7 +67,7 @@ object KotlinDatabase {
     }
 }
 
-fun <T: Any?> useDb(statement: JdbcTransaction.() -> T): T {
+fun <T> useDb(statement: JdbcTransaction.() -> T): T {
     KotlinDatabase.ensureConnected()
     return TransactionManager.currentOrNull()?.statement() ?: transaction(KotlinDatabase.db) {
         statement()

FightSystem/FightSystem_21/src/de/steamwar/fightsystem/utils/FlatteningWrapper21.java

@@ -24,10 +24,6 @@ import org.bukkit.inventory.ItemStack;
 public class FlatteningWrapper21 extends FlatteningWrapper14 {
     @Override
     public boolean hasAttributeModifier(ItemStack stack) {
-        if (!stack.getDataTypes().isEmpty()) {
+        return stack.hasItemMeta() && stack.getItemMeta() != null && stack.getItemMeta().hasAttributeModifiers();
-            return true;
-        }
-
-        return super.hasAttributeModifier(stack);
     }
 }

FightSystem/FightSystem_21/src/de/steamwar/fightsystem/utils/ReflectionWrapper21.java

@@ -38,6 +38,27 @@ public class ReflectionWrapper21 implements ReflectionWrapper {
         FORBIDDEN_TYPES.add(DataComponentTypes.BLOCKS_ATTACKS);
         FORBIDDEN_TYPES.add(DataComponentTypes.BUNDLE_CONTENTS);
         FORBIDDEN_TYPES.add(DataComponentTypes.CUSTOM_MODEL_DATA);
+
+        FORBIDDEN_TYPES.add(DataComponentTypes.ATTRIBUTE_MODIFIERS);
+        FORBIDDEN_TYPES.add(DataComponentTypes.TOOL);
+        FORBIDDEN_TYPES.add(DataComponentTypes.WEAPON);
+        FORBIDDEN_TYPES.add(DataComponentTypes.FOOD);
+        FORBIDDEN_TYPES.add(DataComponentTypes.CONSUMABLE);
+        FORBIDDEN_TYPES.add(DataComponentTypes.POTION_CONTENTS);
+        FORBIDDEN_TYPES.add(DataComponentTypes.STORED_ENCHANTMENTS);
+        FORBIDDEN_TYPES.add(DataComponentTypes.CAN_BREAK);
+        FORBIDDEN_TYPES.add(DataComponentTypes.CAN_PLACE_ON);
+        FORBIDDEN_TYPES.add(DataComponentTypes.MAX_DAMAGE);
+        FORBIDDEN_TYPES.add(DataComponentTypes.USE_REMAINDER);
+        FORBIDDEN_TYPES.add(DataComponentTypes.USE_COOLDOWN);
+        FORBIDDEN_TYPES.add(DataComponentTypes.SUSPICIOUS_STEW_EFFECTS);
+        FORBIDDEN_TYPES.add(DataComponentTypes.CHARGED_PROJECTILES);
+        FORBIDDEN_TYPES.add(DataComponentTypes.INTANGIBLE_PROJECTILE);
+        FORBIDDEN_TYPES.add(DataComponentTypes.FIREWORKS);
+        FORBIDDEN_TYPES.add(DataComponentTypes.FIREWORK_EXPLOSION);
+        FORBIDDEN_TYPES.add(DataComponentTypes.EQUIPPABLE);
+        FORBIDDEN_TYPES.add(DataComponentTypes.REPAIR_COST);
+        FORBIDDEN_TYPES.add(DataComponentTypes.ENCHANTABLE);
     }
 
     @Override

FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/FightSystem.java

@@ -98,10 +98,12 @@ public class FightSystem extends JavaPlugin {
         new StateDependentListener(ArenaMode.All, FightState.All, BountifulWrapper.impl.newDenyArrowPickupListener());
         new OneShotStateDependent(ArenaMode.All, FightState.PreSchemSetup, () -> Fight.playSound(SWSound.BLOCK_NOTE_PLING.getSound(), 100.0f, 2.0f));
         new OneShotStateDependent(ArenaMode.Test, FightState.All, WorldEditRendererCUIEditor::new);
-        try {
+        if (Core.getVersion() >= 19) {
-            Bukkit.getWorlds().get(0).setGameRule(GameRule.REDUCED_DEBUG_INFO, ArenaMode.AntiTest.contains(Config.mode));
+            try {
-        } catch (Exception e) {
+                Bukkit.getWorlds().get(0).setGameRule(GameRule.REDUCED_DEBUG_INFO, ArenaMode.AntiTest.contains(Config.mode));
-            // Ignore if failed!
+            } catch (Exception e) {
+                // Ignore if failed!
+            }
         }
 
         techHider = new TechHiderWrapper();

FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/listener/Permanent.java

@@ -181,7 +181,12 @@ public class Permanent implements Listener {
 
     @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
     public void onExplosion(EntityExplodeEvent e) {
-        if (!(e.getEntity() instanceof TNTPrimed)) return;
+        if (!(e.getEntity() instanceof TNTPrimed)) {
+            if (Config.GameModeConfig.Schematic.Type.toDB().equals("wargearseason26")) {
+                e.blockList().clear();
+            }
+            return;
+        }
         if (!Config.GameModeConfig.Arena.WaterDamage) return;
         e.blockList().removeIf(block -> {
             if(block.getType() == Material.TNT) {

FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/listener/PersonalKitCreator.java

@@ -35,10 +35,7 @@ import org.bukkit.entity.HumanEntity;
 import org.bukkit.entity.Player;
 import org.bukkit.event.EventHandler;
 import org.bukkit.event.Listener;
-import org.bukkit.event.inventory.InventoryAction;
+import org.bukkit.event.inventory.*;
-import org.bukkit.event.inventory.InventoryClickEvent;
-import org.bukkit.event.inventory.InventoryCloseEvent;
-import org.bukkit.event.inventory.InventoryOpenEvent;
 import org.bukkit.event.player.PlayerMoveEvent;
 import org.bukkit.event.player.PlayerQuitEvent;
 import org.bukkit.inventory.ItemStack;
@@ -81,25 +78,8 @@ public class PersonalKitCreator implements Listener {
         if(!openKitCreators.containsKey(e.getWhoClicked()))
             return;
 
-        Player player = (Player) e.getWhoClicked();
-        //Deny bad items
         if(Kit.isBadItem(e.getCursor()))
             e.setCancelled(true);
-
-        /* Should the inventory reset? */
-        if(e.getAction() != InventoryAction.PLACE_ALL)
-            return;
-
-        ItemStack[] items = e.getWhoClicked().getInventory().getContents();
-        for(int i = 0; i < items.length; i++){
-            ItemStack stack = items[i];
-            if(stack != null && i != e.getSlot())
-                return;
-        }
-
-        FightPlayer fightPlayer = Fight.getFightPlayer(player);
-        assert fightPlayer != null;
-        Bukkit.getScheduler().runTaskLater(FightSystem.getPlugin(), () -> fightPlayer.getKit().loadToPlayer(player), 1);
     }
 
     @EventHandler
@@ -117,7 +97,10 @@ public class PersonalKitCreator implements Listener {
         if(backup == null)
             return;
 
-        backup.close();
+        InventoryType type = e.getInventory().getType();
+        if(type != InventoryType.PLAYER && type != InventoryType.CREATIVE) {
+            backup.close();
+        }
     }
 
     @EventHandler
@@ -126,7 +109,7 @@ public class PersonalKitCreator implements Listener {
         if(backup == null)
             return;
 
-        backup.close();
+        Bukkit.getScheduler().runTaskLater(FightSystem.getPlugin(), backup::close, 1);
     }
 
     @EventHandler
@@ -151,9 +134,11 @@ public class PersonalKitCreator implements Listener {
         }
 
         private void close(){
-            openKitCreators.remove(player);
             Kit kit1 = new Kit(kit.getName(), player);
             kit1.removeBadItems();
+
+
+            openKitCreators.remove(player);
             kit1.toPersonalKit(kit);
             backup.loadToPlayer(player);
             player.setGameMode(GameMode.SURVIVAL);

SchematicSystem/SchematicSystem_21/build.gradle.kts

@@ -0,0 +1,37 @@
+/*
+ *   This file is a part of the SteamWar software.
+ *
+ *   Copyright (C) 2025 SteamWar.de-Serverteam
+ *
+ *   This program 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.
+ *
+ *   This program 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 this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+plugins {
+    steamwar.java
+}
+
+dependencies {
+    compileOnly(project(":SpigotCore", "default"))
+    compileOnly(project(":SchematicSystem:SchematicSystem_Core", "default"))
+
+    compileOnly(libs.paperapi21) {
+        attributes {
+            // Very Hacky, but it works
+            attribute(TargetJvmVersion.TARGET_JVM_VERSION_ATTRIBUTE, 21)
+        }
+    }
+
+    compileOnly(libs.nms21)
+    compileOnly(libs.fawe21)
+}

SchematicSystem/SchematicSystem_21/src/de/steamwar/schematicsystem/autocheck/AutoChecker21.java

@@ -0,0 +1,137 @@
+/*
+ *   This file is a part of the SteamWar software.
+ *
+ *   Copyright (C) 2026 SteamWar.de-Serverteam
+ *
+ *   This program 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.
+ *
+ *   This program 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 this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.schematicsystem.autocheck;
+
+import com.sk89q.jnbt.CompoundTag;
+import com.sk89q.worldedit.entity.Entity;
+import com.sk89q.worldedit.extent.clipboard.Clipboard;
+import com.sk89q.worldedit.math.BlockVector3;
+import com.sk89q.worldedit.world.block.BaseBlock;
+import de.steamwar.core.Core;
+import de.steamwar.sql.GameModeConfig;
+import org.bukkit.Material;
+
+import java.util.*;
+import java.util.stream.Collectors;
+
+public class AutoChecker21 implements AutoChecker.IAutoChecker {
+
+    public AutoChecker.BlockScanResult scan(Clipboard clipboard, GameModeConfig<Material, String> type) {
+        AutoChecker.BlockScanResult result = new AutoChecker.BlockScanResult();
+        BlockVector3 min = clipboard.getMinimumPoint();
+        BlockVector3 max = clipboard.getMaximumPoint();
+        for (int x = min.getBlockX(); x <= max.getBlockX(); x++) {
+            for (int y = min.getBlockY(); y <= max.getBlockY(); y++) {
+                for (int z = min.getBlockZ(); z <= max.getBlockZ(); z++) {
+                    final BaseBlock block = clipboard.getFullBlock(BlockVector3.at(x, y, z));
+                    final Material material = Material.matchMaterial(block.getBlockType().getId());
+                    if (material == null) {
+                        continue;
+                    }
+
+                    result.getBlockCounts().merge(material, 1, Integer::sum);
+
+                    if (AutoCheckerItems.impl.getInventoryMaterials().contains(material)) {
+                        checkInventory(result, block, material, new BlockPos(x, y, z), type);
+                    }
+
+                    if (x == min.getBlockX() || x == max.getBlockX() || y == max.getBlockY() || z == min.getBlockZ() || z == max.getBlockZ()) {
+                        result.getDesignBlocks().computeIfAbsent(material, m -> new ArrayList<>()).add(new BlockPos(x, y, z));
+                    }
+                }
+            }
+        }
+        return result;
+    }
+
+    private static final Map<Material, Set<Material>> itemsInInv = new EnumMap<>(Material.class);
+
+    static {
+        itemsInInv.put(Material.BUCKET, EnumSet.of(Material.DISPENSER));
+        itemsInInv.put(Material.TNT, EnumSet.of(Material.CHEST, Material.BARREL, Material.SHULKER_BOX, Material.BLACK_SHULKER_BOX, Material.BLUE_SHULKER_BOX,
+                Material.BROWN_SHULKER_BOX, Material.CYAN_SHULKER_BOX, Material.GRAY_SHULKER_BOX, Material.GREEN_SHULKER_BOX, Material.LIGHT_BLUE_SHULKER_BOX,
+                Material.LIGHT_GRAY_SHULKER_BOX, Material.LIME_SHULKER_BOX, Material.MAGENTA_SHULKER_BOX, Material.ORANGE_SHULKER_BOX,
+                Material.PINK_SHULKER_BOX, Material.PURPLE_SHULKER_BOX, Material.RED_SHULKER_BOX, Material.WHITE_SHULKER_BOX, Material.YELLOW_SHULKER_BOX));
+        itemsInInv.put(Material.FIRE_CHARGE, EnumSet.of(Material.DISPENSER));
+        itemsInInv.put(Material.ARROW, EnumSet.of(Material.DISPENSER));
+        AutoCheckerItems.impl.getAllowedMaterialsInInventory().forEach(material -> itemsInInv.put(material, AutoCheckerItems.impl.getInventoryMaterials()));
+    }
+
+    private void checkInventory(AutoChecker.BlockScanResult result, BaseBlock block, Material material, BlockPos pos, GameModeConfig<Material, String> type) {
+        CompoundTag nbt = block.getNbtData();
+        if (nbt == null) {
+            result.getDefunctNbt().add(pos);
+            return;
+        }
+
+
+        if (material == Material.JUKEBOX && nbt.getValue().containsKey("RecordItem")) {
+            result.getRecords().add(pos);
+            return;
+        }
+
+        List<CompoundTag> items = nbt.getList("Items", CompoundTag.class);
+        if (items.isEmpty())
+            return; // Leeres Inventar
+
+        int counter = 0;
+        int windChargeCount = 0;
+        for (CompoundTag item : items) {
+            if (!item.containsKey("id")) {
+                result.getDefunctNbt().add(pos);
+                continue;
+            }
+
+            Material itemType = Material.matchMaterial(item.getString("id"));
+            if (itemType == null) // Leere Slots
+                continue;
+
+            if(type.Schematic.Type.getName().equals("wargearseason26") && material == Material.DISPENSER && itemType == Material.WIND_CHARGE) {
+                windChargeCount += item.getInt("count");
+            }
+            else if (!itemsInInv.getOrDefault(itemType, EnumSet.noneOf(Material.class)).contains(material)) {
+                result.getForbiddenItems().computeIfAbsent(pos, blockVector3 -> new HashSet<>()).add(itemType);
+            } else if (material == Material.DISPENSER && (itemType == Material.ARROW || itemType == Material.FIRE_CHARGE)) {
+                counter += Core.getVersion() >= 21 ? item.getInt("count") : item.getByte("Count");
+            }
+            if (item.containsKey("tag")) {
+                result.getForbiddenNbt().computeIfAbsent(pos, blockVector3 -> new HashSet<>()).add(itemType);
+            }
+        }
+        result.getDispenserItems().put(pos, counter);
+        result.getWindChargeCount().put(pos, windChargeCount);
+    }
+
+    @Override
+    public AutoCheckerResult check(Clipboard clipboard, GameModeConfig<Material, String> type) {
+        return AutoCheckerResult.builder().type(type).height(clipboard.getDimensions().getBlockY()).width(clipboard.getDimensions().getBlockX())
+                .depth(clipboard.getDimensions().getBlockZ()).blockScanResult(scan(clipboard, type))
+                .entities(clipboard.getEntities().stream().map(Entity::getLocation)
+                        .map(blockVector3 -> new BlockPos(blockVector3.getBlockX(), blockVector3.getBlockY(), blockVector3.getBlockZ()))
+                        .collect(Collectors.toList()))
+                .build();
+    }
+
+    @Override
+    public AutoCheckerResult sizeCheck(Clipboard clipboard, GameModeConfig<Material, String> type) {
+        return AutoCheckerResult.builder().type(type).height(clipboard.getDimensions().getBlockY()).width(clipboard.getDimensions().getBlockX())
+                .depth(clipboard.getDimensions().getBlockZ()).build();
+    }
+}

SchematicSystem/SchematicSystem_21/src/de/steamwar/schematicsystem/autocheck/AutoCheckerItems21.java

@@ -0,0 +1,49 @@
+/*
+ * This file is a part of the SteamWar software.
+ *
+ * Copyright (C) 2025 SteamWar.de-Serverteam
+ *
+ * This program 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.
+ *
+ * This program 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 this program.
+ * If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.schematicsystem.autocheck;
+
+import org.bukkit.Material;
+
+import java.util.EnumSet;
+import java.util.Set;
+
+public class AutoCheckerItems21 implements AutoCheckerItems {
+
+    private static final Set<Material> INVENTORY = EnumSet.of(Material.BARREL, Material.BLAST_FURNACE, Material.BREWING_STAND, Material.CAMPFIRE,
+            Material.CHEST, Material.DISPENSER, Material.DROPPER, Material.FURNACE, Material.HOPPER, Material.JUKEBOX, Material.SHULKER_BOX,
+            Material.WHITE_SHULKER_BOX, Material.ORANGE_SHULKER_BOX, Material.MAGENTA_SHULKER_BOX, Material.LIGHT_BLUE_SHULKER_BOX, Material.YELLOW_SHULKER_BOX,
+            Material.LIME_SHULKER_BOX, Material.PINK_SHULKER_BOX, Material.GRAY_SHULKER_BOX, Material.LIGHT_GRAY_SHULKER_BOX, Material.CYAN_SHULKER_BOX,
+            Material.PURPLE_SHULKER_BOX, Material.BLUE_SHULKER_BOX, Material.BROWN_SHULKER_BOX, Material.GREEN_SHULKER_BOX, Material.RED_SHULKER_BOX,
+            Material.BLACK_SHULKER_BOX, Material.SMOKER, Material.TRAPPED_CHEST);
+
+    private static final Set<Material> FLOWERS = EnumSet.of(Material.CORNFLOWER, Material.POPPY, Material.FERN, Material.DANDELION, Material.BLUE_ORCHID,
+            Material.ALLIUM, Material.AZURE_BLUET, Material.RED_TULIP, Material.ORANGE_TULIP, Material.WHITE_TULIP, Material.PINK_TULIP, Material.OXEYE_DAISY,
+            Material.LILY_OF_THE_VALLEY, Material.WITHER_ROSE, Material.SUNFLOWER, Material.DIAMOND_HORSE_ARMOR, Material.IRON_HORSE_ARMOR,
+            Material.GOLDEN_HORSE_ARMOR, Material.LEATHER_HORSE_ARMOR, Material.HONEY_BOTTLE, Material.LILAC, Material.ROSE_BUSH, Material.PEONY,
+            Material.TALL_GRASS, Material.LARGE_FERN);
+
+    @Override
+    public Set<Material> getInventoryMaterials() {
+        return INVENTORY;
+    }
+
+    @Override
+    public Set<Material> getAllowedMaterialsInInventory() {
+        return FLOWERS;
+    }
+}

SchematicSystem/SchematicSystem_Core/src/SchematicSystem.properties

@@ -262,6 +262,8 @@ AUTO_CHECKER_RESULT_BLOCKS=§7Blocks: §c{0}§7, Max: §e{1}
 AUTO_CHECKER_RESULT_UNKNOWN_MATERIAL=§7Unknown block: §c{0}
 AUTO_CHECKER_RESULT_TOO_MANY_BLOCK=§7{0}: §c{1}§7, Max: §e{2}
 AUTO_CHECKER_RESULT_FORBIDDEN_BLOCK=§7Forbidden block: §c{0}
+AUTO_CHECKER_RESULT_WIND_CHARGES=§7Windcharges: §c{0}§7, Max: §e2048
+AUTO_CHECKER_RESULT_WIND_CHARGES_DISPENSER=§7Dispenser: §c[{0}, {1}, {2}]§7, Windcharges: §c{3}§7
 AUTO_CHECKER_RESULT_FORBIDDEN_ITEM=§7Forbidden Item: [{0}, {1}, {2}] -> §c{3}
 AUTO_CHECKER_RESULT_DEFUNCT_NBT=§7Defunct NBT: §7[{0}, {1}, {2}]
 AUTO_CHECKER_RESULT_DESIGN_BLOCK=§7{0} in Design: [{1}, {2}, {3}]

SchematicSystem/SchematicSystem_Core/src/SchematicSystem_de.properties

@@ -242,6 +242,8 @@ AUTO_CHECKER_RESULT_BLOCKS=§7Blöcke: §c{0}§7, Max: §e{1}
 AUTO_CHECKER_RESULT_UNKNOWN_MATERIAL=§7Unbekannter Block: §c{0}
 AUTO_CHECKER_RESULT_TOO_MANY_BLOCK=§7{0}: §c{1}§7, Max: §e{2}
 AUTO_CHECKER_RESULT_FORBIDDEN_BLOCK=§7Verbotener Block: §c{0}
+AUTO_CHECKER_RESULT_WIND_CHARGES=§7Windcharges: §c{0}§7, Max: §e2048
+AUTO_CHECKER_RESULT_WIND_CHARGES_DISPENSER=§7Werfer: §c[{0}, {1}, {2}]§7, Windcharges: §c{3}§7
 AUTO_CHECKER_RESULT_FORBIDDEN_ITEM=§7Verbotener gegenstand: [{0}, {1}, {2}] -> §c{3}
 AUTO_CHECKER_RESULT_DEFUNCT_NBT=§7Keine NBT-Daten: §c[{0}, {1}, {2}]
 AUTO_CHECKER_RESULT_DESIGN_BLOCK=§7{0} im Design: [{1}, {2}, {3}]

SchematicSystem/SchematicSystem_Core/src/de/steamwar/schematicsystem/autocheck/AutoChecker.java

@@ -55,6 +55,7 @@ public class AutoChecker {
         private final List<BlockPos> records = new ArrayList<>();
         private final Map<Material, List<BlockPos>> designBlocks = new EnumMap<>(Material.class);
         private final Map<BlockPos, Integer> dispenserItems = new HashMap<>();
+        private final Map<BlockPos, Integer> windChargeCount = new HashMap<>();
         private final Map<BlockPos, Set<Material>> forbiddenItems = new HashMap<>();
         private final Map<BlockPos, Set<Material>> forbiddenNbt = new HashMap<>();
     }

SchematicSystem/SchematicSystem_Core/src/de/steamwar/schematicsystem/autocheck/AutoCheckerResult.java

@@ -52,6 +52,7 @@ public class AutoCheckerResult {
                 isBlockCountOk() &&
                 isLimitedBlocksOK() &&
                 isDispenserItemsOK() &&
+                isWindchargeCountOK() &&
                 !type.isAfterDeadline() &&
                 entities.isEmpty() &&
                 isDesignBlastResistanceOK();
@@ -62,8 +63,18 @@ public class AutoCheckerResult {
                 !type.isAfterDeadline();
     }
 
+    public boolean isWindchargeCountOK() {
+        if( type.Schematic.Type.getName().equals("wargearseason26")) {
+            int windChargesCount = blockScanResult.getWindChargeCount().values().stream().reduce(Integer::sum).orElse(0);
+            return windChargesCount <= 2048;  
+        }
+        else {
+            return true;
+        }
+    }
+
     public boolean isDispenserItemsOK() {
-        return blockScanResult.getDispenserItems().values().stream().allMatch(i -> i <= type.Schematic.MaxDispenserItems);
+        return blockScanResult.getDispenserItems().values().stream().allMatch(i -> i <= type.Schematic.MaxDispenserItems);  
     }
 
     public boolean hasWarnings() {
@@ -127,6 +138,19 @@ public class AutoCheckerResult {
                 }
             });
         }
+
+        if(!isWindchargeCountOK()) {
+            int windChargesCount = blockScanResult.getWindChargeCount().values().stream().reduce(Integer::sum).orElse(0);
+            SchematicSystem.MESSAGE.sendPrefixless("AUTO_CHECKER_RESULT_WIND_CHARGES", p, windChargesCount, 2048);
+            blockScanResult.getWindChargeCount().entrySet().stream().filter(blockVector3IntegerEntry -> blockVector3IntegerEntry.getValue() > 0).forEach(blockVector3IntegerEntry -> {
+                SchematicSystem.MESSAGE.sendPrefixless("AUTO_CHECKER_RESULT_WIND_CHARGES_DISPENSER", p, SchematicSystem.MESSAGE.parse("AUTO_CHECKER_RESULT_TELEPORT_HERE", p), tpCommandTo(blockVector3IntegerEntry.getKey()),
+                        blockVector3IntegerEntry.getKey().getBlockX(),
+                        blockVector3IntegerEntry.getKey().getBlockY(),
+                        blockVector3IntegerEntry.getKey().getBlockZ(),
+                        blockVector3IntegerEntry.getValue());
+            });
+        }
+
         blockScanResult.getDispenserItems().entrySet().stream().filter(blockVector3IntegerEntry -> blockVector3IntegerEntry.getValue() > type.Schematic.MaxDispenserItems).forEach(blockVector3IntegerEntry -> {
             SchematicSystem.MESSAGE.sendPrefixless("AUTO_CHECKER_RESULT_TOO_MANY_DISPENSER_ITEMS", p, SchematicSystem.MESSAGE.parse("AUTO_CHECKER_RESULT_TELEPORT_HERE", p), tpCommandTo(blockVector3IntegerEntry.getKey()),
                     blockVector3IntegerEntry.getKey().getBlockX(),
@@ -135,6 +159,7 @@ public class AutoCheckerResult {
                     blockVector3IntegerEntry.getValue(),
                     type.Schematic.MaxDispenserItems);
         });
+
         blockScanResult.getRecords().forEach(blockVector3 -> {
             SchematicSystem.MESSAGE.sendPrefixless("AUTO_CHECKER_RESULT_RECORD", p, SchematicSystem.MESSAGE.parse("AUTO_CHECKER_RESULT_TELEPORT_HERE", p), tpCommandTo(blockVector3), blockVector3.getBlockX(), blockVector3.getBlockY(), blockVector3.getBlockZ());
         });

SchematicSystem/build.gradle.kts

@@ -32,4 +32,5 @@ dependencies {
     implementation(project(":SchematicSystem:SchematicSystem_15"))
     implementation(project(":SchematicSystem:SchematicSystem_19"))
     implementation(project(":SchematicSystem:SchematicSystem_20"))
+    implementation(project(":SchematicSystem:SchematicSystem_21"))
 }

VelocityCore/src/de/steamwar/velocitycore/commands/CheckCommand.java

@@ -316,8 +316,18 @@ public class CheckCommand extends SWCommand {
                 SchematicNode node = SchematicNode.createSchematic(-1, name, teamFolder.getNodeId());
                 NodeData.saveFromStream(node, data.schemData(false), data.getNodeFormat());
 
-                // Accept the team folder schematic and set other to Normal
+                // Accept the team folder schematic and set other to Normal as well as adding the original owner on the schematic
                 node.setSchemtype(GameModeConfig.getBySchematicType(schematic.getSchemtype()).Schematic.Type);
+                NodeMember.createNodeMember(node.getNodeId(), schematic.getOwner());
+
+                // Remove any added players from the schematic in the folder
+                for (SchematicNode schematicNode : SchematicNode.getSchematicNodeInNode(teamFolder.getNodeId())) {
+                    if (schematicNode.getNodeId() == node.getNodeId()) continue;
+                    for (NodeMember nodeMember : NodeMember.getNodeMembers(schematicNode.getNodeId())) {
+                        NodeMember.createNodeMember(node.getNodeId(), nodeMember.getMember());
+                        nodeMember.delete();
+                    }
+                }
 
                 // Conclude by setting send in schematic to normal and broadcast
                 concludeCheckSession("freigegeben", SchematicType.Normal, () -> {

VelocityCore/src/de/steamwar/velocitycore/commands/WhoisCommand.java

@@ -50,7 +50,7 @@ public class WhoisCommand extends SWCommand {
 
     @Register(description = "WHOIS_USAGE")
     public void whois(Chatter sender, long id, WhoisParameterTypes... parameters) {
-        if(!sender.user().hasPerm(UserPerm.ADMINISTRATION)) {
+        if(!sender.user().hasPerm(UserPerm.ADMINISTRATION) && !sender.user().hasPerm(UserPerm.PREFIX_DEVELOPER)) {
             sender.system("UNKNOWN_PLAYER");
             return;
         }

settings.gradle.kts

@@ -101,6 +101,7 @@ dependencyResolutionManagement {
             library("hamcrest", "org.hamcrest:hamcrest:2.2")
             library("classindex", "org.atteo.classindex:classindex:3.13")
 
+
             library("spigotapi", "org.spigotmc:spigot-api:1.20-R0.1-SNAPSHOT")
             library("spigotannotations", "org.spigotmc:plugin-annotations:1.2.3-SNAPSHOT")
             library("paperapi", "io.papermc.paper:paper-api:1.19.2-R0.1-SNAPSHOT")
@@ -182,6 +183,8 @@ include(
 
 include("CommandFramework")
 
+include("CLI")
+
 include(
     "CommonCore",
     "CommonCore:Data",
@@ -222,6 +225,7 @@ include(
     "SchematicSystem:SchematicSystem_15",
     "SchematicSystem:SchematicSystem_19",
     "SchematicSystem:SchematicSystem_20",
+    "SchematicSystem:SchematicSystem_21",
     "SchematicSystem:SchematicSystem_Core"
 )
 

steamwarci.yml

@@ -33,4 +33,6 @@ artifacts:
   "/jars/website-api.jar": "WebsiteBackend/build/libs/WebsiteBackend-all.jar"
 
 release:
+  - "rm -rf /jars/sw"
+  - "unzip -o CLI/build/distributions/sw.zip -d /jars"
   - "sudo systemctl restart api.service"