Move arena runtime configuration into GameCore

- Replace FightSystem runtime properties with shared GameConfig - Update dependent modules, commands, states, and tests
Remove File
2026-07-24 12:51:03 +02:00 · 2026-07-24 12:19:35 +02:00 · 2026-07-24 12:18:49 +02:00 · 2026-07-18 15:00:18 +02:00 · 2026-07-18 14:58:24 +02:00 · 2026-07-18 12:49:23 +02:00
300 changed files with 8482 additions and 4567 deletions
@@ -51,6 +51,7 @@ jobs:
          rm -rf deploy
          mkdir -p deploy

+          cp "AccessWidener/build/libs/AccessWidener-all.jar" "deploy/AccessWidener.jar"
          cp "BauSystem/build/libs/BauSystem-all.jar" "deploy/BauSystem.jar"
          cp "FightSystem/build/libs/FightSystem-all.jar" "deploy/FightSystem.jar"
          cp "KotlinCore/build/libs/KotlinCore-all.jar" "deploy/KotlinCore.jar"
@@ -15,6 +15,11 @@ bin/
 .vscode
 .settings

+# Language Server
+**/.project
+**/.factorypath
+**/.classpath
+
 # Other
 lib
 /WebsiteBackend/data
@@ -0,0 +1,151 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="LanguageInjectionConfiguration">
+    <injection language="SQL" injector-id="java">
+      <display-name>AsyncQueryRunner (org.apache.commons.dbutils)</display-name>
+      <single-file value="true" />
+      <place><![CDATA[psiParameter().ofMethod(0, psiMethod().withName("batch").withParameterCount(2).definedInClass("org.apache.commons.dbutils.AsyncQueryRunner"))]]></place>
+      <place><![CDATA[psiParameter().ofMethod(0, psiMethod().withName("insertBatch").withParameterCount(3).definedInClass("org.apache.commons.dbutils.AsyncQueryRunner"))]]></place>
+      <place><![CDATA[psiParameter().ofMethod(0, psiMethod().withName("query", "insert").withParameters("java.lang.String", "org.apache.commons.dbutils.ResultSetHandler").definedInClass("org.apache.commons.dbutils.AsyncQueryRunner"))]]></place>
+      <place><![CDATA[psiParameter().ofMethod(0, psiMethod().withName("query", "insert").withParameters("java.lang.String", "org.apache.commons.dbutils.ResultSetHandler", "java.lang.Object...").definedInClass("org.apache.commons.dbutils.AsyncQueryRunner"))]]></place>
+      <place><![CDATA[psiParameter().ofMethod(0, psiMethod().withName("update").withParameters("java.lang.String").definedInClass("org.apache.commons.dbutils.AsyncQueryRunner"))]]></place>
+      <place><![CDATA[psiParameter().ofMethod(0, psiMethod().withName("update").withParameters("java.lang.String", "java.lang.Object").definedInClass("org.apache.commons.dbutils.AsyncQueryRunner"))]]></place>
+      <place><![CDATA[psiParameter().ofMethod(0, psiMethod().withName("update").withParameters("java.lang.String", "java.lang.Object...").definedInClass("org.apache.commons.dbutils.AsyncQueryRunner"))]]></place>
+      <place><![CDATA[psiParameter().ofMethod(1, psiMethod().withName("batch").withParameterCount(3).definedInClass("org.apache.commons.dbutils.AsyncQueryRunner"))]]></place>
+      <place><![CDATA[psiParameter().ofMethod(1, psiMethod().withName("insertBatch").withParameterCount(4).definedInClass("org.apache.commons.dbutils.AsyncQueryRunner"))]]></place>
+      <place><![CDATA[psiParameter().ofMethod(1, psiMethod().withName("query", "insert").withParameters("java.sql.Connection", "java.lang.String", "org.apache.commons.dbutils.ResultSetHandler").definedInClass("org.apache.commons.dbutils.AsyncQueryRunner"))]]></place>
+      <place><![CDATA[psiParameter().ofMethod(1, psiMethod().withName("query", "insert").withParameters("java.sql.Connection", "java.lang.String", "org.apache.commons.dbutils.ResultSetHandler", "java.lang.Object...").definedInClass("org.apache.commons.dbutils.AsyncQueryRunner"))]]></place>
+      <place><![CDATA[psiParameter().ofMethod(1, psiMethod().withName("update").withParameters("java.sql.Connection", "java.lang.String").definedInClass("org.apache.commons.dbutils.AsyncQueryRunner"))]]></place>
+      <place><![CDATA[psiParameter().ofMethod(1, psiMethod().withName("update").withParameters("java.sql.Connection", "java.lang.String", "java.lang.Object").definedInClass("org.apache.commons.dbutils.AsyncQueryRunner"))]]></place>
+      <place><![CDATA[psiParameter().ofMethod(1, psiMethod().withName("update").withParameters("java.sql.Connection", "java.lang.String", "java.lang.Object...").definedInClass("org.apache.commons.dbutils.AsyncQueryRunner"))]]></place>
+    </injection>
+    <injection language="SQL" injector-id="java">
+      <display-name>Jodd (jodd.db)</display-name>
+      <single-file value="true" />
+      <place><![CDATA[psiParameter().ofMethod(0, psiMethod().withName("query").withParameterCount(1).definedInClass("jodd.db.DbQuery"))]]></place>
+      <place><![CDATA[psiParameter().ofMethod(1, psiMethod().withName("DbQuery").withParameterCount(2).definedInClass("jodd.db.DbQuery"))]]></place>
+      <place><![CDATA[psiParameter().ofMethod(1, psiMethod().withName("query").withParameterCount(2).definedInClass("jodd.db.DbQuery"))]]></place>
+      <place><![CDATA[psiParameter().ofMethod(2, psiMethod().withName("DbQuery").withParameterCount(3).definedInClass("jodd.db.DbQuery"))]]></place>
+    </injection>
+    <injection language="SQL" injector-id="java">
+      <display-name>MyBatis @Select/@Delete/@Insert/@Update</display-name>
+      <single-file value="true" />
+      <place><![CDATA[psiMethod().withName("value").withParameters().definedInClass("org.apache.ibatis.annotations.Delete")]]></place>
+      <place><![CDATA[psiMethod().withName("value").withParameters().definedInClass("org.apache.ibatis.annotations.Insert")]]></place>
+      <place><![CDATA[psiMethod().withName("value").withParameters().definedInClass("org.apache.ibatis.annotations.Select")]]></place>
+      <place><![CDATA[psiMethod().withName("value").withParameters().definedInClass("org.apache.ibatis.annotations.Update")]]></place>
+    </injection>
+    <injection language="SQL" injector-id="java">
+      <display-name>QueryRunner (org.apache.commons.dbutils)</display-name>
+      <single-file value="true" />
+      <place><![CDATA[psiParameter().ofMethod(0, psiMethod().withName("batch").withParameterCount(2).definedInClass("org.apache.commons.dbutils.QueryRunner"))]]></place>
+      <place><![CDATA[psiParameter().ofMethod(0, psiMethod().withName("insertBatch").withParameterCount(3).definedInClass("org.apache.commons.dbutils.QueryRunner"))]]></place>
+      <place><![CDATA[psiParameter().ofMethod(0, psiMethod().withName("query", "insert").withParameters("java.lang.String", "org.apache.commons.dbutils.ResultSetHandler").definedInClass("org.apache.commons.dbutils.QueryRunner"))]]></place>
+      <place><![CDATA[psiParameter().ofMethod(0, psiMethod().withName("query", "insert", "execute").withParameters("java.lang.String", "org.apache.commons.dbutils.ResultSetHandler", "java.lang.Object...").definedInClass("org.apache.commons.dbutils.QueryRunner"))]]></place>
+      <place><![CDATA[psiParameter().ofMethod(0, psiMethod().withName("update").withParameters("java.lang.String").definedInClass("org.apache.commons.dbutils.QueryRunner"))]]></place>
+      <place><![CDATA[psiParameter().ofMethod(0, psiMethod().withName("update").withParameters("java.lang.String", "java.lang.Object").definedInClass("org.apache.commons.dbutils.QueryRunner"))]]></place>
+      <place><![CDATA[psiParameter().ofMethod(0, psiMethod().withName("update", "execute").withParameters("java.lang.String", "java.lang.Object...").definedInClass("org.apache.commons.dbutils.QueryRunner"))]]></place>
+      <place><![CDATA[psiParameter().ofMethod(1, psiMethod().withName("batch").withParameterCount(3).definedInClass("org.apache.commons.dbutils.QueryRunner"))]]></place>
+      <place><![CDATA[psiParameter().ofMethod(1, psiMethod().withName("insertBatch").withParameterCount(4).definedInClass("org.apache.commons.dbutils.QueryRunner"))]]></place>
+      <place><![CDATA[psiParameter().ofMethod(1, psiMethod().withName("query", "insert").withParameters("java.sql.Connection", "java.lang.String", "org.apache.commons.dbutils.ResultSetHandler", "java.lang.Object...").definedInClass("org.apache.commons.dbutils.QueryRunner"))]]></place>
+      <place><![CDATA[psiParameter().ofMethod(1, psiMethod().withName("query", "insert", "execute").withParameters("java.sql.Connection", "java.lang.String", "org.apache.commons.dbutils.ResultSetHandler").definedInClass("org.apache.commons.dbutils.QueryRunner"))]]></place>
+      <place><![CDATA[psiParameter().ofMethod(1, psiMethod().withName("update").withParameters("java.sql.Connection", "java.lang.String").definedInClass("org.apache.commons.dbutils.QueryRunner"))]]></place>
+      <place><![CDATA[psiParameter().ofMethod(1, psiMethod().withName("update").withParameters("java.sql.Connection", "java.lang.String", "java.lang.Object").definedInClass("org.apache.commons.dbutils.QueryRunner"))]]></place>
+      <place><![CDATA[psiParameter().ofMethod(1, psiMethod().withName("update", "execute").withParameters("java.sql.Connection", "java.lang.String", "java.lang.Object...").definedInClass("org.apache.commons.dbutils.QueryRunner"))]]></place>
+    </injection>
+    <injection language="SQL" injector-id="java">
+      <display-name>R2DBC (io.r2dbc)</display-name>
+      <single-file value="true" />
+      <place><![CDATA[psiParameter().ofMethod(0, psiMethod().withName("add").definedInClass("io.r2dbc.spi.Batch"))]]></place>
+      <place><![CDATA[psiParameter().ofMethod(0, psiMethod().withName("createStatement").definedInClass("io.r2dbc.spi.Connection"))]]></place>
+    </injection>
+    <injection language="PostgreSQL" injector-id="java">
+      <display-name>Reactiverse Postgres Client (io.reactiverse)</display-name>
+      <single-file value="true" />
+      <place><![CDATA[psiParameter().ofMethod(0, psiMethod().withName("query", "prepare", "preparedQuery", "preparedBatch").definedInClass("io.reactiverse.pgclient.PgConnection"))]]></place>
+      <place><![CDATA[psiParameter().ofMethod(0, psiMethod().withName("query", "prepare", "preparedQuery", "preparedBatch").definedInClass("io.reactiverse.pgclient.PgTransaction"))]]></place>
+      <place><![CDATA[psiParameter().ofMethod(0, psiMethod().withName("query", "prepare", "preparedQuery", "preparedBatch", "rxQuery", "rxPrepare", "rxPreparedQuery", "rxPreparedBatch").definedInClass("io.reactiverse.reactivex.pgclient.PgClient"))]]></place>
+      <place><![CDATA[psiParameter().ofMethod(0, psiMethod().withName("query", "prepare", "preparedQuery", "preparedBatch", "rxQuery", "rxPrepare", "rxPreparedQuery", "rxPreparedBatch").definedInClass("io.reactiverse.reactivex.pgclient.PgConnection"))]]></place>
+      <place><![CDATA[psiParameter().ofMethod(0, psiMethod().withName("query", "prepare", "preparedQuery", "preparedBatch", "rxQuery", "rxPrepare", "rxPreparedQuery", "rxPreparedBatch").definedInClass("io.reactiverse.reactivex.pgclient.PgPool"))]]></place>
+      <place><![CDATA[psiParameter().ofMethod(0, psiMethod().withName("query", "prepare", "preparedQuery", "preparedBatch", "rxQuery", "rxPrepare", "rxPreparedQuery", "rxPreparedBatch").definedInClass("io.reactiverse.reactivex.pgclient.PgTransaction"))]]></place>
+      <place><![CDATA[psiParameter().ofMethod(0, psiMethod().withName("query", "preparedQuery", "preparedBatch").definedInClass("io.reactiverse.axle.pgclient.PgClient"))]]></place>
+      <place><![CDATA[psiParameter().ofMethod(0, psiMethod().withName("query", "preparedQuery", "preparedBatch").definedInClass("io.reactiverse.pgclient.PgClient"))]]></place>
+      <place><![CDATA[psiParameter().ofMethod(0, psiMethod().withName("query", "preparedQuery", "preparedBatch").definedInClass("io.reactiverse.pgclient.PgPool"))]]></place>
+    </injection>
+    <injection language="SQL" injector-id="java">
+      <display-name>SmallRye Axle SqlClient (io.vertx.axle.sqlclient)</display-name>
+      <single-file value="true" />
+      <place><![CDATA[psiParameter().ofMethod(0, psiMethod().withName("query", "preparedQuery", "preparedBatch").definedInClass("io.vertx.axle.sqlclient.Pool"))]]></place>
+      <place><![CDATA[psiParameter().ofMethod(0, psiMethod().withName("query", "preparedQuery", "preparedBatch").definedInClass("io.vertx.axle.sqlclient.SqlClient"))]]></place>
+    </injection>
+    <injection language="SQL" injector-id="java">
+      <display-name>SmallRye Mutiny SqlClient (io.vertx.mutiny.sqlclient)</display-name>
+      <single-file value="true" />
+      <place><![CDATA[psiParameter().ofMethod(0, psiMethod().withName("query", "preparedQuery", "preparedBatch").definedInClass("io.vertx.mutiny.sqlclient.Pool"))]]></place>
+      <place><![CDATA[psiParameter().ofMethod(0, psiMethod().withName("query", "preparedQuery", "preparedBatch").definedInClass("io.vertx.mutiny.sqlclient.SqlClient"))]]></place>
+    </injection>
+    <injection language="SQL" injector-id="java">
+      <display-name>SmallRye Mutiny SqlConnection (io.vertx.mutiny.sqlclient)</display-name>
+      <single-file value="true" />
+      <place><![CDATA[psiParameter().ofMethod(0, psiMethod().withName("prepare", "prepareAndAwait").definedInClass("io.vertx.mutiny.db2client.DB2Connection"))]]></place>
+      <place><![CDATA[psiParameter().ofMethod(0, psiMethod().withName("prepare", "prepareAndAwait").definedInClass("io.vertx.mutiny.mssqlclient.MSSQLConnection"))]]></place>
+      <place><![CDATA[psiParameter().ofMethod(0, psiMethod().withName("prepare", "prepareAndAwait").definedInClass("io.vertx.mutiny.mysqlclient.MySQLConnection"))]]></place>
+      <place><![CDATA[psiParameter().ofMethod(0, psiMethod().withName("prepare", "prepareAndAwait").definedInClass("io.vertx.mutiny.pgclient.PgConnection"))]]></place>
+    </injection>
+    <injection language="SQL" injector-id="java">
+      <display-name>Vert.x SQL Extensions (io.vertx.ext.sql)</display-name>
+      <single-file value="true" />
+      <place><![CDATA[psiParameter().ofMethod(0, psiMethod().withName("query", "queryWithParams", "queryStream", "queryStreamWithParams", "querySingle", "querySingleWithParams", "update", "updateWithParams", "call", "callWithParams").definedInClass("io.vertx.ext.sql.SQLClient"))]]></place>
+      <place><![CDATA[psiParameter().ofMethod(0, psiMethod().withName("query", "queryWithParams", "queryStream", "queryStreamWithParams", "querySingle", "querySingleWithParams", "update", "updateWithParams", "call", "callWithParams").definedInClass("io.vertx.ext.sql.SQLOperations"))]]></place>
+      <place><![CDATA[psiParameter().ofMethod(0, psiMethod().withName("query", "queryWithParams", "queryStream", "queryStreamWithParams", "querySingle", "querySingleWithParams", "update", "updateWithParams", "call", "callWithParams", "execute", "batchWithParams", "batchCallableWithParams").definedInClass("io.vertx.ext.sql.SQLConnection"))]]></place>
+    </injection>
+    <injection language="SQL" injector-id="java">
+      <display-name>Vert.x SQL Reactive Extensions (io.vertx.reactivex.ext.sql)</display-name>
+      <single-file value="true" />
+      <place><![CDATA[psiParameter().ofMethod(0, psiMethod().withName("query", "queryWithParams", "queryStream", "queryStreamWithParams", "querySingle", "querySingleWithParams", "update", "updateWithParams", "call", "callWithParams").definedInClass("io.vertx.reactivex.ext.sql.SQLOperations"))]]></place>
+      <place><![CDATA[psiParameter().ofMethod(0, psiMethod().withName("query", "queryWithParams", "queryStream", "queryStreamWithParams", "querySingle", "querySingleWithParams", "update", "updateWithParams", "call", "callWithParams", "execute", "batchWithParams", "batchCallableWithParams", "rxQuerySingle", "rxQuerySingleWithParams", "rxQuery", "rxQueryWithParams", "rxQueryStream", "rxQueryStreamWithParams", "rxUpdate", "rxUpdateWithParams", "rxCall", "rxCallWithParams", "rxExecute", "rxBatchWithParams", "rxBatchCallableWithParams").definedInClass("io.vertx.reactivex.ext.sql.SQLClient"))]]></place>
+      <place><![CDATA[psiParameter().ofMethod(0, psiMethod().withName("query", "queryWithParams", "queryStream", "queryStreamWithParams", "querySingle", "querySingleWithParams", "update", "updateWithParams", "call", "callWithParams", "execute", "batchWithParams", "batchCallableWithParams", "rxQuerySingle", "rxQuerySingleWithParams", "rxQuery", "rxQueryWithParams", "rxQueryStream", "rxQueryStreamWithParams", "rxUpdate", "rxUpdateWithParams", "rxCall", "rxCallWithParams", "rxExecute", "rxBatchWithParams", "rxBatchCallableWithParams").definedInClass("io.vertx.reactivex.ext.sql.SQLConnection"))]]></place>
+      <place><![CDATA[psiParameter().ofMethod(0, psiMethod().withName("querySingle", "rxQuerySingle", "querySingleWithParams", "rxQuerySingleWithParams").definedInClass("io.vertx.reactivex.ext.asyncsql.AsyncSQLClient"))]]></place>
+      <place><![CDATA[psiParameter().ofMethod(0, psiMethod().withName("querySingle", "rxQuerySingle", "querySingleWithParams", "rxQuerySingleWithParams").definedInClass("io.vertx.reactivex.ext.asyncsql.MySQLClient"))]]></place>
+      <place><![CDATA[psiParameter().ofMethod(0, psiMethod().withName("querySingle", "rxQuerySingle", "querySingleWithParams", "rxQuerySingleWithParams").definedInClass("io.vertx.reactivex.ext.asyncsql.PostgreSQLClient"))]]></place>
+    </injection>
+    <injection language="SQL" injector-id="java">
+      <display-name>Vert.x SqlClient (io.vertx.sqlclient)</display-name>
+      <single-file value="true" />
+      <place><![CDATA[psiParameter().ofMethod(0, psiMethod().withName("query", "prepare", "preparedQuery", "preparedBatch").definedInClass("io.vertx.mssqlclient.MSSQLConnection"))]]></place>
+      <place><![CDATA[psiParameter().ofMethod(0, psiMethod().withName("query", "prepare", "preparedQuery", "preparedBatch").definedInClass("io.vertx.mysqlclient.MySQLConnection"))]]></place>
+      <place><![CDATA[psiParameter().ofMethod(0, psiMethod().withName("query", "prepare", "preparedQuery", "preparedBatch").definedInClass("io.vertx.pgclient.PgConnection"))]]></place>
+      <place><![CDATA[psiParameter().ofMethod(0, psiMethod().withName("query", "prepare", "preparedQuery", "preparedBatch").definedInClass("io.vertx.sqlclient.Pool"))]]></place>
+      <place><![CDATA[psiParameter().ofMethod(0, psiMethod().withName("query", "prepare", "preparedQuery", "preparedBatch").definedInClass("io.vertx.sqlclient.SqlClient"))]]></place>
+      <place><![CDATA[psiParameter().ofMethod(0, psiMethod().withName("query", "prepare", "preparedQuery", "preparedBatch").definedInClass("io.vertx.sqlclient.SqlConnection"))]]></place>
+      <place><![CDATA[psiParameter().ofMethod(0, psiMethod().withName("query", "prepare", "preparedQuery", "preparedBatch").definedInClass("io.vertx.sqlclient.Transaction"))]]></place>
+    </injection>
+    <injection language="SQL" injector-id="java">
+      <display-name>Vert.x SqlClient RxJava2 (io.vertx.reactivex.sqlclient)</display-name>
+      <single-file value="true" />
+      <place><![CDATA[psiParameter().ofMethod(0, psiMethod().withName("query", "prepare", "preparedQuery", "preparedBatch", "rxQuery", "rxPrepare", "rxPreparedQuery", "rxPreparedBatch").definedInClass("io.vertx.reactivex.mysqlclient.MySQLConnection"))]]></place>
+      <place><![CDATA[psiParameter().ofMethod(0, psiMethod().withName("query", "prepare", "preparedQuery", "preparedBatch", "rxQuery", "rxPrepare", "rxPreparedQuery", "rxPreparedBatch").definedInClass("io.vertx.reactivex.pgclient.PgConnection"))]]></place>
+      <place><![CDATA[psiParameter().ofMethod(0, psiMethod().withName("query", "prepare", "preparedQuery", "preparedBatch", "rxQuery", "rxPrepare", "rxPreparedQuery", "rxPreparedBatch").definedInClass("io.vertx.reactivex.sqlclient.SqlConnection"))]]></place>
+      <place><![CDATA[psiParameter().ofMethod(0, psiMethod().withName("query", "prepare", "preparedQuery", "preparedBatch", "rxQuery", "rxPrepare", "rxPreparedQuery", "rxPreparedBatch").definedInClass("io.vertx.reactivex.sqlclient.Transaction"))]]></place>
+      <place><![CDATA[psiParameter().ofMethod(0, psiMethod().withName("query", "prepare", "preparedQuery", "preparedBatch", "rxQuery", "rxPreparedQuery", "rxPreparedBatch").definedInClass("io.vertx.reactivex.mysqlclient.MySQLPool"))]]></place>
+      <place><![CDATA[psiParameter().ofMethod(0, psiMethod().withName("query", "prepare", "preparedQuery", "preparedBatch", "rxQuery", "rxPreparedQuery", "rxPreparedBatch").definedInClass("io.vertx.reactivex.pgclient.PgPool"))]]></place>
+      <place><![CDATA[psiParameter().ofMethod(0, psiMethod().withName("query", "prepare", "preparedQuery", "preparedBatch", "rxQuery", "rxPreparedQuery", "rxPreparedBatch").definedInClass("io.vertx.reactivex.sqlclient.Pool"))]]></place>
+      <place><![CDATA[psiParameter().ofMethod(0, psiMethod().withName("query", "prepare", "preparedQuery", "preparedBatch", "rxQuery", "rxPreparedQuery", "rxPreparedBatch").definedInClass("io.vertx.reactivex.sqlclient.SqlClient"))]]></place>
+    </injection>
+    <injection language="SQL" injector-id="java">
+      <display-name>jOOQ (org.jooq.DSLContext)</display-name>
+      <single-file value="true" />
+      <place><![CDATA[psiParameter().ofMethod(0, psiMethod().withName("batch").withParameters("java.lang.String", "java.lang.Object[]...").definedInClass("org.jooq.DSLContext"))]]></place>
+      <place><![CDATA[psiParameter().ofMethod(0, psiMethod().withName("query", "fetch", "fetchLazy", "fetchAsync", "fetchStream", "fetchMany", "fetchOne", "fetchSingle", "fetchOptional", "fetchValue", "fetchOptionalValue", "fetchValues", "execute", "resultQuery").withParameters("java.lang.String", "java.lang.Object...").definedInClass("org.jooq.DSLContext"))]]></place>
+      <place><![CDATA[psiParameter().ofMethod(0, psiMethod().withName("query", "fetch", "fetchLazy", "fetchAsync", "fetchStream", "fetchMany", "fetchOne", "fetchSingle", "fetchOptional", "fetchValue", "fetchOptionalValue", "fetchValues", "execute", "resultQuery", "batch").withParameters("java.lang.String").definedInClass("org.jooq.DSLContext"))]]></place>
+      <place><![CDATA[psiParameter().ofMethod(psiMethod().withName("batch").withParameters("java.lang.String...").definedInClass("org.jooq.DSLContext"))]]></place>
+    </injection>
+    <injection language="SQL" injector-id="java">
+      <display-name>rxjava2-jdbc (org.davidmoten.rx.jdbc)</display-name>
+      <single-file value="true" />
+      <place><![CDATA[psiMethod().withName("value").definedInClass("org.davidmoten.rx.jdbc.annotations.Query")]]></place>
+      <place><![CDATA[psiParameter().ofMethod(0, psiMethod().withName("call", "select", "update").definedInClass("org.davidmoten.rx.jdbc.Database"))]]></place>
+      <place><![CDATA[psiParameter().ofMethod(0, psiMethod().withName("call", "select", "update").definedInClass("org.davidmoten.rx.jdbc.TransactedBuilder"))]]></place>
+    </injection>
+  </component>
+</project>
@@ -0,0 +1,45 @@
+/*
+ *   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 {
+    `java-library`
+    alias(libs.plugins.shadow)
+}
+
+dependencies {
+    implementation("org.ow2.asm:asm:9.7")
+    implementation("org.ow2.asm:asm-commons:9.7")
+}
+
+tasks.shadowJar {
+    manifest {
+        attributes(
+            "Manifest-Version" to "1.0",
+            "Build-Jdk-Spec" to "21",
+            "Main-Class" to "de.steamwar.Main",
+            "Premain-Class" to "de.steamwar.Agent",
+            "Can-Retransform-Classes" to "true",
+            "Can-Redefine-Classes" to "true",
+        )
+    }
+}
+
+tasks.build {
+    dependsOn(tasks.shadowJar)
+}
@@ -0,0 +1,49 @@
+/*
+ *   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;
+
+/**
+ * A single parsed line from a .accesswidener file.
+ * <p>
+ * Examples:
+ * accessible class  net/minecraft/server/level/ServerPlayer
+ * accessible method net/minecraft/server/level/ServerPlayer getStats ()V
+ * mutable    field  net/minecraft/world/entity/Entity id I
+ * extendable class  net/minecraft/world/level/chunk/LevelChunk
+ */
+public record AccessWidenerEntry(
+        /** accessible | mutable | extendable (may have "transitive-" prefix) */
+        String directive,
+        /** class | method | field */
+        String memberType,
+        /** Internal class name, e.g. net/minecraft/server/level/ServerPlayer */
+        String target,
+        /** Method/field name, null for class entries */
+        String name,
+        /** Descriptor, null for class entries */
+        String descriptor) {
+    /**
+     * Returns true if this entry targets the class with the given internal name.
+     */
+    public boolean targets(String internalName) {
+        return target.equals(internalName);
+    }
+}
+
@@ -0,0 +1,104 @@
+/*
+ *   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;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.nio.charset.StandardCharsets;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Parses Fabric-compatible .accesswidener files.
+ * <p>
+ * Supported format:
+ * <pre>
+ *   accessWidener v2 named
+ *
+ *   # comments are supported
+ *   accessible class  net/minecraft/Foo
+ *   accessible method net/minecraft/Foo someMethod ()V
+ *   accessible field  net/minecraft/Foo someField I
+ *   mutable    field  net/minecraft/Foo someField I
+ *   extendable class  net/minecraft/Foo
+ *   extendable method net/minecraft/Foo someMethod ()V
+ *
+ *   # transitive variants (expose widening to dependents)
+ *   transitive-accessible class net/minecraft/Foo
+ * </pre>
+ */
+public final class AccessWidenerParser {
+
+    private AccessWidenerParser() {
+    }
+
+    public static List<AccessWidenerEntry> parse(InputStream in) throws IOException {
+        List<AccessWidenerEntry> entries = new ArrayList<>();
+
+        try (BufferedReader reader = new BufferedReader(new InputStreamReader(in, StandardCharsets.UTF_8))) {
+
+            String line;
+            boolean headerSeen = false;
+
+            while ((line = reader.readLine()) != null) {
+                // Strip inline comments
+                int commentIdx = line.indexOf('#');
+                if (commentIdx >= 0) line = line.substring(0, commentIdx);
+                line = line.strip();
+
+                if (line.isEmpty()) continue;
+
+                if (!headerSeen) {
+                    // First non-blank, non-comment line must be the header
+                    if (!line.startsWith("accessWidener")) {
+                        throw new IOException("Missing accessWidener header, got: " + line);
+                    }
+                    headerSeen = true;
+                    continue;
+                }
+
+                AccessWidenerEntry entry = parseLine(line);
+                if (entry != null) entries.add(entry);
+            }
+        }
+
+        return entries;
+    }
+
+    private static AccessWidenerEntry parseLine(String line) {
+        String[] parts = line.split("\\s+");
+        if (parts.length < 3) return null;
+
+        String directive = parts[0]; // accessible / mutable / extendable / transitive-*
+        String memberType = parts[1]; // class / method / field
+        String target = parts[2]; // internal class name
+
+        return switch (memberType) {
+            case "class" -> new AccessWidenerEntry(directive, "class", target, null, null);
+            case "method", "field" -> {
+                if (parts.length < 5) yield null;
+                yield new AccessWidenerEntry(directive, memberType, target, parts[3], parts[4]);
+            }
+            default -> null;
+        };
+    }
+}
@@ -0,0 +1,75 @@
+/*
+ *   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;
+
+import java.io.File;
+import java.io.IOException;
+import java.lang.instrument.Instrumentation;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.logging.Logger;
+
+/**
+ * Java agent entry point.
+ * <p>
+ * At JVM startup:  java -javaagent:paper-access-widener-agent.jar -jar server.jar
+ * <p>
+ * On attach the agent:
+ * <ol>
+ *     <li>Find all .jar files inside the plugins folder</li>
+ *     <li>Scan all found jars for *.accesswidener resources</li>
+ *     <li>Transform any class during loading</li>
+ * </ol>
+ */
+public class Agent {
+    private Agent() {
+        throw new IllegalStateException("Utility class");
+    }
+
+    private static final Logger LOG = Logger.getLogger("AccessWidenerAgent");
+
+    // -javaagent: startup
+    public static void premain(String args, Instrumentation inst) {
+        init(inst);
+    }
+
+    private static void init(Instrumentation inst) {
+        LOG.info("[AccessWidener] Agent initialising.");
+
+        List<AccessWidenerEntry> entries = new ArrayList<>();
+        File file = new File(new File(".").getAbsoluteFile(), "plugins/");
+        File[] files = file.listFiles();
+        if (files == null) files = new File[0];
+        for (File jarFile : files) {
+            if (!jarFile.isFile()) continue;
+            if (!jarFile.getName().endsWith(".jar")) continue;
+            try {
+                entries.addAll(Utils.findAndParseAccessWideners(jarFile.toPath()));
+            } catch (IOException e) {
+                LOG.warning("Failed to parse access wideners from " + jarFile.getAbsolutePath());
+            }
+        }
+        LOG.info("[AccessWidener] Loaded " + entries.size() + " access wideners.");
+
+        inst.addTransformer(new WideningTransformer(entries), false);
+        LOG.info("[AccessWidener] Agent ready.");
+    }
+}
+
@@ -0,0 +1,83 @@
+/*
+ *   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;
+
+import org.objectweb.asm.ClassReader;
+import org.objectweb.asm.ClassWriter;
+
+import java.util.List;
+import java.util.Set;
+import java.util.logging.Logger;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+/**
+ * Uses ASM to patch class bytecode according to a list of access widener entries.
+ *
+ * Returns {@code null} if the class is not targeted by any entry (no-op signal
+ * to the caller so it can skip the write).
+ */
+public class ClassPatcher {
+
+    private static final Logger LOG = Logger.getLogger("ClassPatcher");
+
+    private final List<AccessWidenerEntry> entries;
+
+    /** Pre-computed set of targeted internal names for fast filtering. */
+    private final Set<String> targets;
+
+    private final Set<String> targetsPublicConstructor;
+
+    public ClassPatcher(List<AccessWidenerEntry> entries) {
+        this.entries = entries;
+        this.targets = entries.stream()
+                .map(AccessWidenerEntry::target)
+                .flatMap(s -> {
+                    if (!s.contains("$")) return Stream.of(s);
+                    int index = s.lastIndexOf('$');
+                    return Stream.of(s, s.substring(0, index));
+                })
+                .collect(Collectors.toSet());
+        this.targetsPublicConstructor = entries.stream()
+                .filter(entry -> entry.directive().equals("transitive-extendable"))
+                .map(AccessWidenerEntry::target)
+                .collect(Collectors.toSet());
+    }
+
+    /**
+     * Patches {@code classBytes} if {@code className} is targeted.
+     *
+     * @return patched bytes, or {@code null} if no changes were needed
+     */
+    public byte[] patch(String className, byte[] classBytes) {
+        if (!targets.contains(className)) return null;
+
+        try {
+            ClassReader cr = new ClassReader(classBytes);
+            ClassWriter cw = new ClassWriter(cr, 0);
+            cr.accept(new ClassTransformer(cw, className, entries, targetsPublicConstructor.contains(className)), ClassReader.SKIP_CODE | ClassReader.SKIP_DEBUG | ClassReader.SKIP_FRAMES);
+            return cw.toByteArray();
+        } catch (Exception e) {
+            LOG.warning("[AccessWidener] Failed to transform " + className + ": " + e.getMessage());
+            return null;
+        }
+    }
+}
+
@@ -0,0 +1,125 @@
+/*
+ *   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;
+
+import org.objectweb.asm.ClassVisitor;
+import org.objectweb.asm.FieldVisitor;
+import org.objectweb.asm.MethodVisitor;
+import org.objectweb.asm.Opcodes;
+
+import java.util.List;
+
+public class ClassTransformer extends ClassVisitor {
+
+    private final String internalName;
+    private final List<AccessWidenerEntry> entries;
+    private final boolean appendPublicConstructor;
+
+    public ClassTransformer(ClassVisitor cv, String internalName, List<AccessWidenerEntry> entries, boolean appendPublicConstructor) {
+        super(Opcodes.ASM9, cv);
+        this.internalName = internalName;
+        this.entries = entries;
+        this.appendPublicConstructor = appendPublicConstructor;
+    }
+
+    @Override
+    public void visit(int version, int access, String name, String signature, String superName, String[] interfaces) {
+        int newAccess = access;
+        for (AccessWidenerEntry e : entries) {
+            if (!e.targets(internalName) || !"class".equals(e.memberType())) continue;
+            newAccess = applyDirective(e.directive(), newAccess, false);
+        }
+        if (appendPublicConstructor) {
+            MethodVisitor methodVisitor = visitMethod(Opcodes.ACC_PUBLIC, "<init>", "()V", null, null);
+            methodVisitor.visitCode();
+            methodVisitor.visitVarInsn(Opcodes.ALOAD, 0);
+            methodVisitor.visitMethodInsn(
+                    Opcodes.INVOKESPECIAL,
+                    "java/lang/Object",
+                    "<init>",
+                    "()V",
+                    false
+            );
+            methodVisitor.visitInsn(Opcodes.RETURN);
+            methodVisitor.visitMaxs(1, 1);
+            methodVisitor.visitEnd();
+        }
+        super.visit(version, newAccess, name, signature, superName, interfaces);
+    }
+
+    @Override
+    public void visitInnerClass(String name, String outerName, String innerName, int access) {
+        int newAccess = access;
+        for (AccessWidenerEntry e : entries) {
+            if (!e.target().equals(name) || !"class".equals(e.memberType())) continue;
+            newAccess = applyDirective(e.directive(), newAccess, false);
+        }
+        super.visitInnerClass(name, outerName, innerName, newAccess);
+    }
+
+    @Override
+    public MethodVisitor visitMethod(int access, String name, String descriptor, String signature, String[] exceptions) {
+        int newAccess = access;
+        for (AccessWidenerEntry e : entries) {
+            if (!e.targets(internalName) || !"method".equals(e.memberType())) continue;
+            if (!name.equals(e.name()) || !descriptor.equals(e.descriptor())) continue;
+            newAccess = applyDirective(e.directive(), newAccess, false);
+        }
+        return super.visitMethod(newAccess, name, descriptor, signature, exceptions);
+    }
+
+    @Override
+    public FieldVisitor visitField(int access, String name, String descriptor, String signature, Object value) {
+        int newAccess = access;
+        for (AccessWidenerEntry e : entries) {
+            if (!e.targets(internalName) || !"field".equals(e.memberType())) continue;
+            if (!name.equals(e.name())) continue;
+            newAccess = applyDirective(e.directive(), newAccess, true);
+        }
+        return super.visitField(newAccess, name, descriptor, signature, value);
+    }
+
+    /**
+     * Apply a directive to an access bitmask.
+     *
+     * @param directive accessible / mutable / extendable (with optional "transitive-" prefix)
+     * @param access    current access flags
+     * @param isField   true when processing a field (mutable removes final)
+     */
+    private static int applyDirective(String directive, int access, boolean isField) {
+        // Strip transitive- prefix — the widening itself is the same
+        String effective = directive.startsWith("transitive-") ? directive.substring("transitive-".length()) : directive;
+
+        return switch (effective) {
+            case "accessible" -> makePublic(access);
+            case "extendable" -> makePublic(removeFinal(access));
+            case "mutable" -> isField ? removeFinal(access) : access;
+            default -> access;
+        };
+    }
+
+    private static int makePublic(int access) {
+        return (access & ~(Opcodes.ACC_PRIVATE | Opcodes.ACC_PROTECTED)) | Opcodes.ACC_PUBLIC;
+    }
+
+    private static int removeFinal(int access) {
+        return access & ~Opcodes.ACC_FINAL;
+    }
+}
@@ -0,0 +1,125 @@
+/*
+ *   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;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.nio.file.*;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Command-line tool that produces a widened copy of a JAR for use as a
+ * compile-time stub in IntelliJ / Gradle.
+ *
+ * Usage:
+ *   java -jar jar-widener.jar <input.jar> <output.jar> [file.accesswidener ...]
+ *
+ * The output JAR is identical to the input JAR except that every class
+ * targeted by the access widener entries has its access flags patched:
+ *   accessible  → public
+ *   extendable  → public + non-final
+ *   mutable     → non-final field
+ *
+ * Intended for use as a Gradle task so IntelliJ sees the already-widened
+ * class when you Ctrl+click NMS code, and javac compiles without complaints.
+ */
+public class Main {
+
+    public static void main(String[] args) throws Exception {
+        if (args.length < 2) {
+            System.err.println("Usage: jar-widener <input.jar> <output.jar> [*.accesswidener ...]");
+            System.exit(1);
+        }
+
+        Path inputJar  = Path.of(args[0]);
+        Path outputJar = Path.of(args[1]);
+
+        if (!Files.exists(inputJar)) {
+            System.err.println("Input JAR not found: " + inputJar);
+            System.exit(1);
+        }
+
+        // --- Collect all access widener entries ---
+        List<AccessWidenerEntry> entries = new ArrayList<>();
+
+        if (args.length > 2) {
+            for (int i = 2; i < args.length; i++) {
+                Path awFile = Path.of(args[i]);
+                if (!Files.exists(awFile)) {
+                    System.err.println("Warning: access widener file not found, skipping: " + awFile);
+                    continue;
+                }
+                try (InputStream in = Files.newInputStream(awFile)) {
+                    List<AccessWidenerEntry> parsed = AccessWidenerParser.parse(in);
+                    System.out.println("Loaded " + parsed.size() + " entries from " + awFile.getFileName());
+                    entries.addAll(parsed);
+                }
+            }
+        }
+
+        if (entries.isEmpty()) {
+            System.out.println("No access widener entries found — copying JAR unchanged.");
+            Files.createDirectories(outputJar.getParent());
+            Files.copy(inputJar, outputJar, StandardCopyOption.REPLACE_EXISTING);
+            return;
+        }
+
+        System.out.println("Widening " + inputJar.getFileName()
+                + " with " + entries.size() + " total entr"
+                + (entries.size() == 1 ? "y" : "ies") + "...");
+
+        // --- Copy input → output, transforming .class files in place ---
+        Files.createDirectories(outputJar.getParent());
+        Files.copy(inputJar, outputJar, StandardCopyOption.REPLACE_EXISTING);
+
+        ClassPatcher patcher = new ClassPatcher(entries);
+
+        try (FileSystem fs = FileSystems.newFileSystem(outputJar)) {
+            // Walk every .class entry in the JAR
+            try (var stream = Files.walk(fs.getPath("/"))) {
+                stream.filter(p -> p.toString().endsWith(".class"))
+                        .forEach(classPath -> patchClass(fs, classPath, patcher));
+            }
+        }
+
+        System.out.println("Done. Widened JAR written to " + outputJar);
+    }
+
+    private static void patchClass(FileSystem fs, Path classPath, ClassPatcher patcher) {
+        // Derive internal class name from path  e.g. /net/minecraft/Foo.class → net/minecraft/Foo
+        String internalName = classPath.toString()
+                .replaceFirst("^/", "")
+                .replace(".class", "");
+
+        try {
+            byte[] original = Files.readAllBytes(classPath);
+            byte[] patched  = patcher.patch(internalName, original);
+
+            if (patched != null) {
+                Files.write(classPath, patched);
+                System.out.println("  Widened: " + internalName);
+            }
+        } catch (IOException e) {
+            System.err.println("  Warning: failed to patch " + internalName + ": " + e.getMessage());
+        }
+    }
+}
+
@@ -0,0 +1,60 @@
+/*
+ *   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;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.nio.file.Path;
+import java.util.ArrayList;
+import java.util.Enumeration;
+import java.util.List;
+import java.util.logging.Logger;
+import java.util.zip.ZipEntry;
+import java.util.zip.ZipFile;
+
+public class Utils {
+
+    private static final Logger LOG = Logger.getLogger("AccessWidenerAgent");
+
+    private Utils() {
+        throw new IllegalStateException("Utility class");
+    }
+
+    public static List<AccessWidenerEntry> findAndParseAccessWideners(Path jarPath) throws IOException {
+        List<AccessWidenerEntry> results = new ArrayList<>();
+
+        try (ZipFile zip = new ZipFile(jarPath.toFile())) {
+            Enumeration<? extends ZipEntry> entries = zip.entries();
+            while (entries.hasMoreElements()) {
+                ZipEntry entry = entries.nextElement();
+                if (entry.isDirectory() || !entry.getName().endsWith(".accesswidener")) continue;
+
+                try (InputStream in = zip.getInputStream(entry)) {
+                    results.addAll(AccessWidenerParser.parse(in));
+                } catch (IOException e) {
+                    LOG.warning("[AccessWidener] Failed to parse " + entry.getName()
+                            + " in " + jarPath.getFileName() + ": " + e.getMessage());
+                }
+            }
+        }
+
+        return results;
+    }
+}
@@ -0,0 +1,44 @@
+/*
+ *   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;
+
+import java.lang.instrument.ClassFileTransformer;
+import java.security.ProtectionDomain;
+import java.util.List;
+
+/**
+ * Transforms class bytecode to apply access widening rules.
+ * <p>
+ * Also monitors for new plugin ClassLoaders appearing (when plugins load after
+ * the agent attaches) and automatically picks up their .accesswidener files.
+ */
+public class WideningTransformer implements ClassFileTransformer {
+
+    private final ClassPatcher patcher;
+
+    public WideningTransformer(List<AccessWidenerEntry> entries) {
+        patcher = new ClassPatcher(entries);
+    }
+
+    @Override
+    public byte[] transform(ClassLoader loader, String className, Class<?> classBeingRedefined, ProtectionDomain protectionDomain, byte[] classfileBuffer) {
+        return patcher.patch(className, classfileBuffer);
+    }
+}
@@ -19,6 +19,7 @@

 plugins {
    steamwar.java
+    widener
 }

 tasks.compileJava {
@@ -34,6 +35,7 @@ dependencies {
    compileOnly(libs.classindex)
    annotationProcessor(libs.classindex)
    compileOnly(project(":SpigotCore", "default"))
+    compileOnly(project(":KotlinCore", "default"))

    compileOnly(libs.axiom)
    compileOnly(libs.authlib)
@@ -47,3 +49,7 @@ dependencies {
    implementation(libs.luaj)
    implementation(files("$projectDir/../libs/YAPION-SNAPSHOT.jar"))
 }
+
+widener {
+    fromCatalog(libs.nms)
+}
@@ -834,6 +834,10 @@ SKIN_NO_REGION = §7You are not in a region with a changealbe skin
 SKIN_ALREADY_EXISTS = §cThis skin already exists like this
 SKIN_MESSAGE = §7Skin created
 SKIN_MESSAGE_HOVER = §eClick to copy for YoyoNow and send
+# Blast Resistance
+BLASTRESISTANCE_HELP = §8/§eblastresistance §8-§7 Calculate min/max and average blast resistance of current clipboard
+BLASTRESISTANCE_NO_CLIPBOARD = §cYou currently do not have a clipboard to be used.
+BLASTRESISTANCE_RESULT = §7BlastResistance §8>>§7 Min§8: §e{0}§7   Max§8: §e{1}§7   Avg§8: §e{2}
 # Panzern
 PANZERN_HELP = §8/§epanzern §8[§7Block§8] §8[§7Slab§8] §8- §7Armor your WorldEdit selection
 PANZERN_PREPARE1 = §71. Check, if barrels reach until border of armor.
@@ -772,6 +772,10 @@ SKIN_NO_REGION = §7Du steht in keiner Region, welche mit einem Skin versehen we
 SKIN_ALREADY_EXISTS = §cDieser Skin existiert in der Form bereits
 SKIN_MESSAGE = §7Skin erstellt
 SKIN_MESSAGE_HOVER = §eKlicken zum kopieren für YoyoNow und an diesen senden
+# Blast Resistance
+BLASTRESISTANCE_HELP = §8/§eblastresistance §8-§7 Minimal-, Maximal- und durchschnittliche Sprengfestigkeit des aktuellen Inhalts der Zwischenablage berechnen
+BLASTRESISTANCE_NO_CLIPBOARD = §cDerzeit steht Ihnen keine Zwischenablage zur Verfügung.
+BLASTRESISTANCE_RESULT = §7BlastResistance §8>>§7 Min§8: §e{0}§7   Max§8: §e{1}§7   Avg§8: §e{2}
 # Panzern
 PANZERN_HELP = §8/§epanzern §8[§7Block§8] §8[§7Slab§8] §8- §7Panzer deine WorldEdit Auswahl
 PANZERN_PREPARE1 = §71. Gucke nochmal nach, ob Läufe auch bis zur Panzergrenze führen.
@@ -0,0 +1,13 @@
+accessWidener v2 named
+
+# For NoClipCommand
+accessible field net/minecraft/server/level/ServerPlayerGameMode gameModeForPlayer Lnet/minecraft/world/level/GameType;
+
+# For PlaceItemUtils
+accessible field org/bukkit/craftbukkit/block/CraftBlockState position Lnet/minecraft/core/BlockPos;
+mutable field org/bukkit/craftbukkit/block/CraftBlockState position Lnet/minecraft/core/BlockPos;
+accessible field org/bukkit/craftbukkit/block/CraftBlockState world Lorg/bukkit/craftbukkit/CraftWorld;
+mutable field org/bukkit/craftbukkit/block/CraftBlockState world Lorg/bukkit/craftbukkit/CraftWorld;
+
+# For TickManager
+accessible field net/minecraft/server/ServerTickRateManager remainingSprintTicks J
@@ -133,12 +133,7 @@ public class BauSystem extends JavaPlugin implements Listener {

        Bukkit.getWorlds().get(0).setGameRule(GameRule.SEND_COMMAND_FEEDBACK, false);

-        String identifier;
-        if (BauServerInfo.getWorldId() != null) {
-            identifier = BauServerInfo.getWorldId().toString().replace("-", "");
-        } else {
-            identifier = BauServerInfo.getOwnerUser().getUUID().toString().replace("-", "");
-        }
+        String identifier = BauServerInfo.getOwnerUser().getUUID().toString().replace("-", "");
        WorldIdentifier.set("bau/" + Core.getVersion() + "/" + identifier);
    }

@@ -229,4 +224,4 @@ public class BauSystem extends JavaPlugin implements Listener {
        AtomicReference<BukkitTask> task = new AtomicReference<>();
        task.set(runTaskTimer(plugin, () -> consumer.accept(task.get()), delay, period));
    }
-}
+}
@@ -60,16 +60,11 @@ public enum Permission {
    }

    public boolean hasPermission(Player member) {
-        SteamwarUser steamwarUser = SteamwarUser.get(member.getUniqueId());
-        BauServer server = BauServer.getInstance();
-        if (!server.isTeamWorld() && steamwarUser.getId() == server.getOwnerID()) {
+        if (SteamwarUser.get(member.getUniqueId()).getId() == BauServer.getInstance().getOwnerID()) {
            return this != SPECTATOR;
        }
-        if (server.isTeamWorld() && steamwarUser.getTeam() == server.getTeamID()) {
-            return this != SPECTATOR;
-        }
-        BauweltMember bauweltMember = BauweltMember.getBauMember(server.getWorldID(), steamwarUser.getId());
+        BauweltMember bauweltMember = BauweltMember.getBauMember(BauServer.getInstance().getOwner(), member.getUniqueId());
        if (bauweltMember == null) return this == SPECTATOR;
        return permissionPredicate.test(bauweltMember);
    }
-}
+}
@@ -34,41 +34,16 @@ public class BauServer {
    }

    private Integer owner;
-    private UUID world;
-    private Integer team;

    public UUID getOwner() {
-        Integer ownerId = getOwnerID();
-        return ownerId == null ? null : SteamwarUser.byId(ownerId).getUUID();
+        return SteamwarUser.byId(getOwnerID()).getUUID();
    }

-    public Integer getOwnerID() {
+    public int getOwnerID() {
        //Lazy loading to improve startup time of the server in 1.15
        if (owner == null) {
            owner = BauServerInfo.getOwnerId();
        }
        return owner;
    }
-
-    public boolean hasOwner() {
-        return getOwnerID() != null;
-    }
-
-    public UUID getWorldID() {
-        if (world == null) {
-            world = BauServerInfo.getWorldId();
-        }
-        return world;
-    }
-
-    public Integer getTeamID() {
-        if (team == null) {
-            team = BauServerInfo.getTeamId();
-        }
-        return team;
-    }
-
-    public boolean isTeamWorld() {
-        return getTeamID() != null;
-    }
-}
+}
@@ -47,7 +47,7 @@ public class BauInfoBauGuiItem extends BauGuiItem {
    @Override
    public ItemStack getItem(Player player) {
        SWItem itemStack;
-        if (!player.getName().endsWith("⍇") && !BauServer.getInstance().isTeamWorld()) {
+        if (!player.getName().endsWith("⍇")) {
            itemStack = SWItem.getPlayerSkull(SteamwarUser.get(BauServer.getInstance().getOwner()).getUserName());
        } else {
            itemStack = new SWItem(Material.PLAYER_HEAD, "");
@@ -47,9 +47,7 @@ public class InfoCommand extends SWCommand {

    @Register(description = "BAU_INFO_COMMAND_HELP")
    public void genericCommand(Player p) {
-        if (!bauServer.isTeamWorld()) {
-            BauSystem.MESSAGE.send("BAU_INFO_COMMAND_OWNER", p, SteamwarUser.byId(bauServer.getOwnerID()).getUserName());
-        }
+        BauSystem.MESSAGE.send("BAU_INFO_COMMAND_OWNER", p, SteamwarUser.byId(bauServer.getOwnerID()).getUserName());
        Region region = Region.getRegion(p.getLocation());
        for (Flag flag : Flag.getFlags()) {
            if (!region.getRegionData().has(flag).isApplicable()) continue;
@@ -60,7 +58,7 @@ public class InfoCommand extends SWCommand {
        }

        if (Permission.BUILD.hasPermission(p)) {
-            List<BauweltMember> members = BauweltMember.getWorldMembers(bauServer.getWorldID());
+            List<BauweltMember> members = BauweltMember.getMembers(bauServer.getOwnerID());
            Map<Permission, List<BauweltMember>> memberByPermission = new HashMap<>();
            members.forEach(member -> {
                if (Permission.SUPERVISOR.hasPermission(member)) {
@@ -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
@@ -17,18 +17,15 @@
 *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */

-package de.steamwar.core;
+package de.steamwar.bausystem.features.experimental;

-import lombok.experimental.UtilityClass;
-import net.minecraft.network.chat.MutableComponent;
-import net.minecraft.network.chat.contents.PlainTextContents;
+import de.steamwar.command.SWCommand;
+import de.steamwar.linkage.Linked;

-import java.util.Optional;
+@Linked
+public class ExperimentalCommand extends SWCommand {

-@UtilityClass
-public class FlatteningWrapper {
-
-    public Object formatDisplayName(String displayName) {
-        return displayName != null ? Optional.of((Object) MutableComponent.create(PlainTextContents.create(displayName))) : Optional.empty();
+    public ExperimentalCommand() {
+        super("experimental", "experiment");
    }
 }
@@ -0,0 +1,135 @@
+/*
+ *   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.bausystem.features.experimental.redstone_engine;
+
+import de.steamwar.bausystem.features.experimental.ExperimentalCommand;
+import de.steamwar.bausystem.region.Region;
+import de.steamwar.bausystem.utils.ScoreboardElement;
+import de.steamwar.command.AbstractSWCommand;
+import de.steamwar.command.SWCommand;
+import de.steamwar.linkage.Linked;
+import io.papermc.paper.configuration.WorldConfiguration;
+import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.format.NamedTextColor;
+import net.kyori.adventure.title.TitlePart;
+import org.bukkit.Bukkit;
+import org.bukkit.craftbukkit.CraftWorld;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.player.PlayerJoinEvent;
+
+import java.util.Collection;
+import java.util.List;
+
+@AbstractSWCommand.PartOf(ExperimentalCommand.class)
+@Linked
+public class RedstoneEngine extends SWCommand implements Listener, ScoreboardElement {
+
+    public RedstoneEngine() {
+        super("");
+    }
+
+    private WorldConfiguration.Misc getConfig() {
+        return ((CraftWorld) Bukkit.getWorlds().get(0)).getHandle().paperConfig().misc;
+    }
+
+    @Register("redstone")
+    @Register("redstoneengine")
+    public void setRedstoneEngine(Player player, @StaticValue("alternate_current") String __, WorldConfiguration.Misc.AlternateCurrentUpdateOrder updateOrder) {
+        WorldConfiguration.Misc misc = getConfig();
+        misc.redstoneImplementation = WorldConfiguration.Misc.RedstoneImplementation.ALTERNATE_CURRENT;
+        misc.alternateCurrentUpdateOrder = updateOrder;
+        broadcastTitle(Bukkit.getOnlinePlayers());
+    }
+
+    @Register("redstone")
+    @Register("redstoneengine")
+    public void setRedstoneEngine(Player player, WorldConfiguration.Misc.RedstoneImplementation implementation) {
+        getConfig().redstoneImplementation = implementation;
+        broadcastTitle(Bukkit.getOnlinePlayers());
+    }
+
+    @EventHandler
+    public void onPlayerJoin(PlayerJoinEvent event) {
+        WorldConfiguration.Misc misc = getConfig();
+        if (misc.redstoneImplementation != WorldConfiguration.Misc.RedstoneImplementation.EIGENCRAFT) {
+            broadcastTitle(List.of(event.getPlayer()));
+        }
+    }
+
+    private void broadcastTitle(Collection<? extends Player> players) {
+        WorldConfiguration.Misc misc = getConfig();
+        Component title = switch (misc.redstoneImplementation) {
+            case VANILLA -> Component.text("⚠").color(NamedTextColor.RED).append(Component.text(" Redstone: Vanilla ").color(NamedTextColor.WHITE)).append(Component.text("⚠").color(NamedTextColor.RED));
+            case EIGENCRAFT -> Component.text("Redstone: Eigencraft");
+            case ALTERNATE_CURRENT -> Component.text("⚠").color(NamedTextColor.RED).append(Component.text(" Redstone: AC ").color(NamedTextColor.WHITE)).append(Component.text("⚠").color(NamedTextColor.RED));
+        };
+        Component subtitle;
+        if (misc.redstoneImplementation != WorldConfiguration.Misc.RedstoneImplementation.ALTERNATE_CURRENT) {
+            subtitle = Component.text().build();
+        } else {
+            subtitle = switch (misc.alternateCurrentUpdateOrder) {
+                case VERTICAL_FIRST_INWARD -> Component.text("Y first inwards"); // Y before XZ
+                case VERTICAL_FIRST_OUTWARD -> Component.text("Y first outwards"); // XZ before Y
+                case HORIZONTAL_FIRST_INWARD -> Component.text("XZ first inwards"); // Y before XZ
+                case HORIZONTAL_FIRST_OUTWARD -> Component.text("XZ first outwards"); // XZ before Y
+            };
+        }
+        players.forEach(player -> {
+            player.sendTitlePart(TitlePart.TITLE, title);
+            player.sendTitlePart(TitlePart.SUBTITLE, subtitle);
+        });
+    }
+
+    @Override
+    public ScoreboardGroup getGroup() {
+        return ScoreboardGroup.FOOTER;
+    }
+
+    @Override
+    public int order() {
+        return Integer.MAX_VALUE;
+    }
+
+    @Override
+    public String get(Region region, Player p) {
+        WorldConfiguration.Misc misc = getConfig();
+        switch (misc.redstoneImplementation) {
+            case ALTERNATE_CURRENT:
+                switch (misc.alternateCurrentUpdateOrder) {
+                    case VERTICAL_FIRST_INWARD:
+                        return "§eRedstone§8: §cAC §8(§7Y in§8)";
+                    case VERTICAL_FIRST_OUTWARD:
+                        return "§eRedstone§8: §cAC §8(§7Y out§8)";
+                    case HORIZONTAL_FIRST_INWARD:
+                        return "§eRedstone§8: §cAC §8(§7XZ in§8)";
+                    case HORIZONTAL_FIRST_OUTWARD:
+                        return "§eRedstone§8: §cAC §8(§7XZ out§8)";
+                }
+                return "§eRedstone§8: §cAC";
+            case EIGENCRAFT:
+                return null;
+            case VANILLA:
+            default:
+                return "§eRedstone§8: §cVanilla";
+        }
+    }
+}
@@ -20,7 +20,6 @@
 package de.steamwar.bausystem.features.region;

 import de.steamwar.bausystem.BauSystem;
-import de.steamwar.bausystem.Permission;
 import de.steamwar.bausystem.config.BauServer;
 import de.steamwar.bausystem.region.Region;
 import de.steamwar.bausystem.region.RegionUtils;
@@ -84,9 +83,6 @@ public class ColorCommand extends SWCommand {
    @ClassValidator(value = Player.class, local = true)
    public TypeValidator<Player> validator() {
        return (commandSender, player, messageSender) -> {
-            if (bauServer.isTeamWorld()) {
-                return !messageSender.send(!Permission.SUPERVISOR.hasPermission(player), "NO_PERMISSION");
-            }
            return !messageSender.send(!bauServer.getOwner().equals(player.getUniqueId()), "NO_PERMISSION");
        };
    }
@@ -68,7 +68,7 @@ public class ResetCommand extends SWCommand {
        Region region = regionCheck(p);
        if (region == null) return;

-        if (bauServer.hasOwner() && !p.getUniqueId().equals(bauServer.getOwner())) {
+        if (!p.getUniqueId().equals(bauServer.getOwner())) {
            if (Punishment.isPunished(SteamwarUser.get(bauServer.getOwner()), Punishment.PunishmentType.NoSchemReceiving, punishment -> BauSystem.MESSAGE.send("REGION_TB_NO_SCHEMRECEIVING", p, punishment.getEndTime()))) {
                return;
            }
@@ -91,7 +91,7 @@ public class TestblockCommand extends SWCommand {
            }
        }

-        if (bauServer.hasOwner() && !p.getUniqueId().equals(bauServer.getOwner())) {
+        if (!p.getUniqueId().equals(bauServer.getOwner())) {
            if (Punishment.isPunished(SteamwarUser.get(bauServer.getOwner()), Punishment.PunishmentType.NoSchemReceiving, punishment -> BauSystem.MESSAGE.send("REGION_TB_NO_SCHEMRECEIVING", p, punishment.getEndTime()))) {
                return;
            }
@@ -185,17 +185,16 @@ public class TestblockCommand extends SWCommand {
        return new TypeMapper<SchematicNode>() {
            @Override
            public List<String> tabCompletes(CommandSender commandSender, PreviousArguments previousArguments, String s) {
-                List<String> stringList = new ArrayList<>(SchematicNode.getNodeTabcomplete(SteamwarUser.get(((Player) commandSender).getUniqueId()), s));
+                List<String> stringList = new ArrayList<>();
                stringList.addAll(SchematicNode.getNodeTabcomplete(SteamwarUser.byId(0), s));
+                stringList.addAll(SchematicNode.getNodeTabcomplete(SteamwarUser.get(((Player) commandSender).getUniqueId()), s));
                return stringList;
            }

            @Override
            public SchematicNode map(CommandSender commandSender, PreviousArguments previousArguments, String s) {
-                SchematicNode node = SchematicNode.getNodeFromPath(SteamwarUser.get(((Player) commandSender).getUniqueId()), s);
-                if (node == null) {
-                    node = SchematicNode.getNodeFromPath(SteamwarUser.byId(0), s);
-                }
+                SchematicNode node = SchematicNode.getNodeFromPath(SteamwarUser.byId(0), s);
+                if (node == null) node = SchematicNode.getNodeFromPath(SteamwarUser.get(((Player) commandSender).getUniqueId()), s);
                return node;
            }
        };
@@ -19,7 +19,7 @@

 package de.steamwar.bausystem.features.simulator;

-import com.comphenix.tinyprotocol.TinyProtocol;
+import com.destroystokyo.paper.event.server.ServerTickEndEvent;
 import de.steamwar.bausystem.BauSystem;
 import de.steamwar.bausystem.Permission;
 import de.steamwar.bausystem.SWUtils;
@@ -38,77 +38,88 @@ import de.steamwar.bausystem.features.simulator.gui.SimulatorGui;
 import de.steamwar.bausystem.features.simulator.gui.base.SimulatorBaseGui;
 import de.steamwar.bausystem.utils.BauMemberUpdateEvent;
 import de.steamwar.bausystem.utils.ItemUtils;
-import de.steamwar.bausystem.utils.RayTraceUtils;
+import de.steamwar.core.SWPlayer;
+import de.steamwar.cursor.Cursor;
 import de.steamwar.entity.REntity;
 import de.steamwar.entity.REntityServer;
-import de.steamwar.entity.RFallingBlockEntity;
 import de.steamwar.inventory.SWAnvilInv;
 import de.steamwar.linkage.Linked;
 import lombok.AllArgsConstructor;
 import lombok.Getter;
-import net.minecraft.network.protocol.game.ServerboundMovePlayerPacket;
 import org.bukkit.Bukkit;
 import org.bukkit.Location;
 import org.bukkit.Material;
-import org.bukkit.World;
-import org.bukkit.block.BlockFace;
 import org.bukkit.entity.Player;
 import org.bukkit.event.EventHandler;
 import org.bukkit.event.EventPriority;
 import org.bukkit.event.Listener;
 import org.bukkit.event.block.Action;
+import org.bukkit.event.inventory.InventoryClickEvent;
+import org.bukkit.event.inventory.InventoryDragEvent;
 import org.bukkit.event.player.*;
 import org.bukkit.inventory.ItemStack;
 import org.bukkit.util.Vector;

 import java.util.*;
-import java.util.function.BiFunction;
 import java.util.function.Function;
 import java.util.stream.Collectors;

@Linked
 public class SimulatorCursor implements Listener {

-    private static final World WORLD = Bukkit.getWorlds().get(0);
-
-    private static Map<Player, CursorType> cursorType = Collections.synchronizedMap(new HashMap<>());
-    private static Map<Player, REntityServer> cursors = Collections.synchronizedMap(new HashMap<>());
-    private static final Set<Player> calculating = new HashSet<>();
+    private static final Map<Player, CursorType> cursorType = Collections.synchronizedMap(new HashMap<>());
+    private static final Map<Player, REntityServer> emptyTargetServers = Collections.synchronizedMap(new HashMap<>());

    public static boolean isSimulatorItem(ItemStack itemStack) {
        return ItemUtils.isItem(itemStack, "simulator");
    }

-    public SimulatorCursor() {
-        BiFunction<Player, ServerboundMovePlayerPacket, Object> function = (player, object) -> {
-            calcCursor(player);
-            return object;
-        };
-        TinyProtocol.instance.addFilter(ServerboundMovePlayerPacket.Pos.class, function);
-        TinyProtocol.instance.addFilter(ServerboundMovePlayerPacket.Rot.class, function);
-        TinyProtocol.instance.addFilter(ServerboundMovePlayerPacket.PosRot.class, function);
+    private static boolean hasSimulatorItem(Player player) {
+        return isSimulatorItem(player.getInventory().getItemInMainHand()) || isSimulatorItem(player.getInventory().getItemInOffHand());
+    }
+
+    private static Set<Player> scheduledUpdates = new HashSet<>();
+
+    private static void scheduleCursorUpdate(Player player) {
+        scheduledUpdates.add(player);
+    }
+
+    @EventHandler
+    public void onServerTickEnd(ServerTickEndEvent event) {
+        scheduledUpdates.forEach(SimulatorCursor::calcCursor);
+        scheduledUpdates.clear();
    }

    @EventHandler
    public void onPlayerJoin(PlayerJoinEvent event) {
        if (!Permission.BUILD.hasPermission(event.getPlayer())) return;
-        Bukkit.getScheduler().runTaskLater(BauSystem.getInstance(), () -> {
-            calcCursor(event.getPlayer());
-        }, 0);
+        scheduleCursorUpdate(event.getPlayer());
    }

    @EventHandler
    public void onPlayerDropItem(PlayerDropItemEvent event) {
        if (!Permission.BUILD.hasPermission(event.getPlayer())) return;
-        calcCursor(event.getPlayer());
+        scheduleCursorUpdate(event.getPlayer());
    }

    @EventHandler
    public void onPlayerItemHeld(PlayerItemHeldEvent event) {
        if (!Permission.BUILD.hasPermission(event.getPlayer())) return;
-        Bukkit.getScheduler().runTaskLater(BauSystem.getInstance(), () -> {
-            calcCursor(event.getPlayer());
-        }, 1);
+        scheduleCursorUpdate(event.getPlayer());
+    }
+
+    @EventHandler
+    public void onInventoryClick(InventoryClickEvent event) {
+        if (!(event.getWhoClicked() instanceof Player player)) return;
+        if (!Permission.BUILD.hasPermission(player)) return;
+        scheduleCursorUpdate(player);
+    }
+
+    @EventHandler
+    public void onInventoryDrag(InventoryDragEvent event) {
+        if (!(event.getWhoClicked() instanceof Player player)) return;
+        if (!Permission.BUILD.hasPermission(player)) return;
+        scheduleCursorUpdate(player);
    }

    @EventHandler
@@ -119,10 +130,8 @@ public class SimulatorCursor implements Listener {
    @EventHandler
    public void onPlayerQuit(PlayerQuitEvent event) {
        cursorType.remove(event.getPlayer());
-        cursors.remove(event.getPlayer());
-        synchronized (calculating) {
-            calculating.remove(event.getPlayer());
-        }
+        removeCursor(event.getPlayer());
+        scheduledUpdates.remove(event.getPlayer());
    }

    private static final Map<Player, Long> LAST_SNEAKS = new HashMap<>();
@@ -138,7 +147,7 @@ public class SimulatorCursor implements Listener {
    public void onPlayerToggleSneak(PlayerToggleSneakEvent event) {
        if (!event.isSneaking()) return;
        Player player = event.getPlayer();
-        if (!isSimulatorItem(player.getInventory().getItemInMainHand()) && !isSimulatorItem(player.getInventory().getItemInOffHand())) {
+        if (!hasSimulatorItem(player)) {
            return;
        }
        if (LAST_SNEAKS.containsKey(player)) {
@@ -164,17 +173,10 @@ public class SimulatorCursor implements Listener {
    }

    public static void calcCursor(Player player) {
-        synchronized (calculating) {
-            if (calculating.contains(player)) return;
-            calculating.add(player);
-        }
-        if (!Permission.BUILD.hasPermission(player) || (!isSimulatorItem(player.getInventory().getItemInMainHand()) && !isSimulatorItem(player.getInventory().getItemInOffHand()))) {
-            if (removeCursor(player) || SimulatorWatcher.show(null, player)) {
+        if (!Permission.BUILD.hasPermission(player) || !hasSimulatorItem(player)) {
+            if (removeCursor(player) | SimulatorWatcher.show(null, player)) {
                SWUtils.sendToActionbar(player, "");
            }
-            synchronized (calculating) {
-                calculating.remove(player);
-            }
            return;
        }

@@ -183,203 +185,98 @@ public class SimulatorCursor implements Listener {
            removeCursor(player);
            SimulatorWatcher.show(null, player);
            SWUtils.sendToActionbar(player, "§cGenerating Stab");
-            synchronized (calculating) {
-                calculating.remove(player);
-            }
            return;
        }

        SimulatorWatcher.show(simulator, player);
-        List<REntity> entities = SimulatorWatcher.getEntitiesOfSimulator(simulator);
-        RayTraceUtils.RRayTraceResult rayTraceResult = RayTraceUtils.traceREntity(player, player.getLocation(), entities);
-        if (rayTraceResult == null) {
-            removeCursor(player);
-            if (simulator == null) {
-                SWUtils.sendToActionbar(player, "§eSelect Simulator");
-            } else {
-                SWUtils.sendToActionbar(player, "§eOpen Simulator");
-            }
-            synchronized (calculating) {
-                calculating.remove(player);
-            }
-            return;
+        Cursor cursor = getOrCreateCursor(player, simulator, cursorType.getOrDefault(player, CursorType.TNT));
+        cursor.renderDeduplicated();
+    }
+
+    private static Cursor getOrCreateCursor(Player player, Simulator simulator, CursorType type) {
+        REntityServer targetServer = simulator == null ? emptyTargetServers.computeIfAbsent(player, __ -> new REntityServer()) : SimulatorWatcher.getEntityServerOfSimulator(simulator);
+        SWPlayer swPlayer = SWPlayer.of(player);
+        Optional<Cursor> activeCursor = swPlayer.getComponent(Cursor.class);
+
+        Cursor cursor = activeCursor.orElse(null);
+        if (cursor == null || cursor.getTargetServer() != targetServer) {
+            swPlayer.removeComponent(Cursor.class);
+            cursor = new Cursor(
+                    targetServer,
+                    player,
+                    Material.GLASS,
+                    type.material,
+                    type.cursorModes,
+                    (location, hitEntity, action) -> handlePlayerClick(player, location, hitEntity, action),
+                    (location, hitEntity) -> sendCursorActionbar(player, SimulatorStorage.getSimulator(player), location != null, hitEntity.isPresent())
+            );
+        } else {
+            cursor.setCursorMaterial(type.material);
+            cursor.setAllowedCursorModes(type.cursorModes);
        }

-        showCursor(player, rayTraceResult, simulator != null);
-        synchronized (calculating) {
-            calculating.remove(player);
-        }
+        return cursor;
    }

    private static synchronized boolean removeCursor(Player player) {
-        REntityServer entityServer = cursors.get(player);
-        boolean hadCursor = entityServer != null && !entityServer.getEntities().isEmpty();
-        if (entityServer != null) {
-            entityServer.getEntities().forEach(REntity::die);
+        Optional<Cursor> cursor = SWPlayer.of(player).getComponent(Cursor.class);
+        cursor.ifPresent(__ -> SWPlayer.of(player).removeComponent(Cursor.class));
+        REntityServer emptyTargetServer = emptyTargetServers.remove(player);
+        if (emptyTargetServer != null) {
+            emptyTargetServer.close();
        }
-        return hadCursor;
+        return cursor.isPresent();
    }

-    private static synchronized void showCursor(Player player, RayTraceUtils.RRayTraceResult rayTraceResult, boolean hasSimulatorSelected) {
-        REntityServer entityServer = cursors.computeIfAbsent(player, __ -> {
-            REntityServer rEntityServer = new REntityServer();
-            rEntityServer.addPlayer(player);
-            return rEntityServer;
-        });
-
-        CursorType type = cursorType.getOrDefault(player, CursorType.TNT);
-        REntity hitEntity = rayTraceResult.getHitEntity();
-        Location location = hitEntity != null ? new Vector(hitEntity.getX(), hitEntity.getY(), hitEntity.getZ()).toLocation(WORLD) :
-                type.position.apply(player, rayTraceResult).toLocation(WORLD);
-
-        Material material = hitEntity != null ? Material.GLASS : type.getMaterial();
-        List<RFallingBlockEntity> entities = entityServer.getEntitiesByType(RFallingBlockEntity.class);
-        entities.removeIf(rFallingBlockEntity -> {
-            if (rFallingBlockEntity.getMaterial() != material) {
-                rFallingBlockEntity.die();
-                return true;
-            }
-            rFallingBlockEntity.move(location);
-            return false;
-        });
-        if (entities.isEmpty()) {
-            RFallingBlockEntity rFallingBlockEntity = new RFallingBlockEntity(entityServer, location, material);
-            rFallingBlockEntity.setNoGravity(true);
-            if (material == Material.GLASS) {
-                rFallingBlockEntity.setGlowing(true);
-            }
-        }
-
-        if (hasSimulatorSelected) {
-            if (hitEntity != null) {
-                SWUtils.sendToActionbar(player, "§eEdit Position");
-            } else {
-                SWUtils.sendToActionbar(player, "§eAdd new " + type.name);
-            }
-        } else {
+    private static void sendCursorActionbar(Player player, Simulator simulator, boolean hasCursorLocation, boolean hasHitEntity) {
+        if (!hasCursorLocation) {
+            SWUtils.sendToActionbar(player, simulator == null ? "§eSelect Simulator" : "§eOpen Simulator");
+        } else if (simulator == null) {
            SWUtils.sendToActionbar(player, "§eCreate new Simulator");
-        }
-    }
-
-    public static Vector getPosFree(Player player, RayTraceUtils.RRayTraceResult result) {
-        Vector pos = result.getHitPosition();
-
-        BlockFace face = result.getHitBlockFace();
-        if (face != null) {
-            switch (face) {
-                case DOWN:
-                    pos.setY(pos.getY() - 0.98);
-                    break;
-                case EAST:
-                    pos.setX(pos.getX() + 0.49);
-                    break;
-                case WEST:
-                    pos.setX(pos.getX() - 0.49);
-                    break;
-                case NORTH:
-                    pos.setZ(pos.getZ() - 0.49);
-                    break;
-                case SOUTH:
-                    pos.setZ(pos.getZ() + 0.49);
-                    break;
-                default:
-                    break;
-            }
-
-            if (face.getModY() == 0 && player.isSneaking()) {
-                pos.setY(pos.getY() - 0.49);
-            }
-        }
-
-        if (!player.isSneaking()) {
-            pos.setX(pos.getBlockX() + 0.5);
-            if (face == null || face.getModY() == 0) {
-                pos.setY(pos.getBlockY() + 0.0);
-            }
-            pos.setZ(pos.getBlockZ() + 0.5);
-        }
-
-        return pos;
-    }
-
-    private static Vector getPosBlockAligned(Player player, RayTraceUtils.RRayTraceResult result) {
-        Vector pos = result.getHitPosition();
-
-        BlockFace face = result.getHitBlockFace();
-        if (face != null) {
-            switch (face) {
-                case DOWN:
-                    pos.setY(pos.getY() - 0.98);
-                    break;
-                case EAST:
-                    pos.setX(pos.getX() + 0.49);
-                    break;
-                case WEST:
-                    pos.setX(pos.getX() - 0.49);
-                    break;
-                case NORTH:
-                    pos.setZ(pos.getZ() - 0.49);
-                    break;
-                case SOUTH:
-                    pos.setZ(pos.getZ() + 0.49);
-                    break;
-                default:
-                    break;
-            }
-        }
-
-        pos.setX(pos.getBlockX() + 0.5);
-        if (pos.getY() - pos.getBlockY() != 0 && face == BlockFace.UP) {
-            pos.setY(pos.getBlockY() + 1.0);
+        } else if (hasHitEntity) {
+            SWUtils.sendToActionbar(player, "§eEdit Position");
        } else {
-            pos.setY(pos.getBlockY());
+            SWUtils.sendToActionbar(player, "§eAdd new " + cursorType.getOrDefault(player, CursorType.TNT).name);
        }
-        pos.setZ(pos.getBlockZ() + 0.5);
-        return pos;
    }

    @Getter
    @AllArgsConstructor
    public enum CursorType {
-        TNT(Material.TNT, Material.GUNPOWDER, SimulatorCursor::getPosFree, "TNT", vector -> new TNTElement(vector).add(new TNTPhase())),
-        REDSTONE_BLOCK(Material.REDSTONE_BLOCK, Material.REDSTONE, SimulatorCursor::getPosBlockAligned, "Redstone Block", vector -> new RedstoneElement(vector).add(new RedstonePhase())),
-        OBSERVER(Material.OBSERVER, Material.QUARTZ, SimulatorCursor::getPosBlockAligned, "Observer", vector -> new ObserverElement(vector).add(new ObserverPhase())),
+        TNT(Material.TNT, Material.GUNPOWDER, List.of(Cursor.CursorMode.FREE, Cursor.CursorMode.SURFACE_ALIGNED), "TNT", vector -> new TNTElement(vector).add(new TNTPhase())),
+        REDSTONE_BLOCK(Material.REDSTONE_BLOCK, Material.REDSTONE, List.of(Cursor.CursorMode.BLOCK_ALIGNED), "Redstone Block", vector -> new RedstoneElement(vector).add(new RedstonePhase())),
+        OBSERVER(Material.OBSERVER, Material.QUARTZ, List.of(Cursor.CursorMode.BLOCK_ALIGNED), "Observer", vector -> new ObserverElement(vector).add(new ObserverPhase())),
        ;

        public final Material material;
        public final Material nonSelectedMaterial;
-        public final BiFunction<Player, RayTraceUtils.RRayTraceResult, Vector> position;
+        public final List<Cursor.CursorMode> cursorModes;
        public final String name;
        public final Function<Vector, SimulatorElement<?>> elementFunction;
    }

-    @EventHandler
-    public void onPlayerInteract(PlayerInteractEvent event) {
-        if (!Permission.BUILD.hasPermission(event.getPlayer())) return;
-        if (!ItemUtils.isItem(event.getItem(), "simulator")) {
+    private static void handlePlayerClick(Player player, Location cursorLocation, Optional<REntity> hitEntity, Action action) {
+        if (!Permission.BUILD.hasPermission(player)) return;
+        if (!hasSimulatorItem(player)) {
            return;
        }

-        event.setCancelled(true);
-        Player player = event.getPlayer();
        Simulator simulator = SimulatorStorage.getSimulator(player);

-        if (event.getAction() == Action.LEFT_CLICK_BLOCK || event.getAction() == Action.LEFT_CLICK_AIR) {
+        if (action == Action.LEFT_CLICK_BLOCK || action == Action.LEFT_CLICK_AIR) {
            if (simulator == null) {
                return;
            }
-            SimulatorExecutor.run(event.getPlayer(), simulator, null);
+            SimulatorExecutor.run(player, simulator, null);
            return;
        }

-        if (event.getAction() != Action.RIGHT_CLICK_BLOCK && event.getAction() != Action.RIGHT_CLICK_AIR) {
+        if (action != Action.RIGHT_CLICK_BLOCK && action != Action.RIGHT_CLICK_AIR) {
            return;
        }

-
-        RayTraceUtils.RRayTraceResult rayTraceResult = RayTraceUtils.traceREntity(player, player.getLocation(), SimulatorWatcher.getEntitiesOfSimulator(simulator));
        if (simulator == null) {
-            if (rayTraceResult == null) {
+            if (cursorLocation == null) {
                SimulatorStorage.openSimulatorSelector(player);
            } else {
                SWAnvilInv anvilInv = new SWAnvilInv(player, "Name");
@@ -395,7 +292,7 @@ public class SimulatorCursor implements Listener {
                    }
                    sim = new Simulator(s);
                    SimulatorStorage.addSimulator(s, sim);
-                    createElement(player, rayTraceResult, sim);
+                    createElement(player, cursorLocation, sim);
                    SimulatorStorage.setSimulator(player, sim);
                });
                anvilInv.open();
@@ -403,57 +300,56 @@ public class SimulatorCursor implements Listener {
            return;
        }

-        if (rayTraceResult == null) {
+        if (cursorLocation == null) {
            new SimulatorGui(player, simulator).open();
            return;
        }

-        if (rayTraceResult.getHitEntity() != null) {
-            REntity hitEntity = rayTraceResult.getHitEntity();
-            Vector vector = new Vector(hitEntity.getX(), hitEntity.getY(), hitEntity.getZ());
-            List<SimulatorElement<?>> elements = simulator.getGroups().stream().map(SimulatorGroup::getElements).flatMap(List::stream).filter(element -> {
-                return element.getWorldPos().distanceSquared(vector) < (1 / 16.0) * (1 / 16.0);
-            }).collect(Collectors.toList());
-
-            switch (elements.size()) {
-                case 0:
-                    return;
-                case 1:
-                    // Open single element present in Simulator
-                    SimulatorElement<?> element = elements.get(0);
-                    SimulatorGroup group1 = element.getGroup(simulator);
-                    SimulatorBaseGui back = new SimulatorGui(player, simulator);
-                    if (group1.getElements().size() > 1) {
-                        back = new SimulatorGroupGui(player, simulator, group1, back);
-                    }
-                    element.open(player, simulator, group1, back);
-                    break;
-                default:
-                    List<SimulatorGroup> parents = elements.stream().map(e -> e.getGroup(simulator)).distinct().collect(Collectors.toList());
-                    if (parents.size() == 1) {
-                        // Open multi element present in Simulator in existing group
-                        SimulatorGui simulatorGui = new SimulatorGui(player, simulator);
-                        new SimulatorGroupGui(player, simulator, parents.get(0), simulatorGui).open();
-                    } else {
-                        // Open multi element present in Simulator in implicit group
-                        SimulatorGroup group2 = new SimulatorGroup();
-                        group2.setMaterial(null);
-                        group2.getElements().addAll(elements);
-                        SimulatorGui simulatorGui = new SimulatorGui(player, simulator);
-                        new SimulatorGroupGui(player, simulator, group2, simulatorGui).open();
-                    }
-                    break;
-            }
+        if (hitEntity.isPresent()) {
+            openElement(player, simulator, hitEntity.get());
            return;
        }

-        // Add new Element to current simulator
-        createElement(player, rayTraceResult, simulator);
+        createElement(player, cursorLocation, simulator);
    }

-    private void createElement(Player player, RayTraceUtils.RRayTraceResult rayTraceResult, Simulator simulator) {
+    private static void openElement(Player player, Simulator simulator, REntity hitEntity) {
+        Vector vector = new Vector(hitEntity.getX(), hitEntity.getY(), hitEntity.getZ());
+        List<SimulatorElement<?>> elements = simulator.getGroups().stream().map(SimulatorGroup::getElements).flatMap(List::stream).filter(element -> {
+            return element.getWorldPos().distanceSquared(vector) < (1 / 16.0) * (1 / 16.0);
+        }).collect(Collectors.toList());
+
+        switch (elements.size()) {
+            case 0:
+                return;
+            case 1:
+                SimulatorElement<?> element = elements.get(0);
+                SimulatorGroup group1 = element.getGroup(simulator);
+                SimulatorBaseGui back = new SimulatorGui(player, simulator);
+                if (group1.getElements().size() > 1) {
+                    back = new SimulatorGroupGui(player, simulator, group1, back);
+                }
+                element.open(player, simulator, group1, back);
+                break;
+            default:
+                List<SimulatorGroup> parents = elements.stream().map(e -> e.getGroup(simulator)).distinct().collect(Collectors.toList());
+                if (parents.size() == 1) {
+                    SimulatorGui simulatorGui = new SimulatorGui(player, simulator);
+                    new SimulatorGroupGui(player, simulator, parents.get(0), simulatorGui).open();
+                } else {
+                    SimulatorGroup group2 = new SimulatorGroup();
+                    group2.setMaterial(null);
+                    group2.getElements().addAll(elements);
+                    SimulatorGui simulatorGui = new SimulatorGui(player, simulator);
+                    new SimulatorGroupGui(player, simulator, group2, simulatorGui).open();
+                }
+                break;
+        }
+    }
+
+    private static void createElement(Player player, Location cursorLocation, Simulator simulator) {
        CursorType type = cursorType.getOrDefault(player, CursorType.TNT);
-        Vector vector = type.position.apply(player, rayTraceResult);
+        Vector vector = cursorLocation.toVector();
        if (type == CursorType.REDSTONE_BLOCK) {
            vector.subtract(new Vector(0.5, 0, 0.5));
        }
@@ -124,4 +124,11 @@ public class SimulatorWatcher {
        }
        return entityServer.getEntities();
    }
+
+    synchronized REntityServer getEntityServerOfSimulator(Simulator simulator) {
+        if (simulator == null) {
+            return null;
+        }
+        return entityServers.computeIfAbsent(simulator, __ -> createSim(new REntityServer(), simulator));
+    }
 }
@@ -0,0 +1,72 @@
+/*
+ *   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.bausystem.features.slaves.blastresistance;
+
+import com.google.common.util.concurrent.AtomicDouble;
+import com.sk89q.worldedit.LocalSession;
+import com.sk89q.worldedit.WorldEdit;
+import com.sk89q.worldedit.WorldEditException;
+import com.sk89q.worldedit.bukkit.BukkitAdapter;
+import com.sk89q.worldedit.extent.clipboard.Clipboard;
+import com.sk89q.worldedit.world.block.BlockState;
+import de.steamwar.bausystem.BauSystem;
+import de.steamwar.command.SWCommand;
+import de.steamwar.linkage.Linked;
+import org.bukkit.Material;
+import org.bukkit.entity.Player;
+
+import java.util.concurrent.atomic.AtomicInteger;
+
+@Linked
+public class BlastResistanceCommand extends SWCommand {
+
+    public BlastResistanceCommand() {
+        super("blastresistance");
+    }
+
+    @Register(description = "BLASTRESISTANCE_HELP")
+    public void command(@Validator Player player) {
+        LocalSession localSession = WorldEdit.getInstance().getSessionManager().get(BukkitAdapter.adapt(player));
+        Clipboard clipboard;
+        try {
+            clipboard = localSession.getClipboard().getClipboards().getFirst();
+        } catch (WorldEditException e) {
+            BauSystem.MESSAGE.send("BLASTRESISTANCE_NO_CLIPBOARD", player);
+            return;
+        }
+
+        AtomicDouble min = new AtomicDouble(0);
+        AtomicDouble max = new AtomicDouble(0);
+        AtomicDouble sum = new AtomicDouble(0);
+        AtomicInteger count = new AtomicInteger(0);
+        clipboard.forEach(blockVector3 -> {
+            BlockState blockState = clipboard.getBlock(blockVector3);
+            Material material = BukkitAdapter.adapt(blockState).getMaterial();
+            if (material == Material.WATER || material == Material.LAVA) return;
+            double blastResistance = BukkitAdapter.adapt(blockState).getMaterial().getBlastResistance();
+            min.set(Math.min(min.get(), blastResistance));
+            max.set(Math.max(max.get(), blastResistance));
+            sum.addAndGet(blastResistance);
+            count.getAndIncrement();
+        });
+
+        BauSystem.MESSAGE.send("BLASTRESISTANCE_RESULT", player, min.get(), max.get(), sum.get() / count.get());
+    }
+}
@@ -31,6 +31,7 @@ import de.steamwar.command.TypeMapper;
 import de.steamwar.core.CraftbukkitWrapper;
 import de.steamwar.linkage.Linked;
 import de.steamwar.linkage.LinkedInstance;
+import de.steamwar.techhider.legacy.TechHider;
 import net.md_5.bungee.api.ChatMessageType;
 import org.bukkit.Bukkit;
 import org.bukkit.command.CommandSender;
@@ -38,7 +39,6 @@ import org.bukkit.entity.Player;
 import org.bukkit.event.EventHandler;
 import org.bukkit.event.Listener;
 import org.bukkit.event.player.PlayerQuitEvent;
-import de.steamwar.techhider.legacy.TechHider;

 import java.util.*;
 import java.util.stream.Collectors;
@@ -25,7 +25,6 @@ import de.steamwar.bausystem.features.tracer.rendering.TraceEntity;
 import de.steamwar.bausystem.features.tracer.rendering.ViewFlag;
 import de.steamwar.bausystem.region.Region;
 import de.steamwar.entity.REntity;
-import de.steamwar.entity.REntityAction;
 import de.steamwar.entity.REntityServer;
 import lombok.Getter;
 import lombok.Setter;
@@ -153,7 +153,11 @@ public class TraceCommand extends SWCommand {

    @Register(value = "isolate", description = "TRACE_COMMAND_HELP_ISOLATE")
    public void isolate(@Validator Player player, Trace trace, @ErrorMessage("TRACE_RECORD_ID_INVALID") TNTPoint... records) {
-        TraceManager.instance.isolate(player, records);
+        if (records.length == 0) {
+            TraceManager.instance.isolate(player, trace, trace.getRecords().toArray(TNTPoint[]::new));
+        } else {
+            TraceManager.instance.isolate(player, trace, records);
+        }
        BauSystem.MESSAGE.send("TRACE_MESSAGE_ISOLATE", player);
    }

@@ -347,9 +347,10 @@ public class TraceManager implements Listener {
     * Toggles the isolated render for the given records and player
     *
     * @param player  the player the trace is shown to
-     * @param records the record for which isolation is toggled
+     * @param ptrace  the trace for whitch isolation is toggled
+     * @param records the records of the trace for which isolation is toggled
     */
-    public void isolate(Player player, TNTPoint... records) {
+    public void isolate(Player player, Trace ptrace, TNTPoint... records) {
        unfollow(player);

        Region region = Region.getRegion(player.getLocation());
@@ -374,12 +375,20 @@ public class TraceManager implements Listener {
            isolateFlag.toggleId(record.getTntId());
        }

+        if (isolateFlag.isEmpty() && playerTraceShowData.hasViewFlagOnly(IsolateFlag.class) && records.length != 0) {
+            playerTraceShowData.removeViewFlag(IsolateFlag.class);
+        }
+
        PlayerTraceShowData finalPlayerTraceShowData = playerTraceShowData;
        tracesByRegion.getOrDefault(region, Collections.emptyMap()).forEach((integer, trace) -> {
-            trace.render(player, finalPlayerTraceShowData);
-            followerMap.getOrDefault(player, Collections.emptySet()).forEach(follower -> {
-                trace.render(follower, finalPlayerTraceShowData);
-            });
+            if (trace.getUuid() == ptrace.getUuid() || finalPlayerTraceShowData.hasNoViewFlags()) {
+                trace.render(player, finalPlayerTraceShowData);
+                followerMap.getOrDefault(player, Collections.emptySet()).forEach(follower -> {
+                    trace.render(follower, finalPlayerTraceShowData);
+                });
+            } else {
+                trace.hide(player);
+            }
        });
    }

@@ -135,6 +135,13 @@ public class TraceRecorder implements Listener {
            Iterator<TNTPrimed> iter = trackedTNT.getOrDefault(region, Collections.emptyList()).iterator();
            while (iter.hasNext()) {
                TNTPrimed tnt = iter.next();
+                if (tnt.isDead()) {
+                    iter.remove();
+                    tntSpawnRegion.remove(tnt);
+                    historyMap.remove(tnt);
+                    tntSpawnRegion.remove(tnt);
+                    continue;
+                }
                if (tnt.getFuseTicks() == 80) continue;
                TNTPoint record = record(tnt, wrappedTrace, Collections.emptyList());
                if (record == null) {
@@ -95,4 +95,8 @@ public class PlayerTraceShowData {
    public void addViewFlag(ViewFlag viewFlag) {
        viewFlags.put(viewFlag.getClass(), viewFlag);
    }
+
+    public <T extends ViewFlag> void removeViewFlag(Class<T> clazz) {
+        viewFlags.remove(clazz);
+    }
 }
@@ -48,9 +48,9 @@ import static de.steamwar.bausystem.features.util.TNTClickListener.TNT_CLICK_DET
 */
 public class TraceEntity extends RBlockDisplay {

-    private static final float TNT_VISUAL_SCALE = 0.98F;
-    private static final float TNT_VISUAL_OFFSET = -TNT_VISUAL_SCALE / 2.0F;
-    private static final Transformation TNT_VISUAL_TRANSFORM = new Transformation(
+    public static final float TNT_VISUAL_SCALE = 0.98F;
+    public static final float TNT_VISUAL_OFFSET = -TNT_VISUAL_SCALE / 2.0F;
+    public static final Transformation TNT_VISUAL_TRANSFORM = new Transformation(
            new Vector3f(TNT_VISUAL_OFFSET, 0.0F, TNT_VISUAL_OFFSET),
            new Quaternionf(0, 0, 0, 1),
            new Vector3f(TNT_VISUAL_SCALE, TNT_VISUAL_SCALE, TNT_VISUAL_SCALE),
@@ -131,6 +131,7 @@ public abstract class ViewFlag {
                if (yLocation.distanceSquared(representative.getLocation()) >= 1.0 / 256.0 && yLocation.distanceSquared(previous.getLocation()) >= 1.0 / 256.0) {
                    RBlockDisplay y = new RBlockDisplay(server, yLocation);
                    y.setBlock(Material.WHITE_STAINED_GLASS.createBlockData());
+                    y.setTransform(TraceEntity.TNT_VISUAL_TRANSFORM);
                }

                Location secoundLocation;
@@ -143,6 +144,7 @@ public abstract class ViewFlag {
                if (secoundLocation.distanceSquared(representative.getLocation()) >= 1.0 / 256.0 && secoundLocation.distanceSquared(previous.getLocation()) >= 1.0 / 256.0) {
                    RBlockDisplay second = new RBlockDisplay(server, secoundLocation);
                    second.setBlock(Material.WHITE_STAINED_GLASS.createBlockData());
+                    second.setTransform(TraceEntity.TNT_VISUAL_TRANSFORM);
                }
            }
        }
@@ -51,6 +51,10 @@ public class IsolateFlag extends ViewFlag {
        }
    }

+    public boolean isEmpty() {
+        return tntToIsolate.isEmpty();
+    }
+
    @Override
    public Stream<TNTPoint> filter(Stream<TNTPoint> records) {
        if (tntToIsolate.isEmpty()) return records;
@@ -38,6 +38,7 @@ import org.bukkit.Bukkit;
 import org.bukkit.NamespacedKey;
 import org.bukkit.command.CommandMap;
 import org.bukkit.command.CommandSender;
+import org.bukkit.craftbukkit.CraftServer;
 import org.bukkit.entity.Player;
 import org.bukkit.event.EventHandler;
 import org.bukkit.event.Listener;
@@ -47,7 +48,6 @@ import org.bukkit.inventory.ItemStack;
 import org.bukkit.inventory.meta.ItemMeta;
 import org.bukkit.persistence.PersistentDataType;

-import java.lang.reflect.Field;
 import java.util.Arrays;
 import java.util.Collection;
 import java.util.List;
@@ -73,19 +73,7 @@ public class BindCommand extends SWCommand implements Listener {
        }
    }

-    private static final CommandMap commandMap;
-
-    static {
-        Field knownCommandsField;
-        try {
-            knownCommandsField = Bukkit.getServer().getClass().getDeclaredField("commandMap");
-            knownCommandsField.setAccessible(true);
-            commandMap = (CommandMap) knownCommandsField.get(Bukkit.getServer());
-        } catch (IllegalAccessException | NoSuchFieldException var2) {
-            Bukkit.shutdown();
-            throw new SecurityException("Oh shit. Commands cannot be registered.", var2);
-        }
-    }
+    private static final CommandMap commandMap = ((CraftServer) Bukkit.getServer()).getCommandMap();

    private static final NamespacedKey KEY = SWUtils.getNamespaceKey("command");

@@ -21,7 +21,6 @@ package de.steamwar.bausystem.features.util;

 import com.comphenix.tinyprotocol.TinyProtocol;
 import com.mojang.authlib.GameProfile;
-import de.steamwar.Reflection;
 import de.steamwar.bausystem.BauSystem;
 import de.steamwar.bausystem.features.tpslimit.TPSUtils;
 import de.steamwar.bausystem.utils.BauMemberUpdateEvent;
@@ -30,7 +29,6 @@ import de.steamwar.core.ProtocolWrapper;
 import de.steamwar.core.SWPlayer;
 import de.steamwar.linkage.Linked;
 import net.minecraft.network.protocol.game.*;
-import net.minecraft.server.level.ServerPlayerGameMode;
 import net.minecraft.world.entity.player.Abilities;
 import net.minecraft.world.level.GameType;
 import org.bukkit.Bukkit;
@@ -103,10 +101,8 @@ public class NoClipCommand extends SWCommand implements Listener {
        TinyProtocol.instance.addFilter(ServerboundSetCreativeModeSlotPacket.class, third);
    }

-    private static final Reflection.Field<GameType> playerGameMode = Reflection.getField(ServerPlayerGameMode.class, GameType.class, 0);
-
    private void setInternalGameMode(Player player, GameMode gameMode) {
-        playerGameMode.set(((CraftPlayer) player).getHandle().gameMode, GameType.byId(gameMode.getValue()));
+        ((CraftPlayer) player).getHandle().gameMode.gameModeForPlayer = GameType.byId(gameMode.getValue());
    }

    @Register(help = true)
@@ -143,6 +139,7 @@ public class NoClipCommand extends SWCommand implements Listener {

    @EventHandler(ignoreCancelled = true)
    public void onBlock(BlockCanBuildEvent event) {
+        if (event.getPlayer() == null) return;
        if (SWPlayer.of(event.getPlayer()).hasComponent(NoClipData.class)) {
            event.setBuildable(true);
        }
@@ -20,7 +20,6 @@
 package de.steamwar.bausystem.features.world;

 import de.steamwar.bausystem.BauSystem;
-import de.steamwar.bausystem.Permission;
 import de.steamwar.bausystem.config.BauServer;
 import de.steamwar.core.CRIUWakeupEvent;
 import de.steamwar.linkage.Linked;
@@ -37,13 +36,12 @@ public class AntiBauAddMemberFix implements Listener {
    @EventHandler(priority = EventPriority.LOW)
    public void onPlayerJoin(PlayerJoinEvent event) {
        if (BauSystem.DEV_SERVER) return;
-        if (Permission.SUPERVISOR.hasPermission(event.getPlayer())) {
+        if (event.getPlayer().getUniqueId().equals(BauServer.getInstance().getOwner())) {
            return;
        }
-        if (BauweltMember.getBauMember(BauServer.getInstance().getWorldID(), event.getPlayer().getUniqueId()) == null) {
+        if (BauweltMember.getBauMember(BauServer.getInstance().getOwner(), event.getPlayer().getUniqueId()) == null) {
            event.getPlayer().kickPlayer("");
-            String owner = BauServer.getInstance().isTeamWorld() ? "team " + BauServer.getInstance().getTeamID() : SteamwarUser.byId(BauServer.getInstance().getOwnerID()).getUserName();
-            throw new SecurityException("The player " + event.getPlayer().getName() + " joined on the server of " + owner + " without being added!");
+            throw new SecurityException("The player " + event.getPlayer().getName() + " joined on the server of " + SteamwarUser.byId(BauServer.getInstance().getOwnerID()).getUserName() + " without being added!");
        }
    }

@@ -33,7 +33,7 @@ public class AxiomPermissionCheck implements Listener {

    @EventHandler
    public void onAxiomHandshake(AxiomHandshakeEvent event) {
-        if (Permission.SUPERVISOR.hasPermission(event.getPlayer()) || (BauServer.getInstance().hasOwner() && BauServer.getInstance().getOwner().equals(event.getPlayer().getUniqueId()))) {
+        if (Permission.SUPERVISOR.hasPermission(event.getPlayer()) || BauServer.getInstance().getOwner().equals(event.getPlayer().getUniqueId())) {
            event.setMaxBufferSize(Short.MAX_VALUE);
            return;
        }
@@ -28,7 +28,7 @@ import de.steamwar.data.BauLockState;
 import de.steamwar.linkage.Linked;
 import de.steamwar.network.packets.PacketHandler;
 import de.steamwar.network.packets.server.BaulockUpdatePacket;
-import de.steamwar.sql.SteamwarWorld;
+import de.steamwar.sql.UserConfig;
 import lombok.Getter;
 import org.bukkit.entity.Player;
 import org.bukkit.event.EventHandler;
@@ -37,13 +37,13 @@ import org.bukkit.event.Listener;
@Linked
 public class BauLockStateScoreboard extends PacketHandler implements ScoreboardElement, Listener {

+    private static final String BAU_LOCK_CONFIG_NAME = "baulockstate";
+
    @Getter
    private BauLockState lockState = loadLockState();

    private BauLockState loadLockState() {
-        if (BauServer.getInstance().isTeamWorld()) return BauLockState.OPEN;
-        SteamwarWorld world = SteamwarWorld.getWorld(BauServer.getInstance().getWorldID());
-        String state = world == null ? null : world.getLockState();
+        String state = UserConfig.getConfig(BauServer.getInstance().getOwner(), BAU_LOCK_CONFIG_NAME);
        return state == null ? BauLockState.OPEN : BauLockState.valueOf(state);
    }

@@ -69,7 +69,6 @@ public class BauLockStateScoreboard extends PacketHandler implements ScoreboardE

    @Override
    public String get(Region region, Player p) {
-        if (BauServer.getInstance().isTeamWorld()) return null;
        if (!BauServer.getInstance().getOwner().equals(p.getUniqueId())) {
            return null;
        }
@@ -36,8 +36,6 @@ import org.bukkit.entity.Player;
 import org.bukkit.event.EventHandler;
 import org.bukkit.event.Listener;
 import org.bukkit.event.entity.PlayerDeathEvent;
-import org.bukkit.event.inventory.ClickType;
-import org.bukkit.event.inventory.InventoryClickEvent;
 import org.bukkit.event.player.PlayerItemConsumeEvent;
 import org.bukkit.event.player.PlayerJoinEvent;
 import org.bukkit.event.player.PlayerQuitEvent;
@@ -42,11 +42,7 @@ public class KickallCommand extends SWCommand {
        if (!Permission.OWNER.hasPermission(player)) return;

        Bukkit.getOnlinePlayers().forEach(p -> {
-            if (bauServer.isTeamWorld()) {
-                if (!Permission.SUPERVISOR.hasPermission(p)) p.kickPlayer("");
-            } else if (!bauServer.getOwner().equals(p.getUniqueId())) {
-                p.kickPlayer("");
-            }
+            if (!bauServer.getOwner().equals(p.getUniqueId())) p.kickPlayer("");
        });
    }
 }
@@ -25,6 +25,7 @@ import de.steamwar.bausystem.config.BauServer;
 import de.steamwar.bausystem.utils.BauMemberUpdateEvent;
 import de.steamwar.linkage.Linked;
 import de.steamwar.sql.BauweltMember;
+import de.steamwar.techhider.legacy.TechHider;
 import org.bukkit.Bukkit;
 import org.bukkit.Location;
 import org.bukkit.Material;
@@ -39,7 +40,6 @@ import org.bukkit.event.block.BlockPlaceEvent;
 import org.bukkit.event.entity.EntityPickupItemEvent;
 import org.bukkit.event.player.*;
 import org.bukkit.util.Vector;
-import de.steamwar.techhider.legacy.TechHider;

 import java.util.HashSet;
 import java.util.Set;
@@ -143,14 +143,17 @@ public class SpectatorListener implements Listener {
    public void onPlayerJoin(PlayerJoinEvent event) {
        enableOrDisableTechhider();
        if (BauSystem.DEV_SERVER) return;
-        if (Permission.SUPERVISOR.hasPermission(event.getPlayer())) {
+        if (event.getPlayer().getUniqueId().equals(BauServer.getInstance().getOwner())) {
            return;
        }
-        BauweltMember bauweltMember = BauweltMember.getBauMember(BauServer.getInstance().getWorldID(), event.getPlayer().getUniqueId());
+        BauweltMember bauweltMember = BauweltMember.getBauMember(BauServer.getInstance().getOwner(), event.getPlayer().getUniqueId());
        if (bauweltMember == null) {
            event.getPlayer().kickPlayer("");
            return;
        }
+        if (Permission.SUPERVISOR.hasPermission(event.getPlayer())) {
+            return;
+        }
        if (!anySupervisorOnline(null)) {
            Bukkit.getScheduler().runTaskLater(BauSystem.getInstance(), () -> {
                event.getPlayer().kickPlayer("");
@@ -57,7 +57,7 @@ public class WorldEditListener implements Listener {

    private static final Set<String> commands = new HashSet<>();
    private static final Set<String> commandExclusions = new HashSet<>();
-    private static final String[] shortcutCommands = {"//1", "//2", "//90", "//-90", "//180", "//p", "//c", "//flopy", "//floppy", "//flopyp", "//floppyp", "//u", "//r"};
+    private static final String[] shortcutCommands = {"//1", "//2", "//90", "//-90", "//180", "//p", "//c", "//flopy", "//floppy", "//flopyp", "//floppyp", "//u", "//r", "//download", "/download"};

    public static boolean isWorldEditCommand(String command) {
        for (String shortcut : shortcutCommands) {
@@ -28,6 +28,7 @@ import de.steamwar.command.SWCommand;
 import de.steamwar.core.CraftbukkitWrapper;
 import de.steamwar.linkage.Linked;
 import de.steamwar.linkage.LinkedInstance;
+import de.steamwar.techhider.legacy.TechHider;
 import net.md_5.bungee.api.ChatMessageType;
 import net.minecraft.network.protocol.game.ServerboundMovePlayerPacket;
 import net.minecraft.server.level.ServerPlayer;
@@ -40,7 +41,6 @@ import org.bukkit.event.Listener;
 import org.bukkit.event.block.Action;
 import org.bukkit.event.player.PlayerInteractEvent;
 import org.bukkit.event.player.PlayerQuitEvent;
-import de.steamwar.techhider.legacy.TechHider;

 import java.util.*;
 import java.util.function.BiFunction;
@@ -19,7 +19,6 @@

 package de.steamwar.bausystem.utils;

-import de.steamwar.Reflection;
 import lombok.AllArgsConstructor;
 import lombok.Getter;
 import lombok.experimental.UtilityClass;
@@ -86,9 +85,6 @@ public class PlaceItemUtils {
                .collect(Collectors.toSet());
    }

-    private static final Reflection.Field<?> positionAccessor = Reflection.getField(CraftBlockState.class, BlockPos.class, 0);
-    private static final Reflection.Field<?> worldAccessor = Reflection.getField(CraftBlockState.class, CraftWorld.class, 0);
-
    /**
     * Attempt to place an {@link ItemStack} the {@link Player} is holding against a {@link Block} inside the World.
     * This can be easily used inside the {@link org.bukkit.event.player.PlayerInteractEvent} to mimik placing a
@@ -288,8 +284,9 @@ public class PlaceItemUtils {
        } else {
            // If a BlockState is present set the Position and World to the Block you want to place
            Location blockLocation = block.getLocation();
-            positionAccessor.set(blockState, new BlockPos(blockLocation.getBlockX(), blockLocation.getBlockY(), blockLocation.getBlockZ()));
-            worldAccessor.set(blockState, blockLocation.getWorld());
+            CraftBlockState craftBlockState = (CraftBlockState) blockState;
+            craftBlockState.position = new BlockPos(blockLocation.getBlockX(), blockLocation.getBlockY(), blockLocation.getBlockZ());
+            craftBlockState.world = (CraftWorld) blockLocation.getWorld();
        }

        if (blockData.getMaterial().isSolid()) {
@@ -20,7 +20,6 @@
 package de.steamwar.bausystem.utils;

 import com.comphenix.tinyprotocol.TinyProtocol;
-import de.steamwar.Reflection;
 import de.steamwar.bausystem.BauSystem;
 import net.minecraft.network.protocol.game.ClientboundTickingStatePacket;
 import net.minecraft.server.MinecraftServer;
@@ -33,7 +32,6 @@ public class TickManager implements Listener {
    public static final TickManager impl = new TickManager();

    private static final ServerTickRateManager manager = MinecraftServer.getServer().tickRateManager();
-    private static final Reflection.Field<Long> remainingSprintTicks = Reflection.getField(ServerTickRateManager.class, long.class, 0);

    private boolean blockTpsPacket = true;
    private int totalSteps;
@@ -121,7 +119,7 @@ public class TickManager implements Listener {

    public long getRemainingTicks() {
        if (isSprinting()) {
-            return remainingSprintTicks.get(manager);
+            return manager.remainingSprintTicks;
        } else {
            return manager.frozenTicksToRun();
        }
@@ -19,6 +19,7 @@

 package de.steamwar.bausystem.utils;

+import com.fastasyncworldedit.core.regions.selector.PolyhedralRegionSelector;
 import com.sk89q.worldedit.EditSession;
 import com.sk89q.worldedit.IncompleteRegionException;
 import com.sk89q.worldedit.LocalSession;
@@ -32,16 +33,19 @@ import com.sk89q.worldedit.internal.registry.InputParser;
 import com.sk89q.worldedit.math.BlockVector3;
 import com.sk89q.worldedit.regions.Region;
 import com.sk89q.worldedit.regions.RegionSelector;
+import com.sk89q.worldedit.regions.selector.*;
 import com.sk89q.worldedit.regions.selector.limit.SelectorLimits;
-import de.steamwar.Reflection;
+import com.sk89q.worldedit.world.World;
 import de.steamwar.bausystem.shared.Pair;
 import lombok.SneakyThrows;
 import lombok.experimental.UtilityClass;
 import org.bukkit.Location;
-import org.bukkit.World;
 import org.bukkit.entity.Player;

+import java.util.HashMap;
 import java.util.List;
+import java.util.Map;
+import java.util.function.Function;
 import java.util.stream.Collectors;

@UtilityClass
@@ -91,17 +95,36 @@ public class WorldEditUtils {
                .getRegionSelector(BukkitAdapter.adapt(player.getWorld()));
        return new Pair<>(regionSelector.getClass(), regionSelector.getVertices()
                .stream()
-                .map(blockVector3 -> blockVector3 == null ? null : adapt(player.getWorld(), blockVector3))
+                .map(blockVector3 -> {
+                    if (blockVector3 == null) {
+                        return null;
+                    } else {
+                        return BukkitAdapter.adapt(player.getWorld(), blockVector3);
+                    }
+                })
                .collect(Collectors.toList()));
    }

+    private static final Map<Class<? extends RegionSelector>, Function<World, RegionSelector>> constructors = new HashMap<>();
+    static {
+        constructors.put(CuboidRegionSelector.class, CuboidRegionSelector::new);
+        constructors.put(ExtendingCuboidRegionSelector.class, ExtendingCuboidRegionSelector::new);
+        constructors.put(Polygonal2DRegionSelector.class, Polygonal2DRegionSelector::new);
+        constructors.put(EllipsoidRegionSelector.class, EllipsoidRegionSelector::new);
+        constructors.put(SphereRegionSelector.class, SphereRegionSelector::new);
+        constructors.put(CylinderRegionSelector.class, CylinderRegionSelector::new);
+        constructors.put(ConvexPolyhedralRegionSelector.class, ConvexPolyhedralRegionSelector::new);
+        constructors.put(PolyhedralRegionSelector.class, PolyhedralRegionSelector::new);
+    }
+
    public void setVertices(Player player, Class<? extends RegionSelector> clazz, List<Location> vertices) {
        LocalSession localSession = WorldEdit.getInstance()
                .getSessionManager()
                .get(BukkitAdapter.adapt(player));

-        Reflection.Constructor constructorInvoker = Reflection.getConstructor(clazz, com.sk89q.worldedit.world.World.class);
-        RegionSelector regionSelector = (RegionSelector) constructorInvoker.invoke(BukkitAdapter.adapt(player.getWorld()));
+        Function<World, RegionSelector> constructor = constructors.get(clazz);
+        if (constructor == null) return;
+        RegionSelector regionSelector = constructor.apply(BukkitAdapter.adapt(player.getWorld()));
        localSession.setRegionSelector(BukkitAdapter.adapt(player.getWorld()), regionSelector);

        if (vertices.isEmpty()) return;
@@ -127,13 +150,9 @@ public class WorldEditUtils {
        try {
            BlockVector3 min = regionSelector.getRegion().getMinimumPoint();
            BlockVector3 max = regionSelector.getRegion().getMaximumPoint();
-            return new Pair<>(adapt(player.getWorld(), min), adapt(player.getWorld(), max));
+            return new Pair<>(BukkitAdapter.adapt(player.getWorld(), min), BukkitAdapter.adapt(player.getWorld(), max));
        } catch (IncompleteRegionException e) {
            return null;
        }
    }
-
-    private Location adapt(World world, BlockVector3 blockVector3) {
-        return new Location(world, blockVector3.getBlockX(), blockVector3.getBlockY(), blockVector3.getBlockZ());
-    }
 }
@@ -4,7 +4,7 @@ version: "2.0"
 depend: [ WorldEdit, SpigotCore ]
 load: POSTWORLD
 main: de.steamwar.bausystem.BauSystem
-api-version: "1.13"
+api-version: "1.21"
 website: "https://steamwar.de"
 description: "So unseriös wie wir sind: BauSystem nur besser."

@@ -37,5 +37,6 @@ tasks.register<DevServer>("DevBau21") {
    dependsOn(":SpigotCore:shadowJar")
    dependsOn(":BauSystem:shadowJar")
    dependsOn(":SchematicSystem:shadowJar")
+    dependsOn(":KotlinCore:shadowJar")
    template = "Bau21"
 }
@@ -18,6 +18,7 @@ dependencies {
    implementation("com.github.ajalt.clikt:clikt:5.0.3")
    implementation("com.github.ajalt.mordant:mordant:3.0.2")
    implementation(libs.logback)
+    implementation("org.yaml:snakeyaml:2.2")
    implementation("org.mariadb.jdbc:mariadb-java-client:3.3.1")

    implementation(libs.exposedCore)
@@ -11,23 +11,13 @@ import de.steamwar.commands.profiler.ProfilerCommand
 import de.steamwar.commands.user.UserCommand
 import de.steamwar.commands.user.UserInfoCommand
 import de.steamwar.commands.user.UserSearchCommand
-import de.steamwar.commands.world.MigrationCommand
-import de.steamwar.commands.world.SaveToStorageCommand
-import de.steamwar.commands.world.TemplateCommand
-import de.steamwar.commands.world.TemplateCreateCommand
-import de.steamwar.commands.world.WorldCommand

 fun main(args: Array<String>) =
    SteamWar()
        .subcommands(
            DatabaseCommand().subcommands(InfoCommand(), ResetCommand()),
            UserCommand().subcommands(UserInfoCommand(), UserSearchCommand()),
-            WorldCommand().subcommands(
-                MigrationCommand(),
-                SaveToStorageCommand(),
-                TemplateCommand().subcommands(TemplateCreateCommand())
-            ),
            DevCommand(),
            ProfilerCommand()
        )
-        .main(args)
+        .main(args)
@@ -7,6 +7,7 @@ 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.executeScript
 import de.steamwar.db.useDb
 import java.io.File

@@ -22,13 +23,25 @@ class ResetCommand : CliktCommand() {

            val schema = schemaFile.readText()

-            val tables = execute("SHOW TABLES;") { it.getString(1) }
-            for (table in tables) {
-                execute("DROP TABLE IF EXISTS $table;") { }
+            execute("SET FOREIGN_KEY_CHECKS=0;") { }
+
+            val databaseObjects = execute("SHOW FULL TABLES;") { it.getString(1) to it.getString(2) }
+            for (view in databaseObjects.filter { it.second == "VIEW" }.map { it.first }) {
+                execute("DROP VIEW IF EXISTS `${view.replace("`", "``")}`;") { }
+            }
+            for (table in databaseObjects.filter { it.second == "BASE TABLE" }.map { it.first }) {
+                execute("DROP TABLE IF EXISTS `${table.replace("`", "``")}`;") { }
            }

-            execute(schema) { }
+            executeScript(schema)
+
+            val seed = javaClass.getResource("/db/reset-seed.sql")
+                ?: throw CliktError("Reset seed file not found!")
+
+            executeScript(seed.readText())
+
+            execute("SET FOREIGN_KEY_CHECKS=1;") { }

            echo(TextColors.brightGreen(TextStyles.bold("Database reset!")))
        }
-}
+}
@@ -14,9 +14,11 @@ 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 org.yaml.snakeyaml.Yaml
 import java.io.File
 import kotlin.io.path.absolute
 import kotlin.io.path.absolutePathString
+import kotlin.random.Random

 const val LOG4J_CONFIG = """<?xml version="1.0" encoding="UTF-8"?>
 <Configuration status="WARN" packages="com.mojang.util">
@@ -69,35 +71,47 @@ class DevCommand : CliktCommand("dev") {
    override fun run() {
        val args = mutableListOf<String>()

-        val serverDirectory = File(workingDir, server)
-        val serverDir =
-            if (serverDirectory.exists() && serverDirectory.isDirectory) serverDirectory else File(workingDir, server)
+        var serverDir = resolveServerDirectory(server)

        if (isVelocity(server)) {
            runServer(
                args, jvmArgs, listOf(
                    jar?.absolutePath
-                        ?: File("/jar/Velocity.jar").absolutePath
+                        ?: File("/jars/Velocity.jar").absolutePath
                ), serverDir
            )
        } else {
            setLogConfig(args)
            val version = findVersion(server)
                ?: throw CliktError("Unknown Server Version")
+            val gameModeTemplate = if (serverDir.isDirectory) null else loadGameModeTemplate(server)
+            if (gameModeTemplate != null) {
+                serverDir = gameModeTemplate.serverDir
+                args += "-Dconfig=$server.yml"
+            }
            val worldFile = world?.absolute()?.toFile()
-                ?: File(serverDir, "devtempworld")
-            val jarFile = jar?.absolutePath
+                ?: File(workingDir, "devtempworld")
+            var jarFile = jar?.absolutePath
                ?: additionalVersions[server]?.let { supportedVersionJars[it] }
                ?: supportedVersionJars[version]
                ?: throw CliktError("Unknown Server Version")
+            if (gameModeTemplate != null) {
+                jarFile = if (gameModeTemplate.spigot) {
+                    jarFile.replace("paper", "spigot")
+                } else {
+                    jarFile.replace("spigot", "paper")
+                }
+            }

            if (!worldFile.exists()) {
-                val templateFile = File(serverDir, "Bauwelt")
+                val templateFile = gameModeTemplate?.worldTemplate ?: File(serverDir, "Bauwelt")
                if (!templateFile.exists()) {
-                    throw CliktError("World Template not found!")
+                    throw CliktError("Could not find world template: ${templateFile.absolutePath}")
                }
+                worldFile.parentFile?.mkdirs()
                templateFile.copyRecursively(worldFile)
            }
+            val worldDir = worldFile.parentFile ?: workingDir

            val devFile = File("/configs/DevServer/${System.getProperty("user.name")}.$port.$version")
            if (System.getProperty("user.name") != "minecraft") {
@@ -108,10 +122,11 @@ class DevCommand : CliktCommand("dev") {
                args, jvmArgs, listOf(
                    jarFile,
                    *(if (forceUpgrade) arrayOf("-forceUpgrade") else arrayOf()),
+                    "--log-strip-color",
                    "--port", port.toString(),
                    "--level-name", worldFile.name,
-                    "--world-dir", workingDir.absolutePath,
-                    "--nogui",
+                    "--world-dir", worldDir.absolutePath,
+                    "nogui",
                    *(if (plugins != null) arrayOf("--plugins", plugins!!.absolutePathString()) else arrayOf())
                ), serverDir
            )
@@ -123,6 +138,12 @@ class DevCommand : CliktCommand("dev") {
        }
    }

+    data class GameModeTemplate(
+        val serverDir: File,
+        val worldTemplate: File,
+        val spigot: Boolean
+    )
+
    val jvmDefaultParams = arrayOf(
        "-Xmx1G",
        "-Xgc:excessiveGCratio=80",
@@ -138,6 +159,16 @@ class DevCommand : CliktCommand("dev") {

    val jvmArgOverrides = arrayOf("--add-opens", "java.base/jdk.internal.misc=ALL-UNNAMED")

+    val jvmNonJava8Params = arrayOf(
+        *jvmArgOverrides,
+        "-XX:-CRIUSecProvider"
+    )
+
+    val extendedStartupParams = arrayOf(
+        "-Dpaper.disablePluginRemapping=true",
+        "-javaagent:/jars/AccessWidener.jar=start"
+    )
+
    val supportedVersionJars = mapOf(
        8 to "/jars/paper-1.8.8.jar",
        9 to "/jars/spigot-1.9.4.jar",
@@ -152,8 +183,7 @@ class DevCommand : CliktCommand("dev") {
    )

    val additionalVersions = mapOf(
-        "Tutorial" to 15,
-        "Lobby" to 20
+        "Lobby" to 21
    )

    fun findVersion(server: String): Int? =
@@ -166,6 +196,41 @@ class DevCommand : CliktCommand("dev") {
    fun isVelocity(server: String): Boolean =
        server.endsWith("Velocity")

+    fun resolveServerDirectory(server: String): File {
+        val localServer = File(workingDir, server)
+        if (localServer.isDirectory) {
+            return localServer
+        }
+        return File("/servers", server)
+    }
+
+    fun loadGameModeTemplate(server: String): GameModeTemplate? {
+        val configFile = File("/configs/GameModes/$server.yml")
+        if (!configFile.exists()) {
+            throw CliktError("Server/GameMode not found")
+        }
+
+        val document = configFile.reader().use { reader ->
+            Yaml().load<Map<String, Any?>>(reader)
+        } ?: throw CliktError("GameMode config is empty: ${configFile.absolutePath}")
+        val serverConfig = document["Server"] as? Map<*, *>
+            ?: throw CliktError("GameMode config is missing Server section: ${configFile.absolutePath}")
+        val folder = serverConfig["Folder"] as? String
+            ?: throw CliktError("GameMode config is missing Server.Folder: ${configFile.absolutePath}")
+        val maps = (serverConfig["Maps"] as? List<*>)
+            ?.filterIsInstance<String>()
+            ?.takeIf { it.isNotEmpty() }
+            ?: throw CliktError("GameMode config is missing Server.Maps: ${configFile.absolutePath}")
+
+        val serverDir = File("/servers", folder)
+        val worldTemplate = File(File(serverDir, "arenas"), maps[Random.nextInt(maps.size)])
+        return GameModeTemplate(
+            serverDir = serverDir,
+            worldTemplate = worldTemplate,
+            spigot = serverConfig["Spigot"] == true
+        )
+    }
+
    fun setLogConfig(args: MutableList<String>) {
        args += "-DlogPath=${workingDir.absolutePath}/logs"
        args += "-Dlog4j.configurationFile=${log4jConfig.absolutePath}"
@@ -176,13 +241,23 @@ class DevCommand : CliktCommand("dev") {
    }

    fun runServer(args: List<String>, jvmArgs: List<String>, cmd: List<String>, serverDir: File) {
+        val effectiveJvmArgs = mutableListOf<String>()
+        effectiveJvmArgs += jvmArgs
+        if (!isVelocity(server)) {
+            extendedStartupParams.forEach { arg ->
+                if (effectiveJvmArgs.none { it == arg }) {
+                    effectiveJvmArgs += arg
+                }
+            }
+        }
+
        val process = ProcessBuilder(
            jvm?.absolutePath
-                ?: if (isJava8(server)) "/usr/lib/jvm/openj9-8/bin/java" else "java",
-            *jvmArgs.toTypedArray(),
+                ?: if (isJava8(server)) "/usr/lib/jvm/openj9-8/bin/java" else "/usr/lib/jvm/openj9-21/bin/java",
+            *effectiveJvmArgs.toTypedArray(),
            *args.toTypedArray(),
            *jvmDefaultParams,
-            *(if (isJava8(server)) arrayOf() else jvmArgOverrides),
+            *(if (isJava8(server)) arrayOf() else jvmNonJava8Params),
            *(if (profile) arrayOf("-javaagent:/jars/LixfelsProfiler.jar=start") else arrayOf()),
            "-Xshareclasses:nonfatal,name=$server",
            "-jar",
@@ -191,4 +266,4 @@ class DevCommand : CliktCommand("dev") {
        Runtime.getRuntime().addShutdownHook(Thread { if (process.isAlive) process.destroyForcibly() })
        process.waitFor()
    }
-}
+}
@@ -1,243 +0,0 @@
-package de.steamwar.commands.world
-
-import com.github.ajalt.clikt.core.CliktCommand
-import de.steamwar.db.Database
-import de.steamwar.sql.SteamwarUser
-import de.steamwar.sql.SteamwarWorld
-import de.steamwar.sql.UserConfig
-import org.jetbrains.exposed.v1.jdbc.transactions.transaction
-import java.io.File
-import java.sql.SQLException
-import java.util.UUID
-
-class MigrationCommand : CliktCommand(name = "migrate") {
-    private val userWorldPattern = Regex("""userworlds(\d+)""")
-    private val builderWorldPattern = Regex("""builder(\d+)""")
-    private val trailingVersionPattern = Regex("""(\d+)$""")
-
-    override fun run() {
-        Database.ensureConnected()
-
-        val bau = migrateBauWorlds()
-        val builder = migrateBuilderWorlds()
-        val arena = migrateArenaWorlds()
-        migrateBauLockConfig()
-        migrateBauweltMembers()
-
-        echo("Imported ${bau.imported} build worlds, skipped ${bau.skipped}, missing users ${bau.missingOwner}.")
-        echo("Imported ${builder.imported} builder worlds, skipped ${builder.skipped}.")
-        echo("Imported ${arena.imported} arena worlds, skipped ${arena.skipped}.")
-        echo("World migration completed.")
-    }
-
-    private fun migrateBauWorlds(): MigrationStats {
-        val stats = MigrationStats()
-        val worldsRoot = File("/worlds")
-        worldsRoot.listFiles { file -> file.isDirectory && userWorldPattern.matches(file.name) }
-            ?.forEach { versionFolder ->
-                val version = userWorldPattern.matchEntire(versionFolder.name)!!.groupValues[1].toInt()
-                versionFolder.listFiles { file -> file.isDirectory && isWorldDirectory(file) }
-                    ?.sortedBy { it.name }
-                    ?.forEach { legacyWorld ->
-                        val owner = legacyWorld.ownerUser()
-                        if (owner == null) {
-                            stats.missingOwner++
-                            echo("Skipped build world ${legacyWorld.path}: no matching user.")
-                            return@forEach
-                        }
-
-                        val lockState = UserConfig.getConfig(owner.id.value, BAU_LOCK_CONFIG_NAME)
-                        val world = SteamwarWorld.getOrCreateBauWorld(owner, owner.userName, version, legacyWorld)
-                        if (world.lockState == null && lockState != null) {
-                            world.changeLockState(lockState)
-                        }
-                        stats.imported++
-                    }
-            } ?: run {
-            stats.skipped++
-            echo("Skipped build worlds: /worlds does not exist.")
-        }
-        return stats
-    }
-
-    private fun migrateBuilderWorlds(): MigrationStats {
-        val stats = MigrationStats()
-        val worldsRoot = File("/worlds")
-        worldsRoot.listFiles { file -> file.isDirectory && builderWorldPattern.matches(file.name) }
-            ?.forEach { versionFolder ->
-                val version = builderWorldPattern.matchEntire(versionFolder.name)!!.groupValues[1].toInt()
-                versionFolder.listFiles { file -> file.isDirectory && isWorldDirectory(file) }
-                    ?.sortedBy { it.name }
-                    ?.forEach { legacyWorld ->
-                        SteamwarWorld.getOrCreateBuilderWorld(legacyWorld.name, version, legacyWorld)
-                        stats.imported++
-                    }
-            } ?: run {
-            stats.skipped++
-            echo("Skipped builder worlds: /worlds does not exist.")
-        }
-        return stats
-    }
-
-    private fun migrateArenaWorlds(): MigrationStats {
-        val stats = MigrationStats()
-        val configs = parseGameModeConfigs(File("/configs/GameModes"))
-        if (configs.isEmpty()) {
-            stats.skipped++
-            echo("Skipped arena worlds: no game mode configs found in /configs/GameModes.")
-            return stats
-        }
-
-        for (config in configs) {
-            val version = trailingVersionPattern.find(config.serverFolder)?.value?.toIntOrNull()
-            if (version == null) {
-                stats.skipped++
-                echo("Skipped arena mode ${config.modeName}: server folder '${config.serverFolder}' has no version suffix.")
-                continue
-            }
-
-            val arenaRoot = File("/servers/${config.serverFolder}/arenas")
-            for (map in config.maps) {
-                val legacyWorld = File(arenaRoot, map)
-                if (!isWorldDirectory(legacyWorld)) {
-                    stats.skipped++
-                    continue
-                }
-
-                SteamwarWorld.getOrCreateArenaWorld(config.modeName, map, version, legacyWorld)
-                stats.imported++
-            }
-        }
-
-        return stats
-    }
-
-    private fun migrateBauLockConfig() {
-        transaction(Database.db) {
-            exec(
-                """
-                UPDATE `world` w
-                JOIN `UserConfig` uc ON uc.`User` = w.`Owner` AND uc.`Config` = 'baulockstate'
-                SET w.`LockState` = uc.`Value`
-                WHERE w.`Owner` IS NOT NULL AND w.`LockState` IS NULL
-                """.trimIndent()
-            )
-        }
-    }
-
-    private fun migrateBauweltMembers() {
-        if (!columnExists("BauweltMember", "WorldID") || !columnExists("BauweltMember", "BauweltID")) {
-            echo("Skipped BauweltMember data migration: expected WorldID and BauweltID columns are not both present.")
-            return
-        }
-
-        execIgnore(
-            """
-            INSERT IGNORE INTO `BauweltMember` (`WorldID`, `MemberID`, `Build`, `WorldEdit`, `World`)
-            SELECT w.`id`, bm.`MemberID`, bm.`Build`, bm.`WorldEdit`, bm.`World`
-            FROM `BauweltMember` bm
-            JOIN `world` w ON w.`Owner` = bm.`BauweltID` AND w.`Deleted` = 0
-            """.trimIndent(),
-            "Skipped BauweltMember data migration"
-        )
-    }
-
-    private fun parseGameModeConfigs(configRoot: File): List<ArenaMigrationConfig> {
-        if (!configRoot.isDirectory) return emptyList()
-
-        return configRoot.listFiles { file -> file.isFile && file.extension == "yml" && !file.name.endsWith(".kits.yml") }
-            ?.mapNotNull { file ->
-                val server = parseServerBlock(file)
-                val folder = server.folder ?: return@mapNotNull null
-                ArenaMigrationConfig(file.nameWithoutExtension, folder, server.maps)
-            }
-            ?: emptyList()
-    }
-
-    private fun parseServerBlock(file: File): ParsedServerBlock {
-        var inServer = false
-        var inMaps = false
-        var folder: String? = null
-        val maps = mutableListOf<String>()
-
-        file.readLines().forEach { line ->
-            val trimmed = line.trim()
-            if (trimmed.isEmpty() || trimmed.startsWith("#")) return@forEach
-
-            val indent = line.indexOfFirst { !it.isWhitespace() }.let { if (it == -1) 0 else it }
-            if (indent == 0) {
-                inServer = trimmed == "Server:"
-                inMaps = false
-                return@forEach
-            }
-
-            if (!inServer) return@forEach
-
-            when {
-                indent <= 2 && trimmed.startsWith("Folder:") -> folder = trimmed.substringAfter(":").cleanYamlValue()
-                indent <= 2 && trimmed.startsWith("Maps:") -> {
-                    val value = trimmed.substringAfter(":").trim()
-                    inMaps = true
-                    if (value.startsWith("[") && value.endsWith("]")) {
-                        maps += value.removePrefix("[").removeSuffix("]")
-                            .split(",")
-                            .map { it.cleanYamlValue() }
-                            .filter { it.isNotEmpty() }
-                        inMaps = false
-                    }
-                }
-                inMaps && trimmed.startsWith("-") -> maps += trimmed.removePrefix("-").cleanYamlValue()
-                inMaps && indent <= 2 -> inMaps = false
-            }
-        }
-
-        return ParsedServerBlock(folder, maps)
-    }
-
-    private fun File.ownerUser(): SteamwarUser? {
-        name.toIntOrNull()?.let { return SteamwarUser.byId(it) }
-        return runCatching { SteamwarUser.get(UUID.fromString(name)) }.getOrNull()
-    }
-
-    private fun isWorldDirectory(file: File): Boolean =
-        file.isDirectory && (File(file, "level.dat").isFile || File(file, "region").isDirectory)
-
-    private fun String.cleanYamlValue(): String =
-        trim().trim('"').trim('\'')
-
-    private fun columnExists(table: String, column: String): Boolean =
-        transaction(Database.db) {
-            exec("SHOW COLUMNS FROM `$table` LIKE '$column'") { result -> result.next() } ?: false
-        }
-
-    private fun execIgnore(sql: String, prefix: String) {
-        try {
-            transaction(Database.db) {
-                exec(sql)
-            }
-        } catch (e: SQLException) {
-            echo("$prefix: ${e.message}")
-        }
-    }
-
-    private data class MigrationStats(
-        var imported: Int = 0,
-        var skipped: Int = 0,
-        var missingOwner: Int = 0,
-    )
-
-    private data class ArenaMigrationConfig(
-        val modeName: String,
-        val serverFolder: String,
-        val maps: List<String>,
-    )
-
-    private data class ParsedServerBlock(
-        val folder: String?,
-        val maps: List<String>,
-    )
-
-    private companion object {
-        private const val BAU_LOCK_CONFIG_NAME = "baulockstate"
-    }
-}
@@ -1,30 +0,0 @@
-package de.steamwar.commands.world
-
-import com.github.ajalt.clikt.core.CliktCommand
-import de.steamwar.db.Database
-import de.steamwar.sql.SteamwarWorld
-import java.time.LocalTime
-
-class SaveToStorageCommand : CliktCommand(name = "saveToStorage") {
-    override fun run() {
-        Database.ensureConnected()
-
-        var archived = 0
-        for (world in SteamwarWorld.getWorldsToArchive()) {
-            if (!beforeCutoff()) {
-                echo("Stopping before 04:00. Archived $archived worlds.")
-                return
-            }
-
-            if (world.archiveIfNeeded()) {
-                archived++
-                echo("Archived ${world.uuid} (${world.type}/${world.name}).")
-            }
-        }
-
-        echo("Storage save completed. Archived $archived worlds.")
-    }
-
-    private fun beforeCutoff(): Boolean =
-        LocalTime.now().isBefore(LocalTime.of(4, 0))
-}
@@ -1,24 +0,0 @@
-package de.steamwar.commands.world
-
-import com.github.ajalt.clikt.core.CliktCommand
-import com.github.ajalt.clikt.parameters.arguments.argument
-import com.github.ajalt.clikt.parameters.types.int
-import com.github.ajalt.clikt.parameters.types.path
-import de.steamwar.db.Database
-import de.steamwar.sql.SteamwarWorld
-
-class TemplateCommand : CliktCommand(name = "template") {
-    override fun run() = Unit
-}
-
-class TemplateCreateCommand : CliktCommand(name = "create") {
-    private val name by argument()
-    private val version by argument().int()
-    private val source by argument().path(canBeFile = false, mustExist = true)
-
-    override fun run() {
-        Database.ensureConnected()
-        SteamwarWorld.getOrCreateTemplateWorld(name, version, source.toFile())
-        echo("Template world '$name' created.")
-    }
-}
@@ -1,7 +0,0 @@
-package de.steamwar.commands.world
-
-import com.github.ajalt.clikt.core.CliktCommand
-
-class WorldCommand : CliktCommand(name = "world") {
-    override fun run() = Unit
-}
@@ -16,15 +16,14 @@ import java.sql.ResultSet
 import java.util.*

 object Database {
-    lateinit var host: String
-    lateinit var port: String
-    lateinit var database: String
+    val host: String
+    val port: String
+    val database: String
+    val username: String
+    val password: String
    lateinit var db: Database

-    fun ensureConnected() {
-        if (::db.isInitialized) {
-            return
-        }
+    init {
        val config = File(System.getProperty("user.home"), "mysql.properties")

        if (!config.exists()) {
@@ -38,9 +37,14 @@ object Database {
        host = props.getProperty("host")
        port = props.getProperty("port")
        database = props.getProperty("database")
+        username = props.getProperty("user")
+        password = props.getProperty("password")
+    }

-        val username = props.getProperty("user")
-        val password = props.getProperty("password")
+    fun ensureConnected() {
+        if (::db.isInitialized) {
+            return
+        }

        val url = "jdbc:mariadb://$host:$port/$database"

@@ -79,6 +83,113 @@ fun <T> JdbcTransaction.executeSingle(sql: String, transform: (ResultSet) -> T):
    }.single()
 }

+fun JdbcTransaction.executeScript(sql: String) {
+    for (statement in splitSqlScript(sql)) {
+        exec(statement) { }
+    }
+}
+
+private fun splitSqlScript(sql: String): List<String> {
+    val statements = mutableListOf<String>()
+    val current = StringBuilder()
+    var quote: Char? = null
+    var inLineComment = false
+    var inBlockComment = false
+    var index = 0
+
+    fun addStatement() {
+        val statement = current.toString().trim()
+        if (statement.isNotEmpty()) {
+            statements += statement
+        }
+        current.clear()
+    }
+
+    while (index < sql.length) {
+        val char = sql[index]
+        val next = sql.getOrNull(index + 1)
+
+        if (inLineComment) {
+            current.append(char)
+            if (char == '\n') {
+                inLineComment = false
+            }
+            index++
+            continue
+        }
+
+        if (inBlockComment) {
+            current.append(char)
+            if (char == '*' && next == '/') {
+                current.append(next)
+                inBlockComment = false
+                index += 2
+            } else {
+                index++
+            }
+            continue
+        }
+
+        if (quote != null) {
+            current.append(char)
+            if (char == '\\' && quote != '`' && next != null) {
+                current.append(next)
+                index += 2
+                continue
+            }
+            if (char == quote) {
+                if (next == quote) {
+                    current.append(next)
+                    index += 2
+                    continue
+                }
+                quote = null
+            }
+            index++
+            continue
+        }
+
+        when {
+            char == '-' && next == '-' -> {
+                current.append(char).append(next)
+                inLineComment = true
+                index += 2
+            }
+
+            char == '#' -> {
+                current.append(char)
+                inLineComment = true
+                index++
+            }
+
+            char == '/' && next == '*' -> {
+                current.append(char).append(next)
+                inBlockComment = true
+                index += 2
+            }
+
+            char == '\'' || char == '"' || char == '`' -> {
+                current.append(char)
+                quote = char
+                index++
+            }
+
+            char == ';' -> {
+                addStatement()
+                index++
+            }
+
+            else -> {
+                current.append(char)
+                index++
+            }
+        }
+    }
+
+    addStatement()
+    return statements
+}
+
 fun useDb(statement: JdbcTransaction.() -> Unit) {
    de.steamwar.db.Database.ensureConnected()
    transaction(de.steamwar.db.Database.db, statement = statement)
@@ -19,6 +19,7 @@

 package de.steamwar.sql

+import de.steamwar.sql.BauweltMemberTable.bauweltId
 import de.steamwar.sql.internal.useDb
 import org.jetbrains.exposed.v1.core.and
 import org.jetbrains.exposed.v1.core.dao.id.CompositeID
@@ -31,37 +32,45 @@ import org.jetbrains.exposed.v1.jdbc.insertIgnore
 import java.util.*

 object BauweltMemberTable : CompositeIdTable("BauweltMember") {
-    val worldId = reference("WorldID", WorldTable).index()
+    val bauweltId = reference("BauweltID", SteamwarUserTable).index()
    val memberId = reference("MemberID", SteamwarUserTable).index()
    val build = bool("Build")
    val worldEdit = bool("WorldEdit")
    val world = bool("World")

-    override val primaryKey = PrimaryKey(worldId, memberId)
+    override val primaryKey = PrimaryKey(bauweltId, memberId)

    init {
-        addIdColumn(worldId)
+        addIdColumn(bauweltId)
        addIdColumn(memberId)
    }
 }

 class BauweltMember(id: EntityID<CompositeID>) : CompositeEntity(id) {
    companion object : CompositeEntityClass<BauweltMember>(BauweltMemberTable) {
-        private val cache = mutableMapOf<Pair<UUID, Int>, BauweltMember>()
+        private val cache = mutableMapOf<Int, BauweltMember>()

        private fun cache(member: BauweltMember) =
-            cache.put(member.worldID to member.memberID, member)
+            cache.put(member.memberID, member)

        @JvmStatic
        fun clear() =
            cache.clear()

        @JvmStatic
-        fun addMember(worldId: UUID, newMemberId: Int) =
+        @Deprecated("Use addMember(ownerId: Int, newMemberId: Int)")
+        fun addMember(ownerId: UUID, newMemberId: UUID) =
+            addMember(SteamwarUser.get(ownerId)!!.id, SteamwarUser.get(newMemberId)!!.id)
+
+        @JvmStatic
+        fun addMember(ownerId: Int, newMemberId: Int) =
+            addMember(EntityID(ownerId, SteamwarUserTable), EntityID(newMemberId, SteamwarUserTable))
+
+        fun addMember(ownerId: EntityID<Int>, newMemberId: EntityID<Int>) =
            useDb {
                BauweltMemberTable.insertIgnore {
-                    it[BauweltMemberTable.worldId] = EntityID(worldId, WorldTable)
-                    it[memberId] = EntityID(newMemberId, SteamwarUserTable)
+                    it[bauweltId] = ownerId
+                    it[memberId] = newMemberId
                    it[build] = false
                    it[worldEdit] = false
                    it[world] = false
@@ -69,32 +78,31 @@ class BauweltMember(id: EntityID<CompositeID>) : CompositeEntity(id) {
            }

        @JvmStatic
-        fun addMember(worldId: UUID, newMemberId: UUID) =
-            addMember(worldId, SteamwarUser.get(newMemberId)!!.id.value)
-
-        @JvmStatic
-        fun getBauMember(world: UUID, member: Int) =
-            cache[world to member]
-                ?: useDb {
-                    find { (BauweltMemberTable.worldId eq world) and (BauweltMemberTable.memberId eq member) }.firstOrNull()?.also { cache(it) }
-                }
-
-        @JvmStatic
-        fun getBauMember(world: UUID, member: UUID) =
-            getBauMember(world, SteamwarUser.get(member)!!.id.value)
-
-        @JvmStatic
-        fun getWorldMembers(world: UUID) =
+        @Deprecated("Use getBauMember(bauwelt: Int, member: Int)")
+        fun getBauMember(bauwelt: UUID, member: UUID) =
            useDb {
-                find { BauweltMemberTable.worldId eq world }.toList().also { it.forEach { cache(it) } }
+                find { (bauweltId eq SteamwarUser.get(bauwelt)!!.id) and (BauweltMemberTable.memberId eq SteamwarUser.get(member)!!.id) }.firstOrNull()?.also { cache(it) }
            }

        @JvmStatic
-        fun getMembers(world: UUID) =
-            getWorldMembers(world)
+        fun getBauMember(bauwelt: Int, member: Int) =
+            useDb {
+                find { (bauweltId eq bauwelt) and (BauweltMemberTable.memberId eq member) }.firstOrNull()?.also { cache(it) }
+            }
+
+        @JvmStatic
+        @Deprecated("Use getMembers(bauwelt: Int)")
+        fun getMembers(bauwelt: UUID) =
+            getMembers(SteamwarUser.get(bauwelt)!!.id.value)
+
+        @JvmStatic
+        fun getMembers(bauwelt: Int) =
+            useDb {
+                find { bauweltId eq bauwelt }.toList().also { it.forEach { cache(it) } }
+            }
    }

-    val worldID by BauweltMemberTable.worldId.transform({ EntityID(it, WorldTable) }, { it.value })
+    val bauweltID by BauweltMemberTable.bauweltId.transform({ EntityID(it, SteamwarUserTable) }, { it.value })
    val memberID by BauweltMemberTable.memberId.transform({ EntityID(it, SteamwarUserTable) }, { it.value })
    private var worldEditInternal by BauweltMemberTable.worldEdit
    var worldEdit: Boolean
@@ -136,4 +144,4 @@ class BauweltMember(id: EntityID<CompositeID>) : CompositeEntity(id) {
        useDb {
            delete()
        }
-}
+}
@@ -86,6 +86,24 @@ class CheckedSchematic(id: EntityID<CompositeID>) : CompositeEntity(id) {
            useDb {
                find { (CheckedSchematicTable.nodeOwner eq owner.id) and (CheckedSchematicTable.seen eq false) }.orderBy(CheckedSchematicTable.endTime to SortOrder.DESC).toList()
            }
+
+        @JvmStatic
+        fun countAccepted(owner: SteamwarUser) =
+            useDb {
+                find { (CheckedSchematicTable.nodeOwner eq owner.id) and (CheckedSchematicTable.declineReason eq "freigegeben") }.count()
+            }
+
+        @JvmStatic
+        fun countAccepted(owner: SteamwarUser, type: String) =
+            useDb {
+                find { (CheckedSchematicTable.nodeOwner eq owner.id) and (CheckedSchematicTable.declineReason eq "freigegeben") and (CheckedSchematicTable.nodeType like "$type%") }.count()
+            }
+
+        @JvmStatic
+        fun countChecked(validator: SteamwarUser) =
+            useDb {
+                find { CheckedSchematicTable.validator eq validator.id }.count()
+            }
    }

    val node by CheckedSchematicTable.nodeId.transform({ it?.let { EntityID(it, SchematicNodeTable) } }, { it?.value })
@@ -130,6 +130,43 @@ class EventFight(id: EntityID<Int>) : IntEntity(id), Comparable<EventFight> {
                    }
                )
            }
+
+        @JvmStatic
+        fun countEventFights(fighter: SteamwarUser) =
+            useDb {
+                exec(
+                    "SELECT COUNT(DISTINCT F.FightID) AS FightCount FROM FightPlayer INNER JOIN Fight F on FightPlayer.FightID = F.FightID INNER JOIN EventFight EF on F.FightID = EF.Fight WHERE UserID = ?",
+                    args = listOf(IntegerColumnType() to fighter.id.value)
+                ) {
+                    if (it.next()) {
+                        it.getLong("FightCount")
+                    } else {
+                        0
+                    }
+                }
+                    ?: 0
+            }
+
+        @JvmStatic
+        fun countPlacement(fighter: SteamwarUser, placement: Int) =
+            useDb {
+                exec(
+                    """
+                        SELECT COUNT(DISTINCT EventFight.EventID) AS PlacementCount FROM TeamTeilnahme
+                            INNER JOIN EventFight ON EventFight.EventID = TeamTeilnahme.EventID
+                            INNER JOIN FightPlayer ON FightPlayer.FightID = EventFight.Fight
+                        WHERE (IF(FightPlayer.Team = 1, EventFight.TeamBlue, EventFight.TeamRed)) = TeamTeilnahme.TeamID AND UserID = ? AND Placement = ?
+                    """.trimIndent(),
+                    args = listOf(IntegerColumnType() to fighter.id.value, IntegerColumnType() to placement)
+                ) {
+                    if (it.next()) {
+                        it.getInt("PlacementCount")
+                    } else {
+                        0
+                    }
+                }
+                    ?: 0
+            }
    }

    val fightID by EventFightTable.id.transform({ EntityID(it, EventFightTable) }, { it.value })
@@ -200,6 +237,7 @@ class EventFight(id: EntityID<Int>) : IntEntity(id), Comparable<EventFight> {

    override fun delete() =
        useDb {
+            EventRelation.deleteRelations(this@EventFight)
            super.delete()
        }
-}
+}
@@ -159,10 +159,13 @@ class EventGroup(id: EntityID<Int>) : IntEntity(id) {
        }

    override fun delete() =
-        useDb { super.delete() }
+        useDb {
+            EventRelation.deleteRelations(this@EventGroup)
+            super.delete()
+        }

    enum class EventGroupType {
        GROUP_STAGE,
        ELIMINATION_STAGE
    }
-}
+}
@@ -24,8 +24,10 @@ import org.jetbrains.exposed.v1.core.and
 import org.jetbrains.exposed.v1.core.dao.id.EntityID
 import org.jetbrains.exposed.v1.core.dao.id.IntIdTable
 import org.jetbrains.exposed.v1.core.eq
+import org.jetbrains.exposed.v1.core.or
 import org.jetbrains.exposed.v1.dao.IntEntity
 import org.jetbrains.exposed.v1.dao.IntEntityClass
+import org.jetbrains.exposed.v1.jdbc.deleteWhere
 import org.jetbrains.exposed.v1.jdbc.select

 object EventRelationTable : IntIdTable("EventRelation") {
@@ -59,6 +61,23 @@ class EventRelation(id: EntityID<Int>) : IntEntity(id) {
        fun getGroupRelations(group: EventGroup) =
            useDb { find { (EventRelationTable.fromId eq group.id.value) and (EventRelationTable.fromType eq FromType.GROUP) }.toList() }

+        @JvmStatic
+        fun deleteRelations(fight: EventFight) =
+            useDb {
+                EventRelationTable.deleteWhere {
+                    (EventRelationTable.fightId eq fight.id) or
+                        ((EventRelationTable.fromId eq fight.id.value) and (EventRelationTable.fromType eq FromType.FIGHT))
+                }
+            }
+
+        @JvmStatic
+        fun deleteRelations(group: EventGroup) =
+            useDb {
+                EventRelationTable.deleteWhere {
+                    (EventRelationTable.fromId eq group.id.value) and (EventRelationTable.fromType eq FromType.GROUP)
+                }
+            }
+
        @JvmStatic
        fun create(fight: EventFight, fightTeam: FightTeam, fromType: FromType, fromId: Int, fromPlace: Int) =
            useDb {
@@ -159,4 +178,4 @@ class EventRelation(id: EntityID<Int>) : IntEntity(id) {
    enum class FromType {
        FIGHT, GROUP
    }
-}
+}
@@ -20,9 +20,12 @@
 package de.steamwar.sql

 import de.steamwar.sql.internal.useDb
+import org.jetbrains.exposed.v1.core.IntegerColumnType
+import org.jetbrains.exposed.v1.core.VarCharColumnType
 import org.jetbrains.exposed.v1.core.dao.id.CompositeID
 import org.jetbrains.exposed.v1.core.dao.id.CompositeIdTable
 import org.jetbrains.exposed.v1.core.dao.id.EntityID
+import org.jetbrains.exposed.v1.core.eq
 import org.jetbrains.exposed.v1.core.inList
 import org.jetbrains.exposed.v1.dao.CompositeEntity
 import org.jetbrains.exposed.v1.dao.CompositeEntityClass
@@ -69,6 +72,28 @@ class FightPlayer(id: EntityID<CompositeID>) : CompositeEntity(id) {
            useDb {
                find { FightPlayerTable.fightId inList fightIds.toList() }.toList()
            }
+
+        @JvmStatic
+        fun countFights(userId: Int) =
+            useDb {
+                find { FightPlayerTable.userId eq userId }.count()
+            }
+
+        @JvmStatic
+        fun countFights(userId: Int, type: String) =
+            useDb {
+                exec(
+                    "SELECT COUNT(*) AS FightCount FROM FightPlayer INNER JOIN Fight F on FightPlayer.FightID = F.FightID WHERE UserID = ? AND GameMode LIKE ?",
+                    args = listOf(IntegerColumnType() to userId, VarCharColumnType() to "$type%")
+                ) {
+                    if (it.next()) {
+                        it.getInt("FightCount")
+                    } else {
+                        0
+                    }
+                }
+                    ?: 0
+            }
    }

    val fightID by FightPlayerTable.fightId.transform({ EntityID(it, FightTable) }, { it.value })
@@ -146,12 +146,12 @@ public final class GameModeConfig<M, W> {
    public final List<String> CheckQuestions;

    /**
-     * The allowed checkers to check this schematic type denoted by a list of SteamWar ids.
+     * The allowed checkers to check this schematic type denoted by a list of SteamwarUser ids.
     * The people need the {@link UserPerm#CHECK} to be able to check though.
     *
     * @implSpec {@code []} by default -> denoting every person with {@link UserPerm#CHECK} can check it
     */
-    public final List<Integer> Checkers;
+    public final Set<Integer> Checkers;

    /**
     * Bundle for countdowns during the fight
@@ -246,7 +246,7 @@ public final class GameModeConfig<M, W> {
        }

        CheckQuestions = loader.getStringList("CheckQuestions");
-        Checkers = loader.getIntList("Checkers");
+        Checkers = loader.getIntSet("Checkers");
        Times = new TimesConfig(loader.with("Times"));
        // Arena would be here to be in config order but needs Schematic.Size and EnterStages loaded afterwards
        Schematic = new SchematicConfig<>(loader.with("Schematic"));
@@ -488,6 +488,27 @@ public final class GameModeConfig<M, W> {
         */
        public final boolean NoFloor;

+        /**
+         * Allows Wind Charges to cross the Middle.
+         *
+         * @implSpec {@code false} by default
+         */
+        public final boolean WindchargesCanCrossMiddle;
+
+        /**
+         * Allows Wind Charge interaction with Blocks.
+         *
+         * @implSpec {@code true} by default
+         */
+        public final boolean WindchargesInteractWithBlocks;
+
+        /**
+         * Allows Wind Charge to destroy Water.
+         *
+         * @implSpec {@code false} by default
+         */
+        public final boolean WindchargesDestroyWater;
+
        private ArenaConfig(YMLWrapper<M, W> loader, SchematicConfig.SizeConfig Size, List<Integer> EnterStages) {
            loaded = loader.canLoad();
            WaterDepth = loader.getInt("WaterDepth", 0);
@@ -505,6 +526,9 @@ public final class GameModeConfig<M, W> {
            Leaveable = loader.getBoolean("Leaveable", false);
            AllowMissiles = loader.getBoolean("AllowMissiles", !EnterStages.isEmpty());
            NoFloor = loader.getBoolean("NoFloor", false);
+            WindchargesCanCrossMiddle = loader.getBoolean("WindchargesCanCrossMiddle", false);
+            WindchargesInteractWithBlocks = loader.getBoolean("WindchargesInteractWithBlocks", true);
+            WindchargesDestroyWater = loader.getBoolean("WindchargesDestroyWater", false);
        }

        @ToString
@@ -929,6 +953,13 @@ public final class GameModeConfig<M, W> {
         */
        public final boolean PersonalKits;

+        /**
+         * Maximal blast resistance for the blocks in the kit
+         *
+         * @implSpec {@code 9.0} by default
+         */
+        public final double MaxBlastResistance;
+
        /**
         * Items (Valid spigot material values) that are not allowed in the personal kit
         */
@@ -940,7 +971,10 @@ public final class GameModeConfig<M, W> {
            MemberDefault = loader.getString("MemberDefault", "default");
            LeaderDefault = loader.getString("LeaderDefault", "default");
            PersonalKits = loader.getBoolean("PersonalKits", false);
-            ForbiddenItems = loader.getMaterialList("ForbiddenItems");
+            MaxBlastResistance = loader.getDouble("MaxBlastResistance", 9.0);
+            List forbiddenItems = new ArrayList<>(loader.getMaterialList("ForbiddenItems"));
+            forbiddenItems.addAll(SQLWrapper.impl.getMaterialWithGreaterBlastResistance(MaxBlastResistance));
+            ForbiddenItems = Collections.unmodifiableList(forbiddenItems);
        }
    }

@@ -50,8 +50,6 @@ enum class UserPerm {
    PUNISHMENTS,
    TICKET_LOG,
    BUILD,
-    BUILD_EXTRA_WORLDS,
-    BUILD_UNLIMITED_WORLDS,
    CHECK,
    MODERATION,
    ADMINISTRATION;
@@ -97,4 +95,4 @@ enum class UserPerm {
    }

    data class Prefix(val colorCode: String, val chatPrefix: String, val teamPrefix: Boolean = false)
-}
+}
@@ -1,345 +0,0 @@
-/*
- *   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.sql
-
-import de.steamwar.sql.internal.useDb
-import org.jetbrains.exposed.v1.core.and
-import org.jetbrains.exposed.v1.core.dao.id.EntityID
-import org.jetbrains.exposed.v1.core.dao.id.java.UUIDTable
-import org.jetbrains.exposed.v1.core.eq
-import org.jetbrains.exposed.v1.core.not
-import org.jetbrains.exposed.v1.core.or
-import org.jetbrains.exposed.v1.core.SortOrder
-import org.jetbrains.exposed.v1.dao.Entity
-import org.jetbrains.exposed.v1.dao.EntityClass
-import org.jetbrains.exposed.v1.javatime.CurrentTimestamp
-import org.jetbrains.exposed.v1.javatime.timestamp
-import java.io.File
-import java.time.Instant
-import java.time.temporal.ChronoUnit
-import java.util.UUID
-
-object WorldTable : UUIDTable("world") {
-    val name = varchar("Name", 512)
-    val version = integer("Version")
-    val type = enumeration<WorldType>("Type")
-    val owner = reference("Owner", SteamwarUserTable).nullable()
-    val team = reference("Team", TeamTable).nullable()
-    val lockState = varchar("LockState", 32).nullable()
-    val deleted = bool("Deleted").default(false)
-    val created = timestamp("Created").defaultExpression(CurrentTimestamp)
-    val lastUsed = timestamp("LastUsed").defaultExpression(CurrentTimestamp)
-}
-
-enum class WorldType {
-    BAU,
-    BUILDER,
-    TEAM,
-    ARENA,
-    TEMPLATE,
-}
-
-class SteamwarWorld(id: EntityID<UUID>) : Entity<UUID>(id) {
-    var name by WorldTable.name
-        private set
-    var version by WorldTable.version
-        private set
-    var type by WorldTable.type
-        private set
-    var owner by WorldTable.owner
-        private set
-    var team by WorldTable.team
-        private set
-    var lockState by WorldTable.lockState
-        private set
-    var deleted by WorldTable.deleted
-        private set
-    val created by WorldTable.created
-    var lastUsed by WorldTable.lastUsed
-        private set
-
-    val archived: Boolean
-        get() = !storageDirectory.exists() && archiveFile.exists()
-
-    val shouldArchive: Boolean
-        get() = !archived && (deleted || lastUsed.plus(7, ChronoUnit.DAYS).isBefore(Instant.now()))
-
-    val uuid: UUID
-        get() = id.value
-
-    val storageDirectory: File
-        get() = File(WORLD_STORAGE, id.value.toString())
-
-    private val archiveFile: File
-        get() = File(ARCHIVE_WORLD_STORAGE, "${id.value}.zip")
-
-    @JvmOverloads
-    fun setupAndGetStoragePath(prototype: File? = null): String {
-        if (archived) {
-            loadFromArchive()
-        }
-
-        val needsInitialization = !storageDirectory.exists() || storageDirectory.list()?.isEmpty() == true
-        if (needsInitialization) {
-            if (prototype != null && prototype.exists()) {
-                prototype.copyRecursively(storageDirectory, overwrite = true)
-            } else {
-                storageDirectory.mkdirs()
-            }
-        }
-
-        useDb {
-            lastUsed = Instant.now()
-        }
-
-        return storageDirectory.path
-    }
-
-    fun markDeleted() = useDb {
-        deleted = true
-    }
-
-    fun rename(newName: String) = useDb {
-        name = newName
-    }
-
-    fun archiveIfNeeded(): Boolean {
-        if (!shouldArchive) return false
-
-        File(ARCHIVE_WORLD_STORAGE).mkdirs()
-        return archiveWorld() == 0
-    }
-
-    fun changeVersion(newVersion: Int) = useDb {
-        version = newVersion
-    }
-
-    fun changeLockState(newLockState: String?) = useDb {
-        lockState = newLockState
-    }
-
-    private fun archiveWorld() = ProcessBuilder("zip", "-u9oymrqq", "$ARCHIVE_WORLD_STORAGE/${id.value}.zip", id.value.toString())
-        .directory(File(WORLD_STORAGE))
-        .inheritIO()
-        .start()
-        .waitFor()
-
-
-    private fun loadFromArchive() = ProcessBuilder("unzip", "-qq", "-o", "$ARCHIVE_WORLD_STORAGE/${id.value}.zip", "-d", WORLD_STORAGE)
-        .inheritIO()
-        .start()
-        .waitFor()
-
-    companion object : EntityClass<UUID, SteamwarWorld>(WorldTable) {
-        const val WORLD_STORAGE = "/worlds/storage"
-        const val ARCHIVE_WORLD_STORAGE = "/mnt/storage/worlds/storage"
-        const val DEFAULT_BAU_WORLD_LIMIT = 3
-        const val EXTRA_BAU_WORLD_LIMIT = 10
-        const val TEAM_WORLD_LIMIT = 2
-
-        @JvmStatic
-        fun getWorld(uuid: UUID) = useDb {
-            findById(uuid)
-        }
-
-        @JvmStatic
-        fun getBauWorld(user: SteamwarUser, version: Int) = useDb {
-            find {
-                (WorldTable.owner eq user.id) and
-                        (WorldTable.version eq version) and
-                        (WorldTable.type eq WorldType.BAU) and
-                        not(WorldTable.deleted)
-            }.firstOrNull()
-        }
-
-        @JvmStatic
-        fun getBauWorld(user: SteamwarUser, name: String, version: Int) = useDb {
-            find {
-                (WorldTable.owner eq user.id) and
-                        (WorldTable.name eq name) and
-                        (WorldTable.version eq version) and
-                        (WorldTable.type eq WorldType.BAU) and
-                        not(WorldTable.deleted)
-            }.firstOrNull()
-        }
-
-        @JvmStatic
-        fun getBauWorlds(user: SteamwarUser) = useDb {
-            find {
-                (WorldTable.owner eq user.id) and
-                        (WorldTable.type eq WorldType.BAU) and
-                        not(WorldTable.deleted)
-            }.orderBy(WorldTable.created to SortOrder.ASC).toList()
-        }
-
-        @JvmStatic
-        fun countBauWorlds(user: SteamwarUser) = useDb {
-            find {
-                (WorldTable.owner eq user.id) and
-                        (WorldTable.type eq WorldType.BAU) and
-                        not(WorldTable.deleted)
-            }.count()
-        }
-
-        @JvmStatic
-        @JvmOverloads
-        fun getOrCreateBauWorld(user: SteamwarUser, version: Int, prototype: File? = null): SteamwarWorld =
-            getBauWorld(user, version) ?: createWorld(user, user.userName, version, WorldType.BAU, prototype)
-
-        @JvmStatic
-        @JvmOverloads
-        fun getOrCreateBauWorld(user: SteamwarUser, name: String, version: Int, prototype: File? = null): SteamwarWorld =
-            getBauWorld(user, name, version) ?: createWorld(user, name, version, WorldType.BAU, prototype)
-
-        @JvmStatic
-        fun getBuilderWorld(name: String, version: Int) = useDb {
-            find {
-                (WorldTable.name eq name) and
-                        (WorldTable.version eq version) and
-                        (WorldTable.type eq WorldType.BUILDER) and
-                        not(WorldTable.deleted)
-            }.firstOrNull()
-        }
-
-        @JvmStatic
-        fun getBuilderWorlds(version: Int) = useDb {
-            find {
-                (WorldTable.version eq version) and
-                        (WorldTable.type eq WorldType.BUILDER) and
-                        not(WorldTable.deleted)
-            }.toList()
-        }
-
-        @JvmStatic
-        @JvmOverloads
-        fun getOrCreateBuilderWorld(name: String, version: Int, prototype: File? = null): SteamwarWorld =
-            getBuilderWorld(name, version) ?: createWorld(null, name, version, WorldType.BUILDER, prototype)
-
-        @JvmStatic
-        fun getTeamWorld(team: Team, name: String, version: Int) = useDb {
-            find {
-                (WorldTable.team eq team.id) and
-                        (WorldTable.name eq name) and
-                        (WorldTable.version eq version) and
-                        (WorldTable.type eq WorldType.TEAM) and
-                        not(WorldTable.deleted)
-            }.firstOrNull()
-        }
-
-        @JvmStatic
-        fun getTeamWorlds(team: Team) = useDb {
-            find {
-                (WorldTable.team eq team.id) and
-                        (WorldTable.type eq WorldType.TEAM) and
-                        not(WorldTable.deleted)
-            }.orderBy(WorldTable.created to SortOrder.ASC).toList()
-        }
-
-        @JvmStatic
-        @JvmOverloads
-        fun getOrCreateTeamWorld(team: Team, name: String, version: Int, prototype: File? = null): SteamwarWorld =
-            getTeamWorld(team, name, version) ?: createWorld(null, name, version, WorldType.TEAM, prototype, team)
-
-        @JvmStatic
-        fun countTeamWorlds(team: Team) = useDb {
-            find {
-                (WorldTable.team eq team.id) and
-                        (WorldTable.type eq WorldType.TEAM) and
-                        not(WorldTable.deleted)
-            }.count()
-        }
-
-        @JvmStatic
-        fun getArenaWorld(mode: String, map: String, version: Int) = useDb {
-            find {
-                (WorldTable.name eq arenaWorldName(mode, map)) and
-                        (WorldTable.version eq version) and
-                        (WorldTable.type eq WorldType.ARENA) and
-                        not(WorldTable.deleted)
-            }.firstOrNull()
-        }
-
-        @JvmStatic
-        @JvmOverloads
-        fun getOrCreateArenaWorld(mode: String, map: String, version: Int, prototype: File? = null): SteamwarWorld =
-            getArenaWorld(mode, map, version) ?: createWorld(null, arenaWorldName(mode, map), version, WorldType.ARENA, prototype)
-
-        @JvmStatic
-        fun getTemplateWorld(name: String, version: Int) = useDb {
-            find {
-                (WorldTable.name eq name) and
-                        (WorldTable.version eq version) and
-                        (WorldTable.type eq WorldType.TEMPLATE) and
-                        not(WorldTable.deleted)
-            }.firstOrNull()
-        }
-
-        @JvmStatic
-        fun getTemplateWorlds() = useDb {
-            find {
-                (WorldTable.type eq WorldType.TEMPLATE) and
-                        not(WorldTable.deleted)
-            }.orderBy(WorldTable.name to SortOrder.ASC).toList()
-        }
-
-        @JvmStatic
-        fun getTemplateWorlds(version: Int) = useDb {
-            find {
-                (WorldTable.version eq version) and
-                        (WorldTable.type eq WorldType.TEMPLATE) and
-                        not(WorldTable.deleted)
-            }.orderBy(WorldTable.name to SortOrder.ASC).toList()
-        }
-
-        @JvmStatic
-        @JvmOverloads
-        fun getOrCreateTemplateWorld(name: String, version: Int, prototype: File? = null): SteamwarWorld =
-            getTemplateWorld(name, version) ?: createWorld(null, name, version, WorldType.TEMPLATE, prototype)
-
-        @JvmStatic
-        fun getAllActiveWorlds() = useDb {
-            find { not(WorldTable.deleted) }.toList()
-        }
-
-        @JvmStatic
-        fun getWorldsToArchive() = useDb {
-            find {
-                not(WorldTable.deleted) or (WorldTable.deleted eq true)
-            }.toList().filter { it.shouldArchive }
-        }
-
-        private fun arenaWorldName(mode: String, map: String) = "$mode/$map"
-
-        @JvmStatic
-        @JvmOverloads
-        fun createWorld(user: SteamwarUser?, name: String, version: Int, type: WorldType, prototype: File? = null, team: Team? = null): SteamwarWorld {
-            val world = useDb { new {
-                this.name = name
-                this.version = version
-                this.type = type
-                this.owner = user?.id
-                this.team = team?.id
-            } }
-
-            world.setupAndGetStoragePath(prototype)
-            return world
-        }
-    }
-}
@@ -139,6 +139,12 @@ final class YMLWrapper<M, W> {
        return get(path, o -> (List<Integer>) o);
    }

+    public Set<Integer> getIntSet(String path) {
+        List<Integer> list = get(path, o -> (List<Integer>) o);
+        if (list.isEmpty()) return Collections.emptySet();
+        return Collections.unmodifiableSet(new HashSet<>(list));
+    }
+
    public List<SchematicType> getSchematicTypeList(String path) {
        List<String> list = getStringList(path);
        if (list.isEmpty()) {
@@ -29,6 +29,7 @@ java {
 dependencies {
    compileOnly(libs.classindex)
    annotationProcessor(libs.classindex)
+    compileOnly(project(":GameCore", "default"))
    compileOnly(project(":SpigotCore", "default"))

    compileOnly(libs.netty)
@@ -64,6 +64,10 @@ Arena:
  AllowMissiles: false # defaults to true if EnterStages are present otherwise 'false'
  # Denotes that there is no floor for this GameMode
  NoFloor: false # defaults to false if missing
+  # Allows Wind Charges to cross the Middle.
+  WindchargesCanCrossMiddle: false # defaults to false if missing
+  # Allows Wind Charge interaction with Blocks.
+  WindchargesInteractWithBlocks: false # defaults to false if missing

 Schematic:
  # The size of the schematics
@@ -1,56 +0,0 @@
-/*
- *   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.fightsystem;
-
-import java.util.Collections;
-import java.util.EnumSet;
-import java.util.Set;
-
-public enum ArenaMode {
-    NORMAL,
-    EVENT,
-    TEST,
-    CHECK,
-    PREPARE,
-    REPLAY;
-
-    public static final Set<ArenaMode> All = Collections.unmodifiableSet(EnumSet.allOf(ArenaMode.class));
-
-    public static final Set<ArenaMode> Normal = Collections.unmodifiableSet(EnumSet.of(NORMAL));
-    public static final Set<ArenaMode> Check = Collections.unmodifiableSet(EnumSet.of(CHECK));
-    public static final Set<ArenaMode> Event = Collections.unmodifiableSet(EnumSet.of(EVENT));
-    public static final Set<ArenaMode> Test = Collections.unmodifiableSet(EnumSet.of(TEST, CHECK));
-    public static final Set<ArenaMode> Prepare = Collections.unmodifiableSet(EnumSet.of(PREPARE));
-    public static final Set<ArenaMode> Replay = Collections.unmodifiableSet(EnumSet.of(REPLAY, TEST));
-
-    public static final Set<ArenaMode> AntiReplay = Collections.unmodifiableSet(EnumSet.complementOf(EnumSet.of(REPLAY)));
-    public static final Set<ArenaMode> AntiTest = Collections.unmodifiableSet(EnumSet.complementOf(EnumSet.of(TEST, CHECK)));
-    public static final Set<ArenaMode> AntiEvent = Collections.unmodifiableSet(EnumSet.complementOf(EnumSet.of(EVENT)));
-    public static final Set<ArenaMode> AntiTestCheckPrepare = Collections.unmodifiableSet(EnumSet.complementOf(EnumSet.of(TEST, CHECK, PREPARE)));
-    public static final Set<ArenaMode> AntiPrepare = Collections.unmodifiableSet(EnumSet.complementOf(EnumSet.of(PREPARE)));
-    public static final Set<ArenaMode> VariableTeams = Collections.unmodifiableSet(EnumSet.complementOf(EnumSet.of(EVENT, REPLAY, CHECK)));
-    public static final Set<ArenaMode> ManualTeams = Collections.unmodifiableSet(EnumSet.complementOf(EnumSet.of(EVENT, REPLAY)));
-    public static final Set<ArenaMode> RankedEvent = Collections.unmodifiableSet(EnumSet.of(EVENT, REPLAY));
-    public static final Set<ArenaMode> Restartable = Collections.unmodifiableSet(EnumSet.of(NORMAL, TEST));
-    public static final Set<ArenaMode> NotRestartable = Collections.unmodifiableSet(EnumSet.of(EVENT, REPLAY));
-    public static final Set<ArenaMode> SoloLeader = Collections.unmodifiableSet(EnumSet.of(TEST, CHECK, PREPARE));
-    public static final Set<ArenaMode> NotOnBau = Collections.unmodifiableSet(EnumSet.complementOf(EnumSet.of(TEST, CHECK, PREPARE, REPLAY)));
-    public static final Set<ArenaMode> SeriousFight = Collections.unmodifiableSet(EnumSet.complementOf(EnumSet.of(TEST, CHECK, REPLAY)));
-}
@@ -22,6 +22,7 @@ package de.steamwar.fightsystem;
 import de.steamwar.data.GameModeConfigUtils;
 import de.steamwar.fightsystem.utils.Region;
 import de.steamwar.fightsystem.winconditions.Winconditions;
+import de.steamwar.gamecore.GameConfig;
 import de.steamwar.sql.*;
 import org.bukkit.Bukkit;
 import org.bukkit.Location;
@@ -35,7 +36,6 @@ import org.bukkit.util.Vector;
 import java.io.File;
 import java.util.Collections;
 import java.util.Set;
-import java.util.UUID;
 import java.util.logging.Level;

 public class Config {
@@ -75,8 +75,6 @@ public class Config {
    public static final String TeamBlueName;
    public static final String TeamRedColor;
    public static final String TeamBlueColor;
-    public static final UUID BlueLeader;
-    public static final UUID RedLeader;

    //event parameter
    public static final EventFight EventKampf;
@@ -87,23 +85,12 @@ public class Config {
    public static final int MaximumTeamMembers;
    public static final boolean LiveReplay;

-    //check parameter
-    public static final int CheckSchemID;
-    public static final int PrepareSchemID;
-
-    public static final ArenaMode mode;
-
    //replay system parameter
    public static final String spectateIP = "127.0.0.1";
    public static final int SpectatePort;
-    public static final int ReplayID;

    static {
-        CheckSchemID = Integer.parseInt(System.getProperty("checkSchemID", "0"));
-        PrepareSchemID = Integer.parseInt(System.getProperty("prepareSchemID", "0"));
-        ReplayID = Integer.parseInt(System.getProperty("replay", "0"));
-
-        String configFile = System.getProperty("config", "config.yml");
+        String configFile = GameConfig.ConfigFile;
        if (!new File(FightSystem.getPlugin().getDataFolder(), configFile).exists()) {
            FightSystem.getPlugin().saveDefaultConfig();
            Bukkit.getLogger().log(Level.SEVERE, "Arenaconfig fehlt!");
@@ -209,7 +196,7 @@ public class Config {

        BlueInsetRegion = new Region(BluePasteRegion.getMinX() + GameModeConfig.Schematic.Inset.x, BluePasteRegion.getMinY() + GameModeConfig.Schematic.Inset.bottom, BluePasteRegion.getMinZ() + GameModeConfig.Schematic.Inset.z, BluePasteRegion.getMaxX() - GameModeConfig.Schematic.Inset.x, BluePasteRegion.getMaxY() - GameModeConfig.Schematic.Inset.top, BluePasteRegion.getMaxZ() - GameModeConfig.Schematic.Inset.z);

-        int eventKampfID = Integer.parseInt(System.getProperty("fightID", "0"));
+        int eventKampfID = GameConfig.EventKampfID;
        if (eventKampfID >= 1) {
            EventKampf = EventFight.byId(eventKampfID);
            if (EventKampf == null) {
@@ -261,43 +248,8 @@ public class Config {
            Referees = Collections.emptySet();
            MaximumTeamMembers = Integer.MAX_VALUE;
            LiveReplay = false;
-            SpectatePort = -ReplayID;
+            SpectatePort = -GameConfig.ReplayID;
        }
-
-        String blueLeader = System.getProperty("blueLeader", null);
-        String redLeader = System.getProperty("redLeader", null);
-        if (blueLeader != null) {
-            BlueLeader = UUID.fromString(blueLeader);
-        } else {
-            BlueLeader = null;
-        }
-        if (redLeader != null) {
-            RedLeader = UUID.fromString(redLeader);
-        } else {
-            RedLeader = null;
-        }
-
-        if (CheckSchemID != 0) {
-            mode = ArenaMode.CHECK;
-        } else if (PrepareSchemID != 0) {
-            mode = ArenaMode.PREPARE;
-        } else if (eventKampfID >= 1) {
-            mode = ArenaMode.EVENT;
-        } else if (eventKampfID == -1) {
-            mode = ArenaMode.TEST;
-        } else if (ReplayID != 0) {
-            mode = ArenaMode.REPLAY;
-        } else {
-            mode = ArenaMode.NORMAL;
-        }
-    }
-
-    public static boolean test() {
-        return ArenaMode.Test.contains(mode);
-    }
-
-    public static boolean replayserver() {
-        return ReplayID < 0;
    }

    public static boolean blueNegZ() {
@@ -32,7 +32,12 @@ import de.steamwar.fightsystem.record.GlobalRecorder;
 import de.steamwar.fightsystem.states.FightState;
 import de.steamwar.fightsystem.states.OneShotStateDependent;
 import de.steamwar.fightsystem.states.StateDependentListener;
-import de.steamwar.fightsystem.utils.*;
+import de.steamwar.fightsystem.utils.FightUI;
+import de.steamwar.fightsystem.utils.HullHider;
+import de.steamwar.fightsystem.utils.SWSound;
+import de.steamwar.fightsystem.utils.TechHiderWrapper;
+import de.steamwar.gamecore.ArenaMode;
+import de.steamwar.gamecore.GameConfig;
 import de.steamwar.linkage.AbstractLinker;
 import de.steamwar.linkage.SpigotLinker;
 import de.steamwar.message.Message;
@@ -72,7 +77,7 @@ public class FightSystem extends JavaPlugin {
        }
        if (Config.SpectatePort != 0) {
            Core.setServerName("Spectate");
-        } else if (Config.ReplayID != 0) {
+        } else if (GameConfig.ReplayID != 0) {
            Core.setServerName("Replay");
        }

@@ -106,7 +111,7 @@ public class FightSystem extends JavaPlugin {
        });
        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);
-        Config.world.setGameRule(GameRule.REDUCED_DEBUG_INFO, ArenaMode.AntiTest.contains(Config.mode));
+        Config.world.setGameRule(GameRule.REDUCED_DEBUG_INFO, ArenaMode.AntiTest.contains(GameConfig.mode));

        hullHider = new HullHider();
        techHider = new TechHiderWrapper(hullHider);
@@ -115,10 +120,10 @@ public class FightSystem extends JavaPlugin {

        FileSource.startReplay();

-        if (Config.mode == ArenaMode.EVENT) {
+        if (GameConfig.mode == ArenaMode.EVENT) {
            FightState.setFightState(FightState.PRE_SCHEM_SETUP);
-        } else if (Config.mode == ArenaMode.CHECK) {
-            SchematicNode checkSchematicNode = SchematicNode.getSchematicNode(Config.CheckSchemID);
+        } else if (GameConfig.mode == ArenaMode.CHECK) {
+            SchematicNode checkSchematicNode = SchematicNode.getSchematicNode(GameConfig.CheckSchemID);
            Fight.getBlueTeam().setSchem(checkSchematicNode);

            if (checkSchematicNode.isPrepared()) {
@@ -126,8 +131,8 @@ public class FightSystem extends JavaPlugin {
            }

            new TechareaCommand();
-        } else if (Config.mode == ArenaMode.PREPARE) {
-            Fight.getUnrotated().setSchem(SchematicNode.getSchematicNode(Config.PrepareSchemID));
+        } else if (GameConfig.mode == ArenaMode.PREPARE) {
+            Fight.getUnrotated().setSchem(SchematicNode.getSchematicNode(GameConfig.PrepareSchemID));
        }

        Config.world.setGameRule(GameRule.LOCATOR_BAR, false);
@@ -20,7 +20,7 @@
 package de.steamwar.fightsystem.ai;

 import com.sk89q.worldedit.extent.clipboard.Clipboard;
-import de.steamwar.fightsystem.ArenaMode;
+import de.steamwar.gamecore.ArenaMode;
 import de.steamwar.fightsystem.Config;
 import de.steamwar.fightsystem.FightSystem;
 import de.steamwar.fightsystem.fight.Fight;
@@ -19,8 +19,8 @@

 package de.steamwar.fightsystem.ai;

-import de.steamwar.fightsystem.ArenaMode;
-import de.steamwar.fightsystem.Config;
+import de.steamwar.gamecore.ArenaMode;
+import de.steamwar.gamecore.GameConfig;
 import de.steamwar.fightsystem.fight.FightTeam;
 import lombok.AllArgsConstructor;
 import lombok.Getter;
@@ -35,7 +35,7 @@ import java.util.stream.Collectors;
@AllArgsConstructor
 public class AIManager {
    private static final List<AIManager> AIs = Arrays.asList(
-            new AIManager("DummyAI", DummyAI::new, Material.STONE, () -> ArenaMode.Test.contains(Config.mode))
+            new AIManager("DummyAI", DummyAI::new, Material.STONE, () -> ArenaMode.Test.contains(GameConfig.mode))
    );

    public static List<AIManager> availableAIs() {
@@ -20,7 +20,7 @@
 package de.steamwar.fightsystem.commands;

 import de.steamwar.core.Core;
-import de.steamwar.fightsystem.ArenaMode;
+import de.steamwar.gamecore.ArenaMode;
 import de.steamwar.fightsystem.FightSystem;
 import de.steamwar.fightsystem.fight.Kit;
 import de.steamwar.fightsystem.states.FightState;
@@ -19,7 +19,8 @@

 package de.steamwar.fightsystem.commands;

-import de.steamwar.fightsystem.ArenaMode;
+import de.steamwar.gamecore.ArenaMode;
+import de.steamwar.gamecore.GameConfig;
 import de.steamwar.fightsystem.Config;
 import de.steamwar.fightsystem.FightSystem;
 import de.steamwar.fightsystem.ai.AIManager;
@@ -56,7 +57,7 @@ public class GUI {
        inv.setItem(pos, ColorConverter.chat2dye(team.getColor()), msg.parse("JOIN_REQUEST_TEAM", p, team.getColor() + name), click -> {
            p.closeInventory();

-            if (ArenaMode.ManualTeams.contains(Config.mode) && team.canbeLeader(p)) {
+            if (ArenaMode.ManualTeams.contains(GameConfig.mode) && team.canbeLeader(p)) {
                team.addMember(p);
            } else {
                JoinRequest.forPlayer(p, team);
@@ -198,7 +199,7 @@ public class GUI {
    }

    public static void preSchemDialog(Player p) {
-        if (!Config.test() && FightState.getFightState() != FightState.PRE_SCHEM_SETUP) {
+        if (!GameConfig.test() && FightState.getFightState() != FightState.PRE_SCHEM_SETUP) {
            msg.sendPrefixless("SCHEM_NO_ENEMY", p, ChatMessageType.ACTION_BAR);
            return;
        }
@@ -209,7 +210,7 @@ public class GUI {
        for (int i = 0; i < Config.GameModeConfig.Schematic.SubTypes.size(); i++) {
            setupSchemTypeRow(p, inv, Config.GameModeConfig.Schematic.SubTypes.get(i), i + 1);
        }
-        if (!Config.test() && SteamwarUser.get(p.getUniqueId()).hasPerm(UserPerm.TEAM)) {
+        if (!GameConfig.test() && SteamwarUser.get(p.getUniqueId()).hasPerm(UserPerm.TEAM)) {
            SchematicNode node = SchematicNode.getSchematicNode(-1, Config.GameModeConfig.GameName, (Integer) null);
            if (node != null) {
                inv.setItem(2, new SWItem(SWItem.getMaterial(node.getItem()), msg.parse("SCHEM_DIRT", p), click -> {
@@ -233,14 +234,14 @@ public class GUI {
            return;
        }

-        if (type.checkType() != null && type.checkType() != type && ArenaMode.AntiEvent.contains(Config.mode) && !SchematicNode.getAllAccessibleSchematicsOfType(SteamwarUser.get(p.getUniqueId()).getId(), type.checkType().toDB()).isEmpty()) {
+        if (type.checkType() != null && type.checkType() != type && ArenaMode.AntiEvent.contains(GameConfig.mode) && !SchematicNode.getAllAccessibleSchematicsOfType(SteamwarUser.get(p.getUniqueId()).getId(), type.checkType().toDB()).isEmpty()) {
            inv.setItem(row * 9 + 4, Material.ANVIL, msg.parse("SCHEM_UNCHECKED", p, type.name()), (ClickType click) -> {
                p.closeInventory();
                schemDialog(p, type, false, true);
            });
        }

-        if (SchematicNode.getAllAccessibleSchematicsOfType(SteamwarUser.get(p.getUniqueId()).getId(), type.toDB()).isEmpty() && !Config.test()) {
+        if (SchematicNode.getAllAccessibleSchematicsOfType(SteamwarUser.get(p.getUniqueId()).getId(), type.toDB()).isEmpty() && !GameConfig.test()) {
            inv.setItem(row * 9, Material.GRAY_DYE, (byte) 8, msg.parse("SCHEM_NO_PRIVATE", p, type.name()), (ClickType click) -> {
            });
            return;
@@ -253,7 +254,7 @@ public class GUI {
    }

    private static void schemDialog(Player p, SchematicType type, boolean publicSchems, boolean unchecked) {
-        SchematicSelector selector = new SchematicSelector(p, Config.test() ? SchematicSelector.selectSchematic() : SchematicSelector.selectSchematicType(unchecked ? type.checkType() : type), node -> {
+        SchematicSelector selector = new SchematicSelector(p, GameConfig.test() ? SchematicSelector.selectSchematic() : SchematicSelector.selectSchematicType(unchecked ? type.checkType() : type), node -> {
            schemSelect(p, node);
        });
        selector.setPublicMode(publicSchems ? SchematicSelector.PublicMode.PUBLIC_ONLY : SchematicSelector.PublicMode.PRIVATE_ONLY);
@@ -263,7 +264,7 @@ public class GUI {
    private static void schemSelect(Player p, SchematicNode node) {
        FightTeam fightTeam = Fight.getPlayerTeam(p);
        if (fightTeam == null) return;
-        if (Config.test() || FightState.getFightState() != FightState.POST_SCHEM_SETUP) {
+        if (GameConfig.test() || FightState.getFightState() != FightState.POST_SCHEM_SETUP) {
            fightTeam.pasteSchem(node);
        }
        p.closeInventory();
@@ -22,6 +22,7 @@ package de.steamwar.fightsystem.commands;
 import com.google.common.collect.ImmutableList;
 import de.steamwar.fightsystem.Config;
 import de.steamwar.fightsystem.FightSystem;
+import de.steamwar.gamecore.GameConfig;
 import de.steamwar.linkage.Linked;
 import net.md_5.bungee.api.ChatMessageType;
 import org.bukkit.Bukkit;
@@ -65,7 +66,7 @@ public class GamemodeCommand extends BukkitCommand {

        Player p = (Player) sender;

-        if (!(Config.test() || Config.isReferee(p))) {
+        if (!(GameConfig.test() || Config.isReferee(p))) {
            FightSystem.getMessage().sendPrefixless("GAMEMODE_NOT_ALLOWED", p, ChatMessageType.ACTION_BAR);
            return false;
        }
@@ -19,7 +19,7 @@

 package de.steamwar.fightsystem.commands;

-import de.steamwar.fightsystem.ArenaMode;
+import de.steamwar.gamecore.ArenaMode;
 import de.steamwar.fightsystem.FightSystem;
 import de.steamwar.fightsystem.fight.Fight;
 import de.steamwar.fightsystem.fight.FightTeam;
@@ -19,7 +19,7 @@

 package de.steamwar.fightsystem.commands;

-import de.steamwar.fightsystem.ArenaMode;
+import de.steamwar.gamecore.ArenaMode;
 import de.steamwar.fightsystem.states.FightState;
 import de.steamwar.fightsystem.states.StateDependentCommand;
 import de.steamwar.linkage.Linked;
@@ -19,7 +19,7 @@

 package de.steamwar.fightsystem.commands;

-import de.steamwar.fightsystem.ArenaMode;
+import de.steamwar.gamecore.ArenaMode;
 import de.steamwar.fightsystem.states.FightState;
 import de.steamwar.fightsystem.states.StateDependentCommand;
 import de.steamwar.linkage.Linked;
@@ -19,7 +19,7 @@

 package de.steamwar.fightsystem.commands;

-import de.steamwar.fightsystem.ArenaMode;
+import de.steamwar.gamecore.ArenaMode;
 import de.steamwar.fightsystem.FightSystem;
 import de.steamwar.fightsystem.fight.Fight;
 import de.steamwar.fightsystem.fight.FightTeam;
@@ -19,7 +19,7 @@

 package de.steamwar.fightsystem.commands;

-import de.steamwar.fightsystem.ArenaMode;
+import de.steamwar.gamecore.ArenaMode;
 import de.steamwar.fightsystem.states.FightState;
 import de.steamwar.fightsystem.states.StateDependentCommand;
 import de.steamwar.linkage.Linked;
@@ -19,7 +19,7 @@

 package de.steamwar.fightsystem.commands;

-import de.steamwar.fightsystem.ArenaMode;
+import de.steamwar.gamecore.ArenaMode;
 import de.steamwar.fightsystem.FightSystem;
 import de.steamwar.fightsystem.states.FightState;
 import de.steamwar.fightsystem.states.StateDependentCommand;
@@ -19,7 +19,7 @@

 package de.steamwar.fightsystem.commands;

-import de.steamwar.fightsystem.ArenaMode;
+import de.steamwar.gamecore.ArenaMode;
 import de.steamwar.fightsystem.FightSystem;
 import de.steamwar.fightsystem.fight.Fight;
 import de.steamwar.fightsystem.fight.FightPlayer;
@@ -19,8 +19,8 @@

 package de.steamwar.fightsystem.commands;

-import de.steamwar.fightsystem.ArenaMode;
-import de.steamwar.fightsystem.Config;
+import de.steamwar.gamecore.ArenaMode;
+import de.steamwar.gamecore.GameConfig;
 import de.steamwar.fightsystem.fight.Fight;
 import de.steamwar.fightsystem.record.PacketProcessor;
 import de.steamwar.fightsystem.states.FightState;
@@ -35,7 +35,7 @@ import org.bukkit.entity.Player;
 public class SkipCommand implements CommandExecutor {

    public SkipCommand() {
-        new StateDependentCommand(ArenaMode.AntiPrepare, ArenaMode.Replay.contains(Config.mode) ? FightState.All : FightState.TeamFix, "skip", this);
+        new StateDependentCommand(ArenaMode.AntiPrepare, ArenaMode.Replay.contains(GameConfig.mode) ? FightState.All : FightState.TeamFix, "skip", this);
    }

    @Override
@@ -19,7 +19,7 @@

 package de.steamwar.fightsystem.commands;

-import de.steamwar.fightsystem.ArenaMode;
+import de.steamwar.gamecore.ArenaMode;
 import de.steamwar.fightsystem.states.FightState;
 import de.steamwar.fightsystem.states.StateDependentCommand;
 import de.steamwar.linkage.Linked;
@@ -19,7 +19,7 @@

 package de.steamwar.fightsystem.commands;

-import de.steamwar.fightsystem.ArenaMode;
+import de.steamwar.gamecore.ArenaMode;
 import de.steamwar.fightsystem.fight.Fight;
 import de.steamwar.fightsystem.states.FightState;
 import de.steamwar.fightsystem.states.StateDependentCommand;
@@ -17,7 +17,7 @@

 package de.steamwar.fightsystem.commands;

-import de.steamwar.fightsystem.ArenaMode;
+import de.steamwar.gamecore.ArenaMode;
 import de.steamwar.fightsystem.FightSystem;
 import de.steamwar.fightsystem.states.FightState;
 import de.steamwar.fightsystem.states.StateDependentCommand;
@@ -20,7 +20,8 @@
 package de.steamwar.fightsystem.commands;

 import com.comphenix.tinyprotocol.TinyProtocol;
-import de.steamwar.fightsystem.ArenaMode;
+import de.steamwar.gamecore.ArenaMode;
+import de.steamwar.gamecore.GameConfig;
 import de.steamwar.fightsystem.Config;
 import de.steamwar.fightsystem.FightSystem;
 import de.steamwar.fightsystem.fight.Fight;
@@ -49,7 +50,7 @@ public class TechhiderbugCommand implements CommandExecutor {
        StringWriter writer = new StringWriter();

        try {
-            writer.append("ArenaMode: ").append(Config.mode.name()).append('\n');
+            writer.append("ArenaMode: ").append(GameConfig.mode.name()).append('\n');
            writer.append("FightState: ").append(FightState.getFightState().name()).append('\n');
            writer.append("TechHider enabled: ").append(FightState.getStateDependentFeatures().get(FightSystem.getTechHider()).toString()).append('\n');

@@ -19,7 +19,7 @@

 package de.steamwar.fightsystem.commands;

-import de.steamwar.fightsystem.ArenaMode;
+import de.steamwar.gamecore.ArenaMode;
 import de.steamwar.fightsystem.fight.Fight;
 import de.steamwar.fightsystem.fight.FightWorld;
 import de.steamwar.fightsystem.states.FightState;
@@ -19,7 +19,7 @@

 package de.steamwar.fightsystem.commands;

-import de.steamwar.fightsystem.ArenaMode;
+import de.steamwar.gamecore.ArenaMode;
 import de.steamwar.fightsystem.Config;
 import de.steamwar.fightsystem.FightSystem;
 import de.steamwar.fightsystem.fight.Fight;
@@ -1,151 +0,0 @@
-/*
- *   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.fightsystem.countdown;
-
-import de.steamwar.fightsystem.FightSystem;
-import de.steamwar.fightsystem.fight.Fight;
-import de.steamwar.fightsystem.record.GlobalRecorder;
-import de.steamwar.fightsystem.utils.FightUI;
-import de.steamwar.fightsystem.utils.Message;
-import de.steamwar.fightsystem.utils.SWSound;
-import net.md_5.bungee.api.ChatMessageType;
-import org.bukkit.Bukkit;
-import org.bukkit.Sound;
-import org.bukkit.entity.Player;
-import org.bukkit.scheduler.BukkitTask;
-
-import java.util.ArrayList;
-import java.util.List;
-
-public abstract class Countdown {
-
-    private static final List<Countdown> currentCountdowns = new ArrayList<>();
-
-    protected final Message appendix;
-
-    private final int totalTime;
-    protected final Sound sound;
-    private final boolean level;
-
-    protected int time;
-    private BukkitTask task = null;
-
-    public abstract void countdownFinished();
-
-    protected Countdown(int time, Message appendix, SWSound sound, boolean level) {
-        this.totalTime = time;
-        this.time = time;
-        this.appendix = appendix;
-        this.sound = sound != null ? sound.getSound() : null;
-        this.level = level;
-    }
-
-    public void enable() {
-        time = totalTime;
-        task = Bukkit.getScheduler().runTaskTimer(FightSystem.getPlugin(), this::count, 20, 20);
-        currentCountdowns.add(this);
-        show();
-    }
-
-    public void disable() {
-        if (task != null) {
-            task.cancel();
-            currentCountdowns.remove(this);
-            task = null;
-        }
-    }
-
-    public static void skip() {
-        if (currentCountdowns.isEmpty()) return;
-
-        int smallestTime = currentCountdowns.get(0).time;
-        for (Countdown countdown : currentCountdowns) {
-            if (countdown.time < smallestTime) smallestTime = countdown.time;
-        }
-
-        for (Countdown countdown : new ArrayList<>(currentCountdowns)) {
-            countdown.time -= smallestTime;
-            countdown.show();
-        }
-
-        FightUI.addSubtitle("UI_SKIP");
-    }
-
-    public static void sendCountdownMessage(Player p, String message, int displaytime, Message appendix) {
-        FightSystem.getMessage().sendPrefixless(message, p, ChatMessageType.ACTION_BAR, displaytime, FightSystem.getMessage().parse(appendix.getMsg(), p, appendix.getParams()));
-    }
-
-    protected void broadcast(String message, int divisor) {
-        if (this.sound != null && divisor == 1) {
-            Fight.playSound(this.sound, 100.0F, 1.0F);
-        }
-
-        GlobalRecorder.getInstance().countdown(message, time / divisor, appendix);
-        Bukkit.getOnlinePlayers().forEach(p -> sendCountdownMessage(p, message, time / divisor, appendix));
-    }
-
-    public int getTimeLeft() {
-        return time;
-    }
-
-    private void count() {
-        time--;
-        show();
-    }
-
-    private void show() {
-        switch (time) {
-            case 900:
-            case 600:
-            case 300:
-            case 180:
-            case 120:
-                broadcast("COUNTDOWN_MINUTES", 60);
-                break;
-            case 60:
-            case 30:
-            case 20:
-            case 15:
-            case 10:
-            case 5:
-            case 4:
-            case 3:
-            case 2:
-                broadcast("COUNTDOWN_SECONDS", 1);
-                break;
-            case 1:
-                broadcast("COUNTDOWN_SECOND", 1);
-                break;
-            case 0:
-                if (this.sound != null) {
-                    Fight.playSound(this.sound, 100.0F, 2.0F);
-                }
-
-                disable();
-                countdownFinished();
-                break;
-            default:
-        }
-
-        if (this.level) {
-            Bukkit.getServer().getOnlinePlayers().forEach(player -> player.setLevel(time));
-        }
-    }
-}
@@ -27,13 +27,12 @@ import de.steamwar.fightsystem.fight.FightPlayer;
 import de.steamwar.fightsystem.utils.Message;
 import de.steamwar.fightsystem.utils.Region;
 import de.steamwar.fightsystem.utils.SWSound;
-import de.steamwar.techhider.ProtocolUtils;
+import de.steamwar.gamecore.countdown.Countdown;
+import de.steamwar.gamecore.countdown.StandardCountdown;
 import net.md_5.bungee.api.ChatMessageType;
 import org.bukkit.Bukkit;

-import java.util.List;
-
-public class EnternCountdown extends Countdown {
+public class EnternCountdown extends StandardCountdown {

    private static int calcTime(FightPlayer fp, Countdown countdown) {
        int time = Config.GameModeConfig.EnterStages.get(fp.getKit().getEnterStage());
@@ -47,16 +46,19 @@ public class EnternCountdown extends Countdown {
    }

    private final FightPlayer fightPlayer;
-    private List<ProtocolUtils.ChunkPos> chunkPos;

    public EnternCountdown(FightPlayer fp, Countdown countdown) {
-        super(calcTime(fp, countdown), new Message("ENTERN_COUNTDOWN"), SWSound.BLOCK_NOTE_PLING, false);
+        super(
+                FightSystem.getPlugin(),
+                calcTime(fp, countdown),
+                FightCountdownAdapter.playerPresentation(fp, new Message("ENTERN_COUNTDOWN"), SWSound.BLOCK_NOTE_PLING)
+        );
        fightPlayer = fp;
        enable();
    }

    @Override
-    public void countdownFinished() {
+    protected void countdownFinished() {
        Bukkit.getPluginManager().callEvent(new BoardingEvent(fightPlayer));
        FightSystem.getMessage().sendPrefixless("ENTERN_ALLOWED", fightPlayer.getEntity(), ChatMessageType.ACTION_BAR);
        fightPlayer.ifPlayer(player -> {
@@ -65,11 +67,4 @@ public class EnternCountdown extends Countdown {
        });
    }

-    @Override
-    protected void broadcast(String message, int divisor) {
-        fightPlayer.ifPlayer(player -> {
-            player.playSound(player.getLocation(), sound, 100.0f, 1.0f);
-            sendCountdownMessage(player, message, time / divisor, appendix);
-        });
-    }
 }
@@ -19,25 +19,27 @@

 package de.steamwar.fightsystem.countdown;

-import de.steamwar.fightsystem.ArenaMode;
+import de.steamwar.gamecore.ArenaMode;
+import de.steamwar.gamecore.GameConfig;
+import de.steamwar.gamecore.countdown.StandardCountdown;
 import de.steamwar.fightsystem.Config;
 import de.steamwar.fightsystem.FightSystem;
 import de.steamwar.fightsystem.states.FightState;
-import de.steamwar.fightsystem.states.StateDependentCountdown;
+import de.steamwar.gamecore.state.StateDependentCountdown;
 import de.steamwar.fightsystem.utils.Message;
 import de.steamwar.fightsystem.utils.SWSound;
 import de.steamwar.linkage.Linked;

@Linked
-public class EventSpectateCountdown extends Countdown {
+public class EventSpectateCountdown extends StandardCountdown {

    public EventSpectateCountdown() {
-        super(Config.GameModeConfig.Times.SpectatorDuration, new Message("SHUTDOWN_COUNTDOWN"), SWSound.BLOCK_NOTE_PLING, false);
-        new StateDependentCountdown(ArenaMode.NotRestartable.contains(Config.mode) && !Config.replayserver(), FightState.Spectate, this);
+        super(FightSystem.getPlugin(), Config.GameModeConfig.Times.SpectatorDuration, FightCountdownAdapter.presentation(new Message("SHUTDOWN_COUNTDOWN"), SWSound.BLOCK_NOTE_PLING, false));
+        new StateDependentCountdown<>(FightState.lifecycle, ArenaMode.NotRestartable.contains(GameConfig.mode) && !GameConfig.replayserver(), FightState.Spectate, this);
    }

    @Override
-    public void countdownFinished() {
+    protected void countdownFinished() {
        FightSystem.shutdown();
    }
 }
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Chaoscaot	12e085600e	Move arena runtime configuration into GameCore - Replace FightSystem runtime properties with shared GameConfig - Update dependent modules, commands, states, and tests	2026-07-24 12:51:03 +02:00
Chaoscaot	f8cda32119	Remove File	2026-07-24 12:19:35 +02:00
Chaoscaot	867ca6f5dc	Migrate FightSystem modes and countdowns to GameCore - Move shared arena-mode abstractions into GameCore - Adapt fight countdowns and APIs to the shared model - Add SteamWar issue audit workflow and SQL language settings	2026-07-24 12:18:49 +02:00
YoyoNow	badff1c70f	Merge pull request 'Fix Wind Charges remove Water, interact with Blocks and cross middle' (#455 ) from FightSystem/Windcharge into main Reviewed-on: SteamWar/SteamWar#455	2026-07-18 15:00:18 +02:00
Sakziea	1d2ac4f705	Fix pull Request comment	2026-07-18 14:58:24 +02:00
Sakziea	b48c75ef74	Remove unused imports	2026-07-18 12:49:23 +02:00
Sakziea	8b6ea12a08	Add Wind charge config	2026-07-18 12:43:46 +02:00
Sakziea	801678ddd3	Fix Wind charges cross middle and interact with Blocks	2026-07-18 12:43:23 +02:00
Sakziea	e5cc874834	Fix Windcharge remove Water	2026-07-18 11:08:51 +02:00
YoyoNow	95119fc93f	Fix FightServer.kt and VelocityServer.kt @get:Optional annotations complaining about primitive types of field	2026-07-17 16:40:38 +02:00
YoyoNow	d84ca3547a	Merge pull request 'Fix AutoChecker only counts filled Dispenser' (#453 ) from SchematicSystem/AutoPrüfer into main Reviewed-on: SteamWar/SteamWar#453 Reviewed-by: YoyoNow <4+yoyonow@noreply.localhost>	2026-07-17 14:27:01 +02:00
Sakziea	25ab79abc0	Fix PullRequest comment	2026-07-17 14:23:55 +02:00
Sakziea	582d6a62e3	Fix PullRequest comment	2026-07-17 14:22:36 +02:00
Chaoscaot	5eec792aff	Merge branch 'main' of https://git.steamwar.de/SteamWar/SteamWar	2026-07-17 12:05:00 +02:00
Chaoscaot	e0f26c3e8d	Delete event relations when fights and groups are removed	2026-07-17 12:03:15 +02:00
YoyoNow	a59e9b4343	Closes: #323	2026-07-17 10:06:48 +02:00
Sakziea	a8c68864d8	Fix AutoChecker only counts filled Dispenser	2026-07-16 17:07:37 +02:00
YoyoNow	c0668723d7	Merge pull request 'Add GameModeConfig.KitsConfig.MaxBlastResistance for disabling all Blocks with more than 9.0 blast resistance' (#451 ) from UpdateGameModeConfig into main Reviewed-on: SteamWar/SteamWar#451	2026-07-16 16:42:16 +02:00
YoyoNow	5bc2daf37a	Add GameModeConfig.KitsConfig.MaxBlastResistance for disabling all Blocks with more than 9.0 blast resistance	2026-07-16 16:39:56 +02:00
YoyoNow	e6d39da36b	Add GameModeConfig.KitsConfig.MaxBlastResistance for disabling all Blocks with more than 9.0 blast resistance	2026-07-16 16:39:27 +02:00
YoyoNow	390d388692	Closes: #442	2026-07-16 16:32:35 +02:00
YoyoNow	9a60ac228c	Merge pull request 'Making /trace isolate toggle the tnt on and off to normal Trace show' (#445 ) from BauSystem/Trace into main Reviewed-on: SteamWar/SteamWar#445 Reviewed-by: YoyoNow <4+yoyonow@noreply.localhost>	2026-07-16 16:24:16 +02:00
Sakziea	dab443b989	Fix pullRequest comments	2026-07-16 16:23:52 +02:00
Sakziea	bf3c65c630	Fix when no tnt isolated show normal	2026-07-14 19:47:08 +02:00
Sakziea	b488c4ed7c	Fix /trace isolate {id} showing tnt from other traces	2026-07-14 19:29:12 +02:00
Sakziea	2e795aaf8e	Fix /trace 1 still showes all the tnt of that trace	2026-07-06 17:49:09 +02:00
Sakziea	7a601235f5	Fix Trace isolating the same Tnt shows all Tnts	2026-07-06 17:27:47 +02:00
Chaoscaot	62e855ec1b	Fix Reset Signed-off-by: Chaoscaot <max@maxsp.de>	2026-07-05 14:39:20 +02:00
YoyoNow	9e7311934f	Convert buildSrc from gradle/groovy to kts/kotlin	2026-07-05 14:14:04 +02:00
Chaoscaot	6fd3e6f690	Fix Reset Signed-off-by: Chaoscaot <max@maxsp.de>	2026-07-05 13:51:45 +02:00
Chaoscaot	7acd51fd61	Fix Reset Signed-off-by: Chaoscaot <max@maxsp.de>	2026-07-05 13:45:59 +02:00
Chaoscaot	b278ca15f3	Fix Devserver Signed-off-by: Chaoscaot <max@maxsp.de>	2026-07-05 13:41:01 +02:00
Chaoscaot	029249c2b0	Fix Database Reset Signed-off-by: Chaoscaot <max@maxsp.de>	2026-07-05 13:23:52 +02:00
Chaoscaot	1ceb10439b	Fix Database Reset Signed-off-by: Chaoscaot <max@maxsp.de>	2026-07-05 13:18:38 +02:00
Chaoscaot	a5dfe6ab7e	Fix Database Reset Signed-off-by: Chaoscaot <max@maxsp.de>	2026-07-05 12:59:29 +02:00
YoyoNow	c8a5f567eb	Add StreamingCommand for UserPerm.PREFIX_YOUTUBER	2026-07-05 11:54:07 +02:00
Chaoscaot	47fb4da85b	Fix Inventory Signed-off-by: Chaoscaot <max@maxsp.de>	2026-06-20 21:43:05 +02:00
YoyoNow	0eef22aab0	Fix ServerStarter.tempWorld	2026-06-20 17:42:16 +02:00
D4rkr34lm	013d18614f	Fix player nametags showing	2026-06-20 17:20:25 +02:00
YoyoNow	c7c1ab64e0	Fix BoatRace	2026-06-18 15:30:07 +02:00
Chaoscaot	b68a27fbb6	Merge pull request 'SWUI V2' (#418 ) from swui-v2 into main Reviewed-on: SteamWar/SteamWar#418 Reviewed-by: D4rkr34lm <dark@steamwar.de> Reviewed-by: YoyoNow <4+yoyonow@noreply.localhost>	2026-06-18 14:10:59 +02:00
Chaoscaot	7038dc2aa5	Merge branch 'main' into swui-v2	2026-06-17 21:49:52 +02:00
Chaoscaot	7af586ec16	Fix Observer Signed-off-by: Chaoscaot <max@maxsp.de>	2026-06-17 21:48:27 +02:00
YoyoNow	b04e99ce54	Merge pull request 'fix(FightSystem): prevent driedGhasts from spawing & plants from growing' (#434 ) from FightSystem/fix-dried-ghast-spawning into main Reviewed-on: SteamWar/SteamWar#434 Reviewed-by: YoyoNow <4+yoyonow@noreply.localhost>	2026-06-17 21:24:00 +02:00
YoyoNow	524702fbb9	Merge pull request 'Implement proper stop and not sleep on BauCommand.stop' (#435 ) from VelocityCore/BauCommand#stop into main Reviewed-on: SteamWar/SteamWar#435 Reviewed-by: D4rkr34lm <dark@steamwar.de>	2026-06-17 21:23:33 +02:00
D4rkr34lm	e07298e748	Move listener to permanent	2026-06-17 21:21:17 +02:00
YoyoNow	e1df793e9f	Merge pull request 'VelocityCore /check command' (#430 ) from VelocityCore/CheckCommand into main Reviewed-on: SteamWar/SteamWar#430 Reviewed-by: D4rkr34lm <dark@steamwar.de>	2026-06-17 21:17:54 +02:00
YoyoNow	806a1affea	Merge pull request 'fix(BauSystem): advanced flag entities being misplaced' (#433 ) from wip/fix-advanced-flag into main Reviewed-on: SteamWar/SteamWar#433 Reviewed-by: YoyoNow <4+yoyonow@noreply.localhost>	2026-06-17 21:14:27 +02:00
YoyoNow	c538cdbbd2	Implement proper stop and not sleep on BauCommand.stop	2026-06-17 21:13:57 +02:00
D4rkr34lm	d7ba19049a	Add event handler	2026-06-17 21:10:55 +02:00
D4rkr34lm	47909b6f07	Add listener to prevent dried ghasts from growing	2026-06-17 21:09:07 +02:00
YoyoNow	48846a698f	Fix TestblockCommand tab complete order	2026-06-17 21:04:34 +02:00
D4rkr34lm	b771c95b99	Fix advanced flag and add lsp files to gitignore	2026-06-17 20:28:33 +02:00
YoyoNow	d0aada2b00	Deactivate AdvancementsManager	2026-06-17 16:16:39 +02:00
YoyoNow	6522fc77f2	Improve color gradient	2026-06-17 11:14:53 +02:00
YoyoNow	27e01a56ae	Improve CheckCommand	2026-06-17 11:09:32 +02:00
YoyoNow	ed89770c0f	Fix ConcurrentModificationException	2026-06-17 11:04:07 +02:00
YoyoNow	3ec3c90f04	Fix message on join	2026-06-17 10:57:04 +02:00
YoyoNow	73d4ed26c8	Implement CheckCommand for Checkers not having Check perm	2026-06-17 10:52:32 +02:00
YoyoNow	256bcfb1bf	Update CheckCommand	2026-06-17 10:52:32 +02:00
YoyoNow	28ce288815	Merge pull request 'Velocity core/ advancements' (#429 ) from VelocityCore/Advancements into main Reviewed-on: SteamWar/SteamWar#429	2026-06-17 10:24:21 +02:00
YoyoNow	6599dd026a	Update CustomMap	2026-06-15 09:24:46 +02:00
YoyoNow	03052b677f	Update CustomMap	2026-06-15 09:20:21 +02:00
YoyoNow	f76a6fa79d	Merge pull request 'fix(VelocityCore): server starter copping world to wrong path' (#427 ) from fix-event-server-naming into main Reviewed-on: SteamWar/SteamWar#427 Reviewed-by: YoyoNow <4+yoyonow@noreply.localhost>	2026-06-14 21:47:31 +02:00
D4rkr34lm	7fb7f46ca7	Fix path issues	2026-06-14 00:58:41 +02:00
YoyoNow	1269b7f00a	Fix NoClipCommand	2026-06-12 22:16:00 +02:00
YoyoNow	91a0685724	Fix Missile spawning	2026-06-12 21:41:20 +02:00
YoyoNow	72dd2ef59a	Fix Missile spawning	2026-06-12 20:43:43 +02:00
YoyoNow	54a1549973	Fix Missile spawning	2026-06-12 20:30:44 +02:00
D4rkr34lm	fd5f5b92b4	Merge pull request 'fix(SchematicSystem): mixup of coordinates in size check' (#426 ) from fix-autochecker into main Reviewed-on: SteamWar/SteamWar#426	2026-06-12 19:59:48 +02:00
D4rkr34lm	60dc5e4442	Fix formatiing	2026-06-12 19:56:12 +02:00
D4rkr34lm	4cdaf759af	Fix mixup of dimensions in autochecker	2026-06-12 19:54:06 +02:00
YoyoNow	6e919d9148	Fix AdvancementsManager (cherry picked from commit `c221989f9c`)	2026-06-12 16:29:28 +02:00
YoyoNow	a20ec8c93d	Add comment in Items	2026-06-12 15:36:21 +02:00
YoyoNow	18b65a2984	Remove item.json Improve AdvancementsManager	2026-06-12 15:35:13 +02:00
YoyoNow	669235709e	Fix WorldEditListener	2026-06-12 15:14:09 +02:00
YoyoNow	796e154c1c	Fix paper in inventory	2026-06-12 15:07:46 +02:00
YoyoNow	9efe35fe0d	Update LobbySystem run task	2026-06-12 14:52:46 +02:00
YoyoNow	e0aaacd66a	Fix AnvilGUI for 1.21 not being mojmapped	2026-06-12 14:52:03 +02:00
YoyoNow	7adb1e8b4a	Remove automatic update for now	2026-06-12 14:22:44 +02:00
YoyoNow	b88e592e79	Move item.json	2026-06-12 14:21:45 +02:00
YoyoNow	914134600e	Improve Advancements performance	2026-06-12 14:19:47 +02:00
Chaoscaot	27877938bc	Add support for GameMode templates and YAML-based configuration handling in DevCommand. Signed-off-by: Chaoscaot <max@maxsp.de>	2026-06-12 12:29:56 +02:00
YoyoNow	701964c2f2	Fix DevCommand.kt	2026-06-12 12:15:07 +02:00
Chaoscaot	70c8678c60	Refactor rendering system: Introduced `RenderObject` abstraction, replaced `RenderBoundary` with `ObserverListener`, and updated slot calculation for inventory types. Signed-off-by: Chaoscaot <max@maxsp.de>	2026-06-12 12:00:04 +02:00
YoyoNow	6cbfc94e6d	Merge pull request 'Access widener for paper' (#420 ) from AccessWidener into main Reviewed-on: SteamWar/SteamWar#420 Reviewed-by: Chaoscaot <max@chaoscaot.de>	2026-06-12 11:16:33 +02:00
YoyoNow	c0ff123279	Fix EntityDamage only applying cancel for Player	2026-06-12 11:09:13 +02:00
YoyoNow	5511a1f08e	Fix steamwar.devserver.gradle	2026-06-12 10:41:18 +02:00
YoyoNow	8c8da355bb	Fix build.yml	2026-06-12 10:02:34 +02:00
Chaoscaot	7326ed4aa0	Merge pull request 'Remove some deprecated code in favor of newer code' (#421 ) from RemoveDeprecatedCode into main Reviewed-on: SteamWar/SteamWar#421 Reviewed-by: Chaoscaot <max@chaoscaot.de>	2026-06-12 09:58:05 +02:00
YoyoNow	2d59eb81c7	Fix ColorInit and CustomMap deprecation warnings	2026-06-12 09:49:32 +02:00
YoyoNow	711920464a	Remove some deprecated code in favor of newer code	2026-06-12 09:37:43 +02:00
YoyoNow	117dbd08ae	Implement startup arguments into steamwar.devserver.gradle	2026-06-11 23:54:42 +02:00
YoyoNow	b36464e69e	Implement Velocity changes	2026-06-11 23:50:34 +02:00
YoyoNow	f5ac006c0c	Fix REntity.EntityDataPacketBuilder	2026-06-11 23:49:38 +02:00
YoyoNow	414bfbfe3c	Fix ClassTransformer public constructor	2026-06-11 23:48:33 +02:00
YoyoNow	c362a3e1f0	Remove unused code	2026-06-11 23:24:11 +02:00
YoyoNow	2b43af8851	Remove unneded reflection	2026-06-11 23:22:05 +02:00
YoyoNow	1590f8f0ee	Remove Reflection	2026-06-11 23:18:22 +02:00
YoyoNow	932732737d	Unreflect more stuff	2026-06-11 22:35:13 +02:00
YoyoNow	2bc164c1b0	Extract widener definition into a widener.gradle.kts plugin	2026-06-11 20:38:33 +02:00
YoyoNow	aa66b3dc83	Optimize imports	2026-06-11 18:29:44 +02:00
YoyoNow	f5d9c6e175	Unreflect everything	2026-06-11 18:26:15 +02:00
YoyoNow	36b31fac77	Remove unneeded code Cleanup build.gradle.kts	2026-06-11 13:49:35 +02:00
YoyoNow	641cefad01	Add comments to bausystem.accesswidener	2026-06-11 13:46:55 +02:00
YoyoNow	eb866125ea	Remove reflection from BauSystem	2026-06-11 13:45:49 +02:00
YoyoNow	961331f029	Fix Agent and WideningTransformer and ClassPatcher	2026-06-11 13:19:04 +02:00
YoyoNow	786257ad0e	Add initial AccessWidener	2026-06-11 12:22:44 +02:00
Chaoscaot	997292d58e	Merge branch 'main' into swui-v2	2026-06-10 21:43:25 +02:00
Chaoscaot	8050f51424	Cleanup for Merge Signed-off-by: Chaoscaot <max@maxsp.de>	2026-06-10 21:43:02 +02:00
YoyoNow	e176b3bca8	Fix steamwar.devserver.gradle 'worldName' parameter	2026-06-10 20:46:13 +02:00
Chaoscaot	a6681ffaf6	Add Top-Level State and more Utils Signed-off-by: Chaoscaot <max@maxsp.de>	2026-06-10 16:07:37 +02:00
Chaoscaot	a23530074c	Merge remote-tracking branch 'origin/swui-v2' into swui-v2	2026-06-10 09:28:24 +02:00
Chaoscaot	e88a4c624b	Merge branch 'main' into swui-v2	2026-06-10 09:28:16 +02:00
Chaoscaot	105beaf7a6	Merge branch 'main' into swui-v2	2026-06-10 09:27:59 +02:00
Chaoscaot	5f7ab3cd7b	Updates Signed-off-by: Chaoscaot <max@maxsp.de>	2026-06-10 09:26:04 +02:00
YoyoNow	f81f05c3d0	Merge pull request 'Add RedstoneEngineCommand' (#406 ) from BauSystem/RedstoneEngineCommand into main Reviewed-on: SteamWar/SteamWar#406 Reviewed-by: D4rkr34lm <dark@steamwar.de>	2026-06-10 09:04:15 +02:00
YoyoNow	0afb6ce06a	Merge branch 'main' into BauSystem/RedstoneEngineCommand	2026-06-10 09:03:55 +02:00
Chaoscaot	5ce69e6b7a	SWUI V2 Signed-off-by: Chaoscaot <max@maxsp.de>	2026-06-10 00:36:18 +02:00
YoyoNow	a938abde3f	Add 'debug' property to enable/disable debugger	2026-06-09 23:00:46 +02:00
YoyoNow	ec9b0387c5	Fix permission for BlastResistanceCommand	2026-06-09 16:42:40 +02:00
YoyoNow	03c3d49659	Add BlastResistanceCommand	2026-06-09 16:38:22 +02:00
Chaoscaot	8d9a77ab67	Merge pull request 'chore(VelocityCore): reennable replays for serverteam' (#417 ) from wip/VelocityCore-reenable-replays-for-serverteam into main Reviewed-on: SteamWar/SteamWar#417 Reviewed-by: Chaoscaot <max@chaoscaot.de>	2026-06-07 00:06:07 +02:00
D4rkr34lm	fc2997e011	Rennable replays for serverteam	2026-06-06 12:17:23 +02:00
D4rkr34lm	8eb5f5ddf2	fix(BauSystem): cursor not properly disapearing	2026-06-03 21:23:36 +02:00
YoyoNow	aa807060f4	Merge pull request 'fix(SpigotCore): small collection of rendering bugs in new cursor' (#413 ) from BauSystem/fix-small-sim-cursor-bug into main Reviewed-on: SteamWar/SteamWar#413 Reviewed-by: YoyoNow <4+yoyonow@noreply.localhost>	2026-06-02 21:39:13 +02:00
D4rkr34lm	9bbbab9d4b	Fix collection of rendering issues	2026-06-02 21:33:31 +02:00
YoyoNow	7cca4ada10	Merge pull request 'refactor(BauSystem): Extract sim cursor into generic curser and refactor sim cursor' (#410 ) from BauSystem/refactor-sim-cursor-no2 into main Reviewed-on: SteamWar/SteamWar#410 Reviewed-by: YoyoNow <4+yoyonow@noreply.localhost>	2026-06-02 20:22:00 +02:00
YoyoNow	725e6df047	Merge pull request 'fix(SpigotCore): versions above 1.21.6 being kicked from arena' (#412 ) from SpigotCore/fix-newer-version-being-kicked-from-arena into main Reviewed-on: SteamWar/SteamWar#412 Reviewed-by: YoyoNow <4+yoyonow@noreply.localhost>	2026-06-02 20:19:57 +02:00
D4rkr34lm	f3ce124a23	Make dev velocity easier to debug and fix version issue	2026-06-02 20:18:13 +02:00
D4rkr34lm	e83f72a53e	Further simplification	2026-06-01 22:01:52 +02:00
D4rkr34lm	def0c19e43	Refactor simulation cursor to use new generic cursor	2026-06-01 21:51:54 +02:00
D4rkr34lm	3810ccd63d	Add proper onclick handleing	2026-06-01 21:27:34 +02:00
YoyoNow	9e43d5cd1b	Add more Advancements in progression	2026-06-01 14:03:50 +02:00
YoyoNow	2ad9ae3c7f	Fix Advancements Placements	2026-05-31 23:04:08 +02:00
YoyoNow	847eb3fe5d	Add even more Advancements	2026-05-31 22:31:02 +02:00
YoyoNow	8fa9f7b0d3	Add even more Advancements	2026-05-31 21:56:38 +02:00
YoyoNow	559cae2b6d	Add playtime update	2026-05-31 20:20:14 +02:00
YoyoNow	5dbf3638d0	Add Advancement Add Advancements Add AdvancementsManager Add SelectAdvancementTabPacket Add item.json Update ConnectionListener	2026-05-31 18:09:44 +02:00
D4rkr34lm	a018af1c8a	Refactor to use Player components for better usability	2026-05-31 13:20:24 +02:00
YoyoNow	fd8f942014	Fix RedstoneEngine not registering	2026-05-31 11:37:43 +02:00
YoyoNow	eab8826583	Fix RedstoneEngine not registering	2026-05-31 11:36:21 +02:00
YoyoNow	bc0177df43	Add ExperimentalCommand	2026-05-31 00:56:05 +02:00
YoyoNow	1dc78b8eb8	Add RedstoneEngineCommand	2026-05-31 00:44:56 +02:00