added entity and potion listeners

varo/src/main/java/eu/mhsl/craftattack/spawn/varo/appliances/metaGameplay/forbiddenItems/ForbiddenEntityListener.java

@@ -0,0 +1,27 @@
+package eu.mhsl.craftattack.spawn.varo.appliances.metaGameplay.forbiddenItems;
+
+import eu.mhsl.craftattack.core.appliance.ApplianceListener;
+import net.kyori.adventure.text.Component;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.entity.EntitySpawnEvent;
+import org.bukkit.event.player.PlayerInteractEntityEvent;
+
+class ForbiddenEntityListener extends ApplianceListener<ForbiddenItems> {
+    @EventHandler
+    public void onEntitySpawn(EntitySpawnEvent event) {
+        if(!this.getAppliance().forbiddenEntities.isForbidden(event.getEntity())) return;
+        event.setCancelled(true);
+    }
+
+    @EventHandler
+    public void onEntityInteraction(PlayerInteractEntityEvent event) {
+        if(!this.getAppliance().forbiddenEntities.isForbidden(event.getRightClicked())) return;
+        event.setCancelled(true);
+
+        event.getPlayer().sendActionBar(
+            Component.text()
+                .append(Component.text(event.getRightClicked().getName()))
+                .append(Component.text(" ist eine verbotene Entität!"))
+        );
+    }
+}

varo/src/main/java/eu/mhsl/craftattack/spawn/varo/appliances/metaGameplay/forbiddenItems/ForbiddenGroup.java

@@ -0,0 +1,17 @@
+package eu.mhsl.craftattack.spawn.varo.appliances.metaGameplay.forbiddenItems;
+
+import java.util.Set;
+import java.util.function.Function;
+
+public class ForbiddenGroup<TType> {
+    private final Set<Function<TType, Boolean>> forbiddenT;
+
+    public ForbiddenGroup(Set<Function<TType, Boolean>> forbiddenT) {
+        this.forbiddenT = forbiddenT;
+    }
+
+    public boolean isForbidden(TType value) {
+        return this.forbiddenT.stream()
+            .anyMatch(test -> test.apply(value));
+    }
+}

varo/src/main/java/eu/mhsl/craftattack/spawn/varo/appliances/metaGameplay/forbiddenItems/ForbiddenItems.java

@@ -11,18 +11,17 @@ import org.jetbrains.annotations.NotNull;
 
 import java.util.List;
 import java.util.Set;
-import java.util.function.Function;
 
 public class ForbiddenItems extends Appliance {
-    Set<Function<Material, Boolean>> forbiddenMaterials = Set.of(
+    public ForbiddenGroup<Material> forbiddenMaterials = new ForbiddenGroup<>(Set.of(
         (material) -> material.name().startsWith("NETHERITE"),
         (material) -> material.equals(Material.TOTEM_OF_UNDYING),
         (material) -> material.equals(Material.END_CRYSTAL),
         (material) -> material.equals(Material.MACE),
         (material) -> material.equals(Material.ENCHANTED_GOLDEN_APPLE)
-    );
+    ));
 
-    Set<Function<Entity, Boolean>> forbiddenEntities = Set.of(
+    public ForbiddenGroup<Entity> forbiddenEntities = new ForbiddenGroup<>(Set.of(
         (entity) -> {
             if(!(entity instanceof Villager villager)) return false;
             return List.of(
@@ -30,31 +29,18 @@ public class ForbiddenItems extends Appliance {
                 Villager.Profession.ARMORER
             ).contains(villager.getProfession());
         }
-    );
+    ));
 
-    Set<Function<PotionEffect, Boolean>> forbiddenPotions = Set.of(
+    public ForbiddenGroup<PotionEffect> forbiddenPotions = new ForbiddenGroup<>(Set.of(
-        (potion) -> !potion.getType().equals(PotionEffectType.INSTANT_HEALTH) && potion.getAmplifier() >= 2
+        (potion) -> !potion.getType().equals(PotionEffectType.INSTANT_HEALTH) && potion.getAmplifier() >= 1     // Amplifier starts at 0
-    );
+    ));
-
-    public boolean isForbidden(Material material) {
-        return this.forbiddenMaterials.stream()
-            .anyMatch(test -> test.apply(material));
-    }
-
-    public boolean isForbidden(Entity entity) {
-        return this.forbiddenEntities.stream()
-            .anyMatch(test -> test.apply(entity));
-    }
-
-    public boolean isForbidden(PotionEffect potionEffect) {
-        return this.forbiddenPotions.stream()
-            .anyMatch(test -> test.apply(potionEffect));
-    }
 
     @Override
     protected @NotNull List<Listener> listeners() {
         return List.of(
-            new ForbiddenMaterialListener()
+            new ForbiddenMaterialListener(),
+            new ForbiddenEntityListener(),
+            new ForbiddenPotionsListener()
         );
     }
 }

varo/src/main/java/eu/mhsl/craftattack/spawn/varo/appliances/metaGameplay/forbiddenItems/ForbiddenMaterialListener.java

@@ -27,7 +27,7 @@ class ForbiddenMaterialListener extends ApplianceListener<ForbiddenItems> {
     }
 
     private void testAndCancel(Cancellable event, Material material, Entity entity) {
-        if(!this.getAppliance().isForbidden(material)) return;
+        if(!this.getAppliance().forbiddenMaterials.isForbidden(material)) return;
         event.setCancelled(true);
 
         if(entity instanceof Player p) {

varo/src/main/java/eu/mhsl/craftattack/spawn/varo/appliances/metaGameplay/forbiddenItems/ForbiddenPotionsListener.java

@@ -0,0 +1,54 @@
+package eu.mhsl.craftattack.spawn.varo.appliances.metaGameplay.forbiddenItems;
+
+import eu.mhsl.craftattack.core.appliance.ApplianceListener;
+import net.kyori.adventure.text.Component;
+import org.bukkit.entity.Player;
+import org.bukkit.event.Cancellable;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.entity.LingeringPotionSplashEvent;
+import org.bukkit.event.entity.PotionSplashEvent;
+import org.bukkit.event.player.PlayerItemConsumeEvent;
+import org.bukkit.inventory.meta.PotionMeta;
+import org.bukkit.potion.PotionEffect;
+
+import javax.annotation.Nullable;
+import java.util.Collection;
+
+class ForbiddenPotionsListener extends ApplianceListener<ForbiddenItems> {
+    @EventHandler
+    public void onPotionSplash(PotionSplashEvent event) {
+        Collection<PotionEffect> effects = event.getPotion().getEffects();
+
+        this.testAndCancel(event, effects, null);
+    }
+
+    @EventHandler
+    public void onPotionConsume(PlayerItemConsumeEvent event) {
+        if(!(event.getItem().getItemMeta() instanceof PotionMeta meta)) return;
+        if(meta.getBasePotionType() == null) return;
+        Collection<PotionEffect> effects = meta.getBasePotionType().getPotionEffects();
+
+        this.testAndCancel(event, effects, event.getPlayer());
+    }
+
+    @EventHandler
+    public void onLingeringPotionSplash(LingeringPotionSplashEvent event) {
+        if(event.getAreaEffectCloud().getBasePotionType() == null) return;
+        Collection<PotionEffect> effects = event.getAreaEffectCloud().getBasePotionType().getPotionEffects();
+
+        this.testAndCancel(event, effects, null);
+    }
+
+    private void testAndCancel(Cancellable event, Collection<PotionEffect> effects, @Nullable Player player) {
+        if(effects.stream().noneMatch(potionEffect -> this.getAppliance().forbiddenPotions.isForbidden(potionEffect))) return;
+
+        event.setCancelled(true);
+
+        if(player == null) return;
+
+        player.sendActionBar(
+            Component.text()
+                .append(Component.text("Das ist ein verbotener Trank!"))
+        );
+    }
+}