Merge branch 'main' into FightSystem/tech-hider-hardening

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

@@ -19,7 +19,6 @@
 
 package de.steamwar.fightsystem;
 
-import de.steamwar.sql.GameModeConfig;
 import de.steamwar.data.GameModeConfigUtils;
 import de.steamwar.fightsystem.utils.Region;
 import de.steamwar.fightsystem.winconditions.Winconditions;

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

@@ -23,7 +23,6 @@ import com.sk89q.worldedit.extent.clipboard.Clipboard;
 import de.steamwar.fightsystem.Config;
 import de.steamwar.fightsystem.fight.FightTeam;
 import de.steamwar.fightsystem.states.FightState;
-import de.steamwar.fightsystem.utils.FightStatistics;
 import de.steamwar.sql.SchematicNode;
 import de.steamwar.sql.SteamwarUser;
 

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

@@ -42,7 +42,6 @@ import org.bukkit.event.inventory.ClickType;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.UUID;
-import java.util.function.Consumer;
 import java.util.stream.Collectors;
 
 public class GUI {

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

@@ -25,7 +25,6 @@ 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.fightsystem.utils.FightStatistics;
 import de.steamwar.linkage.Linked;
 import de.steamwar.sql.SchematicNode;
 import de.steamwar.sql.SteamwarUser;

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

@@ -26,7 +26,10 @@ import de.steamwar.fightsystem.fight.FightTeam;
 import de.steamwar.fightsystem.states.FightState;
 import de.steamwar.fightsystem.states.StateDependentCommand;
 import de.steamwar.linkage.Linked;
-import de.steamwar.sql.*;
+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;

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

@@ -17,7 +17,6 @@
 
 package de.steamwar.fightsystem.commands;
 
-import de.steamwar.core.TPSWarpUtils;
 import de.steamwar.fightsystem.ArenaMode;
 import de.steamwar.fightsystem.FightSystem;
 import de.steamwar.fightsystem.states.FightState;

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

@@ -19,7 +19,6 @@
 
 package de.steamwar.fightsystem.fight;
 
-import de.steamwar.Reflection;
 import de.steamwar.fightsystem.Config;
 import de.steamwar.fightsystem.FightSystem;
 import de.steamwar.fightsystem.commands.Commands;

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

@@ -19,8 +19,8 @@
 
 package de.steamwar.fightsystem.listener;
 
-import de.steamwar.Reflection;
 import com.comphenix.tinyprotocol.TinyProtocol;
+import de.steamwar.Reflection;
 import de.steamwar.core.Core;
 import de.steamwar.fightsystem.Config;
 import de.steamwar.fightsystem.utils.CraftbukkitWrapper;

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

@@ -22,7 +22,6 @@ package de.steamwar.fightsystem.listener;
 import de.steamwar.fightsystem.Config;
 import de.steamwar.fightsystem.FightSystem;
 import de.steamwar.fightsystem.fight.Fight;
-import de.steamwar.fightsystem.fight.FightPlayer;
 import de.steamwar.fightsystem.fight.Kit;
 import de.steamwar.fightsystem.states.FightState;
 import de.steamwar.fightsystem.states.StateDependentListener;
@@ -35,10 +34,12 @@ import org.bukkit.entity.HumanEntity;
 import org.bukkit.entity.Player;
 import org.bukkit.event.EventHandler;
 import org.bukkit.event.Listener;
-import org.bukkit.event.inventory.*;
+import org.bukkit.event.inventory.InventoryClickEvent;
+import org.bukkit.event.inventory.InventoryCloseEvent;
+import org.bukkit.event.inventory.InventoryOpenEvent;
+import org.bukkit.event.inventory.InventoryType;
 import org.bukkit.event.player.PlayerMoveEvent;
 import org.bukkit.event.player.PlayerQuitEvent;
-import org.bukkit.inventory.ItemStack;
 
 import java.util.HashMap;
 import java.util.Map;

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

@@ -19,8 +19,8 @@
 
 package de.steamwar.fightsystem.listener;
 
-import de.steamwar.Reflection;
 import com.comphenix.tinyprotocol.TinyProtocol;
+import de.steamwar.Reflection;
 import de.steamwar.core.TrickyTrialsWrapper;
 import de.steamwar.fightsystem.ArenaMode;
 import de.steamwar.fightsystem.FightSystem;

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

@@ -19,9 +19,16 @@
 
 package de.steamwar.fightsystem.listener;
 
-import java.util.HashSet;
-import java.util.Set;
-
+import com.comphenix.tinyprotocol.TinyProtocol;
+import com.mojang.authlib.GameProfile;
+import de.steamwar.core.ProtocolWrapper;
+import de.steamwar.fightsystem.ArenaMode;
+import de.steamwar.fightsystem.Config;
+import de.steamwar.fightsystem.fight.Fight;
+import de.steamwar.fightsystem.fight.FightPlayer;
+import de.steamwar.fightsystem.states.FightState;
+import de.steamwar.fightsystem.states.StateDependentListener;
+import de.steamwar.fightsystem.states.StateDependentTask;
 import de.steamwar.linkage.Linked;
 import org.bukkit.Bukkit;
 import org.bukkit.GameMode;
@@ -33,17 +40,8 @@ import org.bukkit.event.player.PlayerGameModeChangeEvent;
 import org.bukkit.event.player.PlayerJoinEvent;
 import org.bukkit.event.player.PlayerQuitEvent;
 
-import com.comphenix.tinyprotocol.TinyProtocol;
-import com.mojang.authlib.GameProfile;
-
-import de.steamwar.core.ProtocolWrapper;
-import de.steamwar.fightsystem.ArenaMode;
-import de.steamwar.fightsystem.Config;
-import de.steamwar.fightsystem.fight.Fight;
-import de.steamwar.fightsystem.fight.FightPlayer;
-import de.steamwar.fightsystem.states.FightState;
-import de.steamwar.fightsystem.states.StateDependentListener;
-import de.steamwar.fightsystem.states.StateDependentTask;
+import java.util.HashSet;
+import java.util.Set;
 
 @Linked
 public class Spectator implements Listener {

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

@@ -19,12 +19,6 @@
 
 package de.steamwar.fightsystem.listener;
 
-import org.bukkit.entity.Player;
-import org.bukkit.event.EventHandler;
-import org.bukkit.event.Listener;
-import org.bukkit.event.player.PlayerJoinEvent;
-import org.bukkit.event.player.PlayerQuitEvent;
-
 import de.steamwar.fightsystem.ArenaMode;
 import de.steamwar.fightsystem.Config;
 import de.steamwar.fightsystem.events.BoardingEvent;
@@ -37,6 +31,11 @@ import de.steamwar.fightsystem.fight.FightTeam;
 import de.steamwar.fightsystem.states.FightState;
 import de.steamwar.fightsystem.states.OneShotStateDependent;
 import de.steamwar.fightsystem.states.StateDependentListener;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.player.PlayerJoinEvent;
+import org.bukkit.event.player.PlayerQuitEvent;
 
 public class TeamArea implements Listener {
 

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

@@ -19,17 +19,35 @@
 
 package de.steamwar.fightsystem.listener;
 
-import de.steamwar.core.VersionDependent;
-import de.steamwar.fightsystem.FightSystem;
+import de.steamwar.fightsystem.Config;
+import de.steamwar.fightsystem.states.FightState;
+import de.steamwar.fightsystem.states.StateDependentTask;
 import de.steamwar.linkage.Linked;
+import org.bukkit.Location;
+import org.bukkit.entity.WindCharge;
 
 @Linked
 public class WindchargeStopper {
 
-    static {
-        VersionDependent.getVersionImpl(FightSystem.getPlugin());
+    public WindchargeStopper() {
+        new StateDependentTask(true, FightState.Running, this::run, 1, 1);
     }
 
-    public interface IWindchargeStopper {
+    private static final int middleLine = Config.SpecSpawn.getBlockZ();
+
+    private static final Class<?> windChargeClass = WindCharge.class;
+
+    private void run() {
+        Recording.iterateOverEntities(windChargeClass::isInstance, entity -> {
+            Location location = entity.getLocation();
+            Location prevLocation = location.clone().subtract(entity.getVelocity());
+
+            boolean passedMiddle = location.getBlockZ() > middleLine && prevLocation.getBlockZ() > middleLine ||
+                    location.getBlockZ() < middleLine && prevLocation.getBlockZ() < middleLine;
+
+            if(!passedMiddle) {
+                entity.remove();
+            }
+        });
     }
 }

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

@@ -25,7 +25,9 @@ import de.steamwar.fightsystem.states.StateDependent;
 import de.steamwar.linkage.Linked;
 import org.bukkit.Bukkit;
 
-import java.io.*;
+import java.io.BufferedOutputStream;
+import java.io.DataOutputStream;
+import java.io.IOException;
 import java.net.Socket;
 import java.util.logging.Level;
 

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

@@ -329,7 +329,7 @@ public class PacketProcessor implements Listener {
 
         ItemStack stack = new ItemStack(Material.valueOf(item.replace("minecraft:", "").toUpperCase()), 1);
         if(enchanted)
-            stack.addUnsafeEnchantment(Enchantment.DURABILITY, 1);
+            stack.addUnsafeEnchantment(Enchantment.UNBREAKING, 1);
 
         Object slot;
         switch(slotName){

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

@@ -19,29 +19,63 @@
 
 package de.steamwar.fightsystem.utils;
 
+import com.comphenix.tinyprotocol.TinyProtocol;
+import com.mojang.authlib.GameProfile;
 import de.steamwar.Reflection;
-import de.steamwar.core.VersionDependent;
+import de.steamwar.core.ProtocolWrapper;
 import de.steamwar.fightsystem.FightSystem;
+import net.minecraft.core.BlockPos;
+import net.minecraft.server.level.ServerLevel;
+import net.minecraft.world.level.block.state.BlockState;
+import org.bukkit.GameMode;
 import org.bukkit.Material;
 import org.bukkit.World;
 import org.bukkit.block.Block;
+import org.bukkit.craftbukkit.CraftWorld;
+import org.bukkit.craftbukkit.block.CraftBlockState;
+import org.bukkit.craftbukkit.util.CraftMagicNumbers;
 import org.bukkit.entity.Entity;
 import org.bukkit.entity.Player;
 
-public interface BlockIdWrapper {
-    Class<?> worldServer = Reflection.getClass("net.minecraft.server.level.ServerLevel");
-    Reflection.Method getWorldHandle = Reflection.getTypedMethod(Reflection.getClass("org.bukkit.craftbukkit.CraftWorld"), "getHandle", worldServer);
+public class BlockIdWrapper {
+    public static final Class<?> worldServer = Reflection.getClass("net.minecraft.server.level.ServerLevel");
+    public static final Reflection.Method getWorldHandle = Reflection.getTypedMethod(Reflection.getClass("org.bukkit.craftbukkit.CraftWorld"), "getHandle", worldServer);
 
-    Class<?> craftPlayer = Reflection.getClass("org.bukkit.craftbukkit.entity.CraftPlayer");
-    Class<?> entityPlayer = Reflection.getClass("net.minecraft.server.level.ServerPlayer");
-    Reflection.Method getPlayer = Reflection.getTypedMethod(craftPlayer, "getHandle", entityPlayer);
+    public static final Class<?> craftPlayer = Reflection.getClass("org.bukkit.craftbukkit.entity.CraftPlayer");
+    public static final Class<?> entityPlayer = Reflection.getClass("net.minecraft.server.level.ServerPlayer");
+    public static final Reflection.Method getPlayer = Reflection.getTypedMethod(craftPlayer, "getHandle", entityPlayer);
 
-    BlockIdWrapper impl = VersionDependent.getVersionImpl(FightSystem.getPlugin());
+    public static final BlockIdWrapper impl = new BlockIdWrapper();
 
-    Material idToMaterial(int blockState);
-    int blockToId(Block block);
-    void setBlock(World world, int x, int y, int z, int blockState);
+    public Material idToMaterial(int blockState) {
+        return CraftMagicNumbers.getMaterial(net.minecraft.world.level.block.Block.stateById(blockState)).getItemType();
+    }
 
-    void trackEntity(Player player, Entity entity);
-    void untrackEntity(Player player, Entity entity);
+    public int blockToId(Block block) {
+        return net.minecraft.world.level.block.Block.getId(((CraftBlockState) block.getState()).getHandle());
+    }
+
+    public void setBlock(World world, int x, int y, int z, int blockState) {
+        BlockState blockData = net.minecraft.world.level.block.Block.stateById(blockState);
+        ServerLevel level = ((CraftWorld) world).getHandle();
+        BlockPos pos = new BlockPos(x, y, z);
+
+        level.removeBlockEntity(pos);
+        level.setBlock(pos, blockData, blockState);
+        level.getChunkSource().blockChanged(pos);
+    }
+
+    public void trackEntity(Player player, Entity entity) {
+        if(entity instanceof Player)
+            TinyProtocol.instance.sendPacket(player, ProtocolWrapper.impl.playerInfoPacketConstructor(ProtocolWrapper.PlayerInfoAction.REMOVE, new GameProfile(entity.getUniqueId(), entity.getName()), GameMode.CREATIVE));
+
+        player.showEntity(FightSystem.getPlugin(), entity);
+    }
+
+    public void untrackEntity(Player player, Entity entity) {
+        player.hideEntity(FightSystem.getPlugin(), entity);
+
+        if(entity instanceof Player)
+            TinyProtocol.instance.sendPacket(player, ProtocolWrapper.impl.playerInfoPacketConstructor(ProtocolWrapper.PlayerInfoAction.ADD, new GameProfile(entity.getUniqueId(), entity.getName()), GameMode.CREATIVE));
+    }
 }

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

@@ -19,31 +19,143 @@
 
 package de.steamwar.fightsystem.utils;
 
-import de.steamwar.core.VersionDependent;
-import de.steamwar.fightsystem.FightSystem;
+import de.steamwar.Reflection;
+import de.steamwar.fightsystem.fight.Fight;
 import de.steamwar.fightsystem.fight.FightTeam;
-import org.bukkit.World;
+import de.steamwar.fightsystem.listener.Recording;
+import de.steamwar.fightsystem.record.GlobalRecorder;
+import org.bukkit.*;
+import org.bukkit.attribute.Attribute;
+import org.bukkit.attribute.AttributeInstance;
+import org.bukkit.boss.BarColor;
+import org.bukkit.boss.BarStyle;
+import org.bukkit.boss.BossBar;
 import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
 import org.bukkit.event.Listener;
+import org.bukkit.event.player.PlayerPickupArrowEvent;
+import org.bukkit.event.player.PlayerSwapHandItemsEvent;
 import org.bukkit.scoreboard.Team;
 
-public interface BountifulWrapper {
-    BountifulWrapper impl = VersionDependent.getVersionImpl(FightSystem.getPlugin());
+import java.util.HashMap;
+import java.util.Map;
 
-    boolean mainHand(Object packet);
-    boolean bowInHand(boolean mainHand, Player p);
+public class BountifulWrapper {
+    public static final BountifulWrapper impl = new BountifulWrapper();
 
-    void setAttackSpeed(Player player);
+    private static final Class<?> enumHand = Reflection.getClass("net.minecraft.world.InteractionHand");
+    private static final Object mainHand = enumHand.getEnumConstants()[0];
+    private static final Reflection.Field<?> blockPlaceHand = Reflection.getField(Recording.blockPlacePacket, enumHand, 0);
 
-    void setNametagVisibility(Team team);
+    public boolean mainHand(Object packet) {
+        return blockPlaceHand.get(packet) == mainHand;
+    }
 
-    Listener newDenyArrowPickupListener();
-    Listener newDenyHandSwapListener();
+    public boolean bowInHand(boolean mainHand, Player p) {
+        return (mainHand ? p.getInventory().getItemInMainHand() : p.getInventory().getItemInOffHand()).getType() == Material.BOW;
+    }
 
-    void recordHandItems(Player player);
-    Listener newHandSwapRecorder();
+    public void setAttackSpeed(Player player) {
+        AttributeInstance attribute = player.getAttribute(Attribute.ATTACK_SPEED);
+        attribute.setBaseValue(16);
+    }
 
-    void spawnParticle(World world, String particleName, double x, double y, double z);
+    public void setNametagVisibility(Team team) {
+        team.setOption(Team.Option.NAME_TAG_VISIBILITY, Team.OptionStatus.FOR_OWN_TEAM);
+    }
 
-    void sendBar(Player player, FightTeam team, double progress, String text);
+    public Listener newDenyArrowPickupListener() {
+        return new Listener() {
+            @EventHandler
+            public void onArrowPickup(PlayerPickupArrowEvent e){
+                if(Fight.fighting(e.getPlayer()))
+                    e.setCancelled(true);
+            }
+        };
+    }
+
+    public Listener newDenyHandSwapListener() {
+        return new Listener() {
+            @EventHandler
+            public void onSwapItems(PlayerSwapHandItemsEvent event) {
+                if(Fight.fighting(event.getPlayer()))
+                    event.setCancelled(true);
+            }
+        };
+    }
+
+    public void recordHandItems(Player player) {
+        GlobalRecorder.getInstance().item(player, Recording.disarmNull(player.getInventory().getItemInMainHand()), "MAINHAND");
+        GlobalRecorder.getInstance().item(player, Recording.disarmNull(player.getInventory().getItemInOffHand()), "OFFHAND");
+    }
+
+    public Listener newHandSwapRecorder() {
+        return new Listener() {
+            @EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
+            public void onItemSwap(PlayerSwapHandItemsEvent e){
+                if(Recording.isNotSent(e.getPlayer()))
+                    return;
+
+                Player player = e.getPlayer();
+                GlobalRecorder.getInstance().item(player, Recording.disarmNull(e.getMainHandItem()), "MAINHAND");
+                GlobalRecorder.getInstance().item(player, Recording.disarmNull(e.getOffHandItem()), "OFFHAND");
+            }
+        };
+    }
+
+    public void spawnParticle(World world, String particleName, double x, double y, double z) {
+        world.spawnParticle(Particle.valueOf(particleName), x, y, z, 1);
+    }
+
+    private final Map<Player, BossBar> barMap = new HashMap<>();
+    public void sendBar(Player player, FightTeam team, double progress, String text) {
+        barMap.keySet().removeIf(p -> !p.isOnline());
+
+        if(!barMap.containsKey(player)) {
+            BossBar bar = Bukkit.createBossBar(player.getName(), BarColor.WHITE, BarStyle.SOLID);
+            barMap.put(player, bar);
+            bar.addPlayer(player);
+        }
+
+        BossBar bar = barMap.get(player);
+        BarColor color = chat2bar(team.getColor());
+        if(bar.getColor() != color)
+            bar.setColor(color);
+
+        if(bar.getProgress() != progress)
+            bar.setProgress(progress);
+
+        if(!bar.getTitle().equals(text))
+            bar.setTitle(text);
+    }
+
+    private BarColor chat2bar(ChatColor color) {
+        switch(color) {
+            case DARK_BLUE:
+            case DARK_AQUA:
+            case BLUE:
+            case AQUA:
+                return BarColor.BLUE;
+            case GREEN:
+            case DARK_GREEN:
+                return BarColor.GREEN;
+            case DARK_RED:
+            case RED:
+                return BarColor.RED;
+            case DARK_PURPLE:
+                return BarColor.PURPLE;
+            case GOLD:
+            case YELLOW:
+                return BarColor.YELLOW;
+            case LIGHT_PURPLE:
+                return BarColor.PINK;
+            case BLACK:
+            case WHITE:
+            case GRAY:
+            case DARK_GRAY:
+            default:
+                return BarColor.WHITE;
+        }
+    }
 }

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

@@ -19,20 +19,65 @@
 
 package de.steamwar.fightsystem.utils;
 
-import de.steamwar.core.VersionDependent;
-import de.steamwar.fightsystem.FightSystem;
+import de.steamwar.Reflection;
+import de.steamwar.fightsystem.Config;
+import net.minecraft.core.BlockPos;
+import net.minecraft.server.level.ServerLevel;
+import net.minecraft.world.level.chunk.LevelChunk;
+import net.minecraft.world.level.chunk.LevelChunkSection;
+import net.minecraft.world.level.entity.LevelEntityGetter;
+import org.bukkit.Chunk;
+import org.bukkit.GameRule;
 import org.bukkit.World;
+import org.bukkit.craftbukkit.CraftWorld;
 import org.bukkit.entity.Entity;
 
+import java.util.HashSet;
+import java.util.Set;
 import java.util.stream.Stream;
+import java.util.stream.StreamSupport;
 
-public interface CraftbukkitWrapper {
-    CraftbukkitWrapper impl = VersionDependent.getVersionImpl(FightSystem.getPlugin());
+public class CraftbukkitWrapper {
+    public static final CraftbukkitWrapper impl = new CraftbukkitWrapper();
 
-    void resetChunk(World world, World backup, int x, int z);
-    float headRotation(Entity e);
+    private static final Reflection.Method getWorld = Reflection.getMethod(Reflection.getClass("org.bukkit.craftbukkit.CraftWorld"), "getHandle");
+    private static final Reflection.Method getChunk = Reflection.getTypedMethod(ServerLevel.class, null, LevelChunk.class, int.class, int.class);
+    private static final Reflection.Method getChunkSections = Reflection.getTypedMethod(LevelChunk.class, null, LevelChunkSection[].class);
+    private LevelChunkSection[] getChunkSections(World world, int x, int z) {
+        return (LevelChunkSection[]) getChunkSections.invoke(getChunk.invoke(getWorld.invoke(world), x, z));
+    }
 
-    Stream<?> entityIterator();
+    private static final Reflection.Method getEntity = Reflection.getTypedMethod(Reflection.getClass("org.bukkit.craftbukkit.entity.CraftEntity"), "getHandle", net.minecraft.world.entity.Entity.class);
+    protected net.minecraft.world.entity.Entity getEntity(Entity e) {
+        return (net.minecraft.world.entity.Entity) getEntity.invoke(e);
+    }
 
-    void setupGamerule();
+    public float headRotation(Entity e) {
+        return getEntity(e).getYHeadRot();
+    }
+
+    private static final Reflection.Method getWorldEntities = Reflection.getTypedMethod(ServerLevel.class, null, LevelEntityGetter.class);
+    private static final Reflection.Method getIterable = Reflection.getTypedMethod(LevelEntityGetter.class, null, Iterable.class);
+    public Stream<?> entityIterator() {
+        return StreamSupport.stream(((Iterable<?>) getIterable.invoke(getWorldEntities.invoke(getWorld.invoke(Config.world)))).spliterator(), false);
+    }
+
+    public void setupGamerule() {
+        Config.world.setGameRule(GameRule.LOCATOR_BAR, false);
+    }
+
+    private LevelChunk getChunk(World world, int x, int z) {
+        return ((CraftWorld) world).getHandle().getChunk(x, z);
+    }
+
+    public void resetChunk(World world, World backup, int x, int z) {
+        LevelChunk worldChunk = getChunk(world, x, z);
+        LevelChunk backupChunk = getChunk(backup, x, z);
+        LevelChunkSection[] sections = worldChunk.getSections();
+        System.arraycopy(backupChunk.getSections(), 0, sections, 0, sections.length);
+        Set<BlockPos> blocks = new HashSet<>(worldChunk.blockEntities.keySet());
+        blocks.stream().filter(key -> !backupChunk.blockEntities.containsKey(key)).forEach(worldChunk::removeBlockEntity);
+        worldChunk.heightmaps.clear();
+        worldChunk.heightmaps.putAll(backupChunk.heightmaps);
+    }
 }

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

@@ -19,36 +19,87 @@
 
 package de.steamwar.fightsystem.utils;
 
-import de.steamwar.core.VersionDependent;
-import de.steamwar.fightsystem.FightSystem;
 import org.bukkit.DyeColor;
 import org.bukkit.Material;
 import org.bukkit.World;
 import org.bukkit.block.Block;
+import org.bukkit.block.data.BlockData;
+import org.bukkit.block.data.Waterlogged;
+import org.bukkit.block.data.type.Dispenser;
 import org.bukkit.entity.Player;
+import org.bukkit.entity.Pose;
 import org.bukkit.event.block.BlockPhysicsEvent;
 import org.bukkit.inventory.ItemStack;
+import org.bukkit.inventory.meta.BlockDataMeta;
 import org.bukkit.inventory.meta.ItemMeta;
 
-public interface FlatteningWrapper {
-    FlatteningWrapper impl = VersionDependent.getVersionImpl(FightSystem.getPlugin());
+public class FlatteningWrapper {
+    public static final FlatteningWrapper impl = new FlatteningWrapper();
 
-    DyeColor getSilver();
+    public DyeColor getSilver() {
+        return DyeColor.LIGHT_GRAY;
+    }
 
-    boolean isWater(Block block);
-    boolean removeWater(Block block);
+    public boolean isWater(Block block) {
+        if(block.getType() == Material.WATER)
+            return true;
 
-    boolean containsBlockMeta(ItemMeta meta);
-    boolean hasAttributeModifier(ItemStack stack);
+        BlockData data = block.getBlockData();
+        if(!(data instanceof Waterlogged))
+            return false;
 
-    boolean doRecord(BlockPhysicsEvent e);
+        return ((Waterlogged) data).isWaterlogged();
+    }
 
-    void forceLoadChunk(World world, int cX, int cZ);
+    public boolean removeWater(Block block) {
+        Material type = block.getType();
+        if(type == Material.WATER || type == Material.LAVA){
+            block.setType(Material.AIR);
+            return true;
+        }
 
-    boolean checkPistonMoving(Block block);
+        BlockData data = block.getBlockData();
+        if(!(data instanceof Waterlogged))
+            return false;
 
-    boolean isFacingWater(Block dispenser);
+        Waterlogged waterlogged = (Waterlogged) data;
+        if(waterlogged.isWaterlogged()){
+            block.setType(Material.AIR);
+            return true;
+        }
 
-    boolean isCrouching(Player player);
-    void sendBlockChange(Player player, Block block, Material type);
+        return false;
+    }
+
+    public boolean containsBlockMeta(ItemMeta meta) {
+        return meta instanceof BlockDataMeta && ((BlockDataMeta)meta).hasBlockData();
+    }
+
+    public boolean hasAttributeModifier(ItemStack stack) {
+        return stack.hasItemMeta() && stack.getItemMeta() != null && stack.getItemMeta().hasAttributeModifiers();
+    }
+
+    public boolean doRecord(BlockPhysicsEvent e) {
+        return e.getBlock() == e.getSourceBlock() || e.getChangedType() == Material.AIR;
+    }
+
+    public void forceLoadChunk(World world, int cX, int cZ) {
+        world.setChunkForceLoaded(cX, cZ, true);
+    }
+
+    public boolean checkPistonMoving(Block block) {
+        return block.getType() == Material.MOVING_PISTON;
+    }
+
+    public boolean isFacingWater(Block dispenser) {
+        return dispenser.getRelative(((Dispenser) dispenser.getBlockData()).getFacing()).isLiquid();
+    }
+
+    public boolean isCrouching(Player player) {
+        return player.getPose() == Pose.SWIMMING;
+    }
+
+    public void sendBlockChange(Player player, Block block, Material type) {
+        player.sendBlockChange(block.getLocation(), type.createBlockData());
+    }
 }

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

@@ -19,8 +19,8 @@
 
 package de.steamwar.fightsystem.utils;
 
-import de.steamwar.Reflection;
 import com.comphenix.tinyprotocol.TinyProtocol;
+import de.steamwar.Reflection;
 import de.steamwar.core.Core;
 import de.steamwar.entity.REntity;
 import de.steamwar.fightsystem.Config;
@@ -49,7 +49,6 @@ import org.bukkit.event.player.PlayerJoinEvent;
 import org.bukkit.event.player.PlayerQuitEvent;
 
 import java.util.HashMap;
-import java.util.List;
 import java.util.Map;
 import java.util.Objects;
 import java.util.function.BiFunction;

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

@@ -19,13 +19,54 @@
 
 package de.steamwar.fightsystem.utils;
 
-import de.steamwar.core.VersionDependent;
-import de.steamwar.fightsystem.FightSystem;
+import de.steamwar.Reflection;
+import de.steamwar.fightsystem.Config;
+import it.unimi.dsi.fastutil.shorts.Short2ObjectArrayMap;
+import net.minecraft.core.BlockPos;
+import net.minecraft.core.SectionPos;
+import net.minecraft.network.protocol.game.ClientboundBlockUpdatePacket;
+import net.minecraft.network.protocol.game.ClientboundSectionBlocksUpdatePacket;
+import net.minecraft.world.level.block.state.BlockState;
 
 import java.util.List;
 
-public interface HullHiderWrapper {
-    HullHiderWrapper impl = VersionDependent.getVersionImpl(FightSystem.getPlugin());
+public class HullHiderWrapper {
+    public static final HullHiderWrapper impl = new HullHiderWrapper();
 
-    Object generateBlockChangePacket(List<Hull.IntVector> changes);
+    private static final Reflection.Method getState = Reflection.getTypedMethod(Reflection.getClass("org.bukkit.craftbukkit.block.data.CraftBlockData"), "getState", BlockState.class);
+    public Object generateBlockChangePacket(List<Hull.IntVector> changes) {
+        Object[] blockdata = new Object[changes.size()];
+        for(int i = 0; i < blockdata.length; i++) {
+            Hull.IntVector change = changes.get(i);
+            blockdata[i] = getState.invoke(Config.world.getBlockData(change.getX(), change.getY(), change.getZ()));
+        }
+
+        return generateBlockChangePacket(changes, blockdata);
+    }
+
+    private Object generateBlockChangePacket(List<Hull.IntVector> changes, Object[] blockdata) {
+        if(changes.size() > 1) {
+            Hull.IntVector section = changes.get(0);
+            section = new Hull.IntVector(section.getX() >> 4, section.getY() >> 4, section.getZ() >> 4);
+            int xOffset = 16*section.getX();
+            int yOffset = 16*section.getY();
+            int zOffset = 16*section.getZ();
+
+            short[] pos = new short[changes.size()];
+            for(int i = 0; i < changes.size(); i++) {
+                Hull.IntVector change = changes.get(i);
+
+                pos[i] = (short) (((change.getX()-xOffset) << 8) + ((change.getZ()-zOffset) << 4) + (change.getY()-yOffset));
+            }
+
+            return constructMultiBlockChange(section, pos, blockdata);
+        } else {
+            Hull.IntVector pos = changes.get(0);
+            return new ClientboundBlockUpdatePacket(new BlockPos(pos.getX(), pos.getY(), pos.getZ()), (BlockState) blockdata[0]);
+        }
+    }
+
+    protected Object constructMultiBlockChange(Hull.IntVector section, short[] pos, Object[] blockdata) {
+        return new ClientboundSectionBlocksUpdatePacket(SectionPos.of(section.getX(), section.getY(), section.getZ()), new Short2ObjectArrayMap<>(pos, blockdata, blockdata.length));
+    }
 }

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

@@ -44,7 +44,7 @@ public class ItemBuilder {
 	}
 
 	public ItemBuilder enchant() {
-		meta.addEnchant(Enchantment.DURABILITY, 1, true);
+		meta.addEnchant(Enchantment.UNBREAKING, 1, true);
 		return this;
 	}
 	

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

@@ -19,17 +19,59 @@
 
 package de.steamwar.fightsystem.utils;
 
-import de.steamwar.core.VersionDependent;
-import de.steamwar.fightsystem.FightSystem;
+import io.papermc.paper.datacomponent.DataComponentType;
+import io.papermc.paper.datacomponent.DataComponentTypes;
 import org.bukkit.Location;
 import org.bukkit.entity.Player;
 import org.bukkit.inventory.ItemStack;
 
-public interface ReflectionWrapper {
-    ReflectionWrapper impl = VersionDependent.getVersionImpl(FightSystem.getPlugin());
+import java.util.HashSet;
+import java.util.Set;
 
-    Object explosionHider(Player player, Object packet, PacketHiderFunction packetHiderFunction);
-    boolean hasItems(ItemStack stack);
+public class ReflectionWrapper {
+    public static final ReflectionWrapper impl = new ReflectionWrapper();
+
+    private static final Set<DataComponentType> FORBIDDEN_TYPES = new HashSet<>();
+
+    static {
+        FORBIDDEN_TYPES.add(DataComponentTypes.CUSTOM_NAME);
+        FORBIDDEN_TYPES.add(DataComponentTypes.PROFILE);
+        FORBIDDEN_TYPES.add(DataComponentTypes.UNBREAKABLE);
+        FORBIDDEN_TYPES.add(DataComponentTypes.BLOCK_DATA);
+        FORBIDDEN_TYPES.add(DataComponentTypes.BLOCKS_ATTACKS);
+        FORBIDDEN_TYPES.add(DataComponentTypes.BUNDLE_CONTENTS);
+        FORBIDDEN_TYPES.add(DataComponentTypes.CUSTOM_MODEL_DATA);
+
+        FORBIDDEN_TYPES.add(DataComponentTypes.ATTRIBUTE_MODIFIERS);
+        FORBIDDEN_TYPES.add(DataComponentTypes.TOOL);
+        FORBIDDEN_TYPES.add(DataComponentTypes.WEAPON);
+        FORBIDDEN_TYPES.add(DataComponentTypes.FOOD);
+        FORBIDDEN_TYPES.add(DataComponentTypes.CONSUMABLE);
+        FORBIDDEN_TYPES.add(DataComponentTypes.POTION_CONTENTS);
+        FORBIDDEN_TYPES.add(DataComponentTypes.STORED_ENCHANTMENTS);
+        FORBIDDEN_TYPES.add(DataComponentTypes.CAN_BREAK);
+        FORBIDDEN_TYPES.add(DataComponentTypes.CAN_PLACE_ON);
+        FORBIDDEN_TYPES.add(DataComponentTypes.MAX_DAMAGE);
+        FORBIDDEN_TYPES.add(DataComponentTypes.USE_REMAINDER);
+        FORBIDDEN_TYPES.add(DataComponentTypes.USE_COOLDOWN);
+        FORBIDDEN_TYPES.add(DataComponentTypes.SUSPICIOUS_STEW_EFFECTS);
+        FORBIDDEN_TYPES.add(DataComponentTypes.CHARGED_PROJECTILES);
+        FORBIDDEN_TYPES.add(DataComponentTypes.INTANGIBLE_PROJECTILE);
+        FORBIDDEN_TYPES.add(DataComponentTypes.FIREWORKS);
+        FORBIDDEN_TYPES.add(DataComponentTypes.FIREWORK_EXPLOSION);
+        FORBIDDEN_TYPES.add(DataComponentTypes.EQUIPPABLE);
+        FORBIDDEN_TYPES.add(DataComponentTypes.REPAIR_COST);
+        FORBIDDEN_TYPES.add(DataComponentTypes.ENCHANTABLE);
+    }
+
+    public Object explosionHider(Player player, Object packet, PacketHiderFunction packetHiderFunction) {
+        return packet;
+    }
+
+    public boolean hasItems(ItemStack stack) {
+        FORBIDDEN_TYPES.forEach(stack::resetData);
+        return false;
+    }
 
     public interface PacketHiderFunction {
         Object hide(Player player, Object packet, Location location);

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

@@ -19,8 +19,6 @@
 
 package de.steamwar.fightsystem.utils;
 
-import de.steamwar.core.VersionDependent;
-import de.steamwar.fightsystem.FightSystem;
 import org.bukkit.Sound;
 
 public enum SWSound {
@@ -29,13 +27,18 @@ public enum SWSound {
     BLOCK_NOTE_BASS,
     ENTITY_GENERIC_EXPLODE;
 
-    private static final ISWSound impl = VersionDependent.getVersionImpl(FightSystem.getPlugin());
-
     public Sound getSound() {
-        return impl.getSound(this);
-    }
-
-    public interface ISWSound {
-        Sound getSound(SWSound sound);
+        switch(this){
+            case ENTITY_WITHER_DEATH:
+                return Sound.ENTITY_WITHER_DEATH;
+            case BLOCK_NOTE_BASS:
+                return Sound.BLOCK_NOTE_BLOCK_BASS;
+            case BLOCK_NOTE_PLING:
+                return Sound.BLOCK_NOTE_BLOCK_PLING;
+            case ENTITY_GENERIC_EXPLODE:
+                return Sound.ENTITY_GENERIC_EXPLODE;
+            default:
+                return null;
+        }
     }
 }

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

@@ -1,10 +1,11 @@
 package de.steamwar.fightsystem.utils;
 
-import de.steamwar.core.VersionDependent;
-import de.steamwar.fightsystem.FightSystem;
+import net.minecraft.server.MinecraftServer;
 
-public interface TpsWarper {
-  TpsWarper impl = VersionDependent.getVersionImpl(FightSystem.getPlugin());
+public class TpsWarper {
+    public static final TpsWarper impl = new TpsWarper();
 
-  void warp(float tps);
+    public void warp(float tps) {
+        MinecraftServer.getServer().tickRateManager().setTickRate(tps);
+    }
 }

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

@@ -19,22 +19,33 @@
 
 package de.steamwar.fightsystem.utils;
 
-import de.steamwar.core.VersionDependent;
-import de.steamwar.fightsystem.FightSystem;
 import org.bukkit.ChatColor;
 import org.bukkit.Location;
 import org.bukkit.Sound;
+import org.bukkit.SoundCategory;
+import org.bukkit.entity.Arrow;
 import org.bukkit.entity.Player;
 import org.bukkit.entity.Projectile;
 import org.bukkit.scoreboard.Team;
 
-public interface WorldOfColorWrapper {
-    WorldOfColorWrapper impl = VersionDependent.getVersionImpl(FightSystem.getPlugin());
+public class WorldOfColorWrapper {
+    public static final WorldOfColorWrapper impl = new WorldOfColorWrapper();
 
-    void setTeamColor(Team team, ChatColor color);
-    boolean isInBlock(Projectile e);
+    public void setTeamColor(Team team, ChatColor color) {
+        team.setColor(color);
+    }
 
-    void playSound(Location location, Sound sound, String soundCategory, float volume, float pitch);
+    public boolean isInBlock(Projectile e) {
+        if(e instanceof Arrow)
+            return ((Arrow) e).isInBlock();
+        return false;
+    }
 
-    void sendTitle(Player player, String title, String subtitle, int start, int hold, int stop);
+    public void playSound(Location location, Sound sound, String soundCategory, float volume, float pitch) {
+        location.getWorld().playSound(location, sound, SoundCategory.valueOf(soundCategory), volume, pitch);
+    }
+
+    public void sendTitle(Player player, String title, String subtitle, int start, int hold, int stop) {
+        player.sendTitle(title, subtitle, start, hold, stop);
+    }
 }

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

@@ -19,25 +19,131 @@
 
 package de.steamwar.fightsystem.utils;
 
+import com.sk89q.worldedit.EditSession;
+import com.sk89q.worldedit.WorldEdit;
 import com.sk89q.worldedit.WorldEditException;
+import com.sk89q.worldedit.bukkit.BukkitAdapter;
+import com.sk89q.worldedit.bukkit.BukkitWorld;
+import com.sk89q.worldedit.extent.clipboard.BlockArrayClipboard;
 import com.sk89q.worldedit.extent.clipboard.Clipboard;
+import com.sk89q.worldedit.extent.clipboard.io.BuiltInClipboardFormat;
+import com.sk89q.worldedit.extent.clipboard.io.ClipboardFormats;
+import com.sk89q.worldedit.extent.clipboard.io.ClipboardReader;
+import com.sk89q.worldedit.extent.clipboard.io.ClipboardWriter;
+import com.sk89q.worldedit.function.operation.ForwardExtentCopy;
+import com.sk89q.worldedit.function.operation.Operations;
+import com.sk89q.worldedit.math.BlockVector3;
+import com.sk89q.worldedit.math.Vector3;
 import com.sk89q.worldedit.math.transform.AffineTransform;
-import de.steamwar.core.VersionDependent;
+import com.sk89q.worldedit.regions.CuboidRegion;
+import com.sk89q.worldedit.session.ClipboardHolder;
+import com.sk89q.worldedit.world.World;
+import com.sk89q.worldedit.world.block.BaseBlock;
+import com.sk89q.worldedit.world.block.BlockTypes;
+import de.steamwar.fightsystem.Config;
 import de.steamwar.fightsystem.FightSystem;
+import de.steamwar.sql.NodeData;
+import de.steamwar.sql.SchematicData;
 import de.steamwar.sql.SchematicNode;
 import org.bukkit.DyeColor;
 import org.bukkit.Location;
 import org.bukkit.util.Vector;
 
+import java.io.ByteArrayOutputStream;
+import java.io.File;
+import java.io.FileInputStream;
 import java.io.IOException;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Objects;
 
-public interface WorldeditWrapper {
-    WorldeditWrapper impl = VersionDependent.getVersionImpl(FightSystem.getPlugin());
+public class WorldeditWrapper {
+    public static final WorldeditWrapper impl = new WorldeditWrapper();
 
-    void replaceTeamColor(Clipboard clipboard, DyeColor c) throws WorldEditException;
-    int getWaterDepth(Clipboard clipboard);
-    void pasteClipboard(Clipboard clipboard, Location position, Vector offset, AffineTransform aT);
-    Vector getDimensions(Clipboard clipboard);
-    Clipboard loadChar(String charName) throws IOException;
-    void saveSchem(SchematicNode schem, Region region, int minY) throws WorldEditException;
+    private static final Map<BaseBlock, String> colorBlocks = new HashMap<>();
+
+    static {
+        colorBlocks.put(Objects.requireNonNull(BlockTypes.PINK_WOOL).getDefaultState().toBaseBlock(), "_wool");
+        colorBlocks.put(Objects.requireNonNull(BlockTypes.PINK_TERRACOTTA).getDefaultState().toBaseBlock(), "_terracotta");
+        colorBlocks.put(Objects.requireNonNull(BlockTypes.PINK_STAINED_GLASS).getDefaultState().toBaseBlock(), "_stained_glass");
+        colorBlocks.put(Objects.requireNonNull(BlockTypes.PINK_STAINED_GLASS_PANE).getDefaultState().toBaseBlock(), "_stained_glass_pane");
+        colorBlocks.put(Objects.requireNonNull(BlockTypes.PINK_CONCRETE).getDefaultState().toBaseBlock(), "_concrete");
+        colorBlocks.put(Objects.requireNonNull(BlockTypes.PINK_CONCRETE_POWDER).getDefaultState().toBaseBlock(), "_concrete_powder");
+        colorBlocks.put(Objects.requireNonNull(BlockTypes.PINK_CARPET).getDefaultState().toBaseBlock(), "_carpet");
+    }
+
+    public void replaceTeamColor(Clipboard clipboard, DyeColor c) throws WorldEditException {
+        BlockVector3 minimum = clipboard.getRegion().getMinimumPoint();
+        Map<BaseBlock, BaseBlock> replaceMap = new HashMap<>();
+        colorBlocks.forEach((base, postfix) -> replaceMap.put(base, Objects.requireNonNull(BlockTypes.get(c.name().toLowerCase() + postfix)).getDefaultState().toBaseBlock()));
+
+        for(int x = 0; x < clipboard.getDimensions().getX(); x++){
+            for(int y = 0; y < clipboard.getDimensions().getY(); y++){
+                for(int z = 0; z < clipboard.getDimensions().getZ(); z++){
+                    BlockVector3 pos = minimum.add(x, y, z);
+                    BaseBlock replacement = replaceMap.get(clipboard.getFullBlock(pos));
+                    if(replacement != null)
+                        clipboard.setBlock(pos, replacement);
+                }
+            }
+        }
+    }
+
+    public int getWaterDepth(Clipboard clipboard) {
+        BlockVector3 it = clipboard.getMinimumPoint().add(0, 0, 1);
+        int depth = 0;
+        while(!clipboard.getBlock(it).getBlockType().getMaterial().isAir()){
+            depth++;
+            it = it.add(0, 1, 0);
+        }
+        return depth;
+    }
+
+    public void pasteClipboard(Clipboard clipboard, Location position, Vector offset, AffineTransform aT) {
+        EditSession e = WorldEdit.getInstance().getEditSessionFactory().getEditSession(new BukkitWorld(position.getWorld()), -1);
+        ClipboardHolder ch = new ClipboardHolder(clipboard);
+        ch.setTransform(aT);
+        Operations.completeBlindly(ch.createPaste(e).to(BukkitAdapter.asVector(position).add(
+                aT.apply(Vector3.at(offset.getX(), offset.getY(), offset.getZ()).add(clipboard.getOrigin().toVector3()).subtract(clipboard.getMinimumPoint().toVector3()))
+        ).toBlockPoint()).build());
+        e.flushSession();
+    }
+
+    public Vector getDimensions(Clipboard clipboard) {
+        BlockVector3 dims = clipboard.getDimensions();
+        return new Vector(dims.getX(), dims.getY(), dims.getZ());
+    }
+
+    public Clipboard loadChar(String charName) throws IOException {
+        File file = new File(FightSystem.getPlugin().getDataFolder(), "text/" + charName + ".schem");
+        Clipboard clipboard;
+        try (ClipboardReader reader = Objects.requireNonNull(ClipboardFormats.findByFile(file)).getReader(new FileInputStream(file))) {
+            clipboard = reader.read();
+        }
+        return clipboard;
+    }
+
+    public void saveSchem(SchematicNode schem, Region region, int minY) throws WorldEditException {
+        World w = new BukkitWorld(Config.world);
+        BlockVector3 min = BlockVector3.at(region.getMinX(), minY, region.getMinZ());
+        CuboidRegion cuboidRegion = new CuboidRegion(w, min, BlockVector3.at(region.getMaxX(), region.getMaxY(), region.getMaxZ()).subtract(BlockVector3.ONE));
+        BlockArrayClipboard clipboard = new BlockArrayClipboard(cuboidRegion);
+
+        ForwardExtentCopy forwardExtentCopy = new ForwardExtentCopy(
+                WorldEdit.getInstance().getEditSessionFactory().getEditSession(w, -1), cuboidRegion, clipboard, min
+        );
+        forwardExtentCopy.setCopyingEntities(false);
+        Operations.complete(forwardExtentCopy);
+
+        ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
+        try {
+            ClipboardWriter writer = BuiltInClipboardFormat.SPONGE_SCHEMATIC.getWriter(outputStream);
+            writer.write(clipboard);
+            writer.close();
+        } catch (IOException e) {
+            throw new SecurityException(e);
+        }
+
+        SchematicData.saveFromBytes(schem, outputStream.toByteArray(), NodeData.SchematicFormat.SPONGE_V2);
+    }
 }

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

@@ -91,7 +91,7 @@ public abstract class WinconditionBasePercent extends Wincondition implements Pr
         @EventHandler
         public void onEntityExplode(EntityExplodeEvent event) {
             if (
-                    event.getEntityType() != EntityType.PRIMED_TNT ||
+                    event.getEntityType() != EntityType.TNT ||
                     !team.getExtendRegion().inRegion(event.getEntity().getLocation()) ||
                     (!Config.GameModeConfig.WinConditionParams.PercentEntern && !Config.GameModeConfig.EnterStages.isEmpty() && Config.GameModeConfig.EnterStages.get(0) >= Wincondition.getTimeOverCountdown().getTimeLeft())
             ) {