Remove YAPION from BauSystem_Main module

Merge pull request 'Fix SteamwarUser.setLocale' (#489 ) from Hut512/SteamWar:fix/setlocale-typo into main
Reviewed-on: #489 Reviewed-by: YoyoNow <4+yoyonow@noreply.localhost>
2026-09-29 14:26:57 +02:00 · 2026-09-14 12:18:40 +02:00 · 2026-09-14 12:18:16 +02:00 · 2026-09-14 12:17:30 +02:00 · 2026-09-14 10:02:39 +02:00 · 2026-09-12 20:07:07 +02:00
255 changed files with 4866 additions and 3630 deletions
@@ -1,151 +0,0 @@
-<?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>
@@ -47,7 +47,7 @@ dependencies {
    compileOnly(libs.netty)

    implementation(libs.luaj)
-    implementation(files("$projectDir/../libs/YAPION-SNAPSHOT.jar"))
+    // implementation(files("$projectDir/../libs/YAPION-SNAPSHOT.jar"))
 }

 widener {
@@ -20,8 +20,7 @@
 package de.steamwar.bausystem;

 import de.steamwar.bausystem.config.BauServer;
-import de.steamwar.bausystem.configplayer.Config;
-import de.steamwar.bausystem.configplayer.ConfigConverter;
+import de.steamwar.bausystem.config.ConfigStore;
 import de.steamwar.bausystem.features.gui.BauGUI;
 import de.steamwar.bausystem.features.script.lua.SteamWarLuaPlugin;
 import de.steamwar.bausystem.features.script.lua.libs.LuaLib;
@@ -32,16 +31,17 @@ import de.steamwar.bausystem.features.tracer.TraceManager;
 import de.steamwar.bausystem.features.tracer.TraceRecorder;
 import de.steamwar.bausystem.features.world.BauScoreboard;
 import de.steamwar.bausystem.linkage.BauGuiItem;
+import de.steamwar.bausystem.region.Region;
 import de.steamwar.bausystem.region.RegionSystem;
 import de.steamwar.bausystem.utils.ScoreboardElement;
 import de.steamwar.bausystem.utils.TickManager;
-import de.steamwar.bausystem.worlddata.WorldData;
 import de.steamwar.command.AbstractValidator;
 import de.steamwar.command.SWCommandUtils;
 import de.steamwar.core.CRIUSleepEvent;
 import de.steamwar.core.Core;
-import de.steamwar.core.WorldEditRendererCUIEditor;
 import de.steamwar.core.WorldIdentifier;
+import de.steamwar.core.worldedit.SteamEdit;
+import de.steamwar.core.worldedit.WorldEditRendererCUIEditor;
 import de.steamwar.linkage.AbstractLinker;
 import de.steamwar.linkage.SpigotLinker;
 import de.steamwar.message.Message;
@@ -49,6 +49,7 @@ import de.steamwar.providers.BauServerInfo;
 import lombok.Getter;
 import org.bukkit.Bukkit;
 import org.bukkit.GameRule;
+import org.bukkit.Location;
 import org.bukkit.command.CommandSender;
 import org.bukkit.entity.Player;
 import org.bukkit.event.EventHandler;
@@ -109,9 +110,6 @@ public class BauSystem extends JavaPlugin implements Listener {
                if (any instanceof PanzernAlgorithm) {
                    Panzern.add((PanzernAlgorithm) any);
                }
-                if (any instanceof ConfigConverter) {
-                    Config.addConfigConverter((ConfigConverter) any);
-                }
                if (any instanceof BoundingBoxLoader) {
                    ((BoundingBoxLoader) any).load();
                }
@@ -129,7 +127,19 @@ public class BauSystem extends JavaPlugin implements Listener {
        TraceManager.instance.init();
        TraceRecorder.instance.init();

-        new WorldEditRendererCUIEditor();
+        SteamEdit.init();
+        SteamEdit.ADJACENT_FILTERS = location -> {
+            Region region = Region.getRegion(location);
+            Region.Area area;
+            if (region.getBuildArea().inRegion(location, true)) {
+                area = region.getBuildArea();
+            } else if (region.getTestblockArea().inRegion(location, true)) {
+                area = region.getTestblockArea();
+            } else {
+                return SteamEdit.AdjacentFilter.ALWAYS;
+            }
+            return (x, y, z) -> area.inRegion(new Location(null, x, y, z), true);
+        };

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

@@ -145,9 +155,8 @@ public class BauSystem extends JavaPlugin implements Listener {
    @Override
    public void onDisable() {
        linker.unlink();
-        WorldData.write();
        RegionSystem.INSTANCE.save();
-        Config.getInstance().saveAll();
+        ConfigStore.saveAll();
    }

    private <T extends CommandSender> AbstractValidator<T, ?> validator(Permission permission) {
@@ -0,0 +1,47 @@
+/*
+ *   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.bausystem.config;
+
+/**
+ * Converts a config of one version into the next version, e.g. ConfigV1 to
+ * ConfigV2. The converter for the second newest version converts into the
+ * current version. Converters are registered in the {@link ConfigStore}
+ * of the config.
+ *
+ * @param <F> the config version to convert from
+ * @param <T> the config version to convert to
+ */
+public interface ConfigConverter<F extends VersionedConfig, T extends VersionedConfig> {
+
+    /**
+     * @return the version this converter converts from
+     */
+    int version();
+
+    /**
+     * Converts the config to the next version. If anything goes wrong do not
+     * silently exit this method, throw an Exception. The {@link ConfigStore}
+     * will deal with it.
+     *
+     * @param config the config to convert
+     * @return the converted config
+     */
+    T convert(F config);
+}
@@ -0,0 +1,364 @@
+/*
+ *   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.config;
+
+import com.google.gson.Gson;
+import com.google.gson.JsonObject;
+import com.google.gson.JsonParser;
+import de.steamwar.sql.UserConfig;
+import org.bukkit.Bukkit;
+import org.bukkit.entity.Player;
+
+import java.io.File;
+import java.io.IOException;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.StandardCopyOption;
+import java.util.*;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.function.Function;
+import java.util.function.Predicate;
+import java.util.function.Supplier;
+import java.util.logging.Level;
+
+/**
+ * Loads, converts and saves a versioned config stored as JSON. Older versions
+ * are converted with the registered {@link ConfigConverter}s, legacy formats
+ * that are not JSON can be read with {@link #legacy(Predicate, Function)}.
+ * <p>
+ * A store can be bound to where the config is stored:
+ * <ul>
+ *     <li>{@link #userConfig(String)}: one config per player in the {@link UserConfig}, use {@link #get(Player)}</li>
+ *     <li>{@link #file(File)}: one config in a file, use {@link #get()}</li>
+ *     <li>unbound: use {@link #load(File)} and {@link #save(File, VersionedConfig)}</li>
+ * </ul>
+ *
+ * @param <T> the current config version
+ */
+public class ConfigStore<T extends VersionedConfig> {
+
+    private static final List<ConfigStore<?>> STORES = new ArrayList<>();
+
+    private final Class<T> type;
+    private final int version;
+    private final Supplier<T> defaultConfig;
+
+    private final Map<Integer, Class<? extends VersionedConfig>> jsonVersions = new HashMap<>();
+    private final Map<Integer, ConfigConverter<?, ?>> converters = new HashMap<>();
+    private final List<LegacyFormat> legacyFormats = new ArrayList<>();
+    private Gson gson = new Gson();
+    private Integer unversionedVersion = null;
+
+    private String userConfigKey = null;
+    private Predicate<T> removeIf = config -> false;
+    private final Map<UUID, T> playerConfigs = new ConcurrentHashMap<>();
+
+    private File file = null;
+    private File legacyFile = null;
+    private Function<String, ? extends VersionedConfig> legacyFileReader = null;
+    private T fileConfig = null;
+
+    private record LegacyFormat(Predicate<String> matches, Function<String, ? extends VersionedConfig> reader) {
+    }
+
+    public ConfigStore(Class<T> type, int version, Supplier<T> defaultConfig) {
+        this.type = type;
+        this.version = version;
+        this.defaultConfig = defaultConfig;
+        jsonVersions.put(version, type);
+        STORES.add(this);
+    }
+
+    public ConfigStore<T> gson(Gson gson) {
+        this.gson = gson;
+        return this;
+    }
+
+    /**
+     * Registers an older config version that is stored as JSON.
+     */
+    public ConfigStore<T> jsonVersion(int version, Class<? extends VersionedConfig> type) {
+        jsonVersions.put(version, type);
+        return this;
+    }
+
+    public ConfigStore<T> converter(ConfigConverter<?, ?> converter) {
+        if (converters.putIfAbsent(converter.version(), converter) != null) {
+            throw new IllegalStateException("Duplicate converter for version " + converter.version() + " of " + type.getSimpleName());
+        }
+        return this;
+    }
+
+    /**
+     * Registers a legacy format that is not JSON, stored strings matching the predicate are read by the reader.
+     */
+    public ConfigStore<T> legacy(Predicate<String> matches, Function<String, ? extends VersionedConfig> reader) {
+        legacyFormats.add(new LegacyFormat(matches, reader));
+        return this;
+    }
+
+    /**
+     * The version of stored JSON without a version field.
+     */
+    public ConfigStore<T> unversioned(int version) {
+        this.unversionedVersion = version;
+        return this;
+    }
+
+    /**
+     * Binds this store to the {@link UserConfig} with the given key, one config per player.
+     */
+    public ConfigStore<T> userConfig(String key) {
+        this.userConfigKey = key;
+        return this;
+    }
+
+    /**
+     * Removes the config from the {@link UserConfig} instead of saving it, if the predicate matches.
+     */
+    public ConfigStore<T> removeIf(Predicate<T> removeIf) {
+        this.removeIf = removeIf;
+        return this;
+    }
+
+    /**
+     * Binds this store to a single file.
+     */
+    public ConfigStore<T> file(File file) {
+        this.file = file;
+        return this;
+    }
+
+    /**
+     * Legacy file to read, if the file of this store does not exist yet.
+     */
+    public ConfigStore<T> legacyFile(File legacyFile, Function<String, ? extends VersionedConfig> reader) {
+        this.legacyFile = legacyFile;
+        this.legacyFileReader = reader;
+        return this;
+    }
+
+    /**
+     * Reads a stored config and converts it to the current version.
+     *
+     * @throws RuntimeException if the config could not be read or converted
+     */
+    public T read(String stored) {
+        for (LegacyFormat legacyFormat : legacyFormats) {
+            if (legacyFormat.matches().test(stored)) {
+                return update(legacyFormat.reader().apply(stored));
+            }
+        }
+
+        JsonObject json = JsonParser.parseString(stored).getAsJsonObject();
+        int storedVersion;
+        if (json.has("version")) {
+            storedVersion = json.get("version").getAsInt();
+        } else if (unversionedVersion != null) {
+            storedVersion = unversionedVersion;
+            json.addProperty("version", storedVersion);
+        } else {
+            throw new IllegalStateException("Missing version of " + type.getSimpleName());
+        }
+        Class<? extends VersionedConfig> storedType = jsonVersions.get(storedVersion);
+        if (storedType == null) {
+            throw new IllegalStateException("Unknown version " + storedVersion + " of " + type.getSimpleName());
+        }
+        return update(gson.fromJson(json, storedType));
+    }
+
+    public String write(T config) {
+        return gson.toJson(config);
+    }
+
+    /**
+     * Converts a config to the current version.
+     */
+    @SuppressWarnings({"unchecked", "rawtypes"})
+    public T update(VersionedConfig config) {
+        while (config.getVersion() < version) {
+            ConfigConverter converter = converters.get(config.getVersion());
+            if (converter == null) {
+                throw new IllegalStateException("No converter found for version " + config.getVersion() + " of " + type.getSimpleName());
+            }
+            VersionedConfig converted = converter.convert(config);
+            if (converted.getVersion() <= config.getVersion()) {
+                throw new IllegalStateException("Version did not increase after conversion of version " + config.getVersion() + " of " + type.getSimpleName());
+            }
+            config = converted;
+        }
+        if (!type.isInstance(config)) {
+            throw new IllegalStateException("Version " + config.getVersion() + " is not the current version of " + type.getSimpleName());
+        }
+        return type.cast(config);
+    }
+
+    /**
+     * @return the config stored in the file, or the default config if the file is missing or empty
+     * @throws RuntimeException if the config could not be read or converted
+     */
+    public T load(File file) throws IOException {
+        if (file.length() == 0) {
+            return defaultConfig.get();
+        }
+        return read(Files.readString(file.toPath(), StandardCharsets.UTF_8));
+    }
+
+    public void save(File file, T config) throws IOException {
+        Files.writeString(file.toPath(), write(config), StandardCharsets.UTF_8);
+    }
+
+    /**
+     * Get the config of a player, loads it from the {@link UserConfig} and converts it if necessary.
+     */
+    public T get(Player player) {
+        requireUserConfig();
+        return playerConfigs.computeIfAbsent(player.getUniqueId(), this::loadPlayer);
+    }
+
+    /**
+     * Save the config of a player, this does not unload the config.
+     */
+    public void save(Player player) {
+        requireUserConfig();
+        T config = playerConfigs.get(player.getUniqueId());
+        if (config != null) {
+            savePlayer(player.getUniqueId(), config);
+        }
+    }
+
+    /**
+     * Save and unload the config of a player.
+     */
+    public void unload(Player player) {
+        if (userConfigKey == null) return;
+        T config = playerConfigs.remove(player.getUniqueId());
+        if (config != null) {
+            savePlayer(player.getUniqueId(), config);
+        }
+    }
+
+    private T loadPlayer(UUID uuid) {
+        String stored = UserConfig.getConfig(uuid, userConfigKey);
+        if (stored == null) {
+            return defaultConfig.get();
+        }
+        try {
+            return read(stored);
+        } catch (Exception e) {
+            Bukkit.getLogger().log(Level.SEVERE, "Could not load " + type.getSimpleName() + " of " + uuid, e);
+            return defaultConfig.get();
+        }
+    }
+
+    private void savePlayer(UUID uuid, T config) {
+        if (removeIf.test(config)) {
+            UserConfig.removePlayerConfig(uuid, userConfigKey);
+        } else {
+            UserConfig.updatePlayerConfig(uuid, userConfigKey, write(config));
+        }
+    }
+
+    private void requireUserConfig() {
+        if (userConfigKey == null) {
+            throw new IllegalStateException(type.getSimpleName() + " is not stored in the UserConfig");
+        }
+    }
+
+    /**
+     * Get the config of the file of this store, loads it and converts it if necessary.
+     */
+    public T get() {
+        requireFile();
+        if (fileConfig == null) {
+            fileConfig = loadFile();
+            save();
+        }
+        return fileConfig;
+    }
+
+    /**
+     * Save the config to the file of this store, if it was loaded.
+     */
+    public void save() {
+        requireFile();
+        if (fileConfig == null) return;
+        try {
+            save(file, fileConfig);
+        } catch (IOException e) {
+            Bukkit.getLogger().log(Level.SEVERE, "Could not write " + file, e);
+        }
+    }
+
+    private T loadFile() {
+        try {
+            if (file.length() != 0) {
+                return load(file);
+            }
+            if (legacyFile != null && legacyFile.length() != 0) {
+                return update(legacyFileReader.apply(Files.readString(legacyFile.toPath(), StandardCharsets.UTF_8)));
+            }
+            return defaultConfig.get();
+        } catch (Exception e) {
+            Bukkit.getLogger().log(Level.SEVERE, "Could not load " + file + ", using default " + type.getSimpleName(), e);
+            backupBrokenFile();
+            return defaultConfig.get();
+        }
+    }
+
+    private void backupBrokenFile() {
+        if (file.length() == 0) return;
+        try {
+            Files.copy(file.toPath(), new File(file.getParentFile(), file.getName() + ".broken").toPath(), StandardCopyOption.REPLACE_EXISTING);
+        } catch (IOException e) {
+            Bukkit.getLogger().log(Level.SEVERE, "Could not backup broken " + file, e);
+        }
+    }
+
+    private void requireFile() {
+        if (file == null) {
+            throw new IllegalStateException(type.getSimpleName() + " is not bound to a file");
+        }
+    }
+
+    static void unloadAll(Player player) {
+        STORES.forEach(store -> store.unload(player));
+    }
+
+    /**
+     * Saves every loaded config and unloads the configs of the players.
+     */
+    public static void saveAll() {
+        for (ConfigStore<?> store : STORES) {
+            if (store.userConfigKey != null) {
+                store.playerConfigs.forEach((uuid, config) -> saveUnchecked(store, uuid, config));
+                store.playerConfigs.clear();
+            }
+            if (store.file != null) {
+                store.save();
+            }
+        }
+    }
+
+    @SuppressWarnings("unchecked")
+    private static <T extends VersionedConfig> void saveUnchecked(ConfigStore<T> store, UUID uuid, Object config) {
+        store.savePlayer(uuid, (T) config);
+    }
+}
@@ -0,0 +1,45 @@
+/*
+ *   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.config;
+
+import de.steamwar.core.CRIUSleepEvent;
+import de.steamwar.linkage.Linked;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.Listener;
+import org.bukkit.event.player.PlayerQuitEvent;
+
+/**
+ * Saves and unloads the configs of the {@link ConfigStore}s bound to the UserConfig
+ * when a player quits, configs are loaded on first use.
+ */
+@Linked
+public class ConfigStoreListener implements Listener {
+
+    @EventHandler(priority = EventPriority.MONITOR)
+    public void onPlayerQuit(PlayerQuitEvent event) {
+        ConfigStore.unloadAll(event.getPlayer());
+    }
+
+    @EventHandler
+    public void onCRIUSleep(CRIUSleepEvent event) {
+        ConfigStore.saveAll();
+    }
+}
@@ -17,15 +17,13 @@
 *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */

-package de.steamwar.kotlin.ui
+package de.steamwar.bausystem.config;

-abstract class ObserverListener {
-    val observers = mutableSetOf<Observable<*>>()
+/**
+ * Common interface of every version of a config stored by a {@link ConfigStore},
+ * the current version (e.g. Config) and every older version (ConfigV1, ConfigV2, ...).
+ */
+public interface VersionedConfig {

-    abstract fun update()
-
-    open fun destroy() {
-        observers.forEach { it.removeListener(this) }
-        observers.clear()
-    }
-}
+    int getVersion();
+}
@@ -0,0 +1,95 @@
+/*
+ *   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.config.legacy;
+
+import lombok.experimental.UtilityClass;
+import org.bukkit.configuration.serialization.ConfigurationSerialization;
+import org.bukkit.inventory.ItemStack;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * Deserializes {@link ItemStack}s that were serialized by YAPION, read with {@link YapionReader}.
+ */
+@UtilityClass
+@Deprecated
+public class YapionItemDeserializer {
+
+    private static final String TYPE_IDENTIFIER = "@type";
+
+    public ItemStack deserializeItem(Object yapion) {
+        if (yapion == null) return null;
+        Object result = deserialize(yapion);
+        if (result instanceof ItemStack itemStack) return itemStack;
+        throw new IllegalArgumentException("Not an ItemStack: " + result);
+    }
+
+    private Object deserialize(Object yapion) {
+        if (yapion instanceof List<?> list) {
+            List<Object> result = new ArrayList<>();
+            list.forEach(o -> result.add(deserialize(o)));
+            return result;
+        }
+        if (yapion instanceof YapionReader.YapionMap map) {
+            Map<Object, Object> result = new LinkedHashMap<>();
+            map.entries().forEach((key, value) -> result.put(deserialize(key), deserialize(value)));
+            return result;
+        }
+        if (yapion instanceof Map<?, ?> object) {
+            return deserializeObject(object);
+        }
+        return yapion;
+    }
+
+    private Object deserializeObject(Map<?, ?> object) {
+        Map<String, Object> data = new LinkedHashMap<>();
+        object.forEach((key, value) -> {
+            if (!TYPE_IDENTIFIER.equals(key)) data.put((String) key, deserialize(value));
+        });
+
+        if (!(object.get(TYPE_IDENTIFIER) instanceof String type)) {
+            return data;
+        }
+
+        Class<?> javaType = javaUtilClass(type);
+        if (javaType != null && Collection.class.isAssignableFrom(javaType)) {
+            return data.getOrDefault("values", new ArrayList<>());
+        }
+        if (javaType != null && Map.class.isAssignableFrom(javaType)) {
+            return data.containsKey("values") ? data.get("values") : data;
+        }
+
+        data.put(ConfigurationSerialization.SERIALIZED_TYPE_KEY, type.equals("org.bukkit.inventory.meta.ItemMeta") ? "ItemMeta" : type);
+        return ConfigurationSerialization.deserializeObject(data);
+    }
+
+    private Class<?> javaUtilClass(String type) {
+        if (!type.startsWith("java.util.")) return null;
+        try {
+            return Class.forName(type);
+        } catch (ClassNotFoundException e) {
+            return null;
+        }
+    }
+}
@@ -0,0 +1,323 @@
+/*
+ *   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.config.legacy;
+
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.regex.Pattern;
+
+/**
+ * Minimal reader for the legacy YAPION format, only used to migrate old data.
+ * <p>
+ * The result is built from plain java objects:
+ * <ul>
+ *     <li>YAPION objects {@code {key(value)}} become a {@link LinkedHashMap} of String to value</li>
+ *     <li>YAPION arrays {@code [a,b]} become a {@link List}</li>
+ *     <li>YAPION maps {@code <(a):(b)>} become a {@link YapionMap}</li>
+ *     <li>YAPION values {@code (value)} become null, Boolean, Number or String</li>
+ * </ul>
+ */
+@Deprecated
+public class YapionReader {
+
+    private static final Pattern INTEGER = Pattern.compile("[-+]?\\d+");
+    private static final Pattern DECIMAL = Pattern.compile("[-+]?(\\d+\\.\\d*|\\.\\d+|\\d+)([eE][-+]?\\d+)?");
+
+    public record YapionMap(Map<Object, Object> entries) {
+    }
+
+    public static Map<String, Object> parse(String yapion) {
+        YapionReader reader = new YapionReader(yapion);
+        reader.skipWhitespace();
+        Map<String, Object> result = reader.readObject();
+        reader.skipWhitespace();
+        if (reader.index != yapion.length()) {
+            throw reader.error("Unexpected trailing content");
+        }
+        return result;
+    }
+
+    public static double getDouble(Map<?, ?> object, String key, double defaultValue) {
+        return object.get(key) instanceof Number value ? value.doubleValue() : defaultValue;
+    }
+
+    public static int getInt(Map<?, ?> object, String key, int defaultValue) {
+        return object.get(key) instanceof Number value ? value.intValue() : defaultValue;
+    }
+
+    public static boolean getBoolean(Map<?, ?> object, String key, boolean defaultValue) {
+        return object.get(key) instanceof Boolean value ? value : defaultValue;
+    }
+
+    public static String getString(Map<?, ?> object, String key, String defaultValue) {
+        return object.get(key) instanceof String value ? value : defaultValue;
+    }
+
+    /**
+     * @return the entries of the array that are YAPION objects
+     */
+    public static List<Map<?, ?>> getObjects(Map<?, ?> object, String key) {
+        List<Map<?, ?>> objects = new ArrayList<>();
+        if (object.get(key) instanceof List<?> array) {
+            array.forEach(o -> {
+                if (o instanceof Map<?, ?> map) objects.add(map);
+            });
+        }
+        return objects;
+    }
+
+    private final String input;
+    private int index = 0;
+
+    private YapionReader(String input) {
+        this.input = input;
+    }
+
+    private Object readAny() {
+        return switch (peek()) {
+            case '{' -> readObject();
+            case '[' -> readArray();
+            case '<' -> readMap();
+            case '(' -> readValue();
+            default -> throw error("Expected '{', '[', '<' or '('");
+        };
+    }
+
+    private Map<String, Object> readObject() {
+        expect('{');
+        Map<String, Object> object = new LinkedHashMap<>();
+        while (true) {
+            skipWhitespace();
+            if (peek() == '}') {
+                index++;
+                return object;
+            }
+            StringBuilder key = new StringBuilder();
+            while (true) {
+                char c = peek();
+                if (c == '(' || c == '{' || c == '[' || c == '<') break;
+                if (c == '}') throw error("Key without value");
+                key.append(readChar());
+            }
+            object.put(key.toString(), readAny());
+        }
+    }
+
+    private List<Object> readArray() {
+        expect('[');
+        List<Object> array = new ArrayList<>();
+        skipWhitespace();
+        if (peek() == ']') {
+            index++;
+            return array;
+        }
+        while (true) {
+            int start = index;
+            skipWhitespace();
+            char c = peek();
+            if (c == '{' || c == '[' || c == '<' || c == '(') {
+                array.add(readAny());
+                skipWhitespace();
+            } else {
+                // Whitespace is part of plain values
+                index = start;
+                StringBuilder value = new StringBuilder();
+                while (peek() != ',' && peek() != ']') {
+                    value.append(readChar());
+                }
+                array.add(typed(value.toString()));
+            }
+            char separator = input.charAt(index++);
+            if (separator == ']') return array;
+            if (separator != ',') throw error("Expected ',' or ']'");
+        }
+    }
+
+    private YapionMap readMap() {
+        expect('<');
+        Map<Object, Object> map = new LinkedHashMap<>();
+        while (true) {
+            skipWhitespace();
+            if (peek() == '>') {
+                index++;
+                return new YapionMap(map);
+            }
+            Object key = readAny();
+            skipWhitespace();
+            expect(':');
+            skipWhitespace();
+            map.put(key, readAny());
+        }
+    }
+
+    /**
+     * YAPION does not escape parentheses in values, balanced parentheses are part of the value.
+     * A backslash only escapes a backslash, a unicode sequence or a control character, otherwise it is kept.
+     */
+    private Object readValue() {
+        expect('(');
+        StringBuilder value = new StringBuilder();
+        int depth = 0;
+        while (true) {
+            char c = peek();
+            if (c == '\\') {
+                value.append(readValueEscape());
+                continue;
+            }
+            index++;
+            if (c == '(') {
+                depth++;
+            } else if (c == ')') {
+                if (depth == 0) break;
+                depth--;
+            }
+            value.append(c);
+        }
+        return typed(value.toString());
+    }
+
+    private String readValueEscape() {
+        index++;
+        if (index >= input.length()) return "\\";
+        char escaped = input.charAt(index);
+        switch (escaped) {
+            case '\\', '(', ')':
+                index++;
+                return String.valueOf(escaped);
+            case 'n':
+                index++;
+                return "\n";
+            case 't':
+                index++;
+                return "\t";
+            case 'r':
+                index++;
+                return "\r";
+            case 'u':
+                if (index + 5 <= input.length() && input.substring(index + 1, index + 5).matches("[0-9a-fA-F]{4}")) {
+                    char unicode = (char) Integer.parseInt(input.substring(index + 1, index + 5), 16);
+                    index += 5;
+                    return String.valueOf(unicode);
+                }
+                return "\\";
+            default:
+                return "\\";
+        }
+    }
+
+    /**
+     * Reads one character of a key or plain array value, resolving backslash escapes.
+     * A backslash that does not escape anything is kept, as the old player config
+     * collapsed escaped backslashes into a single one.
+     */
+    private char readChar() {
+        char c = input.charAt(index++);
+        if (c != '\\') return c;
+        if (index >= input.length()) throw error("Unterminated escape");
+        char escaped = input.charAt(index);
+        switch (escaped) {
+            case 'n':
+                index++;
+                return '\n';
+            case 't':
+                index++;
+                return '\t';
+            case 'r':
+                index++;
+                return '\r';
+            case 'u':
+                if (index + 5 <= input.length() && input.substring(index + 1, index + 5).matches("[0-9a-fA-F]{4}")) {
+                    char unicode = (char) Integer.parseInt(input.substring(index + 1, index + 5), 16);
+                    index += 5;
+                    return unicode;
+                }
+                return '\\';
+            case '\\', ',', ' ', '(', ')', '{', '}', '[', ']', '<', '>', '"', ':', '@':
+                index++;
+                return escaped;
+            default:
+                return '\\';
+        }
+    }
+
+    private static Object typed(String value) {
+        if (value.equals("null")) return null;
+        if (value.equals("true")) return true;
+        if (value.equals("false")) return false;
+        if (value.length() >= 2 && value.startsWith("\"") && value.endsWith("\"")) {
+            return value.substring(1, value.length() - 1);
+        }
+        try {
+            if (INTEGER.matcher(value).matches()) {
+                long l = Long.parseLong(value);
+                if (l >= Integer.MIN_VALUE && l <= Integer.MAX_VALUE) return (int) l;
+                return l;
+            }
+            if (value.length() > 1) {
+                String number = value.substring(0, value.length() - 1);
+                switch (value.charAt(value.length() - 1)) {
+                    case 'L':
+                        if (INTEGER.matcher(number).matches()) return Long.parseLong(number);
+                        break;
+                    case 'S':
+                        if (INTEGER.matcher(number).matches()) return Short.parseShort(number);
+                        break;
+                    case 'B':
+                        if (INTEGER.matcher(number).matches()) return Byte.parseByte(number);
+                        break;
+                    case 'F':
+                        if (DECIMAL.matcher(number).matches()) return Float.parseFloat(number);
+                        break;
+                    case 'D':
+                        if (DECIMAL.matcher(number).matches()) return Double.parseDouble(number);
+                        break;
+                    default:
+                        break;
+                }
+            }
+            if (DECIMAL.matcher(value).matches()) return Double.parseDouble(value);
+        } catch (NumberFormatException e) {
+            // Not a number, fall through to String
+        }
+        return value;
+    }
+
+    private void skipWhitespace() {
+        while (index < input.length() && Character.isWhitespace(input.charAt(index))) {
+            index++;
+        }
+    }
+
+    private char peek() {
+        if (index >= input.length()) throw error("Unexpected end of input");
+        return input.charAt(index);
+    }
+
+    private void expect(char c) {
+        if (peek() != c) throw error("Expected '" + c + "'");
+        index++;
+    }
+
+    private IllegalArgumentException error(String message) {
+        return new IllegalArgumentException(message + " at index " + index);
+    }
+}
@@ -0,0 +1,63 @@
+/*
+ *   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.config.serializer;
+
+import com.google.gson.TypeAdapter;
+import com.google.gson.stream.JsonReader;
+import com.google.gson.stream.JsonToken;
+import com.google.gson.stream.JsonWriter;
+import org.bukkit.Bukkit;
+import org.bukkit.inventory.ItemStack;
+
+import java.io.IOException;
+import java.util.Base64;
+import java.util.logging.Level;
+
+/**
+ * Stores an {@link ItemStack} as Base64 of {@link ItemStack#serializeAsBytes()}, which
+ * contains the data version and gets upgraded on newer Minecraft versions.
+ * Empty items are stored as null, items that can't be read are deserialized as null.
+ */
+public class ItemStackTypeAdapter extends TypeAdapter<ItemStack> {
+
+    @Override
+    public void write(JsonWriter out, ItemStack itemStack) throws IOException {
+        if (itemStack == null || itemStack.isEmpty()) {
+            out.nullValue();
+            return;
+        }
+        out.value(Base64.getEncoder().encodeToString(itemStack.serializeAsBytes()));
+    }
+
+    @Override
+    public ItemStack read(JsonReader in) throws IOException {
+        if (in.peek() == JsonToken.NULL) {
+            in.nextNull();
+            return null;
+        }
+        String value = in.nextString();
+        try {
+            return ItemStack.deserializeBytes(Base64.getDecoder().decode(value));
+        } catch (Exception e) {
+            Bukkit.getLogger().log(Level.WARNING, "Could not deserialize ItemStack", e);
+            return null;
+        }
+    }
+}
@@ -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
@@ -19,129 +19,77 @@

 package de.steamwar.bausystem.configplayer;

-import de.steamwar.bausystem.configplayer.serializer.ConfigurationSerializableSerializer;
-import de.steamwar.linkage.Linked;
-import de.steamwar.sql.UserConfig;
+import com.google.gson.GsonBuilder;
+import de.steamwar.bausystem.config.ConfigConverter;
+import de.steamwar.bausystem.config.ConfigStore;
+import de.steamwar.bausystem.config.VersionedConfig;
+import de.steamwar.bausystem.config.serializer.ItemStackTypeAdapter;
+import de.steamwar.bausystem.configplayer.converter.ConfigV1ToV2Converter;
+import de.steamwar.bausystem.features.hotbar.DefaultHotbar;
+import lombok.AccessLevel;
 import lombok.Getter;
-import org.bukkit.Bukkit;
-import org.bukkit.entity.Player;
-import org.bukkit.event.EventHandler;
-import org.bukkit.event.Listener;
-import org.bukkit.event.player.PlayerJoinEvent;
-import org.bukkit.event.player.PlayerQuitEvent;
-import yapion.hierarchy.output.StringOutput;
-import yapion.hierarchy.types.YAPIONObject;
-import yapion.parser.YAPIONParser;
-import yapion.serializing.SerializeManager;
+import lombok.Setter;
+import org.bukkit.inventory.ItemStack;

 import java.util.HashMap;
 import java.util.Map;
-import java.util.UUID;
-import java.util.logging.Level;

-@Linked
-public class Config implements Listener {
+/**
+ * The current player config. It is stored as JSON, fields missing in the
+ * stored JSON keep the default value of their initializer, so adding a new
+ * field does not need a new version.
+ * <p>
+ * When a field gets removed, renamed or its meaning changes, copy this class
+ * to ConfigV{@link #VERSION} (without the {@link #STORE}), increase {@link #VERSION},
+ * write a {@link ConfigConverter} from the copy to this class and register it in the {@link #STORE}.
+ */
+@Getter
+@Setter
+public class Config implements VersionedConfig {

-    static {
-        SerializeManager.add(new ConfigurationSerializableSerializer());
-    }
+    public static final int VERSION = 2;

-    @Getter
-    private static Config instance;
+    public static final ConfigStore<Config> STORE = new ConfigStore<>(Config.class, VERSION, Config::new)
+            .gson(new GsonBuilder().registerTypeHierarchyAdapter(ItemStack.class, new ItemStackTypeAdapter()).create())
+            .legacy(s -> s.startsWith("{@version(1)"), ConfigV1::parse)
+            .converter(new ConfigV1ToV2Converter())
+            .userConfig("bausystem");

-    {
-        instance = this;
-    }
-
-    private final Map<UUID, YAPIONObject> playerConfigurations = new HashMap<>();
-
-    private static final Map<Integer, ConfigConverter> CONFIG_CONVERTER_MAP = new HashMap<>();
-
-    public static void addConfigConverter(ConfigConverter configConverter) {
-        CONFIG_CONVERTER_MAP.putIfAbsent(configConverter.version(), configConverter);
-    }
-
-    @EventHandler
-    public void onPlayerJoin(PlayerJoinEvent event) {
-        get(event.getPlayer());
-    }
-
-    @EventHandler
-    public void onPlayerQuit(PlayerQuitEvent event) {
-        save(event.getPlayer());
-        playerConfigurations.remove(event.getPlayer().getUniqueId());
-    }
+    @Setter(AccessLevel.NONE)
+    protected int version = VERSION;

    /**
-     * Get a PlayerConfig, optionally loads it from the DataBase and migrates it if necessary.
-     *
-     * @param player the player from whom to get the config.
-     * @return the config object
+     * BauGui item id to inventory slot
     */
-    public YAPIONObject get(Player player) {
-        UUID uuid = player.getUniqueId();
-        if (!playerConfigurations.containsKey(uuid)) {
-            String s = UserConfig.getConfig(uuid, "bausystem");
-            YAPIONObject yapionObject;
-            if (s == null) {
-                yapionObject = ConfigCreator.createDefaultConfig();
-            } else {
-                yapionObject = YAPIONParser.parse(s);
-            }
-            yapionObject = update(yapionObject);
-            playerConfigurations.put(uuid, yapionObject);
-            return yapionObject;
-        }
-        return playerConfigurations.get(uuid);
-    }
-
-    public void saveAll() {
-        playerConfigurations.forEach((uuid, yapionObject) -> {
-            String string = yapionObject.toYAPION(new StringOutput()).getResult().replaceAll("\\+", "\\");
-            UserConfig.updatePlayerConfig(uuid, "bausystem", string);
-        });
-        playerConfigurations.clear();
-    }
+    protected Map<Integer, Integer> bauGui = defaultBauGui();
+    protected int bauGuiSize = 45;

    /**
-     * Save a PlayerConfig, this does not remove the key value mapping from the map.
-     *
-     * @param player the player to save the config.
+     * Slots 0-8 are the hotbar, slots 9-12 the armor contents
     */
-    public void save(Player player) {
-        UUID uuid = player.getUniqueId();
-        if (playerConfigurations.containsKey(uuid)) {
-            YAPIONObject yapionObject = playerConfigurations.get(uuid);
-            String string = yapionObject.toYAPION(new StringOutput()).getResult().replaceAll("\\\\+", "\\\\");
-            UserConfig.updatePlayerConfig(uuid, "bausystem", string);
-        }
-    }
+    protected ItemStack[] hotbar = DefaultHotbar.defaultHotbar();

-    private YAPIONObject update(YAPIONObject yapionObject) {
-        int version = yapionObject.getPlainValue("@version");
-        while (version < ConfigCreator.currentVersion) {
-            ConfigConverter configConverter = CONFIG_CONVERTER_MAP.getOrDefault(version, null);
-            if (configConverter == null) {
-                Bukkit.getLogger().log(Level.SEVERE, "No updater found for version " + version);
-                return ConfigCreator.createDefaultConfig();
-            }
-            try {
-                configConverter.update(yapionObject);
-            } catch (Exception e) {
-                Bukkit.getLogger().log(Level.SEVERE, e.getMessage(), e);
-                return ConfigCreator.createDefaultConfig();
-            }
-            int newVersion = yapionObject.getPlainValue("@version");
-            if (version == newVersion) {
-                Bukkit.getLogger().log(Level.SEVERE, "Version Tag was the same after conversion");
-                return ConfigCreator.createDefaultConfig();
-            }
-            if (newVersion < version) {
-                Bukkit.getLogger().log(Level.SEVERE, "Version Tag was earlier after conversion");
-                return ConfigCreator.createDefaultConfig();
-            }
-            version = newVersion;
-        }
-        return yapionObject;
+    protected boolean nightVision = false;
+    protected boolean tntClickDetails = true;
+    protected boolean detonatorAutostart = false;
+    protected boolean inventoryFill = false;
+    protected boolean rayVisualizer = false;
+    protected boolean smartPlace = false;
+    protected boolean blockCounter = false;
+    protected boolean depthMessage = true;
+
+    public static Map<Integer, Integer> defaultBauGui() {
+        //  0:  ? |  1:  ? |  2: 10 |  3:  3 |  4:  7 |  5: 17 |  6: 15 |  7:  ? |  8:  ?
+        //  9:  5 | 10:  ? | 11:  ? | 12:  ? | 13:  ? | 14:  ? | 15:  ? | 16:  ? | 17: 16
+        // 18:  4 | 19:  ? | 20: 19 | 21: 21 | 22:  9 | 23:  0 | 24:  1 | 25:  ? | 26: 11
+        // 27:  6 | 28:  ? | 29:  ? | 30:  ? | 31:  ? | 32:  ? | 33:  ? | 34:  ? | 35: 18
+        // 36:  ? | 37: 23 | 38: 20 | 39:  8 | 40: 22 | 41: 26 | 42: 12 | 43: 14 | 44:  ?
+        Map<Integer, Integer> bauGui = new HashMap<>();
+        bauGui.put(10, 2); bauGui.put(3, 3); bauGui.put(7, 4); bauGui.put(17, 5); bauGui.put(15, 6);
+        bauGui.put(5, 9); bauGui.put(4, 18); bauGui.put(6, 27);
+        bauGui.put(16, 17); bauGui.put(11, 26); bauGui.put(18, 35);
+        bauGui.put(19, 20); bauGui.put(21, 21); bauGui.put(9, 22); bauGui.put(0, 23); bauGui.put(1, 24);
+        bauGui.put(23, 37); bauGui.put(20, 38); bauGui.put(8, 39); bauGui.put(22, 40); bauGui.put(26, 41); bauGui.put(12, 42); bauGui.put(14, 43);
+        return bauGui;
    }
 }
@@ -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.bausystem.configplayer;
-
-import yapion.hierarchy.types.YAPIONObject;
-
-/**
- * A new {@link ConfigConverter} should be written when you remove anything
- * from the Config or modify any mayor part. When you move anything from
- * any key to any other key you should write a new {@link ConfigConverter}.
- * For adding any new key you should be able to get the default without
- * having it in the Config. Anything you need to change you should also
- * change the {@link ConfigCreator} accordingly, to produce the new Config.
- */
-public interface ConfigConverter {
-
-    /**
-     * This describes the version this Converter can convert from. The version
-     * it should convert to is the version 1 above this number. But this is not
-     * a necessity. In the config Object as parameter given in {@link #update(YAPIONObject)}
-     * you should update the <b>@version</b> variable in the root object to the
-     * new version this converter produced.
-     *
-     * @return the version number
-     */
-    int version();
-
-    /**
-     * This method should update everything needed to go from a lower config
-     * version to a higher. It should update the <b>@version</b> variable
-     * accordingly. Anything else is up the implementation. If anything goes wrong
-     * do not silently exit this method, throw an Exception. The updater Code will
-     * deal with it. Never leave the inputted object in a corrupted state.
-     *
-     * @param config the config object to update
-     */
-    void update(YAPIONObject config);
-
-}
@@ -1,61 +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.bausystem.configplayer;
-
-import de.steamwar.bausystem.features.hotbar.DefaultHotbar;
-import lombok.experimental.UtilityClass;
-import yapion.hierarchy.types.YAPIONObject;
-
-@UtilityClass
-public class ConfigCreator {
-
-    public static final int currentVersion = 1;
-
-    public YAPIONObject createDefaultConfig() {
-        YAPIONObject yapionObject = new YAPIONObject();
-        // This call should never be touched
-        yapionObject.add("@version", currentVersion);
-
-        // Any initialising goes into here
-        yapionObject.add("baugui", defaultBauGui());
-
-        // Default Hotbar Gui
-        yapionObject.add("hotbar", DefaultHotbar.defaultHotbar());
-        return yapionObject;
-    }
-
-    private YAPIONObject defaultBauGui() {
-        YAPIONObject yapionObject = new YAPIONObject();
-
-        //  0:  ? |  1:  ? |  2: 10 |  3:  3 |  4:  7 |  5: 17 |  6: 15 |  7:  ? |  8:  ?
-        //  9:  5 | 10:  ? | 11:  ? | 12:  ? | 13:  ? | 14:  ? | 15:  ? | 16:  ? | 17: 16
-        // 18:  4 | 19:  ? | 20: 19 | 21: 21 | 22:  9 | 23:  0 | 24:  1 | 25:  ? | 26: 11
-        // 27:  6 | 28:  ? | 29:  ? | 30:  ? | 31:  ? | 32:  ? | 33:  ? | 34:  ? | 35: 18
-        // 36:  ? | 37: 23 | 38: 20 | 39:  8 | 40: 22 | 41: 26 | 42: 12 | 43: 14 | 44:  ?
-
-        yapionObject.add("10", 2).add("3", 3).add("7", 4).add("17", 5).add("15", 6);
-        yapionObject.add("5", 9).add("4", 18).add("6", 27);
-        yapionObject.add("16", 17).add("11", 26).add("18", 35);
-        yapionObject.add("19", 20).add("21", 21).add("9", 22).add("0", 23).add("1", 24);
-        yapionObject.add("23", 37).add("20", 38).add("8", 39).add("22", 40).add("26", 41).add("12", 42).add("14", 43);
-        yapionObject.add("size", 45);
-        return yapionObject;
-    }
-}
@@ -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.bausystem.configplayer;
+
+import de.steamwar.bausystem.config.VersionedConfig;
+import de.steamwar.bausystem.config.legacy.YapionReader;
+import lombok.AccessLevel;
+import lombok.Getter;
+import lombok.Setter;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * The legacy config that was stored in the YAPION format.
+ */
+@Getter
+@Setter
+public class ConfigV1 implements VersionedConfig {
+
+    public static final int VERSION = 1;
+
+    @Setter(AccessLevel.NONE)
+    protected int version = VERSION;
+
+    /**
+     * BauGui item id to inventory slot
+     */
+    protected Map<Integer, Integer> bauGui = new HashMap<>();
+    protected int bauGuiSize = 45;
+
+    /**
+     * Minecraft version to the hotbar serialized by YAPION, read with {@link YapionReader}.
+     * Use {@link de.steamwar.bausystem.config.legacy.YapionItemDeserializer} to get the items.
+     */
+    protected Map<Integer, List<?>> hotbars = new HashMap<>();
+
+    protected boolean nightVision = false;
+    protected boolean tntClickDetails = true;
+    protected boolean detonatorAutostart = false;
+    protected boolean inventoryFill = false;
+    protected boolean rayVisualizer = false;
+    protected boolean smartPlace = false;
+    protected boolean blockCounter = false;
+    protected boolean depthMessage = true;
+
+    public static ConfigV1 parse(String yapion) {
+        Map<String, Object> object = YapionReader.parse(yapion);
+        ConfigV1 config = new ConfigV1();
+        config.version = (Integer) object.get("@version");
+
+        if (object.get("baugui") instanceof Map<?, ?> bauGui) {
+            bauGui.forEach((key, value) -> {
+                if (key.equals("size")) {
+                    config.bauGuiSize = (Integer) value;
+                } else {
+                    config.bauGui.put(Integer.parseInt((String) key), (Integer) value);
+                }
+            });
+        }
+
+        object.forEach((key, value) -> {
+            if (!(value instanceof List<?> hotbar)) return;
+            if (key.equals("hotbar")) {
+                // Hotbars were stored without version prior to 1.19
+                config.hotbars.putIfAbsent(19, hotbar);
+            } else if (key.startsWith("hotbar-")) {
+                config.hotbars.put(Integer.parseInt(key.substring("hotbar-".length())), hotbar);
+            }
+        });
+
+        config.nightVision = getBoolean(object, "nightvision", config.nightVision);
+        config.tntClickDetails = getBoolean(object, "tnt_click_details", config.tntClickDetails);
+        config.detonatorAutostart = getBoolean(object, "detonator-autostart", config.detonatorAutostart);
+        config.inventoryFill = getBoolean(object, "inventoryfill", config.inventoryFill);
+        config.rayVisualizer = getBoolean(object, "rayvisualizer", config.rayVisualizer);
+        config.smartPlace = getBoolean(object, "smartPlace", config.smartPlace);
+        config.blockCounter = getBoolean(object, "blockCounter", config.blockCounter);
+        config.depthMessage = getBoolean(object, "depth_message", config.depthMessage);
+        return config;
+    }
+
+    private static boolean getBoolean(Map<String, Object> object, String key, boolean defaultValue) {
+        return object.get(key) instanceof Boolean value ? value : defaultValue;
+    }
+}
@@ -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.bausystem.configplayer.converter;
+
+import de.steamwar.bausystem.config.ConfigConverter;
+import de.steamwar.bausystem.config.legacy.YapionItemDeserializer;
+import de.steamwar.bausystem.configplayer.Config;
+import de.steamwar.bausystem.configplayer.ConfigV1;
+import de.steamwar.core.Core;
+import org.bukkit.Bukkit;
+import org.bukkit.inventory.ItemStack;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.logging.Level;
+
+@Deprecated
+public class ConfigV1ToV2Converter implements ConfigConverter<ConfigV1, Config> {
+
+    @Override
+    public int version() {
+        return ConfigV1.VERSION;
+    }
+
+    @Override
+    public Config convert(ConfigV1 old) {
+        Config config = new Config();
+        config.setBauGui(new HashMap<>(old.getBauGui()));
+        config.setBauGuiSize(old.getBauGuiSize());
+
+        List<?> hotbar = old.getHotbars().get(Core.getVersion());
+        if (hotbar != null) {
+            config.setHotbar(convertHotbar(hotbar));
+        }
+
+        config.setNightVision(old.isNightVision());
+        config.setTntClickDetails(old.isTntClickDetails());
+        config.setDetonatorAutostart(old.isDetonatorAutostart());
+        config.setInventoryFill(old.isInventoryFill());
+        config.setRayVisualizer(old.isRayVisualizer());
+        config.setSmartPlace(old.isSmartPlace());
+        config.setBlockCounter(old.isBlockCounter());
+        config.setDepthMessage(old.isDepthMessage());
+        return config;
+    }
+
+    private ItemStack[] convertHotbar(List<?> hotbar) {
+        ItemStack[] items = new ItemStack[13];
+        for (int i = 0; i < Math.min(hotbar.size(), items.length); i++) {
+            try {
+                items[i] = YapionItemDeserializer.deserializeItem(hotbar.get(i));
+            } catch (Exception e) {
+                Bukkit.getLogger().log(Level.WARNING, "Could not convert hotbar item " + i, e);
+            }
+        }
+        return items;
+    }
+}
@@ -1,90 +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.bausystem.configplayer.serializer;
-
-import org.bukkit.configuration.serialization.ConfigurationSerializable;
-import org.bukkit.configuration.serialization.ConfigurationSerialization;
-import org.bukkit.inventory.ItemStack;
-import org.bukkit.inventory.meta.ItemMeta;
-import yapion.hierarchy.api.groups.YAPIONAnyType;
-import yapion.hierarchy.types.YAPIONObject;
-import yapion.serializing.api.SerializerObject;
-import yapion.serializing.data.DeserializeData;
-import yapion.serializing.data.SerializeData;
-
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.Map;
-
-import static yapion.utils.IdentifierUtils.TYPE_IDENTIFIER;
-
-public class ConfigurationSerializableSerializer extends SerializerObject<ConfigurationSerializable> {
-
-    @Override
-    public Class<ConfigurationSerializable> type() {
-        return ConfigurationSerializable.class;
-    }
-
-    @Override
-    public boolean isInterface() {
-        return true;
-    }
-
-    @Override
-    public YAPIONObject serialize(SerializeData<ConfigurationSerializable> serializeData) {
-        YAPIONObject yapionObject = new YAPIONObject();
-        yapionObject.add(TYPE_IDENTIFIER, serializeData.object.getClass().getTypeName());
-        if (serializeData.object instanceof ItemStack) {
-            yapionObject.add(TYPE_IDENTIFIER, ItemStack.class.getTypeName());
-        }
-        if (serializeData.object instanceof ItemMeta) {
-            yapionObject.add(TYPE_IDENTIFIER, ItemMeta.class.getTypeName());
-        }
-        Map<String, Object> serializeDataMap = serializeData.object.serialize();
-        serializeDataMap.forEach((s, o) -> {
-            YAPIONAnyType yapionAnyType = serializeData.serialize(o);
-            if (yapionAnyType instanceof YAPIONObject) {
-                YAPIONObject object = (YAPIONObject) yapionAnyType;
-                if (object.containsKey(TYPE_IDENTIFIER) && object.getPlainValue(TYPE_IDENTIFIER).equals("com.google.common.collect.RegularImmutableList")) {
-                    object.put(TYPE_IDENTIFIER, ArrayList.class.getTypeName());
-                }
-            }
-            yapionObject.add(s, yapionAnyType);
-        });
-        return yapionObject;
-    }
-
-    @Override
-    public ConfigurationSerializable deserialize(DeserializeData<YAPIONObject> deserializeData) {
-        Map<String, Object> deserializeDataMap = new HashMap<>();
-        deserializeData.object.forEach((s, yapionAnyType) -> {
-            if (s.equals(TYPE_IDENTIFIER)) {
-                if (yapionAnyType.toString().equals("(org.bukkit.inventory.meta.ItemMeta)")) {
-                    deserializeDataMap.put("==", "ItemMeta");
-                } else {
-                    deserializeDataMap.put("==", deserializeData.deserialize(yapionAnyType));
-                }
-                return;
-            }
-            deserializeDataMap.put(s, deserializeData.deserialize(yapionAnyType));
-        });
-        return ConfigurationSerialization.deserializeObject(deserializeDataMap);
-    }
-}
@@ -64,7 +64,7 @@ public class Depth {
        dimensions.setZ(Math.abs(dimensions.getZ()));

        RegionUtils.message(region, player -> {
-            if (Config.getInstance().get(player).getPlainValueOrDefault("depth_message", true)) {
+            if (Config.STORE.get(player).isDepthMessage()) {
                player.spigot().sendMessage(getMessage(player, dimensions.getBlockX() + 1, dimensions.getBlockY() + 1, dimensions.getBlockZ() + 1, tntCount));
            }
        });
@@ -34,11 +34,11 @@ public class DepthCommand extends SWCommand {

    @Register
    public void toggle(Player player) {
-        if (Config.getInstance().get(player).getPlainValueOrDefault("depth_message", true)) {
-            Config.getInstance().get(player).put("depth_message", false);
+        if (Config.STORE.get(player).isDepthMessage()) {
+            Config.STORE.get(player).setDepthMessage(false);
            BauSystem.MESSAGE.send("DEPTH_COUNTER_DISABLE", player);
        } else {
-            Config.getInstance().get(player).put("depth_message", true);
+            Config.STORE.get(player).setDepthMessage(true);
            BauSystem.MESSAGE.send("DEPTH_COUNTER_ENABLE", player);
        }
    }
@@ -95,7 +95,7 @@ public class Detonator {

    public static void activateDetonator(DetonatorStorage detonator) {
        Player p = detonator.getPlayer();
-        if (Config.getInstance().get(p).getPlainValueOrDefault("detonator-autostart", false)) {
+        if (Config.STORE.get(p).isDetonatorAutostart()) {
            AutostartListener.instance.activate(p);
        }

@@ -76,8 +76,8 @@ public class DetonatorCommand extends SWCommand {

    @Register(value = "autostart", description = "DETONATOR_HELP_AUTOSTART")
    public void toggleAutostartTimer(Player p) {
-        boolean current = Config.getInstance().get(p).getPlainValueOrDefault("detonator-autostart", false);
-        Config.getInstance().get(p).put("detonator-autostart", !current);
+        boolean current = Config.STORE.get(p).isDetonatorAutostart();
+        Config.STORE.get(p).setDetonatorAutostart(!current);
        if (!current) {
            BauSystem.MESSAGE.send("DETONATOR_AUTOSTART_ENABLE", p);
        } else {
@@ -28,7 +28,6 @@ import lombok.Setter;
 import org.bukkit.Bukkit;
 import org.bukkit.entity.Player;
 import org.bukkit.scheduler.BukkitTask;
-import yapion.hierarchy.types.YAPIONObject;

 import java.util.*;

@@ -52,15 +51,15 @@ public class BauGuiMapping {
    }

    @Getter
-    private final YAPIONObject object;
+    private final Config config;
    @Getter
    private final Player owner;
    @Getter
    @Setter
    private boolean saved;

-    protected BauGuiMapping(YAPIONObject object, Player p) {
-        this.object = object;
+    protected BauGuiMapping(Config config, Player p) {
+        this.config = config;
        this.owner = p;
        fromUUID.put(p.getUniqueId(), this);
        mappings.add(this);
@@ -70,19 +69,18 @@ public class BauGuiMapping {
        BauGuiMapping mapping = fromUUID.get(p.getUniqueId());

        if (mapping == null) {
-            YAPIONObject yapionObject = Config.getInstance().get(p);
-            mapping = new BauGuiMapping(yapionObject.getObject("baugui"), p);
+            mapping = new BauGuiMapping(Config.STORE.get(p), p);
        }

        return mapping;
    }

    public boolean isShown(int id) {
-        return object.getPlainValueOrDefault(Integer.toString(id), -1) >= 0;
+        return config.getBauGui().getOrDefault(id, -1) >= 0;
    }

    public int getSlot(int id) {
-        return object.getPlainValue(Integer.toString(id));
+        return config.getBauGui().get(id);
    }

    public Map<Integer, Integer> getMapping() {
@@ -94,7 +92,7 @@ public class BauGuiMapping {
    }

    public int getSize() {
-        return object.getPlainValueOrDefault("size", 45);
+        return config.getBauGuiSize();
    }

    public void setSize(int size) {
@@ -102,7 +100,7 @@ public class BauGuiMapping {
            return;
        }

-        object.add("size", size);
+        config.setBauGuiSize(size);
    }

    private void tick() {
@@ -111,16 +109,17 @@ public class BauGuiMapping {

    public void save() {
        if (saved) return;
-        YAPIONObject config = Config.getInstance().get(owner);
-        config.add("baugui", object);
-        Config.getInstance().save(owner);
+        Config current = Config.STORE.get(owner);
+        current.setBauGui(config.getBauGui());
+        current.setBauGuiSize(config.getBauGuiSize());
+        Config.STORE.save(owner);
        saved = true;
    }

    private Map<Integer, Integer> internalReadMap() {
        Map<Integer, Integer> map = new HashMap<>();
        for (Map.Entry<Integer, BauGuiItem> e : BauGUI.getITEMS().entrySet()) {
-            Integer value = object.getPlainValueOrDefault(e.getKey().toString(), -1);
+            Integer value = config.getBauGui().getOrDefault(e.getKey(), -1);
            if (value == -1) continue;
            map.put(e.getKey(), value);
        }
@@ -129,10 +128,10 @@ public class BauGuiMapping {

    private void internalWriteMap(Map<Integer, Integer> map) {
        for (Map.Entry<Integer, BauGuiItem> e : BauGUI.getITEMS().entrySet()) {
-            object.remove(e.getKey().toString());
+            config.getBauGui().remove(e.getKey());
            Integer value = map.getOrDefault(e.getKey(), -1);
            if (value == -1) continue;
-            object.add(e.getKey().toString(), value);
+            config.getBauGui().put(e.getKey(), value);
        }
    }
 }
@@ -20,39 +20,23 @@
 package de.steamwar.bausystem.features.hotbar;

 import de.steamwar.bausystem.configplayer.Config;
-import de.steamwar.core.Core;
 import lombok.experimental.UtilityClass;
+import org.bukkit.Material;
 import org.bukkit.entity.Player;
 import org.bukkit.inventory.ItemStack;
-import yapion.hierarchy.types.YAPIONArray;
-import yapion.hierarchy.types.YAPIONObject;
-import yapion.hierarchy.types.YAPIONValue;
-import yapion.parser.YAPIONParser;
-import yapion.serializing.YAPIONDeserializer;
-import yapion.serializing.YAPIONSerializer;
+import org.bukkit.inventory.meta.ItemMeta;

-import java.util.HashSet;
-import java.util.Set;
+import java.util.List;

@UtilityClass
 public class DefaultHotbar {

-    private final YAPIONArray DEFAULT_HOTBAR = YAPIONParser.parse("{[{@type(org.bukkit.inventory.ItemStack)v(2230)type(WOODEN_AXE)meta{@type(org.bukkit.inventory.meta.ItemMeta)meta-type(UNSPECIFIC)display-name(WorldEdit Wand)lore{@type(java.util.ArrayList)values[Left click: select pos #1,Right click: select pos #2]}}},{@type(org.bukkit.inventory.ItemStack)v(2230)type(COMPASS)meta{@type(org.bukkit.inventory.meta.ItemMeta)meta-type(UNSPECIFIC)display-name(Navigation Wand)lore{@type(java.util.ArrayList)values[Left click: jump to location,Right click: pass through walls]}}},null,null,null,null,null,null,{@type(org.bukkit.inventory.ItemStack)v(2230)type(NETHER_STAR)meta{@type(org.bukkit.inventory.meta.ItemMeta)meta-type(UNSPECIFIC)display-name(§eBau GUI)}},null,null,{@type(org.bukkit.inventory.ItemStack)v(3117)type(ELYTRA)},null]}").getArray("");
-
    public void updateHotbar(Player p) {
        ItemStack[] hotbar = new ItemStack[13];
        System.arraycopy(p.getInventory().getContents(), 0, hotbar, 0, 9);
        System.arraycopy(p.getInventory().getArmorContents(), 0, hotbar, 9, 4);
-        YAPIONArray yapionArray = new YAPIONArray();
-        for (ItemStack itemStack : hotbar) {
-            if (itemStack != null) {
-                yapionArray.add(YAPIONSerializer.serialize(itemStack));
-            } else {
-                yapionArray.add(new YAPIONValue<>(null));
-            }
-        }
-        Config.getInstance().get(p).add("hotbar-" + Core.getVersion(), yapionArray);
-        Config.getInstance().save(p);
+        Config.STORE.get(p).setHotbar(copy(hotbar));
+        Config.STORE.save(p);
    }

    public void setHotbar(Player p) {
@@ -66,28 +50,34 @@ public class DefaultHotbar {
    }

    public ItemStack[] getItems(Player p) {
-        Config.getInstance().get(p).remap("hotbar", "hotbar-19");
-        YAPIONArray yapionArray = Config.getInstance().get(p).getYAPIONArrayOrSetDefault("hotbar-" + Core.getVersion(), defaultHotbar());
+        return copy(Config.STORE.get(p).getHotbar());
+    }
+
+    public ItemStack[] defaultHotbar() {
        ItemStack[] hotbar = new ItemStack[13];
-        Set<Integer> invalid = new HashSet<>();
-        yapionArray.forEach((integer, yapionAnyType) -> {
-            if (yapionAnyType instanceof YAPIONValue) {
-                hotbar[integer] = null;
-            } else {
-                try {
-                    hotbar[integer] = YAPIONDeserializer.deserialize((YAPIONObject) yapionAnyType);
-                } catch (Exception e) {
-                    invalid.add(integer);
-                    hotbar[integer] = null;
-                }
-            }
-        });
-        invalid.forEach(i -> yapionArray.set(i, new YAPIONValue<>(null)));
-        if (!invalid.isEmpty()) Config.getInstance().save(p);
+        hotbar[0] = item(Material.WOODEN_AXE, "WorldEdit Wand", "Left click: select pos #1", "Right click: select pos #2");
+        hotbar[1] = item(Material.COMPASS, "Navigation Wand", "Left click: jump to location", "Right click: pass through walls");
+        hotbar[8] = item(Material.NETHER_STAR, "§eBau GUI");
+        hotbar[11] = new ItemStack(Material.ELYTRA);
        return hotbar;
    }

-    public YAPIONArray defaultHotbar() {
-        return DEFAULT_HOTBAR;
+    private ItemStack item(Material material, String name, String... lore) {
+        ItemStack itemStack = new ItemStack(material);
+        ItemMeta meta = itemStack.getItemMeta();
+        meta.setDisplayName(name);
+        if (lore.length > 0) {
+            meta.setLore(List.of(lore));
+        }
+        itemStack.setItemMeta(meta);
+        return itemStack;
+    }
+
+    private ItemStack[] copy(ItemStack[] hotbar) {
+        ItemStack[] copy = new ItemStack[13];
+        for (int i = 0; i < Math.min(hotbar.length, copy.length); i++) {
+            copy[i] = hotbar[i] == null ? null : hotbar[i].clone();
+        }
+        return copy;
    }
 }
@@ -49,7 +49,7 @@ public class InventoryFillBauGuiItem extends BauGuiItem {

    @Override
    public ItemStack getItem(Player player) {
-        String loreKey = Config.getInstance().get(player).getPlainValueOrDefault("inventoryfill", false) ? "OTHER_ITEMS_INVENTORY_FILL_LORE_ACTIVE" : "OTHER_ITEMS_INVENTORY_FILL_LORE_INACTIVE";
+        String loreKey = Config.STORE.get(player).isInventoryFill() ? "OTHER_ITEMS_INVENTORY_FILL_LORE_ACTIVE" : "OTHER_ITEMS_INVENTORY_FILL_LORE_INACTIVE";
        return new SWItem(Material.HOPPER, BauSystem.MESSAGE.parse("OTHER_ITEMS_INVENTORY_FILL_NAME", player), Collections.singletonList(BauSystem.MESSAGE.parse(loreKey, player)), false, clickType -> {
        }).getItemStack();
    }
@@ -40,7 +40,7 @@ public class InventoryFiller implements Listener {
    @EventHandler
    public void onPlayerDropItem(PlayerDropItemEvent event) {
        if (!Permission.BUILD.hasPermission(event.getPlayer())) return;
-        if (!Config.getInstance().get(event.getPlayer()).getPlainValueOrDefault("inventoryfill", false)) return;
+        if (!Config.STORE.get(event.getPlayer()).isInventoryFill()) return;
        if (!event.getPlayer().isSneaking()) return;
        Block block = event.getPlayer().getTargetBlockExact(5);
        if (block == null) return;
@@ -62,7 +62,7 @@ public class InventoryFiller implements Listener {
    @EventHandler
    public void onPlayerItemHeld(PlayerItemHeldEvent event) {
        if (!Permission.BUILD.hasPermission(event.getPlayer())) return;
-        if (!Config.getInstance().get(event.getPlayer()).getPlainValueOrDefault("inventoryfill", false)) return;
+        if (!Config.STORE.get(event.getPlayer()).isInventoryFill()) return;
        if (!event.getPlayer().isSneaking()) return;
        ItemStack itemStack = event.getPlayer().getInventory().getItemInMainHand();
        if (itemStack.getType() == Material.AIR) return;
@@ -68,8 +68,8 @@ public class InventoryFillerCommand extends SWCommand {

    @Register(description = {"INVENTORY_FILL_HELP", "INVENTORY_FILL_INFO"})
    public void toggle(Player player) {
-        boolean inventoryFill = Config.getInstance().get(player).getPlainValueOrDefault("inventoryfill", false);
-        Config.getInstance().get(player).put("inventoryfill", !inventoryFill);
+        boolean inventoryFill = Config.STORE.get(player).isInventoryFill();
+        Config.STORE.get(player).setInventoryFill(!inventoryFill);
        if (!inventoryFill) {
            SWUtils.sendToActionbar(player, BauSystem.MESSAGE.parse("INVENTORY_FILL_ENABLE", player));
            BauSystem.MESSAGE.send("INVENTORY_FILL_INFO", player);
@@ -290,7 +290,7 @@ public class KillcheckerVisualizer {
                }
                rEntities.get(point).die();
            }
-            RBlockDisplay entity = new RBlockDisplay(outlinePoints.contains(point) ? outline : inner, point.toLocation(WORLD, 0.5, 0, 0.5));
+            RBlockDisplay entity = new RBlockDisplay(outlinePoints.contains(point) ? outline : inner, point.toLocation(WORLD, 0, 0, 0));
            entity.setBlock(MATERIALS[Math.min(count - 1, MATERIALS.length) - 1].createBlockData());
            rEntities.put(point, entity);
            if (outlinePoints.contains(point)) outlinePointsCache.add(point);
@@ -46,7 +46,7 @@ public class ObserverTracerListener implements Listener {
    public ObserverTracerListener() {
        Bukkit.getScheduler().runTaskTimer(BauSystem.getInstance(), () -> {
            SWPlayer.allWithSingleComponent(ObserverTracer.class).forEach(pair -> {
-                if (pair.getPlayer().getGameMode() != GameMode.SPECTATOR) return;
+                if (pair.getSwPlayer().getPlayer().getGameMode() != GameMode.SPECTATOR) return;
                pair.getComponent().show();
            });
        }, 15L, 15L);
@@ -167,7 +167,7 @@ public class RayVisualizerCommand extends SWCommand implements Listener {
    @EventHandler
    public void onPlayerJoin(PlayerJoinEvent event) {
        if (!Permission.BUILD.hasPermission(event.getPlayer())) return;
-        boolean rayvisualizer = Config.getInstance().get(event.getPlayer()).getPlainValueOrDefault("rayvisualizer", false);
+        boolean rayvisualizer = Config.STORE.get(event.getPlayer()).isRayVisualizer();
        if (rayvisualizer) server.addPlayer(event.getPlayer());
    }

@@ -181,7 +181,7 @@ public class RayVisualizerCommand extends SWCommand implements Listener {
        Bukkit.getScheduler().runTaskLater(BauSystem.getInstance(), () -> {
            for (Player player : Bukkit.getOnlinePlayers()) {
                if (Permission.BUILD.hasPermission(player)) {
-                    boolean rayvisualizer = Config.getInstance().get(player).getPlainValueOrDefault("rayvisualizer", false);
+                    boolean rayvisualizer = Config.STORE.get(player).isRayVisualizer();
                    if (rayvisualizer) server.addPlayer(player);
                } else {
                    server.removePlayer(player);
@@ -192,8 +192,8 @@ public class RayVisualizerCommand extends SWCommand implements Listener {

    @Register
    public void toggle(@Validator Player player) {
-        boolean rayvisualizer = Config.getInstance().get(player).getPlainValueOrDefault("rayvisualizer", false);
-        Config.getInstance().get(player).put("rayvisualizer", !rayvisualizer);
+        boolean rayvisualizer = Config.STORE.get(player).isRayVisualizer();
+        Config.STORE.get(player).setRayVisualizer(!rayvisualizer);
        if (!rayvisualizer) {
            SWUtils.sendToActionbar(player, BauSystem.MESSAGE.parse("RAY_VISUALIZER_ENABLE", player));
            server.addPlayer(player);
@@ -21,6 +21,7 @@ package de.steamwar.bausystem.features.simulator.data;

 import de.steamwar.bausystem.features.simulator.execute.SimulatorAction;
 import de.steamwar.bausystem.features.simulator.gui.base.SimulatorBaseGui;
+import de.steamwar.bausystem.features.simulator.storage.SimulatorConfig;
 import de.steamwar.inventory.InvCallback;
 import de.steamwar.inventory.SWItem;
 import lombok.Getter;
@@ -28,7 +29,6 @@ import lombok.Setter;
 import org.bukkit.Material;
 import org.bukkit.entity.Player;
 import org.bukkit.util.Vector;
-import yapion.hierarchy.types.YAPIONObject;

 import java.util.ArrayList;
 import java.util.Comparator;
@@ -121,9 +121,9 @@ public abstract class SimulatorElement<T extends SimulatorPhase> {

    public abstract String getType();

-    public void saveExtra(YAPIONObject elementObject) {
+    public void saveExtra(SimulatorConfig.Element element) {
    }

-    public void loadExtra(YAPIONObject elementObject) {
+    public void loadExtra(SimulatorConfig.Element element) {
    }
 }
@@ -20,10 +20,10 @@
 package de.steamwar.bausystem.features.simulator.data;

 import de.steamwar.bausystem.features.simulator.execute.SimulatorAction;
+import de.steamwar.bausystem.features.simulator.storage.SimulatorConfig;
 import lombok.Getter;
 import lombok.Setter;
 import org.bukkit.util.Vector;
-import yapion.hierarchy.types.YAPIONObject;

 import java.util.function.BiConsumer;

@@ -38,9 +38,9 @@ public abstract class SimulatorPhase {

    public abstract void toSimulatorActions(Vector position, BiConsumer<Integer, SimulatorAction> tickStart, BiConsumer<Integer, SimulatorAction> tickEnd);

-    public void saveExtra(YAPIONObject phaseObject) {
+    public void saveExtra(SimulatorConfig.Phase phase) {
    }

-    public void loadExtra(YAPIONObject phaseObject) {
+    public void loadExtra(SimulatorConfig.Phase phase) {
    }
 }
@@ -21,6 +21,7 @@ package de.steamwar.bausystem.features.simulator.data.observer;

 import de.steamwar.bausystem.features.simulator.data.SimulatorPhase;
 import de.steamwar.bausystem.features.simulator.execute.SimulatorAction;
+import de.steamwar.bausystem.features.simulator.storage.SimulatorConfig;
 import lombok.Getter;
 import lombok.NoArgsConstructor;
 import lombok.Setter;
@@ -31,7 +32,6 @@ import org.bukkit.block.BlockFace;
 import org.bukkit.block.BlockState;
 import org.bukkit.block.data.type.Observer;
 import org.bukkit.util.Vector;
-import yapion.hierarchy.types.YAPIONObject;

 import java.util.function.BiConsumer;

@@ -70,12 +70,12 @@ public final class ObserverPhase extends SimulatorPhase {
    }

    @Override
-    public void saveExtra(YAPIONObject phaseObject) {
-        phaseObject.add("orientation", orientation.name());
+    public void saveExtra(SimulatorConfig.Phase phase) {
+        phase.setOrientation(orientation);
    }

    @Override
-    public void loadExtra(YAPIONObject phaseObject) {
-        orientation = BlockFace.valueOf(phaseObject.getPlainValue("orientation"));
+    public void loadExtra(SimulatorConfig.Phase phase) {
+        if (phase.getOrientation() != null) orientation = phase.getOrientation();
    }
 }
@@ -24,13 +24,13 @@ import de.steamwar.bausystem.features.simulator.data.SimulatorElement;
 import de.steamwar.bausystem.features.simulator.data.SimulatorGroup;
 import de.steamwar.bausystem.features.simulator.gui.SimulatorTNTGui;
 import de.steamwar.bausystem.features.simulator.gui.base.SimulatorBaseGui;
+import de.steamwar.bausystem.features.simulator.storage.SimulatorConfig;
 import de.steamwar.inventory.InvCallback;
 import de.steamwar.inventory.SWItem;
 import lombok.Getter;
 import org.bukkit.Material;
 import org.bukkit.entity.Player;
 import org.bukkit.util.Vector;
-import yapion.hierarchy.types.YAPIONObject;

 public final class TNTElement extends SimulatorElement<TNTPhase> {

@@ -100,14 +100,14 @@ public final class TNTElement extends SimulatorElement<TNTPhase> {
    }

    @Override
-    public void saveExtra(YAPIONObject elementObject) {
-        elementObject.add("alignmentX", alignment.getX());
-        elementObject.add("alignmentZ", alignment.getZ());
+    public void saveExtra(SimulatorConfig.Element element) {
+        element.setAlignmentX(alignment.getX());
+        element.setAlignmentZ(alignment.getZ());
    }

    @Override
-    public void loadExtra(YAPIONObject elementObject) {
-        alignment.setX(elementObject.getDoubleOrSetDefault("alignmentX", 0));
-        alignment.setZ(elementObject.getDoubleOrSetDefault("alignmentZ", 0));
+    public void loadExtra(SimulatorConfig.Element element) {
+        alignment.setX(element.getAlignmentX() != null ? element.getAlignmentX() : 0);
+        alignment.setZ(element.getAlignmentZ() != null ? element.getAlignmentZ() : 0);
    }
 }
@@ -21,6 +21,7 @@ package de.steamwar.bausystem.features.simulator.data.tnt;

 import de.steamwar.bausystem.features.simulator.data.SimulatorPhase;
 import de.steamwar.bausystem.features.simulator.execute.SimulatorAction;
+import de.steamwar.bausystem.features.simulator.storage.SimulatorConfig;
 import de.steamwar.bausystem.region.Region;
 import de.steamwar.bausystem.region.flags.Flag;
 import de.steamwar.bausystem.region.flags.FreezeMode;
@@ -31,7 +32,6 @@ import org.bukkit.Location;
 import org.bukkit.World;
 import org.bukkit.entity.TNTPrimed;
 import org.bukkit.util.Vector;
-import yapion.hierarchy.types.YAPIONObject;

 import java.util.function.BiConsumer;

@@ -83,18 +83,18 @@ public final class TNTPhase extends SimulatorPhase {
    }

    @Override
-    public void saveExtra(YAPIONObject phaseObject) {
-        phaseObject.add("count", count);
-        phaseObject.add("xJump", xJump);
-        phaseObject.add("yJump", yJump);
-        phaseObject.add("zJump", zJump);
+    public void saveExtra(SimulatorConfig.Phase phase) {
+        phase.setCount(count);
+        phase.setXJump(xJump);
+        phase.setYJump(yJump);
+        phase.setZJump(zJump);
    }

    @Override
-    public void loadExtra(YAPIONObject phaseObject) {
-        count = phaseObject.getPlainValue("count");
-        xJump = phaseObject.getPlainValue("xJump");
-        yJump = phaseObject.getPlainValue("yJump");
-        zJump = phaseObject.getPlainValue("zJump");
+    public void loadExtra(SimulatorConfig.Phase phase) {
+        if (phase.getCount() != null) count = phase.getCount();
+        if (phase.getXJump() != null) xJump = phase.getXJump();
+        if (phase.getYJump() != null) yJump = phase.getYJump();
+        if (phase.getZJump() != null) zJump = phase.getZJump();
    }
 }
@@ -19,6 +19,7 @@

 package de.steamwar.bausystem.features.simulator.storage;

+import com.google.gson.JsonParseException;
 import de.steamwar.bausystem.features.simulator.data.Simulator;
 import de.steamwar.bausystem.features.simulator.data.SimulatorElement;
 import de.steamwar.bausystem.features.simulator.data.SimulatorGroup;
@@ -29,12 +30,7 @@ import de.steamwar.bausystem.features.simulator.data.redstone.RedstoneElement;
 import de.steamwar.bausystem.features.simulator.data.redstone.RedstonePhase;
 import de.steamwar.bausystem.features.simulator.data.tnt.TNTElement;
 import de.steamwar.bausystem.features.simulator.data.tnt.TNTPhase;
-import org.bukkit.Material;
 import org.bukkit.util.Vector;
-import yapion.exceptions.YAPIONException;
-import yapion.hierarchy.types.YAPIONArray;
-import yapion.hierarchy.types.YAPIONObject;
-import yapion.parser.YAPIONParser;

 import java.io.File;
 import java.io.IOException;
@@ -51,44 +47,41 @@ public class SimFormatSimulatorLoader implements SimulatorLoader {
            return Optional.empty();
        }

-        YAPIONObject yapionObject;
+        SimulatorConfig config;
        try {
-            yapionObject = YAPIONParser.parse(file);
-        } catch (YAPIONException | IOException e) {
+            config = SimulatorConfig.STORE.load(file);
+        } catch (JsonParseException | IllegalStateException | IOException e) {
            return Optional.empty();
        }

        String name = file.getName().substring(0, file.getName().length() - ".sim".length());

        Simulator simulator = new Simulator(name);
-        loadSimulator(yapionObject, simulator);
+        loadSimulator(config, simulator);
        return Optional.of(Collections.singletonList(simulator));
    }

-    private void loadSimulator(YAPIONObject simulatorObject, Simulator simulator) {
-        simulator.setMaterial(Material.valueOf(simulatorObject.getPlainValue("material")));
-        simulator.setAutoTrace(simulatorObject.getPlainValue("autoTrace"));
-        simulator.setAutoTestblock(simulatorObject.getPlainValueOrDefault("autoTestblock", false));
+    private void loadSimulator(SimulatorConfig config, Simulator simulator) {
+        if (config.getMaterial() != null) simulator.setMaterial(config.getMaterial());
+        simulator.setAutoTrace(config.isAutoTrace());
+        simulator.setAutoTestblock(config.isAutoTestblock());

-        YAPIONArray groups = simulatorObject.getArray("groups");
-        groups.streamObject().forEach(groupObject -> {
+        config.getGroups().forEach(groupConfig -> {
            SimulatorGroup simulatorGroup = new SimulatorGroup();
-            loadGroup(groupObject, simulatorGroup);
+            loadGroup(groupConfig, simulatorGroup);
            simulator.add(simulatorGroup);
        });
    }

-    private void loadGroup(YAPIONObject groupObject, SimulatorGroup group) {
-        group.setMaterial(Material.valueOf(groupObject.getPlainValue("material")));
-        group.setDisabled(groupObject.getPlainValue("disabled"));
+    private void loadGroup(SimulatorConfig.Group groupConfig, SimulatorGroup group) {
+        if (groupConfig.getMaterial() != null) group.setMaterial(groupConfig.getMaterial());
+        group.setDisabled(groupConfig.isDisabled());

-        YAPIONArray elements = groupObject.getArray("elements");
-        elements.streamObject().forEach(elementObject -> {
+        groupConfig.getElements().forEach(elementConfig -> {
            SimulatorElement<?> element;
            Supplier<SimulatorPhase> phaseConstructor;
-            Vector position = new Vector(elementObject.getDouble("x"), elementObject.getDouble("y"), elementObject.getDouble("z"));
-            String type = elementObject.getPlainValue("type");
-            switch (type) {
+            Vector position = new Vector(elementConfig.getX(), elementConfig.getY(), elementConfig.getZ());
+            switch (String.valueOf(elementConfig.getType())) {
                case "TNT":
                    element = new TNTElement(position);
                    phaseConstructor = TNTPhase::new;
@@ -109,28 +102,27 @@ public class SimFormatSimulatorLoader implements SimulatorLoader {
            if (element == null) {
                return;
            }
-            loadElement(elementObject, element, phaseConstructor);
+            loadElement(elementConfig, element, phaseConstructor);
            group.add(element);
        });
    }

-    private void loadElement(YAPIONObject elementObject, SimulatorElement<?> element, Supplier<SimulatorPhase> phaseConstructor) {
-        element.setMaterial(Material.valueOf(elementObject.getPlainValue("material")));
-        element.setDisabled(elementObject.getPlainValue("disabled"));
-        element.loadExtra(elementObject);
+    private void loadElement(SimulatorConfig.Element elementConfig, SimulatorElement<?> element, Supplier<SimulatorPhase> phaseConstructor) {
+        if (elementConfig.getMaterial() != null) element.setMaterial(elementConfig.getMaterial());
+        element.setDisabled(elementConfig.isDisabled());
+        element.loadExtra(elementConfig);

-        YAPIONArray phases = elementObject.getArray("phases");
-        phases.streamObject().forEach(phaseObject -> {
+        elementConfig.getPhases().forEach(phaseConfig -> {
            SimulatorPhase phase = phaseConstructor.get();
-            loadPhase(phaseObject, phase);
+            loadPhase(phaseConfig, phase);
            ((SimulatorElement) element).add(phase);
        });
    }

-    private void loadPhase(YAPIONObject phaseObject, SimulatorPhase phase) {
-        phase.setTickOffset(phaseObject.getPlainValue("tickOffset"));
-        phase.setLifetime(phaseObject.getPlainValue("lifetime"));
-        phase.setOrder(phaseObject.getPlainValue("order"));
-        phase.loadExtra(phaseObject);
+    private void loadPhase(SimulatorConfig.Phase phaseConfig, SimulatorPhase phase) {
+        phase.setTickOffset(phaseConfig.getTickOffset());
+        phase.setLifetime(phaseConfig.getLifetime());
+        phase.setOrder(phaseConfig.getOrder());
+        phase.loadExtra(phaseConfig);
    }
 }
@@ -0,0 +1,117 @@
+/*
+ *   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.simulator.storage;
+
+import de.steamwar.bausystem.config.ConfigStore;
+import de.steamwar.bausystem.config.VersionedConfig;
+import lombok.AccessLevel;
+import lombok.Getter;
+import lombok.Setter;
+import org.bukkit.Material;
+import org.bukkit.block.BlockFace;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * The current stored form of a simulator, saved as JSON in a .sim file. Files
+ * saved before the version was stored have no version and are version 1.
+ * Fields missing in the stored JSON keep the default value of their initializer,
+ * so adding a new field does not need a new version.
+ * <p>
+ * When a field gets removed, renamed or its meaning changes, copy this class
+ * to SimulatorConfigV{@link #VERSION} (without the {@link #STORE}), increase {@link #VERSION}, write a
+ * {@link de.steamwar.bausystem.config.ConfigConverter} from the copy to
+ * this class and register it in the {@link #STORE}.
+ */
+@Getter
+@Setter
+public class SimulatorConfig implements VersionedConfig {
+
+    public static final int VERSION = 1;
+
+    /**
+     * Files saved before the version was stored are version 1
+     */
+    public static final ConfigStore<SimulatorConfig> STORE = new ConfigStore<>(SimulatorConfig.class, VERSION, SimulatorConfig::new)
+            .unversioned(1);
+
+    @Setter(AccessLevel.NONE)
+    protected int version = VERSION;
+
+    protected Material material = Material.BARREL;
+    protected boolean autoTrace = false;
+    protected boolean autoTestblock = false;
+    protected List<Group> groups = new ArrayList<>();
+
+    @Getter
+    @Setter
+    public static class Group {
+
+        protected Material material = Material.CHEST;
+        protected boolean disabled = false;
+        protected List<Element> elements = new ArrayList<>();
+    }
+
+    @Getter
+    @Setter
+    public static class Element {
+
+        /**
+         * One of "TNT", "Redstone" or "Observer"
+         */
+        protected String type;
+        protected Material material;
+        protected boolean disabled = false;
+        protected double x;
+        protected double y;
+        protected double z;
+
+        /**
+         * Only used by TNT
+         */
+        protected Double alignmentX;
+        protected Double alignmentZ;
+
+        protected List<Phase> phases = new ArrayList<>();
+    }
+
+    @Getter
+    @Setter
+    public static class Phase {
+
+        protected int tickOffset;
+        protected int lifetime;
+        protected int order;
+
+        /**
+         * Only used by TNT
+         */
+        protected Integer count;
+        protected Boolean xJump;
+        protected Boolean yJump;
+        protected Boolean zJump;
+
+        /**
+         * Only used by Observer
+         */
+        protected BlockFace orientation;
+    }
+}
@@ -19,24 +19,30 @@

 package de.steamwar.bausystem.features.simulator.storage;

+import de.steamwar.bausystem.config.legacy.YapionReader;
 import de.steamwar.bausystem.features.simulator.data.Simulator;
 import de.steamwar.bausystem.features.simulator.data.SimulatorGroup;
 import de.steamwar.bausystem.features.simulator.data.tnt.TNTElement;
 import de.steamwar.bausystem.features.simulator.data.tnt.TNTPhase;
 import org.bukkit.Material;
 import org.bukkit.util.Vector;
-import yapion.exceptions.YAPIONException;
-import yapion.hierarchy.types.YAPIONArray;
-import yapion.hierarchy.types.YAPIONObject;
-import yapion.parser.YAPIONParser;

 import java.io.File;
 import java.io.IOException;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
 import java.util.Collections;
 import java.util.List;
+import java.util.Map;
 import java.util.Optional;
-import java.util.stream.Collectors;

+import static de.steamwar.bausystem.config.legacy.YapionReader.*;
+
+/**
+ * Loads the legacy .simulator files stored as YAPION, they are deleted after loading
+ * and saved in the current format by the {@link SimulatorSaver}.
+ */
+@Deprecated
 public class SimulatorFormatSimulatorLoader implements SimulatorLoader {

    @Override
@@ -45,20 +51,19 @@ public class SimulatorFormatSimulatorLoader implements SimulatorLoader {
            return Optional.empty();
        }

-        YAPIONObject yapionObject;
+        Map<String, Object> yapionObject;
        try {
-            yapionObject = YAPIONParser.parse(file);
-        } catch (YAPIONException | IOException e) {
+            yapionObject = YapionReader.parse(Files.readString(file.toPath(), StandardCharsets.UTF_8));
+        } catch (IllegalArgumentException | IOException e) {
            return Optional.empty();
        }

        String name = file.getName().substring(0, file.getName().length() - ".simulator".length());

        Simulator simulator = new Simulator(name);
-        simulator.setMaterial(Material.valueOf(yapionObject.getStringOrDefault("material", "BARREL")));
+        simulator.setMaterial(Material.valueOf(getString(yapionObject, "material", "BARREL")));

-        YAPIONArray tntElements = yapionObject.getArrayOrDefault("tntElements", new YAPIONArray());
-        for (YAPIONObject element : tntElements.streamObject().collect(Collectors.toList())) {
+        for (Map<?, ?> element : getObjects(yapionObject, "tntElements")) {
            if (element.containsKey("elements")) {
                simulator.add(loadGroup(element));
            } else {
@@ -70,27 +75,26 @@ public class SimulatorFormatSimulatorLoader implements SimulatorLoader {
        return Optional.of(Collections.singletonList(simulator));
    }

-    private SimulatorGroup loadGroup(YAPIONObject element) {
-        double x = element.getDoubleOrDefault("x", 0);
-        double y = element.getDoubleOrDefault("y", 0);
-        double z = element.getDoubleOrDefault("z", 0);
-        int tickOffset = element.getIntOrDefault("tickOffset", 0);
+    private SimulatorGroup loadGroup(Map<?, ?> element) {
+        double x = getDouble(element, "x", 0);
+        double y = getDouble(element, "y", 0);
+        double z = getDouble(element, "z", 0);
+        int tickOffset = getInt(element, "tickOffset", 0);

        SimulatorGroup simulatorGroup = new SimulatorGroup();
-        simulatorGroup.setDisabled(element.getBooleanOrDefault("disabled", false));
+        simulatorGroup.setDisabled(getBoolean(element, "disabled", false));

-        YAPIONArray elements = element.getArrayOrDefault("elements", new YAPIONArray());
-        for (YAPIONObject e : elements.streamObject().collect(Collectors.toList())) {
+        for (Map<?, ?> e : getObjects(element, "elements")) {
            simulatorGroup.add(loadElement(e, x, y, z, tickOffset));
        }

        return simulatorGroup;
    }

-    private TNTElement loadElement(YAPIONObject element, double dx, double dy, double dz, int dTickOffset) {
-        TNTElement tntElement = new TNTElement(new Vector(element.getDouble("x") + dx, element.getDouble("y") + dy, element.getDouble("z") + dz));
-        tntElement.setDisabled(element.getBooleanOrDefault("disabled", false));
-        tntElement.setMaterial(Material.valueOf(element.getStringOrDefault("material", "TNT")));
+    private TNTElement loadElement(Map<?, ?> element, double dx, double dy, double dz, int dTickOffset) {
+        TNTElement tntElement = new TNTElement(new Vector(requireDouble(element, "x") + dx, requireDouble(element, "y") + dy, requireDouble(element, "z") + dz));
+        tntElement.setDisabled(getBoolean(element, "disabled", false));
+        tntElement.setMaterial(Material.valueOf(getString(element, "material", "TNT")));

        TNTPhase tntPhase = loadPhase(element);
        tntPhase.setTickOffset(tntPhase.getTickOffset() + dTickOffset);
@@ -99,12 +103,12 @@ public class SimulatorFormatSimulatorLoader implements SimulatorLoader {
        return tntElement;
    }

-    private SimulatorGroup loadElement(YAPIONObject element) {
+    private SimulatorGroup loadElement(Map<?, ?> element) {
        SimulatorGroup simulatorGroup = new SimulatorGroup();

-        TNTElement tntElement = new TNTElement(new Vector(element.getDouble("x"), element.getDouble("y"), element.getDouble("z")));
-        tntElement.setDisabled(element.getBooleanOrDefault("disabled", false));
-        tntElement.setMaterial(Material.valueOf(element.getStringOrDefault("material", "TNT")));
+        TNTElement tntElement = new TNTElement(new Vector(requireDouble(element, "x"), requireDouble(element, "y"), requireDouble(element, "z")));
+        tntElement.setDisabled(getBoolean(element, "disabled", false));
+        tntElement.setMaterial(Material.valueOf(getString(element, "material", "TNT")));
        simulatorGroup.add(tntElement);

        tntElement.add(loadPhase(element));
@@ -112,15 +116,15 @@ public class SimulatorFormatSimulatorLoader implements SimulatorLoader {
        return simulatorGroup;
    }

-    private TNTPhase loadPhase(YAPIONObject element) {
+    private TNTPhase loadPhase(Map<?, ?> element) {
        TNTPhase tntPhase = new TNTPhase();
-        tntPhase.setLifetime(element.getIntOrDefault("fuseTicks", 80));
-        tntPhase.setCount(element.getIntOrDefault("count", 1));
-        tntPhase.setTickOffset(element.getIntOrDefault("tickOffset", 0));
-        tntPhase.setXJump(element.getBooleanOrDefault("xVelocity", false));
-        tntPhase.setYJump(element.getBooleanOrDefault("yVelocity", false));
-        tntPhase.setZJump(element.getBooleanOrDefault("zVelocity", false));
-        switch (element.getStringOrDefault("order", "REPEATER")) {
+        tntPhase.setLifetime(getInt(element, "fuseTicks", 80));
+        tntPhase.setCount(getInt(element, "count", 1));
+        tntPhase.setTickOffset(getInt(element, "tickOffset", 0));
+        tntPhase.setXJump(getBoolean(element, "xVelocity", false));
+        tntPhase.setYJump(getBoolean(element, "yVelocity", false));
+        tntPhase.setZJump(getBoolean(element, "zVelocity", false));
+        switch (getString(element, "order", "REPEATER")) {
            case "REPEATER":
                tntPhase.setOrder(0);
                break;
@@ -133,4 +137,8 @@ public class SimulatorFormatSimulatorLoader implements SimulatorLoader {
        }
        return tntPhase;
    }
+
+    private double requireDouble(Map<?, ?> element, String key) {
+        return ((Number) element.get(key)).doubleValue();
+    }
 }
@@ -21,9 +21,6 @@ package de.steamwar.bausystem.features.simulator.storage;

 import de.steamwar.bausystem.features.simulator.data.Simulator;
 import lombok.experimental.UtilityClass;
-import yapion.hierarchy.output.FileOutput;
-import yapion.hierarchy.types.YAPIONArray;
-import yapion.hierarchy.types.YAPIONObject;

 import java.io.File;
 import java.io.IOException;
@@ -36,48 +33,42 @@ public class SimulatorSaver {
            directory.mkdirs();
        }

-        YAPIONObject simulatorObject = new YAPIONObject();
-        simulatorObject.add("material", simulator.getMaterial().name());
-        simulatorObject.add("autoTrace", simulator.isAutoTrace());
-        simulatorObject.add("autoTestblock", simulator.isAutoTestblock());
+        SimulatorConfig config = new SimulatorConfig();
+        config.setMaterial(simulator.getMaterial());
+        config.setAutoTrace(simulator.isAutoTrace());
+        config.setAutoTestblock(simulator.isAutoTestblock());

-        YAPIONArray groups = new YAPIONArray();
        simulator.getGroups().forEach(group -> {
-            YAPIONObject groupObject = new YAPIONObject();
-            groupObject.add("material", group.getMaterial().name());
-            groupObject.add("disabled", group.isDisabled());
+            SimulatorConfig.Group groupConfig = new SimulatorConfig.Group();
+            groupConfig.setMaterial(group.getMaterial());
+            groupConfig.setDisabled(group.isDisabled());

-            YAPIONArray elements = new YAPIONArray();
            group.getElements().forEach(element -> {
-                YAPIONObject elementObject = new YAPIONObject();
-                elementObject.add("type", element.getType());
-                elementObject.add("material", element.getMaterial().name());
-                elementObject.add("disabled", element.isDisabled());
-                elementObject.add("x", element.getPosition().getX());
-                elementObject.add("y", element.getPosition().getY());
-                elementObject.add("z", element.getPosition().getZ());
-                element.saveExtra(elementObject);
+                SimulatorConfig.Element elementConfig = new SimulatorConfig.Element();
+                elementConfig.setType(element.getType());
+                elementConfig.setMaterial(element.getMaterial());
+                elementConfig.setDisabled(element.isDisabled());
+                elementConfig.setX(element.getPosition().getX());
+                elementConfig.setY(element.getPosition().getY());
+                elementConfig.setZ(element.getPosition().getZ());
+                element.saveExtra(elementConfig);

-                YAPIONArray phases = new YAPIONArray();
                element.getPhases().forEach(phase -> {
-                    YAPIONObject phaseObject = new YAPIONObject();
-                    phaseObject.add("tickOffset", phase.getTickOffset());
-                    phaseObject.add("lifetime", phase.getLifetime());
-                    phaseObject.add("order", phase.getOrder());
-                    phase.saveExtra(phaseObject);
-                    phases.add(phaseObject);
+                    SimulatorConfig.Phase phaseConfig = new SimulatorConfig.Phase();
+                    phaseConfig.setTickOffset(phase.getTickOffset());
+                    phaseConfig.setLifetime(phase.getLifetime());
+                    phaseConfig.setOrder(phase.getOrder());
+                    phase.saveExtra(phaseConfig);
+                    elementConfig.getPhases().add(phaseConfig);
                });
-                elementObject.add("phases", phases);
-                elements.add(elementObject);
+                groupConfig.getElements().add(elementConfig);
            });
-            groupObject.add("elements", elements);
-            groups.add(groupObject);
+            config.getGroups().add(groupConfig);
        });
-        simulatorObject.add("groups", groups);

        File file = new File(directory, simulator.getName() + ".sim");
        try {
-            simulatorObject.toJSONLossy(new FileOutput(file)).close();
+            SimulatorConfig.STORE.save(file, config);
        } catch (IOException e) {
            // Ignore
        }
@@ -19,6 +19,7 @@

 package de.steamwar.bausystem.features.simulator.storage;

+import de.steamwar.bausystem.config.legacy.YapionReader;
 import de.steamwar.bausystem.features.simulator.data.Simulator;
 import de.steamwar.bausystem.features.simulator.data.SimulatorGroup;
 import de.steamwar.bausystem.features.simulator.data.tnt.TNTElement;
@@ -26,18 +27,23 @@ import de.steamwar.bausystem.features.simulator.data.tnt.TNTPhase;
 import de.steamwar.sql.SteamwarUser;
 import org.bukkit.Material;
 import org.bukkit.util.Vector;
-import yapion.exceptions.YAPIONException;
-import yapion.hierarchy.types.YAPIONArray;
-import yapion.hierarchy.types.YAPIONObject;
-import yapion.parser.YAPIONParser;

 import java.io.File;
 import java.io.IOException;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
 import java.util.ArrayList;
 import java.util.List;
+import java.util.Map;
 import java.util.Optional;
-import java.util.stream.Collectors;

+import static de.steamwar.bausystem.config.legacy.YapionReader.*;
+
+/**
+ * Loads the legacy per player .yapion files containing multiple simulators, they are
+ * deleted after loading and saved in the current format by the {@link SimulatorSaver}.
+ */
+@Deprecated
 public class YAPIONFormatSimulatorLoader implements SimulatorLoader {

    @Override
@@ -46,10 +52,10 @@ public class YAPIONFormatSimulatorLoader implements SimulatorLoader {
            return Optional.empty();
        }

-        YAPIONObject yapionObject;
+        Map<String, Object> yapionObject;
        try {
-            yapionObject = YAPIONParser.parse(file);
-        } catch (YAPIONException | IOException e) {
+            yapionObject = YapionReader.parse(Files.readString(file.toPath(), StandardCharsets.UTF_8));
+        } catch (IllegalArgumentException | IOException e) {
            return Optional.empty();
        }

@@ -57,28 +63,28 @@ public class YAPIONFormatSimulatorLoader implements SimulatorLoader {
        SteamwarUser steamwarUser = SteamwarUser.byId(Integer.parseInt(name));

        List<Simulator> simulators = new ArrayList<>();
-        for (String s : yapionObject.getKeys()) {
+        for (String s : yapionObject.keySet()) {
            String newName = steamwarUser.getUserName() + (s.isEmpty() ? "" : "_" + s);
-            YAPIONArray content = yapionObject.getArray(s);
+            List<Map<?, ?>> content = getObjects(yapionObject, s);
            if (content.isEmpty()) continue;
            Simulator simulator = new Simulator(newName);
-            for (YAPIONObject element : content.streamObject().collect(Collectors.toList())) {
+            for (Map<?, ?> element : content) {
                SimulatorGroup simulatorGroup = new SimulatorGroup();
                simulator.add(simulatorGroup);

-                TNTElement tntElement = new TNTElement(new Vector(element.getDouble("positionX"), element.getDouble("positionY"), element.getDouble("positionZ")));
-                tntElement.setDisabled(element.getBooleanOrDefault("disabled", false)); // IDK if this existed back then?
-                tntElement.setMaterial(Material.valueOf(element.getStringOrDefault("material", "TNT")));
+                TNTElement tntElement = new TNTElement(new Vector(requireDouble(element, "positionX"), requireDouble(element, "positionY"), requireDouble(element, "positionZ")));
+                tntElement.setDisabled(getBoolean(element, "disabled", false)); // IDK if this existed back then?
+                tntElement.setMaterial(Material.valueOf(getString(element, "material", "TNT")));
                simulatorGroup.add(tntElement);

                TNTPhase tntPhase = new TNTPhase();
-                tntPhase.setLifetime(element.getIntOrDefault("fuseTicks", 80));
-                tntPhase.setCount(element.getIntOrDefault("count", 1));
-                tntPhase.setTickOffset(element.getIntOrDefault("tickOffset", 0));
-                tntPhase.setXJump(element.getBooleanOrDefault("xVelocity", false));
-                tntPhase.setYJump(element.getBooleanOrDefault("yVelocity", false));
-                tntPhase.setZJump(element.getBooleanOrDefault("zVelocity", false));
-                tntPhase.setOrder(element.getBooleanOrDefault("comparator", false) ? 2 : 0);
+                tntPhase.setLifetime(getInt(element, "fuseTicks", 80));
+                tntPhase.setCount(getInt(element, "count", 1));
+                tntPhase.setTickOffset(getInt(element, "tickOffset", 0));
+                tntPhase.setXJump(getBoolean(element, "xVelocity", false));
+                tntPhase.setYJump(getBoolean(element, "yVelocity", false));
+                tntPhase.setZJump(getBoolean(element, "zVelocity", false));
+                tntPhase.setOrder(getBoolean(element, "comparator", false) ? 2 : 0);
                tntElement.add(tntPhase);
            }
            simulators.add(simulator);
@@ -87,4 +93,8 @@ public class YAPIONFormatSimulatorLoader implements SimulatorLoader {
        file.delete();
        return Optional.of(simulators);
    }
+
+    private double requireDouble(Map<?, ?> element, String key) {
+        return ((Number) element.get(key)).doubleValue();
+    }
 }
@@ -0,0 +1,64 @@
+/*
+ *   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.laufbau;
+
+import de.steamwar.bausystem.config.ConfigStore;
+import de.steamwar.bausystem.config.VersionedConfig;
+import de.steamwar.bausystem.features.slaves.laufbau.converter.LaufbauConfigV1ToV2Converter;
+import lombok.AccessLevel;
+import lombok.Getter;
+import lombok.Setter;
+
+import java.util.HashSet;
+import java.util.Set;
+
+/**
+ * The current laufbau config of a player. It is stored as JSON, fields missing
+ * in the stored JSON keep the default value of their initializer, so adding a
+ * new field does not need a new version.
+ * <p>
+ * When a field gets removed, renamed or its meaning changes, copy this class
+ * to LaufbauConfigV{@link #VERSION} (without the {@link #STORE}), increase {@link #VERSION}, write a
+ * {@link de.steamwar.bausystem.config.ConfigConverter} from the copy to
+ * this class and register it in the {@link #STORE}.
+ */
+@Getter
+@Setter
+public class LaufbauConfig implements VersionedConfig {
+
+    public static final int VERSION = 2;
+
+    /**
+     * LaufbauConfigV1 is stored as Base64 of gzipped YAPION, the current version as JSON
+     */
+    public static final ConfigStore<LaufbauConfig> STORE = new ConfigStore<>(LaufbauConfig.class, VERSION, LaufbauConfig::new)
+            .legacy(s -> !s.startsWith("{"), LaufbauConfigV1::parse)
+            .converter(new LaufbauConfigV1ToV2Converter())
+            .userConfig("bausystem-laufbau")
+            .removeIf(config -> config.getDeactivated().isEmpty());
+
+    @Setter(AccessLevel.NONE)
+    protected int version = VERSION;
+
+    /**
+     * Identifiers of the deactivated {@link BlockBoundingBox}es, see {@link LaufbauUtils#identifier(BlockBoundingBox)}
+     */
+    protected Set<String> deactivated = new HashSet<>();
+}
@@ -0,0 +1,65 @@
+/*
+ *   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.laufbau;
+
+import de.steamwar.bausystem.config.VersionedConfig;
+import de.steamwar.bausystem.config.legacy.YapionReader;
+import lombok.AccessLevel;
+import lombok.Getter;
+import lombok.Setter;
+
+import java.io.ByteArrayInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.UncheckedIOException;
+import java.nio.charset.StandardCharsets;
+import java.util.Base64;
+import java.util.HashSet;
+import java.util.Set;
+import java.util.zip.GZIPInputStream;
+
+/**
+ * The legacy laufbau config that was stored as Base64 of the gzipped YAPION,
+ * an object with the deactivated identifiers as keys.
+ */
+@Getter
+@Setter
+@Deprecated
+public class LaufbauConfigV1 implements VersionedConfig {
+
+    public static final int VERSION = 1;
+
+    @Setter(AccessLevel.NONE)
+    protected int version = VERSION;
+
+    protected Set<String> deactivated = new HashSet<>();
+
+    public static LaufbauConfigV1 parse(String base64) {
+        String yapion;
+        try (InputStream inputStream = new GZIPInputStream(new ByteArrayInputStream(Base64.getDecoder().decode(base64)))) {
+            yapion = new String(inputStream.readAllBytes(), StandardCharsets.UTF_8);
+        } catch (IOException e) {
+            throw new UncheckedIOException(e);
+        }
+        LaufbauConfigV1 config = new LaufbauConfigV1();
+        config.deactivated.addAll(YapionReader.parse(yapion).keySet());
+        return config;
+    }
+}
@@ -20,63 +20,22 @@
 package de.steamwar.bausystem.features.slaves.laufbau;

 import de.steamwar.bausystem.BauSystem;
-import de.steamwar.core.SWPlayer;
 import de.steamwar.inventory.SWItem;
-import de.steamwar.sql.UserConfig;
-import lombok.Cleanup;
 import lombok.SneakyThrows;
 import lombok.experimental.UtilityClass;
 import org.bukkit.Material;
 import org.bukkit.entity.Player;
 import org.bukkit.inventory.meta.ItemMeta;
-import yapion.hierarchy.output.StreamOutput;
-import yapion.hierarchy.types.YAPIONObject;
-import yapion.parser.YAPIONParser;
-import yapion.parser.options.StreamOptions;

-import java.io.ByteArrayInputStream;
-import java.io.ByteArrayOutputStream;
 import java.util.ArrayList;
 import java.util.Arrays;
-import java.util.Base64;
 import java.util.List;
+import java.util.Set;
 import java.util.stream.Collectors;
-import java.util.zip.GZIPInputStream;
-import java.util.zip.GZIPOutputStream;

@UtilityClass
 public class LaufbauUtils {

-    public static class LaufbauComponent implements SWPlayer.Component {
-
-        private YAPIONObject yapionObject = new YAPIONObject();
-
-        @Override
-        @SneakyThrows
-        public void onMount(SWPlayer player) {
-            String config = UserConfig.getConfig(player.getPlayer().getUniqueId(), "bausystem-laufbau");
-            if (config == null) {
-                return;
-            }
-            byte[] bytes = Base64.getDecoder().decode(config);
-            @Cleanup GZIPInputStream gzipInputStream = new GZIPInputStream(new ByteArrayInputStream(bytes));
-            yapionObject = new YAPIONParser(gzipInputStream, new StreamOptions().stopOnStreamEnd(true)).parse().result();
-        }
-
-        @Override
-        @SneakyThrows
-        public void onUnmount(SWPlayer player) {
-            if (yapionObject.isEmpty()) {
-                UserConfig.removePlayerConfig(player.getPlayer().getUniqueId(), "bausystem-laufbau");
-                return;
-            }
-            @Cleanup ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
-            @Cleanup GZIPOutputStream gzipOutputStream = new GZIPOutputStream(byteArrayOutputStream);
-            yapionObject.toYAPION(new StreamOutput(gzipOutputStream)).close();
-            UserConfig.updatePlayerConfig(player.getPlayer().getUniqueId(), "bausystem-laufbau", Base64.getEncoder().encodeToString(byteArrayOutputStream.toByteArray()));
-        }
-    }
-
    public static Cuboid pixelCuboid(double pixelX, double pixelY, double pixelZ, double pixelDX, double pixelDY, double pixelDZ) {
        return new Cuboid(pixelToBlock(pixelX), pixelToBlock(pixelY), pixelToBlock(pixelZ), pixelToBlock(pixelDX), pixelToBlock(pixelDY), pixelToBlock(pixelDZ));
    }
@@ -123,7 +82,7 @@ public class LaufbauUtils {
            return false;
        }
        String identifier = identifier(bb);
-        return SWPlayer.of(p).getComponentOrDefault(LaufbauComponent.class, LaufbauComponent::new).yapionObject.containsKey(identifier);
+        return LaufbauConfig.STORE.get(p).getDeactivated().contains(identifier);
    }

    @SneakyThrows
@@ -132,11 +91,9 @@ public class LaufbauUtils {
            return;
        }
        String identifier = identifier(bb);
-        YAPIONObject yapionObject = SWPlayer.of(p).getComponentOrDefault(LaufbauComponent.class, LaufbauComponent::new).yapionObject;
-        if (yapionObject.containsKey(identifier)) {
-            yapionObject.remove(identifier);
-        } else {
-            yapionObject.put(identifier, new YAPIONObject());
+        Set<String> deactivated = LaufbauConfig.STORE.get(p).getDeactivated();
+        if (!deactivated.remove(identifier)) {
+            deactivated.add(identifier);
        }
    }
 }
@@ -0,0 +1,40 @@
+/*
+ *   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.laufbau.converter;
+
+import de.steamwar.bausystem.config.ConfigConverter;
+import de.steamwar.bausystem.features.slaves.laufbau.LaufbauConfig;
+import de.steamwar.bausystem.features.slaves.laufbau.LaufbauConfigV1;
+
+@Deprecated
+public class LaufbauConfigV1ToV2Converter implements ConfigConverter<LaufbauConfigV1, LaufbauConfig> {
+
+    @Override
+    public int version() {
+        return LaufbauConfigV1.VERSION;
+    }
+
+    @Override
+    public LaufbauConfig convert(LaufbauConfigV1 old) {
+        LaufbauConfig config = new LaufbauConfig();
+        config.getDeactivated().addAll(old.getDeactivated());
+        return config;
+    }
+}
@@ -35,8 +35,8 @@ public class SmartPlaceCommand extends SWCommand {

    @Register(description = {"SMART_PLACE_HELP", "SMART_PLACE_INFO"})
    public void genericToggle(Player p) {
-        boolean smartPlace = Config.getInstance().get(p).getPlainValueOrDefault("smartPlace", false);
-        Config.getInstance().get(p).put("smartPlace", !smartPlace);
+        boolean smartPlace = Config.STORE.get(p).isSmartPlace();
+        Config.STORE.get(p).setSmartPlace(!smartPlace);
        if (!smartPlace) {
            SWUtils.sendToActionbar(p, BauSystem.MESSAGE.parse("SMART_PLACE_ENABLE", p));
            BauSystem.MESSAGE.send("SMART_PLACE_INFO", p);
@@ -87,7 +87,7 @@ public class SmartPlaceListener implements Listener {
    public SmartPlaceListener() {
        TinyProtocol.instance.addFilter(ServerboundUseItemOnPacket.class, (player, packet) -> {
            if (!Permission.BUILD.hasPermission(player)) return packet;
-            if (!Config.getInstance().get(player).getPlainValueOrDefault("smartPlace", false)) return packet;
+            if (!Config.STORE.get(player).isSmartPlace()) return packet;
            RayTraceResult rayTraceResult = player.rayTraceBlocks(6);
            Block block = rayTraceResult != null ? rayTraceResult.getHitBlock() : null;
            BlockFace blockFace = rayTraceResult != null ? rayTraceResult.getHitBlockFace() : null;
@@ -127,7 +127,7 @@ public class SmartPlaceListener implements Listener {
    @EventHandler
    public void onPlayerInteract(PlayerInteractEvent event) {
        if (!Permission.BUILD.hasPermission(event.getPlayer())) return;
-        if (!Config.getInstance().get(event.getPlayer()).getPlainValueOrDefault("smartPlace", false)) return;
+        if (!Config.STORE.get(event.getPlayer()).isSmartPlace()) return;
        WAS_EXECUTED.add(event.getPlayer());
        if (event.getAction() != Action.RIGHT_CLICK_BLOCK) return;
        if (event.getPlayer().getGameMode() == GameMode.SPECTATOR) return;
@@ -146,7 +146,7 @@ public class SmartPlaceListener implements Listener {
    @EventHandler
    public void onBlockPlace(BlockPlaceEvent event) {
        if (!Permission.BUILD.hasPermission(event.getPlayer())) return;
-        if (!Config.getInstance().get(event.getPlayer()).getPlainValueOrDefault("smartPlace", false)) return;
+        if (!Config.STORE.get(event.getPlayer()).isSmartPlace()) return;
        if (!SMART_PLACING.contains(event.getPlayer())) {
            if (CONTAINERS.contains(event.getBlockAgainst().getType())) {
                SoundGroup soundGroup = event.getBlockPlaced().getBlockData().getSoundGroup();
@@ -35,18 +35,15 @@ public class BlockCounter {
    public final Map<Region, BlockCount> blockCountMap = new HashMap<>();

    public boolean isActive(final Player p) {
-        if (!Config.getInstance().get(p).containsKey("blockCounter")) {
-            return false;
-        }
-        return Config.getInstance().get(p).getPlainValue("blockCounter");
+        return Config.STORE.get(p).isBlockCounter();
    }

    public void enable(final Player p) {
-        Config.getInstance().get(p).put("blockCounter", true);
+        Config.STORE.get(p).setBlockCounter(true);
    }

    public void disable(final Player p) {
-        Config.getInstance().get(p).put("blockCounter", false);
+        Config.STORE.get(p).setBlockCounter(false);
    }

    public String getMessage(Player player, int count, int tntCount, long tick, long lastTick) {
@@ -165,6 +165,7 @@ public class TPSSystem implements Listener {
        }

        @Register(value = "default", description = "TPSLIMIT_DEFAULT_HELP")
+        @Register(value = "rate")
        public void reset(@Validator Player player) {
            TickManager.impl.setTickRate(20.0F);
            sendTickRateChange();
@@ -187,15 +188,18 @@ public class TPSSystem implements Listener {
        }

        @Register(value = {"rate", "0"}, description = "TICK_FREEZE_HELP")
-        @Register(value = "freeze", description = "TICK_FREEZE_HELP_2")
-        public void freeze(@Validator Player player) {
+        public void rate(@Validator Player player) {
            TickManager.impl.setFreeze(true);
            sendTickRateChange();
        }

-        @Register(value = "unfreeze", description = "TICK_UNFREEZE_HELP")
-        public void unfreeze(@Validator Player player) {
-            TickManager.impl.setTickRate(20.0F);
+        @Register(value = "freeze", description = "TICK_FREEZE_HELP_2")
+        public void freezeToggle(@Validator Player player) {
+            if (TickManager.impl.isFrozen()) {
+                TickManager.impl.setTickRate(20.0F);
+            } else {
+                TickManager.impl.setFreeze(true);
+            }
            sendTickRateChange();
        }
    }
@@ -36,13 +36,10 @@ import org.bukkit.entity.Player;
 import org.bukkit.util.Transformation;
 import org.joml.Quaternionf;
 import org.joml.Vector3f;
-import yapion.hierarchy.types.YAPIONValue;

 import java.util.List;
 import java.util.stream.Collectors;

-import static de.steamwar.bausystem.features.util.TNTClickListener.TNT_CLICK_DETAILS;
-
 /**
 * Wrapper for the rendering of a record bundle
 */
@@ -102,7 +99,7 @@ public class TraceEntity extends RBlockDisplay {
     * @param player the player the message should be printed for
     */
    public void printIntoChat(Player player) {
-        if (!Config.getInstance().get(player).getOrSetDefault(TNT_CLICK_DETAILS, new YAPIONValue<>(true)).asBoolean().orElse(true)) {
+        if (!Config.STORE.get(player).isTntClickDetails()) {
            return;
        }
        TNTPoint representative = records.get(0);
@@ -30,7 +30,6 @@ import org.bukkit.event.Listener;
 import org.bukkit.event.player.PlayerJoinEvent;
 import org.bukkit.potion.PotionEffect;
 import org.bukkit.potion.PotionEffectType;
-import yapion.hierarchy.types.YAPIONObject;

@Linked
 public class NightVisionCommand extends SWCommand implements Listener {
@@ -41,15 +40,15 @@ public class NightVisionCommand extends SWCommand implements Listener {

    @Register(description = "NIGHT_VISION_HELP")
    public void genericCommand(Player p) {
-        YAPIONObject yapionObject = Config.getInstance().get(p);
-        boolean value = !yapionObject.getBooleanOrDefault("nightvision", false);
-        yapionObject.put("nightvision", value);
+        Config config = Config.STORE.get(p);
+        boolean value = !config.isNightVision();
+        config.setNightVision(value);
        setNightVision(p, value);
    }

    @EventHandler
    public void onPlayerJoin(PlayerJoinEvent event) {
-        setNightVision(event.getPlayer(), Config.getInstance().get(event.getPlayer()).getBooleanOrDefault("nightvision", false));
+        setNightVision(event.getPlayer(), Config.STORE.get(event.getPlayer()).isNightVision());
    }

    private void setNightVision(Player p, boolean value) {
@@ -53,7 +53,7 @@ public class NoClipCommand extends SWCommand implements Listener {

        @Override
        public void onUnmount(SWPlayer player) {
-            player.setGameMode(GameMode.CREATIVE);
+            player.getPlayer().setGameMode(GameMode.CREATIVE);
        }
    }

@@ -115,6 +115,7 @@ public class NoClipCommand extends SWCommand implements Listener {
            Abilities abilities = (((CraftPlayer) player).getHandle()).getAbilities();
            abilities.mayBuild = true;
            abilities.mayfly = true;
+            abilities.instabuild = true;

            swPlayer.setComponent(new NoClipData());
            BauSystem.MESSAGE.send("OTHER_NOCLIP_SLOT_INFO", player);
@@ -32,26 +32,22 @@ import org.bukkit.event.EventHandler;
 import org.bukkit.event.Listener;
 import org.bukkit.event.player.PlayerInteractEntityEvent;
 import org.bukkit.inventory.EquipmentSlot;
-import yapion.hierarchy.types.YAPIONObject;
-import yapion.hierarchy.types.YAPIONValue;

@Linked
 public class TNTClickListener extends SWCommand implements Listener {

-    public static final String TNT_CLICK_DETAILS = "tnt_click_details";
-
    public TNTClickListener() {
        super("tntdetails");
    }

    @Register(description = "TNT_DETAILS_COMMAND")
    public void toggle(Player player) {
-        YAPIONObject yapionObject = Config.getInstance().get(player);
-        if (yapionObject.getOrSetDefault(TNT_CLICK_DETAILS, new YAPIONValue<>(true)).asBoolean().orElse(true)) {
-            yapionObject.put(TNT_CLICK_DETAILS, false);
+        Config config = Config.STORE.get(player);
+        if (config.isTntClickDetails()) {
+            config.setTntClickDetails(false);
            BauSystem.MESSAGE.send("TNT_DETAILS_OFF", player);
        } else {
-            yapionObject.put(TNT_CLICK_DETAILS, true);
+            config.setTntClickDetails(true);
            BauSystem.MESSAGE.send("TNT_DETAILS_ON", player);
        }
    }
@@ -60,7 +56,7 @@ public class TNTClickListener extends SWCommand implements Listener {
    public void onPlayerInteractEntity(PlayerInteractEntityEvent event) {
        if (!Permission.BUILD.hasPermission(event.getPlayer())) return;
        if (event.getHand() != EquipmentSlot.HAND) return;
-        if (!Config.getInstance().get(event.getPlayer()).getOrSetDefault(TNT_CLICK_DETAILS, new YAPIONValue<>(true)).asBoolean().orElse(true)) {
+        if (!Config.STORE.get(event.getPlayer()).isTntClickDetails()) {
            return;
        }

@@ -25,7 +25,6 @@ import lombok.Getter;
 import org.bukkit.*;
 import org.bukkit.entity.Player;
 import org.bukkit.event.player.PlayerTeleportEvent;
-import yapion.hierarchy.types.YAPIONObject;

 import java.util.*;

@@ -56,27 +55,22 @@ public class Warp {
        warpMap.put(name, this);
    }

-    public Warp(String name, YAPIONObject object) {
+    public Warp(String name, WorldData.WarpEntry warp) {
        this.name = name;
-        double x = object.getPlainValue("x");
-        double y = object.getPlainValue("y");
-        double z = object.getPlainValue("z");
-        float yaw = object.getPlainValue("yaw");
-        float pitch = object.getPlainValue("pitch");
-        location = new Location(Bukkit.getWorlds().get(0), x, y, z, yaw, pitch);
-        mat = Material.getMaterial(object.getPlainValue("material"));
+        location = new Location(Bukkit.getWorlds().get(0), warp.getX(), warp.getY(), warp.getZ(), warp.getYaw(), warp.getPitch());
+        mat = Material.getMaterial(warp.getMaterial());
        warpMap.put(name, this);
    }

-    public YAPIONObject output() {
-        YAPIONObject yapionObject = new YAPIONObject();
-        yapionObject.add("x", location.getX());
-        yapionObject.add("y", location.getY());
-        yapionObject.add("z", location.getZ());
-        yapionObject.add("yaw", location.getYaw());
-        yapionObject.add("pitch", location.getPitch());
-        yapionObject.add("material", mat.toString());
-        return yapionObject;
+    public WorldData.WarpEntry output() {
+        WorldData.WarpEntry warp = new WorldData.WarpEntry();
+        warp.setX(location.getX());
+        warp.setY(location.getY());
+        warp.setZ(location.getZ());
+        warp.setYaw(location.getYaw());
+        warp.setPitch(location.getPitch());
+        warp.setMaterial(mat.toString());
+        return warp;
    }

    public static Set<String> getWarpNames() {
@@ -101,7 +95,7 @@ public class Warp {

    public void delete() {
        warpMap.remove(name);
-        WorldData.getWarpData().remove(name);
+        WorldData.STORE.get().getWarps().remove(name);
    }

    public void teleport(Player player) {
@@ -34,9 +34,9 @@ import net.md_5.bungee.api.chat.ComponentBuilder;
 import net.md_5.bungee.api.chat.HoverEvent;
 import net.md_5.bungee.api.chat.TextComponent;
 import org.bukkit.entity.Player;
-import yapion.hierarchy.types.YAPIONObject;

 import java.util.ArrayList;
+import java.util.Map;

@Linked
 public class WarpCommand extends SWCommand implements Disable, Enable {
@@ -135,17 +135,15 @@ public class WarpCommand extends SWCommand implements Disable, Enable {

    @Override
    public void enable() {
-        WorldData.getWarpData().forEach((name, yapionAnyType) -> {
-            new Warp(name, (YAPIONObject) yapionAnyType);
-        });
+        WorldData.STORE.get().getWarps().forEach(Warp::new);
        Warp.enable();
    }

    @Override
    public void disable() {
-        YAPIONObject yapionObject = WorldData.getWarpData();
+        Map<String, WorldData.WarpEntry> warps = WorldData.STORE.get().getWarps();
        for (Warp warp : Warp.getWarps()) {
-            yapionObject.add(warp.getName(), warp.output());
+            warps.put(warp.getName(), warp.output());
        }
    }
 }
@@ -0,0 +1,41 @@
+/*
+ *   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.world;
+
+import de.steamwar.linkage.Linked;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.Listener;
+import org.bukkit.event.player.PlayerJoinEvent;
+import org.bukkit.scoreboard.Scoreboard;
+import org.bukkit.scoreboard.Team;
+
+@Linked
+public class AntiPlayerCollision implements Listener {
+
+    @EventHandler(priority = EventPriority.MONITOR)
+    public void onPlayerJoin(PlayerJoinEvent event) {
+        Scoreboard board = event.getPlayer().getScoreboard();
+        Team team = board.getTeam("players");
+        if (team == null) team = board.registerNewTeam("players");
+        team.setOption(Team.Option.COLLISION_RULE, Team.OptionStatus.NEVER);
+        team.addPlayer(event.getPlayer());
+    }
+}
@@ -131,6 +131,7 @@ public class BauScoreboard implements Listener {

    @EventHandler
    public void onPlayerQuit(PlayerQuitEvent event) {
+        SWScoreboard.impl.removeScoreboard(event.getPlayer());
        ADDITIONAL_SCOREBOARD_LINES.remove(event.getPlayer());
    }
 }
@@ -20,78 +20,39 @@
 package de.steamwar.bausystem.region;

 import de.steamwar.bausystem.region.flags.Flag;
+import de.steamwar.bausystem.worlddata.WorldData;
 import de.steamwar.sql.SchematicNode;
 import lombok.NonNull;
-import yapion.hierarchy.types.YAPIONObject;

-import java.util.ArrayList;
 import java.util.HashMap;
-import java.util.List;
 import java.util.Map;
-import java.util.function.Function;

 public abstract class RegionData {

-    private final List<Property<?, ?>> properties = new ArrayList<>();
-
-    protected final YAPIONObject data;
-    protected final YAPIONObject flagData;
+    protected final WorldData.RegionEntry data;
+    protected final Map<String, String> flagData;
    protected final Runnable onChange;
    protected final Map<Flag<?>, Flag.Value<?>> flagMap = new HashMap<>();

-    private final class Property<T, K> {
-        private final String field;
-        private final Function<K, T> loader;
-        private final Function<T, K> writer;
+    private SchematicNode testblockSchematic;

-        private T value;
-
-        public Property(String field, Function<K, T> loader, Function<T, K> writer) {
-            this.field = field;
-            this.loader = loader;
-            this.writer = writer;
-            properties.add(this);
-        }
-
-        public void load() {
-            if (flagData.containsKey(field)) {
-                value = loader.apply(flagData.getPlainValue(field));
-            } else {
-                value = null;
-            }
-        }
-
-        public T get() {
-            return value;
-        }
-
-        public void set(T value) {
-            this.value = value;
-            if (value == null) {
-                flagData.remove(field);
-            } else {
-                flagData.put(field, writer.apply(value));
-            }
-        }
-    }
-
-    private Property<SchematicNode, Integer> testblockSchematic = new Property<>("testblockSchematic", SchematicNode::byId, SchematicNode::getId);
-
-    protected RegionData(YAPIONObject data, Runnable onChange) {
+    protected RegionData(WorldData.RegionEntry data, Runnable onChange) {
        this.data = data;
-        this.flagData = data.getObjectOrSetDefault("flagStorage", new YAPIONObject());
+        this.flagData = data.getFlags();
        this.onChange = onChange;
        initialize();
        for (final Flag flag : Flag.getFlags()) {
            if (!has(flag).isWritable()) continue;
            try {
-                String s = flagData.getPlainValue(flag.name());
+                String s = flagData.get(flag.name());
                flagMap.put(flag, flag.valueOfValue(s));
            } catch (Exception e) {
                flagMap.put(flag, (Flag.Value<?>) flag.getDefaultValue());
            }
        }
-        properties.forEach(Property::load);
+        if (data.getTestblockSchematic() != null) {
+            testblockSchematic = SchematicNode.byId(data.getTestblockSchematic());
+        }
    }

    protected void initialize() {
@@ -126,7 +87,8 @@ public abstract class RegionData {
                flagData.remove(flag.name());
            }
        }
-        properties.forEach(property -> property.set(null));
+        testblockSchematic = null;
+        data.setTestblockSchematic(null);
        onChange.run();
    }

@@ -135,11 +97,12 @@ public abstract class RegionData {
    }

    public SchematicNode getTestblockSchematic() {
-        return testblockSchematic.get();
+        return testblockSchematic;
    }

    public void setTestblockSchematic(SchematicNode schematic) {
-        testblockSchematic.set(schematic);
+        testblockSchematic = schematic;
+        data.setTestblockSchematic(schematic == null ? null : schematic.getId());
        onChange.run();
    }

@@ -1,101 +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.bausystem.worlddata;
-
-import de.steamwar.sql.SteamwarUser;
-import lombok.SneakyThrows;
-import lombok.experimental.UtilityClass;
-import org.bukkit.Bukkit;
-import org.bukkit.entity.Player;
-import yapion.hierarchy.output.FileOutput;
-import yapion.hierarchy.types.YAPIONArray;
-import yapion.hierarchy.types.YAPIONObject;
-import yapion.parser.InputStreamCharsets;
-import yapion.parser.YAPIONParser;
-import yapion.parser.options.FileOptions;
-
-import java.io.File;
-import java.util.List;
-
-@UtilityClass
-public class SimulatorData {
-
-    private final File simulatorsDir = new File(Bukkit.getWorlds().get(0).getWorldFolder(), "simulators");
-
-    static {
-        simulatorsDir.mkdirs();
-    }
-
-    @SneakyThrows
-    public YAPIONObject getSimulator(Player player) {
-        File file = getFile(player);
-        if (!file.exists()) {
-            return new YAPIONObject();
-        }
-        return YAPIONParser.parse(file, new FileOptions().charset(InputStreamCharsets.UTF_8));
-    }
-
-    @SneakyThrows
-    private void internalSaveSimulator(Player player, YAPIONObject yapionObject) {
-        File file = getFile(player);
-        yapionObject.toYAPION(new FileOutput(file)).close();
-    }
-
-    @SneakyThrows
-    void saveSimulator(SteamwarUser steamwarUser, YAPIONObject yapionObject) {
-        File file = new File(simulatorsDir, steamwarUser.getId() + ".yapion");
-        yapionObject.toYAPION(new FileOutput(file)).close();
-    }
-
-    public List<String> listSimulator(Player player) {
-        List<String> strings = getSimulator(player).getKeys();
-        strings.remove("");
-        return strings;
-    }
-
-    public void saveSimulator(Player player, String name) {
-        YAPIONObject yapionObject = getSimulator(player);
-        yapionObject.put(name, yapionObject.getArray("").copy());
-        internalSaveSimulator(player, yapionObject);
-    }
-
-    public void saveSimulator(Player player, YAPIONArray simulator) {
-        YAPIONObject yapionObject = getSimulator(player);
-        yapionObject.put("", simulator);
-        internalSaveSimulator(player, yapionObject);
-    }
-
-    public void loadSimulator(Player player, String name) {
-        YAPIONObject yapionObject = getSimulator(player);
-        yapionObject.put("", yapionObject.getArray(name).copy());
-        internalSaveSimulator(player, yapionObject);
-    }
-
-    public void removeSimulator(Player player, String name) {
-        YAPIONObject yapionObject = getSimulator(player);
-        yapionObject.remove(name);
-        internalSaveSimulator(player, yapionObject);
-    }
-
-    private File getFile(Player player) {
-        SteamwarUser steamwarUser = SteamwarUser.get(player.getUniqueId());
-        return new File(simulatorsDir, steamwarUser.getId() + ".yapion");
-    }
-}
@@ -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
@@ -19,58 +19,83 @@

 package de.steamwar.bausystem.worlddata;

-import lombok.experimental.UtilityClass;
+import com.google.gson.GsonBuilder;
+import de.steamwar.bausystem.config.ConfigStore;
+import de.steamwar.bausystem.config.VersionedConfig;
+import de.steamwar.bausystem.worlddata.converter.WorldDataV1ToV2Converter;
+import lombok.AccessLevel;
+import lombok.Getter;
+import lombok.Setter;
 import org.bukkit.Bukkit;
-import yapion.hierarchy.output.FileOutput;
-import yapion.hierarchy.types.YAPIONObject;
-import yapion.parser.InputStreamCharsets;
-import yapion.parser.YAPIONParser;
-import yapion.parser.options.StreamOptions;

-import java.io.BufferedInputStream;
 import java.io.File;
-import java.io.FileInputStream;
-import java.io.IOException;
+import java.util.HashMap;
+import java.util.Map;

-@UtilityClass
-public class WorldData {
+/**
+ * The current world data. It is stored as JSON, fields missing in the
+ * stored JSON keep the default value of their initializer, so adding a new
+ * field does not need a new version.
+ * <p>
+ * When a field gets removed, renamed or its meaning changes, copy this class
+ * to WorldDataV{@link #VERSION} (without the {@link #STORE}), increase {@link #VERSION}, write a
+ * {@link de.steamwar.bausystem.config.ConfigConverter} from the copy to this class and register it in the {@link #STORE}.
+ */
+@Getter
+@Setter
+public class WorldData implements VersionedConfig {

-    private final File optionsFile = new File(Bukkit.getWorlds().get(0).getWorldFolder(), "options.yapion");
-    private YAPIONObject worldData;
+    public static final int VERSION = 2;

-    public YAPIONObject getWorldData() {
-        if (worldData == null) {
-            read();
-        }
-        return worldData;
+    public static final ConfigStore<WorldData> STORE = new ConfigStore<>(WorldData.class, VERSION, WorldData::new)
+            .gson(new GsonBuilder().setPrettyPrinting().create())
+            .converter(new WorldDataV1ToV2Converter())
+            .file(new File(Bukkit.getWorlds().get(0).getWorldFolder(), "options.json"))
+            .legacyFile(new File(Bukkit.getWorlds().get(0).getWorldFolder(), "options.yapion"), WorldDataV1::parse);
+
+    @Setter(AccessLevel.NONE)
+    protected int version = VERSION;
+
+    /**
+     * Region name to the data of the region
+     */
+    protected Map<String, RegionEntry> regions = new HashMap<>();
+    protected RegionEntry globalRegion = new RegionEntry();
+
+    /**
+     * Warp name to warp
+     */
+    protected Map<String, WarpEntry> warps = new HashMap<>();
+
+    @Getter
+    @Setter
+    public static class RegionEntry {
+
+        /**
+         * Overrides the prototype of the region config, null if not overridden
+         */
+        protected String prototype = null;
+
+        /**
+         * Flag name to flag value name
+         */
+        protected Map<String, String> flags = new HashMap<>();
+
+        /**
+         * Id of the testblock SchematicNode, null if the default testblock is used
+         */
+        protected Integer testblockSchematic = null;
    }

-    public YAPIONObject getRegionsData() {
-        return getWorldData().getYAPIONObjectOrSetDefault("regions", new YAPIONObject());
-    }
+    @Getter
+    @Setter
+    public static class WarpEntry {

-    public YAPIONObject getWarpData() {
-        return getWorldData().getYAPIONObjectOrSetDefault("warps", new YAPIONObject());
-    }
-
-    private void read() {
-        worldData = new YAPIONObject();
-        if (optionsFile.length() != 0) {
-            try (BufferedInputStream bufferedInputStream = new BufferedInputStream(new FileInputStream(optionsFile))) {
-                worldData = YAPIONParser.parse(bufferedInputStream, new StreamOptions().charset(InputStreamCharsets.UTF_8));
-            } catch (IOException e) {
-                // Ignored
-            }
-        } else {
-            write();
-        }
-    }
-
-    public void write() {
-        try {
-            worldData.toYAPION(new FileOutput(optionsFile)).close();
-        } catch (IOException e) {
-            e.printStackTrace();
-        }
+        protected double x;
+        protected double y;
+        protected double z;
+        protected float yaw;
+        protected float pitch;
+        protected String material;
    }
 }
@@ -0,0 +1,111 @@
+/*
+ *   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.worlddata;
+
+import de.steamwar.bausystem.config.VersionedConfig;
+import de.steamwar.bausystem.config.legacy.YapionReader;
+import lombok.AccessLevel;
+import lombok.Getter;
+import lombok.Setter;
+
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * The legacy world data that was stored in the YAPION format in options.yapion.
+ */
+@Getter
+@Setter
+@Deprecated
+public class WorldDataV1 implements VersionedConfig {
+
+    public static final int VERSION = 1;
+
+    @Setter(AccessLevel.NONE)
+    protected int version = VERSION;
+
+    /**
+     * Region name to the data of the region, the global region is stored with the name "global"
+     */
+    protected Map<String, RegionEntry> regions = new HashMap<>();
+
+    /**
+     * Warp name to warp
+     */
+    protected Map<String, WarpEntry> warps = new HashMap<>();
+
+    @Getter
+    @Setter
+    public static class RegionEntry {
+
+        protected String prototype = null;
+
+        /**
+         * Flag name to flag value name and "testblockSchematic" to the SchematicNode id
+         */
+        protected Map<String, Object> flagStorage = new HashMap<>();
+    }
+
+    @Getter
+    @Setter
+    public static class WarpEntry {
+
+        protected double x;
+        protected double y;
+        protected double z;
+        protected float yaw;
+        protected float pitch;
+        protected String material;
+    }
+
+    public static WorldDataV1 parse(String yapion) {
+        Map<String, Object> object = YapionReader.parse(yapion);
+        WorldDataV1 worldData = new WorldDataV1();
+
+        if (object.get("regions") instanceof Map<?, ?> regions) {
+            regions.forEach((name, value) -> {
+                if (!(value instanceof Map<?, ?> region)) return;
+                RegionEntry entry = new RegionEntry();
+                if (region.get("prototype") instanceof String prototype) {
+                    entry.prototype = prototype;
+                }
+                if (region.get("flagStorage") instanceof Map<?, ?> flagStorage) {
+                    flagStorage.forEach((key, flag) -> entry.flagStorage.put((String) key, flag));
+                }
+                worldData.regions.put((String) name, entry);
+            });
+        }
+
+        if (object.get("warps") instanceof Map<?, ?> warps) {
+            warps.forEach((name, value) -> {
+                if (!(value instanceof Map<?, ?> warp)) return;
+                WarpEntry entry = new WarpEntry();
+                entry.x = ((Number) warp.get("x")).doubleValue();
+                entry.y = ((Number) warp.get("y")).doubleValue();
+                entry.z = ((Number) warp.get("z")).doubleValue();
+                entry.yaw = ((Number) warp.get("yaw")).floatValue();
+                entry.pitch = ((Number) warp.get("pitch")).floatValue();
+                entry.material = (String) warp.get("material");
+                worldData.warps.put((String) name, entry);
+            });
+        }
+        return worldData;
+    }
+}
@@ -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.bausystem.worlddata.converter;
+
+import de.steamwar.bausystem.config.ConfigConverter;
+import de.steamwar.bausystem.worlddata.WorldData;
+import de.steamwar.bausystem.worlddata.WorldDataV1;
+
+@Deprecated
+public class WorldDataV1ToV2Converter implements ConfigConverter<WorldDataV1, WorldData> {
+
+    private static final String GLOBAL_REGION = "global";
+    private static final String TESTBLOCK_SCHEMATIC = "testblockSchematic";
+
+    @Override
+    public int version() {
+        return WorldDataV1.VERSION;
+    }
+
+    @Override
+    public WorldData convert(WorldDataV1 old) {
+        WorldData worldData = new WorldData();
+        old.getRegions().forEach((name, region) -> {
+            if (name.equals(GLOBAL_REGION)) {
+                worldData.setGlobalRegion(convert(region));
+            } else {
+                worldData.getRegions().put(name, convert(region));
+            }
+        });
+        old.getWarps().forEach((name, warp) -> worldData.getWarps().put(name, convert(warp)));
+        return worldData;
+    }
+
+    private WorldData.RegionEntry convert(WorldDataV1.RegionEntry old) {
+        WorldData.RegionEntry region = new WorldData.RegionEntry();
+        region.setPrototype(old.getPrototype());
+        old.getFlagStorage().forEach((key, value) -> {
+            if (value == null) return;
+            if (key.equals(TESTBLOCK_SCHEMATIC)) {
+                region.setTestblockSchematic(((Number) value).intValue());
+            } else {
+                region.getFlags().put(key, value.toString());
+            }
+        });
+        return region;
+    }
+
+    private WorldData.WarpEntry convert(WorldDataV1.WarpEntry old) {
+        WorldData.WarpEntry warp = new WorldData.WarpEntry();
+        warp.setX(old.getX());
+        warp.setY(old.getY());
+        warp.setZ(old.getZ());
+        warp.setYaw(old.getYaw());
+        warp.setPitch(old.getPitch());
+        warp.setMaterial(old.getMaterial());
+        return warp;
+    }
+}
@@ -25,12 +25,12 @@ import de.steamwar.bausystem.region.flags.ColorMode;
 import de.steamwar.bausystem.region.flags.Flag;
 import de.steamwar.bausystem.region.flags.ProtectMode;
 import de.steamwar.bausystem.region.flags.TNTMode;
+import de.steamwar.bausystem.worlddata.WorldData;
 import lombok.NonNull;
-import yapion.hierarchy.types.YAPIONObject;

 public class FixedGlobalRegionData extends RegionData {

-    public FixedGlobalRegionData(YAPIONObject data, Runnable onChange) {
+    public FixedGlobalRegionData(WorldData.RegionEntry data, Runnable onChange) {
        super(data, onChange);
    }

@@ -26,6 +26,7 @@ import de.steamwar.bausystem.region.flags.Flag;
 import de.steamwar.bausystem.region.flags.TestblockMode;
 import de.steamwar.bausystem.utils.FlatteningWrapper;
 import de.steamwar.bausystem.utils.PasteBuilder;
+import de.steamwar.bausystem.worlddata.WorldData;
 import de.steamwar.core.Core;
 import de.steamwar.sql.GameModeConfig;
 import de.steamwar.sql.SchematicType;
@@ -139,7 +140,7 @@ public class FixedRegion implements Region {
        }
    }

-    public FixedRegion(String name, FixedRegionData flagStorage, Prototype prototype, YAPIONObject regionConfig, YAPIONObject regionData) {
+    public FixedRegion(String name, FixedRegionData flagStorage, Prototype prototype, YAPIONObject regionConfig, WorldData.RegionEntry regionData) {
        this.name = name;
        uuid = UUID.nameUUIDFromBytes(name.getBytes(StandardCharsets.UTF_8));
        this.flagStorage = flagStorage;
@@ -325,7 +326,7 @@ public class FixedRegion implements Region {
        }

        floorLevel = prototype.getFloorOffset() != 0 ? minPoint.getY() + prototype.getFloorOffset() : 0;
-        waterLevel = prototype.getWaterOffset() != 0 ? minPoint.getX() + prototype.getWaterOffset() : 0;
+        waterLevel = prototype.getWaterOffset() != 0 ? minPoint.getY() + prototype.getWaterOffset() : 0;

        File found = null;
        File baseFile = new File(BauSystem.getInstance().getDataFolder().getParentFile(), "FightSystem");
@@ -22,12 +22,12 @@ package de.steamwar.bausystem.region.fixed;
 import de.steamwar.bausystem.region.RegionData;
 import de.steamwar.bausystem.region.RegionFlagPolicy;
 import de.steamwar.bausystem.region.flags.Flag;
+import de.steamwar.bausystem.worlddata.WorldData;
 import lombok.NonNull;
-import yapion.hierarchy.types.YAPIONObject;

 public class FixedRegionData extends RegionData {

-    public FixedRegionData(YAPIONObject data, Runnable onChange) {
+    public FixedRegionData(WorldData.RegionEntry data, Runnable onChange) {
        super(data, onChange);
    }

@@ -210,14 +210,14 @@ public class Prototype {
        }
    }

-    public static void generateRegion(String name, YAPIONObject regionConfig, YAPIONObject regionData) {
+    public static void generateRegion(String name, YAPIONObject regionConfig, WorldData.RegionEntry regionData) {
        Prototype prototype;
-        if (regionData.containsKey("prototype", String.class)) {
-            prototype = PROTOTYPE_MAP.get(regionData.getPlainValue("prototype"));
+        if (regionData.getPrototype() != null) {
+            prototype = PROTOTYPE_MAP.get(regionData.getPrototype());
        } else {
            prototype = PROTOTYPE_MAP.get(regionConfig.getPlainValue("prototype"));
        }
-        FixedRegionData flagStorage = new FixedRegionData(regionData, WorldData::write);
+        FixedRegionData flagStorage = new FixedRegionData(regionData, WorldData.STORE::save);
        FixedRegionSystem.addRegion(new FixedRegion(name, flagStorage, prototype, regionConfig, regionData));
    }
 }
@@ -28,7 +28,6 @@ import org.bukkit.Bukkit;
 import yapion.hierarchy.diff.DiffChange;
 import yapion.hierarchy.diff.YAPIONDiff;
 import yapion.hierarchy.types.YAPIONObject;
-import yapion.hierarchy.types.YAPIONType;
 import yapion.parser.YAPIONParser;

 import java.io.BufferedInputStream;
@@ -55,7 +54,7 @@ public class RegionLoader {
        }
        loaded = yapionObject;

-        YAPIONObject optionsYapionObject = WorldData.getRegionsData();
+        WorldData worldData = WorldData.STORE.get();
        yapionObject.forEach((key, yapionAnyType) -> {
            if (key.equals("global")) {
                return;
@@ -65,21 +64,10 @@ public class RegionLoader {
            }

            YAPIONObject regionConfig = (YAPIONObject) yapionAnyType;
-            YAPIONObject regionData = new YAPIONObject();
-            if (optionsYapionObject.containsKey(key, YAPIONType.OBJECT)) {
-                regionData = optionsYapionObject.getObject(key);
-            } else {
-                optionsYapionObject.add(key, regionData);
-            }
-
+            WorldData.RegionEntry regionData = worldData.getRegions().computeIfAbsent(key, k -> new WorldData.RegionEntry());
            Prototype.generateRegion(key, regionConfig, regionData);
        });

-        YAPIONObject globalOptions = optionsYapionObject.getObject("global");
-        if (globalOptions == null) {
-            globalOptions = new YAPIONObject();
-            optionsYapionObject.add("global", globalOptions);
-        }
-        FixedGlobalRegion.setFLAG_STORAGE(new FixedGlobalRegionData(globalOptions, WorldData::write));
+        FixedGlobalRegion.setFLAG_STORAGE(new FixedGlobalRegionData(worldData.getGlobalRegion(), WorldData.STORE::save));
    }
 }
@@ -19,6 +19,7 @@

 plugins {
    steamwar.kotlin
+    kotlin("plugin.lombok")
 }

 kotlin {
@@ -40,4 +41,8 @@ dependencies {
    compileOnlyApi(libs.exposedDao)
    compileOnlyApi(libs.exposedJdbc)
    compileOnlyApi(libs.exposedTime)
+    testImplementation(kotlin("test"))
 }
+repositories {
+    mavenCentral()
+}
@@ -688,13 +688,6 @@ public final class GameModeConfig<M, W> {
         */
        public final int MaxBlocks;

-        /**
-         * Maximal amount of items per dispenser
-         *
-         * @implSpec {@code 128} by default
-         */
-        public final int MaxDispenserItems;
-
        /**
         * Maximal blast resistance for the blocks
         *
@@ -710,10 +703,12 @@ public final class GameModeConfig<M, W> {
        public final double MaxDesignBlastResistance;

        /**
-         * List of limited material (combinations)<br/>
-         * List contains tags Amount (integer) and Materials (List of material names in Spigot 1.12 AND Spigot 1.15 format)
+         * List of limited block materials
+         *
+         * @implSpec {@link SQLWrapper#getInventoryMaterials)} are all disallowed by default to have any content but are unlimited in number.
+         * @implSpec Any Block that has more Blast Resistance than {@link #MaxBlastResistance} will be defaulted to 0.
         */
-        public final Map<Set<M>, Integer> Limited;
+        public final List<BlockRule<M>> Limited;

        private SchematicConfig(YMLWrapper<M, ?> loader) {
            loaded = loader.canLoad();
@@ -731,32 +726,140 @@ public final class GameModeConfig<M, W> {
            IgnorePublicOnly = loader.getBoolean("IgnorePublicOnly", false);
            UnlimitedPrepare = loader.getBoolean("UnlimitedPrepare", false);
            MaxBlocks = loader.getInt("MaxBlocks", 0);
-            MaxDispenserItems = loader.getInt("MaxDispenserItems", 128);
            MaxBlastResistance = loader.getDouble("MaxBlastResistance", Double.MAX_VALUE);
            MaxDesignBlastResistance = loader.getDouble("MaxDesignBlastResistance", MaxBlastResistance);

-            Map<Set<M>, Integer> Limited = new HashMap<>();
-            for (Map<?, ?> entry : loader.getMapList("Limited")) {
-                int amount = (Integer) entry.get("Amount");
-                Set<String> materials = new HashSet<>((List<String>) entry.get("Materials"));
-                if (amount == 0) {
-                    materials.forEach(material -> {
-                        Limited.put(Collections.singleton(loader.materialMapper.apply(material.toUpperCase())), 0);
-                    });
-                } else {
-                    Limited.put(Collections.unmodifiableSet(materials.stream().map(String::toUpperCase).map(loader.materialMapper).collect(Collectors.toSet())), amount);
-                }
+            List<BlockRule<M>> limited = new ArrayList<>();
+            Set<M> blocks = new HashSet<>();
+            for (YMLWrapper<M, ?> limitedLoader : loader.withAsList("Limited")) {
+                BlockRule<M> blockRule = new BlockRule<>(limitedLoader);
+                blocks.addAll(blockRule.Materials);
+                limited.add(blockRule);
            }
-            SQLWrapper.impl.getMaterialWithGreaterBlastResistance(MaxBlastResistance).forEach(material -> {
-                if (Limited.entrySet().stream().anyMatch(entry -> entry.getKey().contains(material))) return;
-                Limited.put(Collections.singleton((M) material), 0);
-            });
-            this.Limited = Collections.unmodifiableMap(Limited);
+            for (M material : (List<M>) SQLWrapper.impl.getMaterialWithGreaterBlastResistance(MaxBlastResistance)) {
+                if (material == null || !blocks.add(material)) continue;
+                limited.add(new BlockRule<>(material, 0));
+            }
+            for (M material : (Set<M>) SQLWrapper.impl.getInventoryMaterials()) {
+                if (material == null || !blocks.add(material)) continue;
+                limited.add(new BlockRule<>(material, Integer.MAX_VALUE));
+            }
+            this.Limited = Collections.unmodifiableList(limited);

            this.ReplacementsWithoutBlockUpdates = loader.getMap("ReplacementsWithoutBlockUpdates", loader.materialMapper, loader.materialMapper);
            this.ReplacementsWithBlockUpdates = loader.getMap("ReplacementsWithBlockUpdates", loader.materialMapper, loader.materialMapper);
        }

+        public int getMaxCount(M material) {
+            return Limited.stream()
+                    .filter(rule -> rule.Materials.contains(material))
+                    .mapToInt(rule -> rule.Amount)
+                    .max()
+                    .orElse(Integer.MAX_VALUE);
+        }
+
+        public boolean isInventory(M material) {
+            return Limited.stream()
+                    .filter(rule -> rule.Materials.contains(material))
+                    .anyMatch(rule -> rule.Content.loaded);
+        }
+
+        public Integer getItemAmount(M material, M item) {
+            return Limited.stream()
+                    .filter(rule -> rule.Materials.contains(material))
+                    .filter(rule -> rule.Content.Items.contains(item))
+                    .mapToInt(rule -> rule.Content.Amount)
+                    .max()
+                    .orElse(0);
+        }
+
+        @ToString
+        public static final class BlockRule<M> {
+
+            /**
+             * The block materials this rule applies to
+             */
+            public final Set<M> Materials;
+
+            /**
+             * Maximal amount of Blocks allowed in the schematic
+             *
+             * @implSpec {@code 0} by default
+             */
+            public final int Amount;
+
+            /**
+             * The item content filter for Blocks
+             *
+             * @implSpec no Items with {@code Amount 0} (denies any item) by default
+             */
+            public final Content<M> Content;
+
+            /**
+             * Resolves one {@code Materials} entry to the concrete materials it denotes: {@code storage}
+             * for {@link SQLWrapper#getStorageMaterials()}, {@code inventory} for
+             * {@link SQLWrapper#getInventoryMaterials()}, or the material itself otherwise.
+             */
+            private Set<M> expandInventoryGroup(YMLWrapper<M, ?> loader, String name) {
+                switch (name.toUpperCase()) {
+                    case "STORAGE":
+                        return (Set<M>) SQLWrapper.impl.getStorageMaterials();
+                    case "INVENTORY":
+                        return (Set<M>) SQLWrapper.impl.getInventoryMaterials();
+                    default:
+                        M material = loader.materialMapper.apply(name.toUpperCase());
+                        return material != null ? Collections.singleton(material) : Collections.emptySet();
+                }
+            }
+
+            private BlockRule(YMLWrapper<M, ?> loader) {
+                Set<M> blocks = loader.getStringList("Materials")
+                        .stream()
+                        .flatMap(value -> expandInventoryGroup(loader, value).stream())
+                        .collect(Collectors.toSet());
+                Materials = Collections.unmodifiableSet(blocks);
+                Amount = loader.getInt("Amount", 0);
+                Content = new Content<>(loader.with("Content"));
+            }
+
+            private BlockRule(M block, int amount) {
+                Materials = Collections.singleton(block);
+                Amount = amount;
+                Content = new Content<>();
+            }
+
+            @ToString
+            public static final class Content<M> {
+
+                public final boolean loaded;
+
+                /**
+                 * Items allowed by this rule
+                 */
+                public final Set<M> Items;
+
+                /**
+                 * Maximal amount of an allowed item per single block instance
+                 *
+                 * @implSpec {@code 0} by default
+                 */
+                public final int Amount;
+
+                private Content(YMLWrapper<M, ?> loader) {
+                    loaded = loader.canLoad();
+                    List<M> items = loader.getMaterialList("Items");
+                    Items = Collections.unmodifiableSet(new HashSet<>(items));
+                    Amount = loader.getInt("Amount", 0);
+                }
+
+                private Content() {
+                    loaded = false;
+                    Items = new HashSet<>();
+                    Amount = 0;
+                }
+            }
+        }
+
        @ToString
        public static final class SizeConfig {

@@ -183,14 +183,6 @@ class Punishment(id: EntityID<Int>) : IntEntity(id) {
            "UNNOFIGHTSERVER",
            UserPerm.MODERATION
        ),
-        NoTeamServer(
-            "NOTEAMSERVER_TEAM",
-            "NOTEAMSERVER_PERMA",
-            "NOTEAMSERVER_UNTIL",
-            "UNNOTEAMSERVER_ERROR",
-            "UNNOTEAMSERVER",
-            UserPerm.MODERATION
-        ),
        Note("NOTE_TEAM", null, null, null, null, UserPerm.PUNISHMENTS, true);

        fun isMulti() =
@@ -24,6 +24,7 @@ import de.steamwar.ImplementationProvider;
 import java.io.File;
 import java.util.Collections;
 import java.util.List;
+import java.util.Set;

 public interface SQLWrapper<M> {
    SQLWrapper<?> impl = ImplementationProvider.getImpl("de.steamwar.sql.SQLWrapperImpl");
@@ -36,5 +37,21 @@ public interface SQLWrapper<M> {
        return Collections.emptyList();
    }

+    /**
+     * Storage-type inventory materials (chests, barrels, shulker boxes of any color) - the
+     * {@code storage} group usable in {@code GameModeConfig}'s {@code Limited}.
+     */
+    default Set<M> getStorageMaterials() {
+        return Collections.emptySet();
+    }
+
+    /**
+     * Every inventory material - the {@code all} group usable in {@code GameModeConfig}'s
+     * {@code Limited}. Expected to be a superset of {@link #getStorageMaterials()}.
+     */
+    default Set<M> getInventoryMaterials() {
+        return Collections.emptySet();
+    }
+
    void additionalExceptionMetadata(StringBuilder builder);
 }
@@ -307,12 +307,12 @@ class SteamwarUser(id: EntityID<Int>) : IntEntity(id) {
            punishments[punishment] = Punishment.createPunishment(this@SteamwarUser.id.value, from, punishment, reason, time, perma)
        }

-    fun setLocale(locale: Locale?, manualeLocale: Boolean) {
+    fun setLocale(locale: Locale?, manualLocale: Boolean) {
        if (locale == null || (this.manualLocale && !manualLocale)) return

        useDb {
            this@SteamwarUser.locale = locale
-            this@SteamwarUser.manualLocale = manualeLocale
+            this@SteamwarUser.manualLocale = manualLocale
        }
    }

@@ -76,6 +76,25 @@ final class YMLWrapper<M, W> {
        return new YMLWrapper<>(false, Collections.emptyMap(), materialMapper, winconditionMapper);
    }

+    public List<YMLWrapper<M, W>> withAsList(String path) {
+        if (document.containsKey(path)) {
+            Object value = document.get(path);
+            if (value instanceof List) {
+                List<?> list = (List<?>) value;
+                List<Map> maps = list.stream()
+                        .filter(Map.class::isInstance)
+                        .map(Map.class::cast)
+                        .collect(Collectors.toList());
+                if (maps.size() == list.size()) {
+                    return (List) maps.stream()
+                            .map(map -> new YMLWrapper(true, map, materialMapper, winconditionMapper))
+                            .collect(Collectors.toList());
+                }
+            }
+        }
+        return Collections.emptyList();
+    }
+
    public <T> T get(String path, T defaultValue, Function<Object, T> mapper) {
        Object value = this.document.get(path);
        if (value == null) return defaultValue;
@@ -29,7 +29,6 @@ java {
 dependencies {
    compileOnly(libs.classindex)
    annotationProcessor(libs.classindex)
-    compileOnly(project(":GameCore", "default"))
    compileOnly(project(":SpigotCore", "default"))

    compileOnly(libs.netty)
@@ -107,15 +107,23 @@ Schematic:
  UnlimitedPrepare: false # defaults to false if missing
  # Maximal amount of blocks allowed in the schematic
  MaxBlocks: 0 # defaults to 0 (ignored) if missing
-  # Maximal amount of items per dispenser
-  MaxDispenserItems: 128 # defaults to 128 if missing
  # Maximal blast resistance for the design blocks
  MaxDesignBlastResistance: 100000000 # defaults to Double.MAX_VALUE if missing
-  # List of limited material (combinations)
-  # List contains tags Amount (integer) and Materials (List of material names in Spigot 1.12 AND Spigot 1.15 format)
+  # List of limited block materials
+  # InventoryMaterials are all disallowed by default to have any content but are unlimited in number
+  # Any Block that has more Blast Resistance than MaxBlastResistance will be defaulted to 0.
  Limited:
-    - Materials: [ ]
-      Amount: 0
+    - Blocks: [ DISPENSER ]
+      MaxCount: 64
+    - Blocks: [ DISPENSER ]
+      MaxCount: 16
+      Content:
+        Items: [ ARROW, FIRE_CHARGE ]
+        Amount: 128
+    - Blocks: [ storage ]
+      Content:
+        Items: [ TNT ]
+        Amount: 1728

 # The name of the game mode presented to the players
 GameName: WarGear # defaults to WarGear if missing
@@ -0,0 +1,57 @@
+/*
+ *   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> TestOrReferee = Collections.unmodifiableSet(EnumSet.of(TEST, CHECK, EVENT));
+
+    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,7 +22,6 @@ 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;
@@ -36,6 +35,7 @@ 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,6 +75,8 @@ 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;
@@ -85,12 +87,23 @@ 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 {
-        String configFile = GameConfig.ConfigFile;
+        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");
        if (!new File(FightSystem.getPlugin().getDataFolder(), configFile).exists()) {
            FightSystem.getPlugin().saveDefaultConfig();
            Bukkit.getLogger().log(Level.SEVERE, "Arenaconfig fehlt!");
@@ -196,7 +209,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 = GameConfig.EventKampfID;
+        int eventKampfID = Integer.parseInt(System.getProperty("fightID", "0"));
        if (eventKampfID >= 1) {
            EventKampf = EventFight.byId(eventKampfID);
            if (EventKampf == null) {
@@ -248,8 +261,43 @@ public class Config {
            Referees = Collections.emptySet();
            MaximumTeamMembers = Integer.MAX_VALUE;
            LiveReplay = false;
-            SpectatePort = -GameConfig.ReplayID;
+            SpectatePort = -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() {
@@ -21,8 +21,8 @@ package de.steamwar.fightsystem;

 import com.comphenix.tinyprotocol.TinyProtocol;
 import de.steamwar.core.Core;
-import de.steamwar.core.WorldEditRendererCUIEditor;
-import de.steamwar.fightsystem.commands.TechareaCommand;
+import de.steamwar.core.worldedit.SteamEdit;
+import de.steamwar.core.worldedit.WorldEditRendererCUIEditor;
 import de.steamwar.fightsystem.fight.Fight;
 import de.steamwar.fightsystem.fight.FightTeam;
 import de.steamwar.fightsystem.listener.ClickAnalyzer;
@@ -36,8 +36,6 @@ 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;
@@ -77,7 +75,7 @@ public class FightSystem extends JavaPlugin {
        }
        if (Config.SpectatePort != 0) {
            Core.setServerName("Spectate");
-        } else if (GameConfig.ReplayID != 0) {
+        } else if (Config.ReplayID != 0) {
            Core.setServerName("Replay");
        }

@@ -110,8 +108,8 @@ 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(GameConfig.mode));
+        new OneShotStateDependent(ArenaMode.Test, FightState.All, SteamEdit::init);
+        Config.world.setGameRule(GameRule.REDUCED_DEBUG_INFO, ArenaMode.AntiTest.contains(Config.mode));

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

        FileSource.startReplay();

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

            if (checkSchematicNode.isPrepared()) {
                Fight.getRedTeam().setSchem(checkSchematicNode, NodeData.getRevisions(checkSchematicNode) - 1);
            }
-
-            new TechareaCommand();
-        } else if (GameConfig.mode == ArenaMode.PREPARE) {
-            Fight.getUnrotated().setSchem(SchematicNode.getSchematicNode(GameConfig.PrepareSchemID));
+        } else if (Config.mode == ArenaMode.PREPARE) {
+            Fight.getUnrotated().setSchem(SchematicNode.getSchematicNode(Config.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.gamecore.ArenaMode;
+import de.steamwar.fightsystem.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.gamecore.ArenaMode;
-import de.steamwar.gamecore.GameConfig;
+import de.steamwar.fightsystem.ArenaMode;
+import de.steamwar.fightsystem.Config;
 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(GameConfig.mode))
+            new AIManager("DummyAI", DummyAI::new, Material.STONE, () -> ArenaMode.Test.contains(Config.mode))
    );

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

 import de.steamwar.core.Core;
-import de.steamwar.gamecore.ArenaMode;
+import de.steamwar.fightsystem.ArenaMode;
 import de.steamwar.fightsystem.FightSystem;
 import de.steamwar.fightsystem.fight.Kit;
 import de.steamwar.fightsystem.states.FightState;
-import de.steamwar.fightsystem.states.StateDependentCommand;
 import de.steamwar.linkage.Linked;
 import de.steamwar.sql.SteamwarUser;
 import de.steamwar.sql.UserPerm;
-import org.bukkit.command.Command;
-import org.bukkit.command.CommandExecutor;
-import org.bukkit.command.CommandSender;
 import org.bukkit.entity.Player;

@Linked
-public class AkCommand implements CommandExecutor {
+public class AkCommand extends FightSWCommand {

    public AkCommand() {
-        new StateDependentCommand(ArenaMode.Test, FightState.All, "ak", this);
+        super(ArenaMode.Test, FightState.All, "ak");
    }

    @Override
-    public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
-        if (!(sender instanceof Player)) {
-            return false;
-        }
-        Player player = (Player) sender;
-        if (!player.isOp()) return false;
+    protected boolean hasPerm(Player player, SteamwarUser user) {
+        return player.isOp() && user.hasPerm(UserPerm.ADMINISTRATION) && Core.getInstance() != FightSystem.getPlugin();
+    }

-        if (!SteamwarUser.get(player.getUniqueId()).hasPerm(UserPerm.ADMINISTRATION) && Core.getInstance() != FightSystem.getPlugin()) {
-            return false;
-        }
-
-        Kit.createKit(args[0], player);
-        return false;
+    @Register
+    public void run(@Validator Player player, String name) {
+        Kit.createKit(name, player);
    }
 }
@@ -0,0 +1,95 @@
+/*
+ *   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.fightsystem.commands;
+
+import de.steamwar.command.SWCommand;
+import de.steamwar.command.TypeValidator;
+import de.steamwar.fightsystem.ArenaMode;
+import de.steamwar.fightsystem.states.FightState;
+import de.steamwar.fightsystem.states.StateDependent;
+import de.steamwar.sql.SteamwarUser;
+import org.bukkit.Bukkit;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.player.PlayerCommandSendEvent;
+
+import java.util.Set;
+
+public abstract class FightSWCommand extends SWCommand implements Listener {
+
+    private final String command;
+    private final String[] aliases;
+
+    protected FightSWCommand(Set<ArenaMode> mode, Set<FightState> states, String command) {
+        super(command);
+        this.command = command;
+        this.aliases = new String[0];
+        stateDependant(mode, states);
+    }
+
+    protected FightSWCommand(Set<ArenaMode> mode, Set<FightState> states, String command, String... aliases) {
+        super(command, aliases);
+        this.command = command;
+        this.aliases = aliases;
+        stateDependant(mode, states);
+    }
+
+    private void stateDependant(Set<ArenaMode> mode, Set<FightState> states) {
+        FightSWCommand.this.unregister();
+        new StateDependent(mode, states) {
+            @Override
+            public void enable() {
+                System.out.println("--- Enable: " + command);
+                FightSWCommand.this.register();
+            }
+
+            @Override
+            public void disable() {
+                System.out.println("--- Disable: " + command);
+                FightSWCommand.this.unregister();
+            }
+        }.register();
+    }
+
+    public static void postFightStateChange() {
+        for (Player player : Bukkit.getOnlinePlayers()) {
+            player.updateCommands();
+        }
+    }
+
+    protected boolean hasPerm(Player player, SteamwarUser user) {
+        return true;
+    }
+
+    @EventHandler(ignoreCancelled = true)
+    public final void onPlayerCommandSend(PlayerCommandSendEvent event) {
+        if (hasPerm(event.getPlayer(), SteamwarUser.get(event.getPlayer().getUniqueId()))) return;
+        event.getCommands().remove(command);
+        for (String alias : aliases) {
+            event.getCommands().remove(alias);
+        }
+    }
+
+    @ClassValidator(value = Player.class, local = true)
+    public final TypeValidator<Player> permissionCheck() {
+        return (sender, value, messageSender) -> hasPerm(value, SteamwarUser.get(value.getUniqueId()));
+    }
+}
@@ -19,8 +19,7 @@

 package de.steamwar.fightsystem.commands;

-import de.steamwar.gamecore.ArenaMode;
-import de.steamwar.gamecore.GameConfig;
+import de.steamwar.fightsystem.ArenaMode;
 import de.steamwar.fightsystem.Config;
 import de.steamwar.fightsystem.FightSystem;
 import de.steamwar.fightsystem.ai.AIManager;
@@ -57,7 +56,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(GameConfig.mode) && team.canbeLeader(p)) {
+            if (ArenaMode.ManualTeams.contains(Config.mode) && team.canbeLeader(p)) {
                team.addMember(p);
            } else {
                JoinRequest.forPlayer(p, team);
@@ -199,7 +198,7 @@ public class GUI {
    }

    public static void preSchemDialog(Player p) {
-        if (!GameConfig.test() && FightState.getFightState() != FightState.PRE_SCHEM_SETUP) {
+        if (!Config.test() && FightState.getFightState() != FightState.PRE_SCHEM_SETUP) {
            msg.sendPrefixless("SCHEM_NO_ENEMY", p, ChatMessageType.ACTION_BAR);
            return;
        }
@@ -210,7 +209,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 (!GameConfig.test() && SteamwarUser.get(p.getUniqueId()).hasPerm(UserPerm.TEAM)) {
+        if (!Config.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 -> {
@@ -234,14 +233,14 @@ public class GUI {
            return;
        }

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

    private static void schemDialog(Player p, SchematicType type, boolean publicSchems, boolean unchecked) {
-        SchematicSelector selector = new SchematicSelector(p, GameConfig.test() ? SchematicSelector.selectSchematic() : SchematicSelector.selectSchematicType(unchecked ? type.checkType() : type), node -> {
+        SchematicSelector selector = new SchematicSelector(p, Config.test() ? SchematicSelector.selectSchematic() : SchematicSelector.selectSchematicType(unchecked ? type.checkType() : type), node -> {
            schemSelect(p, node);
        });
        selector.setPublicMode(publicSchems ? SchematicSelector.PublicMode.PUBLIC_ONLY : SchematicSelector.PublicMode.PRIVATE_ONLY);
@@ -264,7 +263,7 @@ public class GUI {
    private static void schemSelect(Player p, SchematicNode node) {
        FightTeam fightTeam = Fight.getPlayerTeam(p);
        if (fightTeam == null) return;
-        if (GameConfig.test() || FightState.getFightState() != FightState.POST_SCHEM_SETUP) {
+        if (Config.test() || FightState.getFightState() != FightState.POST_SCHEM_SETUP) {
            fightTeam.pasteSchem(node);
        }
        p.closeInventory();
@@ -19,93 +19,28 @@

 package de.steamwar.fightsystem.commands;

-import com.google.common.collect.ImmutableList;
+import de.steamwar.fightsystem.ArenaMode;
 import de.steamwar.fightsystem.Config;
-import de.steamwar.fightsystem.FightSystem;
-import de.steamwar.gamecore.GameConfig;
+import de.steamwar.fightsystem.states.FightState;
 import de.steamwar.linkage.Linked;
-import net.md_5.bungee.api.ChatMessageType;
-import org.bukkit.Bukkit;
+import de.steamwar.sql.SteamwarUser;
 import org.bukkit.GameMode;
-import org.bukkit.command.Command;
-import org.bukkit.command.CommandSender;
-import org.bukkit.command.defaults.BukkitCommand;
-import org.bukkit.craftbukkit.CraftServer;
 import org.bukkit.entity.Player;
-import org.bukkit.util.StringUtil;
-
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Map;

@Linked
-public class GamemodeCommand extends BukkitCommand {
-
-    private static final List<String> GAMEMODE_NAMES = ImmutableList.of("adventure", "creative", "survival",
-            "spectator");
+public class GamemodeCommand extends FightSWCommand {

    public GamemodeCommand() {
-        super("gamemode");
-        List<String> aliases = new ArrayList<>();
-        aliases.add("gm");
-        this.setAliases(aliases);
-
-        Map<String, Command> knownCommands = ((CraftServer) Bukkit.getServer()).getCommandMap().getKnownCommands();
-        knownCommands.remove("gamemode");
-        Commands.injectCommand(this);
+        super(ArenaMode.TestOrReferee, FightState.All, "gamemode", "gm");
    }

    @Override
-    public boolean execute(CommandSender sender, String currentAlias, String[] args) {
-        if (!(sender instanceof Player)) {
-            return false;
-        } else if (args.length == 0) {
-            FightSystem.getMessage().sendPrefixless("GAMEMODE_HELP", sender);
-            return false;
-        }
-
-        Player p = (Player) sender;
-
-        if (!(GameConfig.test() || Config.isReferee(p))) {
-            FightSystem.getMessage().sendPrefixless("GAMEMODE_NOT_ALLOWED", p, ChatMessageType.ACTION_BAR);
-            return false;
-        }
-
-        GameMode mode = createMode(args[0]);
-
-        if (mode == null) {
-            FightSystem.getMessage().sendPrefixless("GAMEMODE_UNKNOWN", p, ChatMessageType.ACTION_BAR, args[0]);
-            return false;
-        }
-
-        p.setGameMode(mode);
-        return true;
+    protected boolean hasPerm(Player player, SteamwarUser user) {
+        return Config.test() || Config.isReferee(player);
    }

-    @SuppressWarnings("deprecation")
-    private GameMode createMode(String modeArg) {
-        try {
-            return GameMode.getByValue(Integer.parseInt(modeArg));
-        } catch (NumberFormatException ignored) {
-            if ((modeArg.equalsIgnoreCase("creative")) || (modeArg.equalsIgnoreCase("c"))) {
-                return GameMode.CREATIVE;
-            } else if ((modeArg.equalsIgnoreCase("adventure")) || (modeArg.equalsIgnoreCase("a"))) {
-                return GameMode.ADVENTURE;
-            } else if ((modeArg.equalsIgnoreCase("spectator")) || (modeArg.equalsIgnoreCase("sp"))) {
-                return GameMode.SPECTATOR;
-            } else if ((modeArg.equalsIgnoreCase("survival")) || (modeArg.equalsIgnoreCase("s"))) {
-                return GameMode.SURVIVAL;
-            }
-        }
-        return null;
+    @Register(description = "GAMEMODE_HELP")
+    public void execute(@Validator Player player, GameMode gameMode) {
+        player.setGameMode(gameMode);
    }
-
-    @Override
-    public List<String> tabComplete(CommandSender sender, String alias, String[] args) {
-        if (args.length == 1) {
-            return StringUtil.copyPartialMatches(args[0], GAMEMODE_NAMES, new ArrayList<>(GAMEMODE_NAMES.size()));
-        }
-        return ImmutableList.of();
-    }
-
 }
@@ -19,35 +19,32 @@

 package de.steamwar.fightsystem.commands;

-import de.steamwar.gamecore.ArenaMode;
+import de.steamwar.fightsystem.ArenaMode;
+import de.steamwar.fightsystem.Config;
 import de.steamwar.fightsystem.FightSystem;
 import de.steamwar.fightsystem.fight.Fight;
 import de.steamwar.fightsystem.fight.FightTeam;
+import de.steamwar.fightsystem.listener.Check;
 import de.steamwar.fightsystem.states.FightState;
-import de.steamwar.fightsystem.states.StateDependentCommand;
 import de.steamwar.linkage.Linked;
 import de.steamwar.sql.SchematicNode;
 import de.steamwar.sql.SteamwarUser;
-import de.steamwar.sql.UserPerm;
-import org.bukkit.command.Command;
-import org.bukkit.command.CommandExecutor;
-import org.bukkit.command.CommandSender;
 import org.bukkit.entity.Player;

@Linked
-public class InfoCommand implements CommandExecutor {
+public class InfoCommand extends FightSWCommand {

    public InfoCommand() {
-        new StateDependentCommand(ArenaMode.All, FightState.All, "fightinfo", this);
+        super(ArenaMode.All, FightState.All, "fightinfo");
    }

    @Override
-    public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
-        if (!(sender instanceof Player)) return false;
-
-        Player player = (Player) sender;
-        if (!SteamwarUser.get(player.getUniqueId()).hasPerm(UserPerm.CHECK)) return false;
+    protected boolean hasPerm(Player player, SteamwarUser user) {
+        return Check.checkPermission(user, Config.GameModeConfig);
+    }

+    @Register
+    public void run(@Validator Player player) {
        for (FightTeam team : Fight.teams()) {
            if (!team.isLeaderless()) {
                FightSystem.getMessage().send("INFO_LEADER", player, team.getColoredName(), team.getLeader().getEntity().getName());
@@ -58,6 +55,5 @@ public class InfoCommand implements CommandExecutor {
                FightSystem.getMessage().send("INFO_SCHEMATIC", player, team.getColoredName(), schematic.getName(), SteamwarUser.byId(schematic.getOwner()).getUserName(), schematic.getRank());
            }
        }
-        return false;
    }
 }
@@ -19,34 +19,25 @@

 package de.steamwar.fightsystem.commands;

-import de.steamwar.gamecore.ArenaMode;
+import de.steamwar.fightsystem.ArenaMode;
 import de.steamwar.fightsystem.states.FightState;
-import de.steamwar.fightsystem.states.StateDependentCommand;
 import de.steamwar.linkage.Linked;
-import org.bukkit.command.Command;
-import org.bukkit.command.CommandExecutor;
-import org.bukkit.command.CommandSender;
 import org.bukkit.entity.Player;

@Linked
-public class KitCommand implements CommandExecutor {
+public class KitCommand extends FightSWCommand {

    public KitCommand() {
-        new StateDependentCommand(ArenaMode.AntiReplay, FightState.Setup, "kit", this);
+        super(ArenaMode.AntiReplay, FightState.Setup, "kit");
    }

-    @Override
-    public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
-        if (!(sender instanceof Player)) {
-            return false;
-        }
-        Player player = (Player) sender;
+    @Register
+    public void execute(Player player) {
+        GUI.kitSelection(player, "");
+    }

-        if (args.length != 1) {
-            GUI.kitSelection(player, "");
-        } else {
-            Commands.kit(player, args[0]);
-        }
-        return false;
+    @Register
+    public void execute(Player player, String query) { // TODO: TabCompletion of Kit Names!
+        GUI.kitSelection(player, query);
    }
 }
@@ -19,30 +19,20 @@

 package de.steamwar.fightsystem.commands;

-import de.steamwar.gamecore.ArenaMode;
+import de.steamwar.fightsystem.ArenaMode;
 import de.steamwar.fightsystem.states.FightState;
-import de.steamwar.fightsystem.states.StateDependentCommand;
 import de.steamwar.linkage.Linked;
-import org.bukkit.command.Command;
-import org.bukkit.command.CommandExecutor;
-import org.bukkit.command.CommandSender;
 import org.bukkit.entity.Player;

@Linked
-public class LeaveCommand implements CommandExecutor {
+public class LeaveCommand extends FightSWCommand {

    public LeaveCommand() {
-        new StateDependentCommand(ArenaMode.AntiReplay, FightState.Setup, "leave", this);
+        super(ArenaMode.AntiReplay, FightState.Setup, "leave");
    }

-    @Override
-    public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
-        if (!(sender instanceof Player)) {
-            return false;
-        }
-        Player player = (Player) sender;
-
+    @Register
+    public void execute(Player player) {
        Commands.leaveTeam(player);
-        return false;
    }
 }
@@ -19,53 +19,43 @@

 package de.steamwar.fightsystem.commands;

-import de.steamwar.gamecore.ArenaMode;
+import de.steamwar.fightsystem.ArenaMode;
+import de.steamwar.fightsystem.Config;
 import de.steamwar.fightsystem.FightSystem;
 import de.steamwar.fightsystem.fight.Fight;
 import de.steamwar.fightsystem.fight.FightTeam;
+import de.steamwar.fightsystem.listener.Check;
 import de.steamwar.fightsystem.states.FightState;
-import de.steamwar.fightsystem.states.StateDependentCommand;
 import de.steamwar.linkage.Linked;
 import de.steamwar.sql.SchematicNode;
 import de.steamwar.sql.SchematicType;
 import de.steamwar.sql.SteamwarUser;
-import de.steamwar.sql.UserPerm;
 import net.md_5.bungee.api.ChatMessageType;
-import org.bukkit.command.Command;
-import org.bukkit.command.CommandExecutor;
-import org.bukkit.command.CommandSender;
 import org.bukkit.entity.Player;

@Linked
-public class LockschemCommand implements CommandExecutor {
+public class LockschemCommand extends FightSWCommand {

    public LockschemCommand() {
-        new StateDependentCommand(ArenaMode.All, FightState.Schem, "lockschem", this);
+        super(ArenaMode.All, FightState.Schem, "lockschem");
    }

    @Override
-    public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
-        if (!(sender instanceof Player)) return false;
-        Player player = (Player) sender;
+    protected boolean hasPerm(Player player, SteamwarUser user) {
+        return Check.checkPermission(user, Config.GameModeConfig);
+    }

-        if (!SteamwarUser.get(player.getUniqueId()).hasPerm(UserPerm.CHECK)) return false;
-
-        if (args.length != 1) {
-            FightSystem.getMessage().sendPrefixless("LOCKSCHEM_HELP", player);
-            return false;
-        }
-
-        String teamName = args[0];
+    @Register(description = "LOCKSCHEM_HELP")
+    public void execute(@Validator Player player, String teamName) {
        FightTeam fightTeam = Fight.getTeamByName(teamName);

        if (fightTeam == null) {
            FightSystem.getMessage().sendPrefixless("UNKNOWN_TEAM", player, ChatMessageType.ACTION_BAR);
-            return false;
+            return;
        }

        SchematicNode.getSchematicNode(fightTeam.getSchematic()).setSchemtype(SchematicType.Normal);
        FightSystem.getMessage().sendPrefixless("LOCKSCHEM_LOCKED", player, ChatMessageType.ACTION_BAR);
        fightTeam.broadcastSystem("LOCKSCHEM_LOCKED_BY", player.getName());
-        return false;
    }
 }
@@ -19,30 +19,20 @@

 package de.steamwar.fightsystem.commands;

-import de.steamwar.gamecore.ArenaMode;
+import de.steamwar.fightsystem.ArenaMode;
 import de.steamwar.fightsystem.states.FightState;
-import de.steamwar.fightsystem.states.StateDependentCommand;
 import de.steamwar.linkage.Linked;
-import org.bukkit.command.Command;
-import org.bukkit.command.CommandExecutor;
-import org.bukkit.command.CommandSender;
 import org.bukkit.entity.Player;

@Linked
-public class ReadyCommand implements CommandExecutor {
+public class ReadyCommand extends FightSWCommand {

    public ReadyCommand() {
-        new StateDependentCommand(ArenaMode.AntiPrepare, FightState.PostSchemSetup, "ready", this);
+        super(ArenaMode.AntiPrepare, FightState.PostSchemSetup, "ready");
    }

-    @Override
-    public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
-        if (!(sender instanceof Player)) {
-            return false;
-        }
-        Player player = (Player) sender;
-
+    @Register
+    public void execute(Player player) {
        Commands.toggleReady(player);
-        return false;
    }
 }
@@ -19,36 +19,20 @@

 package de.steamwar.fightsystem.commands;

-import de.steamwar.gamecore.ArenaMode;
-import de.steamwar.fightsystem.FightSystem;
+import de.steamwar.fightsystem.ArenaMode;
 import de.steamwar.fightsystem.states.FightState;
-import de.steamwar.fightsystem.states.StateDependentCommand;
 import de.steamwar.linkage.Linked;
-import org.bukkit.command.Command;
-import org.bukkit.command.CommandExecutor;
-import org.bukkit.command.CommandSender;
 import org.bukkit.entity.Player;

@Linked
-public class RemoveCommand implements CommandExecutor {
+public class RemoveCommand extends FightSWCommand {

    public RemoveCommand() {
-        new StateDependentCommand(ArenaMode.VariableTeams, FightState.Setup, "remove", this);
+        super(ArenaMode.VariableTeams, FightState.Setup, "remove");
    }

-    @Override
-    public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
-        if (!(sender instanceof Player)) {
-            return false;
-        }
-        Player player = (Player) sender;
-
-        if (args.length != 1) {
-            FightSystem.getMessage().sendPrefixless("REMOVE_HELP", player);
-            return false;
-        }
-
-        Commands.kick(player, args[0]);
-        return false;
+    @Register(description = "REMOVE_HELP")
+    public void execute(Player player, Player teamMember) {
+        Commands.kick(player, teamMember.getName());
    }
 }
@@ -19,44 +19,35 @@

 package de.steamwar.fightsystem.commands;

-import de.steamwar.gamecore.ArenaMode;
+import de.steamwar.fightsystem.ArenaMode;
 import de.steamwar.fightsystem.FightSystem;
 import de.steamwar.fightsystem.fight.Fight;
 import de.steamwar.fightsystem.fight.FightPlayer;
 import de.steamwar.fightsystem.fight.FightTeam;
 import de.steamwar.fightsystem.fight.JoinRequest;
 import de.steamwar.fightsystem.states.FightState;
-import de.steamwar.fightsystem.states.StateDependentCommand;
 import de.steamwar.linkage.Linked;
-import org.bukkit.command.Command;
-import org.bukkit.command.CommandExecutor;
-import org.bukkit.command.CommandSender;
 import org.bukkit.entity.Player;

 import java.util.function.BiConsumer;

@Linked
-public class RequestsCommand implements CommandExecutor {
+public class RequestsCommand extends FightSWCommand {

    public RequestsCommand() {
-        new StateDependentCommand(ArenaMode.VariableTeams, FightState.AntiSpectate, "request", this);
-        new StateDependentCommand(ArenaMode.VariableTeams, FightState.AntiSpectate, "requests", this);
+        super(ArenaMode.VariableTeams, FightState.AntiSpectate, "request", "requests");
    }

-    @Override
-    public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
-        if (!(sender instanceof Player)) return false;
-        Player player = (Player) sender;
+    @Register
+    public void execute(Player player) {
        FightPlayer fp = Fight.getFightPlayer(player);
        if (fp == null || !(fp.isLeader() || fp.isLiving())) {
            GUI.joinRequest(player);
-            return false;
+            return;
        }

-        if (Commands.checkGetLeader(player) == null) return false;
-
+        if (Commands.checkGetLeader(player) == null) return;
        GUI.chooseJoinRequests(player);
-        return false;
    }

    public static void onJoinRequest(Player player, JoinRequest request, BiConsumer<JoinRequest, FightTeam> handleJoinRequest) {
@@ -19,37 +19,27 @@

 package de.steamwar.fightsystem.commands;

-import de.steamwar.gamecore.ArenaMode;
-import de.steamwar.gamecore.GameConfig;
+import de.steamwar.fightsystem.ArenaMode;
+import de.steamwar.fightsystem.Config;
 import de.steamwar.fightsystem.fight.Fight;
 import de.steamwar.fightsystem.record.PacketProcessor;
 import de.steamwar.fightsystem.states.FightState;
-import de.steamwar.fightsystem.states.StateDependentCommand;
 import de.steamwar.linkage.Linked;
-import org.bukkit.command.Command;
-import org.bukkit.command.CommandExecutor;
-import org.bukkit.command.CommandSender;
 import org.bukkit.entity.Player;

@Linked
-public class SkipCommand implements CommandExecutor {
+public class SkipCommand extends FightSWCommand {

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

-    @Override
-    public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
-        if (!(sender instanceof Player)) {
-            return false;
-        }
-        Player player = (Player) sender;
-
+    @Register
+    public void execute(Player player) {
        if (PacketProcessor.isReplaying() && player.getUniqueId().equals(Fight.getBlueTeam().getDesignatedLeader())) {
            PacketProcessor.currentReplay().skipToSubtitle();
        } else {
            Commands.toggleSkip(player);
        }
-        return false;
    }
 }
@@ -19,29 +19,20 @@

 package de.steamwar.fightsystem.commands;

-import de.steamwar.gamecore.ArenaMode;
+import de.steamwar.fightsystem.ArenaMode;
 import de.steamwar.fightsystem.states.FightState;
-import de.steamwar.fightsystem.states.StateDependentCommand;
 import de.steamwar.linkage.Linked;
-import org.bukkit.command.Command;
-import org.bukkit.command.CommandExecutor;
-import org.bukkit.command.CommandSender;
 import org.bukkit.entity.Player;

@Linked
-public class StateCommand implements CommandExecutor {
+public class StateCommand extends FightSWCommand {

    public StateCommand() {
-        new StateDependentCommand(ArenaMode.Test, FightState.All, "state", this);
+        super(ArenaMode.Test, FightState.All, "state");
    }

-    @Override
-    public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
-        if (!(sender instanceof Player)) {
-            return false;
-        }
-
-        GUI.state((Player) sender);
-        return false;
+    @Register
+    public void execute(Player player) {
+        GUI.state(player);
    }
 }
@@ -19,29 +19,21 @@

 package de.steamwar.fightsystem.commands;

-import de.steamwar.gamecore.ArenaMode;
+import de.steamwar.fightsystem.ArenaMode;
 import de.steamwar.fightsystem.fight.Fight;
 import de.steamwar.fightsystem.states.FightState;
-import de.steamwar.fightsystem.states.StateDependentCommand;
 import de.steamwar.linkage.Linked;
-import org.bukkit.command.Command;
-import org.bukkit.command.CommandExecutor;
-import org.bukkit.command.CommandSender;
 import org.bukkit.entity.Player;

@Linked
-public class TBCommand implements CommandExecutor {
+public class TBCommand extends FightSWCommand {

    public TBCommand() {
-        new StateDependentCommand(ArenaMode.Check, FightState.All, "resettb", this);
+        super(ArenaMode.Check, FightState.All, "resettb");
    }

-    @Override
-    public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
-        if (!(sender instanceof Player)) {
-            return false;
-        }
+    @Register
+    public void execute(Player player) {
        Fight.getRedTeam().pasteSchem();
-        return false;
    }
 }
@@ -17,37 +17,23 @@

 package de.steamwar.fightsystem.commands;

-import de.steamwar.gamecore.ArenaMode;
+import de.steamwar.fightsystem.ArenaMode;
 import de.steamwar.fightsystem.FightSystem;
 import de.steamwar.fightsystem.states.FightState;
-import de.steamwar.fightsystem.states.StateDependentCommand;
 import de.steamwar.linkage.Linked;
 import net.minecraft.server.MinecraftServer;
-import org.bukkit.command.Command;
-import org.bukkit.command.CommandExecutor;
-import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;

@Linked
-public class TPSWarpCommand implements CommandExecutor {
+public class TPSWarpCommand extends FightSWCommand {

    public TPSWarpCommand() {
-        new StateDependentCommand(ArenaMode.Prepare, FightState.PostSchemSetup, "tpswarp", this);
-        new StateDependentCommand(ArenaMode.Prepare, FightState.PostSchemSetup, "tpslimit", this);
+        super(ArenaMode.Prepare, FightState.PostSchemSetup, "tpswarp", "tpslimit");
    }

-    @Override
-    public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
-        float tps;
-        try {
-            tps = Float.parseFloat(args[0]);
-        } catch (NumberFormatException | ArrayIndexOutOfBoundsException e) {
-            FightSystem.getMessage().send("TPSWARP_HELP", sender);
-            return false;
-        }
-
+    @Register(description = "TPSWARP_HELP")
+    public void execute(Player player, float tps) {
        MinecraftServer.getServer().tickRateManager().setTickRate(tps);
-
        FightSystem.getMessage().broadcastActionbar("TPSWARP_SET", tps);
-        return false;
    }
 }
@@ -19,42 +19,39 @@

 package de.steamwar.fightsystem.commands;

-import de.steamwar.command.SWCommand;
 import de.steamwar.entity.CWireframe;
 import de.steamwar.entity.REntityServer;
+import de.steamwar.fightsystem.ArenaMode;
 import de.steamwar.fightsystem.Config;
-import de.steamwar.fightsystem.FightSystem;
-import org.bukkit.Bukkit;
+import de.steamwar.fightsystem.states.FightState;
+import de.steamwar.fightsystem.states.OneShotStateDependent;
+import de.steamwar.linkage.Linked;
 import org.bukkit.Material;
 import org.bukkit.entity.Player;

-import java.util.HashMap;
-import java.util.Map;
-import java.util.UUID;
-
-public class TechareaCommand extends SWCommand {
-    private final Map<UUID, REntityServer> servers = new HashMap<>();
+@Linked
+public class TechareaCommand extends FightSWCommand {
+    private REntityServer entityServer = new REntityServer();

    public TechareaCommand() {
-        super("techarea");
-
-        Bukkit.getScheduler().runTaskTimer(FightSystem.getPlugin(), () -> servers.forEach((uuid, rEntityServer) -> rEntityServer.tick()), 2, 2);
-    }
-
-    @Register
-    public void genericCommand(Player player) {
-        if (servers.containsKey(player.getUniqueId())) {
-            servers.get(player.getUniqueId()).close();
-        } else {
+        super(ArenaMode.Check, FightState.All, "techarea");
+        new OneShotStateDependent(ArenaMode.Check, FightState.All, () -> {
+            if (!entityServer.getEntities().isEmpty()) return;
            REntityServer server = new REntityServer();
            CWireframe wireframe = new CWireframe(server);

            wireframe.setPos1(Config.BlueInsetRegion.getMinLocation(Config.world));
            wireframe.setPos2(Config.BlueInsetRegion.getMaxLocation(Config.world).subtract(1, 1, 1));
            wireframe.setBlock(Material.RED_CONCRETE.createBlockData());
+        });
+    }

-            server.addPlayer(player);
-            servers.put(player.getUniqueId(), server);
+    @Register
+    public void genericCommand(Player player) {
+        if (entityServer.getPlayers().contains(player)) {
+            entityServer.removePlayer(player);
+        } else {
+            entityServer.addPlayer(player);
        }
    }
 }
@@ -20,37 +20,33 @@
 package de.steamwar.fightsystem.commands;

 import com.comphenix.tinyprotocol.TinyProtocol;
-import de.steamwar.gamecore.ArenaMode;
-import de.steamwar.gamecore.GameConfig;
+import de.steamwar.fightsystem.ArenaMode;
 import de.steamwar.fightsystem.Config;
 import de.steamwar.fightsystem.FightSystem;
 import de.steamwar.fightsystem.fight.Fight;
 import de.steamwar.fightsystem.states.FightState;
-import de.steamwar.fightsystem.states.StateDependentCommand;
 import de.steamwar.linkage.Linked;
 import de.steamwar.sql.SWException;
 import org.bukkit.Bukkit;
-import org.bukkit.command.Command;
-import org.bukkit.command.CommandExecutor;
-import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;

 import java.io.StringWriter;
 import java.util.Arrays;
 import java.util.logging.Level;

@Linked
-public class TechhiderbugCommand implements CommandExecutor {
+public class TechhiderbugCommand extends FightSWCommand {

    public TechhiderbugCommand() {
-        new StateDependentCommand(ArenaMode.All, FightState.All, "techhiderbug", this);
+        super(ArenaMode.All, FightState.All, "techhiderbug");
    }

-    @Override
-    public boolean onCommand(CommandSender sender, Command cmd, String alias, String[] args) {
+    @Register
+    public void execute(Player player, String... args) {
        StringWriter writer = new StringWriter();

        try {
-            writer.append("ArenaMode: ").append(GameConfig.mode.name()).append('\n');
+            writer.append("ArenaMode: ").append(Config.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');

@@ -77,7 +73,6 @@ public class TechhiderbugCommand implements CommandExecutor {
            Bukkit.getLogger().log(Level.SEVERE, "Error while generating bug report", e);
        }

-        SWException.log("Techhider-Bug reported by " + sender.getName() + ": " + Arrays.toString(args), writer.toString());
-        return false;
+        SWException.log("Techhider-Bug reported by " + player.getName() + ": " + Arrays.toString(args), writer.toString());
    }
 }
@@ -19,32 +19,24 @@

 package de.steamwar.fightsystem.commands;

-import de.steamwar.gamecore.ArenaMode;
+import de.steamwar.fightsystem.ArenaMode;
 import de.steamwar.fightsystem.fight.Fight;
 import de.steamwar.fightsystem.fight.FightWorld;
 import de.steamwar.fightsystem.states.FightState;
-import de.steamwar.fightsystem.states.StateDependentCommand;
 import de.steamwar.linkage.Linked;
-import org.bukkit.command.Command;
-import org.bukkit.command.CommandExecutor;
-import org.bukkit.command.CommandSender;
 import org.bukkit.entity.Player;

@Linked
-public class WGCommand implements CommandExecutor {
+public class WGCommand extends FightSWCommand {

    public WGCommand() {
-        new StateDependentCommand(ArenaMode.Check, FightState.All, "resetwg", this);
+        super(ArenaMode.Check, FightState.All, "resetwg");
    }

-    @Override
-    public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
-        if (!(sender instanceof Player)) {
-            return false;
-        }
+    @Register
+    public void execute(Player player) {
        FightWorld.resetWorld();
        Fight.getBlueTeam().pasteSchem();
        Fight.getRedTeam().pasteSchem();
-        return false;
    }
 }
@@ -19,55 +19,40 @@

 package de.steamwar.fightsystem.commands;

-import de.steamwar.gamecore.ArenaMode;
+import de.steamwar.fightsystem.ArenaMode;
 import de.steamwar.fightsystem.Config;
 import de.steamwar.fightsystem.FightSystem;
 import de.steamwar.fightsystem.fight.Fight;
 import de.steamwar.fightsystem.fight.FightTeam;
 import de.steamwar.fightsystem.states.FightState;
-import de.steamwar.fightsystem.states.StateDependentCommand;
 import de.steamwar.linkage.Linked;
-import net.md_5.bungee.api.ChatMessageType;
-import org.bukkit.command.Command;
-import org.bukkit.command.CommandExecutor;
-import org.bukkit.command.CommandSender;
+import de.steamwar.sql.SteamwarUser;
 import org.bukkit.entity.Player;

@Linked
-public class WinCommand implements CommandExecutor {
+public class WinCommand extends FightSWCommand {

    public WinCommand() {
-        new StateDependentCommand(ArenaMode.Event, FightState.Ingame, "win", this);
+        super(ArenaMode.Event, FightState.Ingame, "win");
    }

    @Override
-    public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
-        if (!(sender instanceof Player)) {
-            return false;
-        }
-        Player p = (Player) sender;
+    protected boolean hasPerm(Player player, SteamwarUser user) {
+        return Config.isReferee(player);
+    }

-        if (!Config.isReferee(p)) {
-            FightSystem.getMessage().sendPrefixless("NOT_FIGHTLEADER", p, ChatMessageType.ACTION_BAR);
-            return false;
-        }
-
-        if (args.length == 0) {
-            FightSystem.getMessage().sendPrefixless("WIN_HELP", p);
-            return false;
-        }
-
-        if (args[0].equalsIgnoreCase("tie")) {
+    @Register
+    public void execute(@Validator Player player, String teamName) {
+        if (teamName.equalsIgnoreCase("tie")) {
            FightSystem.setSpectateState(null, "Referee", "WIN_FIGHTLEADER");
-            return false;
+            return;
        }

        for (FightTeam team : Fight.teams()) {
-            if (args[0].equalsIgnoreCase(team.getName())) {
+            if (teamName.equalsIgnoreCase(team.getName())) {
                FightSystem.setSpectateState(team, "Referee", "WIN_FIGHTLEADER");
-                return false;
+                return;
            }
        }
-        return false;
    }
 }
@@ -0,0 +1,151 @@
+/*
+ *   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,12 +27,10 @@ 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.gamecore.countdown.Countdown;
-import de.steamwar.gamecore.countdown.StandardCountdown;
 import net.md_5.bungee.api.ChatMessageType;
 import org.bukkit.Bukkit;

-public class EnternCountdown extends StandardCountdown {
+public class EnternCountdown extends Countdown {

    private static int calcTime(FightPlayer fp, Countdown countdown) {
        int time = Config.GameModeConfig.EnterStages.get(fp.getKit().getEnterStage());
@@ -48,17 +46,13 @@ public class EnternCountdown extends StandardCountdown {
    private final FightPlayer fightPlayer;

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

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

+    @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,27 +19,25 @@

 package de.steamwar.fightsystem.countdown;

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

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

    public EventSpectateCountdown() {
-        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);
+        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);
    }

    @Override
-    protected void countdownFinished() {
+    public void countdownFinished() {
        FightSystem.shutdown();
    }
 }
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
YoyoNow	2b42f0d13c	Remove YAPION from BauSystem_Main module Deploy / Build (push) Successful in 40m13s Details Deploy / Deploy (push) Successful in 5m54s Details	2026-09-29 14:26:57 +02:00
YoyoNow	4306fe7bc9	Merge pull request 'Fix SteamwarUser.setLocale' (#489 ) from Hut512/SteamWar:fix/setlocale-typo into main Deploy / Build (push) Successful in 18m57s Details Deploy / Deploy (push) Successful in 26s Details Reviewed-on: #489 Reviewed-by: YoyoNow <4+yoyonow@noreply.localhost>	2026-09-14 12:18:40 +02:00
YoyoNow	58df6087f0	Merge pull request 'Fix NoClip' (#491 ) from Hut512/SteamWar:fix/swplayer-invalid-reference into main Deploy / Build (push) Successful in 19m39s Details Deploy / Deploy (push) Successful in 32s Details Reviewed-on: #491 Reviewed-by: YoyoNow <4+yoyonow@noreply.localhost>	2026-09-14 12:18:16 +02:00
YoyoNow	b9b7869124	Merge pull request 'Fix region water level' (#494 ) from Hut512/SteamWar:fix/testblock-water-level into main Deploy / Build (push) Successful in 19m18s Details Deploy / Deploy (push) Successful in 24s Details Reviewed-on: #494	2026-09-14 12:17:30 +02:00
YoyoNow	1e85b14667	Improve SteamEditWand Deploy / Build (push) Successful in 12m55s Details Deploy / Deploy (push) Successful in 23s Details	2026-09-14 10:02:39 +02:00
Hut512	35c27923aa	Fix region water level Pull Request Build / Build (pull_request) Failing after 4m56s Details Backport CommonCore / Create CommonCore backport PRs (pull_request) Successful in 10s Details	2026-09-12 20:07:07 +02:00
Hut512	c3b3e3e60f	Fix NoClip instant block break Pull Request Build / Build (pull_request) Successful in 1m25s Details Backport CommonCore / Create CommonCore backport PRs (pull_request) Successful in 9s Details	2026-09-07 22:21:53 +02:00
Hut512	3aa1bf7ffd	Fix scoreboard cleanup	2026-09-07 21:15:01 +02:00
Hut512	5a02a58437	Fix SteamwarUser.setLocale Pull Request Build / Build (pull_request) Successful in 1m25s Details Backport CommonCore / Create CommonCore backport PRs (pull_request) Successful in 9s Details	2026-09-07 15:24:32 +02:00
YoyoNow	6209b86149	Fix TeamCommand.info Deploy / Build (push) Successful in 2m25s Details Deploy / Deploy (push) Successful in 11s Details	2026-09-07 14:03:06 +02:00
YoyoNow	6f1403df9c	Cleanup SWPlayer Deploy / Build (push) Successful in 2m29s Details Deploy / Deploy (push) Successful in 14s Details	2026-09-05 14:52:59 +02:00
YoyoNow	0113788da2	Fix SteamEditWand Deploy / Build (push) Successful in 2m25s Details Deploy / Deploy (push) Successful in 11s Details	2026-09-05 09:50:47 +02:00
YoyoNow	8a7f65e000	Merge pull request 'Fix CRIU subserver stop' (#485 ) from Hut512/SteamWar:main into main Deploy / Build (push) Successful in 2m27s Details Deploy / Deploy (push) Successful in 13s Details Reviewed-on: #485 Reviewed-by: YoyoNow <4+yoyonow@noreply.localhost>	2026-09-03 21:39:15 +02:00
Hut512	8401f67b24	Fix CRIU subserver stop Pull Request Build / Build (pull_request) Successful in 1m30s Details Backport CommonCore / Create CommonCore backport PRs (pull_request) Successful in 9s Details	2026-09-03 02:24:49 +02:00
YoyoNow	362468e756	Fix SteamEditWand Deploy / Build (push) Successful in 2m22s Details Deploy / Deploy (push) Successful in 12s Details	2026-09-01 11:14:30 +02:00
YoyoNow	ece12df0bc	Add SteamEdit Deploy / Build (push) Successful in 41m8s Details Deploy / Deploy (push) Successful in 10s Details	2026-09-01 10:32:56 +02:00
YoyoNow	f35c07ab5b	Fix EventStarter Deploy / Build (push) Successful in 2m28s Details Deploy / Deploy (push) Successful in 10s Details	2026-08-30 16:12:32 +02:00
YoyoNow	549f7e555c	Remove NoTeamServer punishment Deploy / Build (push) Successful in 2m30s Details Deploy / Deploy (push) Successful in 11s Details	2026-08-30 13:04:52 +02:00
YoyoNow	859238d7fa	Disable 'showtable' in EventCommand Deploy / Build (push) Successful in 2m31s Details Deploy / Deploy (push) Successful in 13s Details	2026-08-30 12:25:34 +02:00
YoyoNow	a79b00f78f	Fix EventCommand Deploy / Build (push) Successful in 2m21s Details Deploy / Deploy (push) Successful in 18s Details	2026-08-30 12:23:23 +02:00
YoyoNow	105eda32e6	Update CustomMap Deploy / Build (push) Successful in 2m22s Details Deploy / Deploy (push) Successful in 10s Details	2026-08-30 12:15:22 +02:00
YoyoNow	b4487b8079	Update doc comment Deploy / Build (push) Successful in 2m35s Details Deploy / Deploy (push) Successful in 11s Details	2026-08-30 12:00:40 +02:00
YoyoNow	ea3aad3bd2	Initial FightSWCommand Deploy / Build (push) Successful in 2m29s Details Deploy / Deploy (push) Successful in 11s Details	2026-08-29 12:52:09 +02:00
YoyoNow	d307f890e2	Remove debug output Deploy / Build (push) Successful in 2m22s Details Deploy / Deploy (push) Successful in 12s Details	2026-08-26 22:35:39 +02:00
YoyoNow	97c1da1b2a	Add debug output Deploy / Build (push) Successful in 2m18s Details Deploy / Deploy (push) Successful in 11s Details	2026-08-26 22:31:30 +02:00
YoyoNow	8a53aecfac	Add debug output Deploy / Build (push) Successful in 2m19s Details Deploy / Deploy (push) Successful in 13s Details	2026-08-26 22:26:43 +02:00
YoyoNow	5236afba17	Add debug output Deploy / Build (push) Successful in 2m18s Details Deploy / Deploy (push) Successful in 12s Details	2026-08-26 22:17:33 +02:00
YoyoNow	d3c8b6e1c6	Add debug output Deploy / Build (push) Successful in 2m21s Details Deploy / Deploy (push) Successful in 11s Details	2026-08-26 22:12:53 +02:00
YoyoNow	00ea792eee	Merge pull request 'Improve AutoChecker and GameModeConfig again' (#478 ) from AutoChecker into main Deploy / Build (push) Successful in 2m25s Details Deploy / Deploy (push) Successful in 12s Details Reviewed-on: #478	2026-08-26 22:05:31 +02:00
YoyoNow	38e845b0e4	Improve AutoChecker and GameModeConfig again Pull Request Build / Build (pull_request) Successful in 1m33s Details Backport CommonCore / Create CommonCore backport PRs (pull_request) Successful in 7s Details	2026-08-26 21:46:45 +02:00
YoyoNow	c60a8caed8	Merge pull request 'Improve items for GameModeConfig' (#476 ) from AutoChecker into main Deploy / Build (push) Successful in 2m38s Details Deploy / Deploy (push) Successful in 12s Details Reviewed-on: #476 Reviewed-by: sakziea <59+sakziea@noreply.localhost>	2026-08-25 17:07:11 +02:00
YoyoNow	2e390286b2	Merge pull request 'VelocityCore - Server Links' (#477 ) from VelocityCore/ServerLinks into main Deploy / Build (push) Successful in 2m30s Details Deploy / Deploy (push) Successful in 10s Details Reviewed-on: #477 Reviewed-by: sakziea <59+sakziea@noreply.localhost>	2026-08-25 16:57:04 +02:00
YoyoNow	6476125a3f	Add ServerLinks to login Pull Request Build / Build (pull_request) Successful in 1m31s Details Backport CommonCore / Create CommonCore backport PRs (pull_request) Successful in 13s Details	2026-08-24 20:22:48 +02:00
YoyoNow	311437d451	Add ServerLinks to login	2026-08-24 20:22:02 +02:00
YoyoNow	5a52771ec1	Improve items for GameModeConfig Pull Request Build / Build (pull_request) Successful in 1m38s Details Backport CommonCore / Create CommonCore backport PRs (pull_request) Successful in 9s Details	2026-08-24 20:05:58 +02:00
YoyoNow	72b70a62e1	Fix CustomItem Deploy / Build (push) Successful in 2m16s Details Deploy / Deploy (push) Successful in 11s Details	2026-08-19 12:05:09 +02:00
YoyoNow	8575dcac33	Add WindCharge option to LaunchScript Deploy / Build (push) Successful in 2m17s Details Deploy / Deploy (push) Successful in 11s Details	2026-08-19 11:06:34 +02:00
YoyoNow	cb744f6aa0	Add AntiPlayerCollision Deploy / Build (push) Successful in 2m17s Details Deploy / Deploy (push) Successful in 11s Details	2026-08-18 10:48:16 +02:00
YoyoNow	227f63c9ff	Add AntiPlayerCollision Deploy / Build (push) Successful in 2m24s Details Deploy / Deploy (push) Successful in 11s Details	2026-08-18 10:39:58 +02:00
YoyoNow	397b10c319	Merge pull request 'Velocity core /event command' (#465 ) from VelocityCore/EventCommand into main Deploy / Build (push) Successful in 2m12s Details Deploy / Deploy (push) Successful in 10s Details Reviewed-on: #465 Reviewed-by: YoyoNow <4+yoyonow@noreply.localhost>	2026-08-14 07:53:43 +02:00
YoyoNow	32569f19d9	Closes: #468 Deploy / Build (push) Successful in 2m15s Details Deploy / Deploy (push) Successful in 11s Details	2026-08-13 10:09:13 +02:00
YoyoNow	f19e4158e7	Fix Check Deploy / Build (push) Successful in 2m19s Details Deploy / Deploy (push) Successful in 13s Details	2026-08-13 10:01:55 +02:00
YoyoNow	6c46b5b2a2	Fix Check Deploy / Build (push) Successful in 2m20s Details Deploy / Deploy (push) Successful in 11s Details	2026-08-13 09:51:56 +02:00
YoyoNow	58516448d9	Merge pull request 'Add deletion of PlayerData on /bau delmember' (#454 ) from VelocityCore/DeleteMemberOfBauDeletingPlayerData into main Deploy / Build (push) Successful in 2m17s Details Deploy / Deploy (push) Successful in 11s Details Reviewed-on: #454 Reviewed-by: Chaoscaot <max@chaoscaot.de>	2026-08-13 09:50:14 +02:00
YoyoNow	683236bb59	Fix TexturePackSystem for newer versions Deploy / Build (push) Successful in 2m11s Details Deploy / Deploy (push) Successful in 10s Details	2026-08-13 09:39:42 +02:00
YoyoNow	8dc101639d	Add alias of `/tick rate` to `/tick rate 20` Deploy / Build (push) Successful in 2m23s Details Deploy / Deploy (push) Successful in 15s Details	2026-08-11 21:48:28 +02:00
YoyoNow	792620804a	Improve TPSSystem Deploy / Build (push) Successful in 2m26s Details Deploy / Deploy (push) Successful in 11s Details	2026-08-11 21:46:38 +02:00
YoyoNow	4aa7c99a6e	Fix Check and CheckCommand permission Deploy / Build (push) Successful in 3m30s Details Deploy / Deploy (push) Successful in 11s Details	2026-08-11 21:05:36 +02:00
Sakziea	cce18124f2	Remove unused translation Pull Request Build / Build (pull_request) Successful in 3m33s Details Backport CommonCore / Create CommonCore backport PRs (pull_request) Failing after 8s Details	2026-08-05 20:30:36 +02:00
Sakziea	18ad0ad90c	Add Clickevents to EventPage	2026-08-05 20:30:28 +02:00
Sakziea	a58de898bb	Add Clickevents to EventPage	2026-08-05 20:30:25 +02:00
Sakziea	507b7c2569	Add event showtable	2026-08-05 20:30:20 +02:00
Sakziea	a18098b8f4	Fix Pull request comments	2026-08-05 20:30:15 +02:00
Sakziea	97773f292d	Remove unused import	2026-08-05 20:30:09 +02:00
Sakziea	5fdfc03587	Fix /event [Team] move to /event team [Team]	2026-08-05 20:30:00 +02:00
Sakziea	493e66cc98	Add current event uses eventpage	2026-08-05 20:29:37 +02:00
Sakziea	2be3a136ae	Add funktion to show next events and formatet the fights in pages	2026-08-05 20:29:28 +02:00
Sakziea	c62a566447	Fix pull Request comment	2026-08-05 20:29:18 +02:00
Sakziea	0684765a76	Remove unused imports	2026-08-05 20:29:09 +02:00
Sakziea	c40f29c3c1	Add Wind charge config	2026-08-05 20:28:53 +02:00
Sakziea	72dc4eee9e	Fix Wind charges cross middle and interact with Blocks	2026-08-05 20:28:24 +02:00
Sakziea	c7a949322e	Fix Windcharge remove Water	2026-08-05 20:27:39 +02:00
Chaoscaot	9d5b7893f1	Merge pull request 'Replace Custom Observer with kotlinx StateFlows' (#444 ) from swui/flows into main Deploy / Build (push) Successful in 2m47s Details Deploy / Deploy (push) Successful in 11s Details Reviewed-on: #444 Reviewed-by: YoyoNow <4+yoyonow@noreply.localhost>	2026-07-26 10:22:42 +02:00
Chaoscaot	ae898e14c2	Merge branch 'main' into swui/flows Pull Request Build / Build (pull_request) Successful in 1m56s Details Backport CommonCore / Create CommonCore backport PRs (pull_request) Successful in 8s Details	2026-07-26 10:20:35 +02:00
Chaoscaot	726f73cc45	Merge branch 'main' into VelocityCore/DeleteMemberOfBauDeletingPlayerData Pull Request Build / Build (pull_request) Successful in 1m32s Details Backport CommonCore / Create CommonCore backport PRs (pull_request) Successful in 9s Details	2026-07-26 03:04:45 +02:00
YoyoNow	64e627514d	Add deletion of PlayerData on /bau delmember Pull Request Build / Build (pull_request) Successful in 1m29s Details	2026-07-17 09:47:40 +02:00
Chaoscaot	3a247de43d	Replace Custom Observer with kotlinx StateFlows Pull Request Build / Build (pull_request) Successful in 1m50s Details Signed-off-by: Chaoscaot <max@maxsp.de>	2026-07-06 01:13:05 +02:00