added Bedrock player warning in joinEvent method to handle potential compatibility issues

Reviewed-on: #10
Reviewed-by: Elias Müller <elias@elias-mueller.com>

common/src/main/java/eu/mhsl/craftattack/spawn/common/api/repositories/CraftAttackReportRepository.java

@@ -23,4 +23,8 @@ public class CraftAttackReportRepository extends ReportRepository {
             ReportUrl.class
         );
     }
+
+    public ReqResp<AllReports> queryAllReports() {
+        return this.get("reports", AllReports.class);
+    }
 }

common/src/main/java/eu/mhsl/craftattack/spawn/common/api/repositories/ReportRepository.java

@@ -21,6 +21,11 @@ public abstract class ReportRepository extends HttpRepository {
     public record ReportUrl(@NotNull String url) {
     }
 
+    public enum Status {
+        open,
+        closed,
+    }
+
     public record PlayerReports(
         List<Report> from_self,
         List<Report> to_self
@@ -31,11 +36,17 @@ public abstract class ReportRepository extends HttpRepository {
             @Nullable Long created,
             @Nullable Status status,
             @NotNull String url
-        ) {
-            public enum Status {
-                open,
-                closed,
-            }
+        ) { }
     }
+
+    public record AllReports(List<Report> reports) {
+        public record Report(
+            @NotNull UUID reporter,
+            @Nullable UUID reported,
+            @NotNull String reason,
+            @Nullable Long created,
+            @Nullable Status status,
+            @NotNull String url
+        ) { }
     }
 }

common/src/main/java/eu/mhsl/craftattack/spawn/common/appliances/metaGameplay/report/Report.java

@@ -1,6 +1,8 @@
 package eu.mhsl.craftattack.spawn.common.appliances.metaGameplay.report;
 
 import eu.mhsl.craftattack.spawn.common.api.repositories.ReportRepository;
+import eu.mhsl.craftattack.spawn.common.appliances.metaGameplay.report.listeners.ReportCreatedListener;
+import eu.mhsl.craftattack.spawn.common.appliances.metaGameplay.report.listeners.ReportJoinListener;
 import eu.mhsl.craftattack.spawn.core.Main;
 import eu.mhsl.craftattack.spawn.core.api.client.ReqResp;
 import eu.mhsl.craftattack.spawn.common.api.repositories.CraftAttackReportRepository;
@@ -16,6 +18,7 @@ import net.kyori.adventure.text.format.NamedTextColor;
 import org.bukkit.Bukkit;
 import org.bukkit.OfflinePlayer;
 import org.bukkit.entity.Player;
+import org.bukkit.event.Listener;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
@@ -132,7 +135,7 @@ public class Report extends Appliance {
         }
 
         Function<List<ReportRepository.PlayerReports.Report>, List<ReportRepository.PlayerReports.Report>> filterClosed = reports -> reports.stream()
-            .filter(report -> Objects.equals(report.status(), ReportRepository.PlayerReports.Report.Status.closed))
+            .filter(report -> Objects.equals(report.status(), ReportRepository.Status.closed))
             .toList();
 
         List<ReportRepository.PlayerReports.Report> reportsToOthers = filterClosed.apply(userReports.data().from_self()).reversed();
@@ -178,6 +181,35 @@ public class Report extends Appliance {
         issuer.sendMessage(component.build());
     }
 
+    public void sendReportsInfo(Player player) {
+        ReqResp<ReportRepository.AllReports> allReportsResponse = this.queryRepository(CraftAttackReportRepository.class).queryAllReports();
+
+        if(allReportsResponse.status() != 200) {
+            Main.logger().warning("Failed to request Reports: " + allReportsResponse.status());
+            return;
+        }
+
+        List<ReportRepository.AllReports.Report> allOpenReports = allReportsResponse.data().reports().stream()
+            .filter(report -> report.status() == null && report.created() != null)
+            .toList();
+
+        if(allOpenReports.isEmpty()) return;
+
+        player.sendMessage(
+            Component.text("Hey, es gibt noch ", NamedTextColor.GOLD)
+                .append(Component.text(allOpenReports.size(), NamedTextColor.RED))
+                .append(Component.text(" unbearbeitete Reports!", NamedTextColor.GOLD))
+        );
+    }
+
+    @Override
+    protected @NotNull List<Listener> listeners() {
+        return List.of(
+            new ReportCreatedListener(),
+            new ReportJoinListener()
+        );
+    }
+
     @Override
     @NotNull
     protected List<ApplianceCommand<?>> commands() {

common/src/main/java/eu/mhsl/craftattack/spawn/common/appliances/metaGameplay/report/listeners/ReportCreatedListener.java

@@ -0,0 +1,27 @@
+package eu.mhsl.craftattack.spawn.common.appliances.metaGameplay.report.listeners;
+
+import eu.mhsl.craftattack.spawn.common.appliances.metaGameplay.report.Report;
+import eu.mhsl.craftattack.spawn.core.appliance.ApplianceListener;
+import eu.mhsl.craftattack.spawn.core.event.ReportCreatedEvent;
+import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.format.NamedTextColor;
+import org.bukkit.Bukkit;
+import org.bukkit.OfflinePlayer;
+import org.bukkit.event.EventHandler;
+
+public class ReportCreatedListener extends ApplianceListener<Report> {
+    @EventHandler
+    public void onReport(ReportCreatedEvent event) {
+        OfflinePlayer reporter = Bukkit.getOfflinePlayer(event.getReport().reporter());
+        OfflinePlayer reported = Bukkit.getOfflinePlayer(event.getReport().reported());
+
+        Component message = Component.text(
+            "\uD83D\uDD14 Neuer Report von %s gegen %s: %s".formatted(reporter.getName(), reported.getName(), event.getReport().reason()),
+            NamedTextColor.YELLOW
+        );
+
+        Bukkit.getOnlinePlayers().stream()
+            .filter(player -> player.hasPermission("admin"))
+            .forEach(player -> player.sendMessage(message));
+    }
+}

common/src/main/java/eu/mhsl/craftattack/spawn/common/appliances/metaGameplay/report/listeners/ReportJoinListener.java

@@ -0,0 +1,19 @@
+package eu.mhsl.craftattack.spawn.common.appliances.metaGameplay.report.listeners;
+
+import eu.mhsl.craftattack.spawn.common.appliances.metaGameplay.report.Report;
+import eu.mhsl.craftattack.spawn.core.Main;
+import eu.mhsl.craftattack.spawn.core.appliance.ApplianceListener;
+import org.bukkit.Bukkit;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.player.PlayerJoinEvent;
+
+public class ReportJoinListener extends ApplianceListener<Report> {
+    @EventHandler
+    public void onPlayerJoin(PlayerJoinEvent event) {
+        if(!event.getPlayer().hasPermission("admin")) return;
+        Bukkit.getScheduler().runTaskAsynchronously(
+            Main.instance(),
+            () -> this.getAppliance().sendReportsInfo(event.getPlayer())
+        );
+    }
+}

common/src/main/java/eu/mhsl/craftattack/spawn/common/appliances/metaGameplay/settings/Settings.java

@@ -38,7 +38,8 @@ public class Settings extends Appliance {
         BorderWarning,
         LocatorBar,
         InfoBars,
-        CoordinateDisplay
+        CoordinateDisplay,
+        Bloodmoon
     }
 
     public static Settings instance() {
@@ -127,12 +128,12 @@ public class Settings extends Appliance {
                 if(categorizedSettings.isEmpty()) return;
 
                 for(int i = 0; i < categorizedSettings.size(); i++) {
-                    int slot = row.get() * 9 + i % 9;
-                    inventory.setItem(slot, categorizedSettings.get(i).buildItem());
-
-                    if(i % 9 == 8) {
+                    if(i % 9 == 0 && i != 0) {
                         row.incrementAndGet();
                     }
+
+                    int slot = row.get() * 9 + i % 9;
+                    inventory.setItem(slot, categorizedSettings.get(i).buildItem());
                 }
                 row.incrementAndGet();
             });
@@ -142,12 +143,12 @@ public class Settings extends Appliance {
             .toList();
 
         for(int i = 0; i < uncategorizedSettings.size(); i++) {
-            int slot = row.get() * 9 + i % 9;
-            inventory.setItem(slot, uncategorizedSettings.get(i).buildItem());
-
-            if(i % 9 == 8) {
+            if(i % 9 == 0 && i != 0) {
                 row.incrementAndGet();
             }
+
+            int slot = row.get() * 9 + i % 9;
+            inventory.setItem(slot, uncategorizedSettings.get(i).buildItem());
         }
 
         player.openInventory(inventory);

common/src/main/java/eu/mhsl/craftattack/spawn/common/appliances/security/antiBoatFreecam/AntiBoatFreecam.java

@@ -5,15 +5,10 @@ import eu.mhsl.craftattack.spawn.core.Main;
 import eu.mhsl.craftattack.spawn.core.appliance.Appliance;
 import org.bukkit.Bukkit;
 import org.bukkit.entity.Boat;
-import org.bukkit.entity.Player;
-
-import java.util.HashMap;
-import java.util.Map;
 
 @SuppressWarnings("unused")
 public class AntiBoatFreecam extends Appliance {
     private static final float MAX_YAW_OFFSET = 106.0f;
-    private final Map<Player, Float> violatedPlayers = new HashMap<>();
 
     public AntiBoatFreecam() {
         Bukkit.getScheduler().runTaskTimerAsynchronously(
@@ -27,14 +22,12 @@ public class AntiBoatFreecam extends Appliance {
                 float yawDelta = wrapDegrees(playerYaw - boatYaw);
                 if(Math.abs(yawDelta) <= MAX_YAW_OFFSET) return;
 
-                this.violatedPlayers.merge(player, 1f, Float::sum);
-                float violationCount = this.violatedPlayers.get(player);
-                if(violationCount != 1 && violationCount % 100 != 0) return;
-                Main.instance().getAppliance(AcInform.class).notifyAdmins(
+                Main.instance().getAppliance(AcInform.class).slowedNotifyAdmins(
                     "internal",
                     player.getName(),
                     "illegalBoatLookYaw",
-                    violationCount
+                    yawDelta,
+                    3000
                 );
             }),
             1L,

common/src/main/java/eu/mhsl/craftattack/spawn/common/appliances/security/antiIllegalSignCharacters/AntiIllegalSignCharacters.java

@@ -0,0 +1,16 @@
+package eu.mhsl.craftattack.spawn.common.appliances.security.antiIllegalSignCharacters;
+
+import eu.mhsl.craftattack.spawn.core.appliance.Appliance;
+import org.bukkit.event.Listener;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.List;
+
+public class AntiIllegalSignCharacters extends Appliance {
+    @Override
+    protected @NotNull List<Listener> listeners() {
+        return List.of(
+            new SignEditListener()
+        );
+    }
+}

common/src/main/java/eu/mhsl/craftattack/spawn/common/appliances/security/antiIllegalSignCharacters/SignEditListener.java

@@ -0,0 +1,77 @@
+package eu.mhsl.craftattack.spawn.common.appliances.security.antiIllegalSignCharacters;
+
+import eu.mhsl.craftattack.spawn.core.appliance.ApplianceListener;
+import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.serializer.plain.PlainTextComponentSerializer;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.block.SignChangeEvent;
+
+import java.text.Normalizer;
+import java.util.Set;
+
+class SignEditListener extends ApplianceListener<AntiIllegalSignCharacters> {
+    private static final Set<Integer> ALLOWED_CHARS = Set.of(
+        (int)' ', (int)'.', (int)',', (int)';', (int)':', (int)'!', (int)'?',
+        (int)'"', (int)'\'',
+        (int)'(', (int)')', (int)'[', (int)']', (int)'{', (int)'}',
+        (int)'-', (int)'_', (int)'+', (int)'=', (int)'/', (int)'\\',
+        (int)'@', (int)'#', (int)'$', (int)'%', (int)'&', (int)'*',
+        (int)'<', (int)'>', (int)'|',
+        (int)'~', (int)'`', (int)'^'
+    );
+
+    private static final Set<Integer> ALLOWED_EXTRA = Set.of(
+        (int)'Ä', (int)'Ö', (int)'Ü', (int)'ä', (int)'ö', (int)'ü', (int)'ß',
+        (int)'€', (int)'°', (int)'µ'
+    );
+
+    @EventHandler
+    public void onSignEdit(SignChangeEvent event) {
+        for (int i = 0; i < 4; i++) {
+            Component line = event.line(i);
+            if (line == null) continue;
+            String plainString = PlainTextComponentSerializer.plainText().serialize(line);
+            plainString = Normalizer.normalize(plainString, Normalizer.Form.NFC);
+            String cleaned = filterAllowed(plainString);
+            event.line(i, Component.text(cleaned));
+        }
+    }
+
+    private static String filterAllowed(String s) {
+        StringBuilder out = new StringBuilder(s.length());
+
+        for (int off = 0; off < s.length(); ) {
+            int cp = s.codePointAt(off);
+            off += Character.charCount(cp);
+
+            if (isForbidden(cp)) continue;
+
+            if (Character.isLetterOrDigit(cp)) {
+                out.appendCodePoint(cp);
+                continue;
+            }
+
+            if (ALLOWED_CHARS.contains(cp) || ALLOWED_EXTRA.contains(cp)) {
+                out.appendCodePoint(cp);
+            }
+        }
+        return out.toString();
+    }
+
+    private static boolean isForbidden(int cp) {
+        // Surrogates / invalid
+        if (cp >= 0xD800 && cp <= 0xDFFF) return true;
+
+        // Private Use Area (Mod/Pack-Icons/Placeholder)
+        if (cp >= 0xE000 && cp <= 0xF8FF) return true;
+
+        // Zero-width and control characters
+        if (cp == 0x200B || cp == 0x200C || cp == 0x200D || cp == 0xFEFF) return true;
+
+        // BiDi-Steuerzeichen
+        if (cp >= 0x202A && cp <= 0x202E) return true;
+        if (cp >= 0x2066 && cp <= 0x2069) return true;
+
+        return cp == '§';
+    }
+}

common/src/main/java/eu/mhsl/craftattack/spawn/common/appliances/security/antiInventoryMove/AntiInventoryMove.java

@@ -0,0 +1,39 @@
+package eu.mhsl.craftattack.spawn.common.appliances.security.antiInventoryMove;
+
+import eu.mhsl.craftattack.spawn.core.appliance.Appliance;
+import net.kyori.adventure.util.Ticks;
+import org.bukkit.entity.Player;
+import org.bukkit.event.Listener;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.List;
+import java.util.Map;
+import java.util.UUID;
+import java.util.concurrent.ConcurrentHashMap;
+
+@Appliance.Flags(enabled = false)
+public class AntiInventoryMove extends Appliance {
+    private static final long errorTimeMargin = Ticks.SINGLE_TICK_DURATION_MS * 2;
+
+    private final Map<UUID, Long> invOpen = new ConcurrentHashMap<>();
+
+    public void setInvOpen(Player player, boolean open) {
+        if(open)
+            this.invOpen.put(player.getUniqueId(), System.currentTimeMillis());
+        else
+            this.invOpen.remove(player.getUniqueId());
+    }
+
+    public boolean hasInventoryOpen(Player player) {
+        if(!this.invOpen.containsKey(player.getUniqueId())) return false;
+        return this.invOpen.get(player.getUniqueId()) < System.currentTimeMillis() - errorTimeMargin;
+    }
+
+    @Override
+    protected @NotNull List<Listener> listeners() {
+        return List.of(
+            new InventoryTrackerListener(),
+            new InInventoryMoveListener()
+        );
+    }
+}

common/src/main/java/eu/mhsl/craftattack/spawn/common/appliances/security/antiInventoryMove/InInventoryMoveListener.java

@@ -0,0 +1,21 @@
+package eu.mhsl.craftattack.spawn.common.appliances.security.antiInventoryMove;
+
+import eu.mhsl.craftattack.spawn.common.appliances.tooling.acInform.AcInform;
+import eu.mhsl.craftattack.spawn.core.Main;
+import eu.mhsl.craftattack.spawn.core.appliance.ApplianceListener;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.player.PlayerInputEvent;
+
+class InInventoryMoveListener extends ApplianceListener<AntiInventoryMove> {
+    @EventHandler
+    public void onInput(PlayerInputEvent event) {
+        if(!this.getAppliance().hasInventoryOpen(event.getPlayer())) return;
+        Main.instance().getAppliance(AcInform.class).slowedNotifyAdmins(
+            "internal",
+            event.getPlayer().getName(),
+            "inInventoryMove",
+            -1f,
+            3000
+        );
+    }
+}

common/src/main/java/eu/mhsl/craftattack/spawn/common/appliances/security/antiInventoryMove/InventoryTrackerListener.java

@@ -0,0 +1,23 @@
+package eu.mhsl.craftattack.spawn.common.appliances.security.antiInventoryMove;
+
+import eu.mhsl.craftattack.spawn.core.appliance.ApplianceListener;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.inventory.InventoryCloseEvent;
+import org.bukkit.event.inventory.InventoryOpenEvent;
+
+class InventoryTrackerListener extends ApplianceListener<AntiInventoryMove> {
+    @EventHandler(priority = EventPriority.MONITOR)
+    public void onOpen(InventoryOpenEvent event) {
+        if(!(event.getPlayer() instanceof Player player)) return;
+        if(event.isCancelled()) return;
+        this.getAppliance().setInvOpen(player, true);
+    }
+
+    @EventHandler
+    public void onClose(InventoryCloseEvent event) {
+        if(!(event.getPlayer() instanceof Player player)) return;
+        this.getAppliance().setInvOpen(player, false);
+    }
+}

common/src/main/java/eu/mhsl/craftattack/spawn/common/appliances/tooling/acInform/AcInform.java

@@ -11,14 +11,20 @@ import org.bukkit.Bukkit;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
+import java.util.HashMap;
 import java.util.List;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
 
 public class AcInform extends Appliance {
+    private final Map<String, Map<String, Long>> violationSlowdowns = new ConcurrentHashMap<>();
+
     public void processCommand(@NotNull String[] args) {
         String anticheatName = null;
         String playerName = null;
         String checkName = null;
         Float violationCount = null;
+        int notifyEvery = 0;
 
         for(int i = 0; i < args.length; i++) {
             if(!args[i].startsWith("--")) continue;
@@ -36,13 +42,32 @@ public class AcInform extends Appliance {
                 case "--playerName" -> playerName = value;
                 case "--check" -> checkName = value;
                 case "--violationCount" -> violationCount = value.isEmpty() ? null : Float.valueOf(value);
+                case "--notifyEvery" -> notifyEvery = Integer.parseInt(value);
             }
         }
 
+        if(notifyEvery == 0) {
+            this.notifyAdmins(anticheatName, playerName, checkName, violationCount);
+        } else {
+            this.slowedNotifyAdmins(anticheatName, playerName, checkName, violationCount, notifyEvery);
+        }
+    }
+
+    public void slowedNotifyAdmins(@Nullable String anticheatName, @Nullable String playerName, @Nullable String checkName, @Nullable Float violationCount, int notifyEvery) {
+        this.violationSlowdowns.putIfAbsent(playerName, new HashMap<>());
+
+        var slowdowns = this.violationSlowdowns.get(playerName);
+        if(slowdowns.containsKey(checkName)) {
+            if(slowdowns.get(checkName) > System.currentTimeMillis() - notifyEvery) return;
+        }
+
         this.notifyAdmins(anticheatName, playerName, checkName, violationCount);
     }
 
     public void notifyAdmins(@Nullable String anticheatName, @Nullable String playerName, @Nullable String checkName, @Nullable Float violationCount) {
+        this.violationSlowdowns.putIfAbsent(playerName, new HashMap<>());
+        this.violationSlowdowns.get(playerName).put(checkName, System.currentTimeMillis());
+
         ComponentBuilder<TextComponent, TextComponent.Builder> component = Component.text();
         NamedTextColor textColor = NamedTextColor.GRAY;
 
@@ -85,28 +110,42 @@ public class AcInform extends Appliance {
             Component.newline()
                 .append(Component.text("⊥ ", NamedTextColor.GRAY))
                 .append(Component.text("[", NamedTextColor.GRAY))
-                .append(Component.text("Report", NamedTextColor.GOLD))
+                .append(Component.text("\uD83D\uDCD6", NamedTextColor.GOLD))
                 .append(Component.text("]", NamedTextColor.GRAY))
                 .clickEvent(ClickEvent.suggestCommand(String.format("/report %s anticheat %s flagged %s", playerName, anticheatName, checkName)))
         );
 
         component.append(
             Component.text(" [", NamedTextColor.GRAY)
-                .append(Component.text("Kick", NamedTextColor.GOLD))
+                .append(Component.text("\u23F1", NamedTextColor.GOLD))
                 .append(Component.text("]", NamedTextColor.GRAY))
                 .clickEvent(ClickEvent.suggestCommand(String.format("/kick %s", playerName)))
         );
 
         component.append(
             Component.text(" [", NamedTextColor.GRAY)
-                .append(Component.text("Panic Ban", NamedTextColor.GOLD))
+                .append(Component.text("\uD83E\uDDB6", NamedTextColor.GOLD))
+                .append(Component.text("]", NamedTextColor.GRAY))
+                .clickEvent(ClickEvent.suggestCommand(String.format("/kickunsuspected %s", playerName)))
+        );
+
+        component.append(
+            Component.text(" [", NamedTextColor.GRAY)
+                .append(Component.text("\u2623", NamedTextColor.GOLD))
+                .append(Component.text("]", NamedTextColor.GRAY))
+                .clickEvent(ClickEvent.suggestCommand(String.format("/kickcrash %s", playerName)))
+        );
+
+        component.append(
+            Component.text(" [", NamedTextColor.GRAY)
+                .append(Component.text("\uD83D\uDD12", NamedTextColor.GOLD))
                 .append(Component.text("]", NamedTextColor.GRAY))
                 .clickEvent(ClickEvent.suggestCommand(String.format("/panicban %s", playerName)))
         );
 
         component.append(
             Component.text(" [", NamedTextColor.GRAY)
-                .append(Component.text("Spectate/Teleport", NamedTextColor.GOLD))
+                .append(Component.text("\uD83D\uDC41", NamedTextColor.GOLD))
                 .append(Component.text("]", NamedTextColor.GRAY))
                 .clickEvent(ClickEvent.suggestCommand(String.format("/grim spectate %s", playerName)))
         );

common/src/main/java/eu/mhsl/craftattack/spawn/common/appliances/tooling/kick/Kick.java

@@ -1,9 +1,14 @@
 package eu.mhsl.craftattack.spawn.common.appliances.tooling.kick;
 
+import eu.mhsl.craftattack.spawn.core.Main;
 import eu.mhsl.craftattack.spawn.core.appliance.Appliance;
 import eu.mhsl.craftattack.spawn.core.appliance.ApplianceCommand;
+import eu.mhsl.craftattack.spawn.core.util.entity.PlayerUtils;
 import eu.mhsl.craftattack.spawn.core.util.text.DisconnectInfo;
+import net.kyori.adventure.text.Component;
+import net.kyori.adventure.util.Ticks;
 import org.bukkit.Bukkit;
+import org.bukkit.Material;
 import org.bukkit.entity.Player;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
@@ -25,9 +30,36 @@ public class Kick extends Appliance {
         ).applyKick(player);
     }
 
+    public void unsuspectedKick(@NotNull String playerName) {
+        Player player = Bukkit.getPlayer(playerName);
+
+        if(player == null)
+            throw new ApplianceCommand.Error("Player not found");
+
+        String material = Material.values()[(int)(Math.random() * Material.values().length)].name();
+        player.kick(Component.text("java.lang.IllegalStateException: Failed to create model for minecraft:%s".formatted(material)));
+    }
+
+    public void crashKick(@NotNull String playerName) {
+        Player player = Bukkit.getPlayer(playerName);
+
+        if(player == null)
+            throw new ApplianceCommand.Error("Player not found");
+
+        Bukkit.getScheduler().runTaskAsynchronously(Main.instance(), () -> {
+            PlayerUtils.sendCube(player, 100, Material.ENCHANTING_TABLE.createBlockData());
+            PlayerUtils.sendCube(player, 5, Material.DIRT.createBlockData());
+        });
+        Bukkit.getScheduler().runTaskLater(Main.instance(), () -> player.kick(Component.empty()), Ticks.TICKS_PER_SECOND * 15);
+    }
+
     @Override
     @NotNull
     protected List<ApplianceCommand<?>> commands() {
-        return List.of(new KickCommand());
+        return List.of(
+            new KickCommand(),
+            new KickUnsuspectedCommand(),
+            new KickCrashCommand()
+        );
     }
 }

common/src/main/java/eu/mhsl/craftattack/spawn/common/appliances/tooling/kick/KickCrashCommand.java

@@ -0,0 +1,31 @@
+package eu.mhsl.craftattack.spawn.common.appliances.tooling.kick;
+
+import eu.mhsl.craftattack.spawn.core.appliance.ApplianceCommand;
+import org.bukkit.Bukkit;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.List;
+
+public class KickCrashCommand extends ApplianceCommand<Kick> {
+    public KickCrashCommand() {
+        super("kickCrash");
+    }
+
+    @Override
+    protected void execute(@NotNull CommandSender sender, @NotNull Command command, @NotNull String label, @NotNull String[] args) throws Exception {
+        if(args.length < 1) throw new Error("Es muss ein Spielername angegeben werden!");
+        this.getAppliance().crashKick(args[0]);
+    }
+
+    @Override
+    public @Nullable List<String> onTabComplete(@NotNull CommandSender sender, @NotNull Command command, @NotNull String label, @NotNull String[] args) {
+        return super.tabCompleteReducer(
+            Bukkit.getOnlinePlayers().stream().map(Player::getName).toList(),
+            args
+        );
+    }
+}

common/src/main/java/eu/mhsl/craftattack/spawn/common/appliances/tooling/kick/KickUnsuspectedCommand.java

@@ -0,0 +1,31 @@
+package eu.mhsl.craftattack.spawn.common.appliances.tooling.kick;
+
+import eu.mhsl.craftattack.spawn.core.appliance.ApplianceCommand;
+import org.bukkit.Bukkit;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.List;
+
+public class KickUnsuspectedCommand extends ApplianceCommand<Kick> {
+    public KickUnsuspectedCommand() {
+        super("kickUnsuspected");
+    }
+
+    @Override
+    protected void execute(@NotNull CommandSender sender, @NotNull Command command, @NotNull String label, @NotNull String[] args) throws Exception {
+        if(args.length < 1) throw new Error("Es muss ein Spielername angegeben werden!");
+        this.getAppliance().unsuspectedKick(args[0]);
+    }
+
+    @Override
+    public @Nullable List<String> onTabComplete(@NotNull CommandSender sender, @NotNull Command command, @NotNull String label, @NotNull String[] args) {
+        return super.tabCompleteReducer(
+            Bukkit.getOnlinePlayers().stream().map(Player::getName).toList(),
+            args
+        );
+    }
+}

core/src/main/java/eu/mhsl/craftattack/spawn/core/api/server/hooks/impl/WebsiteHook.java

@@ -28,14 +28,16 @@ public class WebsiteHook extends HttpHook {
             return HttpServer.nothing;
         }));
 
-        record CreatedReport(String reporter, String reported, String reason) {}
+        record CreatedReport(UUID reporter, UUID reported, String reason) {}
         this.addAction("report", new JsonAction<>(CreatedReport.class, createdReport -> {
+            Main.logger().info(String.format("New Report from Hook: (%s) Reporter: %s Reported: %s", createdReport.reason, createdReport.reporter, createdReport.reported));
             SpawnEvent.call(new ReportCreatedEvent(new ReportCreatedEvent.CreatedReport(createdReport.reporter, createdReport.reported, createdReport.reason)));
             return HttpServer.nothing;
         }));
 
         record CreatedStrike(UUID uuid) {}
         this.addAction("strike", new JsonAction<>(CreatedStrike.class, createdStrike -> {
+            Main.logger().info(String.format("New Strike from Hook! (User %s)", createdStrike.uuid));
             SpawnEvent.call(new StrikeCreatedEvent(new StrikeCreatedEvent.CreatedStrike(createdStrike.uuid)));
             return HttpServer.nothing;
         }));

core/src/main/java/eu/mhsl/craftattack/spawn/core/event/ReportCreatedEvent.java

@@ -4,6 +4,8 @@ import org.bukkit.event.Event;
 import org.bukkit.event.HandlerList;
 import org.jetbrains.annotations.NotNull;
 
+import java.util.UUID;
+
 public class ReportCreatedEvent extends Event {
     private static final HandlerList HANDLERS = new HandlerList();
     @Override
@@ -15,7 +17,7 @@ public class ReportCreatedEvent extends Event {
         return HANDLERS;
     }
 
-    public record CreatedReport(String reporter, String reported, String reason) {}
+    public record CreatedReport(UUID reporter, UUID reported, String reason) {}
 
     private final CreatedReport report;
     public ReportCreatedEvent(CreatedReport report) {

core/src/main/java/eu/mhsl/craftattack/spawn/core/util/entity/PlayerUtils.java

@@ -1,10 +1,16 @@
 package eu.mhsl.craftattack.spawn.core.util.entity;
 
+import org.bukkit.Location;
 import org.bukkit.Material;
 import org.bukkit.Statistic;
+import org.bukkit.World;
+import org.bukkit.block.data.BlockData;
 import org.bukkit.entity.EntityType;
 import org.bukkit.entity.Player;
 
+import java.util.HashMap;
+import java.util.Map;
+
 public class PlayerUtils {
     public static void resetStatistics(Player player) {
         for(Statistic statistic : Statistic.values()) {
@@ -30,4 +36,30 @@ public class PlayerUtils {
             }
         }
     }
+
+    public static void sendCube(Player player, int cubeSize, BlockData fakeBlock) {
+        Location loc = player.getLocation();
+        World world = player.getWorld();
+
+        int half = cubeSize / 2;
+        int cx = loc.getBlockX();
+        int cy = loc.getBlockY();
+        int cz = loc.getBlockZ();
+
+        int minY = world.getMinHeight();
+        int maxY = world.getMaxHeight() - 1;
+
+        Map<Location, BlockData> changes = new HashMap<>();
+
+        for (int x = cx - half; x <= cx + half; x++) {
+            for (int y = Math.max(cy - half, minY); y <= Math.min(cy + half, maxY); y++) {
+                for (int z = cz - half; z <= cz + half; z++) {
+                    changes.put(new Location(world, x, y, z), fakeBlock);
+                }
+            }
+        }
+
+        //noinspection UnstableApiUsage
+        player.sendMultiBlockChange(changes);
+    }
 }

craftattack/src/main/java/eu/mhsl/craftattack/spawn/craftattack/appliances/gameplay/bloodmoon/Bloodmoon.java

@@ -0,0 +1,282 @@
+package eu.mhsl.craftattack.spawn.craftattack.appliances.gameplay.bloodmoon;
+
+import eu.mhsl.craftattack.spawn.common.appliances.metaGameplay.settings.Settings;
+import eu.mhsl.craftattack.spawn.core.Main;
+import eu.mhsl.craftattack.spawn.core.appliance.Appliance;
+import eu.mhsl.craftattack.spawn.core.appliance.ApplianceCommand;
+import eu.mhsl.craftattack.spawn.craftattack.appliances.gameplay.bloodmoon.commands.BloodmoonCommand;
+import eu.mhsl.craftattack.spawn.craftattack.appliances.gameplay.bloodmoon.listener.BloodmoonEntityDamageListener;
+import eu.mhsl.craftattack.spawn.craftattack.appliances.gameplay.bloodmoon.listener.BloodmoonMonsterDeathListener;
+import eu.mhsl.craftattack.spawn.craftattack.appliances.gameplay.bloodmoon.listener.BloodmoonPlayerJoinListener;
+import eu.mhsl.craftattack.spawn.craftattack.appliances.gameplay.bloodmoon.listener.BloodmoonTimeListener;
+import net.kyori.adventure.bossbar.BossBar;
+import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.format.NamedTextColor;
+import net.kyori.adventure.text.format.TextDecoration;
+import net.kyori.adventure.util.Ticks;
+import org.bukkit.Bukkit;
+import org.bukkit.GameMode;
+import org.bukkit.Location;
+import org.bukkit.Material;
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.EntityType;
+import org.bukkit.entity.Player;
+import org.bukkit.event.Listener;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.potion.PotionEffectType;
+import org.bukkit.scheduler.BukkitTask;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.*;
+import java.util.concurrent.ThreadLocalRandom;
+
+@SuppressWarnings("FieldCanBeLocal")
+public class Bloodmoon extends Appliance {
+    public final Map<EntityType, Set<MobEffect>> affectedMobEffectMap = Map.ofEntries(
+        Map.entry(EntityType.ZOMBIE, Set.of(
+            new MobEffect.PotionMobEffect(PotionEffectType.WITHER, 7, 1)
+        )),
+        Map.entry(EntityType.SKELETON, Set.of(
+            new MobEffect.PotionMobEffect(PotionEffectType.SLOWNESS, 3.5, 1)
+        )),
+        Map.entry(EntityType.SPIDER, Set.of(
+            new MobEffect.PotionMobEffect(PotionEffectType.POISON, 4, 1),
+            new MobEffect.PotionMobEffect(PotionEffectType.NAUSEA, 6, 10)
+        )),
+        Map.entry(EntityType.CREEPER, Set.of(
+            new MobEffect.LightningMobEffect()
+        )),
+        Map.entry(EntityType.HUSK, Set.of(
+            new MobEffect.PotionMobEffect(PotionEffectType.WITHER, 7, 1)
+        )),
+        Map.entry(EntityType.STRAY, Set.of()),
+        Map.entry(EntityType.DROWNED, Set.of(
+            new MobEffect.PotionMobEffect(PotionEffectType.WITHER, 7, 1)
+        )),
+        Map.entry(EntityType.WITCH, Set.of()),
+        Map.entry(EntityType.ZOMBIE_VILLAGER, Set.of(
+            new MobEffect.PotionMobEffect(PotionEffectType.WITHER, 7, 1)
+        )),
+        Map.entry(EntityType.PHANTOM, Set.of(
+            new MobEffect.PotionMobEffect(PotionEffectType.LEVITATION, 1.5, 3)
+        )),
+        Map.entry(EntityType.ENDERMAN, Set.of(
+            new MobEffect.PotionMobEffect(PotionEffectType.SLOWNESS, 2.5, 2)
+        ))
+    );
+    public final int expMultiplier = 3;
+    public final double mobDamageMultiplier = 2;
+    public final double mobHealthMultiplier = 2;
+
+    private final ThreadLocalRandom random = ThreadLocalRandom.current();
+    private boolean isActive = false;
+    private final BossBar bossBar = BossBar.bossBar(
+        Component.text("Blutmond", NamedTextColor.DARK_RED),
+        1f,
+        BossBar.Color.RED,
+        BossBar.Overlay.NOTCHED_12,
+        Set.of(BossBar.Flag.CREATE_WORLD_FOG, BossBar.Flag.DARKEN_SCREEN)
+    );
+    private final boolean hordesEnabled = true;
+    private final int hordeSpawnRateTicks = 40 * Ticks.TICKS_PER_SECOND;
+    private final int hordeSpawnRateVariationTicks = 40 * Ticks.TICKS_PER_SECOND;
+    private final int hordeMinPopulation = 3;
+    private final int hordeMaxPopulation = 10;
+    private final int hordeSpawnDistance = 10;
+    private final List<EntityType> hordeMobList = List.of(
+        EntityType.ZOMBIE,
+        EntityType.SKELETON,
+        EntityType.SPIDER
+    );
+    private final Map<Player, @Nullable BukkitTask> hordeSpawnTasks = new WeakHashMap<>();
+    private long lastBloodmoonStartTick = 0;
+    public final int ticksPerDay = 24000;
+    public final int bloodmoonLength = ticksPerDay/2;
+    public final int preStartMessageTicks = Ticks.TICKS_PER_SECOND * 50;
+    private final int bloodmoonFreeDaysAtStart = 3;
+    private final int bloodmoonStartTime = ticksPerDay/2;
+    private final int bloodmoonDayInterval = 30;
+    private final int minBonusDrops = 1;
+    private final int maxBonusDrops = 4;
+    private final Map<ItemStack, Integer> bonusDropWeightMap = Map.of(
+        new ItemStack(Material.IRON_INGOT, 5), 10,
+        new ItemStack(Material.GOLD_INGOT, 2), 5,
+        new ItemStack(Material.DIAMOND, 1), 1,
+        new ItemStack(Material.IRON_BLOCK, 1), 5,
+        new ItemStack(Material.GOLD_BLOCK, 1), 2
+    );
+
+    @Override
+    public void onEnable() {
+        Settings.instance().declareSetting(BloodmoonSetting.class);
+    }
+
+    public boolean bloodmoonIsActive() {
+        return this.isActive;
+    }
+
+    public void startBloodmoon(long startTick) {
+        this.lastBloodmoonStartTick = startTick;
+        this.isActive = true;
+        Bukkit.getOnlinePlayers().forEach(this::addPlayerToBossBar);
+        this.startHordeSpawning(this.getRandomHordeSpawnDelay());
+        this.sendStartMessages();
+    }
+
+    public void stopBloodmoon() {
+        this.isActive = false;
+        Bukkit.getOnlinePlayers().forEach(player -> player.hideBossBar(this.bossBar));
+        this.sendStopMessages();
+    }
+
+    public void updateBossBar() {
+        long tick = Bukkit.getWorlds().getFirst().getFullTime();
+        long sinceStart = tick - this.lastBloodmoonStartTick;
+        float progress = 1f - ((float) sinceStart / this.bloodmoonLength);
+        if(progress < 0) progress = 1f;
+        this.bossBar.progress(progress);
+    }
+
+    public boolean isStartTick(long tick) {
+        long day = tick / this.ticksPerDay;
+        if(day % this.bloodmoonDayInterval != 0 || day - this.bloodmoonFreeDaysAtStart <= 0) return false;
+        long time = tick - (day * this.ticksPerDay);
+        return time == this.bloodmoonStartTime;
+    }
+
+    private int getRandomHordeSpawnDelay() {
+        return this.hordeSpawnRateTicks + this.random.nextInt(this.hordeSpawnRateVariationTicks);
+    }
+
+    private void startHordeSpawning(int delay) {
+        Bukkit.getOnlinePlayers().forEach(player -> this.startHordeSpawning(delay, player));
+    }
+
+    private void startHordeSpawning(int delay, Player player) {
+        @Nullable BukkitTask task = this.hordeSpawnTasks.get(player);
+        if(task != null) task.cancel();
+        BukkitTask newTask = Bukkit.getScheduler().runTaskLater(
+                Main.instance(),
+                () -> {
+                    if(!this.bloodmoonIsActive()) return;
+                    this.spawnRandomHorde(player);
+                    this.startHordeSpawning(this.getRandomHordeSpawnDelay(), player);
+                },
+                delay
+        );
+        this.hordeSpawnTasks.put(player, newTask);
+    }
+
+    public void addPlayerToBossBar(Player player) {
+        if(!this.getBloodmoonSetting(player)) return;
+        player.showBossBar(this.bossBar);
+    }
+
+    public boolean isAffectedMob(Entity entity) {
+        return this.affectedMobEffectMap.containsKey(entity.getType());
+    }
+
+    public boolean getBloodmoonSetting(Player player) {
+        return Settings.instance().getSetting(
+            player,
+            Settings.Key.Bloodmoon,
+            Boolean.class
+        );
+    }
+
+    public void spawnRandomHorde(Player player) {
+        if(!this.hordesEnabled) return;
+        if(!player.getGameMode().equals(GameMode.SURVIVAL)) return;
+
+        EntityType hordeEntityType = this.hordeMobList.get(this.random.nextInt(this.hordeMobList.size()));
+        int hordeSize = this.random.nextInt(this.hordeMinPopulation, this.hordeMaxPopulation + 1);
+        this.spawnHorde(player, hordeSize, hordeEntityType);
+    }
+
+    public void sendWarningMessage(Player p) {
+        p.sendMessage(Component.text("Der Blutmond waltet in diesem Augenblick!", NamedTextColor.RED));
+    }
+
+    public void sendAnnouncementMessages() {
+        this.sendMessage(Component.text("Der Blutmond naht; morgen wird er den Himmel beherrschen", NamedTextColor.GOLD));
+    }
+
+    public void sendPreStartMessages() {
+        this.sendMessage(Component.text("Der Himmel ist heute Nacht ungewöhnlich düster", NamedTextColor.DARK_PURPLE));
+    }
+
+    private void spawnHorde(Player player, int size, EntityType type) {
+        for(int i = 0; i < size; i++) {
+            double spawnRadiant = this.random.nextDouble(0, 2*Math.PI);
+            Location mobSpawnLocation = player.getLocation().add(
+                Math.sin(spawnRadiant)*this.hordeSpawnDistance,
+                0,
+                Math.cos(spawnRadiant)*this.hordeSpawnDistance
+            );
+            mobSpawnLocation.setY(player.getWorld().getHighestBlockYAt(mobSpawnLocation) + 1);
+            player.getWorld().spawnEntity(mobSpawnLocation, type);
+            player.getWorld().strikeLightningEffect(mobSpawnLocation);
+        }
+    }
+
+    public List<ItemStack> getRandomBonusDrops() {
+        int itemCount = this.random.nextInt(this.minBonusDrops, this.maxBonusDrops + 1);
+        List<ItemStack> result = new ArrayList<>();
+        for(int i = 0; i < itemCount; i++) {
+            result.add(this.getRandomBonusDrop());
+        }
+        return result;
+    }
+
+    private @Nullable ItemStack getRandomBonusDrop() {
+        int totalWeight = this.bonusDropWeightMap.values().stream().mapToInt(value -> value).sum();
+        int randomInt = this.random.nextInt(0, totalWeight + 1);
+        int cumulativeWeight = 0;
+        for(Map.Entry<ItemStack, Integer> entry : this.bonusDropWeightMap.entrySet()) {
+            cumulativeWeight += entry.getValue();
+            if(randomInt <= cumulativeWeight) return entry.getKey();
+        }
+        return null;
+    }
+
+    private void sendMessage(Component message) {
+        if(Bukkit.getOnlinePlayers().isEmpty()) return;
+        List<? extends Player> onlinePlayers = Bukkit.getOnlinePlayers().stream()
+            .filter(this::getBloodmoonSetting)
+            .toList();
+        onlinePlayers.forEach(player -> player.sendMessage(message));
+    }
+
+    private void sendStartMessages() {
+        this.sendMessage(
+            Component.empty()
+                .append(Component.text("Der Blutmond ist über uns", NamedTextColor.DARK_RED, TextDecoration.BOLD))
+                .appendNewline()
+                .append(Component.text("Erfahrung vervielfacht sich und Mobs lassen reichere Beute fallen", NamedTextColor.RED))
+                .appendNewline()
+                .append(Component.text("Mobs sind erstarkt und belegen dich mit finsteren Debuffs", NamedTextColor.RED))
+        );
+    }
+
+    private void sendStopMessages() {
+        this.sendMessage(Component.text("Der Blutmond weicht...", NamedTextColor.GREEN, TextDecoration.BOLD));
+    }
+
+    @Override
+    protected @NotNull List<Listener> listeners() {
+        return List.of(
+            new BloodmoonMonsterDeathListener(),
+            new BloodmoonPlayerJoinListener(),
+            new BloodmoonEntityDamageListener(),
+            new BloodmoonTimeListener()
+        );
+    }
+
+    @Override
+    protected @NotNull List<ApplianceCommand<?>> commands() {
+        return List.of(
+            new BloodmoonCommand()
+        );
+    }
+}

craftattack/src/main/java/eu/mhsl/craftattack/spawn/craftattack/appliances/gameplay/bloodmoon/BloodmoonSetting.java

@@ -0,0 +1,56 @@
+package eu.mhsl.craftattack.spawn.craftattack.appliances.gameplay.bloodmoon;
+
+import eu.mhsl.craftattack.spawn.common.appliances.metaGameplay.settings.CategorizedSetting;
+import eu.mhsl.craftattack.spawn.common.appliances.metaGameplay.settings.SettingCategory;
+import eu.mhsl.craftattack.spawn.common.appliances.metaGameplay.settings.Settings;
+import eu.mhsl.craftattack.spawn.common.appliances.metaGameplay.settings.datatypes.BoolSetting;
+import eu.mhsl.craftattack.spawn.core.Main;
+import eu.mhsl.craftattack.spawn.core.util.world.InteractSounds;
+import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.format.NamedTextColor;
+import org.bukkit.Material;
+import org.bukkit.entity.Player;
+import org.bukkit.event.inventory.ClickType;
+
+public class BloodmoonSetting extends BoolSetting implements CategorizedSetting {
+    public BloodmoonSetting() {
+        super(Settings.Key.Bloodmoon);
+    }
+
+    @Override
+    public SettingCategory category() {
+        return SettingCategory.Gameplay;
+    }
+
+    @Override
+    protected String title() {
+        return "Blutmond";
+    }
+
+    @Override
+    protected String description() {
+        return "Kämpfe während dem Blutmond gegen stärkere Monster mit besseren Drops. Kann nicht während dem Blutmond geändert werden!";
+    }
+
+    @Override
+    protected Material icon() {
+        return Material.SKELETON_SKULL;
+    }
+
+    @Override
+    protected Boolean defaultValue() {
+        return true;
+    }
+
+    // TODO: Settings deaktivierbar machen
+
+    @Override
+    protected void change(Player player, ClickType clickType) {
+        if(Main.instance().getAppliance(Bloodmoon.class).bloodmoonIsActive()) {
+            InteractSounds.of(player).delete();
+            player.sendMessage(Component.text("Während dem Blutmond kann diese Einstellung nicht geändert werden!", NamedTextColor.RED));
+            return;
+        }
+        super.change(player, clickType);
+    }
+}

craftattack/src/main/java/eu/mhsl/craftattack/spawn/craftattack/appliances/gameplay/bloodmoon/MobEffect.java

@@ -0,0 +1,29 @@
+package eu.mhsl.craftattack.spawn.craftattack.appliances.gameplay.bloodmoon;
+
+import net.kyori.adventure.util.Ticks;
+import org.bukkit.entity.Player;
+import org.bukkit.potion.PotionEffect;
+import org.bukkit.potion.PotionEffectType;
+
+public abstract class MobEffect {
+    public abstract void apply(Player p);
+
+    public static class PotionMobEffect extends MobEffect {
+        private final PotionEffect effect;
+        public PotionMobEffect(PotionEffectType type, double seconds, int amplifier) {
+            this.effect = new PotionEffect(type, (int) (seconds * Ticks.TICKS_PER_SECOND), amplifier);
+        }
+
+        @Override
+        public void apply(Player p) {
+            p.addPotionEffect(this.effect);
+        }
+    }
+
+    public static class LightningMobEffect extends MobEffect {
+        @Override
+        public void apply(Player p) {
+            p.getWorld().strikeLightning(p.getLocation());
+        }
+    }
+}

craftattack/src/main/java/eu/mhsl/craftattack/spawn/craftattack/appliances/gameplay/bloodmoon/commands/BloodmoonCommand.java

@@ -0,0 +1,44 @@
+package eu.mhsl.craftattack.spawn.craftattack.appliances.gameplay.bloodmoon.commands;
+
+import eu.mhsl.craftattack.spawn.core.appliance.ApplianceCommand;
+import eu.mhsl.craftattack.spawn.craftattack.appliances.gameplay.bloodmoon.Bloodmoon;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.List;
+
+public class BloodmoonCommand extends ApplianceCommand<Bloodmoon> {
+    public BloodmoonCommand() {
+        super("bloodmoon");
+    }
+
+    @Override
+    protected void execute(@NotNull CommandSender sender, @NotNull Command command, @NotNull String label, @NotNull String[] args) throws Exception {
+        if(args.length == 0) {
+            sender.sendMessage("Bloodmoon is currently %s.".formatted(this.getAppliance().bloodmoonIsActive() ? "active" : "inactive"));
+            return;
+        }
+
+        switch(args[0]) {
+            case "start": {
+                this.getAppliance().startBloodmoon(0L);
+                sender.sendMessage("Started bloodmoon.");
+                break;
+            }
+            case "stop": {
+                this.getAppliance().stopBloodmoon();
+                sender.sendMessage("Stopped bloodmoon.");
+                break;
+            }
+            default: throw new Error("No such option: '%s' !".formatted(args[0]));
+        }
+    }
+
+    @Override
+    public @Nullable List<String> onTabComplete(@NotNull CommandSender sender, @NotNull Command command, @NotNull String label, @NotNull String[] args) {
+        if(args.length == 1) return List.of("start", "stop");
+        return null;
+    }
+}

craftattack/src/main/java/eu/mhsl/craftattack/spawn/craftattack/appliances/gameplay/bloodmoon/listener/BloodmoonEntityDamageListener.java

@@ -0,0 +1,35 @@
+package eu.mhsl.craftattack.spawn.craftattack.appliances.gameplay.bloodmoon.listener;
+
+import eu.mhsl.craftattack.spawn.core.appliance.ApplianceListener;
+import eu.mhsl.craftattack.spawn.craftattack.appliances.gameplay.bloodmoon.Bloodmoon;
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.LivingEntity;
+import org.bukkit.entity.Player;
+import org.bukkit.entity.Projectile;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.entity.EntityDamageByEntityEvent;
+
+public class BloodmoonEntityDamageListener extends ApplianceListener<Bloodmoon> {
+    @EventHandler
+    public void onEntityDamage(EntityDamageByEntityEvent event) {
+        if(!this.getAppliance().bloodmoonIsActive()) return;
+        Entity damagerEntity = event.getDamager();
+        if(damagerEntity instanceof Projectile projectile) {
+            if(!(projectile.getShooter() instanceof Entity shooter)) return;
+            damagerEntity = shooter;
+        }
+        if(!(damagerEntity instanceof LivingEntity damager && event.getEntity() instanceof LivingEntity receiver)) return;
+        if(event.getFinalDamage() == 0) return;
+
+        if(this.getAppliance().isAffectedMob(damager) && receiver instanceof Player player) {
+            if(!this.getAppliance().getBloodmoonSetting(player)) return;
+            event.setDamage(event.getDamage() * this.getAppliance().mobDamageMultiplier);
+            this.getAppliance().affectedMobEffectMap.get(damager.getType()).forEach(mobEffect -> mobEffect.apply(player));
+            return;
+        }
+        if(this.getAppliance().isAffectedMob(receiver) && damager instanceof Player player) {
+            if(!this.getAppliance().getBloodmoonSetting(player)) return;
+            event.setDamage(event.getDamage() / this.getAppliance().mobHealthMultiplier);
+        }
+    }
+}

craftattack/src/main/java/eu/mhsl/craftattack/spawn/craftattack/appliances/gameplay/bloodmoon/listener/BloodmoonMonsterDeathListener.java

@@ -0,0 +1,23 @@
+package eu.mhsl.craftattack.spawn.craftattack.appliances.gameplay.bloodmoon.listener;
+
+import eu.mhsl.craftattack.spawn.core.appliance.ApplianceListener;
+import eu.mhsl.craftattack.spawn.craftattack.appliances.gameplay.bloodmoon.Bloodmoon;
+import org.bukkit.entity.LivingEntity;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.entity.EntityDeathEvent;
+
+public class BloodmoonMonsterDeathListener extends ApplianceListener<Bloodmoon> {
+    @EventHandler
+    public void onMonsterDeath(EntityDeathEvent event) {
+        if(!this.getAppliance().bloodmoonIsActive()) return;
+        if(!(event.getDamageSource().getCausingEntity() instanceof Player player)) return;
+        if(!this.getAppliance().getBloodmoonSetting(player)) return;
+        LivingEntity entity = event.getEntity();
+        if(!this.getAppliance().isAffectedMob(entity)) return;
+
+        event.setDroppedExp(event.getDroppedExp() * this.getAppliance().expMultiplier);
+        event.getDrops().addAll(this.getAppliance().getRandomBonusDrops());
+        entity.getWorld().strikeLightningEffect(entity.getLocation());
+    }
+}

craftattack/src/main/java/eu/mhsl/craftattack/spawn/craftattack/appliances/gameplay/bloodmoon/listener/BloodmoonPlayerJoinListener.java

@@ -0,0 +1,15 @@
+package eu.mhsl.craftattack.spawn.craftattack.appliances.gameplay.bloodmoon.listener;
+
+import eu.mhsl.craftattack.spawn.core.appliance.ApplianceListener;
+import eu.mhsl.craftattack.spawn.craftattack.appliances.gameplay.bloodmoon.Bloodmoon;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.player.PlayerJoinEvent;
+
+public class BloodmoonPlayerJoinListener extends ApplianceListener<Bloodmoon> {
+    @EventHandler
+    public void onPlayerJoin(PlayerJoinEvent event) {
+        if(!this.getAppliance().bloodmoonIsActive()) return;
+        this.getAppliance().addPlayerToBossBar(event.getPlayer());
+        this.getAppliance().sendWarningMessage(event.getPlayer());
+    }
+}

craftattack/src/main/java/eu/mhsl/craftattack/spawn/craftattack/appliances/gameplay/bloodmoon/listener/BloodmoonTimeListener.java

@@ -0,0 +1,31 @@
+package eu.mhsl.craftattack.spawn.craftattack.appliances.gameplay.bloodmoon.listener;
+
+import com.destroystokyo.paper.event.server.ServerTickStartEvent;
+import eu.mhsl.craftattack.spawn.core.appliance.ApplianceListener;
+import eu.mhsl.craftattack.spawn.craftattack.appliances.gameplay.bloodmoon.Bloodmoon;
+import net.kyori.adventure.util.Ticks;
+import org.bukkit.Bukkit;
+import org.bukkit.event.EventHandler;
+
+public class BloodmoonTimeListener extends ApplianceListener<Bloodmoon> {
+    @EventHandler
+    public void onServerTick(ServerTickStartEvent event) {
+        long currentTime = Bukkit.getWorlds().getFirst().getFullTime();
+        if(this.getAppliance().isStartTick(currentTime)) {
+            this.getAppliance().startBloodmoon(currentTime);
+            return;
+        }
+        if(this.getAppliance().isStartTick(currentTime - this.getAppliance().bloodmoonLength)) {
+            this.getAppliance().stopBloodmoon();
+            return;
+        }
+        if(currentTime % Ticks.TICKS_PER_SECOND == 0) this.getAppliance().updateBossBar();
+        if(this.getAppliance().isStartTick(currentTime + this.getAppliance().ticksPerDay)) {
+            this.getAppliance().sendAnnouncementMessages();
+            return;
+        }
+        if(this.getAppliance().isStartTick(currentTime + this.getAppliance().preStartMessageTicks)) {
+            this.getAppliance().sendPreStartMessages();
+        }
+    }
+}

craftattack/src/main/java/eu/mhsl/craftattack/spawn/craftattack/appliances/gameplay/outlawed/Outlawed.java

@@ -74,11 +74,11 @@ public class Outlawed extends Appliance implements DisplayName.Prefixed {
 
     void switchLawStatus(Player player) throws OutlawChangeNotPermitted {
         if(this.getLawStatus(player).equals(Status.FORCED)) {
-            throw new OutlawChangeNotPermitted("Dein Vogelfreistatus wurde als Strafe auferlegt und kann daher nicht verändert werden.");
+            throw new OutlawChangeNotPermitted("Dein PVP-Status wurde als Strafe auferlegt und kann daher nicht verändert werden.");
         }
 
         if(this.isTimeout(player)) {
-            throw new OutlawChangeNotPermitted("Du kannst deinen Vogelfreistatus nicht so schnell wechseln. Bitte warte einige Stunden bevor du umschaltest!");
+            throw new OutlawChangeNotPermitted("Du kannst deinen PVP-Status nicht so schnell wechseln. Bitte warte einige Stunden bevor du umschaltest!");
         }
 
         this.setLawStatus(player, this.isOutlawed(player) ? Status.DISABLED : Status.VOLUNTARILY);
@@ -126,13 +126,13 @@ public class Outlawed extends Appliance implements DisplayName.Prefixed {
 
     public Component getStatusDescription(Status status) {
         return switch(status) {
-            case DISABLED -> Component.text("Vogelfreistatus inaktiv: ", NamedTextColor.GREEN)
+            case DISABLED -> Component.text("PVP-Modus inaktiv: ", NamedTextColor.GREEN)
                 .append(Component.text("Es gelten die normalen Regeln!", NamedTextColor.GOLD));
 
-            case VOLUNTARILY, FORCED -> Component.text("Vogelfreistatus aktiv: ", NamedTextColor.RED)
+            case VOLUNTARILY, FORCED -> Component.text("PVP-Modus aktiv: ", NamedTextColor.RED)
                 .append(Component.text(
-                    "Du darfst von allen anderen vogelfreien Spielern angegriffen und getötet werden!" +
-                        "Wenn du getötet wirst, müssen andere Spieler deine Items nicht zurückerstatten!",
+                    "Du darfst von allen anderen PVP-Spielern angegriffen und getötet werden!\n" +
+                        "Wenn du getötet wirst, müssen andere Spieler deine Items *nicht* zurückerstatten!",
                     NamedTextColor.GOLD
                 ));
         };
@@ -143,7 +143,7 @@ public class Outlawed extends Appliance implements DisplayName.Prefixed {
         if(this.isOutlawed(player)) {
             return Component.text("[☠]", NamedTextColor.RED)
                 .hoverEvent(HoverEvent.showText(Component.text(
-                    "Vogelfreie Spieler dürfen von anderen vogelfreien Spielern ohne Grund angegriffen werden!"
+                    "PVP-Modus Spieler dürfen von anderen vogelfreien Spielern ohne Grund angegriffen werden!"
                 )));
         }
 

craftattack/src/main/java/eu/mhsl/craftattack/spawn/craftattack/appliances/gameplay/outlawed/OutlawedCommand.java

@@ -8,7 +8,7 @@ import org.bukkit.command.CommandSender;
 import org.jetbrains.annotations.NotNull;
 
 class OutlawedCommand extends ApplianceCommand.PlayerChecked<Outlawed> {
-    public static final String commandName = "vogelfrei";
+    public static final String commandName = "pvp";
 
     public OutlawedCommand() {
         super(commandName);

craftattack/src/main/java/eu/mhsl/craftattack/spawn/craftattack/appliances/metaGameplay/event/Event.java

@@ -2,6 +2,7 @@ package eu.mhsl.craftattack.spawn.craftattack.appliances.metaGameplay.event;
 
 import eu.mhsl.craftattack.spawn.core.Main;
 import eu.mhsl.craftattack.spawn.core.api.client.ReqResp;
+import eu.mhsl.craftattack.spawn.core.util.server.Floodgate;
 import eu.mhsl.craftattack.spawn.craftattack.api.repositories.EventRepository;
 import eu.mhsl.craftattack.spawn.core.api.server.HttpServer;
 import eu.mhsl.craftattack.spawn.core.appliance.Appliance;
@@ -26,6 +27,7 @@ import org.bukkit.entity.Villager;
 import org.bukkit.event.Listener;
 import org.bukkit.inventory.ItemStack;
 import org.bukkit.inventory.meta.ItemMeta;
+import org.geysermc.cumulus.form.SimpleForm;
 import org.jetbrains.annotations.NotNull;
 
 import java.util.*;
@@ -94,6 +96,10 @@ public class Event extends Appliance {
     }
 
     public void joinEvent(Player p) {
+        this.joinEvent(p, false);
+    }
+
+    public void joinEvent(Player p, boolean ignoreBedrock) {
         if(!this.isOpen) {
             p.sendMessage(Component.text("Zurzeit ist kein Event geöffnet.", NamedTextColor.RED));
             return;
@@ -109,6 +115,23 @@ public class Event extends Appliance {
             return;
         }
 
+        if(!ignoreBedrock && Floodgate.isBedrock(p)) {
+            Floodgate.getBedrockPlayer(p).sendForm(
+                SimpleForm.builder()
+                    .title("Achtung!")
+                    .content("Je nach deiner Minecraft-Bedrock-Version kann dein Minecraft in den Events abstürzen. " +
+                        "Ggf. ist also für dich ein Mitspielen auf der Bedrock-Edition nicht möglich.")
+                    .button("Ok, lass es uns versuchen")
+                    .button("Abbrechen")
+                    .validResultHandler(simpleFormResponse -> {
+                        if(simpleFormResponse.clickedButtonId() != 0) return;
+                        this.joinEvent(p, true);
+                    })
+                    .build()
+            );
+            return;
+        }
+
         Main.instance().getLogger().info("Verbinde mit eventserver: " + p.getName());
         p.sendMessage(Component.text("Authentifiziere...", NamedTextColor.GREEN));