merge upstream

Fix SteamwarUser.setLocale
Merge pull request 'Fix CRIU subserver stop' (#485 ) from Hut512/SteamWar:main into main
2026-09-04 19:47:27 +02:00 · 2026-09-04 19:45:42 +02:00 · 2026-09-03 21:39:15 +02:00 · 2026-09-03 02:24:49 +02:00 · 2026-09-01 11:14:30 +02:00 · 2026-09-01 10:32:56 +02:00
192 changed files with 2865 additions and 2746 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>
@@ -32,6 +32,7 @@ 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;
@@ -40,8 +41,9 @@ 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 +51,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;
@@ -129,7 +132,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);

@@ -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);
@@ -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();
        }
    }
@@ -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());
+    }
+}
@@ -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();
    }
 }
@@ -1,91 +0,0 @@
-/*
- *   This file is a part of the SteamWar software.
- *
- *   Copyright (C) 2026 SteamWar.de-Serverteam
- *
- *   This program is free software: you can redistribute it and/or modify
- *   it under the terms of the GNU Affero General Public License as published by
- *   the Free Software Foundation, either version 3 of the License, or
- *   (at your option) any later version.
- */
-
-package de.steamwar.fightsystem.countdown;
-
-import de.steamwar.fightsystem.FightSystem;
-import de.steamwar.fightsystem.fight.Fight;
-import de.steamwar.fightsystem.fight.FightPlayer;
-import de.steamwar.fightsystem.record.GlobalRecorder;
-import de.steamwar.fightsystem.utils.Message;
-import de.steamwar.fightsystem.utils.SWSound;
-import de.steamwar.gamecore.countdown.CountdownMessageSink;
-import de.steamwar.gamecore.countdown.CountdownPresentation;
-import net.md_5.bungee.api.ChatMessageType;
-import org.bukkit.Bukkit;
-import org.bukkit.entity.Player;
-
-/**
- * Binds FightSystem's transports to GameCore's presentation engine.
- */
-public final class FightCountdownAdapter {
-    private FightCountdownAdapter() {
-    }
-
-    public static CountdownPresentation presentation(Message appendix, SWSound sound, boolean level) {
-        return presentation(
-                appendix,
-                sound,
-                level,
-                (message, displayTime) -> {
-                    GlobalRecorder.getInstance().countdown(message.getKey(), displayTime, appendix);
-                    Bukkit.getOnlinePlayers().forEach(player ->
-                            sendCountdownMessage(player, message.getKey(), displayTime, appendix)
-                    );
-                }
-        );
-    }
-
-    public static CountdownPresentation presentation(
-            Message appendix,
-            SWSound sound,
-            boolean level,
-            CountdownMessageSink messageSink
-    ) {
-        return new CountdownPresentation(
-                messageSink,
-                sound != null
-                        ? pitch -> Fight.playSound(sound.getSound(), 100.0F, pitch)
-                        : null,
-                level
-                        ? timeLeft -> Bukkit.getOnlinePlayers().forEach(player -> player.setLevel(timeLeft))
-                        : null
-        );
-    }
-
-    public static CountdownPresentation playerPresentation(
-            FightPlayer fightPlayer,
-            Message appendix,
-            SWSound sound
-    ) {
-        return new CountdownPresentation(
-                (message, displayTime) -> fightPlayer.ifPlayer(player ->
-                        sendCountdownMessage(player, message.getKey(), displayTime, appendix)
-                ),
-                pitch -> fightPlayer.ifPlayer(player ->
-                        player.playSound(player.getLocation(), sound.getSound(), 100.0F, pitch)
-                ),
-                pitch -> Fight.playSound(sound.getSound(), 100.0F, pitch),
-                null,
-                true
-        );
-    }
-
-    public static void sendCountdownMessage(Player player, String message, int displayTime, Message appendix) {
-        FightSystem.getMessage().sendPrefixless(
-                message,
-                player,
-                ChatMessageType.ACTION_BAR,
-                displayTime,
-                FightSystem.getMessage().parse(appendix.getMsg(), player, appendix.getParams())
-        );
-    }
-}
@@ -19,30 +19,27 @@

 package de.steamwar.fightsystem.countdown;

-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.states.FightState;
-import de.steamwar.gamecore.state.StateDependentCountdown;
+import de.steamwar.fightsystem.states.StateDependentCountdown;
 import de.steamwar.fightsystem.utils.Message;
-import de.steamwar.gamecore.countdown.StandardCountdown;
 import de.steamwar.linkage.Linked;
 import org.bukkit.Bukkit;

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

    public NoPlayersOnlineCountdown() {
-        super(FightSystem.getPlugin(), Config.GameModeConfig.Times.NoPlayersOnlineDuration, FightCountdownAdapter.presentation(new Message("SHUTDOWN_COUNTDOWN"), null, false));
+        super(Config.GameModeConfig.Times.NoPlayersOnlineDuration, new Message("SHUTDOWN_COUNTDOWN"), null, false);

        if (!Config.GameModeConfig.Arena.Leaveable) {
-            new StateDependentCountdown<>(FightState.lifecycle, ArenaMode.AntiReplay.contains(GameConfig.mode), FightState.PreLeaderSetup, this);
+            new StateDependentCountdown(ArenaMode.AntiReplay, FightState.PreLeaderSetup, this);
        }
    }

    @Override
-    protected void countdownFinished() {
+    public void countdownFinished() {
        Bukkit.getServer().shutdown();
    }
 }
@@ -19,30 +19,27 @@

 package de.steamwar.fightsystem.countdown;

-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.states.FightState;
-import de.steamwar.gamecore.state.StateDependentCountdown;
+import de.steamwar.fightsystem.states.StateDependentCountdown;
 import de.steamwar.fightsystem.utils.Message;
-import de.steamwar.gamecore.countdown.StandardCountdown;
 import de.steamwar.linkage.Linked;

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

    public PostSchemCountdown() {
-        super(FightSystem.getPlugin(), Config.GameModeConfig.Times.SetupDuration, FightCountdownAdapter.presentation(new Message("POST_SCHEM_COUNTDOWN"), null, false));
-        if (GameConfig.mode == ArenaMode.PREPARE && Config.GameModeConfig.Schematic.UnlimitedPrepare) {
+        super(Config.GameModeConfig.Times.SetupDuration, new Message("POST_SCHEM_COUNTDOWN"), null, false);
+        if (Config.mode == ArenaMode.PREPARE && Config.GameModeConfig.Schematic.UnlimitedPrepare) {
            return;
        }

-        new StateDependentCountdown<>(FightState.lifecycle, ArenaMode.SeriousFight.contains(GameConfig.mode), FightState.PostSchemSetup, this);
+        new StateDependentCountdown(ArenaMode.SeriousFight, FightState.PostSchemSetup, this);
    }

    @Override
-    protected void countdownFinished() {
+    public void countdownFinished() {
        FightState.setFightState(FightState.PRE_RUNNING);
    }
 }
@@ -19,27 +19,24 @@

 package de.steamwar.fightsystem.countdown;

-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.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.gamecore.countdown.StandardCountdown;
 import de.steamwar.linkage.Linked;

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

    public PreRunningCountdown() {
-        super(FightSystem.getPlugin(), Config.GameModeConfig.Times.PreFightDuration, FightCountdownAdapter.presentation(new Message("PRE_RUNNING_COUNTDOWN"), SWSound.BLOCK_NOTE_PLING, true));
-        new StateDependentCountdown<>(FightState.lifecycle, ArenaMode.AntiReplay.contains(GameConfig.mode), FightState.PreRunning, this);
+        super(Config.GameModeConfig.Times.PreFightDuration, new Message("PRE_RUNNING_COUNTDOWN"), SWSound.BLOCK_NOTE_PLING, true);
+        new StateDependentCountdown(ArenaMode.AntiReplay, FightState.PreRunning, this);
    }

    @Override
-    protected void countdownFinished() {
+    public void countdownFinished() {
        FightState.setFightState(FightState.RUNNING);
    }
 }
@@ -19,27 +19,24 @@

 package de.steamwar.fightsystem.countdown;

-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.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.gamecore.countdown.StandardCountdown;
 import de.steamwar.linkage.Linked;

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

    public PreSchemCountdown() {
-        super(FightSystem.getPlugin(), Config.GameModeConfig.Times.PreSchemPasteDuration, FightCountdownAdapter.presentation(new Message("PRE_SCHEM_COUNTDOWN"), SWSound.BLOCK_NOTE_PLING, false));
-        new StateDependentCountdown<>(FightState.lifecycle, ArenaMode.AntiReplay.contains(GameConfig.mode), FightState.PreSchemSetup, this);
+        super(Config.GameModeConfig.Times.PreSchemPasteDuration, new Message("PRE_SCHEM_COUNTDOWN"), SWSound.BLOCK_NOTE_PLING, false);
+        new StateDependentCountdown(ArenaMode.AntiReplay, FightState.PreSchemSetup, this);
    }

    @Override
-    protected void countdownFinished() {
+    public void countdownFinished() {
        FightState.setFightState(FightState.POST_SCHEM_SETUP);
    }
 }
@@ -19,27 +19,24 @@

 package de.steamwar.fightsystem.countdown;

-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.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.gamecore.countdown.StandardCountdown;
 import de.steamwar.linkage.Linked;

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

    public SpectateOverCountdown() {
-        super(FightSystem.getPlugin(), GameConfig.test() ? 3600 : Config.GameModeConfig.Times.SpectatorDuration, FightCountdownAdapter.presentation(new Message("SPECTATE_COUNTDOWN"), SWSound.BLOCK_NOTE_PLING, false));
-        new StateDependentCountdown<>(FightState.lifecycle, ArenaMode.Restartable.contains(GameConfig.mode) || GameConfig.replayserver(), FightState.Spectate, this);
+        super(Config.test() ? 3600 : Config.GameModeConfig.Times.SpectatorDuration, new Message("SPECTATE_COUNTDOWN"), SWSound.BLOCK_NOTE_PLING, false);
+        new StateDependentCountdown(ArenaMode.Restartable.contains(Config.mode) || Config.replayserver(), FightState.Spectate, this);
    }

    @Override
-    protected void countdownFinished() {
+    public void countdownFinished() {
        FightState.setFightState(FightState.PRE_LEADER_SETUP);
    }
 }
@@ -20,22 +20,20 @@
 package de.steamwar.fightsystem.countdown;

 import de.steamwar.fightsystem.Config;
-import de.steamwar.fightsystem.FightSystem;
 import de.steamwar.fightsystem.utils.Message;
 import de.steamwar.fightsystem.utils.SWSound;
-import de.steamwar.gamecore.countdown.StandardCountdown;

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

    private final Runnable timeOver;

    public TimeOverCountdown(Runnable timeOver) {
-        super(FightSystem.getPlugin(), Config.GameModeConfig.WinConditionParams.TimeoutTime, FightCountdownAdapter.presentation(new Message("RUNNING_COUNTDOWN"), SWSound.BLOCK_NOTE_BASS, false));
+        super(Config.GameModeConfig.WinConditionParams.TimeoutTime, new Message("RUNNING_COUNTDOWN"), SWSound.BLOCK_NOTE_BASS, false);
        this.timeOver = timeOver;
    }

    @Override
-    protected void countdownFinished() {
+    public void countdownFinished() {
        timeOver.run();
    }
 }
@@ -21,14 +21,13 @@ package de.steamwar.fightsystem.event;

 import de.steamwar.fightsystem.Config;
 import de.steamwar.fightsystem.FightSystem;
-import de.steamwar.fightsystem.countdown.FightCountdownAdapter;
+import de.steamwar.fightsystem.countdown.Countdown;
 import de.steamwar.fightsystem.record.GlobalRecorder;
 import de.steamwar.fightsystem.states.FightState;
 import de.steamwar.fightsystem.states.StateDependent;
 import de.steamwar.fightsystem.utils.Message;
 import de.steamwar.fightsystem.utils.SWSound;
 import de.steamwar.fightsystem.winconditions.Winconditions;
-import de.steamwar.gamecore.countdown.StandardCountdown;
 import de.steamwar.linkage.Linked;
 import org.bukkit.Bukkit;
 import org.bukkit.entity.EntityType;
@@ -140,14 +139,14 @@ public class HellsBells {
        }.register();
    }

-    private class HellsBellsCountdown extends StandardCountdown {
+    private class HellsBellsCountdown extends Countdown {

        public HellsBellsCountdown(int time) {
-            super(FightSystem.getPlugin(), time, FightCountdownAdapter.presentation(new Message("HELLS_BELLS_COUNTDOWN"), SWSound.BLOCK_NOTE_BASS, true));
+            super(time, new Message("HELLS_BELLS_COUNTDOWN"), SWSound.BLOCK_NOTE_BASS, true);
        }

        @Override
-        protected void countdownFinished() {
+        public void countdownFinished() {
            drop();
            startCountdown();
        }
@@ -241,4 +240,4 @@ public class HellsBells {
            return this == NORTH || this == WEST;
        }
    }
-}
+}
@@ -21,7 +21,7 @@ package de.steamwar.fightsystem.event;

 import de.steamwar.fightsystem.Config;
 import de.steamwar.fightsystem.FightSystem;
-import de.steamwar.fightsystem.countdown.FightCountdownAdapter;
+import de.steamwar.fightsystem.countdown.Countdown;
 import de.steamwar.fightsystem.record.GlobalRecorder;
 import de.steamwar.fightsystem.states.FightState;
 import de.steamwar.fightsystem.states.StateDependent;
@@ -29,7 +29,6 @@ import de.steamwar.fightsystem.states.StateDependentListener;
 import de.steamwar.fightsystem.utils.Message;
 import de.steamwar.fightsystem.utils.SWSound;
 import de.steamwar.fightsystem.winconditions.Winconditions;
-import de.steamwar.gamecore.countdown.StandardCountdown;
 import de.steamwar.linkage.Linked;
 import org.bukkit.Bukkit;
 import org.bukkit.entity.Fireball;
@@ -155,14 +154,14 @@ public class Meteor implements Listener {
        }.register();
    }

-    private class MeteorCountdown extends StandardCountdown {
+    private class MeteorCountdown extends Countdown {

        public MeteorCountdown(int time) {
-            super(FightSystem.getPlugin(), time, FightCountdownAdapter.presentation(new Message("METEOR_COUNTDOWN"), SWSound.BLOCK_NOTE_BASS, true));
+            super(time, new Message("METEOR_COUNTDOWN"), SWSound.BLOCK_NOTE_BASS, true);
        }

        @Override
-        protected void countdownFinished() {
+        public void countdownFinished() {
            drop();
            startCountdown();
        }
@@ -213,4 +212,4 @@ public class Meteor implements Listener {
            }
        }
    }
-}
+}
@@ -20,8 +20,8 @@
 package de.steamwar.fightsystem.event;

 import com.sk89q.worldedit.WorldEditException;
-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;
@@ -37,7 +37,7 @@ import java.util.logging.Level;
 public class PersistentDamage {

    public PersistentDamage() {
-        if (!ArenaMode.SeriousFight.contains(GameConfig.mode)) return;
+        if (!ArenaMode.SeriousFight.contains(Config.mode)) return;

        new OneShotStateDependent(Winconditions.PERSISTENT_DAMAGE, FightState.Spectate, () -> Fight.teams().forEach(team -> {
            try {
@@ -19,11 +19,9 @@

 package de.steamwar.fightsystem.fight;

-import de.steamwar.gamecore.ArenaMode;
-import de.steamwar.gamecore.GameConfig;
+import de.steamwar.fightsystem.ArenaMode;
 import de.steamwar.fightsystem.Config;
 import de.steamwar.fightsystem.record.GlobalRecorder;
-import de.steamwar.gamecore.team.TeamRegistry;
 import lombok.Getter;
 import org.bukkit.Bukkit;
 import org.bukkit.Registry;
@@ -31,24 +29,41 @@ import org.bukkit.Sound;
 import org.bukkit.entity.LivingEntity;

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

 public class Fight {
    private Fight() {
    }

    @Getter
-    private static final FightTeam redTeam = new FightTeam(Config.TeamRedName, Config.TeamRedColor, Config.TeamRedSpawn, Config.RedPasteRegion, Config.RedExtendRegion, Config.RedRotate, false, GameConfig.RedLeader);
+    private static final FightTeam redTeam = new FightTeam(Config.TeamRedName, Config.TeamRedColor, Config.TeamRedSpawn, Config.RedPasteRegion, Config.RedExtendRegion, Config.RedRotate, false, Config.RedLeader);
    @Getter
-    private static final FightTeam blueTeam = new FightTeam(Config.TeamBlueName, Config.TeamBlueColor, Config.TeamBlueSpawn, Config.BluePasteRegion, Config.BlueExtendRegion, Config.BlueRotate, true, GameConfig.BlueLeader);
-    private static final TeamRegistry<FightTeam, LivingEntity> teamRegistry = new TeamRegistry<>(List.of(redTeam, blueTeam));
+    private static final FightTeam blueTeam = new FightTeam(Config.TeamBlueName, Config.TeamBlueColor, Config.TeamBlueSpawn, Config.BluePasteRegion, Config.BlueExtendRegion, Config.BlueRotate, true, Config.BlueLeader);
+    private static final Collection<FightTeam> teams = new HashSet<>();
+
+    static {
+        teams.add(redTeam);
+        teams.add(blueTeam);
+    }

    public static FightTeam getPlayerTeam(LivingEntity player) {
-        return teamRegistry.findTeam(player);
+        if (redTeam.isPlayerInTeam(player)) {
+            return redTeam;
+        }
+        if (blueTeam.isPlayerInTeam(player)) {
+            return blueTeam;
+        }
+        return null;
    }

    public static FightTeam getOpposite(FightTeam fightTeam) {
-        return teamRegistry.opposite(fightTeam);
+        if (fightTeam == redTeam) {
+            return blueTeam;
+        } else if (fightTeam == blueTeam) {
+            return redTeam;
+        }
+
+        throw new IllegalArgumentException();
    }

    public static FightPlayer getFightPlayer(LivingEntity player) {
@@ -66,11 +81,7 @@ public class Fight {
    }

    public static Collection<FightTeam> teams() {
-        return teamRegistry.getTeams();
-    }
-
-    public static boolean allTeamsReady() {
-        return teamRegistry.allReady();
+        return teams;
    }

    public static FightTeam getUnrotated() {
@@ -84,14 +95,20 @@ public class Fight {
    }

    public static FightTeam getTeamByName(String name) {
-        return teamRegistry.findById(name);
+        if (redTeam.getName().equalsIgnoreCase(name)) {
+            return redTeam;
+        }
+        if (blueTeam.getName().equalsIgnoreCase(name)) {
+            return blueTeam;
+        }
+        return null;
    }

    public static boolean publicOnly() {
        if (Config.OnlyPublicSchematics) {
            return true;
        }
-        if (Config.GameModeConfig.Schematic.IgnorePublicOnly || ArenaMode.RankedEvent.contains(GameConfig.mode)) {
+        if (Config.GameModeConfig.Schematic.IgnorePublicOnly || ArenaMode.RankedEvent.contains(Config.mode)) {
            return false;
        }
        if (redTeam.getLeader() == null || blueTeam.getLeader() == null) {
@@ -21,7 +21,7 @@ package de.steamwar.fightsystem.fight;

 import de.steamwar.fightsystem.Config;
 import de.steamwar.fightsystem.ai.AI;
-import de.steamwar.gamecore.countdown.Countdown;
+import de.steamwar.fightsystem.countdown.Countdown;
 import de.steamwar.fightsystem.countdown.EnternCountdown;
 import de.steamwar.fightsystem.events.TeamDeathEvent;
 import de.steamwar.sql.PersonalKit;
@@ -22,8 +22,7 @@ package de.steamwar.fightsystem.fight;
 import com.sk89q.worldedit.WorldEditException;
 import com.sk89q.worldedit.extent.clipboard.Clipboard;
 import com.sk89q.worldedit.math.transform.AffineTransform;
-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.record.GlobalRecorder;
@@ -131,7 +130,7 @@ public class FightSchematic extends StateDependent {
            setSchematic(publics.get(new Random().nextInt(publics.size())));
        }

-        if (ArenaMode.AntiReplay.contains(GameConfig.mode)) {
+        if (ArenaMode.AntiReplay.contains(Config.mode)) {
            boolean changeRotation = false;
            if (Config.GameModeConfig.WinConditions.contains(Winconditions.RANDOM_ROTATE)) {
                changeRotation = new Random().nextBoolean();
@@ -149,7 +148,7 @@ public class FightSchematic extends StateDependent {

    private void replaceTeamColor(Clipboard clipboard) {
        try {
-            WorldeditWrapper.impl.replaceTeamColor(clipboard, ArenaMode.AntiPrepare.contains(GameConfig.mode) ? ColorConverter.chat2dyeColor(team.getColor()) : DyeColor.PINK);
+            WorldeditWrapper.impl.replaceTeamColor(clipboard, ArenaMode.AntiPrepare.contains(Config.mode) ? ColorConverter.chat2dyeColor(team.getColor()) : DyeColor.PINK);
        } catch (WorldEditException e) {
            Bukkit.getLogger().log(Level.SEVERE, "Could not recolor schematic", e);
        }
@@ -174,7 +173,7 @@ public class FightSchematic extends StateDependent {
        );
        FightSystem.getHullHider().initialize(team);
        team.getPlayers().forEach(fightPlayer -> fightPlayer.ifAI(ai -> ai.schematic(clipboard)));
-        if (ArenaMode.Check.contains(GameConfig.mode) && !team.isBlue()) {
+        if (ArenaMode.Check.contains(Config.mode) && !team.isBlue()) {
            replaceSync(Material.TNT, Material.RED_WOOL);
        }

@@ -183,7 +182,7 @@ public class FightSchematic extends StateDependent {

    @Override
    public void disable() {
-        if (GameConfig.mode == ArenaMode.PREPARE) {
+        if (Config.mode == ArenaMode.PREPARE) {
            return;
        }

@@ -20,13 +20,12 @@
 package de.steamwar.fightsystem.fight;

 import com.sk89q.worldedit.extent.clipboard.Clipboard;
-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;
 import de.steamwar.fightsystem.commands.GUI;
-import de.steamwar.gamecore.countdown.Countdown;
+import de.steamwar.fightsystem.countdown.Countdown;
 import de.steamwar.fightsystem.events.TeamLeaveEvent;
 import de.steamwar.fightsystem.events.TeamSpawnEvent;
 import de.steamwar.fightsystem.listener.FightScoreboard;
@@ -58,7 +57,7 @@ import java.util.*;
 import java.util.function.Consumer;


-public class FightTeam implements de.steamwar.gamecore.team.GameTeam<LivingEntity> {
+public class FightTeam {

    private static void setKitButton(HotbarKit kit, boolean leader) {
        if (Kit.getAvailableKits(leader).size() > 1 || Config.GameModeConfig.Kits.PersonalKits) {
@@ -80,14 +79,14 @@ public class FightTeam implements de.steamwar.gamecore.team.GameTeam<LivingEntit
    static {
        setKitButton(notReadyKit, true);

-        if (ArenaMode.VariableTeams.contains(GameConfig.mode)) {
+        if (ArenaMode.VariableTeams.contains(Config.mode)) {
            notReadyKit.setItem(2, "REQUESTS", new ItemBuilder(Material.PAPER).build(), GUI::chooseJoinRequests);
            if (!AIManager.availableAIs().isEmpty()) {
                notReadyKit.setItem(6, "ADD_AI", new ItemBuilder(Material.REDSTONE).build(), GUI::addAI);
            }
        }

-        if (GameConfig.test()) {
+        if (Config.test()) {
            notReadyKit.setItem(5, "CHOOSE_SCHEMATIC", new ItemBuilder(Material.CAULDRON).enchant().build(), GUI::preSchemDialog);
        }

@@ -164,7 +163,7 @@ public class FightTeam implements de.steamwar.gamecore.team.GameTeam<LivingEntit
        }

        new OneShotStateDependent(ArenaMode.Restartable, FightState.PreLeaderSetup, () -> Bukkit.getScheduler().runTask(FightSystem.getPlugin(), this::reset));
-        new OneShotStateDependent(GameConfig.replayserver(), FightState.PreLeaderSetup, () -> Bukkit.getScheduler().runTask(FightSystem.getPlugin(), this::reset));
+        new OneShotStateDependent(Config.replayserver(), FightState.PreLeaderSetup, () -> Bukkit.getScheduler().runTask(FightSystem.getPlugin(), this::reset));
        new OneShotStateDependent(ArenaMode.All, FightState.PostSchemSetup, () -> {
            if (leader != null) leader.ifPlayer(notReadyKit::loadToPlayer);
        });
@@ -237,7 +236,7 @@ public class FightTeam implements de.steamwar.gamecore.team.GameTeam<LivingEntit

        playerSet.forEach(uuid -> addMember(Bukkit.getPlayer(uuid), SteamwarUser.get(uuid), true));

-        if (ArenaMode.VariableTeams.contains(GameConfig.mode) && isLeaderless()) {
+        if (ArenaMode.VariableTeams.contains(Config.mode) && isLeaderless()) {
            List<Player> onlinePlayers = new ArrayList<>(Bukkit.getOnlinePlayers());
            Collections.shuffle(onlinePlayers);
            for (Player player : onlinePlayers) {
@@ -339,7 +338,7 @@ public class FightTeam implements de.steamwar.gamecore.team.GameTeam<LivingEntit
                FightSystem.getHullHider().updatePlayer(player);
                FightSystem.getTechHider().reloadChunks(player, Config.ArenaRegion, Fight.getOpposite(this).getExtendRegion());

-                if (ArenaMode.VariableTeams.contains(GameConfig.mode)) {
+                if (ArenaMode.VariableTeams.contains(Config.mode)) {
                    HotbarKit.SPECTATOR_KIT.loadToPlayer(player);
                }
            }
@@ -357,7 +356,7 @@ public class FightTeam implements de.steamwar.gamecore.team.GameTeam<LivingEntit
        this.leader = null;
        if (!players.isEmpty()) {
            setLeader(players.values().iterator().next(), false);
-        } else if (FightState.getFightState() != FightState.PRE_LEADER_SETUP && !ArenaMode.RankedEvent.contains(GameConfig.mode)) {
+        } else if (FightState.getFightState() != FightState.PRE_LEADER_SETUP && !ArenaMode.RankedEvent.contains(Config.mode)) {
            Bukkit.getScheduler().runTaskLater(FightSystem.getPlugin(), () -> FightState.setFightState(FightState.PRE_LEADER_SETUP), 1);
        }
    }
@@ -405,31 +404,6 @@ public class FightTeam implements de.steamwar.gamecore.team.GameTeam<LivingEntit
        return players.values();
    }

-    @Override
-    public String teamId() {
-        return name;
-    }
-
-    @Override
-    public Collection<LivingEntity> members() {
-        return players.values().stream().map(FightPlayer::getEntity).toList();
-    }
-
-    @Override
-    public LivingEntity leader() {
-        return leader == null ? null : leader.getEntity();
-    }
-
-    @Override
-    public boolean ready() {
-        return ready;
-    }
-
-    @Override
-    public boolean contains(LivingEntity member) {
-        return isPlayerInTeam(member);
-    }
-
    public void pasteSchem() {
        testPasteAction();
    }
@@ -449,7 +423,7 @@ public class FightTeam implements de.steamwar.gamecore.team.GameTeam<LivingEntit
    }

    private void testPasteAction() {
-        if (GameConfig.test()) {
+        if (Config.test()) {
            this.schematic.enable();
        } else if (Fight.getOpposite(this).schematic.hasSchematic()) {
            FightState.setFightState(FightState.POST_SCHEM_SETUP);
@@ -481,7 +455,7 @@ public class FightTeam implements de.steamwar.gamecore.team.GameTeam<LivingEntit
        if (ready) {
            broadcast("TEAM_READY");
            leader.ifPlayer(readyKit::loadToPlayer);
-            if (Fight.allTeamsReady() || ArenaMode.SoloLeader.contains(GameConfig.mode)) {
+            if (Fight.getOpposite(this).isReady() || ArenaMode.SoloLeader.contains(Config.mode)) {
                FightState.setFightState(FightState.PRE_RUNNING);
            }
        } else {
@@ -494,12 +468,10 @@ public class FightTeam implements de.steamwar.gamecore.team.GameTeam<LivingEntit
        this.skip = !skip;
        if (skip) {
            broadcast("SKIP_READY");
-            if (Fight.getOpposite(this).skip || GameConfig.test()) {
+            if (Fight.getOpposite(this).skip || Config.test()) {
                skip = false;
                Fight.getOpposite(this).skip = false;
-                if (Countdown.skipActive()) {
-                    FightUI.addSubtitle("UI_SKIP");
-                }
+                Countdown.skip();
            }
        } else {
            broadcast("SKIP_NOT_READY");
@@ -19,8 +19,7 @@

 package de.steamwar.fightsystem.fight;

-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.listener.Recording;
@@ -47,7 +46,7 @@ public class FightWorld extends StateDependent {
    private static final boolean PAPER = Bukkit.getVersion().contains("git-Paper");

    public FightWorld() {
-        super(ArenaMode.Restartable.contains(GameConfig.mode) || GameConfig.replayserver(), FightState.Schem);
+        super(ArenaMode.Restartable.contains(Config.mode) || Config.replayserver(), FightState.Schem);
        register();
    }

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

 package de.steamwar.fightsystem.fight;

-import de.steamwar.gamecore.ArenaMode;
+import de.steamwar.fightsystem.ArenaMode;
 import de.steamwar.fightsystem.listener.PersonalKitCreator;
 import de.steamwar.fightsystem.states.FightState;
 import de.steamwar.fightsystem.states.StateDependentListener;
@@ -19,7 +19,7 @@

 package de.steamwar.fightsystem.listener;

-import de.steamwar.gamecore.ArenaMode;
+import de.steamwar.fightsystem.ArenaMode;
 import de.steamwar.fightsystem.Config;
 import de.steamwar.fightsystem.events.TeamDeathEvent;
 import de.steamwar.fightsystem.events.TeamLeaveEvent;
@@ -19,7 +19,7 @@

 package de.steamwar.fightsystem.listener;

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

 package de.steamwar.fightsystem.listener;

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

 package de.steamwar.fightsystem.listener;

-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,12 +19,13 @@

 package de.steamwar.fightsystem.listener;

-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.states.FightState;
 import de.steamwar.fightsystem.states.StateDependentListener;
 import de.steamwar.linkage.Linked;
+import de.steamwar.sql.GameModeConfig;
 import de.steamwar.sql.SchematicNode;
 import de.steamwar.sql.SteamwarUser;
 import de.steamwar.sql.UserPerm;
@@ -44,14 +45,28 @@ public class Check implements Listener {
        new StateDependentListener(ArenaMode.Check, FightState.All, this);
    }

+    private boolean checkPermission(SteamwarUser user, SchematicNode schematic) {
+        GameModeConfig<Object, String> gameModeConfig = GameModeConfig.getAll().stream()
+                .filter(gmc -> gmc.Schematic.Type != null && gmc.Schematic.Type.checkType() != null && schematic.getSchemtype().name().equals(gmc.Schematic.Type.checkType().name()))
+                .findFirst()
+                .orElse(null);
+        if (gameModeConfig == null) gameModeConfig = GameModeConfig.getDefaults();
+        return checkPermission(user, gameModeConfig);
+    }
+
+    public static boolean checkPermission(SteamwarUser user, GameModeConfig gameModeConfig) {
+        if (user.hasPerm(UserPerm.ADMINISTRATION)) return true;
+        if (gameModeConfig.Checkers.isEmpty() && user.hasPerm(UserPerm.CHECK)) return true;
+        return gameModeConfig.Checkers.contains(user.getId());
+    }
+
    @EventHandler
    public void onJoin(PlayerJoinEvent e) {
        Player player = e.getPlayer();
        SteamwarUser user = SteamwarUser.get(player.getUniqueId());

-        if (user.hasPerm(UserPerm.CHECK)) return;
-
-        SchematicNode schem = SchematicNode.getSchematicNode(GameConfig.CheckSchemID);
+        SchematicNode schem = SchematicNode.getSchematicNode(Config.CheckSchemID);
+        if (checkPermission(user, schem)) return;
        if (user.getId() == schem.getOwner()) return;

        FightSystem.getMessage().send("CHECK_JOIN_DENIED", player);
@@ -19,7 +19,7 @@

 package de.steamwar.fightsystem.listener;

-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.StateDependentListener;
@@ -19,7 +19,7 @@

 package de.steamwar.fightsystem.listener;

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

 package de.steamwar.fightsystem.listener;

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

 package de.steamwar.fightsystem.listener;

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

 package de.steamwar.fightsystem.listener;

-import de.steamwar.gamecore.ArenaMode;
+import de.steamwar.fightsystem.ArenaMode;
 import de.steamwar.fightsystem.states.FightState;
 import de.steamwar.fightsystem.states.StateDependentListener;
 import de.steamwar.scoreboard.SWScoreboard;
@@ -19,7 +19,7 @@

 package de.steamwar.fightsystem.listener;

-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.StateDependentListener;
@@ -19,7 +19,7 @@

 package de.steamwar.fightsystem.listener;

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

 package de.steamwar.fightsystem.listener;

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

 package de.steamwar.fightsystem.listener;

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

 package de.steamwar.fightsystem.listener;

-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;
@@ -86,7 +85,7 @@ public class Permanent implements Listener {

    @EventHandler
    public void onTpGM3(PlayerTeleportEvent e) {
-        if (ArenaMode.AntiTest.contains(GameConfig.mode) && e.getCause() == PlayerTeleportEvent.TeleportCause.SPECTATE) {
+        if (ArenaMode.AntiTest.contains(Config.mode) && e.getCause() == PlayerTeleportEvent.TeleportCause.SPECTATE) {
            e.setCancelled(true);
            FightSystem.getMessage().sendPrefixless("NO_TELEPORT", e.getPlayer(), ChatMessageType.ACTION_BAR);
            e.getPlayer().kickPlayer(null);
@@ -19,11 +19,10 @@

 package de.steamwar.fightsystem.listener;

+import de.steamwar.fightsystem.ArenaMode;
 import de.steamwar.fightsystem.Config;
 import de.steamwar.fightsystem.states.FightState;
 import de.steamwar.fightsystem.states.StateDependentListener;
-import de.steamwar.gamecore.ArenaMode;
-import de.steamwar.gamecore.GameConfig;
 import org.bukkit.block.Block;
 import org.bukkit.block.BlockFace;
 import org.bukkit.block.PistonMoveReaction;
@@ -42,7 +41,7 @@ public class PistonListener implements Listener {

    public PistonListener(Set<ArenaMode> condition, Consumer<BlockPistonEvent> leftAreaHandler) {
        this.leftAreaHandler = leftAreaHandler;
-        if (!condition.contains(GameConfig.mode)) return;
+        if (!condition.contains(Config.mode)) return;

        //Wenn Entern aktiv ist, sollen Raketen etc. entern können
        new StateDependentListener(!Config.GameModeConfig.Arena.AllowMissiles, FightState.All, this);
@@ -20,8 +20,7 @@
 package de.steamwar.fightsystem.listener;

 import com.sk89q.worldedit.WorldEditException;
-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;
@@ -68,7 +67,7 @@ public class PrepareSchem implements Listener {

                SchematicNode schem;
                try {
-                    schem = SchematicNode.getSchematicNode(GameConfig.PrepareSchemID);
+                    schem = SchematicNode.getSchematicNode(Config.PrepareSchemID);
                } catch (SecurityException e) {
                    FightSystem.getMessage().broadcast("PREPARE_SCHEM_DELETED");
                    Bukkit.shutdown();
@@ -20,7 +20,7 @@
 package de.steamwar.fightsystem.listener;

 import com.comphenix.tinyprotocol.TinyProtocol;
-import de.steamwar.gamecore.ArenaMode;
+import de.steamwar.fightsystem.ArenaMode;
 import de.steamwar.fightsystem.Config;
 import de.steamwar.fightsystem.FightSystem;
 import de.steamwar.fightsystem.events.TeamDeathEvent;
@@ -19,7 +19,7 @@

 package de.steamwar.fightsystem.listener;

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

 package de.steamwar.fightsystem.listener;

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

 package de.steamwar.fightsystem.listener;

-import de.steamwar.gamecore.ArenaMode;
-import de.steamwar.gamecore.GameConfig;
+import de.steamwar.fightsystem.ArenaMode;
 import de.steamwar.fightsystem.Config;
 import de.steamwar.fightsystem.states.FightState;
 import de.steamwar.fightsystem.states.StateDependentListener;
@@ -34,12 +33,12 @@ import org.bukkit.event.player.PlayerQuitEvent;
 public class Shutdown implements Listener {

    public Shutdown() {
-        new StateDependentListener(ArenaMode.AntiEvent.contains(GameConfig.mode) && !GameConfig.replayserver(), FightState.All, this);
+        new StateDependentListener(ArenaMode.AntiEvent.contains(Config.mode) && !Config.replayserver(), FightState.All, this);
    }

    @EventHandler
    public void handlePlayerQuit(PlayerQuitEvent event) {
-        if (GameConfig.replayserver() || Config.GameModeConfig.Arena.Leaveable) return;
+        if (Config.replayserver() || Config.GameModeConfig.Arena.Leaveable) return;

        //Shutdown server if nobody online
        if (Bukkit.getOnlinePlayers().isEmpty() || (Bukkit.getOnlinePlayers().size() == 1 && Bukkit.getOnlinePlayers().contains(event.getPlayer()))) {
@@ -22,7 +22,7 @@ package de.steamwar.fightsystem.listener;
 import com.comphenix.tinyprotocol.TinyProtocol;
 import com.mojang.authlib.GameProfile;
 import de.steamwar.core.ProtocolWrapper;
-import de.steamwar.gamecore.ArenaMode;
+import de.steamwar.fightsystem.ArenaMode;
 import de.steamwar.fightsystem.Config;
 import de.steamwar.fightsystem.fight.Fight;
 import de.steamwar.fightsystem.fight.FightPlayer;
@@ -19,7 +19,7 @@

 package de.steamwar.fightsystem.listener;

-import de.steamwar.gamecore.ArenaMode;
+import de.steamwar.fightsystem.ArenaMode;
 import de.steamwar.fightsystem.Config;
 import de.steamwar.fightsystem.events.BoardingEvent;
 import de.steamwar.fightsystem.events.TeamDeathEvent;
@@ -19,8 +19,8 @@

 package de.steamwar.fightsystem.listener;

-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.states.FightState;
 import de.steamwar.fightsystem.states.StateDependentListener;
@@ -43,7 +43,7 @@ public class TestJoin implements Listener {
    public void handlePlayerJoin(PlayerJoinEvent event) {
        Player player = event.getPlayer();

-        if (GameConfig.ReplayID != 0 && !SteamwarUser.get(player.getUniqueId()).hasPerm(UserPerm.MODERATION)) {
+        if (Config.ReplayID != 0 && !SteamwarUser.get(player.getUniqueId()).hasPerm(UserPerm.MODERATION)) {
            FightSystem.getMessage().send("CHECK_JOIN_DENIED", player);
            player.kickPlayer("");
            return;
@@ -19,7 +19,7 @@

 package de.steamwar.fightsystem.listener;

-import de.steamwar.gamecore.ArenaMode;
+import de.steamwar.fightsystem.ArenaMode;
 import de.steamwar.fightsystem.Config;
 import de.steamwar.fightsystem.fight.Fight;
 import de.steamwar.fightsystem.fight.FightTeam;
@@ -22,7 +22,6 @@ package de.steamwar.fightsystem.record;
 import de.steamwar.fightsystem.Config;
 import de.steamwar.fightsystem.states.FightState;
 import de.steamwar.fightsystem.states.StateDependent;
-import de.steamwar.gamecore.GameConfig;
 import de.steamwar.linkage.Linked;
 import lombok.Getter;

@@ -37,7 +36,7 @@ public class FileRecorder extends StateDependent implements Recorder {
    private DataOutputStream outputStream;

    public FileRecorder() {
-        super(GameConfig.ReplayID == 0, FightState.Recording);
+        super(Config.ReplayID == 0, FightState.Recording);
        register();
    }

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

 package de.steamwar.fightsystem.record;

-import de.steamwar.gamecore.GameConfig;
+import de.steamwar.fightsystem.Config;

 import java.io.File;
 import java.io.IOException;
@@ -33,7 +33,7 @@ public class FileSource extends PacketSource {
    }

    public static void startReplay() {
-        if (GameConfig.replayserver()) {
+        if (Config.replayserver()) {
            try {
                new LiveServer();
            } catch (IOException e) {
@@ -42,9 +42,9 @@ public class FileSource extends PacketSource {
            return;
        }

-        if (GameConfig.ReplayID > 0) {
+        if (Config.ReplayID > 0) {
            try {
-                new FileSource(replayFile(GameConfig.ReplayID));
+                new FileSource(replayFile(Config.ReplayID));
            } catch (IOException e) {
                throw new SecurityException("Could not start replay", e);
            }
@@ -20,15 +20,14 @@
 package de.steamwar.fightsystem.record;

 import com.sk89q.worldedit.extent.clipboard.Clipboard;
-import de.steamwar.core.WorldEditWrapper;
+import de.steamwar.core.worldedit.WorldEditWrapper;
 import de.steamwar.entity.REntity;
 import de.steamwar.entity.REntityServer;
 import de.steamwar.entity.RPlayer;
-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.countdown.FightCountdownAdapter;
+import de.steamwar.fightsystem.countdown.Countdown;
 import de.steamwar.fightsystem.fight.Fight;
 import de.steamwar.fightsystem.fight.FightTeam;
 import de.steamwar.fightsystem.fight.FightWorld;
@@ -256,7 +255,7 @@ public class PacketProcessor implements Listener {
            addREntity(entityId, new RPlayer(entityServer, user.getUUID(), user.getUserName(), Config.SpecSpawn));
            team.addEntry(user.getUserName());

-            if (ArenaMode.Test.contains(GameConfig.mode)) {
+            if (ArenaMode.Test.contains(Config.mode)) {
                entities.get(entityId).setGlowing(true);
            }
        });
@@ -394,7 +393,7 @@ public class PacketProcessor implements Listener {
        int displaytime = source.readInt();
        Message appendix = readMessage();

-        Bukkit.getOnlinePlayers().forEach(p -> FightCountdownAdapter.sendCountdownMessage(p, message, displaytime, appendix));
+        Bukkit.getOnlinePlayers().forEach(p -> Countdown.sendCountdownMessage(p, message, displaytime, appendix));
    }

    private void oldArenaInfo() throws IOException {
@@ -634,7 +633,7 @@ public class PacketProcessor implements Listener {
        entities.clear();

        freezer.disable();
-        if (!GameConfig.replayserver()) {
+        if (!Config.replayserver()) {
            FightSystem.getMessage().broadcast("REPLAY_ENDS");
        }
        if (FightSystem.getLastWinner() != null) {
@@ -19,8 +19,7 @@

 package de.steamwar.fightsystem.record;

-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.fight.FightPlayer;
@@ -52,7 +51,7 @@ public interface Recorder {
    default void enable() {
        GlobalRecorder.getInstance().add(this);

-        if (ArenaMode.Event.contains(GameConfig.mode)) {
+        if (ArenaMode.Event.contains(Config.mode)) {
            teamIds(Config.EventTeamBlueID, Config.EventTeamRedID);
        }

@@ -1,12 +1,28 @@
+/*
+ *   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.states;

-import de.steamwar.gamecore.state.GameStateMachine;
-import de.steamwar.gamecore.state.IStateDependent;
+import de.steamwar.fightsystem.commands.FightSWCommand;
+import lombok.Getter;

-import java.util.Collections;
-import java.util.EnumSet;
-import java.util.Map;
-import java.util.Set;
+import java.util.*;

 public enum FightState {
    PRE_LEADER_SETUP,
@@ -16,58 +32,65 @@ public enum FightState {
    RUNNING,
    SPECTATE;

-    public static final Set<FightState> All = immutable(EnumSet.allOf(FightState.class));
-    public static final Set<FightState> PreLeaderSetup = immutable(EnumSet.of(PRE_LEADER_SETUP));
-    public static final Set<FightState> PreSchemSetup = immutable(EnumSet.of(PRE_SCHEM_SETUP));
-    public static final Set<FightState> PostSchemSetup = immutable(EnumSet.of(POST_SCHEM_SETUP));
-    public static final Set<FightState> PreRunning = immutable(EnumSet.of(PRE_RUNNING));
-    public static final Set<FightState> Running = immutable(EnumSet.of(RUNNING));
-    public static final Set<FightState> Spectate = immutable(EnumSet.of(SPECTATE));
-    public static final Set<FightState> Setup = immutable(EnumSet.of(PRE_LEADER_SETUP, PRE_SCHEM_SETUP, POST_SCHEM_SETUP));
-    public static final Set<FightState> Ingame = immutable(EnumSet.of(PRE_RUNNING, RUNNING));
-    public static final Set<FightState> TeamFix = immutable(EnumSet.of(PRE_RUNNING, RUNNING, SPECTATE));
-    public static final Set<FightState> Schem = complement(PRE_LEADER_SETUP, PRE_SCHEM_SETUP);
-    public static final Set<FightState> Recording = complement(PRE_LEADER_SETUP, PRE_SCHEM_SETUP, SPECTATE);
-    public static final Set<FightState> AntiRunning = complement(RUNNING);
-    public static final Set<FightState> AntiIngame = complement(PRE_RUNNING, RUNNING);
-    public static final Set<FightState> AntiSpectate = complement(SPECTATE);
+    public static final Set<FightState> All = Collections.unmodifiableSet(EnumSet.allOf(FightState.class));

-    public static final GameStateMachine<FightState> lifecycle = new GameStateMachine<>(PRE_LEADER_SETUP);
+    public static final Set<FightState> PreLeaderSetup = Collections.unmodifiableSet(EnumSet.of(PRE_LEADER_SETUP));
+    public static final Set<FightState> PreSchemSetup = Collections.unmodifiableSet(EnumSet.of(PRE_SCHEM_SETUP));
+    public static final Set<FightState> PostSchemSetup = Collections.unmodifiableSet(EnumSet.of(POST_SCHEM_SETUP));
+    public static final Set<FightState> PreRunning = Collections.unmodifiableSet(EnumSet.of(PRE_RUNNING));
+    public static final Set<FightState> Running = Collections.unmodifiableSet(EnumSet.of(RUNNING));
+    public static final Set<FightState> Spectate = Collections.unmodifiableSet(EnumSet.of(SPECTATE));

-    public static void registerStateDependent(IStateDependent<FightState> stateDependent) {
-        lifecycle.registerStateDependent(stateDependent);
+    public static final Set<FightState> Setup = Collections.unmodifiableSet(EnumSet.of(PRE_LEADER_SETUP, PRE_SCHEM_SETUP, POST_SCHEM_SETUP));
+    public static final Set<FightState> Ingame = Collections.unmodifiableSet(EnumSet.of(PRE_RUNNING, RUNNING));
+    public static final Set<FightState> TeamFix = Collections.unmodifiableSet(EnumSet.of(PRE_RUNNING, RUNNING, SPECTATE));
+    public static final Set<FightState> Schem = Collections.unmodifiableSet(EnumSet.complementOf(EnumSet.of(PRE_LEADER_SETUP, PRE_SCHEM_SETUP)));
+    public static final Set<FightState> Recording = Collections.unmodifiableSet(EnumSet.complementOf(EnumSet.of(PRE_LEADER_SETUP, PRE_SCHEM_SETUP, SPECTATE)));
+    public static final Set<FightState> AntiRunning = Collections.unmodifiableSet(EnumSet.complementOf(EnumSet.of(RUNNING)));
+    public static final Set<FightState> AntiIngame = Collections.unmodifiableSet(EnumSet.complementOf(EnumSet.of(PRE_RUNNING, RUNNING)));
+    public static final Set<FightState> AntiSpectate = Collections.unmodifiableSet(EnumSet.complementOf(EnumSet.of(SPECTATE)));
+
+    @Getter
+    private static final Map<IStateDependent, Boolean> stateDependentFeatures = new HashMap<>();
+    @Getter
+    private static FightState fightState = PRE_LEADER_SETUP;
+
+    public static void registerStateDependent(IStateDependent stateDependent) {
+        if (stateDependent.enabled().isEmpty()) return;
+        boolean enabled = stateDependent.enabled().contains(fightState);
+        stateDependentFeatures.put(stateDependent, enabled);
+        if (enabled) stateDependent.enable();
    }

    public static void setFightState(FightState state) {
-        lifecycle.transitionTo(state);
-    }
+        if (fightState.equals(state)) return;
+        fightState = state;

-    public static FightState getFightState() {
-        return lifecycle.getCurrentState();
-    }
+        for (Map.Entry<IStateDependent, Boolean> feature : stateDependentFeatures.entrySet()) {
+            //Enable feature if should be enabled and currently disabled
+            if (feature.getKey().enabled().contains(fightState) && !feature.getValue()) {
+                feature.getKey().enable();
+                feature.setValue(true);
+            }

-    public static Map<IStateDependent<FightState>, Boolean> getStateDependentFeatures() {
-        return lifecycle.getStateDependentFeatures();
+            //Disable feature if should be disabled and currently enabled
+            if (!feature.getKey().enabled().contains(fightState) && feature.getValue()) {
+                feature.getKey().disable();
+                feature.setValue(false);
+            }
+        }
+        FightSWCommand.postFightStateChange();
    }

    public static boolean setup() {
-        return Setup.contains(getFightState());
+        return Setup.contains(fightState);
    }

    public static boolean ingame() {
-        return Ingame.contains(getFightState());
+        return Ingame.contains(fightState);
    }

    public static boolean infight() {
-        return getFightState() == RUNNING;
-    }
-
-    private static Set<FightState> complement(FightState first, FightState... remaining) {
-        EnumSet<FightState> excluded = EnumSet.of(first, remaining);
-        return immutable(EnumSet.complementOf(excluded));
-    }
-
-    private static Set<FightState> immutable(EnumSet<FightState> states) {
-        return Collections.unmodifiableSet(states);
+        return fightState == RUNNING;
    }
 }
@@ -1,5 +1,40 @@
+/*
+ *   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.states;

-@Deprecated
-public interface IStateDependent extends de.steamwar.gamecore.state.IStateDependent<FightState> {
+import java.util.Set;
+
+public interface IStateDependent {
+
+    /**
+     * @return returns a set containing
+     */
+    Set<FightState> enabled();
+
+    /**
+     * Enables the state dependent object
+     */
+    void enable();
+
+    /**
+     * Disables the state dependent object
+     */
+    void disable();
 }
@@ -1,22 +1,59 @@
+/*
+ *   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.states;

+import de.steamwar.fightsystem.ArenaMode;
 import de.steamwar.fightsystem.Config;
 import de.steamwar.fightsystem.winconditions.Winconditions;
-import de.steamwar.gamecore.GameConfig;

 import java.util.Set;

-@Deprecated
-public class OneShotStateDependent extends de.steamwar.gamecore.state.OneShotStateDependent<FightState> implements IStateDependent {
-    public OneShotStateDependent(Set<de.steamwar.gamecore.ArenaMode> modes, Set<FightState> states, Runnable runnable) {
-        super(FightState.lifecycle, modes, GameConfig.mode, states, runnable);
+public class OneShotStateDependent extends StateDependent {
+
+    private final Runnable runnable;
+
+    public OneShotStateDependent(Set<ArenaMode> mode, Set<FightState> states, Runnable runnable) {
+        super(mode, states);
+        this.runnable = runnable;
+        register();
    }

    public OneShotStateDependent(Winconditions wincondition, Set<FightState> states, Runnable runnable) {
-        this(Config.GameModeConfig.WinConditions.contains(wincondition), states, runnable);
+        super(Config.GameModeConfig.WinConditions.contains(wincondition), states);
+        this.runnable = runnable;
+        register();
    }

    public OneShotStateDependent(boolean active, Set<FightState> states, Runnable runnable) {
-        super(FightState.lifecycle, active, states, runnable);
+        super(active, states);
+        this.runnable = runnable;
+        register();
+    }
+
+    @Override
+    public void enable() {
+        runnable.run();
+    }
+
+    @Override
+    public void disable() {
+        //Do nothing, oneshot
    }
 }
@@ -1,22 +1,54 @@
+/*
+ *   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.states;

+import de.steamwar.fightsystem.ArenaMode;
 import de.steamwar.fightsystem.Config;
 import de.steamwar.fightsystem.winconditions.Winconditions;
-import de.steamwar.gamecore.GameConfig;

 import java.util.Set;

-@Deprecated
-public abstract class StateDependent extends de.steamwar.gamecore.state.StateDependent<FightState> implements IStateDependent {
+public abstract class StateDependent implements IStateDependent {
+
+    private final Set<FightState> enabled;
+    private final boolean register;
+
    protected StateDependent(Winconditions wincondition, Set<FightState> states) {
        this(Config.GameModeConfig.WinConditions.contains(wincondition), states);
    }

-    protected StateDependent(Set<de.steamwar.gamecore.ArenaMode> modes, Set<FightState> states) {
-        super(FightState.lifecycle, modes, GameConfig.mode, states);
+    protected StateDependent(Set<ArenaMode> mode, Set<FightState> states) {
+        this(mode.contains(Config.mode), states);
    }

    protected StateDependent(boolean enabled, Set<FightState> states) {
-        super(FightState.lifecycle, enabled, states);
+        this.enabled = states;
+        this.register = enabled;
+    }
+
+    public void register() {
+        if (register) FightState.registerStateDependent(this);
+    }
+
+    @Override
+    public Set<FightState> enabled() {
+        return enabled;
    }
 }
@@ -1,20 +0,0 @@
-package de.steamwar.fightsystem.states;
-
-import de.steamwar.fightsystem.FightSystem;
-import de.steamwar.gamecore.GameConfig;
-import net.md_5.bungee.api.ChatMessageType;
-import org.bukkit.command.CommandExecutor;
-
-import java.util.Set;
-
-@Deprecated
-public class StateDependentCommand extends de.steamwar.gamecore.state.StateDependentCommand<FightState> implements IStateDependent {
-    private static final CommandExecutor unavailable = (sender, cmd, label, args) -> {
-        FightSystem.getMessage().sendPrefixless("COMMAND_CURRENTLY_UNAVAILABLE", sender, ChatMessageType.ACTION_BAR);
-        return false;
-    };
-
-    public StateDependentCommand(Set<de.steamwar.gamecore.ArenaMode> modes, Set<FightState> states, String name, CommandExecutor executor) {
-        super(FightState.lifecycle, modes.contains(GameConfig.mode), states, FightSystem.getPlugin(), name, executor, unavailable);
-    }
-}
@@ -0,0 +1,70 @@
+/*
+ *   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.states;
+
+import de.steamwar.fightsystem.ArenaMode;
+import de.steamwar.fightsystem.Config;
+import de.steamwar.fightsystem.countdown.Countdown;
+import de.steamwar.fightsystem.winconditions.Winconditions;
+
+import java.util.Set;
+
+public class StateDependentCountdown extends StateDependent {
+
+    private static Countdown mainCountdown = null;
+
+    public static Countdown getMainCountdown() {
+        return mainCountdown;
+    }
+
+    private final Countdown countdown;
+
+    public StateDependentCountdown(Set<ArenaMode> mode, Set<FightState> states, Countdown countdown) {
+        super(mode, states);
+        this.countdown = countdown;
+        register();
+    }
+
+    public StateDependentCountdown(Winconditions wincondition, Set<FightState> states, Countdown countdown) {
+        this(Config.GameModeConfig.WinConditions.contains(wincondition), states, countdown);
+    }
+
+    public StateDependentCountdown(boolean active, Set<FightState> states, Countdown countdown) {
+        super(active, states);
+        this.countdown = countdown;
+        register();
+    }
+
+    public Countdown getCountdown() {
+        return countdown;
+    }
+
+    @Override
+    public void enable() {
+        mainCountdown = countdown;
+        countdown.enable();
+    }
+
+    @Override
+    public void disable() {
+        countdown.disable();
+        if (mainCountdown == countdown) mainCountdown = null;
+    }
+}
@@ -1,24 +1,63 @@
+/*
+ *   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.states;

+import de.steamwar.fightsystem.ArenaMode;
 import de.steamwar.fightsystem.Config;
 import de.steamwar.fightsystem.FightSystem;
 import de.steamwar.fightsystem.winconditions.Winconditions;
-import de.steamwar.gamecore.GameConfig;
+import org.bukkit.Bukkit;
+import org.bukkit.event.HandlerList;
 import org.bukkit.event.Listener;

 import java.util.Set;

-@Deprecated
-public class StateDependentListener extends de.steamwar.gamecore.state.StateDependentListener<FightState> implements IStateDependent {
+public class StateDependentListener extends StateDependent {
+
+    private final Listener listener;
+
    public StateDependentListener(Winconditions wincondition, Set<FightState> states, Listener listener) {
-        this(Config.GameModeConfig.WinConditions.contains(wincondition), states, listener);
+        super(Config.GameModeConfig.WinConditions.contains(wincondition), states);
+        this.listener = listener;
+        register();
    }

-    public StateDependentListener(boolean active, Set<FightState> states, Listener listener) {
-        super(FightState.lifecycle, active, states, FightSystem.getPlugin(), listener);
+    public StateDependentListener(boolean enabled, Set<FightState> states, Listener listener) {
+        super(enabled, states);
+        this.listener = listener;
+        register();
    }

-    public StateDependentListener(Set<de.steamwar.gamecore.ArenaMode> modes, Set<FightState> states, Listener listener) {
-        super(FightState.lifecycle, modes, GameConfig.mode, states, FightSystem.getPlugin(), listener);
+    public StateDependentListener(Set<ArenaMode> mode, Set<FightState> states, Listener listener) {
+        super(mode, states);
+        this.listener = listener;
+        register();
+    }
+
+    @Override
+    public void enable() {
+        Bukkit.getPluginManager().registerEvents(listener, FightSystem.getPlugin());
+    }
+
+    @Override
+    public void disable() {
+        HandlerList.unregisterAll(listener);
    }
 }
@@ -1,23 +1,69 @@
+/*
+ *   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.states;

+import de.steamwar.fightsystem.ArenaMode;
 import de.steamwar.fightsystem.Config;
 import de.steamwar.fightsystem.FightSystem;
 import de.steamwar.fightsystem.winconditions.Winconditions;
-import de.steamwar.gamecore.GameConfig;
+import org.bukkit.Bukkit;
+import org.bukkit.scheduler.BukkitTask;

 import java.util.Set;

-@Deprecated
-public class StateDependentTask extends de.steamwar.gamecore.state.StateDependentTask<FightState> implements IStateDependent {
+public class StateDependentTask extends StateDependent {
+
+    private final Runnable runnable;
+    private final long delay;
+    private final long period;
+
+    private BukkitTask task = null;
+
    public StateDependentTask(Winconditions wincondition, Set<FightState> states, Runnable runnable, long delay, long period) {
        this(Config.GameModeConfig.WinConditions.contains(wincondition), states, runnable, delay, period);
    }

-    public StateDependentTask(boolean active, Set<FightState> states, Runnable runnable, long delay, long period) {
-        super(FightState.lifecycle, active, states, FightSystem.getPlugin(), runnable, delay, period);
+    public StateDependentTask(boolean enabled, Set<FightState> states, Runnable runnable, long delay, long period) {
+        super(enabled, states);
+        this.runnable = runnable;
+        this.delay = delay;
+        this.period = period;
+        register();
    }

-    public StateDependentTask(Set<de.steamwar.gamecore.ArenaMode> modes, Set<FightState> states, Runnable runnable, long delay, long period) {
-        super(FightState.lifecycle, modes, GameConfig.mode, states, FightSystem.getPlugin(), runnable, delay, period);
+    public StateDependentTask(Set<ArenaMode> mode, Set<FightState> states, Runnable runnable, long delay, long period) {
+        super(mode, states);
+        this.runnable = runnable;
+        this.delay = delay;
+        this.period = period;
+        register();
    }
+
+    @Override
+    public void enable() {
+        task = Bukkit.getScheduler().runTaskTimer(FightSystem.getPlugin(), runnable, delay, period);
+    }
+
+    @Override
+    public void disable() {
+        task.cancel();
+    }
+
 }
@@ -19,12 +19,11 @@

 package de.steamwar.fightsystem.utils;

-import de.steamwar.gamecore.ArenaMode;
-import de.steamwar.gamecore.countdown.Countdown;
+import de.steamwar.fightsystem.ArenaMode;
 import de.steamwar.fightsystem.Config;
 import de.steamwar.fightsystem.fight.Fight;
 import de.steamwar.fightsystem.states.FightState;
-import de.steamwar.gamecore.state.StateDependentCountdown;
+import de.steamwar.fightsystem.states.StateDependentCountdown;
 import de.steamwar.fightsystem.states.StateDependentTask;
 import de.steamwar.linkage.Linked;
 import de.steamwar.network.NetworkSender;
@@ -42,7 +41,6 @@ public class BungeeFightInfo {
    }

    private void send() {
-        Countdown mainCountdown = StateDependentCountdown.getMainCountdown(FightState.lifecycle);
        NetworkSender.send(new FightInfoPacket(
                Config.world.getName(),
                Config.GameModeConfig.Schematic.Type.toDB(),
@@ -50,7 +48,7 @@ public class BungeeFightInfo {
                Fight.getBlueTeam().getColoredName(),
                Fight.getRedTeam().getColoredName(),
                FightState.getFightState().name(),
-                mainCountdown != null ? mainCountdown.getTimeLeft() : 0,
+                StateDependentCountdown.getMainCountdown() != null ? StateDependentCountdown.getMainCountdown().getTimeLeft() : 0,
                Fight.getBlueTeam().getLeader() != null ? Fight.getBlueTeam().getLeader().getUser().getId() : 0,
                Fight.getRedTeam().getLeader() != null ? Fight.getRedTeam().getLeader().getUser().getId() : 0,
                Fight.getBlueTeam().getSchematic(),
@@ -19,11 +19,10 @@

 package de.steamwar.fightsystem.utils;

-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.gamecore.countdown.Countdown;
+import de.steamwar.fightsystem.countdown.Countdown;
 import de.steamwar.fightsystem.fight.Fight;
 import de.steamwar.fightsystem.fight.FightPlayer;
 import de.steamwar.fightsystem.fight.FightTeam;
@@ -126,7 +125,7 @@ public class FightStatistics {
                savePlayerStats(fp, fightId);
            }

-            if (ArenaMode.Event.contains(GameConfig.mode)) {
+            if (ArenaMode.Event.contains(Config.mode)) {
                Config.EventKampf.setFight(fightId);
            }

@@ -20,8 +20,7 @@
 package de.steamwar.fightsystem.utils;

 import de.steamwar.core.TPSWatcher;
-import de.steamwar.gamecore.ArenaMode;
-import de.steamwar.gamecore.countdown.Countdown;
+import de.steamwar.fightsystem.ArenaMode;
 import de.steamwar.fightsystem.Config;
 import de.steamwar.fightsystem.FightSystem;
 import de.steamwar.fightsystem.fight.Fight;
@@ -29,7 +28,7 @@ import de.steamwar.fightsystem.fight.FightTeam;
 import de.steamwar.fightsystem.record.GlobalRecorder;
 import de.steamwar.fightsystem.states.FightState;
 import de.steamwar.fightsystem.states.OneShotStateDependent;
-import de.steamwar.gamecore.state.StateDependentCountdown;
+import de.steamwar.fightsystem.states.StateDependentCountdown;
 import de.steamwar.fightsystem.states.StateDependentTask;
 import de.steamwar.fightsystem.winconditions.Wincondition;
 import de.steamwar.linkage.Linked;
@@ -72,8 +71,7 @@ public class FightUI {
            totalHearts = 1.0;
        }

-        Countdown mainCountdown = StateDependentCountdown.getMainCountdown(FightState.lifecycle);
-        int timeLeft = mainCountdown != null ? mainCountdown.getTimeLeft() : 0;
+        int timeLeft = StateDependentCountdown.getMainCountdown() != null ? StateDependentCountdown.getMainCountdown().getTimeLeft() : 0;
        String time = "§7" + (timeLeft / 60) + "§8:§7" + (timeLeft % 60 < 10 ? "0" : "") + (timeLeft % 60);
        String bluePlayers = blue.getPrefix() + blue.getAlivePlayers() + "§8/§7" + blue.getPlayerCount();
        String redPlayers = red.getPrefix() + red.getAlivePlayers() + "§8/§7" + red.getPlayerCount();
@@ -29,7 +29,6 @@ import de.steamwar.fightsystem.fight.FightTeam;
 import de.steamwar.fightsystem.states.FightState;
 import de.steamwar.fightsystem.states.StateDependent;
 import de.steamwar.fightsystem.states.StateDependentListener;
-import de.steamwar.gamecore.GameConfig;
 import de.steamwar.techhider.AccessPrivilegeProvider;
 import de.steamwar.techhider.TechHider;
 import lombok.Getter;
@@ -59,7 +58,7 @@ import java.util.stream.Stream;

 public class TechHiderWrapper extends StateDependent implements Listener {

-    public static final boolean ENABLED = !Config.OnlyPublicSchematics && !GameConfig.test() && Config.GameModeConfig.Techhider.Active;
+    public static final boolean ENABLED = !Config.OnlyPublicSchematics && !Config.test() && Config.GameModeConfig.Techhider.Active;

    @Getter
    private final ConcurrentHashMap<Player, Region> hiddenRegion = new ConcurrentHashMap<>();
@@ -19,7 +19,7 @@

 package de.steamwar.fightsystem.winconditions;

-import de.steamwar.gamecore.ArenaMode;
+import de.steamwar.fightsystem.ArenaMode;
 import de.steamwar.fightsystem.fight.Fight;
 import de.steamwar.fightsystem.fight.FightTeam;
 import de.steamwar.fightsystem.states.FightState;
@@ -20,12 +20,10 @@
 package de.steamwar.fightsystem.winconditions;

 import de.steamwar.fightsystem.FightSystem;
+import de.steamwar.fightsystem.countdown.Countdown;
 import de.steamwar.fightsystem.fight.Fight;
 import de.steamwar.fightsystem.fight.FightTeam;
-import de.steamwar.fightsystem.states.FightState;
-import de.steamwar.gamecore.state.StateDependentCountdown;
-import de.steamwar.gamecore.countdown.Countdown;
-import de.steamwar.gamecore.wincondition.GameResult;
+import de.steamwar.fightsystem.states.StateDependentCountdown;
 import lombok.Getter;
 import org.bukkit.entity.Entity;
 import org.bukkit.entity.LivingEntity;
@@ -33,12 +31,13 @@ import org.bukkit.entity.LivingEntity;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.function.ToDoubleFunction;
+import java.util.stream.Collectors;

-public abstract class Wincondition implements de.steamwar.gamecore.wincondition.WinCondition<FightTeam> {
+public abstract class Wincondition {

    @Getter
    protected static WinconditionBasePercent percentWincondition = null;
-    protected static StateDependentCountdown<FightState> timeOverCountdown = null;
+    protected static StateDependentCountdown timeOverCountdown = null;
    @Getter
    protected static final List<PrintableWincondition> printableWinconditions = new ArrayList<>();

@@ -48,11 +47,6 @@ public abstract class Wincondition implements de.steamwar.gamecore.wincondition.
        this.windescription = windescription;
    }

-    @Override
-    public String id() {
-        return windescription;
-    }
-
    public static Countdown getTimeOverCountdown() {
        if (timeOverCountdown == null) return null;
        return timeOverCountdown.getCountdown();
@@ -69,12 +63,12 @@ public abstract class Wincondition implements de.steamwar.gamecore.wincondition.
    }

    protected void comparisonWin(ToDoubleFunction<FightTeam> evaluate, String winMessage, String tieMessage) {
-        GameResult<FightTeam> result = de.steamwar.gamecore.wincondition.WinConditions.winnerByScore(Fight.teams(), evaluate);
-        if (result instanceof GameResult.Winner<FightTeam> winner) {
-            FightTeam team = winner.getWinner();
-            win(team, winMessage, team.getColoredName());
-        } else {
+        double max = Fight.teams().stream().mapToDouble(evaluate).max().orElseThrow(() -> new SecurityException("No teams present"));
+        List<FightTeam> teams = Fight.teams().stream().filter(team -> evaluate.applyAsDouble(team) == max).collect(Collectors.toList());
+        if (teams.size() > 1) {
            win(null, tieMessage);
+        } else {
+            win(teams.get(0), winMessage, teams.get(0).getColoredName());
        }
    }
 }
@@ -23,7 +23,7 @@ import de.steamwar.fightsystem.Config;
 import de.steamwar.fightsystem.countdown.TimeOverCountdown;
 import de.steamwar.fightsystem.fight.FightTeam;
 import de.steamwar.fightsystem.states.FightState;
-import de.steamwar.gamecore.state.StateDependentCountdown;
+import de.steamwar.fightsystem.states.StateDependentCountdown;

 import java.util.function.ToDoubleFunction;

@@ -32,12 +32,7 @@ public abstract class WinconditionComparisonTimeout extends Wincondition {
    public WinconditionComparisonTimeout(Winconditions wincondition, String windescription, String winMessage, ToDoubleFunction<FightTeam> evaluate) {
        super(windescription);
        if (Config.GameModeConfig.WinConditions.contains(wincondition)) {
-            timeOverCountdown = new StateDependentCountdown<>(
-                    FightState.lifecycle,
-                    true,
-                    FightState.Running,
-                    new TimeOverCountdown(() -> comparisonWin(evaluate, winMessage, "WIN_TIME_OVER"))
-            );
+            timeOverCountdown = new StateDependentCountdown(wincondition, FightState.Running, new TimeOverCountdown(() -> comparisonWin(evaluate, winMessage, "WIN_TIME_OVER")));
        }
    }
 }
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Hut512	6d775cf4e0	merge upstream	2026-09-04 19:47:27 +02:00
Hut512	8bef779453	Fix SteamwarUser.setLocale	2026-09-04 19:45:42 +02:00
YoyoNow	8a7f65e000	Merge pull request 'Fix CRIU subserver stop' (#485 ) from Hut512/SteamWar:main into main Reviewed-on: SteamWar/SteamWar#485 Reviewed-by: YoyoNow <4+yoyonow@noreply.localhost>	2026-09-03 21:39:15 +02:00
Hut512	8401f67b24	Fix CRIU subserver stop	2026-09-03 02:24:49 +02:00
YoyoNow	362468e756	Fix SteamEditWand	2026-09-01 11:14:30 +02:00
YoyoNow	ece12df0bc	Add SteamEdit	2026-09-01 10:32:56 +02:00
YoyoNow	f35c07ab5b	Fix EventStarter	2026-08-30 16:12:32 +02:00
YoyoNow	549f7e555c	Remove NoTeamServer punishment	2026-08-30 13:04:52 +02:00
YoyoNow	859238d7fa	Disable 'showtable' in EventCommand	2026-08-30 12:25:34 +02:00
YoyoNow	a79b00f78f	Fix EventCommand	2026-08-30 12:23:23 +02:00
YoyoNow	105eda32e6	Update CustomMap	2026-08-30 12:15:22 +02:00
YoyoNow	b4487b8079	Update doc comment	2026-08-30 12:00:40 +02:00
YoyoNow	ea3aad3bd2	Initial FightSWCommand	2026-08-29 12:52:09 +02:00
YoyoNow	d307f890e2	Remove debug output	2026-08-26 22:35:39 +02:00
YoyoNow	97c1da1b2a	Add debug output	2026-08-26 22:31:30 +02:00
YoyoNow	8a53aecfac	Add debug output	2026-08-26 22:26:43 +02:00
YoyoNow	5236afba17	Add debug output	2026-08-26 22:17:33 +02:00
YoyoNow	d3c8b6e1c6	Add debug output	2026-08-26 22:12:53 +02:00
YoyoNow	00ea792eee	Merge pull request 'Improve AutoChecker and GameModeConfig again' (#478 ) from AutoChecker into main Reviewed-on: SteamWar/SteamWar#478	2026-08-26 22:05:31 +02:00
YoyoNow	38e845b0e4	Improve AutoChecker and GameModeConfig again	2026-08-26 21:46:45 +02:00
YoyoNow	c60a8caed8	Merge pull request 'Improve items for GameModeConfig' (#476 ) from AutoChecker into main Reviewed-on: SteamWar/SteamWar#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 Reviewed-on: SteamWar/SteamWar#477 Reviewed-by: sakziea <59+sakziea@noreply.localhost>	2026-08-25 16:57:04 +02:00
YoyoNow	6476125a3f	Add ServerLinks to login	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	2026-08-24 20:05:58 +02:00
YoyoNow	72b70a62e1	Fix CustomItem	2026-08-19 12:05:09 +02:00
YoyoNow	8575dcac33	Add WindCharge option to LaunchScript	2026-08-19 11:06:34 +02:00
YoyoNow	cb744f6aa0	Add AntiPlayerCollision	2026-08-18 10:48:16 +02:00
YoyoNow	227f63c9ff	Add AntiPlayerCollision	2026-08-18 10:39:58 +02:00
YoyoNow	397b10c319	Merge pull request 'Velocity core /event command' (#465 ) from VelocityCore/EventCommand into main Reviewed-on: SteamWar/SteamWar#465 Reviewed-by: YoyoNow <4+yoyonow@noreply.localhost>	2026-08-14 07:53:43 +02:00
YoyoNow	32569f19d9	Closes: #468	2026-08-13 10:09:13 +02:00
YoyoNow	f19e4158e7	Fix Check	2026-08-13 10:01:55 +02:00
YoyoNow	6c46b5b2a2	Fix Check	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 Reviewed-on: SteamWar/SteamWar#454 Reviewed-by: Chaoscaot <max@chaoscaot.de>	2026-08-13 09:50:14 +02:00
YoyoNow	683236bb59	Fix TexturePackSystem for newer versions	2026-08-13 09:39:42 +02:00
YoyoNow	8dc101639d	Add alias of `/tick rate` to `/tick rate 20`	2026-08-11 21:48:28 +02:00
YoyoNow	792620804a	Improve TPSSystem	2026-08-11 21:46:38 +02:00
YoyoNow	4aa7c99a6e	Fix Check and CheckCommand permission	2026-08-11 21:05:36 +02:00
Sakziea	cce18124f2	Remove unused translation	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 Reviewed-on: SteamWar/SteamWar#444 Reviewed-by: YoyoNow <4+yoyonow@noreply.localhost>	2026-07-26 10:22:42 +02:00
Chaoscaot	ae898e14c2	Merge branch 'main' into swui/flows	2026-07-26 10:20:35 +02:00
Chaoscaot	726f73cc45	Merge branch 'main' into VelocityCore/DeleteMemberOfBauDeletingPlayerData	2026-07-26 03:04:45 +02:00
YoyoNow	64e627514d	Add deletion of PlayerData on /bau delmember	2026-07-17 09:47:40 +02:00
Chaoscaot	3a247de43d	Replace Custom Observer with kotlinx StateFlows Signed-off-by: Chaoscaot <max@maxsp.de>	2026-07-06 01:13:05 +02:00