fix(combat): patch elytra escape exploit

eternalcombat-plugin/build.gradle.kts

@@ -96,7 +96,7 @@ bukkit {
 
 tasks {
     runServer {
-        minecraftVersion("1.21.10")
+        minecraftVersion("1.21.11")
         downloadPlugins.modrinth("WorldEdit", Versions.WORLDEDIT)
         downloadPlugins.modrinth("PacketEvents", "${Versions.PACKETEVENTS}+spigot")
         downloadPlugins.modrinth("WorldGuard", Versions.WORLDGUARD)

eternalcombat-plugin/src/main/java/com/eternalcode/combat/CombatPlugin.java

@@ -8,10 +8,13 @@
 import com.eternalcode.combat.bridge.BridgeService;
 import com.eternalcode.combat.crystalpvp.RespawnAnchorListener;
 import com.eternalcode.combat.crystalpvp.EndCrystalListener;
+import com.eternalcode.combat.fight.blocker.CommandsBlocker;
+import com.eternalcode.combat.fight.blocker.ElytraBlocker;
+import com.eternalcode.combat.fight.blocker.FlyingBlocker;
 import com.eternalcode.combat.fight.controller.FightBypassAdminController;
 import com.eternalcode.combat.fight.controller.FightBypassCreativeController;
 import com.eternalcode.combat.fight.controller.FightBypassPermissionController;
-import com.eternalcode.combat.fight.controller.FightInventoryController;
+import com.eternalcode.combat.fight.blocker.InventoryContainersBlocker;
 import com.eternalcode.combat.fight.death.DeathFlareController;
 import com.eternalcode.combat.fight.death.DeathLightningController;
 import com.eternalcode.combat.fight.drop.DropKeepInventoryService;
@@ -32,7 +35,7 @@
 import com.eternalcode.combat.fight.drop.impl.PercentDropModifier;
 import com.eternalcode.combat.fight.drop.impl.PlayersHealthDropModifier;
 import com.eternalcode.combat.fight.FightTagCommand;
-import com.eternalcode.combat.fight.controller.FightActionBlockerController;
+import com.eternalcode.combat.fight.blocker.PlaceBlockBlocker;
 import com.eternalcode.combat.fight.controller.FightMessageController;
 import com.eternalcode.combat.fight.controller.FightTagController;
 import com.eternalcode.combat.fight.controller.FightUnTagController;
@@ -181,7 +184,7 @@ public void onEnable() {
             new FightBypassAdminController(server, pluginConfig),
             new FightBypassPermissionController(server, pluginConfig),
             new FightBypassCreativeController(server, pluginConfig),
-            new FightActionBlockerController(this.fightManager, noticeService, pluginConfig, server),
+            new PlaceBlockBlocker(this.fightManager, noticeService, pluginConfig),
             new FightPearlController(pluginConfig.pearl, noticeService, this.fightManager, this.fightPearlService),
             new DeathFlareController(pluginConfig, server, scheduler, this),
             new DeathLightningController(pluginConfig, server),
@@ -196,7 +199,11 @@ public void onEnable() {
             new EndCrystalListener(this, this.fightManager, pluginConfig),
             new RespawnAnchorListener(this, this.fightManager, pluginConfig),
             new FireworkController(this.fightManager, pluginConfig, noticeService),
-            new FightInventoryController(this.fightManager, pluginConfig, noticeService)
+            new InventoryContainersBlocker(this.fightManager, pluginConfig, noticeService),
+            new CommandsBlocker(this.fightManager, noticeService, pluginConfig),
+            new ElytraBlocker(this.fightManager, noticeService, pluginConfig, server),
+            new FlyingBlocker(this.fightManager, pluginConfig, server),
+            new PlaceBlockBlocker(this.fightManager, noticeService, pluginConfig)
         );
 
         eventManager.subscribe(

eternalcombat-plugin/src/main/java/com/eternalcode/combat/config/implementation/CombatSettings.java

@@ -33,6 +33,14 @@ public class CombatSettings extends OkaeriConfig {
     })
     public boolean disableFlying = true;
 
+    @Comment({
+        "# Forcefully unequip elytra when a player enters combat.",
+        "# This prevents players from abusing glide by jumping before being tagged.",
+        "# The elytra will be moved to the player's inventory.",
+        "# Recommended: true"
+    })
+    public boolean unequipElytraOnCombat = true;
+
     @Comment({
         "# Prevent players from boosting themselves while flying with fireworks",
         "# This setting blocks usage of fireworks to boost elytra flight during combat"

eternalcombat-plugin/src/main/java/com/eternalcode/combat/config/implementation/MessagesSettings.java

@@ -70,6 +70,15 @@ public class MessagesSettings extends OkaeriConfig {
     public Notice commandDisabledDuringCombat = Notice.chat(
         "<gradient:red:yellow>⚠ <white>Command blocked!</white> Cannot use this during combat!</gradient>");
 
+    @Comment({
+        "# Message displayed when a player attempts to use an elytra during combat.",
+        "# This includes gliding, equipping, or having it forcefully removed.",
+        "# Informs the player that elytra usage is disabled in combat."
+    })
+    public Notice elytraDisabledDuringCombat = Notice.chat(
+        "<gradient:red:yellow>⚠ <white>Elytra disabled!</white> Cannot use elytra during combat!</gradient>"
+    );
+
     @Comment({
         "# Message displayed when a player uses a command with incorrect arguments.",
         "# The {USAGE} placeholder is replaced with the correct command syntax."

eternalcombat-plugin/src/main/java/com/eternalcode/combat/fight/blocker/CommandsBlocker.java

@@ -0,0 +1,54 @@
+package com.eternalcode.combat.fight.blocker;
+
+import com.eternalcode.combat.WhitelistBlacklistMode;
+import com.eternalcode.combat.config.implementation.PluginConfig;
+import com.eternalcode.combat.fight.FightManager;
+import com.eternalcode.combat.notification.NoticeService;
+import java.util.UUID;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.player.PlayerCommandPreprocessEvent;
+import org.bukkit.util.StringUtil;
+
+public class CommandsBlocker implements Listener {
+
+    private final FightManager fightManager;
+    private final NoticeService noticeService;
+    private final PluginConfig config;
+
+    public CommandsBlocker(FightManager fightManager, NoticeService noticeService, PluginConfig config) {
+        this.fightManager = fightManager;
+        this.noticeService = noticeService;
+        this.config = config;
+    }
+
+    @EventHandler
+    void onPlayerCommandPreprocess(PlayerCommandPreprocessEvent event) {
+        Player player = event.getPlayer();
+        UUID playerUniqueId = player.getUniqueId();
+
+        if (!this.fightManager.isInCombat(playerUniqueId)) {
+            return;
+        }
+
+        String command = event.getMessage().substring(1);
+
+        boolean isAnyMatch = this.config.commands.restrictedCommands.stream()
+            .anyMatch(restrictedCommand -> StringUtil.startsWithIgnoreCase(command, restrictedCommand));
+
+        WhitelistBlacklistMode mode = this.config.commands.commandRestrictionMode;
+
+        boolean shouldCancel = mode.shouldBlock(isAnyMatch);
+
+        if (shouldCancel) {
+            event.setCancelled(true);
+            this.noticeService.create()
+                .player(playerUniqueId)
+                .notice(this.config.messagesSettings.commandDisabledDuringCombat)
+                .send();
+
+        }
+    }
+
+}

eternalcombat-plugin/src/main/java/com/eternalcode/combat/fight/blocker/ElytraBlocker.java

@@ -0,0 +1,162 @@
+package com.eternalcode.combat.fight.blocker;
+
+import com.eternalcode.combat.config.implementation.PluginConfig;
+import com.eternalcode.combat.fight.FightManager;
+import com.eternalcode.combat.fight.event.FightTagEvent;
+import com.eternalcode.combat.notification.NoticeService;
+import java.util.HashMap;
+import java.util.UUID;
+import org.bukkit.Material;
+import org.bukkit.Server;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.entity.EntityDamageEvent;
+import org.bukkit.event.entity.EntityToggleGlideEvent;
+import org.bukkit.event.inventory.InventoryClickEvent;
+import org.bukkit.event.player.PlayerMoveEvent;
+import org.bukkit.inventory.ItemStack;
+
+public class ElytraBlocker implements Listener {
+
+    private final FightManager fightManager;
+    private final NoticeService noticeService;
+    private final PluginConfig config;
+    private final Server server;
+
+    public ElytraBlocker(FightManager fightManager, NoticeService noticeService, PluginConfig config, Server server) {
+        this.fightManager = fightManager;
+        this.noticeService = noticeService;
+        this.config = config;
+        this.server = server;
+    }
+
+    @EventHandler
+    void onToggleGlide(EntityToggleGlideEvent event) {
+        if (!this.config.combat.disableElytraUsage) {
+            return;
+        }
+
+        if (!(event.getEntity() instanceof Player player)) {
+            return;
+        }
+        UUID uniqueId = player.getUniqueId();
+
+        if (!this.fightManager.isInCombat(uniqueId)) {
+            return;
+        }
+
+        if (event.isGliding()) {
+            event.setCancelled(true);
+            player.setGliding(false);
+        }
+    }
+
+
+    @EventHandler
+    void onMoveWhileGliding(PlayerMoveEvent event) {
+        if (!this.config.combat.disableElytraUsage) {
+            return;
+        }
+
+        Player player = event.getPlayer();
+        UUID uniqueId = player.getUniqueId();
+
+        if (!this.fightManager.isInCombat(uniqueId)) {
+            return;
+        }
+
+        if (player.isGliding()) {
+            player.setGliding(false);
+
+            player.setFallDistance(0f);
+            player.setVelocity(player.getVelocity().setY(-1));
+        }
+    }
+
+    @EventHandler
+    void onInventoryClick(InventoryClickEvent event) {
+        if (!(event.getWhoClicked() instanceof Player player)) {
+            return;
+        }
+
+        if (!this.config.combat.unequipElytraOnCombat) {
+            return;
+        }
+
+        UUID uniqueId = player.getUniqueId();
+
+        if (!this.fightManager.isInCombat(uniqueId)) {
+            return;
+        }
+
+        if (event.getCurrentItem() == null) {
+            return;
+        }
+
+        if (event.getCurrentItem().getType() == Material.ELYTRA) {
+            event.setCancelled(true);
+
+            this.noticeService.create()
+                .player(uniqueId)
+                .notice(this.config.messagesSettings.elytraDisabledDuringCombat)
+                .send();
+        }
+    }
+
+
+    @EventHandler
+    void onTag(FightTagEvent event) {
+        UUID uniqueId = event.getPlayer();
+        Player player = this.server.getPlayer(uniqueId);
+
+        if (player == null) {
+            return;
+        }
+
+        if (this.config.combat.unequipElytraOnCombat) {
+            ItemStack chest = player.getInventory().getChestplate();
+
+            if (chest != null && chest.getType() == Material.ELYTRA) {
+                removeChestplateIfElytra(player);
+
+                this.noticeService.create()
+                    .player(uniqueId)
+                    .notice(this.config.messagesSettings.elytraDisabledDuringCombat)
+                    .send();
+            }
+        }
+    }
+
+    private void removeChestplateIfElytra(Player player) {
+        ItemStack chestplate = player.getInventory().getChestplate();
+
+        if (chestplate != null && chestplate.getType() == Material.ELYTRA) {
+            player.getInventory().setChestplate(null);
+
+            HashMap<Integer, ItemStack> leftover = player.getInventory().addItem(chestplate);
+            if (!leftover.isEmpty()) {
+                leftover.values().forEach(item ->
+                    player.getWorld().dropItemNaturally(player.getLocation(), item)
+                );
+            }
+        }
+    }
+
+    @EventHandler
+    void onDamage(EntityDamageEvent event) {
+        if (!this.config.combat.disableElytraOnDamage) {
+            return;
+        }
+
+        if (!(event.getEntity() instanceof Player player)) {
+            return;
+        }
+        UUID uniqueId = player.getUniqueId();
+
+        if (this.fightManager.isInCombat(uniqueId) && player.isGliding()) {
+            player.setGliding(false);
+        }
+    }
+
+}

eternalcombat-plugin/src/main/java/com/eternalcode/combat/fight/blocker/FlyingBlocker.java

@@ -0,0 +1,86 @@
+package com.eternalcode.combat.fight.blocker;
+
+import com.eternalcode.combat.config.implementation.PluginConfig;
+import com.eternalcode.combat.fight.FightManager;
+import com.eternalcode.combat.fight.event.FightTagEvent;
+import com.eternalcode.combat.fight.event.FightUntagEvent;
+import java.util.UUID;
+import org.bukkit.GameMode;
+import org.bukkit.Server;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.player.PlayerToggleFlightEvent;
+
+public class FlyingBlocker implements Listener {
+
+    private final FightManager fightManager;
+    private final PluginConfig config;
+    private final Server server;
+
+    public FlyingBlocker(FightManager fightManager, PluginConfig config, Server server) {
+        this.fightManager = fightManager;
+        this.config = config;
+        this.server = server;
+    }
+
+
+    @EventHandler
+    void onFly(PlayerToggleFlightEvent event) {
+        if (!this.config.combat.disableFlying) {
+            return;
+        }
+
+        Player player = event.getPlayer();
+        UUID uniqueId = player.getUniqueId();
+
+        if (!this.fightManager.isInCombat(uniqueId)) {
+            return;
+        }
+
+        if (event.isFlying()) {
+            player.setAllowFlight(false);
+
+            event.setCancelled(true);
+        }
+    }
+
+
+    @EventHandler
+    void onTag(FightTagEvent event) {
+        UUID uniqueId = event.getPlayer();
+        Player player = this.server.getPlayer(uniqueId);
+
+        if (player == null) {
+            return;
+        }
+
+        if (this.config.combat.disableFlying) {
+            GameMode gameMode = player.getGameMode();
+
+            if (gameMode != GameMode.CREATIVE && gameMode != GameMode.SPECTATOR) {
+                player.setAllowFlight(false);
+                player.setFlying(false);
+            }
+        }
+    }
+
+    @EventHandler
+    void onUnTag(FightUntagEvent event) {
+        if (!this.config.combat.disableFlying) {
+            return;
+        }
+
+        UUID uniqueId = event.getPlayer();
+        Player player = this.server.getPlayer(uniqueId);
+
+        if (player == null) {
+            return;
+        }
+        GameMode playerGameMode = player.getGameMode();
+        if (playerGameMode == GameMode.CREATIVE || playerGameMode == GameMode.SPECTATOR) {
+            player.setAllowFlight(true);
+        }
+    }
+
+}