added invincibility before event start, added join craftattack command, added player teleport, portal and pvp listeners to deathrun

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);
+                Main.instance().getAppliance(AcInform.class).slowedNotifyAdmins(
-                float violationCount = this.violatedPlayers.get(player);
-                if(violationCount != 1 && violationCount % 100 != 0) return;
-                Main.instance().getAppliance(AcInform.class).notifyAdmins(
                     "internal",
                     player.getName(),
                     "illegalBoatLookYaw",
-                    violationCount
+                    yawDelta,
+                    3000
                 );
             }),
             1L,

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

@@ -0,0 +1,38 @@
+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;
+
+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,21 @@
+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.inventory.InventoryCloseEvent;
+import org.bukkit.event.inventory.InventoryOpenEvent;
+
+class InventoryTrackerListener extends ApplianceListener<AntiInventoryMove> {
+    @EventHandler
+    public void onOpen(InventoryOpenEvent event) {
+        if(!(event.getPlayer() instanceof Player player)) 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/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/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!" +
+                    "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!",
+                        "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

@@ -37,6 +37,11 @@ public class Event extends Appliance {
         DONE
     }
 
+    public enum EventType {
+        BIG,
+        SMALL
+    }
+
     Countdown advertiseCountdown = new Countdown(
         120,
         announcementData -> Component.text()
@@ -50,6 +55,7 @@ public class Event extends Appliance {
     );
     public DisplayVillager.ConfigBound villager;
     private boolean isOpen = false;
+    private EventType eventType;
     private AdvertisementStatus advertiseStatus = AdvertisementStatus.BEFORE;
     private UUID roomId;
     private final List<Reward> pendingRewards = new ArrayList<>();
@@ -79,18 +85,24 @@ public class Event extends Appliance {
         if(this.isOpen) this.roomId = UUID.fromString(this.localConfig().getString("roomId", ""));
     }
 
-    public void openEvent() {
+    public void openEvent(EventType type) {
         if(this.isOpen) throw new ApplianceCommand.Error("Es läuft derzeit bereits ein Event!");
+        this.eventType = type;
 
-        Bukkit.getScheduler().runTaskAsynchronously(Main.instance(), () -> {
+        if(type.equals(EventType.SMALL)) {
-            ReqResp<EventRepository.CreatedRoom> sessionResponse = this.queryRepository(EventRepository.class).createSession();
+            Bukkit.getScheduler().runTaskAsynchronously(Main.instance(), () -> {
+                ReqResp<EventRepository.CreatedRoom> sessionResponse = this.queryRepository(EventRepository.class).createSession();
 
-            if(sessionResponse.status() != HttpStatus.OK)
+                if(sessionResponse.status() != HttpStatus.OK)
-                throw new ApplianceCommand.Error("Event-Server meldet Fehler: " + sessionResponse.status());
+                    throw new ApplianceCommand.Error("Event-Server meldet Fehler: " + sessionResponse.status());
 
-            this.isOpen = true;
+                this.isOpen = true;
-            this.roomId = sessionResponse.data().uuid();
+                this.roomId = sessionResponse.data().uuid();
-        });
+            });
+            return;
+        }
+
+        this.isOpen = true;
     }
 
     public void joinEvent(Player p) {
@@ -112,18 +124,22 @@ public class Event extends Appliance {
         Main.instance().getLogger().info("Verbinde mit eventserver: " + p.getName());
         p.sendMessage(Component.text("Authentifiziere...", NamedTextColor.GREEN));
 
-        Bukkit.getScheduler().runTaskAsynchronously(Main.instance(), () -> {
+        if(this.eventType.equals(EventType.SMALL)) {
-            ReqResp<EventRepository.QueueRoom.Response> queueResponse = this.queryRepository(EventRepository.class)
+            Bukkit.getScheduler().runTaskAsynchronously(Main.instance(), () -> {
-                .queueRoom(new EventRepository.QueueRoom(p.getUniqueId(), this.roomId));
+                ReqResp<EventRepository.QueueRoom.Response> queueResponse = this.queryRepository(EventRepository.class)
+                    .queueRoom(new EventRepository.QueueRoom(p.getUniqueId(), this.roomId));
 
-            if(queueResponse.status() != HttpStatus.OK || queueResponse.data().error() != null) {
+                if(queueResponse.status() != HttpStatus.OK || queueResponse.data().error() != null) {
-                p.sendMessage(Component.text("Fehler beim Betreten: " + queueResponse.data().error(), NamedTextColor.RED));
+                    p.sendMessage(Component.text("Fehler beim Betreten: " + queueResponse.data().error(), NamedTextColor.RED));
-                return;
+                    return;
-            }
+                }
 
-            p.sendMessage(Component.text("Betrete...", NamedTextColor.GREEN));
+                p.sendMessage(Component.text("Betrete...", NamedTextColor.GREEN));
-            PluginMessage.connect(p, this.localConfig().getString("connect-server-name"));
+                PluginMessage.connect(p, this.localConfig().getString("connect-server-name"));
-        });
+            });
+        }
+
+        PluginMessage.connect(p, "grand-event");
     }
 
     public void endEvent() {

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

@@ -7,6 +7,10 @@ import net.kyori.adventure.text.format.NamedTextColor;
 import org.bukkit.command.Command;
 import org.bukkit.command.CommandSender;
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.Arrays;
+import java.util.List;
 
 public class EventOpenSessionCommand extends ApplianceCommand<Event> {
     public EventOpenSessionCommand() {
@@ -15,7 +19,17 @@ public class EventOpenSessionCommand extends ApplianceCommand<Event> {
 
     @Override
     protected void execute(@NotNull CommandSender sender, @NotNull Command command, @NotNull String label, @NotNull String[] args) throws Exception {
-        this.getAppliance().openEvent();
+        if(args.length == 1) {
+            this.getAppliance().openEvent(Event.EventType.SMALL);
+        } else {
+            this.getAppliance().openEvent(Event.EventType.valueOf(args[1]));
+        }
         sender.sendMessage(Component.text("Event-Server gestartet!", NamedTextColor.GREEN));
     }
+
+    @Override
+    public @Nullable List<String> onTabComplete(@NotNull CommandSender sender, @NotNull Command command, @NotNull String label, @NotNull String[] args) {
+        if(args.length == 1) return Arrays.stream(Event.EventType.values()).map(Enum::toString).toList();
+        return null;
+    }
 }

event/src/main/java/eu/mhsl/craftattack/spawn/event/appliances/deathrun/Deathrun.java

@@ -1,32 +1,51 @@
 package eu.mhsl.craftattack.spawn.event.appliances.deathrun;
 
+import eu.mhsl.craftattack.spawn.core.Main;
 import eu.mhsl.craftattack.spawn.core.appliance.Appliance;
+import eu.mhsl.craftattack.spawn.event.appliances.deathrun.listeners.DeathrunPlayerDamageListener;
+import eu.mhsl.craftattack.spawn.event.appliances.deathrun.listeners.DeathrunPlayerJoinListener;
+import eu.mhsl.craftattack.spawn.event.appliances.deathrun.listeners.DeathrunPlayerMoveListener;
+import eu.mhsl.craftattack.spawn.event.appliances.deathrun.listeners.DeathrunPortalListener;
 import eu.mhsl.craftattack.spawn.event.appliances.eventController.Event;
 import eu.mhsl.craftattack.spawn.event.appliances.eventController.Scorable;
 import eu.mhsl.craftattack.spawn.event.appliances.eventController.scoreboard.EventScoreboardBuilder;
 import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.format.NamedTextColor;
 import net.kyori.adventure.title.Title;
+import net.kyori.adventure.util.Ticks;
 import org.bukkit.Bukkit;
 import org.bukkit.Particle;
 import org.bukkit.World;
 import org.bukkit.entity.Player;
 import org.bukkit.event.Listener;
+import org.bukkit.scheduler.BukkitTask;
 import org.jetbrains.annotations.NotNull;
 
+import java.util.ArrayList;
 import java.util.List;
+import java.util.UUID;
 
 @Appliance.Flags(autoload = false)
 public class Deathrun extends Appliance implements Event, Scorable {
     private final EventScoreboardBuilder scoreboardBuilder = new EventScoreboardBuilder(this, 3, 2, 3);
-    private final double borderDistance = 100;
+    private final double borderDistance = 75;
     private final int borderVisibilityDistance = 8;
     private long durationSeconds;
+    private boolean isBeforeStart = true;
+    private boolean pvpDisabled = true;
+    private final World world = Bukkit.getWorlds().getFirst();
+    private BukkitTask pvpTask;
+    public ArrayList<UUID> previouslyJoinedPlayers = new ArrayList<>();
 
     @Override
     public void onEnable() {
-        World world = Bukkit.getWorlds().getFirst();
+        this.world.getWorldBorder().setCenter(this.world.getSpawnLocation());
-        world.getWorldBorder().setCenter(world.getSpawnLocation());
+        this.world.getWorldBorder().setSize(20);
-        world.getWorldBorder().setSize(20);
+        Bukkit.getOnlinePlayers().forEach(player -> {
+            player.teleport(this.world.getSpawnLocation());
+            this.previouslyJoinedPlayers.add(player.getUniqueId());
+        });
+        this.pvpDisabled = true;
     }
 
     public double getBorderDistance() {
@@ -37,7 +56,7 @@ public class Deathrun extends Appliance implements Event, Scorable {
         return this.borderVisibilityDistance;
     }
 
-    public void spawnParticleWall(Player p, double xMin, double xMax, double yMin, double yMax, double zMin, double zMax) {
+    public void spawnParticles(Player p, double xMin, double xMax, double yMin, double yMax, double zMin, double zMax) {
         Particle particle = Particle.WAX_ON;
 
         for (double y = yMin; y <= yMax; y += 0.5) {
@@ -51,18 +70,41 @@ public class Deathrun extends Appliance implements Event, Scorable {
 
     @Override
     public void onDisable() {
-        World world = Bukkit.getWorlds().getFirst();
+        this.world.getWorldBorder().setSize(this.world.getWorldBorder().getMaxSize());
-        world.getWorldBorder().setSize(world.getWorldBorder().getMaxSize());
     }
 
     @Override
     public void start(long durationSeconds) {
+        this.isBeforeStart = false;
         this.durationSeconds = durationSeconds;
-        Title title = Title.title(Component.text("Start"), Component.text("Laufe Richtung Osten! (positiv x)"));
+        Title title = Title.title(Component.text("Start", NamedTextColor.GOLD), Component.text("Laufe Richtung Osten! (positiv x)", NamedTextColor.YELLOW));
-        Bukkit.getOnlinePlayers().forEach(player -> player.showTitle(title));
+        // TODO: Soll PvP überhaupt aktiviert werden? Soll Respawn erlaubt sein?
+        Bukkit.getOnlinePlayers().forEach(player -> {
+            player.showTitle(title);
+            player.sendMessage(Component.text("PvP wird in 10 Minuten aktiviert!", NamedTextColor.GOLD));
+        });
 
-        World world = Bukkit.getWorlds().getFirst();
+        this.world.getWorldBorder().setSize(this.world.getWorldBorder().getMaxSize());
-        world.getWorldBorder().setSize(world.getWorldBorder().getMaxSize());
+        this.pvpTask = Bukkit.getScheduler().runTaskLater(
+            Main.instance(),
+            () -> {
+                this.pvpDisabled = false;
+                Bukkit.getOnlinePlayers().forEach(player -> player.sendMessage(Component.text("PvP ist jetzt aktiviert!", NamedTextColor.GOLD)));
+            },
+            Ticks.TICKS_PER_SECOND * 60 * 10
+        );
+    }
+
+    public boolean isBeforeStart() {
+        return this.isBeforeStart;
+    }
+
+    public World getWorld() {
+        return this.world;
+    }
+
+    public boolean isPvpDisabled() {
+        return this.pvpDisabled;
     }
 
     @Override
@@ -74,6 +116,8 @@ public class Deathrun extends Appliance implements Event, Scorable {
     public void stop() {
         this.getScoreboardBuilder().stopAutomaticUpdates();
         Title title = Title.title(Component.text("Ende!"), Component.empty());
+        this.pvpTask.cancel();
+        this.pvpDisabled = true;
         Bukkit.getOnlinePlayers().forEach(player -> {
             player.showTitle(title);
             player.setScoreboard(Bukkit.getScoreboardManager().getNewScoreboard());
@@ -98,7 +142,10 @@ public class Deathrun extends Appliance implements Event, Scorable {
     @Override
     protected @NotNull List<Listener> listeners() {
         return List.of(
-            new DeathrunPlayerMoveListener()
+            new DeathrunPlayerMoveListener(),
+            new DeathrunPlayerDamageListener(),
+            new DeathrunPlayerJoinListener(),
+            new DeathrunPortalListener()
         );
     }
 }

event/src/main/java/eu/mhsl/craftattack/spawn/event/appliances/deathrun/listeners/DeathrunPlayerDamageListener.java

@@ -0,0 +1,31 @@
+package eu.mhsl.craftattack.spawn.event.appliances.deathrun.listeners;
+
+import eu.mhsl.craftattack.spawn.core.appliance.ApplianceListener;
+import eu.mhsl.craftattack.spawn.event.appliances.deathrun.Deathrun;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.entity.EntityDamageByEntityEvent;
+import org.bukkit.event.entity.EntityDamageEvent;
+import org.bukkit.event.entity.FoodLevelChangeEvent;
+
+public class DeathrunPlayerDamageListener extends ApplianceListener<Deathrun> {
+    @EventHandler
+    public void onPlayerDamagePlayer(EntityDamageByEntityEvent event) {
+        if(!this.getAppliance().isPvpDisabled()) return;
+        if(!(event.getDamager() instanceof Player)) return;
+        if(!(event.getEntity() instanceof Player)) return;
+        event.setCancelled(true);
+    }
+
+    @EventHandler
+    public void onPlayerDamage(EntityDamageEvent event) {
+        if(!this.getAppliance().isBeforeStart()) return;
+        if(!(event.getEntity() instanceof Player)) return;
+        event.setCancelled(true);
+    }
+
+    @EventHandler
+    public void onHunger(FoodLevelChangeEvent event) {
+        if(!this.getAppliance().isBeforeStart()) event.setCancelled(true);
+    }
+}

event/src/main/java/eu/mhsl/craftattack/spawn/event/appliances/deathrun/listeners/DeathrunPlayerJoinListener.java

@@ -0,0 +1,27 @@
+package eu.mhsl.craftattack.spawn.event.appliances.deathrun.listeners;
+
+import eu.mhsl.craftattack.spawn.core.appliance.ApplianceListener;
+import eu.mhsl.craftattack.spawn.event.appliances.deathrun.Deathrun;
+import org.bukkit.GameMode;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.player.PlayerJoinEvent;
+
+public class DeathrunPlayerJoinListener extends ApplianceListener<Deathrun> {
+    @EventHandler
+    public void onPlayerJoin(PlayerJoinEvent event) {
+        Player player = event.getPlayer();
+        if(
+            this.getAppliance().isBeforeStart() ||
+            !this.getAppliance().previouslyJoinedPlayers.contains(player.getUniqueId())
+        ) {
+            player.teleport(this.getAppliance().getWorld().getSpawnLocation());
+            player.setGameMode(GameMode.ADVENTURE);
+            this.getAppliance().previouslyJoinedPlayers.add(player.getUniqueId());
+        }
+
+        if(!this.getAppliance().isBeforeStart() && player.getGameMode().equals(GameMode.ADVENTURE)) {
+            player.setGameMode(GameMode.SURVIVAL);
+        }
+    }
+}

event/src/main/java/eu/mhsl/craftattack/spawn/event/appliances/deathrun/listeners/DeathrunPlayerMoveListener.java

@@ -1,10 +1,12 @@
-package eu.mhsl.craftattack.spawn.event.appliances.deathrun;
+package eu.mhsl.craftattack.spawn.event.appliances.deathrun.listeners;
 
 import eu.mhsl.craftattack.spawn.core.appliance.ApplianceListener;
+import eu.mhsl.craftattack.spawn.event.appliances.deathrun.Deathrun;
 import org.bukkit.Bukkit;
 import org.bukkit.Location;
 import org.bukkit.event.EventHandler;
 import org.bukkit.event.player.PlayerMoveEvent;
+import org.bukkit.event.player.PlayerTeleportEvent;
 
 public class DeathrunPlayerMoveListener extends ApplianceListener<Deathrun> {
     @EventHandler
@@ -14,22 +16,34 @@ public class DeathrunPlayerMoveListener extends ApplianceListener<Deathrun> {
         double minZ = spawnLocation.z() - this.getAppliance().getBorderDistance();
         double maxZ = spawnLocation.z() + this.getAppliance().getBorderDistance();
         if(event.getTo().x() < minX + this.getAppliance().getBorderVisibilityDistance()) {
-            this.getAppliance().spawnParticleWall(event.getPlayer(), minX-0.2, minX-0.2, event.getTo().y()-0.5, event.getTo().y()+2.5, event.getTo().z()-1.5, event.getTo().z()+1.5);
+            this.getAppliance().spawnParticles(event.getPlayer(), minX-0.2, minX-0.2, event.getTo().y()-0.5, event.getTo().y()+2.5, event.getTo().z()-1.5, event.getTo().z()+1.5);
             if(event.getTo().x() < minX) {
                 event.setTo(event.getTo().clone().set(minX, event.getTo().y(), event.getTo().z()));
             }
         }
         if(event.getTo().z() < minZ + this.getAppliance().getBorderVisibilityDistance()) {
-            this.getAppliance().spawnParticleWall(event.getPlayer(), event.getTo().x()-1.5, event.getTo().x()+1.5, event.getTo().y()-0.5, event.getTo().y()+2.5, minZ-0.2, minZ-0.2);
+            this.getAppliance().spawnParticles(event.getPlayer(), event.getTo().x()-1.5, event.getTo().x()+1.5, event.getTo().y()-0.5, event.getTo().y()+2.5, minZ-0.2, minZ-0.2);
             if(event.getTo().z() < minZ) {
                 event.setTo(event.getTo().clone().set(event.getTo().x(), event.getTo().y(), minZ));
             }
         }
         if(event.getTo().z() > maxZ - this.getAppliance().getBorderVisibilityDistance()) {
-            this.getAppliance().spawnParticleWall(event.getPlayer(), event.getTo().x()-1.5, event.getTo().x()+1.5, event.getTo().y()-0.5, event.getTo().y()+2.5, maxZ+0.2, maxZ+0.2);
+            this.getAppliance().spawnParticles(event.getPlayer(), event.getTo().x()-1.5, event.getTo().x()+1.5, event.getTo().y()-0.5, event.getTo().y()+2.5, maxZ+0.2, maxZ+0.2);
             if(event.getTo().z() > maxZ) {
                 event.setTo(event.getTo().clone().set(event.getTo().x(), event.getTo().y(), maxZ));
             }
         }
     }
+
+    @EventHandler
+    public void onPlayerTeleport(PlayerTeleportEvent event) throws Exception {
+        Location spawnLocation = Bukkit.getWorlds().getFirst().getSpawnLocation();
+        double minX = spawnLocation.x() - this.getAppliance().getBorderDistance();
+        double minZ = spawnLocation.z() - this.getAppliance().getBorderDistance();
+        double maxZ = spawnLocation.z() + this.getAppliance().getBorderDistance();
+        if(event.getTo().x() < minX || event.getTo().z() < minZ || event.getTo().z() > maxZ) {
+            event.setCancelled(true);
+            throw new Exception("Player %s teleported outside the border.".formatted(event.getPlayer()));
+        }
+    }
 }

event/src/main/java/eu/mhsl/craftattack/spawn/event/appliances/deathrun/listeners/DeathrunPortalListener.java

@@ -0,0 +1,13 @@
+package eu.mhsl.craftattack.spawn.event.appliances.deathrun.listeners;
+
+import eu.mhsl.craftattack.spawn.core.appliance.ApplianceListener;
+import eu.mhsl.craftattack.spawn.event.appliances.deathrun.Deathrun;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.player.PlayerPortalEvent;
+
+public class DeathrunPortalListener extends ApplianceListener<Deathrun> {
+    @EventHandler
+    public void onPlayerPortal(PlayerPortalEvent event) {
+        event.setCancelled(true);
+    }
+}

event/src/main/java/eu/mhsl/craftattack/spawn/event/appliances/eventController/EventController.java

@@ -3,21 +3,44 @@ package eu.mhsl.craftattack.spawn.event.appliances.eventController;
 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.event.appliances.eventController.commands.EventCommand;
+import eu.mhsl.craftattack.spawn.core.util.IteratorUtil;
+import eu.mhsl.craftattack.spawn.core.util.entity.PlayerUtils;
+import eu.mhsl.craftattack.spawn.core.util.server.PluginMessage;
+import eu.mhsl.craftattack.spawn.event.appliances.eventController.commands.BigEventCommand;
+import eu.mhsl.craftattack.spawn.event.appliances.eventController.commands.JoinCraftattackCommand;
+import net.kyori.adventure.sound.Sound;
 import net.kyori.adventure.text.Component;
 import net.kyori.adventure.text.format.NamedTextColor;
 import net.kyori.adventure.util.Ticks;
 import org.bukkit.Bukkit;
+import org.bukkit.GameMode;
+import org.bukkit.GameRule;
+import org.bukkit.Statistic;
 import org.jetbrains.annotations.NotNull;
 
 import java.util.List;
+import java.util.Map;
+
+import static java.util.Map.entry;
 
 public class EventController extends Appliance {
     private List<Appliance> eventAppliances = null;
     private Event selectedEvent = null;
-    private long timerStart;
     private int timerTaskId = -1;
 
+    private final Map<GameRule<Boolean>, Boolean> gameRulesAfterStart = Map.ofEntries(
+        entry(GameRule.DO_DAYLIGHT_CYCLE, true),
+        entry(GameRule.DO_INSOMNIA, true),
+        entry(GameRule.DISABLE_RAIDS, false),
+        entry(GameRule.DO_FIRE_TICK, true),
+        entry(GameRule.DO_ENTITY_DROPS, true),
+        entry(GameRule.DO_PATROL_SPAWNING, true),
+        entry(GameRule.DO_TRADER_SPAWNING, true),
+        entry(GameRule.DO_WEATHER_CYCLE, true),
+        entry(GameRule.FALL_DAMAGE, true),
+        entry(GameRule.FIRE_DAMAGE, true)
+    );
+
     @Override
     public void onEnable() {
         this.eventAppliances = Main.instance().getAppliances().stream()
@@ -36,6 +59,8 @@ public class EventController extends Appliance {
         Appliance newAppliance = Main.instance().restartAppliance(appliance.getClass());
         if(!(newAppliance instanceof Event newEvent)) throw new IllegalArgumentException("Appliance has to implement Event.");
         this.selectedEvent = newEvent;
+        Bukkit.getOnlinePlayers().forEach(player -> player.setGameMode(GameMode.ADVENTURE));
+        IteratorUtil.worlds(world -> IteratorUtil.setGameRules(this.gameRulesAfterStart, true));
     }
 
     public void unloadEvent() {
@@ -49,10 +74,26 @@ public class EventController extends Appliance {
 
     public void startEvent(long durationMinutes) {
         if(this.selectedEvent == null) throw new ApplianceCommand.Error("There is no event selected!");
+        IteratorUtil.worlds(world -> IteratorUtil.setGameRules(this.gameRulesAfterStart, false));
+        IteratorUtil.worlds(world -> world.setFullTime(0));
+        Bukkit.getOnlinePlayers().forEach(player -> {
+            player.setFoodLevel(20);
+            player.setHealth(20);
+            player.getInventory().clear();
+            player.setGameMode(GameMode.SURVIVAL);
+            player.setExp(0);
+            player.setLevel(0);
+
+            player.playSound(Sound.sound(org.bukkit.Sound.ITEM_GOAT_HORN_SOUND_6, Sound.Source.MASTER, 500f, 1f));
+
+            player.sendMessage(Component.text("Viel Spaß bei %s!".formatted(this.selectedEvent.getClass().getSimpleName()), NamedTextColor.GREEN));
+
+            player.setStatistic(Statistic.TIME_SINCE_REST, 0);
+            PlayerUtils.resetStatistics(player);
+        });
         this.selectedEvent.start(durationMinutes * 60);
         if(this.selectedEvent instanceof Scorable scorable && scorable.automaticUpdates()) scorable.getScoreboardBuilder().startAutomaticUpdates();
         // TODO: possibility for other dimensions
-        this.timerStart = Bukkit.getWorlds().getFirst().getFullTime();
         this.timerTaskId = Bukkit.getScheduler().scheduleSyncRepeatingTask(
             Main.instance(),
             this::updateTimer,
@@ -66,6 +107,17 @@ public class EventController extends Appliance {
         this.selectedEvent.stop();
         if(this.timerTaskId != -1) Bukkit.getScheduler().cancelTask(this.timerTaskId);
         this.timerTaskId = -1;
+        if(this.selectedEvent instanceof Scorable scorable) {
+            String scores = String.join("\n", scorable.getScoreboardBuilder().getScores());
+            Bukkit.getOnlinePlayers().forEach(player -> player.sendMessage(scores));
+            Main.instance().getLogger().info(scores);
+        }
+
+        Bukkit.getScheduler().runTaskLater(
+            Main.instance(),
+            () -> Bukkit.getOnlinePlayers().forEach(player -> PluginMessage.connect(player, "craftattack")),
+            Ticks.TICKS_PER_SECOND * 7
+        );
     }
 
     public String getSelectedEvent() {
@@ -74,12 +126,10 @@ public class EventController extends Appliance {
     }
 
     private void updateTimer() {
-        long ticksLeft = this.timerStart - (Bukkit.getWorlds().getFirst().getFullTime() - this.selectedEvent.getDurationSeconds() * Ticks.TICKS_PER_SECOND);
+        long ticksLeft = -(Bukkit.getWorlds().getFirst().getFullTime() - this.selectedEvent.getDurationSeconds() * Ticks.TICKS_PER_SECOND);
         if(ticksLeft <= 0) {
-            if(this.timerTaskId != -1) Bukkit.getScheduler().cancelTask(this.timerTaskId);
-            this.timerTaskId = -1;
-            this.selectedEvent.stop();
             Bukkit.getOnlinePlayers().forEach(player -> player.sendActionBar(Component.text("Fertig!")));
+            this.stopEvent();
             return;
         }
 
@@ -95,7 +145,8 @@ public class EventController extends Appliance {
     @Override
     protected @NotNull List<ApplianceCommand<?>> commands() {
         return List.of(
-            new EventCommand()
+            new BigEventCommand(),
+            new JoinCraftattackCommand()
         );
     }
 }

event/src/main/java/eu/mhsl/craftattack/spawn/event/appliances/eventController/commands/BigEventCommand.java

@@ -10,8 +10,8 @@ import org.jetbrains.annotations.Nullable;
 
 import java.util.List;
 
-public class EventCommand extends ApplianceCommand<EventController> {
+public class BigEventCommand extends ApplianceCommand<EventController> {
-    public EventCommand() {
+    public BigEventCommand() {
         super("event");
     }
 

event/src/main/java/eu/mhsl/craftattack/spawn/event/appliances/eventController/commands/JoinCraftattackCommand.java

@@ -0,0 +1,19 @@
+package eu.mhsl.craftattack.spawn.event.appliances.eventController.commands;
+
+import eu.mhsl.craftattack.spawn.core.appliance.ApplianceCommand;
+import eu.mhsl.craftattack.spawn.core.util.server.PluginMessage;
+import eu.mhsl.craftattack.spawn.event.appliances.eventController.EventController;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.jetbrains.annotations.NotNull;
+
+public class JoinCraftattackCommand extends ApplianceCommand.PlayerChecked<EventController> {
+    public JoinCraftattackCommand() {
+        super("craftattack");
+    }
+
+    @Override
+    protected void execute(@NotNull CommandSender sender, @NotNull Command command, @NotNull String label, @NotNull String[] args) {
+        PluginMessage.connect(this.getPlayer(), "craftattack");
+    }
+}

event/src/main/java/eu/mhsl/craftattack/spawn/event/appliances/eventController/scoreboard/EventScoreboardBuilder.java

@@ -137,6 +137,16 @@ public class EventScoreboardBuilder {
         return "%s. %s: %s".formatted(place+1, name, score);
     }
 
+    public List<String> getScores() {
+        List<EventScoreEntry> scoreList = new ArrayList<>(this.playerScores);
+        scoreList.sort(this.scoreComparator);
+        ArrayList<String> result = new ArrayList<>();
+        for(int i = 0; i < scoreList.size(); i++) {
+            result.add(this.formattedLine(i, scoreList.get(i).name(), scoreList.get(i).score()));
+        }
+        return result;
+    }
+
     private String trimName(String name) {
         if (name == null) return "Unknown";
         if (name.length() > 12) {