diff --git a/FightSystem/FightSystem_10/build.gradle.kts b/FightSystem/FightSystem_10/build.gradle.kts
new file mode 100644
index 00000000..dfab54e2
--- /dev/null
+++ b/FightSystem/FightSystem_10/build.gradle.kts
@@ -0,0 +1,58 @@
+/*
+ * This file is a part of the SteamWar software.
+ *
+ * Copyright (C) 2024 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 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");
+ }
+
+ @Override
+ public void replaceTeamColor(Clipboard clipboard, DyeColor c) throws WorldEditException {
+ BlockVector3 minimum = clipboard.getRegion().getMinimumPoint();
+ Map 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);
+ }
+ }
+ }
+ }
+
+ @Override
+ 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;
+ }
+
+ @Override
+ 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();
+ }
+
+ @Override
+ public Vector getDimensions(Clipboard clipboard) {
+ BlockVector3 dims = clipboard.getDimensions();
+ return new Vector(dims.getX(), dims.getY(), dims.getZ());
+ }
+
+ @Override
+ public Clipboard loadChar(String charName) throws IOException {
+ return new SpongeSchematicReader(new NBTInputStream(new GZIPInputStream(new FileInputStream(new File(FightSystem.getPlugin().getDataFolder(), "text/" + charName + ".schem"))))).read();
+ }
+
+ @Override
+ 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);
+ }
+
+ new SchematicData(schem).saveFromBytes(outputStream.toByteArray(), true);
+ }
+}
diff --git a/FightSystem/FightSystem_15/build.gradle.kts b/FightSystem/FightSystem_15/build.gradle.kts
new file mode 100644
index 00000000..b321f1b6
--- /dev/null
+++ b/FightSystem/FightSystem_15/build.gradle.kts
@@ -0,0 +1,58 @@
+/*
+ * This file is a part of the SteamWar software.
+ *
+ * Copyright (C) 2024 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 changes) {
+ List blockdata = new ArrayList<>(changes.size());
+
+ changes.removeIf(change -> {
+ BlockData data = Config.world.getBlockData(change.getX(), change.getY(), change.getZ());
+ boolean unchanged = data.getMaterial() == Config.ObfuscateWith || Config.HiddenBlocks.contains(data.getMaterial());
+ if(!unchanged)
+ blockdata.add(getState.invoke(data));
+ return unchanged;
+ });
+
+ if(changes.isEmpty())
+ return null;
+
+ return generateBlockChangePacket(changes, blockdata.toArray());
+ }
+
+ private Object generateBlockChangePacket(List 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 PacketPlayOutBlockChange(new BlockPosition(pos.getX(), pos.getY(), pos.getZ()), (IBlockData) blockdata[0]);
+ }
+ }
+
+ protected Object constructMultiBlockChange(Hull.IntVector section, short[] pos, Object[] blockdata) {
+ return new PacketPlayOutMultiBlockChange(SectionPosition.a(section.getX(), section.getY(), section.getZ()), new Short2ObjectArrayMap<>(pos, blockdata, blockdata.length), false);
+ }
+}
diff --git a/FightSystem/FightSystem_19/build.gradle.kts b/FightSystem/FightSystem_19/build.gradle.kts
new file mode 100644
index 00000000..b3475ff2
--- /dev/null
+++ b/FightSystem/FightSystem_19/build.gradle.kts
@@ -0,0 +1,64 @@
+/*
+ * This file is a part of the SteamWar software.
+ *
+ * Copyright (C) 2024 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 seesDragon = new HashSet<>();
+ private final PacketPlayOutSpawnEntityLiving spawnDragon;
+ private final int spawnDragonId;
+ @Override
+ public void sendBar(Player player, FightTeam team, double progress, String text) {
+ seesDragon.removeIf(p -> !p.isOnline());
+
+ if(!seesDragon.contains(player)) {
+ ((CraftPlayer)player).getHandle().playerConnection.sendPacket(spawnDragon);
+ seesDragon.add(player);
+ }
+
+ DataWatcher watcher = new DataWatcher(null);
+ watcher.a(0, (byte) 0x20);
+ watcher.a(2, text);
+ watcher.a(3, (byte) 1);
+ watcher.a(4, (byte) 1);
+ watcher.a(6, (float)(progress * 200));
+ ((CraftPlayer) player).getHandle().playerConnection.sendPacket(new PacketPlayOutEntityMetadata(spawnDragonId, watcher, true));
+ }
+}
diff --git a/FightSystem/FightSystem_8/src/de/steamwar/fightsystem/utils/CraftbukkitWrapper8.java b/FightSystem/FightSystem_8/src/de/steamwar/fightsystem/utils/CraftbukkitWrapper8.java
new file mode 100644
index 00000000..8d743ae7
--- /dev/null
+++ b/FightSystem/FightSystem_8/src/de/steamwar/fightsystem/utils/CraftbukkitWrapper8.java
@@ -0,0 +1,55 @@
+/*
+ This file is a part of the SteamWar software.
+
+ Copyright (C) 2021 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 changes) {
+ changes.removeIf(change -> {
+ Material material = Config.world.getBlockAt(change.getX(), change.getY(), change.getZ()).getType();
+ return material == Config.ObfuscateWith || Config.HiddenBlocks.contains(material);
+ });
+
+ if(changes.isEmpty())
+ return null;
+
+ Hull.IntVector chunk = changes.get(0);
+ chunk = new Hull.IntVector(chunk.getX() >> 4, chunk.getY() >> 4, chunk.getZ() >> 4);
+ int xOffset = 16*chunk.getX();
+ int zOffset = 16*chunk.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) << 12) + ((change.getZ()-zOffset) << 8) + change.getY());
+ }
+
+ return newMultiBlockChange.invoke(pos.length, pos, getHandle.invoke(Config.world.getChunkAt(chunk.getX(), chunk.getZ())));
+ }
+}
diff --git a/FightSystem/FightSystem_8/src/de/steamwar/fightsystem/utils/SWSound8.java b/FightSystem/FightSystem_8/src/de/steamwar/fightsystem/utils/SWSound8.java
new file mode 100644
index 00000000..d4a6e210
--- /dev/null
+++ b/FightSystem/FightSystem_8/src/de/steamwar/fightsystem/utils/SWSound8.java
@@ -0,0 +1,40 @@
+/*
+ This file is a part of the SteamWar software.
+
+ Copyright (C) 2021 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 colorBlocks = new HashSet<>();
+
+ static {
+ colorBlocks.add(new BaseBlock(Material.WOOL.getId(), COLOR_TO_REPLACE));
+ colorBlocks.add(new BaseBlock(Material.STAINED_GLASS.getId(), COLOR_TO_REPLACE));
+ colorBlocks.add(new BaseBlock(Material.CLAY.getId(), COLOR_TO_REPLACE));
+ colorBlocks.add(new BaseBlock(Material.STAINED_GLASS_PANE.getId(), COLOR_TO_REPLACE));
+ colorBlocks.add(new BaseBlock(Material.CARPET.getId(), COLOR_TO_REPLACE));
+ }
+
+ @Override
+ public void replaceTeamColor(Clipboard clipboard, DyeColor c) throws WorldEditException {
+ Vector minimum = clipboard.getRegion().getMinimumPoint();
+ Map replaceMap = new HashMap<>();
+ colorBlocks.forEach(base -> replaceMap.put(base, new BaseBlock(base.getId(), c.getWoolData())));
+
+ 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++){
+ Vector pos = minimum.add(x, y, z);
+ BaseBlock replacement = replaceMap.get(clipboard.getBlock(pos));
+ if(replacement != null)
+ clipboard.setBlock(pos, replacement);
+ }
+ }
+ }
+ }
+
+ @Override
+ public int getWaterDepth(Clipboard clipboard) {
+ Vector it = clipboard.getMinimumPoint().add(0, 0, 1);
+ int depth = 0;
+ while(!clipboard.getBlock(it).isAir()) {
+ depth++;
+ it = it.add(0, 1, 0);
+ }
+ return depth;
+ }
+
+ @Override
+ public void pasteClipboard(Clipboard clipboard, Location position, org.bukkit.util.Vector offset, AffineTransform aT) {
+ World w = new BukkitWorld(position.getWorld());
+ EditSession e = WorldEdit.getInstance().getEditSessionFactory().getEditSession(w, -1);
+ ClipboardHolder ch = new ClipboardHolder(clipboard, w.getWorldData());
+ ch.setTransform(aT);
+ Operations.completeBlindly(ch.createPaste(e, w.getWorldData()).to(new Vector(position.getX(), position.getY(), position.getZ()).add(
+ aT.apply(new Vector(offset.getX(), offset.getY(), offset.getZ()).add(clipboard.getOrigin()).subtract(clipboard.getMinimumPoint()))
+ ).toBlockPoint()).build());
+ e.flushQueue();
+ }
+
+ @Override
+ public org.bukkit.util.Vector getDimensions(Clipboard clipboard) {
+ Vector dims = clipboard.getDimensions();
+ return new org.bukkit.util.Vector(dims.getBlockX(), dims.getBlockY(), dims.getBlockZ());
+ }
+
+ @Override
+ public Clipboard loadChar(String charName) throws IOException {
+ return new SchematicReader(new NBTInputStream(new GZIPInputStream(new FileInputStream(new File(FightSystem.getPlugin().getDataFolder(), "text/" + charName + ".schematic"))))).read(new BukkitWorld(Config.world).getWorldData());
+ }
+
+ @Override
+ public void saveSchem(SchematicNode schem, Region region, int minY) throws WorldEditException {
+ World w = new BukkitWorld(Config.world);
+ Vector min = new Vector(region.getMinX(), minY, region.getMinZ());
+ CuboidRegion cuboidRegion = new CuboidRegion(w, min, new Vector(region.getMaxX(), region.getMaxY(), region.getMaxZ()).subtract(Vector.ONE));
+ BlockArrayClipboard clipboard = new BlockArrayClipboard(cuboidRegion);
+
+ ForwardExtentCopy forwardExtentCopy = new ForwardExtentCopy(
+ WorldEdit.getInstance().getEditSessionFactory().getEditSession(w, -1), cuboidRegion, clipboard, min
+ );
+ Operations.complete(forwardExtentCopy);
+
+ ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
+ try {
+ ClipboardWriter writer = ClipboardFormat.SCHEMATIC.getWriter(outputStream);
+ writer.write(clipboard, w.getWorldData());
+ writer.close();
+ } catch (IOException e) {
+ throw new SecurityException(e);
+ }
+
+ new SchematicData(schem).saveFromBytes(outputStream.toByteArray(), false);
+ }
+}
diff --git a/FightSystem/FightSystem_9/build.gradle.kts b/FightSystem/FightSystem_9/build.gradle.kts
new file mode 100644
index 00000000..8e018b08
--- /dev/null
+++ b/FightSystem/FightSystem_9/build.gradle.kts
@@ -0,0 +1,59 @@
+/*
+ * This file is a part of the SteamWar software.
+ *
+ * Copyright (C) 2024 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 barMap = new HashMap<>();
+ @Override
+ 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;
+ }
+ }
+}
diff --git a/FightSystem/FightSystem_9/src/de/steamwar/fightsystem/utils/CraftbukkitWrapper9.java b/FightSystem/FightSystem_9/src/de/steamwar/fightsystem/utils/CraftbukkitWrapper9.java
new file mode 100644
index 00000000..54281ed3
--- /dev/null
+++ b/FightSystem/FightSystem_9/src/de/steamwar/fightsystem/utils/CraftbukkitWrapper9.java
@@ -0,0 +1,58 @@
+/*
+ This file is a part of the SteamWar software.
+
+ Copyright (C) 2021 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 All = Collections.unmodifiableSet(EnumSet.allOf(ArenaMode.class));
+
+ public static final Set Normal = Collections.unmodifiableSet(EnumSet.of(NORMAL));
+ public static final Set Check = Collections.unmodifiableSet(EnumSet.of(CHECK));
+ public static final Set Event = Collections.unmodifiableSet(EnumSet.of(EVENT));
+ public static final Set Test = Collections.unmodifiableSet(EnumSet.of(TEST, CHECK));
+ public static final Set Prepare = Collections.unmodifiableSet(EnumSet.of(PREPARE));
+ public static final Set Replay = Collections.unmodifiableSet(EnumSet.of(REPLAY, TEST));
+
+ public static final Set AntiReplay = Collections.unmodifiableSet(EnumSet.complementOf(EnumSet.of(REPLAY)));
+ public static final Set AntiTest = Collections.unmodifiableSet(EnumSet.complementOf(EnumSet.of(TEST, CHECK)));
+ public static final Set AntiEvent = Collections.unmodifiableSet(EnumSet.complementOf(EnumSet.of(EVENT)));
+ public static final Set AntiTestCheckPrepare = Collections.unmodifiableSet(EnumSet.complementOf(EnumSet.of(TEST, CHECK, PREPARE)));
+ public static final Set AntiPrepare = Collections.unmodifiableSet(EnumSet.complementOf(EnumSet.of(PREPARE)));
+ public static final Set VariableTeams = Collections.unmodifiableSet(EnumSet.complementOf(EnumSet.of(EVENT, REPLAY, CHECK)));
+ public static final Set ManualTeams = Collections.unmodifiableSet(EnumSet.complementOf(EnumSet.of(EVENT, REPLAY)));
+ public static final Set RankedEvent = Collections.unmodifiableSet(EnumSet.of(EVENT, REPLAY));
+ public static final Set Restartable = Collections.unmodifiableSet(EnumSet.of(NORMAL, TEST));
+ public static final Set NotRestartable = Collections.unmodifiableSet(EnumSet.of(EVENT, REPLAY));
+ public static final Set SoloLeader = Collections.unmodifiableSet(EnumSet.of(TEST, CHECK, PREPARE));
+ public static final Set NotOnBau = Collections.unmodifiableSet(EnumSet.complementOf(EnumSet.of(TEST, CHECK, PREPARE, REPLAY)));
+ public static final Set SeriousFight = Collections.unmodifiableSet(EnumSet.complementOf(EnumSet.of(TEST, CHECK, REPLAY)));
+}
diff --git a/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/Config.java b/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/Config.java
new file mode 100644
index 00000000..d58ebbb7
--- /dev/null
+++ b/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/Config.java
@@ -0,0 +1,415 @@
+/*
+ This file is a part of the SteamWar software.
+
+ Copyright (C) 2021 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 EnterStages;
+
+ //arena parameter
+ public static final Region BluePasteRegion;
+ public static final Region RedPasteRegion;
+ public static final Region BlueExtendRegion;
+ public static final Region RedExtendRegion;
+ public static final Region ArenaRegion;
+ public static final Region PlayerRegion;
+
+ public static final Location TeamBlueSpawn;
+ public static final Location TeamRedSpawn;
+ public static final Location SpecSpawn;
+
+ public static final int BlueToRedX;
+ private static final int BlueToRedY;
+ public static final int BlueToRedZ;
+
+ public static final int PreperationArea;
+ public static final int WaterDepth;
+ public static final boolean GroundWalkable;
+ public static final boolean DisableSnowMelt;
+ public static final boolean ArenaLeaveable;
+ public static final boolean AllowMissiles;
+
+ //schematic parameter
+ public static final boolean RanksEnabled;
+ public static final boolean OnlyPublicSchematics;
+ public static final boolean IgnorePublicOnly;
+ public static final de.steamwar.sql.SchematicType SchematicType;
+ public static final List SubTypes;
+ public static final boolean RedRotate;
+ public static final boolean BlueRotate;
+ public static final boolean PasteAligned;
+ public static final boolean ReplaceObsidianBedrock;
+ public static final boolean ReplaceWithBlockupdates;
+ public static final boolean UnlimitedPrepare;
+
+ //team parameter
+ public static final String TeamRedName;
+ public static final String TeamBlueName;
+ public static final String TeamRedColor;
+ public static final String TeamBlueColor;
+ public static final String GameName;
+ public static final String TeamChatDetection;
+ public static final UUID BlueLeader;
+ public static final UUID RedLeader;
+
+ //Active win conditions
+ public static final Set ActiveWinconditions;
+
+ //win condition parameters
+ public static final int TimeoutTime;
+ public static final double PercentWin;
+ public static final boolean PercentEntern;
+ public static final boolean PercentBlocksWhitelist;
+ public static final Set PercentBlocks;
+
+ //default kits
+ public static final String MemberDefault;
+ public static final String LeaderDefault;
+ public static final boolean PersonalKits;
+ public static final Set ForbiddenItems;
+ public static final String KitFile;
+
+ //tech hider parameter
+ public static final boolean TechhiderActive;
+ public static final Set HiddenBlocks;
+ public static final Set HiddenBlockEntities;
+ public static final Material ObfuscateWith;
+
+ //event parameter
+ public static final EventFight EventKampf;
+ private static final Set Referees;
+ public static final int EventTeamBlueID;
+ public static final int EventTeamRedID;
+ public static final boolean BothTeamsPublic;
+ public static final int MaximumTeamMembers;
+ public static final boolean LiveReplay;
+
+ //check parameter
+ public static final int CheckSchemID;
+ public static final int PrepareSchemID;
+
+ public static final ArenaMode mode;
+
+ //replay system parameter
+ public static final String spectateIP = "127.0.0.1";
+ public static final int SpectatePort;
+ public static final int ReplayID;
+
+ static{
+ CheckSchemID = Integer.parseInt(System.getProperty("checkSchemID", "0"));
+ PrepareSchemID = Integer.parseInt(System.getProperty("prepareSchemID", "0"));
+ ReplayID = Integer.parseInt(System.getProperty("replay", "0"));
+
+ String configFile = System.getProperty("config", "config.yml");
+ if(!new File(FightSystem.getPlugin().getDataFolder(), configFile).exists()) {
+ FightSystem.getPlugin().saveDefaultConfig();
+ Bukkit.getLogger().log(Level.SEVERE, "Arenaconfig fehlt!");
+ Bukkit.shutdown();
+ }
+ FileConfiguration config = YamlConfiguration.loadConfiguration(new File(FightSystem.getPlugin().getDataFolder(), configFile));
+
+ File worldConfigFile = new File(world.getWorldFolder(), "config.yml");
+ if(!worldConfigFile.exists()) {
+ Bukkit.getLogger().log(Level.SEVERE, "Weltconfig fehlt!");
+ Bukkit.shutdown();
+ }
+ FileConfiguration worldconfig = YamlConfiguration.loadConfiguration(worldConfigFile);
+
+ NoPlayerOnlineDuration = config.getInt("Times.NoPlayersOnlineDuration", 300);
+ PreSchemPasteDuration = config.getInt("Times.PreSchemPasteDuration", 120);
+ SetupDuration = config.getInt("Times.SetupDuration", 300);
+ PreFightDuration = config.getInt("Times.PreFightDuration", 30);
+ SpectatorDuration = config.getInt("Times.SpectatorDuration", 30);
+
+ int blueCornerX = worldconfig.getInt("BlueCorner.x");
+ int blueCornerY = worldconfig.getInt("BlueCorner.y");
+ int blueCornerZ = worldconfig.getInt("BlueCorner.z");
+ int underBorder = worldconfig.getInt("UnderBorder", blueCornerY);
+
+ WaterDepth = config.getInt("Arena.WaterDepth", 0);
+ int schem2BorderX = config.getInt("Arena.Schem2Border.x", 24);
+ int schem2BorderZ = config.getInt("Arena.Schem2Border.z", 24);
+ PreperationArea = config.getInt("Arena.BorderFromSchematic", 12);
+ GroundWalkable = config.getBoolean("Arena.GroundWalkable", true);
+ DisableSnowMelt = config.getBoolean("Arena.DisableSnowMelt", false);
+ ArenaLeaveable = config.getBoolean("Arena.Leaveable", false);
+
+ int schemsizeX = config.getInt("Schematic.Size.x");
+ int schemsizeY = config.getInt("Schematic.Size.y");
+ int schemsizeZ = config.getInt("Schematic.Size.z");
+ RanksEnabled = !config.getStringList("Ranks").isEmpty();
+ SchematicType = de.steamwar.sql.SchematicType.fromDB(Objects.requireNonNull(config.getString("Schematic.Type", "normal")));
+ SubTypes = config.getStringList("Schematic.SubTypes").stream().map(de.steamwar.sql.SchematicType::fromDB).collect(Collectors.toList());
+ IgnorePublicOnly = config.getBoolean("Schematic.IgnorePublicOnly", false);
+ boolean rotate = config.getBoolean("Schematic.Rotate", true);
+ PasteAligned = config.getBoolean("Schematic.PasteAligned", false);
+ ReplaceObsidianBedrock = config.getBoolean("Schematic.ReplaceObsidianBedrock", false);
+ ReplaceWithBlockupdates = config.getBoolean("Schematic.ReplaceWithBlockupdates", false);
+ UnlimitedPrepare = config.getBoolean("Schematic.UnlimitedPrepare", false);
+
+ GameName = config.getString("GameName", "WarGear");
+ TeamChatDetection = config.getString("TeamChatPrefix", "+");
+
+ ActiveWinconditions = Collections.unmodifiableSet(config.getStringList("WinConditions").stream().map(Winconditions::valueOf).collect(Collectors.toSet()));
+
+ TimeoutTime = config.getInt("WinConditionParams.TimeoutTime", 1200);
+ PercentWin = config.getDouble("WinConditionParams.PercentWin", 7.0);
+ PercentEntern = config.getBoolean("WinConditionParams.PercentEntern", true);
+ PercentBlocksWhitelist = config.getBoolean("WinConditionParams.BlocksWhitelist", false);
+ PercentBlocks = Collections.unmodifiableSet(config.getStringList("WinConditionParams.Blocks").stream().map(Material::valueOf).collect(Collectors.toSet()));
+
+ EnterStages = Collections.unmodifiableList(config.getIntegerList("EnterStages"));
+ AllowMissiles = config.getBoolean("Arena.AllowMissiles", !EnterStages.isEmpty());
+
+ KitFile = config.getString("Kits.File", "kits.yml");
+ MemberDefault = config.getString("Kits.MemberDefault", "default");
+ LeaderDefault = config.getString("Kits.LeaderDefault", "default");
+ PersonalKits = config.getBoolean("Kits.PersonalKits", false);
+ ForbiddenItems = Collections.unmodifiableSet(config.getStringList("Kits.ForbiddenItems").stream().map(Material::valueOf).collect(Collectors.toSet()));
+
+ TechhiderActive = config.getBoolean("Techhider.Active", false);
+ ObfuscateWith = Material.getMaterial(config.getString("Techhider.ObfuscateWith", "end_stone").toUpperCase());
+ HiddenBlocks = config.getStringList("Techhider.HiddenBlocks").stream().map(String::toUpperCase).map(Material::getMaterial).collect(Collectors.toSet());
+ HiddenBlockEntities = Collections.unmodifiableSet(new HashSet<>(config.getStringList("Techhider.HiddenBlockEntities")));
+
+ if(schemsizeX < 0){
+ schemsizeX = -schemsizeX;
+ blueCornerX = blueCornerX - schemsizeX;
+ }
+ if(schemsizeY < 0){
+ schemsizeY = -schemsizeY;
+ blueCornerY = blueCornerY - schemsizeY;
+ }
+ if(schemsizeZ < 0){
+ schemsizeZ = -schemsizeZ;
+ blueCornerZ = blueCornerZ - schemsizeZ;
+ }
+
+ BlueToRedX = worldconfig.getInt("BlueToRed.x", 0);
+ BlueToRedY = worldconfig.getInt("BlueToRed.y", 0);
+ BlueToRedZ = worldconfig.getInt("BlueToRed.z", schemsizeZ + 50);
+ double teamBlueSpawnOffsetX = config.getDouble("Arena.SpawnOffset.x", 0);
+ double teamBlueSpawnOffsetY = config.getDouble("Arena.SpawnOffset.y", schemsizeY);
+ double teamBlueSpawnOffsetZ = config.getDouble("Arena.SpawnOffset.z", 0);
+
+ int teamRedCornerX = BlueToRedX + blueCornerX;
+ int teamRedCornerY = BlueToRedY + blueCornerY;
+ int teamRedCornerZ = BlueToRedZ + blueCornerZ;
+
+ int teamBluePasteX = blueCornerX + schemsizeX / 2;
+ int teamBluePasteZ = blueCornerZ + schemsizeZ / 2;
+ int teamRedPasteX = teamBluePasteX + BlueToRedX;
+ int teamRedPasteZ = teamBluePasteZ + BlueToRedZ;
+
+ TeamBlueSpawn = new Location(world,
+ teamBluePasteX + 0.5 + teamBlueSpawnOffsetX,
+ blueCornerY + 0.5 + teamBlueSpawnOffsetY,
+ teamBluePasteZ + 0.5 + teamBlueSpawnOffsetZ);
+
+ TeamRedSpawn = new Location(world,
+ teamRedPasteX + 0.5 - teamBlueSpawnOffsetX,
+ teamRedCornerY + 0.5 + teamBlueSpawnOffsetY,
+ teamRedPasteZ + 0.5 - teamBlueSpawnOffsetZ);
+
+ SpecSpawn = new Location(world,
+ teamBluePasteX + BlueToRedX /2.0,
+ blueCornerY + BlueToRedY /2.0 + schemsizeY/2.0,
+ teamBluePasteZ + BlueToRedZ /2.0);
+
+ Vector v1 = TeamBlueSpawn.toVector().subtract(TeamRedSpawn.toVector());
+ double pitch = Math.toDegrees(v1.angle(v1.clone().setY(0)));
+ double yaw = Math.toDegrees(v1.clone().setY(0).angle(new Vector(0, 0, 1)));
+
+ TeamBlueSpawn.setYaw((float) yaw + 180);
+ TeamBlueSpawn.setPitch((float) pitch);
+
+ TeamRedSpawn.setYaw((float) yaw);
+ TeamRedSpawn.setPitch((float) pitch * -1);
+
+
+ boolean teamRedRotate;
+ boolean teamBlueRotate;
+ int arenaMinX;
+ int arenaMaxX;
+ int arenaMinZ;
+ int arenaMaxZ;
+ if(BlueToRedX > 0){
+ arenaMinX = blueCornerX - schem2BorderX;
+ arenaMaxX = teamRedCornerX + schemsizeX + schem2BorderX;
+ teamRedRotate = true;
+ teamBlueRotate = false;
+ }else{
+ arenaMinX = teamRedCornerX - schem2BorderX;
+ arenaMaxX = blueCornerX + schemsizeX + schem2BorderX;
+ teamRedRotate = false;
+ teamBlueRotate = true;
+ }
+ if(BlueToRedZ > 0){
+ arenaMinZ = blueCornerZ - schem2BorderZ;
+ arenaMaxZ = teamRedCornerZ + schemsizeZ + schem2BorderZ;
+ teamRedRotate = true;
+ teamBlueRotate = false;
+ }else{
+ arenaMinZ = teamRedCornerZ - schem2BorderZ;
+ arenaMaxZ = blueCornerZ + schemsizeZ + schem2BorderZ;
+ if(BlueToRedZ != 0){
+ teamRedRotate = false;
+ teamBlueRotate = true;
+ }
+ }
+ if(!rotate){
+ teamRedRotate = false;
+ teamBlueRotate = false;
+ }
+ RedRotate = teamRedRotate;
+ BlueRotate = teamBlueRotate;
+
+ RedPasteRegion = Region.fromSize(teamRedCornerX, teamRedCornerY, teamRedCornerZ, schemsizeX, schemsizeY, schemsizeZ);
+ BluePasteRegion = Region.fromSize(blueCornerX, blueCornerY, blueCornerZ, schemsizeX, schemsizeY, schemsizeZ);
+
+ RedExtendRegion = Region.withExtension(teamRedCornerX, teamRedCornerY, teamRedCornerZ, schemsizeX, schemsizeY, schemsizeZ, PreperationArea, PreperationArea, PreperationArea);
+ BlueExtendRegion = Region.withExtension(blueCornerX, blueCornerY, blueCornerZ, schemsizeX, schemsizeY, schemsizeZ, PreperationArea, PreperationArea, PreperationArea);
+ ArenaRegion = Region.withExtension(arenaMinX, blueCornerY, arenaMinZ, arenaMaxX - arenaMinX, schemsizeY, arenaMaxZ - arenaMinZ, 0, PreperationArea, 0);
+ PlayerRegion = new Region(arenaMinX, underBorder, arenaMinZ, arenaMaxX, world.getMaxHeight(), arenaMaxZ);
+
+ int eventKampfID = Integer.parseInt(System.getProperty("fightID", "0"));
+ if(eventKampfID >= 1){
+ EventKampf = EventFight.get(eventKampfID);
+ if(EventKampf == null){
+ Bukkit.getLogger().log(Level.SEVERE, "Failed to load EventFight");
+ Bukkit.shutdown();
+ }
+
+ assert EventKampf != null;
+ Team team1 = Team.get(EventKampf.getTeamBlue());
+ Team team2 = Team.get(EventKampf.getTeamRed());
+
+ if(team1 == null || team2 == null){
+ Bukkit.getLogger().log(Level.SEVERE, "Failed to load Team");
+ Bukkit.shutdown();
+ }
+
+ assert team1 != null;
+ assert team2 != null;
+ TeamBlueName = team1.getTeamKuerzel();
+ TeamRedName = team2.getTeamKuerzel();
+ TeamBlueColor = "§" + team1.getTeamColor();
+ TeamRedColor = "§" + team2.getTeamColor();
+ EventTeamBlueID = team1.getTeamId();
+ EventTeamRedID = team2.getTeamId();
+ BothTeamsPublic = EventTeamRedID == 0 && EventTeamBlueID == 0;
+ SpectatePort = EventKampf.getSpectatePort();
+ LiveReplay = SpectatePort != 0;
+ Referees = Referee.get(Config.EventKampf.getEventID());
+
+ Event event = Event.get(EventKampf.getEventID());
+ if(BothTeamsPublic) {
+ OnlyPublicSchematics = true;
+ MaximumTeamMembers = Integer.MAX_VALUE;
+ }else{
+ OnlyPublicSchematics = event.publicSchemsOnly();
+ MaximumTeamMembers = event.getMaximumTeamMembers();
+ }
+ }else{
+ //No event
+ TeamRedColor = config.getString("Red.Prefix", "§c");
+ TeamBlueColor = config.getString("Blue.Prefix", "§3");
+ TeamRedName = config.getString("Red.Name", "Rot");
+ TeamBlueName = config.getString("Blue.Name", "Blau");
+ OnlyPublicSchematics = config.getBoolean("Schematic.OnlyPublicSchematics", false);
+ EventTeamBlueID = 0;
+ EventTeamRedID = 0;
+ EventKampf = null;
+ BothTeamsPublic = true;
+ Referees = Collections.emptySet();
+ MaximumTeamMembers = Integer.MAX_VALUE;
+ LiveReplay = false;
+ 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(){
+ return BlueToRedZ > 0;
+ }
+
+ public static boolean isReferee(Player player) {
+ return Referees.contains(SteamwarUser.get(player.getUniqueId()).getId());
+ }
+}
diff --git a/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/FightSystem.java b/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/FightSystem.java
new file mode 100644
index 00000000..6e6b1c40
--- /dev/null
+++ b/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/FightSystem.java
@@ -0,0 +1,230 @@
+/*
+ This file is a part of the SteamWar software.
+
+ Copyright (C) 2020 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 ais = new HashMap<>();
+
+ static {
+ new OneShotStateDependent(ArenaMode.All, FightState.Spectate, () -> {
+ ais.values().forEach(AI::stop);
+ ais.clear();
+ });
+ }
+
+ public static AI getAI(UUID uuid) {
+ return ais.get(uuid);
+ }
+
+ private final FightTeam team;
+ private final LivingEntity entity;
+ private final BukkitTask task;
+ private final Queue queue = new ArrayDeque<>();
+
+ protected AI(FightTeam team, SteamwarUser user) {
+ this.team = team;
+
+ entity = (LivingEntity) Config.world.spawnEntity(Config.SpecSpawn, EntityType.VILLAGER);
+ entity.setCustomName(user.getUserName());
+ ((Villager)entity).setAware(false);
+
+ task = Bukkit.getScheduler().runTaskTimer(FightSystem.getPlugin(), this::run, 1, 1);
+ ais.put(entity.getUniqueId(), this);
+ team.addMember(entity, user);
+ }
+
+ public abstract SchematicNode chooseSchematic();
+
+ public boolean acceptJoinRequest(Player player, FightTeam team) {
+ return true;
+ }
+
+ protected abstract void plan();
+
+ public void stop() {
+ if(!entity.isDead())
+ entity.remove();
+
+ if(!task.isCancelled())
+ task.cancel();
+ }
+
+ public LivingEntity getEntity() {
+ return entity;
+ }
+
+ protected void setReady() {
+ if(FightState.getFightState() != FightState.POST_SCHEM_SETUP)
+ return;
+
+ if(team.getLeader().getEntity() != entity)
+ return;
+
+ team.setReady(true);
+ }
+
+ protected void chat(String message) {
+ FightSystem.getPlugin().getLogger().log(Level.INFO, () -> entity.getName() + "» " + message);
+ Chat.broadcastChat("PARTICIPANT_CHAT", team.getColoredName(), entity.getName(), message);
+ }
+
+ protected Vector getPosition() {
+ Location location = entity.getLocation();
+ Region extend = team.getExtendRegion();
+ if(Fight.getUnrotated() == team)
+ return new Vector(
+ location.getX() - extend.getMinX(),
+ location.getY() - team.getSchemRegion().getMinY(),
+ location.getZ() - extend.getMinZ()
+ );
+ else
+ return new Vector(
+ extend.getMaxX() - location.getX(),
+ location.getY() - team.getSchemRegion().getMinY(),
+ extend.getMaxZ() - location.getZ()
+ );
+ }
+
+ protected Material getBlock(Vector pos) {
+ queue.add(new Action(1));
+ return translate(pos, true).getBlock().getType();
+ }
+
+ protected boolean isPowered(Vector pos) {
+ queue.add(new Action(1));
+ return translate(pos, true).getBlock().isBlockPowered();
+ }
+
+ protected void setTNT(Vector pos) {
+ queue.add(new Action(1) {
+ @Override
+ public void run() {
+ if(FightState.getFightState() != FightState.RUNNING)
+ return;
+
+ Location location = translate(pos, true);
+ if(interactionDistanceViolation(location))
+ return;
+
+ Block block = location.getBlock();
+ if(block.getType() == Material.AIR)
+ block.setType(Material.TNT);
+ }
+ });
+ }
+
+ protected void interact(Vector pos) {
+ queue.add(new Action(1) {
+ @Override
+ public void run() {
+ Location location = translate(pos, true);
+ if(interactionDistanceViolation(location))
+ return;
+
+ interact(location.getBlock());
+ }
+ });
+ }
+
+ protected void interact(Vector pos, int n) {
+ queue.add(new Action(1) {
+ @Override
+ public void run() {
+ Location location = translate(pos, true);
+ if (interactionDistanceViolation(location))
+ return;
+ Block block = location.getBlock();
+ BlockData data = block.getBlockData();
+ if (data instanceof Repeater) {
+ Repeater repeater = (Repeater) data;
+ repeater.setDelay(n);
+ } else if (data instanceof Lectern) {
+ Lectern lectern = (Lectern) data;
+ lectern.setPage(n);
+ }
+ block.setBlockData(data);
+ }
+ });
+ }
+
+ protected void move(Vector pos) {
+ queue.add(new Action(2) {
+ @Override
+ public void run() {
+ Location location = entity.getLocation();
+ Location target = translate(pos, false);
+ if(Math.abs(location.getX() - target.getX()) > 1 || Math.abs(location.getY() - target.getY()) > 1.2 || Math.abs(location.getZ() - target.getZ()) > 1) {
+ FightSystem.getPlugin().getLogger().log(Level.INFO, () -> entity.getName() + ": Overdistance movement " + location.toVector() + " " + target.toVector());
+ return;
+ }
+
+ if(!team.getFightPlayer(entity).canEntern() && !team.getExtendRegion().inRegion(target))
+ return;
+
+ entity.teleport(target, PlayerTeleportEvent.TeleportCause.COMMAND);
+ }
+ });
+ }
+
+ private boolean interactionDistanceViolation(Location location) {
+ return location.distance(entity.getEyeLocation()) > 5;
+ }
+
+ private void interact(Block block) {
+ BlockData data = block.getBlockData(); //TODO only 1.14+ compatible at the moment
+ if (data instanceof NoteBlock) {
+ NoteBlock noteBlock = (NoteBlock) data;
+ Note note = noteBlock.getNote();
+ noteBlock.setNote(note.isSharped() ? note.flattened() : note.sharped());
+ } else if (data instanceof Openable) {
+ Openable openable = (Openable) data;
+ openable.setOpen(!openable.isOpen());
+ } else if (data instanceof Comparator) {
+ Comparator comparator = (Comparator) data;
+ comparator.setMode(Comparator.Mode.values()[1 - comparator.getMode().ordinal()]);
+ } else if (data instanceof Powerable) {
+ Material type = block.getType();
+ Powerable powerable = (Powerable) data;
+ boolean isPowered = powerable.isPowered();
+
+ if(type.name().endsWith("BUTTON")) {
+ if(isPowered)
+ return;
+
+ Bukkit.getScheduler().runTaskLater(FightSystem.getPlugin(), () -> {
+ if(!block.getType().name().endsWith("BUTTON"))
+ return;
+
+ powerable.setPowered(false);
+ block.setBlockData(powerable);
+ }, type.name().endsWith("STONE_BUTTON") ? 20 : 30);
+ }
+
+ powerable.setPowered(!isPowered);
+ }
+ block.setBlockData(data);
+ }
+
+ private void run() {
+ if(queue.isEmpty())
+ plan();
+
+ if(!queue.isEmpty() && --queue.peek().delay == 0)
+ queue.poll().run();
+ }
+
+ private Location translate(Vector pos, boolean blockPos) {
+ Region extend = team.getExtendRegion();
+ if(Fight.getUnrotated() == team)
+ return new Location(
+ Config.world,
+ pos.getX() + extend.getMinX(),
+ pos.getY() + team.getSchemRegion().getMinY(),
+ pos.getZ() + extend.getMinZ()
+ );
+ else
+ return new Location(
+ Config.world,
+ extend.getMaxX() - pos.getX() - (blockPos ? 1 : 0),
+ pos.getY() + team.getSchemRegion().getMinY(),
+ extend.getMaxZ() - pos.getZ() - (blockPos ? 1 : 0)
+ );
+ }
+
+ private static class Action {
+ private int delay;
+ public Action(int delay) {
+ this.delay = delay;
+ }
+
+ public void run() {}
+ }
+}
diff --git a/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/ai/LixfelAI.java b/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/ai/LixfelAI.java
new file mode 100644
index 00000000..2a89353c
--- /dev/null
+++ b/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/ai/LixfelAI.java
@@ -0,0 +1,60 @@
+/*
+ * This file is a part of the SteamWar software.
+ *
+ * Copyright (C) 2023 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 publics = SchematicNode.getAllSchematicsOfType(0, Config.SchematicType.toDB());
+ SchematicNode schem = publics.get(new Random().nextInt(publics.size()));
+ pathplanner = new LixfelPathplanner(schem);
+ return schem;
+ }
+
+ @Override
+ protected void plan() {
+ setReady();
+ Vector destination = pathplanner.getWalkable().get(random.nextInt(pathplanner.getWalkable().size()));
+ List path = pathplanner.plan(getPosition(), destination);
+ if(!path.isEmpty())
+ chat("Path size: " + path.size());
+ for(Vector p : path) {
+ move(p);
+ }
+ }
+}
diff --git a/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/ai/LixfelPathplanner.java b/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/ai/LixfelPathplanner.java
new file mode 100644
index 00000000..b2e593e8
--- /dev/null
+++ b/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/ai/LixfelPathplanner.java
@@ -0,0 +1,141 @@
+/*
+ * This file is a part of the SteamWar software.
+ *
+ * Copyright (C) 2023 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 walkable = new ArrayList<>();
+ private final Map neighbours = new HashMap<>();
+
+ public LixfelPathplanner(SchematicNode schem) {
+ try {
+ fillWalkable(new SchematicData(schem).load());
+ } catch (IOException e) {
+ throw new IllegalStateException(e);
+ }
+ }
+
+ public List getWalkable() {
+ return walkable;
+ }
+
+ private void fillWalkable(Clipboard clipboard) {
+ BlockVector3 min = clipboard.getRegion().getMinimumPoint().subtract(Config.PreperationArea, 0, Config.PreperationArea); //TODO assumes nonextended Schematic with maximal size
+ Region region = clipboard.getRegion();
+ clipboard.getRegion().forEach(vector -> {
+ BlockVector3 below = vector.subtract(0, 1, 0);
+ if(!region.contains(below))
+ return;
+
+ BlockType belowMaterial = getBlockType(clipboard, below);
+ BlockVector3 above = vector.add(0, 1, 0);
+ if(nonsolid(clipboard, vector)) {
+ if(
+ (belowMaterial.getMaterial().isSolid() || belowMaterial.getId().equals("minecraft:ladder")) &&
+ (!region.contains(above) || nonsolid(clipboard, above))
+ )
+ walkable.add(toBukkit(vector.subtract(min)));
+ } else {
+ if(!region.contains(above))
+ walkable.add(toBukkit(above.subtract(min)));
+ }
+ });
+
+ for(Vector vector : walkable) {
+ neighbours.put(vector, walkable.stream().filter(neighbour -> neighbouring(neighbour, vector)).filter(neighbour -> neighbour != vector).toArray(Vector[]::new));
+ }
+ }
+
+ public List planToAnywhere(Vector start, Vector destination) {
+ Vector intermediate = walkable.stream().filter(vector -> neighbouring(vector, destination)).findAny().orElse(null);
+
+ if(intermediate == null)
+ return Collections.emptyList();
+
+ List plan = plan(start, intermediate);
+ plan.add(destination);
+
+ return plan;
+ }
+
+ public List plan(Vector start, Vector destination) {
+ if(neighbouring(start, destination))
+ return Collections.singletonList(destination);
+
+ Map approach = new HashMap<>();
+ Set checking = Collections.singleton(destination);
+
+ while(!checking.isEmpty()) {
+ Set toCheck = new HashSet<>();
+ for(Vector current : checking) {
+ Vector firstStep = Arrays.stream(neighbours.get(current))
+ .filter(vector -> !approach.containsKey(vector))
+ .filter(next -> {
+ approach.put(next, current);
+ toCheck.add(next);
+ return neighbouring(next, start);
+ })
+ .findAny().orElse(null);
+
+ if(firstStep != null) {
+ List path = new ArrayList<>();
+ path.add(firstStep);
+
+ while(path.get(path.size()-1) != destination) {
+ path.add(approach.get(path.get(path.size()-1)));
+ }
+
+ return path;
+ }
+ }
+ checking = toCheck;
+ }
+
+ return Collections.emptyList();
+ }
+
+ private boolean neighbouring(Vector a, Vector b) {
+ return Math.abs(a.getX() - b.getX()) <= 1 && Math.abs(a.getY() - b.getY()) <= 1 && Math.abs(a.getZ() - b.getZ()) <= 1;
+ }
+}
diff --git a/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/commands/AkCommand.java b/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/commands/AkCommand.java
new file mode 100644
index 00000000..27e6b797
--- /dev/null
+++ b/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/commands/AkCommand.java
@@ -0,0 +1,57 @@
+/*
+ This file is a part of the SteamWar software.
+
+ Copyright (C) 2020 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 commandMap = Reflection.getField("{obc}.CraftServer", "commandMap", SimpleCommandMap.class);
+ public static void injectCommand(Command cmd) {
+ commandMap.get(Bukkit.getServer()).register("FightSystem", cmd);
+ }
+
+ private static void errNoTeam(Player p){
+ FightSystem.getMessage().sendPrefixless("NO_TEAM", p, ChatMessageType.ACTION_BAR);
+ }
+
+ static boolean checkSetup(Player p){
+ if(!FightState.setup()){
+ FightSystem.getMessage().sendPrefixless("FIGHT_ALREADY_STARTED", p, ChatMessageType.ACTION_BAR);
+ return true;
+ }
+ return false;
+ }
+
+ private static FightPlayer checkGetPlayer(Player p){
+ FightPlayer fightPlayer = Fight.getFightPlayer(p);
+ if(fightPlayer == null){
+ errNoTeam(p);
+ }
+ return fightPlayer;
+ }
+
+ public static FightPlayer checkGetLeader(Player p){
+ FightPlayer fightPlayer = checkGetPlayer(p);
+ if(fightPlayer != null && !fightPlayer.isLeader()){
+ FightSystem.getMessage().sendPrefixless("NOT_LEADER", p, ChatMessageType.ACTION_BAR);
+ fightPlayer = null;
+ }
+ return fightPlayer;
+ }
+
+ public static FightTeam checkGetTeam(Player p){
+ FightTeam fightTeam = Fight.getPlayerTeam(p);
+ if(fightTeam == null){
+ errNoTeam(p);
+ }
+ return fightTeam;
+ }
+
+ private static Player checkGetPlayer(Player p, String t){
+ Player target = Bukkit.getPlayer(t);
+ if(target == null) {
+ FightSystem.getMessage().sendPrefixless("PLAYER_UNAVAILABLE", p, ChatMessageType.ACTION_BAR);
+ }
+ return target;
+ }
+
+ static void toggleReady(Player p){
+ FightTeam fightTeam = checkGetTeam(p);
+ if(fightTeam == null || checkGetLeader(p) == null)
+ return;
+
+ fightTeam.setReady(!fightTeam.isReady());
+ }
+
+ static void toggleSkip(Player p){
+ FightTeam fightTeam = checkGetTeam(p);
+ if(fightTeam == null || checkGetLeader(p) == null)
+ return;
+
+ fightTeam.skip();
+ }
+
+ static void leaveTeam(Player p){
+ if(checkSetup(p))
+ return;
+
+ FightTeam fightTeam = checkGetTeam(p);
+ if(fightTeam == null)
+ return;
+
+ fightTeam.removePlayer(p);
+ }
+
+ static void kick(Player p, String kicked){
+ if(checkSetup(p))
+ return;
+
+ FightTeam fightTeam = checkGetTeam(p);
+ if(fightTeam == null)
+ return;
+
+ FightPlayer fightPlayer = checkGetLeader(p);
+ if(fightPlayer == null)
+ return;
+
+ Player target = checkGetPlayer(p, kicked);
+ if(target == null)
+ return;
+
+ if(!fightTeam.isPlayerInTeam(target)){
+ FightSystem.getMessage().sendPrefixless("NOT_IN_TEAM", p, ChatMessageType.ACTION_BAR, target.getName());
+ return;
+ }
+
+ fightTeam.removePlayer(target);
+ }
+
+ public static void kit(Player p, String kitName){
+ if(checkSetup(p))
+ return;
+
+ FightPlayer fightPlayer = checkGetPlayer(p);
+ if(fightPlayer == null)
+ return;
+
+ Kit k = null;
+ if(Config.PersonalKits){
+ PersonalKit kit = PersonalKit.get(SteamwarUser.get(p.getUniqueId()).getId(), Config.SchematicType.toDB(), kitName);
+ if(kit != null){
+ kit.setInUse();
+ k = new Kit(kit);
+ }
+ }else{
+ k = Kit.getKitByName(kitName);
+ }
+
+ if(k == null || !k.canUseKit(fightPlayer.isLeader())){
+ FightSystem.getMessage().sendPrefixless("KIT_UNAVAILABLE", p, ChatMessageType.ACTION_BAR);
+ return;
+ }
+
+ FightSystem.getMessage().sendPrefixless("KIT_CHOSEN", p, ChatMessageType.ACTION_BAR, kitName);
+ fightPlayer.setKit(k);
+ }
+}
diff --git a/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/commands/GUI.java b/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/commands/GUI.java
new file mode 100644
index 00000000..0fba5388
--- /dev/null
+++ b/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/commands/GUI.java
@@ -0,0 +1,224 @@
+/*
+ This file is a part of the SteamWar software.
+
+ Copyright (C) 2020 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 > players = JoinRequest.openRequests(p, Fight.getPlayerTeam(p));
+ SWListInv inv = new SWListInv<>(p, msg.parse("REQUESTS_TITLE", p), players, (ClickType click, Player player) -> {
+ p.closeInventory();
+ RequestsCommand.onJoinRequest(p, player, click.isLeftClick() ? JoinRequest::accept : JoinRequest::decline);
+ });
+ inv.setCallback(-999, (ClickType click) -> p.closeInventory());
+ inv.open();
+ }
+
+ public static void chooseRemove(Player p){
+ List> players = SWListInv.createPlayerList(p.getUniqueId());
+ FightTeam team = Fight.getPlayerTeam(p);
+ if(team == null)
+ return;
+ players.removeIf(swItemUUIDPair -> !team.equals(Fight.getPlayerTeam(Bukkit.getPlayer(swItemUUIDPair.getObject()))));
+ SWListInv inv = new SWListInv<>(p, msg.parse("REMOVE_TITLE", p), players, (ClickType click, UUID player) -> {
+ Commands.kick(p, SteamwarUser.get(player).getUserName());
+ p.closeInventory();
+ });
+ inv.setCallback(-999, (ClickType click) -> p.closeInventory());
+ inv.open();
+ }
+
+ public static void kitSelection(Player p, String query){
+ FightPlayer fightPlayer = Fight.getFightPlayer(p);
+ if(fightPlayer == null)
+ return;
+
+ List> entries = new ArrayList<>();
+
+ if(Config.PersonalKits){
+ List kits = PersonalKit.get(SteamwarUser.get(p.getUniqueId()).getId(), Config.SchematicType.toDB());
+ kits.forEach(kit -> entries.add(new SWListInv.SWListEntry<>(new SWItem(Material.LEATHER_CHESTPLATE, "§e" + kit.getName(), new ArrayList<>(), kit.isInUse(), clickType -> {}), new Kit(kit))));
+ }else{
+ List kitList = Kit.getAvailableKits(fightPlayer.isLeader());
+ for(Kit k : kitList){
+ entries.add(new SWListInv.SWListEntry<>(new SWItem(Material.LEATHER_CHESTPLATE, k.getName(), null, k.leaderExclusive(), null), k));
+ }
+ }
+
+ entries.removeIf(entry -> !entry.getObject().getName().toLowerCase().contains(query.toLowerCase()));
+
+ SWListInv inv = new SWListInv<>(p, msg.parse("KIT_SELECTION_TITLE", p), false, entries, (clickType, kit) -> kit.preview(p));
+ inv.setCallback(-999, (ClickType click) -> p.closeInventory());
+ if(entries.isEmpty()) {
+ inv.setItem(22, new SWItem(Material.BARRIER, msg.parse("KIT_NO_KITS", p)));
+ }
+ if(Config.PersonalKits){
+ inv.setItem(48, Material.NETHER_STAR, msg.parse("KIT_CREATE", p), clickType -> {
+ SWAnvilInv anvilInv = new SWAnvilInv(p, msg.parse("KITNAME_TITLE", p));
+ anvilInv.setItem(Material.LEATHER_CHESTPLATE);
+ anvilInv.setCallback(s -> {
+ SteamwarUser user = SteamwarUser.get(p.getUniqueId());
+ if(PersonalKit.get(user.getId(), Config.SchematicType.toDB(), s) != null) {
+ msg.sendPrefixless("KITNAME_IN_USE", p, ChatMessageType.ACTION_BAR);
+ p.closeInventory();
+ return;
+ }
+ Kit prototype = Kit.getAvailableKits(Fight.getFightPlayer(p).isLeader()).get(0);
+ PersonalKit kit = PersonalKit.create(user.getId(), Config.SchematicType.toDB(), s, prototype.getInventory(), prototype.getArmor());
+ PersonalKitCreator.openKitCreator(p, kit);
+ });
+ anvilInv.open();
+ });
+ }
+ inv.setItem(50, Material.NAME_TAG, msg.parse("KIT_SEARCH", p), clickType -> {
+ SWAnvilInv anvilInv = new SWAnvilInv(p, msg.parse("KITSEARCH_TITLE", p));
+ anvilInv.setItem(Material.PAPER);
+ anvilInv.setCallback(s -> kitSelection(p, s));
+ anvilInv.open();
+ });
+ inv.open();
+ }
+
+ public static void preSchemDialog(Player p){
+ if(!Config.test() && FightState.getFightState() != FightState.PRE_SCHEM_SETUP){
+ msg.sendPrefixless("SCHEM_NO_ENEMY", p, ChatMessageType.ACTION_BAR);
+ return;
+ }
+
+ int invSize = (Config.SubTypes.size() + 1) * 9;
+ SWInventory inv = new SWInventory(p, invSize, msg.parse("SCHEM_TITLE", p, Config.GameName));
+ setupSchemTypeRow(p, inv, Config.SchematicType, 0);
+ for (int i = 0; i < Config.SubTypes.size(); i++) {
+ setupSchemTypeRow(p, inv, Config.SubTypes.get(i), i + 1);
+ }
+ inv.setCallback(-999, (ClickType click) -> p.closeInventory());
+ inv.open();
+ }
+
+ private static void setupSchemTypeRow(Player p, SWInventory inv, SchematicType type, int row) {
+ inv.setItem(row * 9 + 8, Material.REDSTONE, msg.parse("SCHEM_PUBLIC", p, type.name()), (ClickType click) -> {
+ p.closeInventory();
+ schemDialog(p, type, true, false);
+ });
+
+ if (Fight.publicOnly()) {
+ inv.setItem(row * 9, SWItem.getDye(8), (byte)8, msg.parse("SCHEM_PRIVATE_FORBIDDEN", p, type.name()), (ClickType click)->{});
+ return;
+ }
+
+ 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() && !Config.test()) {
+ inv.setItem(row * 9, SWItem.getDye(8), (byte)8, msg.parse("SCHEM_NO_PRIVATE", p, type.name()), (ClickType click)->{});
+ return;
+ }
+
+ inv.setItem(row * 9, SWItem.getMaterial("CAULDRON_ITEM"), msg.parse("SCHEM_PRIVATE", p, type.name()), (ClickType click) -> {
+ p.closeInventory();
+ schemDialog(p, type, false, false);
+ });
+ }
+
+ private static void schemDialog(Player p, SchematicType type, boolean publicSchems, boolean unchecked){
+ SchematicSelector selector = new SchematicSelector(p, Config.test() ? SchematicSelector.selectSchematic() : SchematicSelector.selectSchematicType(unchecked ? type.checkType() : type), node -> {
+ FightTeam fightTeam = Fight.getPlayerTeam(p);
+ if(fightTeam == null)
+ return;
+ if(Config.test() || FightState.getFightState() != FightState.POST_SCHEM_SETUP)
+ fightTeam.pasteSchem(node);
+ p.closeInventory();
+ });
+ selector.setPublicMode(publicSchems?SchematicSelector.PublicMode.PUBLIC_ONLY:SchematicSelector.PublicMode.PRIVATE_ONLY);
+ selector.open();
+ }
+}
diff --git a/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/commands/GamemodeCommand.java b/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/commands/GamemodeCommand.java
new file mode 100644
index 00000000..5c566261
--- /dev/null
+++ b/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/commands/GamemodeCommand.java
@@ -0,0 +1,107 @@
+/*
+ This file is a part of the SteamWar software.
+
+ Copyright (C) 2020 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 GAMEMODE_NAMES = ImmutableList.of("adventure", "creative", "survival",
+ "spectator");
+
+ public GamemodeCommand() {
+ super("gamemode");
+ List aliases = new ArrayList<>();
+ aliases.add("gm");
+ this.setAliases(aliases);
+
+ try {
+ CommandRemover.removeAll("gamemode");
+ } catch (Exception e) {
+ FightSystem.getPlugin().getLogger().log(Level.SEVERE, "Failed to replace commands", e);
+ }
+ Commands.injectCommand(this);
+ }
+
+ @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 (!(Config.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;
+ }
+
+ @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;
+ }
+
+ @Override
+ public List 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();
+ }
+
+}
diff --git a/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/commands/InfoCommand.java b/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/commands/InfoCommand.java
new file mode 100644
index 00000000..4cd6c19c
--- /dev/null
+++ b/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/commands/InfoCommand.java
@@ -0,0 +1,64 @@
+/*
+ * This file is a part of the SteamWar software.
+ *
+ * Copyright (C) 2023 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 handleJoinRequest) {
+ JoinRequest request = JoinRequest.get(target);
+ if(request == null) {
+ FightSystem.getMessage().send("NO_JOIN_REQUEST", player);
+ return;
+ }
+
+ FightTeam team = Fight.getPlayerTeam(player);
+ if(!request.required(team)) {
+ FightSystem.getMessage().send("NO_CONFIRMATION", player);
+ return;
+ }
+
+ handleJoinRequest.accept(request, team);
+ }
+}
diff --git a/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/commands/SkipCommand.java b/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/commands/SkipCommand.java
new file mode 100644
index 00000000..a1bedda9
--- /dev/null
+++ b/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/commands/SkipCommand.java
@@ -0,0 +1,53 @@
+/*
+ This file is a part of the SteamWar software.
+
+ Copyright (C) 2020 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 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));
+ }
+}
diff --git a/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/countdown/EnternCountdown.java b/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/countdown/EnternCountdown.java
new file mode 100644
index 00000000..55bcbe38
--- /dev/null
+++ b/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/countdown/EnternCountdown.java
@@ -0,0 +1,77 @@
+/*
+ This file is a part of the SteamWar software.
+
+ Copyright (C) 2020 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 chunkPos;
+
+ public EnternCountdown(FightPlayer fp, Countdown countdown) {
+ super(calcTime(fp, countdown), new Message("ENTERN_COUNTDOWN"), SWSound.BLOCK_NOTE_PLING, false);
+ fightPlayer = fp;
+ enable();
+ }
+
+ @Override
+ public void countdownFinished() {
+ Bukkit.getPluginManager().callEvent(new BoardingEvent(fightPlayer));
+ FightSystem.getMessage().sendPrefixless("ENTERN_ALLOWED", fightPlayer.getEntity(), ChatMessageType.ACTION_BAR);
+ fightPlayer.ifPlayer(player -> {
+ FightSystem.getHullHider().updatePlayer(player);
+ FightSystem.getTechHider().reloadChunks(player, Fight.getOpposite(fightPlayer.getTeam()).getExtendRegion(), Region.EMPTY);
+ });
+ }
+
+ @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);
+ });
+ }
+}
diff --git a/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/countdown/EventSpectateCountdown.java b/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/countdown/EventSpectateCountdown.java
new file mode 100644
index 00000000..e8772398
--- /dev/null
+++ b/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/countdown/EventSpectateCountdown.java
@@ -0,0 +1,41 @@
+/*
+ This file is a part of the SteamWar software.
+
+ Copyright (C) 2020 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 startMessages = Arrays.asList("HELLS_BELLS_START_1", "HELLS_BELLS_START_2",
+ "HELLS_BELLS_START_3", "HELLS_BELLS_START_4", "HELLS_BELLS_START_5", "HELLS_BELLS_START_6");
+ private final List stateSwapMessages = Arrays.asList("HELLS_BELLS_SWAP_1", "HELLS_BELLS_SWAP_2",
+ "HELLS_BELLS_SWAP_3", "HELLS_BELLS_SWAP_4");
+
+ public void startCountdown() {
+ if (current == HellsBells.State.PRE || current == HellsBells.State.FIRST) {
+ String startMessage = startMessages.get(random.nextInt(startMessages.size()));
+ GlobalRecorder.getInstance().system(startMessage);
+ FightSystem.getMessage().broadcast(startMessage);
+ current = current.getNext();
+ } else if (current != HellsBells.State.LAST && currentDrops >= current.SWITCH_AFTER) {
+ String stateSwapMessage = stateSwapMessages.get(random.nextInt(stateSwapMessages.size()));
+ GlobalRecorder.getInstance().system(stateSwapMessage);
+ FightSystem.getMessage().broadcast(stateSwapMessage);
+ currentDrops = 0;
+ current = current.getNext();
+ }
+
+ currentDrops++;
+ currentCountdown = new HellsBellsCountdown(current.MIN_TIME + random.nextInt(current.MAX_TIME - current.MIN_TIME));
+ currentCountdown.enable();
+ }
+
+ public void drop() {
+ Direction direction = Direction.getRandom();
+
+ AtomicInteger length = new AtomicInteger(20 + random.nextInt(direction.getLength(zLength, xLength) - 20));
+ int width = 5 + random.nextInt(5);
+ int xOffset = getStart(direction.getLength(xLength, zLength), direction.getLength(length.get(), width));
+ int zOffset = getStart(direction.getLength(zLength, xLength), direction.getLength(width, length.get()));
+ int yOffset = getHeightStart();
+
+ Point redStart;
+ Point blueStart;
+
+ if (direction.isNorthOrWest()) {
+ redStart = new Point(Config.RedExtendRegion.getMaxX() - xOffset, Config.RedExtendRegion.getMaxY() + yOffset, Config.RedExtendRegion.getMaxZ() - zOffset);
+ blueStart = new Point(Config.BlueExtendRegion.getMinX() + xOffset, Config.BlueExtendRegion.getMaxY() + yOffset, Config.BlueExtendRegion.getMinZ() + zOffset);
+ } else {
+ redStart = new Point(Config.RedExtendRegion.getMinX() + xOffset, Config.RedExtendRegion.getMaxY() + yOffset, Config.RedExtendRegion.getMinZ() + zOffset);
+ blueStart = new Point(Config.BlueExtendRegion.getMaxX() - xOffset, Config.BlueExtendRegion.getMaxY() + yOffset, Config.BlueExtendRegion.getMaxZ() - zOffset);
+ }
+
+ currentDropping = Bukkit.getScheduler().runTaskTimer(FightSystem.getPlugin(), () -> {
+ for (int w = 0; w < width; w++) {
+ if (direction.isNorthOrWest()) {
+ Config.world.spawnEntity(redStart.addAndToLocation(Config.world, -1 * (direction.dx * length.get() + w * direction.other().dx), 0, -1 * (direction.dz * length.get() + w * direction.other().dz)), EntityType.PRIMED_TNT);
+
+ Config.world.spawnEntity(blueStart.addAndToLocation(Config.world, direction.dx * length.get() + w * direction.other().dx, 0, direction.dz * length.get() + w * direction.other().dz), EntityType.PRIMED_TNT);
+ } else {
+ Config.world.spawnEntity(redStart.addAndToLocation(Config.world, direction.dx * length.get() + w * direction.other().dx, 0, direction.dz * length.get() + w * direction.other().dz), EntityType.PRIMED_TNT);
+
+ Config.world.spawnEntity(blueStart.addAndToLocation(Config.world, -1 * (direction.dx * length.get() + w * direction.other().dx), 0, -1 * (direction.dz * length.get() + w * direction.other().dz)), EntityType.PRIMED_TNT);
+ }
+ }
+ if (length.addAndGet(-2) <= 0) {
+ currentDropping.cancel();
+ }
+ }, 0L, 4L);
+ }
+
+ private int getStart(int regionSize, int length) {
+ double randomNumber = (Math.max(Math.min(random.nextGaussian(), -2), 2) + 2) / 4;
+ Bukkit.getLogger().log(Level.INFO, "Calculated Start: " + (int) (randomNumber * (regionSize - length)));
+ return Math.max(Math.min((int) (randomNumber * (regionSize - length)), regionSize - length), 0);
+ }
+
+ private int getHeightStart() {
+ return 5 + random.nextInt(15);
+ }
+
+ public HellsBells() {
+ new StateDependent(Winconditions.HELLS_BELLS, FightState.Running) {
+ @Override
+ public void enable() {
+ current = State.PRE;
+ currentDrops = 0;
+ startCountdown();
+ }
+
+ @Override
+ public void disable() {
+ currentCountdown.disable();
+ }
+ }.register();
+ }
+
+ private class HellsBellsCountdown extends Countdown {
+
+ public HellsBellsCountdown(int time) {
+ super(time, new Message("HELLS_BELLS_COUNTDOWN"), SWSound.BLOCK_NOTE_BASS, true);
+ }
+
+ @Override
+ public void countdownFinished() {
+ drop();
+ startCountdown();
+ }
+ }
+
+ private enum State {
+
+ PRE(60, 80, 1),
+ FIRST(40, 60, 3),
+ SECOND(30, 40, 4),
+ THIRD(20, 30, 4),
+ FOURTH(10, 20, 5),
+ LAST(5, 10, 0);
+
+
+ State(int minTime, int maxTime, int switchAfter) {
+ this.MIN_TIME = minTime;
+ this.MAX_TIME = maxTime;
+ this.SWITCH_AFTER = switchAfter;
+ }
+
+ private final int MIN_TIME; //NOSONAR
+ private final int MAX_TIME; //NOSONAR
+ private final int SWITCH_AFTER; //NOSONAR
+
+
+ public State getNext() {
+ switch (this) {
+ case PRE:
+ return FIRST;
+ case FIRST:
+ return SECOND;
+ case SECOND:
+ return THIRD;
+ case THIRD:
+ return FOURTH;
+ case FOURTH:
+ case LAST:
+ return LAST;
+ default:
+ return PRE;
+ }
+ }
+ }
+
+ private enum Direction {
+ NORTH(0, 0, 1),
+ SOUTH(0, 0, -1),
+ EAST(1, 0, 0),
+ WEST(-1, 0, 0);
+
+
+ int dx;
+ int dy;
+ int dz;
+
+ Direction(int dx, int dy, int dz) {
+ this.dx = dx;
+ this.dy = dy;
+ this.dz = dz;
+ }
+
+ public static Direction getRandom() {
+ return Direction.values()[random.nextInt(Direction.values().length)];
+ }
+
+ Direction other() {
+ switch (this) {
+ case NORTH:
+ return EAST;
+ case SOUTH:
+ return WEST;
+ case EAST:
+ return NORTH;
+ case WEST:
+ return SOUTH;
+ default:
+ return this;
+ }
+ }
+
+ public int getLength(int length1, int length2) {
+ return isNorthOrSouth() ? length1 : length2;
+ }
+
+ public boolean isNorthOrSouth() {
+ return this == NORTH || this == SOUTH;
+ }
+
+ public boolean isNorthOrWest() {
+ return this == NORTH || this == WEST;
+ }
+ }
+}
\ No newline at end of file
diff --git a/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/event/Meteor.java b/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/event/Meteor.java
new file mode 100644
index 00000000..3f3115d6
--- /dev/null
+++ b/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/event/Meteor.java
@@ -0,0 +1,216 @@
+/*
+ This file is a part of the SteamWar software.
+
+ Copyright (C) 2020 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 startMessages = Arrays.asList("METEOR_START_1", "METEOR_START_2", "METEOR_START_3", "METEOR_START_4", "METEOR_START_5", "METEOR_START_6");
+ private final List stateSwapMessages = Arrays.asList("METEOR_SWAP_1", "METEOR_SWAP_2", "METEOR_SWAP_3", "METEOR_SWAP_4");
+
+ public void startCountdown() {
+ if (current == Meteor.State.PRE || current == Meteor.State.FIRST) {
+ String startMessage = startMessages.get(random.nextInt(startMessages.size()));
+ GlobalRecorder.getInstance().system(startMessage);
+ FightSystem.getMessage().broadcast(startMessage);
+ current = current.getNext();
+ } else if (current != Meteor.State.LAST && currentDrops >= current.SWITCH_AFTER) {
+ String stateSwapMessage = stateSwapMessages.get(random.nextInt(stateSwapMessages.size()));
+ GlobalRecorder.getInstance().system(stateSwapMessage);
+ FightSystem.getMessage().broadcast(stateSwapMessage);
+ currentDrops = 0;
+ current = current.getNext();
+ }
+
+ currentDrops++;
+ currentCountdown = new Meteor.MeteorCountdown(current.MIN_TIME + random.nextInt(current.MAX_TIME - current.MIN_TIME));
+ currentCountdown.enable();
+ }
+
+ //@EventHandler
+ public void explode(ProjectileHitEvent event) {
+ if (event.getEntity() instanceof Fireball) {
+ TNTPrimed tnt = Config.world.spawn(event.getEntity().getLocation(), TNTPrimed.class);
+ tnt.setVelocity(new Vector(0, 0, 0));
+ tnt.setFuseTicks(0);
+ tnt.setYield(((Fireball) event.getEntity()).getYield());
+ event.getEntity().remove();
+ }
+ }
+
+ public void drop() {
+ int randomAmount = current.minAmount + random.nextInt(current.maxAmount - current.minAmount);
+ if (amount.get() > 0) {
+ amount.set(amount.get() + randomAmount);
+ return;
+ }
+ amount.set(randomAmount);
+
+ currentDropping = Bukkit.getScheduler().runTaskTimer(FightSystem.getPlugin(), () -> {
+ int xOffset = getStart(xLength);
+ int zOffset = getStart(zLength);
+ int yOffset = getHeightStart();
+
+ Point redStart = new Point(Config.RedExtendRegion.getMinX() + xOffset, Config.RedExtendRegion.getMaxY() + yOffset, Config.RedExtendRegion.getMaxZ() - zOffset);
+ Point blueStart = new Point(Config.BlueExtendRegion.getMinX() + xOffset, Config.BlueExtendRegion.getMaxY() + yOffset, Config.BlueExtendRegion.getMinZ() + zOffset);
+
+ vector.setX(random.nextDouble() - 0.5);
+ vector.setZ(random.nextDouble() - 0.5);
+
+ LargeFireball fireballRed = Config.world.spawn(redStart.toLocation(Config.world), LargeFireball.class);
+ fireballRed.setDirection(vector);
+ fireballRed.setBounce(false);
+ fireballRed.setIsIncendiary(false);
+ fireballRed.setYield(current.explosionSize);
+
+ LargeFireball fireballBlue = Config.world.spawn(blueStart.toLocation(Config.world), LargeFireball.class);
+ vector.setZ(vector.getZ() * -1);
+ fireballBlue.setDirection(vector);
+ fireballBlue.setBounce(false);
+ fireballBlue.setIsIncendiary(false);
+ fireballBlue.setYield(current.explosionSize);
+
+ if (amount.decrementAndGet() <= 0) {
+ currentDropping.cancel();
+ }
+ }, 0L, 4L);
+ }
+
+ private int getStart(int regionSize) {
+ double randomNumber = (random.nextDouble() - random.nextDouble()) / 2 + 0.5;
+ Bukkit.getLogger().log(Level.INFO, "Calculated Start: " + (int) (randomNumber * (regionSize - 1)));
+ return Math.max(Math.min((int) (randomNumber * (regionSize - 1)), regionSize - 1), 0);
+ }
+
+ private int getHeightStart() {
+ return 5 + random.nextInt(15);
+ }
+
+ public Meteor() {
+ new StateDependentListener(Winconditions.METEOR, FightState.Running, this);
+
+ new StateDependent(Winconditions.METEOR, FightState.Running) {
+ @Override
+ public void enable() {
+ startCountdown();
+ }
+
+ @Override
+ public void disable() {
+ currentCountdown.disable();
+ }
+ }.register();
+ }
+
+ private class MeteorCountdown extends Countdown {
+
+ public MeteorCountdown(int time) {
+ super(time, new Message("METEOR_COUNTDOWN"), SWSound.BLOCK_NOTE_BASS, true);
+ }
+
+ @Override
+ public void countdownFinished() {
+ drop();
+ startCountdown();
+ }
+ }
+
+ private enum State {
+
+ PRE(60, 80, 1, 0, 0, 0),
+ FIRST(25, 35, 6, 2, 3, 6),
+ SECOND(20, 30, 7, 4, 4, 8),
+ THIRD(15, 25, 7, 4, 5, 10),
+ FOURTH(10, 20, 8, 6, 7, 14),
+ LAST(5, 10, 0, 6, 9, 18);
+
+
+ State(int minTime, int maxTime, int switchAfter, int explosionSize, int minAmount, int maxAmount) {
+ this.MIN_TIME = minTime;
+ this.MAX_TIME = maxTime;
+ this.SWITCH_AFTER = switchAfter;
+ this.explosionSize = explosionSize;
+ this.minAmount = minAmount;
+ this.maxAmount = maxAmount;
+ }
+
+ private final int MIN_TIME; //NOSONAR
+ private final int MAX_TIME; //NOSONAR
+ private final int SWITCH_AFTER; //NOSONAR
+ private final int explosionSize; //NOSONAR
+ private final int minAmount;
+ private final int maxAmount;
+
+
+ public Meteor.State getNext() {
+ switch (this) {
+ case PRE:
+ return FIRST;
+ case FIRST:
+ return SECOND;
+ case SECOND:
+ return THIRD;
+ case THIRD:
+ return FOURTH;
+ case FOURTH:
+ case LAST:
+ return LAST;
+ default:
+ return PRE;
+ }
+ }
+ }
+}
\ No newline at end of file
diff --git a/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/event/PersistentDamage.java b/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/event/PersistentDamage.java
new file mode 100644
index 00000000..543eff9e
--- /dev/null
+++ b/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/event/PersistentDamage.java
@@ -0,0 +1,49 @@
+/*
+ * This file is a part of the SteamWar software.
+ *
+ * Copyright (C) 2023 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 teams = new HashSet<>();
+ static {
+ teams.add(redTeam);
+ teams.add(blueTeam);
+ }
+
+ public static FightTeam getPlayerTeam(LivingEntity player) {
+ if(redTeam.isPlayerInTeam(player))
+ return redTeam;
+ if(blueTeam.isPlayerInTeam(player))
+ return blueTeam;
+ return null;
+ }
+
+ public static FightTeam getOpposite(FightTeam fightTeam) {
+ if(fightTeam == redTeam)
+ return blueTeam;
+ else if(fightTeam == blueTeam)
+ return redTeam;
+
+ throw new IllegalArgumentException();
+ }
+
+ public static FightPlayer getFightPlayer(LivingEntity player) {
+ if(redTeam.isPlayerInTeam(player))
+ return redTeam.getFightPlayer(player);
+ if(blueTeam.isPlayerInTeam(player))
+ return blueTeam.getFightPlayer(player);
+ return null;
+ }
+
+ public static boolean fighting(LivingEntity player) {
+ return getPlayerTeam(player) != null;
+ }
+
+ public static Collection teams() {
+ return teams;
+ }
+
+ public static FightTeam getUnrotated() {
+ return Config.blueNegZ() ? Fight.getBlueTeam() : Fight.getRedTeam();
+ }
+
+ public static void playSound(Sound sound, float volume, float pitch) {
+ GlobalRecorder.getInstance().soundAtPlayer(sound.name(), volume, pitch);
+ //volume: max. 100, pitch: max. 2
+ if(Core.getVersion() >= 18)
+ Bukkit.getServer().getOnlinePlayers().forEach(player -> player.playSound(player, sound, volume, pitch));
+ else
+ Bukkit.getServer().getOnlinePlayers().forEach(player -> player.playSound(player.getLocation(), sound, volume, pitch));
+ }
+
+ public static FightTeam getTeamByName(String name) {
+ if(redTeam.getName().equalsIgnoreCase(name))
+ return redTeam;
+ if(blueTeam.getName().equalsIgnoreCase(name))
+ return blueTeam;
+ return null;
+ }
+
+ @SuppressWarnings("deprecation")
+ public static void setPlayerGamemode(Player player, GameMode gameMode) {
+ player.setGameMode(gameMode);
+
+ if(gameMode == GameMode.SPECTATOR) {
+ for(Player currentPlayer : Bukkit.getServer().getOnlinePlayers()) {
+ if(currentPlayer.getUniqueId() != player.getUniqueId() && currentPlayer.getGameMode() == GameMode.SPECTATOR) {
+ currentPlayer.hidePlayer(player);
+ player.hidePlayer(currentPlayer);
+ }
+ }
+
+ if(Config.test() || Config.isReferee(player))
+ return;
+
+ Bukkit.getScheduler().runTaskLater(FightSystem.getPlugin(), () -> {
+ if(!player.isOnline())
+ return;
+ pseudoSpectator(player, true);
+ }, 1);
+ }else if(gameMode == GameMode.SURVIVAL) {
+ for(Player currentPlayer : Bukkit.getServer().getOnlinePlayers()) {
+ if(currentPlayer.getUniqueId() != player.getUniqueId() && currentPlayer.getGameMode() == GameMode.SPECTATOR) {
+ currentPlayer.showPlayer(player);
+ player.showPlayer(currentPlayer);
+ }
+ }
+ }
+ }
+
+ public static void pseudoSpectator(Player player, boolean enable) {
+ TinyProtocol.instance.sendPacket(player, ProtocolWrapper.impl.playerInfoPacketConstructor(ProtocolWrapper.PlayerInfoAction.GAMEMODE, new GameProfile(player.getUniqueId(), player.getName()), enable ? GameMode.CREATIVE : GameMode.SPECTATOR));
+ }
+
+ public static boolean publicOnly() {
+ if (Config.OnlyPublicSchematics) {
+ return true;
+ }
+ if (Config.IgnorePublicOnly || ArenaMode.RankedEvent.contains(Config.mode)) {
+ return false;
+ }
+ if (redTeam.getLeader() == null || blueTeam.getLeader() == null) {
+ return false;
+ }
+ return redTeam.isPublicsOnly() || blueTeam.isPublicsOnly();
+ }
+}
diff --git a/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/fight/FightPlayer.java b/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/fight/FightPlayer.java
new file mode 100644
index 00000000..763bd6fd
--- /dev/null
+++ b/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/fight/FightPlayer.java
@@ -0,0 +1,131 @@
+/*
+ This file is a part of the SteamWar software.
+
+ Copyright (C) 2020 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 function) {
+ if(entity instanceof Player)
+ return;
+ AI ai = AI.getAI(entity.getUniqueId());
+ if(ai != null)
+ function.accept(ai);
+ }
+
+ public void ifPlayer(Consumer function) {
+ if(entity instanceof Player)
+ function.accept((Player) entity);
+ }
+
+ public boolean isLiving() {
+ return !this.isOut;
+ }
+
+ public boolean isLeader() {
+ FightPlayer leader = team.getLeader();
+ return leader != null && leader.getEntity() == entity;
+ }
+
+ public void addKill(){
+ kills++;
+ }
+
+ public boolean canEntern(){
+ if(enternCountdown == null)
+ return false;
+ return enternCountdown.getTimeLeft() == 0;
+ }
+}
diff --git a/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/fight/FightSchematic.java b/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/fight/FightSchematic.java
new file mode 100644
index 00000000..20c304d7
--- /dev/null
+++ b/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/fight/FightSchematic.java
@@ -0,0 +1,217 @@
+/*
+ This file is a part of the SteamWar software.
+
+ Copyright (C) 2020 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 publics = SchematicNode.getAllSchematicsOfType(0, Config.SchematicType.toDB());
+ if(publics.isEmpty()) {
+ for (SchematicType type : Config.SubTypes) {
+ publics = SchematicNode.getAllSchematicsOfType(0, type.toDB());
+ if (!publics.isEmpty()) {
+ break;
+ }
+ }
+ if (publics.isEmpty()) {
+ return;
+ }
+ }
+
+ setSchematic(publics.get(new Random().nextInt(publics.size())));
+ }
+
+ if(ArenaMode.AntiReplay.contains(Config.mode)) {
+ if(team.isBlue())
+ GlobalRecorder.getInstance().blueSchem(schematic);
+ else
+ GlobalRecorder.getInstance().redSchem(schematic);
+ }
+
+ Bukkit.getScheduler().runTask(FightSystem.getPlugin(), this::paste);
+ }
+
+ private void replaceTeamColor(Clipboard clipboard) {
+ try {
+ WorldeditWrapper.impl.replaceTeamColor(clipboard, ArenaMode.AntiPrepare.contains(Config.mode) ? ColorConverter.chat2dye(team.getColor()) : DyeColor.PINK);
+ } catch (WorldEditException e) {
+ Bukkit.getLogger().log(Level.SEVERE, "Could not recolor schematic", e);
+ }
+ }
+
+ private void paste(){
+ FreezeWorld freezer = new FreezeWorld();
+
+ Vector dims = WorldeditWrapper.impl.getDimensions(clipboard);
+ WorldeditWrapper.impl.pasteClipboard(
+ clipboard,
+ new Location(Config.world, region.centerX(), region.getMinY(), region.centerZ()),
+ new Vector(
+ Config.PasteAligned && Config.BlueToRedX != 0 ? region.getSizeX()/2.0 - dims.getBlockX() : -dims.getBlockX()/2.0,
+ Config.WaterDepth != 0 ? Config.WaterDepth - WorldeditWrapper.impl.getWaterDepth(clipboard) : 0,
+ Config.PasteAligned && Config.BlueToRedZ != 0 ? region.getSizeZ()/2.0 - dims.getBlockZ() : -dims.getBlockZ()/2.0
+ ).add(new Vector(rotate ? 1 : 0, 0, rotate ? 1 : 0)),
+ new AffineTransform().rotateY(rotate ? 180 : 0)
+ );
+ FightSystem.getHullHider().initialize(team);
+ if(ArenaMode.Check.contains(Config.mode) && !team.isBlue())
+ replaceSync(Material.TNT, Material.OBSIDIAN);
+
+ Bukkit.getScheduler().runTaskLater(FightSystem.getPlugin(), freezer::disable, 3);
+ Bukkit.getScheduler().runTaskLater(FightSystem.getPlugin(), team::teleportToSpawn, 40);
+ }
+
+ @Override
+ public void disable() {
+ if(!Config.ReplaceObsidianBedrock || Config.mode == ArenaMode.PREPARE)
+ return;
+
+ FreezeWorld freezer = null;
+ if(!Config.ReplaceWithBlockupdates)
+ freezer = new FreezeWorld();
+
+ replaceSync(Material.OBSIDIAN, Material.TNT);
+ replaceSync(Material.BEDROCK, Material.SLIME_BLOCK);
+
+ if(!Config.ReplaceWithBlockupdates)
+ freezer.disable();
+ }
+
+ public void pasteTeamName(){
+ char[] chars = team.getName().toCharArray();
+ Clipboard[] characters = new Clipboard[chars.length];
+
+ int length = 0;
+ int[] offsets = new int[chars.length];
+
+ for(int i = 0; i < chars.length; i++){
+ Clipboard character;
+ try {
+ character = WorldeditWrapper.impl.loadChar(chars[i] == '/' ? "slash" : String.valueOf(chars[i]));
+ } catch (IOException e) {
+ Bukkit.getLogger().log(Level.WARNING, "Could not display character {} due to missing file!", chars[i]);
+ try {
+ character = WorldeditWrapper.impl.loadChar("");
+ }catch (IOException ex) {
+ throw new SecurityException("Could not load text", ex);
+ }
+ }
+
+ replaceTeamColor(character);
+
+ characters[i] = character;
+ offsets[i] = length;
+ length += WorldeditWrapper.impl.getDimensions(character).getBlockX() + 1; // 1 is the distance between characters
+ }
+
+ length -= 1;
+ AffineTransform aT = new AffineTransform().rotateY(((team == Fight.getRedTeam()) == (Config.BlueToRedZ > 0)) ? 180 : 0);
+ Location base = new Location(Config.world, region.centerX(), team.getExtendRegion().getMaxY(), region.centerZ());
+ for(int i = 0; i < characters.length; i++){
+ WorldeditWrapper.impl.pasteClipboard(characters[i], base, new Vector(offsets[i] - length/2, 0, -region.getSizeZ()/2), aT);
+ }
+ }
+
+ private void replaceSync(Material target, Material replacement){
+ region.forEach((x, y, z) -> {
+ Block block = Config.world.getBlockAt(x, y, z);
+ if(block.getType() == target)
+ block.setType(replacement);
+ });
+ }
+}
diff --git a/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/fight/FightTeam.java b/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/fight/FightTeam.java
new file mode 100644
index 00000000..853646fc
--- /dev/null
+++ b/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/fight/FightTeam.java
@@ -0,0 +1,520 @@
+/*
+ This file is a part of the SteamWar software.
+
+ Copyright (C) 2020 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 players = new HashMap<>();
+
+ @Getter
+ private String name;
+ @Getter
+ private String prefix;
+ @Getter
+ private ChatColor color;
+ private final FightSchematic schematic;
+ private final Team team;
+ @Getter
+ private final boolean blue;
+
+ @Getter
+ private boolean ready;
+ private boolean skip;
+
+ @Getter
+ private final Location spawn;
+ @Getter
+ private final Region schemRegion;
+ @Getter
+ private final Region extendRegion;
+
+ @SuppressWarnings("deprecation")
+ public FightTeam(String name, String prefix, Location spawn, Region schemRegion, Region extendRegion, boolean rotate, boolean blue, UUID designatedLeader) { //TODO: Static TeamConfig object
+ this.spawn = spawn;
+ this.schemRegion = schemRegion;
+ this.extendRegion = extendRegion;
+ this.publicsOnly = false;
+ this.ready = false;
+ this.skip = false;
+ this.blue = blue;
+ this.designatedLeader = designatedLeader;
+ setPrefixAndName(prefix, name);
+ this.schematic = new FightSchematic(this, rotate);
+ new KitLoader();
+ new SpectateHandler();
+ new TeamArea(this);
+
+ team = FightScoreboard.getBukkitTeam(name);
+ WorldOfColorWrapper.impl.setTeamColor(team, color);
+ BountifulWrapper.impl.setNametagVisibility(team);
+ team.setNameTagVisibility(NameTagVisibility.HIDE_FOR_OTHER_TEAMS);
+ if (!Config.ActiveWinconditions.contains(Winconditions.AMONG_US)) {
+ team.setAllowFriendlyFire(false);
+ }
+
+ new OneShotStateDependent(ArenaMode.Restartable, 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);
+ });
+ }
+
+ public void setPrefixAndName(String prefix, String name){
+ this.name = name;
+ this.prefix = prefix;
+ this.color = ChatColor.getByChar(ChatColor.getLastColors(prefix).replace("§", ""));
+ }
+
+ public boolean canbeLeader(Player p){
+ return isLeaderless() && (designatedLeader == null || designatedLeader.equals(p.getUniqueId()));
+ }
+
+ public void teleportToSpawn(){
+ players.forEach((player, fp) -> fp.getEntity().teleport(spawn));
+ }
+
+ public FightPlayer getFightPlayer(LivingEntity player) {
+ return players.get(player.getUniqueId());
+ }
+
+ public boolean allPlayersOut() {
+ for(FightPlayer fightPlayer : players.values()) {
+ if(fightPlayer.isLiving())
+ return false;
+ }
+ return true;
+ }
+
+ public boolean isPlayerInTeam(LivingEntity player) {
+ return players.containsKey(player.getUniqueId());
+ }
+
+ public boolean canPlayerEntern(LivingEntity player) {
+ return getFightPlayer(player).canEntern();
+ }
+
+ public boolean isPlayerLeader(LivingEntity player) {
+ if(leader != null)
+ return leader.getEntity().equals(player);
+ else
+ return false;
+ }
+
+ public void reset() {
+ skip = false;
+ ready = false;
+ schematic.reset();
+
+ Set playerSet = new HashSet<>(players.keySet());
+ playerSet.removeIf(uuid -> {
+ Player player = Bukkit.getPlayer(uuid);
+ if(player == null) {
+ removePlayer(players.get(uuid).getEntity());
+ return true;
+ }
+
+ return false;
+ });
+ FightPlayer leaderBackup = leader;
+ players.clear();
+ leader = null;
+
+ if(leaderBackup != null){
+ playerSet.remove(leaderBackup.getEntity().getUniqueId());
+ addMember(leaderBackup.getEntity(), leaderBackup.getUser(), true);
+ }
+
+ playerSet.forEach(uuid -> addMember(Bukkit.getPlayer(uuid), SteamwarUser.get(uuid), true));
+
+ if(ArenaMode.VariableTeams.contains(Config.mode) && isLeaderless()){
+ List onlinePlayers = new ArrayList<>(Bukkit.getOnlinePlayers());
+ Collections.shuffle(onlinePlayers);
+ for(Player player : onlinePlayers) {
+ if(Fight.getPlayerTeam(player) == null && canbeLeader(player)){
+ addMember(player);
+ break;
+ }
+ }
+ }
+ }
+
+ public void broadcast(String message, Object... params) {
+ broadcast(player -> FightSystem.getMessage().sendPrefixless(message, player, ChatMessageType.ACTION_BAR, params));
+ }
+
+ public void broadcastSystem(String message, Object... params) {
+ broadcast(player -> FightSystem.getMessage().send(message, player, params));
+ }
+
+ public void broadcastChat(Player sender, String message) {
+ broadcast(player -> FightSystem.getMessage().sendPrefixless("TEAM_CHAT", player, ChatMessageType.CHAT, prefix, sender.getName(), message));
+ }
+
+ private void broadcast(Consumer f) {
+ players.forEach((uuid, fightPlayer) -> {
+ Player player = Bukkit.getPlayer(uuid);
+ if(player != null)
+ f.accept(player);
+ });
+ }
+
+ public void addMember(Player player) {
+ addMember(player, SteamwarUser.get(player.getUniqueId()), false);
+ }
+
+ public void addMember(LivingEntity entity, SteamwarUser user) {
+ addMember(entity, user, false);
+ }
+
+ public void addMember(LivingEntity entity, SteamwarUser user, boolean silent) {
+ FightPlayer fightPlayer = getFightPlayer(entity) != null ? getFightPlayer(entity) : new FightPlayer(entity, user, this);
+ fightPlayer.revive();
+ players.put(entity.getUniqueId(), fightPlayer);
+ Bukkit.getPluginManager().callEvent(new TeamSpawnEvent(fightPlayer));
+
+ Permanent.getSpectatorTeam().removeEntry(entity.getName());
+ team.addEntry(entity.getName());
+
+ entity.setHealth(20);
+ entity.teleport(spawn);
+
+ fightPlayer.ifPlayer(player -> {
+ BountifulWrapper.impl.setAttackSpeed(player);
+ player.setFoodLevel(20);
+ player.getInventory().clear();
+ FightSystem.getHullHider().updatePlayer(player);
+
+ if(FightState.Spectate.contains(FightState.getFightState())) {
+ Fight.setPlayerGamemode(player, GameMode.SPECTATOR);
+ } else {
+ Fight.setPlayerGamemode(player, GameMode.SURVIVAL);
+ (FightState.ingame() ? fightPlayer.getKit() : memberKit).loadToPlayer(player);
+ }
+ });
+
+ if(FightState.Running.contains(FightState.getFightState()))
+ fightPlayer.startEnternCountdown(Wincondition.getTimeOverCountdown());
+
+ fightPlayer.ifPlayer(player -> FightSystem.getTechHider().reloadChunks(player, Config.ArenaRegion, fightPlayer.canEntern() ? Region.EMPTY : Fight.getOpposite(this).getExtendRegion()));
+
+ if(isLeaderless())
+ setLeader(fightPlayer, silent);
+ else if(!silent)
+ FightUI.addSubtitle("UI_PLAYER_JOINS", prefix, entity.getName());
+ }
+
+ public void removePlayer(LivingEntity entity) {
+ FightPlayer fightPlayer = getFightPlayer(entity);
+ Bukkit.getPluginManager().callEvent(new TeamLeaveEvent(fightPlayer));
+
+ fightPlayer.ifPlayer(PersonalKitCreator::closeIfInKitCreator);
+ players.remove(entity.getUniqueId());
+ team.removeEntry(entity.getName());
+ Permanent.getSpectatorTeam().addEntry(entity.getName());
+
+ FightUI.addSubtitle("UI_PLAYER_LEAVES", prefix, entity.getName());
+
+ if(fightPlayer.equals(leader))
+ removeLeader();
+
+ entity.teleport(Config.SpecSpawn);
+
+ fightPlayer.ifPlayer(player -> {
+ Fight.setPlayerGamemode(player, GameMode.SPECTATOR);
+ player.getInventory().clear();
+
+ if(player.isOnline()){
+ FightSystem.getHullHider().updatePlayer(player);
+ FightSystem.getTechHider().reloadChunks(player, Config.ArenaRegion, Fight.getOpposite(this).getExtendRegion());
+
+ if(ArenaMode.VariableTeams.contains(Config.mode))
+ HotbarKit.SPECTATOR_KIT.loadToPlayer(player);
+ }
+ });
+ }
+
+ public boolean isLeaderless() {
+ return leader == null;
+ }
+
+ private void removeLeader() {
+ this.leader = null;
+ if(!players.isEmpty()) {
+ setLeader(players.values().iterator().next(), false);
+ }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);
+ }
+ }
+
+ private void setLeader(FightPlayer leader, boolean silent) {
+ leader.ifPlayer(PersonalKitCreator::closeIfInKitCreator);
+
+ this.leader = leader;
+ designatedLeader = null;
+ if(ready)
+ setReady(false);
+
+ if(!silent)
+ FightUI.addSubtitle("UI_LEADER_JOINS", prefix, leader.getEntity().getName());
+
+ publicsOnly = SchematicNode.getAllAccessibleSchematicsOfType(leader.getUser().getId(), Config.SchematicType.toDB()).isEmpty();
+
+ if(!Config.PersonalKits)
+ leader.setKit(Kit.getKitByName(Config.LeaderDefault));
+
+ leader.ifPlayer(player -> {
+ if(FightState.getFightState() != FightState.POST_SCHEM_SETUP)
+ chooseSchemKit.loadToPlayer(player);
+ else
+ notReadyKit.loadToPlayer(player);
+ });
+
+ if(FightState.getFightState() == FightState.PRE_LEADER_SETUP && !Fight.getOpposite(this).isLeaderless()){
+ FightState.setFightState(FightState.PRE_SCHEM_SETUP);
+ }
+
+ leader.ifAI(ai -> pasteSchem(ai.chooseSchematic()));
+ }
+
+ public Collection getPlayers() {
+ return players.values();
+ }
+
+ public void pasteSchem() {
+ testPasteAction();
+ }
+
+ public void pasteSchem(SchematicNode schematic){
+ if(schematic.getSchemtype().check()) {
+ FightStatistics.unrank();
+ FightSystem.getMessage().broadcast("SCHEMATIC_UNCHECKED", getColoredName());
+ }
+
+ setSchem(schematic);
+ testPasteAction();
+ }
+
+ public void pasteSchem(int schemId, Clipboard clipboard){
+ this.schematic.setSchematic(schemId, clipboard);
+ testPasteAction();
+ }
+
+ private void testPasteAction(){
+ if(Config.test())
+ this.schematic.enable();
+ else if(Fight.getOpposite(this).schematic.hasSchematic()){
+ FightState.setFightState(FightState.POST_SCHEM_SETUP);
+ }
+ }
+
+ public void pasteTeamName(){
+ schematic.pasteTeamName();
+ }
+
+ public void setSchem(SchematicNode schematic){
+ this.schematic.setSchematic(schematic);
+ broadcast("SCHEMATIC_CHOSEN", Config.GameName, schematic.getName());
+ }
+
+ public void setReady(boolean ready) {
+ LivingEntity l = leader.getEntity();
+
+ if(!schematic.hasSchematic()){
+ FightSystem.getMessage().sendPrefixless("SCHEMATIC_REQUIRED", l, ChatMessageType.ACTION_BAR);
+ return;
+ }
+
+ this.ready = ready;
+ if(ready) {
+ broadcast("TEAM_READY");
+ leader.ifPlayer(readyKit::loadToPlayer);
+ if(Fight.getOpposite(this).isReady() || ArenaMode.SoloLeader.contains(Config.mode))
+ FightState.setFightState(FightState.PRE_RUNNING);
+ } else {
+ broadcast("TEAM_NOT_READY");
+ leader.ifPlayer(notReadyKit::loadToPlayer);
+ }
+ }
+
+ public void skip(){
+ this.skip = !skip;
+ if(skip){
+ broadcast("SKIP_READY");
+ if(Fight.getOpposite(this).skip || Config.test()){
+ skip = false;
+ Fight.getOpposite(this).skip = false;
+ Countdown.skip();
+ }
+ }else{
+ broadcast("SKIP_NOT_READY");
+ }
+ }
+
+ public String getColoredName() {
+ return prefix + name;
+ }
+
+ public int getSchematic() {
+ return schematic.getId();
+ }
+
+ public double getCurrentHearts() {
+ return players.values().stream().filter(FightPlayer::isLiving).mapToDouble(fp -> fp.getEntity().getHealth()).sum();
+ }
+
+ public double getHeartRatio(){
+ int maximumHearts = players.size() * 20;
+ return maximumHearts != 0 ? getCurrentHearts() / maximumHearts : 0;
+ }
+
+ public int getPlayerCount() {
+ return players.size();
+ }
+
+ public int getAlivePlayers() {
+ return (int) players.values().stream().filter(FightPlayer::isLiving).count();
+ }
+
+ @Override
+ public String toString() {
+ return name;
+ }
+
+ private class KitLoader extends StateDependent {
+ private KitLoader() {
+ super(ArenaMode.AntiReplay, FightState.Ingame);
+ register();
+ }
+
+ @Override
+ public void enable() {
+ for(FightPlayer fightPlayer : players.values()) {
+ fightPlayer.ifPlayer(player -> {
+ PersonalKitCreator.closeIfInKitCreator(player);
+
+ player.closeInventory();
+ fightPlayer.getKit().loadToPlayer(player);
+ });
+ }
+ }
+
+ @Override
+ public void disable() {
+ players.values().forEach(fightPlayer -> fightPlayer.ifPlayer(p -> p.getInventory().clear()));
+ }
+ }
+
+ private class SpectateHandler extends StateDependent {
+ private SpectateHandler() {
+ super(ArenaMode.AntiReplay, FightState.Spectate);
+ register();
+ }
+
+ @Override
+ public void enable() {
+ players.values().forEach(fightPlayer -> {
+ fightPlayer.ifPlayer(player -> Fight.setPlayerGamemode(player, GameMode.SPECTATOR));
+ fightPlayer.getEntity().teleport(FightTeam.this.spawn);
+ });
+ }
+
+ @Override
+ public void disable() {
+ players.values().forEach(fightPlayer -> fightPlayer.ifPlayer(player -> Fight.setPlayerGamemode(player, GameMode.SURVIVAL)));
+ }
+ }
+}
diff --git a/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/fight/FightWorld.java b/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/fight/FightWorld.java
new file mode 100644
index 00000000..efcc16a3
--- /dev/null
+++ b/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/fight/FightWorld.java
@@ -0,0 +1,88 @@
+/*
+ This file is a part of the SteamWar software.
+
+ Copyright (C) 2020 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 entities = new ArrayList<>();
+ Recording.iterateOverEntities(Objects::nonNull, entity -> {
+ if(entity.getType() != EntityType.PLAYER && (!Config.ArenaLeaveable || Config.ArenaRegion.inRegion(entity.getLocation())))
+ entities.add(entity);
+ });
+ entities.forEach(Entity::remove);
+ entities.clear();
+
+ World backup = new WorldCreator(Config.world.getName() + "/backup").createWorld();
+ assert backup != null;
+ Config.ArenaRegion.forEachChunk((x, z) -> {
+ CraftbukkitWrapper.impl.resetChunk(Config.world, backup, x, z);
+ for(Player p : Bukkit.getOnlinePlayers()) {
+ de.steamwar.core.CraftbukkitWrapper.impl.sendChunk(p, x, z);
+ }
+ });
+ Bukkit.unloadWorld(backup, false);
+ }
+}
\ No newline at end of file
diff --git a/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/fight/FreezeWorld.java b/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/fight/FreezeWorld.java
new file mode 100644
index 00000000..7b58543f
--- /dev/null
+++ b/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/fight/FreezeWorld.java
@@ -0,0 +1,96 @@
+/*
+ This file is a part of the SteamWar software.
+
+ Copyright (C) 2020 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 [] onClicks;
+
+ protected HotbarKit(String name, ItemStack[] inventory, ItemStack[] armor, Collection effects, String[] nameTags, Consumer[] onClicks) {
+ super(name, inventory, armor, effects);
+ this.nameTags = nameTags;
+ this.onClicks = onClicks;
+ }
+
+ public HotbarKit() {
+ this(null, new ItemStack[HOTBAR_SIZE], null, null, new String[HOTBAR_SIZE], new Consumer[HOTBAR_SIZE]);
+ }
+
+ public HotbarKit(HotbarKit kit) {
+ this(kit.getName(), kit.getInventory().clone(), kit.getArmor() != null ? kit.getArmor().clone() : null, kit.getEffects(), kit.nameTags.clone(), kit.onClicks.clone());
+ }
+
+ public void setItem(int id, String nameTag, ItemStack stack, Consumer onClick) {
+ super.setItem(id, stack);
+ nameTags[id] = nameTag;
+ onClicks[id] = onClick;
+ }
+
+ @Override
+ public synchronized void loadToPlayer(Player player) {
+ for(int i = 0; i < HOTBAR_SIZE; i++) {
+ if(nameTags[i] != null) {
+ ItemMeta meta = Objects.requireNonNull(getInventory()[i].getItemMeta());
+ meta.setDisplayName(FightSystem.getMessage().parse(nameTags[i], player, Config.GameName));
+ getInventory()[i].setItemMeta(meta);
+ }
+ }
+ super.loadToPlayer(player);
+ }
+
+ public static class HotbarKitListener implements Listener {
+
+ private static final Set clicked = new HashSet<>();
+
+ public HotbarKitListener() {
+ new StateDependentListener(ArenaMode.AntiReplay, FightState.All, this);
+ new StateDependentTask(ArenaMode.AntiReplay, FightState.All, clicked::clear, 10, 10);
+ }
+
+ @EventHandler
+ public void handlePlayerInteract(PlayerInteractEvent event) {
+ if(event.getAction() == Action.PHYSICAL || (Core.getVersion() > 8 && event.getHand() != EquipmentSlot.HAND))
+ return;
+
+ Player player = event.getPlayer();
+ int slot = player.getInventory().getHeldItemSlot();
+ Kit activeKit = activeKits.get(player);
+ if(!(activeKit instanceof HotbarKit) || PersonalKitCreator.inKitCreator(player) || activeKit.getInventory()[slot] == null)
+ return;
+
+ event.setCancelled(true);
+ if(!clicked.add(player))
+ return;
+
+ ((HotbarKit)activeKit).onClicks[slot].accept(player);
+ }
+ }
+}
diff --git a/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/fight/JoinRequest.java b/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/fight/JoinRequest.java
new file mode 100644
index 00000000..a7756e4c
--- /dev/null
+++ b/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/fight/JoinRequest.java
@@ -0,0 +1,110 @@
+/*
+ This file is a part of the SteamWar software.
+
+ Copyright (C) 2022 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 activeRequests = new HashMap<>();
+
+ public static List> openRequests(Player p, FightTeam team) {
+ return activeRequests.values().stream().filter(
+ request -> request.waitOnApproval.contains(team)
+ ).map(request -> {
+ SWItem item = SWItem.getPlayerSkull(request.player);
+ item.setLore(Arrays.asList(
+ FightSystem.getMessage().parse("REQUESTS_LEFT_CLICK", p),
+ FightSystem.getMessage().parse("REQUESTS_RIGHT_CLICK", p)
+ ));
+ return new SWListInv.SWListEntry<>(item, request.player);
+ }).collect(Collectors.toList());
+ }
+
+ public static void clearRequests() {
+ activeRequests.clear();
+ }
+
+ public static JoinRequest get(Player player) {
+ return activeRequests.get(player);
+ }
+
+ private final Player player;
+ private final FightTeam team;
+ private final Set waitOnApproval;
+
+ public JoinRequest(Player player, FightTeam team) {
+ this.player = player;
+ this.team = team;
+ this.waitOnApproval = new HashSet<>(FightState.ingame() ? Fight.teams() : Collections.singleton(team));
+ Set alreadyAccepted = new HashSet<>();
+
+ activeRequests.put(player, this);
+ for(FightTeam t : waitOnApproval) {
+ FightPlayer leader = t.getLeader();
+ if(leader == null)
+ continue;
+
+ if(leader.getEntity() == null)
+ continue;
+
+ leader.ifPlayer(leaderPlayer -> FightSystem.getMessage().sendPrefixless("JOIN_REQUEST_NOTIFICATION", leaderPlayer, "REQUESTS", new ClickEvent(ClickEvent.Action.RUN_COMMAND, "/requests"), player.getName(), team.getColoredName()));
+ leader.ifAI(ai -> {
+ if(ai.acceptJoinRequest(player, team))
+ alreadyAccepted.add(t);
+ });
+ }
+
+ FightSystem.getMessage().sendPrefixless("JOIN_REQUEST_CONFIRMATION", player, ChatMessageType.ACTION_BAR);
+ alreadyAccepted.forEach(this::accept);
+ }
+
+ public boolean required(FightTeam decider) {
+ return waitOnApproval.contains(decider);
+ }
+
+ public void accept(FightTeam acceptor) {
+ waitOnApproval.remove(acceptor);
+
+ if(waitOnApproval.isEmpty()) {
+ team.addMember(player);
+ activeRequests.remove(player);
+ }
+ }
+
+ public void decline(FightTeam declinor) {
+ FightSystem.getMessage().sendPrefixless("REQUEST_YOUR_DECLINED", player, ChatMessageType.ACTION_BAR);
+ waitOnApproval.forEach(t -> t.broadcast("REQUEST_DECLINED", player.getName()));
+ silentDecline();
+ }
+
+ public void silentDecline() {
+ activeRequests.remove(player);
+ }
+}
diff --git a/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/fight/Kit.java b/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/fight/Kit.java
new file mode 100644
index 00000000..e3829099
--- /dev/null
+++ b/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/fight/Kit.java
@@ -0,0 +1,368 @@
+/*
+ This file is a part of the SteamWar software.
+
+ Copyright (C) 2020 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 loadedKits = new ArrayList<>();
+
+ protected static final Map activeKits = new HashMap<>();
+
+ public static Kit getActiveKit(Player player) {
+ return activeKits.get(player);
+ }
+
+ static {
+ if(!kits.exists()) {
+ Bukkit.getLogger().log(Level.SEVERE, "Kitconfig fehlend!" + kits.getAbsolutePath());
+ }
+
+ FileConfiguration kitData = YamlConfiguration.loadConfiguration(kits);
+ ConfigurationSection kitSection = kitData.getConfigurationSection("Kits");
+
+ for(String key : Objects.requireNonNull(kitSection).getKeys(false)) {
+ loadedKits.add(new Kit(Objects.requireNonNull(kitSection.getConfigurationSection(key))));
+ }
+ }
+
+ @Getter
+ private final String name;
+ @Getter
+ private final ItemStack[] inventory;
+ @Getter
+ private final ItemStack[] armor;
+ @Getter
+ private final Collection effects;
+ /* In which stage is entern allowed? */
+ @Getter
+ private final int enterStage;
+ /* Is this kit allowed to set/handle tnt? */
+ @Getter
+ private final boolean tnt;
+ private final boolean leaderAllowed;
+ private final boolean memberAllowed;
+
+ protected Kit(String name, ItemStack[] inventory, ItemStack[] armor, Collection effects) {
+ this.name = name;
+ this.inventory = inventory;
+ this.armor = armor;
+ this.effects = effects;
+ this.leaderAllowed = true;
+ this.memberAllowed = true;
+ this.enterStage = 0;
+ this.tnt = true;
+ }
+
+ protected Kit(Kit kit) {
+ this(kit.name, kit.inventory.clone(), kit.armor, kit.effects);
+ }
+
+ public Kit(String name, Player player) {
+ this(name, player.getInventory().getContents(), player.getInventory().getArmorContents(), player.getActivePotionEffects());
+ }
+
+ public Kit(PersonalKit kit){
+ this(kit.getName(), kit.getInventory(), kit.getArmor(), Collections.emptyList());
+ }
+
+ public Kit(ConfigurationSection kit){
+ name = kit.getName();
+ inventory = Objects.requireNonNull(kit.getList("Items")).toArray(new ItemStack[0]);
+ if(kit.isList("Armor"))
+ armor = Objects.requireNonNull(kit.getList("Armor")).toArray(new ItemStack[0]);
+ else
+ armor = null;
+ leaderAllowed = kit.getBoolean("LeaderAllowed");
+ memberAllowed = kit.getBoolean("MemberAllowed");
+ if(kit.isList("Effects"))
+ effects = (List) kit.getList("Effects");
+ else
+ effects = null;
+ enterStage = kit.getInt("EnterStage", 0);
+ tnt = kit.getBoolean("TNT", true);
+ }
+
+ protected void setItem(int id, ItemStack stack) {
+ inventory[id] = stack;
+ }
+
+ public static Kit getKitByName(String kitName) {
+ for(Kit kit : loadedKits) {
+ if(kit.getName().equalsIgnoreCase(kitName))
+ return kit;
+ }
+ return null;
+ }
+
+ public static List getAvailableKits(boolean leader){
+ List kits = new ArrayList<>();
+ for (Kit k : loadedKits) {
+ if (k.canUseKit(leader)){
+ kits.add(k);
+ }
+ }
+ return kits;
+ }
+
+ public boolean canUseKit(boolean leader){
+ if (leader) {
+ return leaderAllowed;
+ } else {
+ return memberAllowed;
+ }
+ }
+
+ public boolean leaderExclusive() {
+ return !memberAllowed;
+ }
+
+ public boolean contains(ItemStack stack) {
+ for(ItemStack i : inventory) {
+ if(similar(i, stack))
+ return true;
+ }
+ for(ItemStack i : armor) {
+ if(similar(i, stack))
+ return true;
+ }
+ return false;
+ }
+
+ public void toPersonalKit(PersonalKit kit) {
+ kit.setContainer(inventory, armor);
+ }
+
+ public void removeBadItems(){
+ Kit normal = Kit.getKitByName(Config.MemberDefault);
+ assert normal != null;
+
+ for(int i = 0; i < inventory.length; i++){
+ if(isBadItem(inventory[i]))
+ inventory[i] = null;
+ }
+
+ }
+
+ public static boolean isBadItem(ItemStack stack){
+ if(stack == null)
+ return false;
+
+ //Check for forbidden item
+ if(Config.ForbiddenItems.contains(stack.getType()))
+ return true;
+
+ //Check for attribute modifiers
+ if(FlatteningWrapper.impl.hasAttributeModifier(stack)){
+ return true;
+ }
+
+ if(stack.hasItemMeta()){
+ ItemMeta meta = stack.getItemMeta();
+ if(FlatteningWrapper.impl.containsBlockMeta(meta))
+ return true; //Blocks always upwards slabs etc.
+
+ if(hasItems(stack))
+ return true; //Blocks prefilled inventories
+ }
+
+ Kit normal = Kit.getKitByName(Config.MemberDefault);
+ assert normal != null;
+ return !normal.isEnchantmentInKit(stack) && !stack.getEnchantments().isEmpty();
+ }
+
+ private static final Class itemStack = Reflection.getClass("{nms.world.item}.ItemStack");
+ private static final Reflection.MethodInvoker asNMSCopy = Reflection.getTypedMethod(Reflection.getClass("{obc}.inventory.CraftItemStack"), "asNMSCopy", itemStack, ItemStack.class);
+ private static final Class nbtTagCompound = Reflection.getClass("{nms.nbt}.NBTTagCompound");
+ private static final Reflection.MethodInvoker getTag = Reflection.getTypedMethod(itemStack, null, nbtTagCompound);
+ private static final Reflection.MethodInvoker getKeys = Reflection.getTypedMethod(nbtTagCompound, null, Set.class);
+ public static boolean hasItems(ItemStack stack) {
+ Set keys = new HashSet<>((Set) getKeys.invoke(getTag.invoke(asNMSCopy.invoke(null, stack))));
+ keys.remove("Enchantments");
+ keys.remove("Damage");
+ return !keys.isEmpty();
+ }
+
+ private boolean isEnchantmentInKit(ItemStack stack){
+ for(ItemStack is : inventory){
+ if(similar(stack, is))
+ return true;
+ }
+ if(armor != null){
+ for(ItemStack is : armor){
+ if(similar(stack, is))
+ return true;
+ }
+ }
+ return false;
+ }
+
+ private boolean similar(ItemStack stack, ItemStack stack2){
+ if(stack == null || stack2 == null)
+ return false;
+ if(stack.getType() != stack2.getType())
+ return false;
+ if(stack.hasItemMeta() != stack2.hasItemMeta())
+ return false;
+ if(stack.getItemMeta() == null || stack2.getItemMeta() == null)
+ return true;
+
+ //Enchantment Map comparison used for default similarity check does not work
+ Map en = stack.getItemMeta().getEnchants();
+ Map en2 = new HashMap<>(stack.getItemMeta().getEnchants());
+
+ for(Map.Entry e : en.entrySet()){
+ if(!en2.remove(e.getKey(), e.getValue()))
+ return false;
+ }
+ return en2.isEmpty();
+ }
+
+ public void loadToPlayer(Player player) {
+ activeKits.put(player, this);
+
+ player.getInventory().clear();
+ player.getInventory().setContents(inventory);
+ if(armor != null)
+ player.getInventory().setArmorContents(armor);
+ player.updateInventory();
+ if(effects != null)
+ player.addPotionEffects(effects);
+ }
+
+ /**
+ * Opens a kit preview with the options to go back to kit selection or to select the kit.
+ */
+ public void preview(Player player){
+ SWInventory inv = new SWInventory(player, 54, name);
+
+ //36 = Inventargröße
+ for(int i = 0; i < 36; i++){
+ if(inventory[i] == null)
+ continue;
+ SWItem item = new SWItem();
+ item.setItemStack(inventory[i]);
+ inv.setItem(i, item);
+ }
+
+ if(armor != null){
+ for(int i = 0; i < 4; i++){
+ if(armor[i] == null)
+ continue;
+ SWItem item = new SWItem();
+ item.setItemStack(armor[i]);
+ inv.setItem(36 + i, item);
+ }
+ }
+
+ if(effects != null){
+ Iterator it = effects.iterator();
+ int pos = 44;
+ while(it.hasNext()){
+ PotionEffect effect = it.next();
+ SWItem item = new SWItem(SWItem.getMaterial("POTION"), effect.getType().getName());
+ inv.setItem(pos, item);
+ pos--;
+ }
+ }
+
+ inv.setCallback(-999, click -> player.closeInventory());
+ if(Config.PersonalKits){
+ inv.setItem(49, SWItem.getMaterial("WOOD_AXE"), FightSystem.getMessage().parse("KIT_PREVIEW_EDIT", player), clickType -> PersonalKitCreator.openKitCreator(player, PersonalKit.get(SteamwarUser.get(player.getUniqueId()).getId(), Config.SchematicType.toDB(), name)));
+ inv.setItem(53, Material.BARRIER, FightSystem.getMessage().parse("KIT_PREVIEW_DELETE", player), clickType -> {
+ player.closeInventory();
+ SWInventory conf = new SWInventory(player, 9, FightSystem.getMessage().parse("KIT_DELETION_CONFIRMATION", player));
+ conf.setItem(8, SWItem.getDye(1), FightSystem.getMessage().parse("KIT_DELETION_ABORT", player), click -> player.closeInventory());
+ conf.setItem(0, SWItem.getDye(10), FightSystem.getMessage().parse("KIT_DELETION_DELETE", player), click -> {
+ player.closeInventory();
+ SteamwarUser user = SteamwarUser.get(player.getUniqueId());
+ PersonalKit kit = PersonalKit.get(user.getId(), Config.SchematicType.toDB(), name);
+ if(kit.isInUse()) {
+ List kits = PersonalKit.get(user.getId(), Config.SchematicType.toDB());
+ if(!kits.isEmpty()){
+ PersonalKit kit1 = kits.get(0);
+ kit1.setInUse();
+ FightPlayer fightPlayer = Fight.getFightPlayer(player);
+ assert fightPlayer != null;
+ fightPlayer.setKit(new Kit(kit1));
+ }
+ }
+ kit.delete();
+ });
+ conf.open();
+ });
+ }
+ inv.setItem(45, SWItem.getDye(10), (byte)10, FightSystem.getMessage().parse("KIT_PREVIEW_CHOOSE", player), click -> {
+ Commands.kit(player, name);
+ player.closeInventory();
+ });
+ inv.setItem(53, SWItem.getDye(1), (byte)1, FightSystem.getMessage().parse("KIT_PREVIEW_BACK", player), click -> GUI.kitSelection(player, ""));
+ inv.open();
+ }
+
+ public static void createKit(String kitName, Player player){
+ loadedKits.add(new Kit(kitName, player));
+ YamlConfiguration yamlConfiguration = new YamlConfiguration();
+ for(Kit k : loadedKits){
+ ConfigurationSection section = yamlConfiguration.createSection("Kits." + k.getName());
+ section.set("Items", k.inventory);
+ if(k.armor != null)
+ section.set("Armor", k.armor);
+ section.set("LeaderAllowed", k.leaderAllowed);
+ section.set("MemberAllowed", k.memberAllowed);
+ section.set("Effects", k.effects);
+ section.set("EnterStage", k.enterStage);
+ section.set("TNT", k.tnt);
+ }
+
+ try {
+ yamlConfiguration.save(kits);
+ }catch(IOException e){
+ throw new SecurityException("Failed to save kits.data", e);
+ }
+ }
+}
diff --git a/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/listener/ArenaBorder.java b/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/listener/ArenaBorder.java
new file mode 100644
index 00000000..4c0daa45
--- /dev/null
+++ b/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/listener/ArenaBorder.java
@@ -0,0 +1,108 @@
+/*
+ This file is a part of the SteamWar software.
+
+ Copyright (C) 2020 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 > ghostBarriers = new HashMap<>();
+ private final Map lastLocation = new HashMap<>();
+ private final boolean contain;
+ private final String resetMessage;
+ private final String name;
+ private final Region region;
+ private final int ghostRange;
+ private final int ghostSize;
+
+ public Border(Region region, boolean contain, int ghostRange, String resetMessage, String name) {
+ this.contain = contain;
+ this.resetMessage = resetMessage;
+ this.name = name;
+ this.region = region;
+ this.ghostRange = ghostRange;
+ this.ghostSize = 2*ghostRange + 1;
+
+ new StateDependentTask(ArenaMode.All, FightState.All, this::run, 1, 1);
+ }
+
+ public void addPlayer(Player player) {
+ if(ghostBarriers.containsKey(player.getUniqueId()))
+ return;
+
+ ghostBarriers.put(player.getUniqueId(), new HashSet<>());
+ lastLocation.put(player.getUniqueId(), player.getLocation());
+ FightSystem.getPlugin().getLogger().log(Level.INFO, () -> player.getName() + " was added to border " + name);
+ }
+
+ public boolean contains(Player player) {
+ return ghostBarriers.containsKey(player.getUniqueId());
+ }
+
+ public void removePlayer(Player player) {
+ FightSystem.getPlugin().getLogger().log(Level.INFO, () -> player.getName() + " was removed from border " + name);
+ lastLocation.remove(player.getUniqueId());
+ Set blocks = ghostBarriers.remove(player.getUniqueId());
+ if(blocks == null || !player.isOnline())
+ return;
+
+ for(Block block : blocks)
+ sendChange(player, block, Material.AIR);
+ }
+
+ private void run() {
+ List offline = new ArrayList<>();
+ for(Map.Entry> entry : ghostBarriers.entrySet()) {
+ UUID uuid = entry.getKey();
+ Player player = Bukkit.getPlayer(uuid);
+ if(player == null) {
+ offline.add(uuid);
+ continue;
+ }
+
+ Location location = player.getLocation();
+ if(region.playerInRegion(location) != contain) {
+ player.teleport(lastLocation.get(uuid));
+ FightSystem.getMessage().sendPrefixless(resetMessage, player, ChatMessageType.ACTION_BAR);
+ return;
+ }
+
+ Set ghostBlocks = entry.getValue();
+ Region ghostRegion = Region.fromSize(location.getBlockX() - ghostRange, location.getBlockY() - ghostRange, location.getBlockZ() - ghostRange, ghostSize, ghostSize, ghostSize);
+ ghostBlocks.removeIf(block -> {
+ if(!ghostRegion.inRegion(block)) {
+ sendChange(player, block, Material.AIR);
+ return true;
+ }
+ return false;
+ });
+
+ if(contain) {
+ borderIteration(player, ghostBlocks, Region.fromSize(region.getMinX()-1, region.getMinY(), region.getMinZ(), 1, region.getSizeY(), region.getSizeZ()).intersection(ghostRegion));
+ borderIteration(player, ghostBlocks, Region.fromSize(region.getMinX(), region.getMinY()-1, region.getMinZ(), region.getSizeX(), 1, region.getSizeZ()).intersection(ghostRegion));
+ borderIteration(player, ghostBlocks, Region.fromSize(region.getMinX(), region.getMinY(), region.getMinZ()-1, region.getSizeX(), region.getSizeY(), 1).intersection(ghostRegion));
+ borderIteration(player, ghostBlocks, Region.fromSize(region.getMaxX(), region.getMinY(), region.getMinZ(), 1, region.getSizeY(), region.getSizeZ()).intersection(ghostRegion));
+ borderIteration(player, ghostBlocks, Region.fromSize(region.getMinX(), region.getMaxY(), region.getMinZ(), region.getSizeX(), 1, region.getSizeZ()).intersection(ghostRegion));
+ borderIteration(player, ghostBlocks, Region.fromSize(region.getMinX(), region.getMinY(), region.getMaxZ(), region.getSizeX(), region.getSizeY(), 1).intersection(ghostRegion));
+ } else {
+ borderIteration(player, ghostBlocks, Region.fromSize(region.getMinX(), region.getMinY(), region.getMinZ(), 1, region.getSizeY(), region.getSizeZ()).intersection(ghostRegion));
+ borderIteration(player, ghostBlocks, Region.fromSize(region.getMinX(), region.getMinY(), region.getMinZ(), region.getSizeX(), 1, region.getSizeZ()).intersection(ghostRegion));
+ borderIteration(player, ghostBlocks, Region.fromSize(region.getMinX(), region.getMinY(), region.getMinZ(), region.getSizeX(), region.getSizeY(), 1).intersection(ghostRegion));
+ borderIteration(player, ghostBlocks, Region.fromSize(region.getMaxX()-1, region.getMinY(), region.getMinZ(), 1, region.getSizeY(), region.getSizeZ()).intersection(ghostRegion));
+ borderIteration(player, ghostBlocks, Region.fromSize(region.getMinX(), region.getMaxY()-1, region.getMinZ(), region.getSizeX(), 1, region.getSizeZ()).intersection(ghostRegion));
+ borderIteration(player, ghostBlocks, Region.fromSize(region.getMinX(), region.getMinY(), region.getMaxZ()-1, region.getSizeX(), region.getSizeY(), 1).intersection(ghostRegion));
+ }
+
+ lastLocation.put(entry.getKey(), location);
+ }
+
+ offline.forEach(uuid -> FightSystem.getPlugin().getLogger().log(Level.INFO, () -> uuid + " was removed from border " + name));
+ offline.forEach(ghostBarriers::remove);
+ offline.forEach(lastLocation::remove);
+ }
+
+ private void borderIteration(Player player, Set ghostBlocks, Region border) {
+ border.forEach((x, y, z) -> {
+ Block block = Config.world.getBlockAt(x, y, z);
+ if(ghostBlocks.add(block))
+ sendChange(player, block, Material.BARRIER);
+ });
+ }
+
+ private void sendChange(Player player, Block block, Material type) {
+ if(block.getType() == Material.AIR)
+ FlatteningWrapper.impl.sendBlockChange(player, block, type);
+ }
+}
diff --git a/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/listener/Chat.java b/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/listener/Chat.java
new file mode 100644
index 00000000..827f46c9
--- /dev/null
+++ b/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/listener/Chat.java
@@ -0,0 +1,70 @@
+/*
+ This file is a part of the SteamWar software.
+
+ Copyright (C) 2020 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 scores = new HashMap<>();
+
+
+ private FightScoreboard(){
+ new StateDependentListener(ArenaMode.Replay, FightState.All, this);
+ Bukkit.getOnlinePlayers().forEach(player -> SWScoreboard.createScoreboard(player, this));
+ }
+
+ @EventHandler
+ public void onPlayerJoin(PlayerJoinEvent event) {
+ SWScoreboard.createScoreboard(event.getPlayer(), this);
+ }
+
+ @EventHandler
+ public void onPlayerQuit(PlayerQuitEvent event) {
+ SWScoreboard.removeScoreboard(event.getPlayer());
+ }
+
+ public void setTitle(String t) {
+ scores.clear();
+ title = t;
+ }
+
+ public void addScore(String string, int i) {
+ scores.put(string, i);
+ }
+
+ @Override
+ public String getTitle() {
+ return title;
+ }
+
+ @Override
+ public HashMap getData() {
+ return scores;
+ }
+}
diff --git a/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/listener/InFightDamage.java b/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/listener/InFightDamage.java
new file mode 100644
index 00000000..7194fdd6
--- /dev/null
+++ b/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/listener/InFightDamage.java
@@ -0,0 +1,88 @@
+/*
+ This file is a part of the SteamWar software.
+
+ Copyright (C) 2020 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 allowed = Collections.unmodifiableSet(EnumSet.of(Material.TNT, Material.AIR));
+
+ public InFightInventory() {
+ new StateDependentListener(ArenaMode.AntiReplay, FightState.Ingame, this);
+ }
+
+ @EventHandler
+ public void onInventoryClick(InventoryClickEvent event) {
+ if(!Fight.fighting((Player) event.getWhoClicked()))
+ return;
+
+ InventoryType top = event.getView().getTopInventory().getType();
+ if(top == InventoryType.CRAFTING)
+ return;
+
+ if ((event.getCursor() != null && !allowed.contains(event.getCursor().getType())) || (event.getCurrentItem() != null && !allowed.contains(event.getCurrentItem().getType())))
+ event.setCancelled(true); // Deny if transferred item is not TNT
+ }
+
+ @EventHandler
+ public void onInventoryDrag(InventoryDragEvent event) {
+ if(!Fight.fighting((Player) event.getWhoClicked()))
+ return;
+
+ if (event.getInventory().getType() != InventoryType.PLAYER) {
+ int inventorySize = event.getInventory().getSize();
+
+ for (int i : event.getRawSlots()) {
+ if (i < inventorySize) {
+ event.setCancelled(true);
+ break;
+ }
+ }
+ }
+ }
+}
diff --git a/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/listener/IngameDeath.java b/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/listener/IngameDeath.java
new file mode 100644
index 00000000..6ff538f4
--- /dev/null
+++ b/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/listener/IngameDeath.java
@@ -0,0 +1,78 @@
+/*
+ This file is a part of the SteamWar software.
+
+ Copyright (C) 2020 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 withLivingPlayer) {
+ if(!(player instanceof LivingEntity))
+ return;
+
+ FightPlayer fightPlayer = Fight.getFightPlayer((LivingEntity) player);
+ if(fightPlayer == null || !fightPlayer.isLiving())
+ return;
+
+ withLivingPlayer.accept(fightPlayer);
+ }
+}
diff --git a/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/listener/JoinRequestListener.java b/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/listener/JoinRequestListener.java
new file mode 100644
index 00000000..1ed3fe8b
--- /dev/null
+++ b/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/listener/JoinRequestListener.java
@@ -0,0 +1,74 @@
+/*
+ This file is a part of the SteamWar software.
+
+ Copyright (C) 2022 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 spectatorsInArena = new HashMap<>();
+
+ public LeaveableArena() {
+ new StateDependentListener(Config.ArenaLeaveable, FightState.All, this);
+ }
+
+ @EventHandler(priority = EventPriority.MONITOR)
+ public void onJoin(PlayerSpawnLocationEvent event) {
+ Player player = event.getPlayer();
+ if(Fight.fighting(player))
+ return;
+
+ if(Config.ArenaRegion.in2dRegion(event.getSpawnLocation())) {
+ markInArena(player);
+ }
+ }
+
+ @EventHandler(priority = EventPriority.MONITOR)
+ public void onRespawn(PlayerRespawnEvent event) {
+ Player player = event.getPlayer();
+ if(Config.ArenaRegion.in2dRegion(event.getRespawnLocation())) {
+ markInArena(player);
+ } else {
+ spectatorsInArena.remove(player);
+ }
+ }
+
+ @EventHandler
+ public void arenaBorder(PlayerMoveEvent event){
+ Player player = event.getPlayer();
+ if(Fight.fighting(player))
+ return;
+
+ boolean inArena = Config.ArenaRegion.in2dRegion(event.getTo());
+ boolean spectator = spectatorsInArena.containsKey(player);
+
+ if(inArena && !spectator) {
+ markInArena(player);
+ } else if(!inArena && spectator) {
+ GameMode mode = spectatorsInArena.remove(player);
+ if(mode != null)
+ player.setGameMode(mode);
+ }
+ }
+
+ private void markInArena(Player player) {
+ spectatorsInArena.put(player, player.getGameMode());
+ Fight.setPlayerGamemode(player, GameMode.SPECTATOR);
+ }
+}
diff --git a/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/listener/NormalJoin.java b/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/listener/NormalJoin.java
new file mode 100644
index 00000000..371ae75c
--- /dev/null
+++ b/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/listener/NormalJoin.java
@@ -0,0 +1,49 @@
+/*
+ This file is a part of the SteamWar software.
+
+ Copyright (C) 2020 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 openKitCreators = new HashMap<>();
+
+ public PersonalKitCreator(){
+ new StateDependentListener(Config.PersonalKits, FightState.Setup, this);
+ }
+
+ public static void openKitCreator(Player player, PersonalKit kit){
+ player.closeInventory();
+ new InventoryBackup(player, kit);
+ new Kit(kit).loadToPlayer(player);
+ player.setGameMode(GameMode.CREATIVE);
+ FightSystem.getMessage().sendPrefixless("OPEN_INVENTORY_TO_CUSTOMIZE", player, ChatMessageType.ACTION_BAR);
+ }
+
+ public static boolean inKitCreator(HumanEntity player){
+ return openKitCreators.containsKey(player);
+ }
+
+ public static void closeIfInKitCreator(HumanEntity player){
+ InventoryBackup backup = openKitCreators.get(player);
+ if(backup == null)
+ return;
+
+ backup.close();
+ }
+
+ @EventHandler
+ public void onInventoryClick(InventoryClickEvent e){
+ if(!openKitCreators.containsKey(e.getWhoClicked()))
+ return;
+
+ Player player = (Player) e.getWhoClicked();
+ //Deny bad items
+ if(Kit.isBadItem(e.getCursor()))
+ e.setCancelled(true);
+
+ /* Should the inventory reset? */
+ if(e.getAction() != InventoryAction.PLACE_ALL)
+ return;
+
+ ItemStack[] items = e.getWhoClicked().getInventory().getContents();
+ for(int i = 0; i < items.length; i++){
+ ItemStack stack = items[i];
+ if(stack != null && i != e.getSlot())
+ return;
+ }
+
+ FightPlayer fightPlayer = Fight.getFightPlayer(player);
+ assert fightPlayer != null;
+ Bukkit.getScheduler().runTaskLater(FightSystem.getPlugin(), () -> fightPlayer.getKit().loadToPlayer(player), 1);
+ }
+
+ @EventHandler
+ public void onMoveEvent(PlayerMoveEvent e){
+ InventoryBackup backup = openKitCreators.get(e.getPlayer());
+ if(backup == null)
+ return;
+
+ backup.close();
+ }
+
+ @EventHandler
+ public void onOpenEvent(InventoryOpenEvent e){
+ InventoryBackup backup = openKitCreators.get(e.getPlayer());
+ if(backup == null)
+ return;
+
+ backup.close();
+ }
+
+ @EventHandler
+ public void onInventoryClose(InventoryCloseEvent e) {
+ InventoryBackup backup = openKitCreators.get(e.getPlayer());
+ if(backup == null)
+ return;
+
+ backup.close();
+ }
+
+ @EventHandler
+ public void onPlayerExit(PlayerQuitEvent e){
+ InventoryBackup backup = openKitCreators.get(e.getPlayer());
+ if(backup == null)
+ return;
+
+ backup.close();
+ }
+
+ private static class InventoryBackup{
+ private final Player player;
+ private final PersonalKit kit;
+ private final Kit backup;
+
+ private InventoryBackup(Player player, PersonalKit kit){
+ openKitCreators.put(player, this);
+ this.player = player;
+ this.backup = Kit.getActiveKit(player);
+ this.kit = kit;
+ }
+
+ private void close(){
+ openKitCreators.remove(player);
+ Kit kit1 = new Kit(kit.getName(), player);
+ kit1.removeBadItems();
+ kit1.toPersonalKit(kit);
+ backup.loadToPlayer(player);
+ player.setGameMode(GameMode.SURVIVAL);
+ kit.setInUse();
+ player.closeInventory();
+ Objects.requireNonNull(Fight.getFightPlayer(player)).setKit(new Kit(kit));
+ }
+ }
+}
diff --git a/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/listener/PistonListener.java b/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/listener/PistonListener.java
new file mode 100644
index 00000000..26c2fb89
--- /dev/null
+++ b/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/listener/PistonListener.java
@@ -0,0 +1,79 @@
+/*
+ This file is a part of the SteamWar software.
+
+ Copyright (C) 2020 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 leftAreaHandler;
+
+ public PistonListener(Set condition, Consumer leftAreaHandler) {
+ this.leftAreaHandler = leftAreaHandler;
+ if(!condition.contains(Config.mode))
+ return;
+
+ //Wenn Entern aktiv ist, sollen Raketen etc. entern können
+ new StateDependentListener(!Config.AllowMissiles, FightState.All, this);
+ new StateDependentListener(Config.AllowMissiles, FightState.Setup, this);
+ }
+
+ @EventHandler
+ public void handlePistonExtend(BlockPistonExtendEvent e){
+ if(!Config.ArenaRegion.inRegion(e.getBlock()))
+ return;
+
+ BlockFace face = e.getDirection();
+ for(Block block : e.getBlocks()){
+ Block target = block.getRelative(face);
+ if(!Config.BlueExtendRegion.inRegion(target) && !Config.RedExtendRegion.inRegion(target) && block.getPistonMoveReaction() != PistonMoveReaction.BREAK) {
+ leftAreaHandler.accept(e);
+ return;
+ }
+ }
+ }
+
+ @EventHandler
+ public void handlePistonRetract(BlockPistonRetractEvent e){
+ if(!Config.ArenaRegion.inRegion(e.getBlock()))
+ return;
+
+ for(Block block : e.getBlocks()){
+ if(!Config.BlueExtendRegion.inRegion(block) && !Config.RedExtendRegion.inRegion(block)) {
+ leftAreaHandler.accept(e);
+ return;
+ }
+ }
+ }
+}
diff --git a/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/listener/PrepareSchem.java b/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/listener/PrepareSchem.java
new file mode 100644
index 00000000..288eda76
--- /dev/null
+++ b/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/listener/PrepareSchem.java
@@ -0,0 +1,135 @@
+/*
+ This file is a part of the SteamWar software.
+
+ Copyright (C) 2020 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 stationaryMovingPistons = new HashSet<>();
+
+ public PrepareSchem() {
+ new OneShotStateDependent(ArenaMode.Prepare, FightState.PostSchemSetup, () -> Bukkit.getScheduler().runTaskLater(FightSystem.getPlugin(), () -> {
+ stationaryMovingPistons.clear();
+ Fight.getUnrotated().getSchemRegion().forEach((x, y, z) -> {
+ if(FlatteningWrapper.impl.checkPistonMoving(Config.world.getBlockAt(x, y, z)))
+ stationaryMovingPistons.add(new Vector(x, y, z));
+ });
+ }, 1));
+
+ new StateDependentListener(ArenaMode.Prepare, FightState.Setup, this){
+ @Override
+ public void disable() {
+ super.disable();
+ Region region = Fight.getUnrotated().getExtendRegion();
+ int minY = Fight.getUnrotated().getSchemRegion().getMinY();
+
+ SchematicNode schem;
+ try{
+ schem = SchematicNode.getSchematicNode(Config.PrepareSchemID);
+ }catch(SecurityException e){
+ FightSystem.getMessage().broadcast("PREPARE_SCHEM_DELETED");
+ Bukkit.shutdown();
+ return;
+ }
+
+ try{
+ region.forEach((x, y, z) -> {
+ if(FlatteningWrapper.impl.checkPistonMoving(Config.world.getBlockAt(x, y, z)) && !stationaryMovingPistons.contains(new Vector(x, y, z))){
+ FightSystem.getMessage().broadcast("PREPARE_ACTIVE_PISTON");
+ Bukkit.shutdown();
+ throw new IllegalStateException();
+ }
+ });
+ }catch (IllegalStateException e){
+ return;
+ }
+
+ if(schemExists(schem))
+ return;
+
+ schem = SchematicNode.createSchematicNode(schem.getOwner(), preparedName(schem), schem.getParent(), Config.SchematicType.checkType().toDB(), schem.getItem());
+
+ try{
+ WorldeditWrapper.impl.saveSchem(schem, region, minY);
+ }catch(WorldEditException e){
+ FightSystem.getMessage().broadcast("PREPARE_FAILED_SAVING");
+ Bukkit.shutdown();
+ schem.delete();
+ throw new SecurityException("Could not save schem", e);
+ }
+
+ FightSystem.getMessage().broadcast("PREPARE_SENT_IN");
+ Bukkit.shutdown();
+ }
+ };
+ }
+
+ @EventHandler
+ public void handlePlayerJoin(PlayerJoinEvent event) {
+ Player player = event.getPlayer();
+ FightTeam team = Fight.getPlayerTeam(player);
+
+ if (team == null) {
+ Fight.getUnrotated().addMember(player);
+ }
+
+ if(FightState.getFightState() == FightState.PRE_LEADER_SETUP) {
+ FightState.setFightState(FightState.PRE_SCHEM_SETUP);
+ FightState.setFightState(FightState.POST_SCHEM_SETUP);
+ }
+
+ schemExists(SchematicNode.getSchematicNode(Config.PrepareSchemID));
+ }
+
+ private boolean schemExists(SchematicNode schem) {
+ if(SchematicNode.getSchematicNode(schem.getOwner(), preparedName(schem), schem.getParent()) != null) {
+ FightSystem.getMessage().broadcast("PREPARE_SCHEM_EXISTS");
+ Bukkit.shutdown();
+ return true;
+ }
+ return false;
+ }
+
+ private String preparedName(SchematicNode schem) {
+ return schem.getName() + "-prepared";
+ }
+}
diff --git a/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/listener/Recording.java b/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/listener/Recording.java
new file mode 100644
index 00000000..f77c1904
--- /dev/null
+++ b/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/listener/Recording.java
@@ -0,0 +1,309 @@
+/*
+ This file is a part of the SteamWar software.
+
+ Copyright (C) 2020 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 filter, Consumer consumer) {
+ CraftbukkitWrapper.impl.entityIterator().filter(filter).map(entity -> (Entity) getBukkitEntity.invoke(entity)).forEach(consumer);
+ }
+
+ public Recording() {
+ new StateDependentListener(ArenaMode.AntiReplay, FightState.All, this);
+ new StateDependentListener(ArenaMode.AntiReplay, FightState.All, BountifulWrapper.impl.newHandSwapRecorder());
+ new StateDependent(ArenaMode.AntiReplay, FightState.Ingame){
+ @Override
+ public void enable() {
+ Bukkit.getScheduler().runTaskLater(FightSystem.getPlugin(), () -> Fight.teams().forEach(Recording.this::setKitItems), 1);
+ }
+
+ @Override
+ public void disable() {
+ Fight.teams().forEach(Recording.this::despawnTeam);
+ despawnTNT();
+ }
+ }.register();
+ new StateDependent(ArenaMode.AntiReplay, FightState.Ingame) {
+ private final BiFunction place = Recording.this::blockPlace;
+ private final BiFunction dig = Recording.this::blockDig;
+
+ @Override
+ public void enable() {
+ TinyProtocol.instance.addFilter(blockPlacePacket, place);
+ TinyProtocol.instance.addFilter(blockDigPacket, dig);
+ }
+
+ @Override
+ public void disable() {
+ TinyProtocol.instance.removeFilter(blockPlacePacket, place);
+ TinyProtocol.instance.removeFilter(blockDigPacket, dig);
+ }
+ }.register();
+ new StateDependentTask(ArenaMode.AntiReplay, FightState.All, () -> {
+ GlobalRecorder.getInstance().tick();
+
+ if(FightState.getFightState() == FightState.SPECTATE || !GlobalRecorder.getInstance().recording())
+ return;
+
+ iterateOverEntities(primedTnt::isInstance, this::trackEntity);
+ }, 1, 1);
+ }
+
+ private void trackEntity(Entity entity) {
+ GlobalRecorder.getInstance().entityMoves(entity);
+ GlobalRecorder.getInstance().entitySpeed(entity);
+ }
+
+ private static final Class blockDigPacket = Reflection.getClass("{nms.network.protocol.game}.PacketPlayInBlockDig");
+ private static final Class playerDigType = blockDigPacket.getDeclaredClasses()[0];
+ private static final Reflection.FieldAccessor blockDigType = Reflection.getField(blockDigPacket, playerDigType, 0);
+ private static final Object releaseUseItem = playerDigType.getEnumConstants()[5];
+ private Object blockDig(Player p, Object packet) {
+ if(!isNotSent(p) && blockDigType.get(packet) == releaseUseItem)
+ GlobalRecorder.getInstance().bowSpan(p, false, false);
+ return packet;
+ }
+
+ public static final Class blockPlacePacket = Reflection.getClass("{nms.network.protocol.game}.PacketPlayInBlockPlace");
+ private Object blockPlace(Player p, Object packet) {
+ boolean mainHand = BountifulWrapper.impl.mainHand(packet);
+ if(!isNotSent(p) && BountifulWrapper.impl.bowInHand(mainHand, p))
+ GlobalRecorder.getInstance().bowSpan(p, true, !mainHand);
+ return packet;
+ }
+
+ @EventHandler
+ public void onPlayerSpawn(TeamSpawnEvent e) {
+ GlobalRecorder.getInstance().playerJoins(e.getFightPlayer().getEntity(), e.getFightPlayer().getUser());
+ }
+
+ @EventHandler(priority = EventPriority.HIGH)
+ public void onPlayerMove(PlayerMoveEvent e){
+ if(isNotSent(e.getPlayer()))
+ return;
+
+ GlobalRecorder.getInstance().entityMoves(e.getPlayer());
+ }
+
+ @EventHandler
+ public void onPlayerDeath(TeamDeathEvent e) {
+ GlobalRecorder.getInstance().entityDespawns(e.getFightPlayer().getEntity());
+ }
+
+ @EventHandler
+ public void onPlayerLeave(TeamLeaveEvent e) {
+ GlobalRecorder.getInstance().entityDespawns(e.getFightPlayer().getEntity());
+ }
+
+ @EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
+ public void onBlockPhysics(BlockPhysicsEvent e){
+ if(FlatteningWrapper.impl.doRecord(e))
+ GlobalRecorder.getInstance().blockChange(e.getBlock());
+ }
+
+ @EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
+ public void onSneak(PlayerToggleSneakEvent e){
+ if(isNotSent(e.getPlayer()))
+ return;
+
+ GlobalRecorder.getInstance().playerSneak(e.getPlayer(), e.isSneaking());
+ }
+
+ @EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
+ public void onAnimation(PlayerAnimationEvent e){
+ if(isNotSent(e.getPlayer()))
+ return;
+
+ if(e.getAnimationType() == PlayerAnimationType.ARM_SWING)
+ GlobalRecorder.getInstance().entityAnimation(e.getPlayer(), AIR);
+ }
+
+ @EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
+ public void onEntityDamage(EntityDamageEvent e) {
+ if(e.getEntityType() != EntityType.PLAYER)
+ return;
+
+ Player p = (Player) e.getEntity();
+ if(isNotSent(p))
+ return;
+
+ GlobalRecorder.getInstance().damageAnimation(p);
+
+ if(e.getCause() == EntityDamageEvent.DamageCause.FIRE_TICK || e.getCause() == EntityDamageEvent.DamageCause.FIRE)
+ GlobalRecorder.getInstance().setOnFire(p, false);
+ }
+
+ @EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
+ public void onEntityCombust(EntityCombustEvent e) {
+ if(e.getEntityType() != EntityType.PLAYER)
+ return;
+
+ Player p = (Player) e.getEntity();
+ if(isNotSent(p))
+ return;
+
+ GlobalRecorder.getInstance().setOnFire(p, false);
+ }
+
+ @EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
+ public void onTNTSpawn(EntitySpawnEvent e){
+ if(e.getEntityType() != EntityType.PRIMED_TNT)
+ return;
+
+ GlobalRecorder.getInstance().tntSpawn(e.getEntity());
+ }
+
+ @EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
+ public void onExplosion(EntityExplodeEvent e){
+ if(e.getEntityType() != EntityType.PRIMED_TNT)
+ return;
+
+ Location loc = e.getLocation();
+ GlobalRecorder.getInstance().entityDespawns(e.getEntity());
+ GlobalRecorder.getInstance().particle(loc.getX(), loc.getY(), loc.getZ(), "EXPLOSION_HUGE");
+ GlobalRecorder.getInstance().sound(loc.getBlockX(), loc.getBlockY(), loc.getBlockZ(), SWSound.ENTITY_GENERIC_EXPLODE, "BLOCKS", 4.0F, (1.0F + (random.nextFloat() - random.nextFloat()) * 0.2F) * 0.7F);
+ }
+
+ @EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
+ public void onItem(PlayerItemHeldEvent e){
+ if(isNotSent(e.getPlayer()))
+ return;
+
+ GlobalRecorder.getInstance().item(e.getPlayer(), disarmNull(e.getPlayer().getInventory().getItem(e.getNewSlot())), "MAINHAND");
+ }
+
+ @EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
+ public void onProjectileSpawn(ProjectileLaunchEvent e){
+ if(e.getEntityType() == EntityType.FIREBALL)
+ GlobalRecorder.getInstance().fireballSpawn(e.getEntity());
+ else if(e.getEntityType() == EntityType.ARROW)
+ GlobalRecorder.getInstance().arrowSpawn(e.getEntity());
+ }
+
+ @EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
+ public void onInventoryClick(InventoryClickEvent e){
+ Player player = (Player) e.getWhoClicked();
+ if(isNotSent(player))
+ return;
+
+ if(e.getSlotType() != InventoryType.SlotType.ARMOR)
+ return;
+
+ switch(e.getSlot()){
+ case 103:
+ GlobalRecorder.getInstance().item(player, disarmNull(e.getCurrentItem()), "HEAD");
+ break;
+ case 102:
+ GlobalRecorder.getInstance().item(player, disarmNull(e.getCurrentItem()), "CHEST");
+ break;
+ case 101:
+ GlobalRecorder.getInstance().item(player, disarmNull(e.getCurrentItem()), "LEGS");
+ break;
+ case 100:
+ default:
+ GlobalRecorder.getInstance().item(player, disarmNull(e.getCurrentItem()), "FEET");
+ }
+ }
+
+ private void setKitItems(FightTeam team){
+ if(FightState.getFightState() != FightState.PRE_RUNNING)
+ return;
+
+ for(FightPlayer fp : team.getPlayers()){
+ if(!fp.isLiving())
+ continue;
+
+ fp.ifPlayer(player -> {
+ BountifulWrapper.impl.recordHandItems(player);
+ GlobalRecorder.getInstance().item(player, disarmNull(player.getInventory().getHelmet()), "HEAD");
+ GlobalRecorder.getInstance().item(player, disarmNull(player.getInventory().getChestplate()), "CHEST");
+ GlobalRecorder.getInstance().item(player, disarmNull(player.getInventory().getLeggings()), "LEGS");
+ GlobalRecorder.getInstance().item(player, disarmNull(player.getInventory().getBoots()), "FEET");
+ });
+ }
+ }
+
+ private void despawnTeam(FightTeam team){
+ for(FightPlayer player : team.getPlayers()){
+ if(player.isLiving())
+ GlobalRecorder.getInstance().entityDespawns(player.getEntity());
+ }
+ }
+
+ private void despawnTNT(){
+ iterateOverEntities(primedTnt::isInstance, GlobalRecorder.getInstance()::entityDespawns);
+ }
+}
diff --git a/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/listener/RunningWorldInteraction.java b/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/listener/RunningWorldInteraction.java
new file mode 100644
index 00000000..7c00a9f1
--- /dev/null
+++ b/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/listener/RunningWorldInteraction.java
@@ -0,0 +1,48 @@
+/*
+ This file is a part of the SteamWar software.
+
+ Copyright (C) 2021 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 realSpectator = new HashSet<>();
+
+ public TeamArea(FightTeam team) {
+ this.team = team;
+ this.spectatorBorder = new Border(team.getExtendRegion(), false, 5, "NO_TEAMAREA", team.getName() + ".spectatorBorder");
+ this.bordingBorder = new Border(team.getExtendRegion().to2d(), true, 1, "NO_ENTERN", team.getName() + ".boardingBorder");
+
+ new StateDependentListener(ArenaMode.AntiTest, FightState.All, this);
+ new StateDependentTask(ArenaMode.AntiTest, FightState.TeamFix, this::realSpectatorCheck, 1, 1);
+ new OneShotStateDependent(ArenaMode.AntiTest, FightState.Spectate, () -> Fight.teams().forEach(t -> t.getPlayers().forEach(this::teamSpectator)));
+ }
+
+ @EventHandler
+ public void playerJoin(PlayerJoinEvent e) {
+ Player player = e.getPlayer();
+ if(Fight.getPlayerTeam(player) != team && !Config.isReferee(player))
+ spectatorBorder.addPlayer(player);
+ }
+
+ @EventHandler
+ public void teamJoin(TeamSpawnEvent e) {
+ FightPlayer fightPlayer = e.getFightPlayer();
+ if(fightPlayer.getTeam() == team) {
+ fightPlayer.ifPlayer(player -> {
+ spectatorBorder.removePlayer(player);
+ bordingBorder.addPlayer(player);
+ });
+ }
+ }
+
+ @EventHandler
+ public void teamLeave(TeamLeaveEvent e) {
+ FightPlayer fightPlayer = e.getFightPlayer();
+ fightPlayer.ifPlayer(spectatorBorder::addPlayer);
+ if(fightPlayer.getTeam() == team)
+ fightPlayer.ifPlayer(bordingBorder::removePlayer);
+ }
+
+ @EventHandler
+ public void boarding(BoardingEvent e) {
+ FightPlayer fightPlayer = e.getFightPlayer();
+ if(fightPlayer.getTeam() == team) {
+ fightPlayer.ifPlayer(bordingBorder::removePlayer);
+ } else {
+ fightPlayer.ifPlayer(spectatorBorder::removePlayer);
+ }
+ }
+
+ @EventHandler
+ public void teamDeath(TeamDeathEvent e) {
+ teamSpectator(e.getFightPlayer());
+ }
+
+ private void teamSpectator(FightPlayer fightPlayer) {
+ if(fightPlayer.getTeam() == team) {
+ fightPlayer.ifPlayer(bordingBorder::removePlayer);
+ } else {
+ fightPlayer.ifPlayer(spectatorBorder::addPlayer);
+ }
+ }
+
+ @EventHandler
+ public void playerQuit(PlayerQuitEvent e) {
+ Player player = e.getPlayer();
+ spectatorBorder.removePlayer(player);
+ bordingBorder.removePlayer(player);
+ realSpectator.remove(player);
+ }
+
+ private void realSpectatorCheck() {
+ for(FightPlayer fightPlayer : team.getPlayers()) {
+ if(fightPlayer.isLiving())
+ continue;
+
+ fightPlayer.ifPlayer(player -> {
+ boolean inRegion = team.getExtendRegion().playerInRegion(player.getLocation());
+ if(inRegion && !realSpectator.contains(player)) {
+ realSpectator.add(player);
+
+ //Later to prevent race condition with Fight.setSpecatator() during respawn
+ Bukkit.getScheduler().runTaskLater(FightSystem.getPlugin(), () -> {
+ if(!player.isOnline())
+ return;
+ Fight.pseudoSpectator(player, false);
+ }, 2);
+ }else if(!inRegion && realSpectator.contains(player)) {
+ Fight.pseudoSpectator(player, true);
+ realSpectator.remove(player);
+ }
+ });
+ }
+ }
+}
diff --git a/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/listener/TestJoin.java b/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/listener/TestJoin.java
new file mode 100644
index 00000000..77240153
--- /dev/null
+++ b/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/listener/TestJoin.java
@@ -0,0 +1,64 @@
+/*
+ This file is a part of the SteamWar software.
+
+ Copyright (C) 2020 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 tnt = new HashMap<>();
+
+ public WaterRemover() {
+ new StateDependentListener(ArenaMode.AntiReplay, FightState.Running, this){
+ @Override
+ public void enable() {
+ tnt.clear();
+ super.enable();
+ }
+ };
+ }
+
+ @EventHandler
+ public void handleEntitySpawn(EntitySpawnEvent event) {
+ if(event.getEntityType() != EntityType.PRIMED_TNT)
+ return;
+
+ Location location = event.getLocation();
+ Fight.teams().forEach(team -> {
+ if(team.getExtendRegion().inRegion(location))
+ tnt.put(event.getEntity().getEntityId(), team);
+ });
+ }
+
+ @EventHandler
+ public void handleEntityExplode(EntityExplodeEvent event) {
+ event.setYield(0); //No drops (additionally to world config)
+
+ FightTeam spawn = tnt.remove(event.getEntity().getEntityId());
+ if(spawn != null && !spawn.getExtendRegion().inRegion(event.getLocation())) {
+ Block b = event.getLocation().getBlock();
+ for(int y = -1; y <= 1; y++) {
+ for(int z = -1; z <= 1; z++) {
+ for(int x = -1; x <= 1; x++) {
+ checkBlock(b.getRelative(x, y, z));
+ }
+ }
+ }
+ }
+
+ event.blockList().forEach(this::checkNeighbours);
+ }
+
+ private void checkNeighbours(Block b) {
+ checkBlock(b.getRelative(BlockFace.UP));
+ checkBlock(b.getRelative(BlockFace.EAST));
+ checkBlock(b.getRelative(BlockFace.WEST));
+ checkBlock(b.getRelative(BlockFace.NORTH));
+ checkBlock(b.getRelative(BlockFace.SOUTH));
+ checkBlock(b.getRelative(BlockFace.DOWN));
+ }
+
+ private void checkBlock(Block b) {
+ //do not remove outside teamareas
+ if(!Config.BlueExtendRegion.inRegion(b) && !Config.RedExtendRegion.inRegion(b))
+ return;
+
+ //checks for water and removes it, if present
+ if(!FlatteningWrapper.impl.removeWater(b))
+ return;
+
+ if(b.getY() < MIN_Y)
+ return;
+
+ checkNeighbours(b);
+ }
+}
diff --git a/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/record/FileRecorder.java b/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/record/FileRecorder.java
new file mode 100644
index 00000000..98933dd8
--- /dev/null
+++ b/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/record/FileRecorder.java
@@ -0,0 +1,75 @@
+/*
+ This file is a part of the SteamWar software.
+
+ Copyright (C) 2020 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 recorders = new ArrayList<>();
+ private final DataOutputStream outputStream = new DataOutputStream(this);
+
+ public void add(Recorder recorder){
+ recorders.add(recorder);
+ }
+
+ public void remove(Recorder recorder){
+ recorders.remove(recorder);
+ }
+
+ public boolean recording(){
+ return !recorders.isEmpty();
+ }
+
+ @Override
+ public DataOutputStream getStream() {
+ return outputStream;
+ }
+
+ @Override
+ public void write(int i) {
+ foreach(stream -> stream.write(i));
+ }
+
+ @Override
+ public void write(byte[] bytes, int i, int i1) {
+ foreach(stream -> stream.write(bytes, i, i1));
+ }
+
+ @Override
+ public void flush() {
+ foreach(OutputStream::flush);
+ }
+
+ @Override
+ public void close() {
+ foreach(OutputStream::close);
+ }
+
+ private void foreach(IOThrower thrower) {
+ for(int i = 0; i < recorders.size(); i++) {
+ Recorder stream = recorders.get(i);
+ try{
+ thrower.run(stream.getStream());
+ }catch (IOException e){
+ Bukkit.getLogger().log(Level.SEVERE, "Could not operate on OutputStream", e);
+ stream.disable();
+ i--; // Recorder was removed from recorders
+ }
+ }
+ }
+
+ interface IOThrower{
+ void run(OutputStream stream) throws IOException;
+ }
+}
diff --git a/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/record/LiveRecorder.java b/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/record/LiveRecorder.java
new file mode 100644
index 00000000..55fef032
--- /dev/null
+++ b/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/record/LiveRecorder.java
@@ -0,0 +1,70 @@
+/*
+ This file is a part of the SteamWar software.
+
+ Copyright (C) 2020 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 syncList = new LinkedList<>();
+ private final Set hiddenBlockIds = Config.HiddenBlocks.stream().flatMap(m -> BlockIds.impl.materialToAllIds(m).stream()).collect(Collectors.toSet());
+ private final int obfuscateWith = BlockIds.impl.materialToId(Config.ObfuscateWith);
+ private final FreezeWorld freezer = new FreezeWorld();
+ private final REntityServer entityServer = new REntityServer();
+ private final Map entities = new HashMap<>();
+
+ private boolean rotateZ = false;
+ private int arenaMinX = Config.ArenaRegion.getMinX();
+ private int arenaMinY = Config.BluePasteRegion.getMinY();
+ private int arenaMinZ = Config.ArenaRegion.getMinZ();
+
+ private boolean skipToSubtitle = false;
+
+ private boolean tickFinished = false;
+ private final List lastPackets = new LinkedList<>();
+
+ public PacketProcessor(PacketSource source) {
+ this.source = source;
+ currentProcessor = this;
+
+ packetDecoder[0x00] = this::playerJoins;
+ packetDecoder[0x01] = this::entityMoves;
+ packetDecoder[0x02] = this::entityDespawns;
+ packetDecoder[0x03] = this::entitySneak;
+ packetDecoder[0x04] = this::entityAnimation;
+ packetDecoder[0x05] = this::tntSpawn;
+ packetDecoder[0x06] = this::entityVelocity;
+ packetDecoder[0x07] = this::playerItem;
+ packetDecoder[0x08] = this::arrowSpawn;
+ packetDecoder[0x09] = this::fireballSpawn;
+ packetDecoder[0x0a] = this::bow;
+ packetDecoder[0x0b] = this::damage;
+ packetDecoder[0x0c] = this::fireTick;
+ packetDecoder[0x20] = this::oldArenaInfo;
+ packetDecoder[0x21] = this::arenaInfo;
+ packetDecoder[0x30] = this::byteWorldHeightBlock;
+ packetDecoder[0x31] = this::particle;
+ packetDecoder[0x32] = this::sound;
+ packetDecoder[0x33] = this::shortBlock;
+ packetDecoder[0x34] = this::soundAtPlayer;
+ packetDecoder[0x35] = this::shortRelativeBlock;
+ packetDecoder[0x36] = this::block;
+ packetDecoder[0xa0] = () -> send(ChatMessageType.CHAT);
+ packetDecoder[0xa1] = () -> send(ChatMessageType.ACTION_BAR);
+ packetDecoder[0xa2] = () -> send(ChatMessageType.SYSTEM);
+ packetDecoder[0xa3] = this::countdown;
+ packetDecoder[0xa4] = this::chat;
+ packetDecoder[0xa5] = this::system;
+ packetDecoder[0xb0] = () -> pasteSchem(Fight.getBlueTeam());
+ packetDecoder[0xb1] = () -> pasteSchem(Fight.getRedTeam());
+ packetDecoder[0xb2] = this::teams;
+ packetDecoder[0xb3] = () -> pasteEmbeddedSchem(Fight.getBlueTeam());
+ packetDecoder[0xb4] = () -> pasteEmbeddedSchem(Fight.getRedTeam());
+ packetDecoder[0xc0] = this::scoreboardTitle;
+ packetDecoder[0xc1] = this::scoreboardData;
+ packetDecoder[0xc2] = this::bossBar;
+ packetDecoder[0xc3] = this::subtitle;
+ packetDecoder[0xc4] = this::printWin;
+ packetDecoder[0xc5] = this::messageSubtitle;
+ packetDecoder[0xc6] = this::winMessage;
+ packetDecoder[0xc7] = this::bossBarMessage;
+ packetDecoder[0xef] = source::readUTF;
+ packetDecoder[0xff] = this::tick;
+
+ execSync(FightWorld::forceLoad);
+
+ if(source.async()) {
+ Bukkit.getScheduler().runTaskAsynchronously(FightSystem.getPlugin(), this::process);
+ task = Bukkit.getScheduler().runTaskTimer(FightSystem.getPlugin(), this::runSync, 1, 1);
+ }else
+ task = Bukkit.getScheduler().runTaskTimer(FightSystem.getPlugin(), this::process, 1, 1);
+
+ Bukkit.getPluginManager().registerEvents(this, FightSystem.getPlugin());
+ for(Player player : Bukkit.getOnlinePlayers())
+ entityServer.addPlayer(player);
+ }
+
+ private void addREntity(int entityId, REntity entity) {
+ entities.put(entityId, entity);
+ FightSystem.getHullHider().updateREntity(entity);
+ }
+
+ @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
+ public void onPlayerJoin(PlayerJoinEvent e) {
+ entityServer.addPlayer(e.getPlayer());
+ }
+
+ public void skipToSubtitle() {
+ skipToSubtitle = true;
+ }
+
+ private void winMessage() throws IOException {
+ byte team = source.readByte();
+ Message message = readMessage();
+
+ execSync(() -> {
+ FightTeam winner = null;
+ if(team == 0x01)
+ winner = Fight.getBlueTeam();
+ else if(team == 0x02)
+ winner = Fight.getRedTeam();
+
+ FightSystem.setSpectateState(winner, "Replay ends", message.getMsg(), message.getParams());
+ });
+ }
+
+ private void system() throws IOException {
+ Message message = readMessage();
+ FightSystem.getMessage().broadcast(message.getMsg(), message.getParams());
+ }
+
+ private void messageSubtitle() throws IOException {
+ Message message = readMessage();
+ FightUI.addSubtitle(message.getMsg(), message.getParams());
+ skipToSubtitle = false;
+ }
+
+ private void chat() throws IOException {
+ Message message = readMessage();
+ FightSystem.getMessage().chat(message.getMsg(), message.getParams());
+ }
+
+ private void runSync() {
+ synchronized (syncList) {
+ for(Runnable runnable : syncList) {
+ try{
+ runnable.run();
+ }catch (Exception e) {
+ Bukkit.getLogger().log(Level.WARNING, "Failed to execute packet LastPacket: " + Arrays.toString(lastPackets.toArray()), e);
+ }
+ }
+ syncList.clear();
+ }
+ }
+
+ private void execSync(Runnable runnable){
+ if (!source.async()) {
+ runnable.run();
+ return;
+ }
+
+ synchronized (syncList) {
+ syncList.add(runnable);
+ }
+ }
+
+ private void playerJoins() throws IOException {
+ int entityId = source.readInt();
+ int userId = source.readInt();
+
+ execSync(() -> {
+ SteamwarUser user = SteamwarUser.get(userId);
+ addREntity(entityId, new RPlayer(entityServer, user.getUUID(), user.getUserName(), Config.SpecSpawn));
+ team.addEntry(user.getUserName());
+ });
+ }
+
+ private void entityMoves() throws IOException {
+ int entityId = source.readInt();
+ double x = source.readDouble() - arenaMinX;
+ double locY = source.readDouble() - arenaMinY + Config.BluePasteRegion.getMinY();
+ double z = source.readDouble() - arenaMinZ;
+ if(rotateZ) {
+ x = Config.ArenaRegion.getSizeX() - x;
+ z = Config.ArenaRegion.getSizeZ() - z;
+ }
+ double locX = x + Config.ArenaRegion.getMinX();
+ double locZ = z + Config.ArenaRegion.getMinZ();
+ float pitch = source.readFloat();
+ float yaw = source.readFloat() + (rotateZ ? 180 : 0);
+ byte headYaw = (byte)((source.readByte() + (rotateZ ? 128 : 0)) % 256);
+
+ execSync(() -> {
+ REntity entity = entities.get(entityId);
+ if(entity != null) {
+ entity.move(locX, locY, locZ, pitch, yaw, headYaw);
+ FightSystem.getHullHider().updateREntity(entity);
+ }
+ });
+ }
+
+ private void entityDespawns() throws IOException {
+ int entityId = source.readInt();
+
+ execSync(() -> {
+ REntity entity = entities.remove(entityId);
+ if(entity != null) {
+ FightSystem.getHullHider().despawnREntity(entity);
+ entity.die();
+ }
+ });
+ }
+
+ private void entitySneak() throws IOException {
+ int entityId = source.readInt();
+ boolean sneaking = source.readBoolean();
+
+ execSync(() -> entities.get(entityId).setPose(sneaking ? de.steamwar.core.FlatteningWrapper.EntityPose.SNEAKING : de.steamwar.core.FlatteningWrapper.EntityPose.NORMAL));
+ }
+
+ private void entityAnimation() throws IOException {
+ int entityId = source.readInt();
+ byte animation = source.readByte();
+
+ execSync(() -> entities.get(entityId).showAnimation(animation));
+ }
+
+ private void tntSpawn() throws IOException {
+ int entityId = source.readInt();
+
+ execSync(() -> addREntity(entityId, new REntity(entityServer, EntityType.PRIMED_TNT, Config.SpecSpawn)));
+ }
+
+ private void entityVelocity() throws IOException {
+ int entityId = source.readInt();
+
+ double dX = rotateZ ? -source.readDouble() : source.readDouble();
+ double dY = source.readDouble();
+ double dZ = rotateZ ? -source.readDouble() : source.readDouble();
+
+ execSync(() -> {
+ REntity entity = entities.get(entityId);
+ if(entity != null)
+ entity.setVelocity(dX, dY, dZ);
+ });
+ }
+
+ private void playerItem() throws IOException {
+ int entityId = source.readInt();
+ String item = source.readUTF();
+ boolean enchanted = source.readBoolean();
+ String slotName = source.readUTF();
+
+ ItemStack stack = new ItemStack(Material.valueOf(item.replace("minecraft:", "").toUpperCase()), 1);
+ if(enchanted)
+ stack.addUnsafeEnchantment(Enchantment.DURABILITY, 1);
+
+ Object slot;
+ switch(slotName){
+ case "HEAD":
+ slot = de.steamwar.core.ProtocolWrapper.itemSlots[5];
+ break;
+ case "CHEST":
+ slot = de.steamwar.core.ProtocolWrapper.itemSlots[4];
+ break;
+ case "LEGS":
+ slot = de.steamwar.core.ProtocolWrapper.itemSlots[3];
+ break;
+ case "FEET":
+ slot = de.steamwar.core.ProtocolWrapper.itemSlots[2];
+ break;
+ case "OFFHAND":
+ slot = de.steamwar.core.ProtocolWrapper.itemSlots[1];
+ break;
+ case "MAINHAND":
+ default:
+ slot = de.steamwar.core.ProtocolWrapper.itemSlots[0];
+ }
+
+ execSync(() -> entities.get(entityId).setItem(slot, stack));
+ }
+
+ private void arrowSpawn() throws IOException {
+ int entityId = source.readInt();
+
+ execSync(() -> addREntity(entityId, new REntity(entityServer, EntityType.ARROW, Config.SpecSpawn)));
+ }
+
+ private void fireballSpawn() throws IOException {
+ int entityId = source.readInt();
+
+ execSync(() -> addREntity(entityId, new REntity(entityServer, EntityType.FIREBALL, Config.SpecSpawn)));
+ }
+
+ private void send(ChatMessageType type) throws IOException {
+ String message = source.readUTF();
+
+ BaseComponent[] text = TextComponent.fromLegacyText(message);
+ Bukkit.getOnlinePlayers().forEach(p -> de.steamwar.core.BountifulWrapper.impl.sendMessage(p, type, text));
+ }
+
+ private void countdown() throws IOException {
+ String message = source.readUTF();
+ int displaytime = source.readInt();
+ Message appendix = readMessage();
+
+ Bukkit.getOnlinePlayers().forEach(p -> Countdown.sendCountdownMessage(p, message, displaytime, appendix));
+ }
+
+ private void oldArenaInfo() throws IOException {
+ rotateZ = source.readBoolean() != Config.blueNegZ();
+ arenaMinY = Byte.toUnsignedInt(source.readByte());
+ arenaMinX = source.readInt();
+ arenaMinZ = source.readInt();
+ }
+
+ private void arenaInfo() throws IOException {
+ rotateZ = source.readBoolean() != Config.blueNegZ();
+ arenaMinX = source.readInt();
+ arenaMinY = source.readInt();
+ arenaMinZ = source.readInt();
+ }
+
+ private void shortBlock() throws IOException {
+ int x = Byte.toUnsignedInt(source.readByte()) + Config.ArenaRegion.getMinX();
+ int y = Byte.toUnsignedInt(source.readByte());
+ int z = Byte.toUnsignedInt(source.readByte()) + Config.ArenaRegion.getMinZ();
+ int blockState = source.readShort();
+
+ setBlock(x, y, z, blockState);
+ }
+
+ private void shortRelativeBlock() throws IOException {
+ int x = Byte.toUnsignedInt(source.readByte());
+ int y = Byte.toUnsignedInt(source.readByte());
+ int z = Byte.toUnsignedInt(source.readByte());
+ int blockState = source.readShort();
+
+ if(rotateZ) {
+ x = Config.ArenaRegion.getSizeX() - x;
+ z = Config.ArenaRegion.getSizeZ() - z;
+ }
+
+ setBlock(x + Config.ArenaRegion.getMinX(), y + Config.BluePasteRegion.getMinY(), z + Config.ArenaRegion.getMinZ(), blockState);
+ }
+
+ private void byteWorldHeightBlock() throws IOException {
+ int x = source.readInt() - arenaMinX;
+ int y = Byte.toUnsignedInt(source.readByte()) - arenaMinY;
+ int z = source.readInt() - arenaMinZ;
+ int blockState = source.readInt();
+
+ if(rotateZ) {
+ x = Config.ArenaRegion.getSizeX() - x;
+ z = Config.ArenaRegion.getSizeZ() - z;
+ }
+
+ setBlock(x + Config.ArenaRegion.getMinX(), y + Config.BluePasteRegion.getMinY(), z + Config.ArenaRegion.getMinZ(), blockState);
+ }
+
+ private void block() throws IOException {
+ int x = source.readInt() - arenaMinX;
+ int y = source.readShort() - arenaMinY;
+ int z = source.readInt() - arenaMinZ;
+ int blockState = source.readInt();
+
+ if(rotateZ) {
+ x = Config.ArenaRegion.getSizeX() - x;
+ z = Config.ArenaRegion.getSizeZ() - z;
+ }
+
+ setBlock(x + Config.ArenaRegion.getMinX(), y + Config.BluePasteRegion.getMinY(), z + Config.ArenaRegion.getMinZ(), blockState);
+ }
+
+ private void setBlock(int x, int y, int z, int blockState){
+ if(!Config.ArenaRegion.in2dRegion(x, z))
+ return; //Outside of the arena
+
+ execSync(() -> {
+ BlockIdWrapper.impl.setBlock(Config.world, x, y, z, TechHiderWrapper.ENABLED && hiddenBlockIds.contains(blockState) ? obfuscateWith : blockState);
+ FightSystem.getHullHider().blockUpdate(Config.world.getBlockAt(x, y, z), BlockIdWrapper.impl.idToMaterial(blockState));
+ });
+ }
+
+ private void particle() throws IOException {
+ double x = source.readDouble() - arenaMinX;
+ double y = source.readDouble() - arenaMinY;
+ double z = source.readDouble() - arenaMinZ;
+ String particleName = source.readUTF();
+
+ if(rotateZ) {
+ x = Config.ArenaRegion.getSizeX() - x;
+ z = Config.ArenaRegion.getSizeZ() - z;
+ }
+
+ double finalX = x;
+ double finalZ = z;
+ execSync(() -> BountifulWrapper.impl.spawnParticle(Config.world, particleName, finalX + Config.ArenaRegion.getMinX(), y + Config.BluePasteRegion.getMinY(), finalZ + Config.ArenaRegion.getMinZ()));
+ }
+
+ private void sound() throws IOException {
+ int rawX = source.readInt() - arenaMinX;
+ int y = source.readInt() - arenaMinY + Config.BluePasteRegion.getMinY();
+ int rawZ = source.readInt() - arenaMinZ;
+
+ if(rotateZ) {
+ rawX = Config.ArenaRegion.getSizeX() - rawX;
+ rawZ = Config.ArenaRegion.getSizeZ() - rawZ;
+ }
+
+ int x = rawX + Config.ArenaRegion.getMinX();
+ int z = rawZ + Config.ArenaRegion.getMinZ();
+
+ String soundName = source.readUTF();
+ String soundCategory = source.readUTF();
+
+ float volume = source.readFloat();
+ float pitch = source.readFloat();
+
+ Sound sound = Sound.valueOf(soundName);
+
+ execSync(() -> WorldOfColorWrapper.impl.playSound(new Location(Config.world, x, y, z), sound, soundCategory, volume, pitch));
+ }
+
+ private void soundAtPlayer() throws IOException {
+ String soundName = source.readUTF();
+
+ float volume = source.readFloat();
+ float pitch = source.readFloat();
+
+ Sound sound = Sound.valueOf(soundName);
+
+ execSync(() -> Fight.playSound(sound, volume, pitch));
+ }
+
+ private void pasteSchem(FightTeam team) throws IOException {
+ int schemId = source.readInt();
+ if(schemId == 0)
+ return;
+
+ execSync(() -> team.pasteSchem(SchematicNode.getSchematicNode(schemId)));
+ }
+
+ private void pasteEmbeddedSchem(FightTeam team) throws IOException {
+ int schemId = source.readInt();
+ Clipboard clipboard = SchematicData.clipboardFromStream(new FilterInputStream(source) {
+ @Override
+ public void close() {
+ // FAWE 1.12 calls close...
+ }
+ }, Core.getVersion() > 12);
+
+ execSync(() -> team.pasteSchem(schemId, clipboard));
+ }
+
+ private void teams() throws IOException {
+ int blueId = source.readInt();
+ int redId = source.readInt();
+
+ execSync(() -> {
+ pasteForTeam(blueId, Fight.getBlueTeam());
+ pasteForTeam(redId, Fight.getRedTeam());
+ });
+ }
+
+ private void pasteForTeam(int teamId, FightTeam fightTeam){
+ Team team = Team.get(teamId);
+ fightTeam.setPrefixAndName("§" + team.getTeamColor(), team.getTeamKuerzel());
+ fightTeam.pasteTeamName();
+ }
+
+ private void scoreboardTitle() throws IOException {
+ String title = source.readUTF();
+
+ FightScoreboard.getScoreboard().setTitle(title);
+ }
+
+ private void scoreboardData() throws IOException {
+ String key = source.readUTF();
+ int value = source.readInt();
+
+ FightScoreboard.getScoreboard().addScore(key, value);
+ }
+
+ private void bossBar() throws IOException {
+ double leftBlueProgress = source.readDouble();
+ double leftRedProgress = source.readDouble();
+ String leftBlueText = source.readUTF();
+ String leftRedText = source.readUTF();
+
+ FightUI.getInstance().setBossbar(leftBlueProgress, leftRedProgress, leftBlueText, leftRedText);
+ }
+
+ private void bossBarMessage() throws IOException {
+ double leftBlueProgress = source.readDouble();
+ double leftRedProgress = source.readDouble();
+ Message leftBlueText = readMessage();
+ Message leftRedText = readMessage();
+
+ FightUI.getInstance().setBossbar(leftBlueProgress, leftRedProgress, leftBlueText, leftRedText);
+ }
+
+ private void subtitle() throws IOException {
+ String subtitle = source.readUTF();
+
+ FightUI.addSubtitle("OLD_STRING", subtitle);
+ skipToSubtitle = false;
+ }
+
+ private void printWin() throws IOException {
+ String title = source.readUTF();
+ String subtitle = source.readUTF();
+
+ Bukkit.getOnlinePlayers().forEach(p -> {
+ p.resetTitle();
+ WorldOfColorWrapper.impl.sendTitle(p, title, subtitle, 5, 40, 5);
+ });
+ }
+
+ private void endReplay() {
+ HandlerList.unregisterAll(this);
+ entityServer.close();
+ entities.values().forEach(FightSystem.getHullHider()::despawnREntity);
+ entities.clear();
+
+ freezer.disable();
+ if(!Config.replayserver()) {
+ FightSystem.getMessage().broadcast("REPLAY_ENDS");
+ }
+ if (FightSystem.getLastWinner() != null) {
+ FightUI.getInstance().setBossbar(0.5, 0.5,
+ new Message("BAR_WIN", FightSystem.getLastWinner().getColoredName(), Fight.getBlueTeam().getColoredName(), Fight.getRedTeam().getColoredName(), ""),
+ new Message("BAR_WIN", FightSystem.getLastWinner().getColoredName(), Fight.getRedTeam().getColoredName(), Fight.getBlueTeam().getColoredName(), ""));
+ } else {
+ FightUI.getInstance().setBossbar(0.5, 0.5,
+ new Message("BAR_TIE", "", Fight.getBlueTeam().getColoredName(), Fight.getRedTeam().getColoredName()),
+ new Message("BAR_TIE", "", Fight.getRedTeam().getColoredName(), Fight.getBlueTeam().getColoredName()));
+ }
+ FightState.setFightState(FightState.SPECTATE);
+ currentProcessor = null;
+ task.cancel();
+ }
+
+ private void bow() throws IOException {
+ int entityId = source.readInt();
+ boolean drawn = source.readBoolean();
+ boolean offHand = source.readBoolean();
+
+ execSync(() -> entities.get(entityId).setBowDrawn(drawn, offHand));
+ }
+
+ private void damage() throws IOException {
+ int entityId = source.readInt();
+
+ execSync(() -> entities.get(entityId).showDamage());
+ }
+
+ private void fireTick() throws IOException {
+ int entityId = source.readInt();
+ boolean perma = source.readBoolean();
+
+ execSync(() -> entities.get(entityId).setOnFire(perma));
+ }
+
+ private void tick(){
+ execSync(entityServer::tick);
+
+ if(!source.async() && !skipToSubtitle)
+ tickFinished = true;
+ }
+
+ private void process(){
+ tickFinished = false;
+ try{
+ while(!source.isClosed() && !tickFinished){
+ int packetType = Byte.toUnsignedInt(source.readByte());
+
+ lastPackets.add(packetType);
+ if (lastPackets.size() > 10)
+ lastPackets.remove(0);
+
+ PacketParser parser = packetDecoder[packetType];
+ if(parser != null){
+ parser.process();
+ }else{
+ Bukkit.getLogger().log(Level.SEVERE, "Unknown packet " + packetType + " recieved, closing. LastPacket: " + Arrays.toString(lastPackets.toArray()));
+ source.close();
+ }
+ }
+ } catch (EOFException e) {
+ Bukkit.getLogger().log(Level.INFO, "The FightServer is offline");
+ source.close();
+ } catch(Exception e) {
+ Bukkit.getLogger().log(Level.WARNING, "Could not recieve packet, LastPacket: " + Arrays.toString(lastPackets.toArray()), e);
+ source.close();
+ }
+
+ if(source.isClosed()){
+ execSync(() -> Bukkit.getScheduler().runTask(FightSystem.getPlugin(), this::endReplay));
+ }
+ }
+
+ private Message readMessage() throws IOException {
+ String msg = source.readUTF();
+ List params = new ArrayList<>();
+
+ while(true) {
+ int type = source.readUnsignedByte();
+ switch(type) {
+ case 0x00:
+ return new Message(msg, params.toArray());
+ case 0x01:
+ params.add(source.readBoolean());
+ break;
+ case 0x02:
+ params.add(source.readByte());
+ break;
+ case 0x03:
+ params.add(source.readShort());
+ break;
+ case 0x04:
+ params.add(source.readInt());
+ break;
+ case 0x05:
+ params.add(source.readFloat());
+ break;
+ case 0x06:
+ params.add(source.readDouble());
+ break;
+ case 0x07:
+ params.add(source.readUTF());
+ break;
+ case 0x08:
+ params.add(readMessage());
+ break;
+ default:
+ throw new IOException("Unknown message param type " + type);
+ }
+ }
+ }
+
+ private interface PacketParser{
+ void process() throws IOException;
+ }
+}
diff --git a/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/record/PacketSource.java b/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/record/PacketSource.java
new file mode 100644
index 00000000..e3d994cc
--- /dev/null
+++ b/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/record/PacketSource.java
@@ -0,0 +1,46 @@
+/*
+ This file is a part of the SteamWar software.
+
+ Copyright (C) 2020 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 All = Collections.unmodifiableSet(EnumSet.allOf(FightState.class));
+
+ public static final Set PreLeaderSetup = Collections.unmodifiableSet(EnumSet.of(PRE_LEADER_SETUP));
+ public static final Set PreSchemSetup = Collections.unmodifiableSet(EnumSet.of(PRE_SCHEM_SETUP));
+ public static final Set PostSchemSetup = Collections.unmodifiableSet(EnumSet.of(POST_SCHEM_SETUP));
+ public static final Set PreRunning = Collections.unmodifiableSet(EnumSet.of(PRE_RUNNING));
+ public static final Set Running = Collections.unmodifiableSet(EnumSet.of(RUNNING));
+ public static final Set Spectate = Collections.unmodifiableSet(EnumSet.of(SPECTATE));
+
+ public static final Set Setup = Collections.unmodifiableSet(EnumSet.of(PRE_LEADER_SETUP, PRE_SCHEM_SETUP, POST_SCHEM_SETUP));
+ public static final Set Ingame = Collections.unmodifiableSet(EnumSet.of(PRE_RUNNING, RUNNING));
+ public static final Set TeamFix = Collections.unmodifiableSet(EnumSet.of(PRE_RUNNING, RUNNING, SPECTATE));
+ public static final Set Schem = Collections.unmodifiableSet(EnumSet.complementOf(EnumSet.of(PRE_LEADER_SETUP, PRE_SCHEM_SETUP)));
+ public static final Set Recording = Collections.unmodifiableSet(EnumSet.complementOf(EnumSet.of(PRE_LEADER_SETUP, PRE_SCHEM_SETUP, SPECTATE)));
+ public static final Set AntiRunning = Collections.unmodifiableSet(EnumSet.complementOf(EnumSet.of(RUNNING)));
+ public static final Set AntiIngame = Collections.unmodifiableSet(EnumSet.complementOf(EnumSet.of(PRE_RUNNING, RUNNING)));
+ public static final Set AntiSpectate = Collections.unmodifiableSet(EnumSet.complementOf(EnumSet.of(SPECTATE)));
+
+ private static final Map 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){
+ fightState = state;
+
+ for(Map.Entry 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);
+ }
+
+ //Disable feature if should be disabled and currently enabled
+ if(!feature.getKey().enabled().contains(fightState) && feature.getValue()){
+ feature.getKey().disable();
+ feature.setValue(false);
+ }
+ }
+ }
+
+ public static boolean setup(){
+ return Setup.contains(fightState);
+ }
+
+ public static boolean ingame(){
+ return Ingame.contains(fightState);
+ }
+
+ public static boolean infight(){
+ return fightState == RUNNING;
+ }
+}
diff --git a/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/states/IStateDependent.java b/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/states/IStateDependent.java
new file mode 100644
index 00000000..1d9f170e
--- /dev/null
+++ b/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/states/IStateDependent.java
@@ -0,0 +1,40 @@
+/*
+ This file is a part of the SteamWar software.
+
+ Copyright (C) 2020 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 enabled();
+
+ /**
+ * Enables the state dependent object
+ */
+ void enable();
+
+ /**
+ * Disables the state dependent object
+ */
+ void disable();
+}
diff --git a/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/states/OneShotStateDependent.java b/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/states/OneShotStateDependent.java
new file mode 100644
index 00000000..610168f3
--- /dev/null
+++ b/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/states/OneShotStateDependent.java
@@ -0,0 +1,59 @@
+/*
+ This file is a part of the SteamWar software.
+
+ Copyright (C) 2020 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 mode, Set states, Runnable runnable) {
+ super(mode, states);
+ this.runnable = runnable;
+ register();
+ }
+
+ public OneShotStateDependent(Winconditions wincondition, Set states, Runnable runnable) {
+ super(Config.ActiveWinconditions.contains(wincondition), states);
+ this.runnable = runnable;
+ register();
+ }
+
+ public OneShotStateDependent(boolean active, Set states, Runnable runnable) {
+ super(active, states);
+ this.runnable = runnable;
+ register();
+ }
+
+ @Override
+ public void enable() {
+ runnable.run();
+ }
+
+ @Override
+ public void disable() {
+ //Do nothing, oneshot
+ }
+}
diff --git a/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/states/StateDependent.java b/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/states/StateDependent.java
new file mode 100644
index 00000000..e20c4fbe
--- /dev/null
+++ b/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/states/StateDependent.java
@@ -0,0 +1,55 @@
+/*
+ This file is a part of the SteamWar software.
+
+ Copyright (C) 2020 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 enabled;
+ private final boolean register;
+
+ protected StateDependent(Winconditions wincondition, Set states){
+ this(Config.ActiveWinconditions.contains(wincondition), states);
+ }
+
+ protected StateDependent(Set mode, Set states){
+ this(mode.contains(Config.mode), states);
+ }
+
+ protected StateDependent(boolean enabled, Set states){
+ this.enabled = states;
+ this.register = enabled;
+ }
+
+ public void register(){
+ if(register)
+ FightState.registerStateDependent(this);
+ }
+
+ @Override
+ public Set enabled() {
+ return enabled;
+ }
+}
diff --git a/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/states/StateDependentCommand.java b/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/states/StateDependentCommand.java
new file mode 100644
index 00000000..2d25b68d
--- /dev/null
+++ b/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/states/StateDependentCommand.java
@@ -0,0 +1,58 @@
+/*
+ This file is a part of the SteamWar software.
+
+ Copyright (C) 2020 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 mode, Set states, String name, CommandExecutor executor) {
+ super(mode, states);
+ this.executor = executor;
+ this.command = FightSystem.getPlugin().getCommand(name);
+ assert command != null;
+ disable();
+ register();
+ }
+
+ @Override
+ public void enable() {
+ command.setExecutor(executor);
+ }
+
+ @Override
+ public void disable() {
+ command.setExecutor(unavailable);
+ }
+}
diff --git a/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/states/StateDependentCountdown.java b/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/states/StateDependentCountdown.java
new file mode 100644
index 00000000..4bdbc093
--- /dev/null
+++ b/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/states/StateDependentCountdown.java
@@ -0,0 +1,71 @@
+/*
+ This file is a part of the SteamWar software.
+
+ Copyright (C) 2020 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 mode, Set states, Countdown countdown) {
+ super(mode, states);
+ this.countdown = countdown;
+ register();
+ }
+
+ public StateDependentCountdown(Winconditions wincondition, Set states, Countdown countdown) {
+ this(Config.ActiveWinconditions.contains(wincondition), states, countdown);
+ }
+
+ public StateDependentCountdown(boolean active, Set 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;
+ }
+}
diff --git a/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/states/StateDependentListener.java b/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/states/StateDependentListener.java
new file mode 100644
index 00000000..f5cfffc8
--- /dev/null
+++ b/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/states/StateDependentListener.java
@@ -0,0 +1,63 @@
+/*
+ This file is a part of the SteamWar software.
+
+ Copyright (C) 2020 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 states, Listener listener){
+ super(Config.ActiveWinconditions.contains(wincondition), states);
+ this.listener = listener;
+ register();
+ }
+
+ public StateDependentListener(boolean enabled, Set states, Listener listener){
+ super(enabled, states);
+ this.listener = listener;
+ register();
+ }
+
+ public StateDependentListener(Set mode, Set 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);
+ }
+}
diff --git a/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/states/StateDependentTask.java b/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/states/StateDependentTask.java
new file mode 100644
index 00000000..950fbcb8
--- /dev/null
+++ b/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/states/StateDependentTask.java
@@ -0,0 +1,69 @@
+/*
+ This file is a part of the SteamWar software.
+
+ Copyright (C) 2020 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 states, Runnable runnable, long delay, long period){
+ this(Config.ActiveWinconditions.contains(wincondition), states, runnable, delay, period);
+ }
+
+ public StateDependentTask(boolean enabled, Set states, Runnable runnable, long delay, long period){
+ super(enabled, states);
+ this.runnable = runnable;
+ this.delay = delay;
+ this.period = period;
+ register();
+ }
+
+ public StateDependentTask(Set mode, Set 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();
+ }
+
+}
diff --git a/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/utils/BlockIdWrapper.java b/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/utils/BlockIdWrapper.java
new file mode 100644
index 00000000..a6b825db
--- /dev/null
+++ b/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/utils/BlockIdWrapper.java
@@ -0,0 +1,46 @@
+/*
+ This file is a part of the SteamWar software.
+
+ Copyright (C) 2021 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 chat2dye = new EnumMap<>(ChatColor.class);
+
+ static{
+ chat2dye.put(ChatColor.WHITE, DyeColor.WHITE);
+ chat2dye.put(ChatColor.GOLD, DyeColor.ORANGE);
+ chat2dye.put(ChatColor.LIGHT_PURPLE, DyeColor.MAGENTA);
+ chat2dye.put(ChatColor.BLUE, DyeColor.LIGHT_BLUE);
+ chat2dye.put(ChatColor.YELLOW, DyeColor.YELLOW);
+ chat2dye.put(ChatColor.GREEN, DyeColor.LIME);
+ chat2dye.put(ChatColor.RED, DyeColor.RED);
+ chat2dye.put(ChatColor.DARK_GRAY, DyeColor.GRAY);
+ chat2dye.put(ChatColor.DARK_AQUA, DyeColor.CYAN);
+ chat2dye.put(ChatColor.DARK_PURPLE, DyeColor.PURPLE);
+ chat2dye.put(ChatColor.DARK_BLUE, DyeColor.BLUE);
+ chat2dye.put(ChatColor.AQUA, DyeColor.CYAN);
+ chat2dye.put(ChatColor.DARK_GREEN, DyeColor.GREEN);
+ chat2dye.put(ChatColor.DARK_RED, DyeColor.RED);
+ chat2dye.put(ChatColor.BLACK, DyeColor.BLACK);
+ chat2dye.put(ChatColor.GRAY, FlatteningWrapper.impl.getSilver());
+ }
+
+ public static DyeColor chat2dye(ChatColor color){
+ return chat2dye.get(color);
+ }
+}
diff --git a/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/utils/CraftbukkitWrapper.java b/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/utils/CraftbukkitWrapper.java
new file mode 100644
index 00000000..242119f5
--- /dev/null
+++ b/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/utils/CraftbukkitWrapper.java
@@ -0,0 +1,36 @@
+/*
+ This file is a part of the SteamWar software.
+
+ Copyright (C) 2021 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 enabled = FightState.Running;
+
+ public EnterHandler(){
+ FightState.registerStateDependent(this);
+ }
+
+ @Override
+ public Set enabled() {
+ return enabled;
+ }
+
+ @Override
+ public void enable() {
+ Fight.teams().forEach(this::registerTeam);
+ }
+
+ @Override
+ public void disable() {
+ Fight.teams().forEach(this::unregisterTeam);
+ }
+
+ private void registerTeam(FightTeam team){
+ for(FightPlayer fp : team.getPlayers()){
+ fp.startEnternCountdown(null);
+ }
+ }
+
+ private void unregisterTeam(FightTeam team){
+ for(FightPlayer fp : team.getPlayers()){
+ fp.stopEnternCountdown();
+ }
+ }
+}
diff --git a/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/utils/FightStatistics.java b/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/utils/FightStatistics.java
new file mode 100644
index 00000000..1f46a3a8
--- /dev/null
+++ b/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/utils/FightStatistics.java
@@ -0,0 +1,154 @@
+/*
+ This file is a part of the SteamWar software.
+
+ Copyright (C) 2020 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 redAdditional = Wincondition.getPrintableWinconditions().stream().map(w -> w.getDisplay(red)).collect(Collectors.toList());
+ List blueAdditional = Wincondition.getPrintableWinconditions().stream().map(w -> w.getDisplay(blue)).collect(Collectors.toList());
+
+ Generator generator;
+ switch(FightState.getFightState()){
+ case PRE_LEADER_SETUP:
+ generator = (l, r, lP, rP, lW, rW) -> new Message("BAR_PRE_LEADER");
+ break;
+ case PRE_SCHEM_SETUP:
+ generator = (l, r, lP, rP, lW, rW) -> new Message("BAR_PRE_SCHEM", time, l.getColoredName(), r.getColoredName());
+ break;
+ case POST_SCHEM_SETUP:
+ generator = (l, r, lP, rP, lW, rW) -> new Message("BAR_PREPARE", time, l.getColoredName(), r.getColoredName(), lP, rP);
+ break;
+ case PRE_RUNNING:
+ generator = (l, r, lP, rP, lW, rW) -> new Message("BAR_PRE_RUNNING", time, l.getColoredName(), r.getColoredName(), lP, rP);
+ break;
+ case RUNNING:
+ generator = (l, r, lP, rP, lW, rW) -> {
+ List params = new ArrayList<>();
+ params.add(time);
+ params.add(l.getColoredName());
+ params.add(r.getColoredName());
+ params.add(lP);
+ params.add(rP);
+ for(int i = 0; i < lW.size(); i++) {
+ params.add(lW.get(i));
+ params.add(rW.get(i));
+ }
+ return new Message("BAR_RUNNING" + lW.size(), params.toArray());
+ };
+ break;
+ case SPECTATE:
+ default:
+ generator = (l, r, lP, rP, lW, rW) -> {
+ if(FightSystem.getLastWinner() == null)
+ return new Message("BAR_TIE", time, l.getColoredName(), r.getColoredName());
+ else
+ return new Message("BAR_WIN", time, l.getColoredName(), r.getColoredName(), FightSystem.getLastWinner().getColoredName());
+ };
+ break;
+ }
+
+ setBossbar(
+ blueHearts / totalHearts, redHearts / totalHearts,
+ generator.gen(blue, red, bluePlayers, redPlayers, blueAdditional, redAdditional),
+ generator.gen(red, blue, redPlayers, bluePlayers, redAdditional, blueAdditional)
+ );
+ }
+
+ private interface Generator {
+ Message gen(FightTeam l, FightTeam r, String lPlayers, String rPlayers, List lWinconditions, List rWinconditions);
+ }
+
+ public void setBossbar(double leftBlueProgress, double leftRedProgress, String leftBlueText, String leftRedText) {
+ setBossbar(leftBlueProgress, leftRedProgress, new Message("OLD_STRING", leftBlueText), new Message("OLD_STRING", leftRedText));
+ }
+
+ public void setBossbar(double leftBlueProgress, double leftRedProgress, Message leftBlueText, Message leftRedText) {
+ GlobalRecorder.getInstance().bossBar(leftBlueProgress, leftRedProgress, leftBlueText, leftRedText);
+ BossBarType.BLUE_LEFT.progress = leftBlueProgress;
+ BossBarType.RED_LEFT.progress = leftRedProgress;
+ BossBarType.BLUE_LEFT.text = leftBlueText;
+ BossBarType.RED_LEFT.text = leftRedText;
+ }
+
+ private void sendToPlayers() {
+ Bukkit.getOnlinePlayers().forEach(player -> {
+ BossBarType bar = BossBarType.byAngle(CraftbukkitWrapper.impl.headRotation(player));
+
+ Object[] params = bar.text.getParams().clone();
+ for(int i = 0; i < params.length; i++) {
+ if(params[i] instanceof Message) {
+ Message msg = (Message) params[i];
+ params[i] = FightSystem.getMessage().parse(msg.getMsg(), player, msg.getParams());
+ }
+ }
+
+ BountifulWrapper.impl.sendBar(player, bar.team, bar.progress, FightSystem.getMessage().parse(bar.text.getMsg(), player, params));
+ });
+ }
+
+ private void tpsWatcher() {
+ double tps = TPSWatcher.getTPS();
+ if(tps < 15.0)
+ FightSystem.getMessage().broadcastActionbar("TPS_WARNING", tps);
+ }
+
+ public enum BossBarType {
+ BLUE_LEFT(Fight.getBlueTeam(), 345, 165),
+ RED_LEFT(Fight.getRedTeam(), 165, 345);
+
+ private static final boolean BLUE_NEG_Z = Config.blueNegZ();
+
+ private final double minAngle;
+ private final double maxAngle;
+
+ private final FightTeam team;
+ private double progress = 0.5;
+ private Message text = new Message("OLD_STRING", "§7");
+
+ BossBarType(FightTeam team, double minAngle, double maxAngle) {
+ this.team = team;
+ this.minAngle = minAngle;
+ this.maxAngle = maxAngle;
+ }
+
+ private static BossBarType byAngle(double angle) {
+ if(BLUE_NEG_Z)
+ angle += 180;
+ angle = ((angle % 360) + 360) % 360;
+
+ for(BossBarType type : values()) {
+ if(type.minAngle < type.maxAngle ? type.minAngle <= angle && angle < type.maxAngle : type.minAngle <= angle || angle < type.maxAngle)
+ return type;
+ }
+
+ throw new SecurityException("No boss bar for angle " + angle + " found");
+ }
+ }
+
+
+ private static final Queue queue = new LinkedList<>();
+ private static boolean subtitleScheduled = false;
+
+ public static void printWin(FightTeam winner, String subtitle, Object... params) {
+ queue.clear();
+
+ FightSystem.getPlugin().getLogger().log(Level.INFO, winner + " " + FightSystem.getMessage().parse(subtitle, null, params));
+ GlobalRecorder.getInstance().winMessage(winner, subtitle, params);
+
+ Bukkit.getOnlinePlayers().forEach(Player::resetTitle);
+ if (winner != null)
+ Bukkit.getOnlinePlayers().forEach(p -> WorldOfColorWrapper.impl.sendTitle(p, FightSystem.getMessage().parse("UI_WIN", p, winner.getColor(), winner.getName()), FightSystem.getMessage().parse(subtitle, p, params), 5, 40, 5));
+ else
+ Bukkit.getOnlinePlayers().forEach(p -> WorldOfColorWrapper.impl.sendTitle(p, FightSystem.getMessage().parse("UI_DRAW", p), FightSystem.getMessage().parse(subtitle, p, params), 5, 40, 5));
+ }
+
+ public static void addSubtitle(String msg, Object... params) {
+ if(FightState.Spectate.contains(FightState.getFightState()))
+ return;
+
+ Message message = new Message(msg, params);
+ queue.add(message);
+ GlobalRecorder.getInstance().subtitle(message);
+ FightSystem.getPlugin().getLogger().log(Level.INFO, FightSystem.getMessage().parse(msg, null, params));
+
+ if(!subtitleScheduled)
+ printSubtitle();
+ }
+
+ private static void printSubtitle() {
+ if(queue.isEmpty()) {
+ subtitleScheduled = false;
+ return;
+ }
+ Message message = queue.poll();
+
+ Bukkit.getOnlinePlayers().forEach(p -> WorldOfColorWrapper.impl.sendTitle(p, " ", FightSystem.getMessage().parse(message.getMsg(), p, message.getParams()), 5, 40, 5));
+ Bukkit.getScheduler().runTaskLater(FightSystem.getPlugin(), FightUI::printSubtitle, 50);
+ subtitleScheduled = true;
+ }
+}
diff --git a/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/utils/FlatteningWrapper.java b/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/utils/FlatteningWrapper.java
new file mode 100644
index 00000000..aa2f10e8
--- /dev/null
+++ b/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/utils/FlatteningWrapper.java
@@ -0,0 +1,54 @@
+/*
+ This file is a part of the SteamWar software.
+
+ Copyright (C) 2021 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 > blockVisibility = new HashMap<>();
+ private final Set uncoveredSurface = new HashSet<>();
+
+ private final HashSet players = new HashSet<>();
+ private final Set entities = new HashSet<>();
+ private final Set rentities = new HashSet<>();
+
+ public Hull(FightTeam team) {
+ this.region = team.getSchemRegion();
+ this.groundVisible = region.getMinY() != Config.PlayerRegion.getMinY();
+ this.occluding = new BitSet(region.volume());
+ this.visibility = new BitSet(region.volume());
+
+ IntVector[] directions;
+ if (groundVisible) {
+ directions = new IntVector[]{
+ new IntVector(1, 0, 0),
+ new IntVector(-1, 0, 0),
+ new IntVector(0, 1, 0),
+ new IntVector(0, -1, 0),
+ new IntVector(0, 0, 1),
+ new IntVector(0, 0, -1)
+ };
+ } else {
+ directions = new IntVector[]{
+ new IntVector(1, 0, 0),
+ new IntVector(-1, 0, 0),
+ new IntVector(0, -1, 0),
+ new IntVector(0, 0, 1),
+ new IntVector(0, 0, -1)
+ };
+ }
+
+ // Generate quadrants for each direction
+ for (IntVector direction : directions) {
+ Map map = new HashMap<>();
+ for (int z = (direction.z == 0 ? -1 : 0); z <= 1; z += 2) {
+ for (int y = (direction.y == 0 ? -1 : 0); y <= 1; y += 2) {
+ for (int x = (direction.x == 0 ? -1 : 0); x <= 1; x += 2) {
+ map.put(new IntVector(x, y, z), new BitSet(region.volume()));
+ }
+ }
+ }
+ blockVisibility.put(direction, map);
+ }
+ }
+
+ public boolean blockPrecise(Player player, int chunkX, int chunkY, int chunkZ) {
+ return players.contains(player) && !region.chunkSectionOutside(chunkX, chunkY, chunkZ);
+ }
+
+ public boolean isBlockHidden(Player player, int x, int y, int z) {
+ return region.inRegion(x, y, z) && players.contains(player) && !visibility.get(((y - region.getMinY()) * region.getSizeZ() + (z - region.getMinZ())) * region.getSizeX() + (x - region.getMinX()));
+ }
+
+ public boolean isLocationHidden(Player player, Location location) {
+ return players.contains(player) && region.inRegion(location) && !visibility.get(new IntVector(location).toId(region));
+ }
+
+ public void addPlayer(Player player) {
+ if(players.add(player)) {
+ for(Entity entity : entities)
+ BlockIdWrapper.impl.untrackEntity(player, entity.getEntityId());
+ }
+ }
+
+ public void removePlayer(Player player, boolean activeRemoval) {
+ if(players.remove(player) && activeRemoval) {
+ for(Entity entity : entities)
+ BlockIdWrapper.impl.trackEntity(player, entity.getEntityId());
+ // techhider triggers block change sending
+ }
+ }
+
+ public void checkEntity(Entity entity) {
+ Location location = entity.getLocation();
+ if(region.inRegion(location) && !visibility.get(new IntVector(location).toId(region))) { //TODO more precise
+ if(entities.add(entity)) {
+ for(Player player : players)
+ BlockIdWrapper.impl.untrackEntity(player, entity.getEntityId());
+ }
+ } else {
+ if(entities.remove(entity)) {
+ for(Player player : players)
+ BlockIdWrapper.impl.trackEntity(player, entity.getEntityId());
+ }
+ }
+ }
+
+ public void removeEntity(Entity entity) {
+ entities.remove(entity);
+ }
+
+ public void checkREntity(REntity entity) {
+ Location location = new Location(Config.world, entity.getX(), entity.getY(), entity.getZ());
+ if(region.inRegion(location) && !visibility.get(new IntVector(location).toId(region))) { //TODO more precise
+ if(rentities.add(entity))
+ entity.hide(true);
+ } else {
+ if(rentities.remove(entity))
+ entity.hide(false);
+ }
+ }
+
+ public void removeREntity(REntity entity) {
+ rentities.remove(entity);
+ }
+
+ public void initialize() {
+ visibility.clear();
+ occluding.clear();
+ uncoveredSurface.clear();
+ for (Map direction : blockVisibility.values()) {
+ for (BitSet set : direction.values())
+ set.clear();
+ }
+
+ long start = System.currentTimeMillis();
+ region.forEach((x, y, z) -> {
+ IntVector block = new IntVector(x, y, z);
+ if (isOccluding(Config.world.getBlockAt(x, y, z).getType()))
+ occluding.set(block.toId(region));
+ });
+ forEachBorder((root, direction) -> {
+ for (Map.Entry quadrant : blockVisibility.get(direction).entrySet()) {
+ checkBlock(new NullList<>(), root, direction, quadrant.getKey(), quadrant.getValue());
+ }
+ });
+ FightSystem.getPlugin().getLogger().log(Level.INFO, () -> "[HullHider] initialisation finished: " + (System.currentTimeMillis() - start) + " ms, visible blocks: " + visibility.cardinality());
+ }
+
+ public void updateBlockVisibility(Block b, Material changedType) {
+ IntVector root = new IntVector(b.getX(), b.getY(), b.getZ());
+ if (root.notInRegion(region))
+ return;
+
+ int id = root.toId(region);
+ if (!occluding.get(id) || isOccluding(changedType))
+ return;
+
+ List uncovered = new ArrayList<>();
+ occluding.clear(id);
+ for (Map.Entry> direction : blockVisibility.entrySet()) {
+ for (Map.Entry quadrant : direction.getValue().entrySet()) {
+ if (quadrant.getValue().get(id)) {
+ quadrant.getValue().clear(id);
+ checkBlock(uncovered, root, direction.getKey(), quadrant.getKey(), quadrant.getValue());
+ }
+ }
+ }
+
+ if(uncovered.isEmpty())
+ return;
+
+ Set uncoveredSet = new HashSet<>(uncovered);
+ Iterator it = entities.iterator();
+ while(it.hasNext()) {
+ Entity entity = it.next();
+ if(uncoveredSet.contains(new IntVector(entity.getLocation()))) { //TODO more precise
+ it.remove();
+ for(Player player : players)
+ BlockIdWrapper.impl.trackEntity(player, entity.getEntityId());
+ }
+ }
+
+ Iterator rit = rentities.iterator();
+ while(rit.hasNext()) {
+ REntity entity = rit.next();
+ if(uncoveredSet.contains(new IntVector(new Location(Config.world, entity.getX(), entity.getY(), entity.getZ())))) { //TODO more precise
+ rit.remove();
+ entity.hide(false);
+ }
+ }
+
+ uncoveredSurface.addAll(uncoveredSet);
+ uncoveredSurface.remove(root);
+ }
+
+ public void sendUncoveredBlocks() {
+ Map> sectionWise = new HashMap<>();
+
+ for(IntVector uncovered : uncoveredSurface) {
+ sectionWise.computeIfAbsent(new IntVector(uncovered.x >> 4, uncovered.y >> 4, uncovered.z >> 4), section -> new ArrayList<>()).add(uncovered);
+ }
+ uncoveredSurface.clear();
+
+ for (Map.Entry> entry : sectionWise.entrySet()) {
+ Object packet = HullHiderWrapper.impl.generateBlockChangePacket(entry.getValue());
+ if(packet == null)
+ continue;
+
+ players.forEach(player -> TinyProtocol.instance.sendPacket(player, packet));
+ }
+ }
+
+ private void forEachBorder(BiConsumer f) {
+ for (int x = region.getMinX(); x < region.getMaxX(); x++) {
+ for (int z = region.getMinZ(); z < region.getMaxZ(); z++) {
+ if (groundVisible)
+ f.accept(new IntVector(x, region.getMinY(), z), new IntVector(0, 1, 0));
+ f.accept(new IntVector(x, region.getMaxY() - 1, z), new IntVector(0, -1, 0));
+ }
+ }
+
+ for (int x = region.getMinX(); x < region.getMaxX(); x++) {
+ for (int y = region.getMinY(); y < region.getMaxY(); y++) {
+ f.accept(new IntVector(x, y, region.getMinZ()), new IntVector(0, 0, 1));
+ f.accept(new IntVector(x, y, region.getMaxZ() - 1), new IntVector(0, 0, -1));
+ }
+ }
+
+ for (int z = region.getMinZ(); z < region.getMaxZ(); z++) {
+ for (int y = region.getMinY(); y < region.getMaxY(); y++) {
+ f.accept(new IntVector(region.getMinX(), y, z), new IntVector(1, 0, 0));
+ f.accept(new IntVector(region.getMaxX() - 1, y, z), new IntVector(-1, 0, 0));
+ }
+ }
+ }
+
+ private void checkBlock(List uncovered, IntVector block, IntVector direction, IntVector quadrant, BitSet quadVisibility) {
+ if (block.notInRegion(region))
+ return;
+
+ int id = block.toId(region);
+ if (quadVisibility.get(id))
+ return;
+
+ quadVisibility.set(id);
+ if (!visibility.get(id)) {
+ visibility.set(id);
+ uncovered.add(block);
+ }
+
+ if (occluding.get(id))
+ return;
+
+ IntVector neighbour = block.add(direction);
+ checkBlock(uncovered, neighbour, direction, quadrant, quadVisibility);
+ boolean neigbourTransparent = boundedNonOccluding(neighbour);
+ boolean diagonalReachable = false;
+ if (direction.x == 0 && (neigbourTransparent || boundedNonOccluding(block.add(quadrant.x, 0, 0)))) {
+ checkBlock(uncovered, neighbour.add(quadrant.x, 0, 0), direction, quadrant, quadVisibility);
+ diagonalReachable = boundedNonOccluding(neighbour.add(quadrant.x, 0, 0));
+ }
+
+ if (direction.y == 0 && (neigbourTransparent || boundedNonOccluding(block.add(0, quadrant.y, 0)))) {
+ checkBlock(uncovered, neighbour.add(0, quadrant.y, 0), direction, quadrant, quadVisibility);
+ diagonalReachable = diagonalReachable || boundedNonOccluding(neighbour.add(0, quadrant.y, 0));
+ }
+
+ if (direction.z == 0 && (neigbourTransparent || boundedNonOccluding(block.add(0, 0, quadrant.z)))) {
+ checkBlock(uncovered, neighbour.add(0, 0, quadrant.z), direction, quadrant, quadVisibility);
+ diagonalReachable = diagonalReachable || boundedNonOccluding(neighbour.add(0, 0, quadrant.z));
+ }
+
+ if (diagonalReachable)
+ checkBlock(uncovered, neighbour.add(quadrant), direction, quadrant, quadVisibility);
+ }
+
+ private boolean boundedNonOccluding(IntVector block) {
+ return !(block.notInRegion(region) || occluding.get(block.toId(region)));
+ }
+
+
+ @Getter
+ @AllArgsConstructor
+ public static class IntVector {
+ private final int x;
+ private final int y;
+ private final int z;
+
+ public IntVector(Location location) {
+ this.x = location.getBlockX();
+ this.y = location.getBlockY();
+ this.z = location.getBlockZ();
+ }
+
+ public boolean notInRegion(Region region) {
+ return !region.inRegion(x, y, z);
+ }
+
+ public int toId(Region region) {
+ return ((y - region.getMinY()) * region.getSizeZ() + (z - region.getMinZ())) * region.getSizeX() + (x - region.getMinX());
+ }
+
+ public IntVector add(int x, int y, int z) {
+ return new IntVector(this.x + x, this.y + y, this.z + z);
+ }
+
+ public IntVector add(IntVector v) {
+ return add(v.x, v.y, v.z);
+ }
+
+ @Override
+ public int hashCode() {
+ return y << 24 ^ x << 12 ^ z;
+ }
+
+ @Override
+ public boolean equals(Object o) {
+ if(o == null || this.getClass() != o.getClass())
+ return false;
+
+ IntVector v = (IntVector) o;
+ return x == v.x && y == v.y && z == v.z;
+ }
+
+ @Override
+ public String toString() {
+ return x + "," + y + "," + z;
+ }
+ }
+
+ private static class NullList extends AbstractList {
+ @Override
+ public void add(int index, E element) {
+ // Straight to /dev/null!
+ }
+
+ @Override
+ public E get(int index) {
+ return null;
+ }
+
+ @Override
+ public int size() {
+ return 0;
+ }
+ }
+}
diff --git a/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/utils/HullHider.java b/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/utils/HullHider.java
new file mode 100644
index 00000000..c613a4ab
--- /dev/null
+++ b/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/utils/HullHider.java
@@ -0,0 +1,241 @@
+/*
+ This file is a part of the SteamWar software.
+
+ Copyright (C) 2022 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 hullMap = new HashMap<>();
+ private final Hull[] hulls;
+ private final Map, BiFunction> packetHiders = new HashMap<>();
+
+ public HullHider() {
+ if(!TechHiderWrapper.ENABLED) {
+ hulls = new Hull[0];
+ return;
+ }
+
+ Fight.teams().forEach(team -> hullMap.put(team, new Hull(team)));
+ hulls = hullMap.values().toArray(new Hull[0]);
+
+ packetHiders.put(packetPlayOutWorldEvent, this::worldEventHider);
+ packetHiders.put(packetPlayOutExplosion, this::explosionHider);
+ posHiderGenerator("{nms.network.protocol.game}.PacketPlayOutWorldParticles", Core.getVersion() >= 18 ? double.class : float.class, 1.0);
+ posHiderGenerator("{nms.network.protocol.game}.PacketPlayOutNamedSoundEffect", int.class, 8.0);
+ if(Core.getVersion() >= 9 && Core.getVersion() < 18)
+ posHiderGenerator("{nms.network.protocol.game}.PacketPlayOutCustomSoundEffect", int.class, 8.0);
+
+ new StateDependentListener(TechHiderWrapper.ENABLED, FightState.Schem, this);
+ new StateDependent(TechHiderWrapper.ENABLED, FightState.Schem) {
+ @Override
+ public void enable() {
+ packetHiders.forEach(TinyProtocol.instance::addFilter);
+ Bukkit.getOnlinePlayers().forEach(HullHider.this::updatePlayer);
+ }
+
+ @Override
+ public void disable() {
+ Bukkit.getOnlinePlayers().forEach(player -> removePlayer(player, true));
+ packetHiders.forEach(TinyProtocol.instance::removeFilter);
+ }
+ }.register();
+ new StateDependentTask(TechHiderWrapper.ENABLED, FightState.Schem, this::onTick, 0, 1);
+ }
+
+ public void initialize(FightTeam team) {
+ if(!TechHiderWrapper.ENABLED)
+ return;
+
+ hullMap.get(team).initialize();
+ }
+
+
+ @EventHandler(priority = EventPriority.HIGH)
+ public void onJoin(PlayerJoinEvent e) {
+ updatePlayer(e.getPlayer());
+ }
+
+ @EventHandler
+ public void onLeave(PlayerQuitEvent e) {
+ removePlayer(e.getPlayer(), false);
+ }
+
+ public void updatePlayer(Player player) {
+ if(!TechHiderWrapper.ENABLED)
+ return;
+
+ FightTeam team = Fight.getPlayerTeam(player);
+ FightPlayer fp = Fight.getFightPlayer(player);
+ for(Map.Entry hull : hullMap.entrySet()) {
+ if(Config.isReferee(player) || hull.getKey() == team || (fp != null && fp.canEntern())) {
+ hull.getValue().removePlayer(player, true);
+ } else {
+ hull.getValue().addPlayer(player);
+ }
+ }
+ }
+
+ private void removePlayer(Player player, boolean activeRemoval) {
+ for (Hull hull : hulls)
+ hull.removePlayer(player, activeRemoval);
+ }
+
+
+ @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
+ public void onBlockPhysic(BlockPhysicsEvent e) {
+ if(FlatteningWrapper.impl.doRecord(e))
+ blockUpdate(e.getBlock(), e.getChangedType());
+ }
+
+ public void blockUpdate(Block block, Material changedType) {
+ for (Hull hull : hulls)
+ hull.updateBlockVisibility(block, changedType);
+ }
+
+ public boolean isBlockHidden(Player player, int x, int y, int z) {
+ if(!TechHiderWrapper.ENABLED)
+ return false;
+
+ for (Hull hull : hulls)
+ if(hull.isBlockHidden(player, x, y, z))
+ return true;
+
+ return false;
+ }
+
+ public boolean blockPrecise(Player player, int chunkX, int chunkY, int chunkZ) {
+ if(!TechHiderWrapper.ENABLED)
+ return false;
+
+ for (Hull hull : hulls)
+ if(hull.blockPrecise(player, chunkX, chunkY, chunkZ))
+ return true;
+
+ return false;
+ }
+
+ @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
+ public void onSpawn(EntitySpawnEvent e) {
+ for (Hull hull : hulls)
+ hull.checkEntity(e.getEntity());
+ }
+
+ private void onTick() {
+ Recording.iterateOverEntities(Objects::nonNull, entity -> {
+ for (Hull hull : hulls)
+ hull.checkEntity(entity);
+ });
+
+ for (Hull hull : hulls)
+ hull.sendUncoveredBlocks();
+ }
+
+ @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
+ public void onDeath(EntityDeathEvent e) {
+ for(Hull hull : hulls)
+ hull.removeEntity(e.getEntity());
+ }
+
+ public void updateREntity(REntity e) {
+ for(Hull hull : hulls)
+ hull.checkREntity(e);
+ }
+
+ public void despawnREntity(REntity e) {
+ for(Hull hull : hulls)
+ hull.removeREntity(e);
+ }
+
+
+ private static final Class packetPlayOutWorldEvent = Reflection.getClass("{nms.network.protocol.game}.PacketPlayOutWorldEvent");
+ private static final Reflection.FieldAccessor worldEventPosition = Reflection.getField(packetPlayOutWorldEvent, TechHider.blockPosition, 0);
+ public static final Reflection.FieldAccessor blockPositionY = Reflection.getField("{nms.core}.BaseBlockPosition", int.class, 1);
+ private Object worldEventHider(Player player, Object packet) {
+ Object baseBlock = worldEventPosition.get(packet);
+ return packetHider(player, packet, new Location(Config.world, TechHider.blockPositionX.get(baseBlock), blockPositionY.get(baseBlock), TechHider.blockPositionZ.get(baseBlock)));
+ }
+
+ private static final Class packetPlayOutExplosion = Reflection.getClass("{nms.network.protocol.game}.PacketPlayOutExplosion");
+ private static final Reflection.FieldAccessor explosionBlocks = Reflection.getField(packetPlayOutExplosion, List.class, 0);
+ private static final Function explosionLocation = posPacketToLocation(packetPlayOutExplosion, double.class, 1.0);
+ private Object explosionHider(Player player, Object packet) {
+ if(explosionBlocks.get(packet).isEmpty())
+ return packetHider(player, packet, explosionLocation.apply(packet));
+
+ return packet;
+ }
+
+ private void posHiderGenerator(String typeName, Class posType, double factor) {
+ Class type = Reflection.getClass(typeName);
+ Function location = posPacketToLocation(type, posType, factor);
+ packetHiders.put(type, (player, packet) -> packetHider(player, packet, location.apply(packet)));
+ }
+
+ private static Function posPacketToLocation(Class type, Class posType, double factor) {
+ Reflection.FieldAccessor x = Reflection.getField(type, posType, 0);
+ Reflection.FieldAccessor y = Reflection.getField(type, posType, 1);
+ Reflection.FieldAccessor z = Reflection.getField(type, posType, 2);
+
+ return packet -> new Location(Config.world, x.get(packet).doubleValue()/factor, y.get(packet).doubleValue()/factor, z.get(packet).doubleValue()/factor);
+ }
+
+ private Object packetHider(Player player, Object packet, Location location) {
+ for(Hull hull : hulls) {
+ if(hull.isLocationHidden(player, location))
+ return null;
+ }
+
+ return packet;
+ }
+}
diff --git a/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/utils/HullHiderWrapper.java b/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/utils/HullHiderWrapper.java
new file mode 100644
index 00000000..17a5195b
--- /dev/null
+++ b/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/utils/HullHiderWrapper.java
@@ -0,0 +1,31 @@
+/*
+ * This file is a part of the SteamWar software.
+ *
+ * Copyright (C) 2024 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 changes);
+}
diff --git a/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/utils/ItemBuilder.java b/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/utils/ItemBuilder.java
new file mode 100644
index 00000000..728fb924
--- /dev/null
+++ b/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/utils/ItemBuilder.java
@@ -0,0 +1,55 @@
+/*
+ This file is a part of the SteamWar software.
+
+ Copyright (C) 2020 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 executor) {
+ for(int x = getMinChunkX(); x <= getMaxChunkX(); x++)
+ for(int z = getMinChunkZ(); z <= getMaxChunkZ(); z++)
+ executor.accept(x, z);
+ }
+
+ public void forEach(TriConsumer executor) {
+ for(int x = minX; x < maxX; x++) {
+ for(int y = minY; y < maxY; y++) {
+ for (int z = minZ; z < maxZ; z++) {
+ executor.accept(x, y, z);
+ }
+ }
+ }
+ }
+
+ public int volume(){
+ return (maxX - minX) * (maxY - minY) * (maxZ - minZ);
+ }
+
+ public double centerX() {
+ return (maxX - minX) / 2.0 + minX;
+ }
+
+ public double centerZ() {
+ return (maxZ - minZ) / 2.0 + minZ;
+ }
+
+ public boolean in2dRegion(Location location){
+ return minX <= location.getX() && location.getX() < maxX && minZ <= location.getZ() && location.getZ() <= maxZ;
+ }
+
+ public boolean inRegion(Location location){
+ return in2dRegion(location) && minY < location.getY() && location.getY() < maxY;
+ }
+
+ public boolean playerInRegion(Location location){
+ return in2dRegion(location) && minY <= location.getY() && location.getY() < maxY;
+ }
+
+ public boolean in2dRegion(Block block){
+ return in2dRegion(block.getX(), block.getZ());
+ }
+
+ public boolean in2dRegion(int x, int z) {
+ return minX <= x && x < maxX && minZ <= z && z < maxZ;
+ }
+
+ public boolean inRegion(Block block){
+ return in2dRegion(block) && minY <= block.getY() && block.getY() < maxY;
+ }
+
+ public boolean inRegion(int x, int y, int z) {
+ return in2dRegion(x, z) && minY <= y && y < maxY;
+ }
+
+ public Region intersection(Region other) {
+ int x = Math.max(minX, other.minX);
+ int y = Math.max(minY, other.minY);
+ int z = Math.max(minZ, other.minZ);
+
+ return new Region(x, y, z, Math.min(maxX, other.maxX), Math.min(maxY, other.maxY), Math.min(maxZ, other.maxZ));
+ }
+
+ public Region to2d() {
+ return new Region(minX, Integer.MIN_VALUE/2, minZ, maxX, Integer.MAX_VALUE/2, maxZ);
+ }
+
+ public interface TriConsumer{
+ void accept(T x, V y, U z);
+ }
+}
diff --git a/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/utils/SWSound.java b/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/utils/SWSound.java
new file mode 100644
index 00000000..9ae178d9
--- /dev/null
+++ b/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/utils/SWSound.java
@@ -0,0 +1,41 @@
+/*
+ This file is a part of the SteamWar software.
+
+ Copyright (C) 2021 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 hiddenRegion = new ConcurrentHashMap<>();
+ private final TechHider techHider;
+
+ public TechHiderWrapper() {
+ super(ENABLED, FightState.Schem);
+ techHider = new TechHider(this, Config.ObfuscateWith, Config.HiddenBlocks, Config.HiddenBlockEntities);
+
+ new StateDependentListener(ENABLED, FightState.Schem, this);
+ register();
+ }
+
+ @Override
+ public void enable() {
+ techHider.enable();
+ }
+
+ @Override
+ public void disable() {
+ techHider.disable();
+ hiddenRegion.clear();
+ }
+
+ @EventHandler
+ public void teamJoin(TeamSpawnEvent e) {
+ e.getFightPlayer().ifPlayer(player -> hiddenRegion.put(player, getHiddenRegion(player)));
+ }
+
+ @EventHandler
+ public void boarding(BoardingEvent e) {
+ e.getFightPlayer().ifPlayer(player -> hiddenRegion.put(player, getHiddenRegion(player)));
+ }
+
+ @EventHandler
+ public void teamLeave(TeamLeaveEvent e) {
+ e.getFightPlayer().ifPlayer(player -> {
+ if(player.isOnline())
+ hiddenRegion.put(player, getHiddenRegion(player));
+ });
+ }
+
+ @EventHandler
+ public void playerQuit(PlayerQuitEvent e) {
+ Player player = e.getPlayer();
+ hiddenRegion.remove(player);
+ }
+
+ public void reloadChunks(Player player, Region region, Region exclusion) {
+ if(!ENABLED || !FightState.Schem.contains(FightState.getFightState()) || !player.isOnline())
+ return;
+
+ region.forEachChunk((chunkX, chunkZ) -> {
+ if(exclusion.chunkOutside(chunkX, chunkZ))
+ CraftbukkitWrapper.impl.sendChunk(player, chunkX, chunkZ);
+ });
+ }
+
+ @Override
+ public boolean skipChunk(Player player, int chunkX, int chunkZ) {
+ return getHiddenRegion(player).chunkOutside(chunkX, chunkZ);
+ }
+
+ @Override
+ public boolean skipChunkSection(Player player, int chunkX, int chunkY, int chunkZ) {
+ return getHiddenRegion(player).chunkSectionOutside(chunkX, chunkY, chunkZ);
+ }
+
+ @Override
+ public TechHider.State check(Player player, int x, int y, int z) {
+ if(hiddenRegion.computeIfAbsent(player, this::getHiddenRegion).inRegion(x, y, z)) {
+ if(FightSystem.getHullHider().isBlockHidden(player, x, y, z)) {
+ return TechHider.State.HIDE;
+ } else {
+ return TechHider.State.CHECK;
+ }
+ } else {
+ return TechHider.State.SKIP;
+ }
+ }
+
+ @Override
+ public boolean blockPrecise(Player player, int chunkX, int chunkY, int chunkZ) {
+ return FightSystem.getHullHider().blockPrecise(player, chunkX, chunkY, chunkZ);
+ }
+
+ private Region getHiddenRegion(Player player) {
+ if(Config.isReferee(player))
+ return Region.EMPTY;
+
+ FightTeam team = Fight.getPlayerTeam(player);
+ if(team == null)
+ return Config.ArenaRegion;
+
+ if(team.canPlayerEntern(player))
+ return Region.EMPTY;
+
+ return Fight.getOpposite(team).getExtendRegion();
+ }
+}
diff --git a/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/utils/WorldOfColorWrapper.java b/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/utils/WorldOfColorWrapper.java
new file mode 100644
index 00000000..e69b4d29
--- /dev/null
+++ b/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/utils/WorldOfColorWrapper.java
@@ -0,0 +1,40 @@
+/*
+ This file is a part of the SteamWar software.
+
+ Copyright (C) 2021 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 printableWinconditions = new ArrayList<>();
+
+ private final String windescription;
+
+ protected Wincondition(String windescription) {
+ this.windescription = windescription;
+ }
+
+ public static Countdown getTimeOverCountdown(){
+ if(timeOverCountdown == null)
+ return null;
+ return timeOverCountdown.getCountdown();
+ }
+
+ protected void win(FightTeam team, String subtitle, Object... params){
+ FightSystem.setSpectateState(team, windescription, subtitle, params);
+ }
+
+ protected FightTeam isTarget(Entity player){
+ if(!(player instanceof LivingEntity))
+ return null;
+
+ return Fight.getPlayerTeam((LivingEntity) player);
+ }
+
+ protected void comparisonWin(ToDoubleFunction evaluate, String winMessage, String tieMessage) {
+ double max = Fight.teams().stream().mapToDouble(evaluate).max().orElseThrow(() -> new SecurityException("No teams present"));
+ List 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());
+ }
+}
diff --git a/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/winconditions/WinconditionAllDead.java b/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/winconditions/WinconditionAllDead.java
new file mode 100644
index 00000000..8f2d73a3
--- /dev/null
+++ b/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/winconditions/WinconditionAllDead.java
@@ -0,0 +1,46 @@
+/*
+ This file is a part of the SteamWar software.
+
+ Copyright (C) 2020 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 imposter = new HashMap<>();
+
+ private final Random random = new Random();
+
+ public WinconditionAmongUs() {
+ super("AmongUs");
+ new OneShotStateDependent(Winconditions.AMONG_US, FightState.Ingame, () -> {
+ imposter.put(Fight.getRedTeam(), sendMessageAndReturnImposter(Fight.getRedTeam().getPlayers()));
+ imposter.put(Fight.getBlueTeam(), sendMessageAndReturnImposter(Fight.getBlueTeam().getPlayers()));
+ });
+ new StateDependentListener(Winconditions.AMONG_US, FightState.Ingame, this);
+ }
+
+ private FightPlayer sendMessageAndReturnImposter(Collection fightPlayers) {
+ List fightPlayerList = new ArrayList<>(fightPlayers);
+ FightPlayer imposter = fightPlayerList.get(random.nextInt(fightPlayerList.size()));
+ for (FightPlayer fightPlayer : fightPlayerList) {
+ if (fightPlayer == imposter) {
+ FightSystem.getMessage().send("AMONG_US_IMPOSTER_MESSAGE", fightPlayer.getEntity());
+ } else {
+ FightSystem.getMessage().send("AMONG_US_IMPOSTER_AMONG_MESSAGE", fightPlayer.getEntity());
+ }
+ }
+ return imposter;
+ }
+
+ @EventHandler
+ public void handlePlayerDeath(PlayerDeathEvent event) {
+ handleDeath(event.getEntity().getPlayer());
+ }
+
+ @EventHandler
+ public void handlePlayerQuit(PlayerQuitEvent event) {
+ handleDeath(event.getPlayer());
+ }
+
+ private void handleDeath(Player player){
+ FightTeam team = isTarget(player);
+ if(team == null)
+ return;
+
+ FightPlayer current = team.getFightPlayer(player);
+ if (current == imposter.get(team)) {
+ win(team, "WIN_IMPOSTER_DEAD", team.getPrefix());
+ } else if (team.getAlivePlayers() <= 2 && imposter.get(team).isLiving()) {
+ win(Fight.getOpposite(team), "WIN_CREWMATE_DEAD", Fight.getOpposite(team).getPrefix());
+ }
+ }
+}
diff --git a/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/winconditions/WinconditionBlocks.java b/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/winconditions/WinconditionBlocks.java
new file mode 100644
index 00000000..b9b0c9f7
--- /dev/null
+++ b/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/winconditions/WinconditionBlocks.java
@@ -0,0 +1,92 @@
+/*
+ This file is a part of the SteamWar software.
+
+ Copyright (C) 2020 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 teamMap = new HashMap<>();
+ private final String barMessage;
+ private final Predicate isOfType;
+
+ public WinconditionBlocks(Winconditions wincondition, String windescription, String barMessage, Predicate isOfType) {
+ super(windescription);
+ this.barMessage = barMessage;
+ this.isOfType = isOfType;
+ Fight.teams().forEach(team -> teamMap.put(team, new TeamBlocks(team)));
+
+ new StateDependentTask(wincondition, FightState.Ingame, () -> teamMap.values().forEach(TeamBlocks::check), 200, 200){
+ @Override
+ public void enable() {
+ teamMap.values().forEach(TeamBlocks::find);
+ super.enable();
+ }
+ };
+
+ if(Config.ActiveWinconditions.contains(wincondition))
+ printableWinconditions.add(this);
+ }
+
+ @Override
+ public Message getDisplay(FightTeam team) {
+ return new Message(barMessage, team.getPrefix() + teamMap.get(team).blocks.size());
+ }
+
+ private class TeamBlocks {
+ private final FightTeam team;
+ private final List blocks = new ArrayList<>();
+
+ private TeamBlocks(FightTeam team) {
+ this.team = team;
+ }
+
+ private void find() {
+ blocks.clear();
+ team.getExtendRegion().forEach((x, y, z) -> {
+ Block block = Config.world.getBlockAt(x, y, z);
+ if (isOfType.test(block))
+ blocks.add(block);
+ });
+ }
+
+ private void check() {
+ blocks.removeIf(block -> !isOfType.test(block));
+ if(blocks.isEmpty())
+ win(Fight.getOpposite(team), "WIN_TECHKO", team.getColoredName());
+ }
+ }
+}
diff --git a/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/winconditions/WinconditionCaptainDead.java b/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/winconditions/WinconditionCaptainDead.java
new file mode 100644
index 00000000..de0205ab
--- /dev/null
+++ b/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/winconditions/WinconditionCaptainDead.java
@@ -0,0 +1,47 @@
+/*
+ This file is a part of the SteamWar software.
+
+ Copyright (C) 2020 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 evaluate) {
+ super(windescription);
+ if(Config.ActiveWinconditions.contains(wincondition)) {
+ timeOverCountdown = new StateDependentCountdown(wincondition, FightState.Running, new TimeOverCountdown(() -> comparisonWin(evaluate, winMessage, "WIN_TIME_OVER")));
+ }
+ }
+}
diff --git a/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/winconditions/WinconditionPercent.java b/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/winconditions/WinconditionPercent.java
new file mode 100644
index 00000000..37d3fafa
--- /dev/null
+++ b/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/winconditions/WinconditionPercent.java
@@ -0,0 +1,126 @@
+/*
+ This file is a part of the SteamWar software.
+
+ Copyright (C) 2020 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 teamMap = new HashMap<>();
+
+ protected Consumer checkWin = team -> {
+ if (getPercent(team) >= Config.PercentWin) {
+ win(Fight.getOpposite(team), "WIN_PERCENT", team.getColoredName());
+ }
+ };
+ protected Consumer postEnable = team -> {};
+
+ public WinconditionPercent(Winconditions wincondition, String windescription) {
+ super(windescription);
+
+ if (Config.ActiveWinconditions.contains(wincondition)) {
+ printableWinconditions.add(this);
+ percentWincondition = this;
+ }
+
+ Fight.teams().forEach(team -> new TeamPercent(team, wincondition));
+ }
+
+ public Message getDisplay(FightTeam team) {
+ return new Message("BAR_PERCENT", team.getPrefix() + (Math.round(10000.0 * (1.0 - getPercent(team) / Config.PercentWin)) / 100.0));
+ }
+
+ public double getPercent(FightTeam team) {
+ return teamMap.get(team).getPercent();
+ }
+
+ protected int getTotalBlocks(FightTeam team) {
+ return teamMap.get(team).totalBlocks;
+ }
+
+ protected int getCurrentBlocks(FightTeam team) {
+ return teamMap.get(team).currentBlocks;
+ }
+
+ private class TeamPercent implements Listener {
+ private final FightTeam team;
+
+ private int totalBlocks = 0;
+ private int currentBlocks = 0;
+
+ private TeamPercent(FightTeam team, Winconditions wincondition) {
+ this.team = team;
+
+ new OneShotStateDependent(wincondition, FightState.Running, this::enable);
+ new StateDependentListener(wincondition, FightState.Running, this).register();
+ teamMap.put(team, this);
+ }
+
+ @EventHandler
+ public void onEntityExplode(EntityExplodeEvent event) {
+ if (
+ event.getEntityType() == EntityType.FIREBALL ||
+ !team.getExtendRegion().inRegion(event.getEntity().getLocation()) ||
+ (!Config.PercentEntern && !Config.EnterStages.isEmpty() && Config.EnterStages.get(0) >= Wincondition.getTimeOverCountdown().getTimeLeft())
+ ) {
+ return;
+ }
+
+ event.blockList().forEach(block -> {
+ if (Config.PercentBlocks.contains(block.getType()) == Config.PercentBlocksWhitelist) {
+ currentBlocks--;
+ }
+ });
+
+ checkWin.accept(team);
+ }
+
+ private void enable() {
+ totalBlocks = 0;
+ team.getSchemRegion().forEach((x, y, z) -> {
+ if (Config.PercentBlocks.contains(Config.world.getBlockAt(x, y, z).getType()) == Config.PercentBlocksWhitelist)
+ totalBlocks++;
+ });
+ currentBlocks = totalBlocks;
+ postEnable.accept(team);
+ }
+
+ private double getPercent() {
+ if (currentBlocks >= totalBlocks) {
+ return 0;
+ }
+ return (totalBlocks - currentBlocks) * 100 / (double) totalBlocks;
+ }
+ }
+}
diff --git a/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/winconditions/WinconditionPoints.java b/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/winconditions/WinconditionPoints.java
new file mode 100644
index 00000000..028e893e
--- /dev/null
+++ b/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/winconditions/WinconditionPoints.java
@@ -0,0 +1,136 @@
+/*
+ This file is a part of the SteamWar software.
+
+ Copyright (C) 2020 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 teamMap = new HashMap<>();
+
+ public WinconditionPoints(){
+ super(Winconditions.POINTS, "Points");
+
+ checkWin = team -> {};
+ postEnable = this::pointInit;
+
+ Fight.teams().forEach(team -> teamMap.put(team, new TeamPoints(team)));
+
+ new StateDependentListener(Winconditions.POINTS, FightState.Ingame, this);
+
+ if(Config.ActiveWinconditions.contains(Winconditions.POINTS)){
+ timeOverCountdown = new StateDependentCountdown(Winconditions.POINTS, FightState.Running, new TimeOverCountdown(this::timeOver));
+ }
+ }
+
+ private void timeOver() {
+ comparisonWin(team -> teamMap.get(team).getPoints(), "WIN_POINTS", "WIN_POINTS_EQUAL");
+ }
+
+ @EventHandler
+ public void handlePlayerDeath(PlayerDeathEvent event) {
+ handleDeath(event.getEntity().getPlayer());
+ }
+
+ @EventHandler
+ public void handlePlayerQuit(PlayerQuitEvent event) {
+ handleDeath(event.getPlayer());
+ }
+
+ private void handleDeath(Player player){
+ FightTeam team = isTarget(player);
+ if(team == null)
+ return;
+
+ TeamPoints enemy = teamMap.get(Fight.getOpposite(team));
+ if(team.isPlayerLeader(player)) {
+ enemy.points += 500;
+ timeOver();
+ }else if(team.getPlayers().size() <= 5)
+ enemy.points += 300;
+ else
+ enemy.points += 200;
+
+ }
+
+ private void pointInit(FightTeam team) {
+ TeamPoints opponent = teamMap.get(Fight.getOpposite(team));
+ if(getTotalBlocks(team) == 0)
+ return;
+
+ teamMap.get(team).setup(getTotalBlocks(Fight.getOpposite(team)));
+ opponent.setup(getTotalBlocks(team));
+ }
+
+ @Override
+ public Message getDisplay(FightTeam team) {
+ return new Message("BAR_POINTS", team.getPrefix() + teamMap.get(team).getPoints());
+ }
+
+ private class TeamPoints {
+ private static final int MAX_POINTS = 2000;
+
+ private final FightTeam team;
+ private double factor;
+ private int points;
+
+ TeamPoints(FightTeam team){
+ this.team = team;
+ }
+
+ private void setup(int enemyBlocks){
+ points = 0;
+ if(enemyBlocks < getTotalBlocks(team)) {
+ this.factor = 100; //Original mit 20 (20% = 0.2 ergeben 2000 Punkte
+ } else {
+ double f = 100.0 * getTotalBlocks(team) / enemyBlocks;
+
+ if(f > 100)
+ f = 100;
+ else if(f < 40)
+ f = 40;
+
+ this.factor = f;
+ }
+ }
+
+ public int getPoints(){
+ int damagePoints = (int)(getPercent(Fight.getOpposite(team)) * factor);
+ if(damagePoints > MAX_POINTS)
+ damagePoints = MAX_POINTS;
+ return points + damagePoints;
+ }
+ }
+}
diff --git a/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/winconditions/WinconditionPointsAirShip.java b/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/winconditions/WinconditionPointsAirShip.java
new file mode 100644
index 00000000..4f166a6d
--- /dev/null
+++ b/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/winconditions/WinconditionPointsAirShip.java
@@ -0,0 +1,153 @@
+/*
+ * This file is a part of the SteamWar software.
+ *
+ * Copyright (C) 2020 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 teamMap = new HashMap<>();
+
+ public WinconditionPointsAirShip(){
+ super(Winconditions.POINTS_AIRSHIP, "Points");
+
+ checkWin = team -> {
+ if (teamMap.get(team).getPoints() > TeamPoints.WIN_POINTS) {
+ end();
+ }
+ };
+ postEnable = this::pointInit;
+
+ Fight.teams().forEach(team -> teamMap.put(team, new TeamPoints(team)));
+
+ new StateDependentListener(Winconditions.POINTS_AIRSHIP, FightState.Ingame, this);
+ new StateDependentTask(Winconditions.POINTS_AIRSHIP, FightState.Running, this::running, 20, 20);
+
+ }
+
+ private void end() {
+ comparisonWin(team -> teamMap.get(team).getPoints(), "WIN_POINTS", "WIN_POINTS_EQUAL");
+ }
+
+ private void running() {
+ AtomicBoolean possibleEnd = new AtomicBoolean(false);
+ Fight.teams().forEach(team -> {
+ teamMap.get(team).points += 1;
+ possibleEnd.compareAndSet(false, teamMap.get(team).getPoints() >= TeamPoints.WIN_POINTS);
+ });
+ if(possibleEnd.get())
+ end();
+ }
+
+ @EventHandler
+ public void handlePlayerDeath(PlayerDeathEvent event) {
+ handleDeath(event.getEntity().getPlayer());
+ }
+
+ @EventHandler
+ public void handlePlayerQuit(PlayerQuitEvent event) {
+ handleDeath(event.getPlayer());
+ }
+
+ private void handleDeath(Player player){
+ FightTeam team = isTarget(player);
+ if(team == null)
+ return;
+
+ TeamPoints enemy = teamMap.get(Fight.getOpposite(team));
+ enemy.points += 200.0 / team.getPlayerCount();
+
+ if (enemy.getPoints() >= TeamPoints.WIN_POINTS)
+ end();
+ }
+
+ private void pointInit(FightTeam team) {
+ TeamPoints opponent = teamMap.get(Fight.getOpposite(team));
+ if(getTotalBlocks(team) == 0)
+ return;
+
+ teamMap.get(team).setup(getTotalBlocks(Fight.getOpposite(team)));
+ opponent.setup(getTotalBlocks(team));
+ }
+
+ @Override
+ public Message getDisplay(FightTeam team) {
+ return new Message("BAR_POINTS_OF", team.getPrefix() + (int) Math.round(teamMap.get(team).getPoints()), TeamPoints.WIN_POINTS);
+ }
+
+ private class TeamPoints {
+ protected static final double WIN_POINTS = 1200;
+
+ private final FightTeam team;
+ private double pointGetPerXBlocksBroken;
+ private double points;
+
+ TeamPoints(FightTeam team){
+ this.team = team;
+ }
+
+ private void setup(int enemyBlocks){
+ points = 0;
+
+ int factorIndex = Math.min(Math.max(team.getPlayerCount(), Fight.getOpposite(team).getPlayerCount()), as.length) - 1;
+ double a = as[factorIndex];
+ double e = es[factorIndex];
+ double volume = team.getSchemRegion().volume();
+
+ double needed = enemyBlocks * (a - (a * enemyBlocks) / volume + (e * enemyBlocks) / volume);
+ pointGetPerXBlocksBroken = needed / WIN_POINTS;
+ }
+
+ public double getPoints(){
+ FightTeam fightTeam = Fight.getOpposite(team);
+ return points + (getPercentWincondition().getTotalBlocks(fightTeam) - getPercentWincondition().getCurrentBlocks(fightTeam)) / pointGetPerXBlocksBroken;
+ }
+ }
+}
diff --git a/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/winconditions/WinconditionTimeTechKO.java b/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/winconditions/WinconditionTimeTechKO.java
new file mode 100644
index 00000000..1659edbc
--- /dev/null
+++ b/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/winconditions/WinconditionTimeTechKO.java
@@ -0,0 +1,127 @@
+/*
+ This file is a part of the SteamWar software.
+
+ Copyright (C) 2020 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 spawnLocations = new HashMap<>();
+ private final Map countdowns = new HashMap<>();
+ private final Map currentTime = new HashMap<>();
+
+ public WinconditionTimeTechKO(){
+ super("TechKO");
+
+ new StateDependentListener(Winconditions.TIME_TECH_KO, FightState.Running, this);
+ new StateDependentTask(Winconditions.TIME_TECH_KO, FightState.Running, this::run, 20, 20);
+ new StateDependent(Winconditions.TIME_TECH_KO, FightState.Running) {
+ @Override
+ public void enable() {
+ Fight.teams().forEach(team -> currentTime.put(team, TECH_KO_HALF_TIME));
+ }
+
+ @Override
+ public void disable() {
+ spawnLocations.clear();
+ currentTime.clear();
+ countdowns.values().forEach(Countdown::disable);
+ countdowns.clear();
+ }
+ }.register();
+ }
+
+ @EventHandler
+ public void onSpawn(EntitySpawnEvent e) {
+ if(e.getEntityType() != EntityType.PRIMED_TNT)
+ return;
+
+ Location location = e.getLocation();
+ for(FightTeam team : Fight.teams()) {
+ if(team.getExtendRegion().inRegion(location)) {
+ spawnLocations.put(e.getEntity().getEntityId(), team);
+ break;
+ }
+ }
+ }
+
+ @EventHandler
+ public void onExplode(EntityExplodeEvent e) {
+ if(e.getEntityType() != EntityType.PRIMED_TNT)
+ return;
+
+ FightTeam spawn = spawnLocations.remove(e.getEntity().getEntityId());
+ if(spawn == null)
+ return;
+
+ Location location = e.getLocation();
+ for(FightTeam team : Fight.teams()) {
+ if(team != spawn && team.getExtendRegion().inRegion(location)) {
+ currentTime.put(spawn, TECH_KO_HALF_TIME);
+ TechKOCountdown countdown = countdowns.remove(spawn);
+ if(countdown != null)
+ countdown.disable();
+ }
+ }
+ }
+
+ private void run(){
+ currentTime.entrySet().forEach(entry -> {
+ entry.setValue(entry.getValue() - 1);
+ if(entry.getValue() == 0)
+ countdowns.put(entry.getKey(), new TechKOCountdown(entry.getKey(), TECH_KO_HALF_TIME));
+ });
+ }
+
+ private class TechKOCountdown extends Countdown {
+ private final FightTeam team;
+
+ public TechKOCountdown(FightTeam team, int countdownTime) {
+ super(countdownTime, new Message("TECHKO_COUNTDOWN", team.getColoredName()), SWSound.BLOCK_NOTE_PLING, false);
+ this.team = team;
+ super.enable();
+ }
+
+ @Override
+ public void countdownFinished() {
+ win(Fight.getOpposite(team), "WIN_TECHKO", team.getColoredName());
+ }
+ }
+}
diff --git a/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/winconditions/WinconditionTimeout.java b/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/winconditions/WinconditionTimeout.java
new file mode 100644
index 00000000..3207fee8
--- /dev/null
+++ b/FightSystem/FightSystem_Core/src/de/steamwar/fightsystem/winconditions/WinconditionTimeout.java
@@ -0,0 +1,39 @@
+/*
+ This file is a part of the SteamWar software.
+
+ Copyright (C) 2020 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