diff --git a/.github/workflows/deploy.yml b/.github/workflows/deploy.yml
index f018ff0a7..bafc3aa60 100644
--- a/.github/workflows/deploy.yml
+++ b/.github/workflows/deploy.yml
@@ -8,6 +8,8 @@ jobs:
 
         steps:
             -   uses: actions/checkout@v3
+                with:
+                    submodules: 'recursive'
             -   name: Set up JDK 17
                 uses: actions/setup-java@v3
                 with:
@@ -48,16 +50,4 @@ jobs:
                     host: ${{ secrets.SSH_HOST }}
                     username: ${{ secrets.SSH_USER }}
                     script: |
-                        tmux -S /home/prod/tmux_sockets/prod send-keys -t prod 'stop' Enter
-                        rm -rf /home/prod/archive/config
-                        rm -rf /home/prod/archive/build
-                        mkdir /home/prod/archive/config
-                        mkdir /home/prod/archive/build
-                        git clone git@github.com-Configuration:PhantazmNetwork/Configuration.git /home/prod/archive/config
-                        tar -xf /home/prod/archive/server.tar.gz -C /home/prod/archive/build
-                        rsync -ac --delete /home/prod/archive/build/ /home/prod/servers/prod
-                        rsync -ac /home/prod/archive/config/ /home/prod/servers/prod
-                        rsync -ac /home/prod/archive/persistent/ /home/prod/servers/prod
-                        tmux -S /home/prod/tmux_sockets/prod send-keys -t prod 'cd /home/prod/servers/prod' Enter
-                        tmux -S /home/prod/tmux_sockets/prod send-keys -t prod 'chmod +x ./start.sh' Enter
-                        tmux -S /home/prod/tmux_sockets/prod send-keys -t prod './start.sh' Enter
+                        /home/prod/archive/sync.sh
diff --git a/.gitmodules b/.gitmodules
new file mode 100644
index 000000000..962b585f7
--- /dev/null
+++ b/.gitmodules
@@ -0,0 +1,4 @@
+[submodule "minestom"]
+	path = minestom
+	url = https://github.com/PhantazmNetwork/Minestom
+	branch = master
diff --git a/.run/Run server.run.xml b/.run/Run server.run.xml
index 060941559..e6b3ba9c2 100644
--- a/.run/Run server.run.xml	
+++ b/.run/Run server.run.xml	
@@ -1,7 +1,7 @@
 <component name="ProjectRunConfigurationManager">
   <configuration default="false" name="Run server" type="JarApplication">
     <option name="JAR_PATH" value="$PROJECT_DIR$/run/server-1/server.jar" />
-    <option name="VM_PARAMETERS" value="-Dfile.encoding=UTF-8" />
+    <option name="VM_PARAMETERS" value="-Dfile.encoding=UTF-8 -Dminestom.packet-queue-size=-1" />
     <option name="PROGRAM_PARAMETERS" value="unsafe" />
     <option name="WORKING_DIRECTORY" value="$ProjectFileDir$/run/server-1" />
     <option name="ALTERNATIVE_JRE_PATH" />
diff --git a/README.md b/README.md
index 75917c3b3..4b03f38f7 100644
--- a/README.md
+++ b/README.md
@@ -26,7 +26,7 @@ This project started out of a perceived lack of PvE-focused Minecraft servers. W
 ## Install
 
 To build Phantazm binaries from source, run the following commands: \
-`git clone https://github.com/PhantazmNetwork/PhantazmServer.git` \
+`git clone --recurse-submodules https://github.com/PhantazmNetwork/PhantazmServer.git` \
 `cd PhantazmServer` \
 `./gradlew build`
 
diff --git a/buildSrc/build.gradle.kts b/buildSrc/build.gradle.kts
index 4bcef465e..cbcc24aee 100644
--- a/buildSrc/build.gradle.kts
+++ b/buildSrc/build.gradle.kts
@@ -8,6 +8,6 @@ repositories {
 
 kotlin {
     jvmToolchain {
-        (this as JavaToolchainSpec).languageVersion.set(JavaLanguageVersion.of(17))
+        languageVersion.set(JavaLanguageVersion.of(17))
     }
 }
diff --git a/buildSrc/src/main/kotlin/org/phantazm/gradle/task/SetupServer.kt b/buildSrc/src/main/kotlin/org/phantazm/gradle/task/SetupServer.kt
index beb0a6d04..ddaecd45a 100644
--- a/buildSrc/src/main/kotlin/org/phantazm/gradle/task/SetupServer.kt
+++ b/buildSrc/src/main/kotlin/org/phantazm/gradle/task/SetupServer.kt
@@ -6,7 +6,7 @@ import org.gradle.api.tasks.TaskAction
 import java.io.File
 
 abstract class SetupServer : DefaultTask() {
-    var dataFolder: File = project.rootDir.resolve("runData")
+    var dataFolder: File = project.rootDir.resolve("defaultRunData")
         @Internal get
 
     @TaskAction
diff --git a/commons/src/main/java/org/phantazm/commons/BasicTickTaskScheduler.java b/commons/src/main/java/org/phantazm/commons/BasicTickTaskScheduler.java
index a5391917a..9a5bfd555 100644
--- a/commons/src/main/java/org/phantazm/commons/BasicTickTaskScheduler.java
+++ b/commons/src/main/java/org/phantazm/commons/BasicTickTaskScheduler.java
@@ -22,6 +22,7 @@ public void scheduleTaskNow(@NotNull TickableTask tickableTask) {
 
     @Override
     public void scheduleTaskAfter(@NotNull TickableTask tickableTask, long millis) {
+        Objects.requireNonNull(tickableTask, "tickableTask");
         long startTime = System.currentTimeMillis();
         tickableTasks.add(new TickableTask() {
             private boolean finished;
@@ -41,6 +42,15 @@ public void tick(long time) {
         });
     }
 
+    @Override
+    public void end() {
+        for (TickableTask tickableTask : tickableTasks) {
+            tickableTask.end();
+        }
+
+        tickableTasks.clear();
+    }
+
     @Override
     public void tick(long time) {
         Iterator<TickableTask> taskIterator = tickableTasks.iterator();
diff --git a/commons/src/main/java/org/phantazm/commons/CancellableState.java b/commons/src/main/java/org/phantazm/commons/CancellableState.java
new file mode 100644
index 000000000..71be0f6f1
--- /dev/null
+++ b/commons/src/main/java/org/phantazm/commons/CancellableState.java
@@ -0,0 +1,37 @@
+package org.phantazm.commons;
+
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Objects;
+import java.util.UUID;
+
+public interface CancellableState {
+    void start();
+
+    void end();
+
+    @NotNull UUID id();
+
+    static @NotNull CancellableState named(@NotNull UUID id, @NotNull Runnable start, @NotNull Runnable end) {
+        Objects.requireNonNull(id, "id");
+        Objects.requireNonNull(start, "start");
+        Objects.requireNonNull(end, "end");
+
+        return new CancellableState() {
+            @Override
+            public void start() {
+                start.run();
+            }
+
+            @Override
+            public void end() {
+                end.run();
+            }
+
+            @Override
+            public @NotNull UUID id() {
+                return id;
+            }
+        };
+    }
+}
diff --git a/commons/src/main/java/org/phantazm/commons/MiniMessageUtils.java b/commons/src/main/java/org/phantazm/commons/MiniMessageUtils.java
new file mode 100644
index 000000000..162c1e54b
--- /dev/null
+++ b/commons/src/main/java/org/phantazm/commons/MiniMessageUtils.java
@@ -0,0 +1,42 @@
+package org.phantazm.commons;
+
+import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.ComponentLike;
+import net.kyori.adventure.text.JoinConfiguration;
+import net.kyori.adventure.text.minimessage.tag.Tag;
+import net.kyori.adventure.text.minimessage.tag.resolver.Placeholder;
+import net.kyori.adventure.text.minimessage.tag.resolver.TagResolver;
+import org.jetbrains.annotations.NotNull;
+
+public class MiniMessageUtils {
+
+    private MiniMessageUtils() {
+        throw new UnsupportedOperationException();
+    }
+
+    public static @NotNull TagResolver optional(@NotNull String key, boolean present) {
+        return TagResolver.resolver(key, (argumentQueue, context) -> {
+            String message = argumentQueue.pop().value();
+            Component result;
+            if (present) {
+                result = context.deserialize(message);
+            } else {
+                result = Component.empty();
+            }
+
+            return Tag.selfClosingInserting(result);
+        });
+    }
+
+    public static @NotNull TagResolver list(@NotNull String key,
+            @NotNull Iterable<? extends ComponentLike> components) {
+        return TagResolver.resolver(key, (argumentQueue, context) -> {
+            String separatorString = argumentQueue.pop().value();
+            Component separator = context.deserialize(separatorString);
+
+            Component result = Component.join(JoinConfiguration.separator(separator), components);
+            return Tag.inserting(result);
+        });
+    }
+
+}
diff --git a/commons/src/main/java/org/phantazm/commons/TickTaskScheduler.java b/commons/src/main/java/org/phantazm/commons/TickTaskScheduler.java
index c95128394..a045332f5 100644
--- a/commons/src/main/java/org/phantazm/commons/TickTaskScheduler.java
+++ b/commons/src/main/java/org/phantazm/commons/TickTaskScheduler.java
@@ -6,4 +6,6 @@ public interface TickTaskScheduler extends Tickable {
     void scheduleTaskNow(@NotNull TickableTask tickableTask);
 
     void scheduleTaskAfter(@NotNull TickableTask tickableTask, long millis);
+
+    void end();
 }
diff --git a/commons/src/main/java/org/phantazm/commons/TickableTask.java b/commons/src/main/java/org/phantazm/commons/TickableTask.java
index 949b5f8bb..419265ab4 100644
--- a/commons/src/main/java/org/phantazm/commons/TickableTask.java
+++ b/commons/src/main/java/org/phantazm/commons/TickableTask.java
@@ -2,4 +2,8 @@
 
 public interface TickableTask extends Tickable {
     boolean isFinished();
+
+    default void end() {
+
+    }
 }
diff --git a/core/src/main/java/org/phantazm/core/BasicClientBlockHandlerSource.java b/core/src/main/java/org/phantazm/core/BasicClientBlockHandlerSource.java
index 96ab1e653..37f048efb 100644
--- a/core/src/main/java/org/phantazm/core/BasicClientBlockHandlerSource.java
+++ b/core/src/main/java/org/phantazm/core/BasicClientBlockHandlerSource.java
@@ -1,20 +1,21 @@
 package org.phantazm.core;
 
+import net.minestom.server.event.Event;
+import net.minestom.server.event.EventNode;
+import net.minestom.server.event.instance.InstanceUnregisterEvent;
 import net.minestom.server.instance.Instance;
 import org.jetbrains.annotations.NotNull;
 
-import java.util.Map;
-import java.util.Objects;
-import java.util.WeakHashMap;
+import java.util.*;
+import java.util.concurrent.ConcurrentHashMap;
 import java.util.function.Function;
 
 /**
- * Standard implementation of {@link ClientBlockHandlerSource}. Does not maintain strong references to Instance objects.
+ * Standard implementation of {@link ClientBlockHandlerSource}.
  */
 public class BasicClientBlockHandlerSource implements ClientBlockHandlerSource {
     private final Function<? super Instance, ? extends ClientBlockHandler> blockHandlerFunction;
-    private final Map<Instance, ClientBlockHandler> map;
-    private final Object sync;
+    private final Map<UUID, ClientBlockHandler> map;
 
     /**
      * Creates a new instance of this class given the provided {@link ClientBlockHandler}-producing function. This
@@ -23,17 +24,26 @@ public class BasicClientBlockHandlerSource implements ClientBlockHandlerSource {
      * @param handlerFunction the handler function, which should never return null
      */
     public BasicClientBlockHandlerSource(
-            @NotNull Function<? super Instance, ? extends ClientBlockHandler> handlerFunction) {
+            @NotNull Function<? super Instance, ? extends ClientBlockHandler> handlerFunction,
+            @NotNull EventNode<Event> globalNode) {
         this.blockHandlerFunction = Objects.requireNonNull(handlerFunction, "handlerFunction");
-        this.map = new WeakHashMap<>();
-        this.sync = new Object();
+        this.map = new ConcurrentHashMap<>();
+
+        globalNode.addListener(InstanceUnregisterEvent.class, this::onInstanceUnregister);
     }
 
     @Override
     public @NotNull ClientBlockHandler forInstance(@NotNull Instance instance) {
-        synchronized (sync) {
-            return map.computeIfAbsent(Objects.requireNonNull(instance, "instance"),
-                    world -> Objects.requireNonNull(this.blockHandlerFunction.apply(world), "handler"));
-        }
+        return map.computeIfAbsent(instance.getUniqueId(), ignored -> {
+            if (!instance.isRegistered()) {
+                throw new IllegalArgumentException("Cannot hold an unregistered instance");
+            }
+
+            return Objects.requireNonNull(this.blockHandlerFunction.apply(instance), "handler");
+        });
+    }
+
+    private void onInstanceUnregister(InstanceUnregisterEvent event) {
+        map.remove(event.getInstance().getUniqueId());
     }
 }
diff --git a/core/src/main/java/org/phantazm/core/ComponentUtils.java b/core/src/main/java/org/phantazm/core/ComponentUtils.java
new file mode 100644
index 000000000..18a136183
--- /dev/null
+++ b/core/src/main/java/org/phantazm/core/ComponentUtils.java
@@ -0,0 +1,27 @@
+package org.phantazm.core;
+
+import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.minimessage.MiniMessage;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.IllegalFormatException;
+import java.util.Objects;
+
+public final class ComponentUtils {
+    private ComponentUtils() {
+    }
+
+    public static @NotNull Component tryFormat(@NotNull String formatString, Object... objects) {
+        Objects.requireNonNull(formatString, "formatString");
+
+        String message;
+        try {
+            message = String.format(formatString, objects);
+        }
+        catch (IllegalFormatException ignored) {
+            message = formatString;
+        }
+
+        return MiniMessage.miniMessage().deserialize(message);
+    }
+}
diff --git a/core/src/main/java/org/phantazm/core/InstanceClientBlockHandler.java b/core/src/main/java/org/phantazm/core/InstanceClientBlockHandler.java
index 4f9f28551..28d6a73eb 100644
--- a/core/src/main/java/org/phantazm/core/InstanceClientBlockHandler.java
+++ b/core/src/main/java/org/phantazm/core/InstanceClientBlockHandler.java
@@ -6,28 +6,22 @@
 import it.unimi.dsi.fastutil.longs.Long2ObjectOpenHashMap;
 import net.minestom.server.coordinate.Point;
 import net.minestom.server.coordinate.Vec;
-import net.minestom.server.event.Event;
-import net.minestom.server.event.EventFilter;
 import net.minestom.server.event.EventNode;
-import net.minestom.server.event.instance.InstanceUnregisterEvent;
+import net.minestom.server.event.instance.InstanceChunkUnloadEvent;
 import net.minestom.server.event.instance.PreBlockChangeEvent;
 import net.minestom.server.event.player.PlayerBlockBreakEvent;
-import net.minestom.server.event.player.PlayerChunkLoadEvent;
 import net.minestom.server.event.player.PrePlayerStartDiggingEvent;
+import net.minestom.server.event.player.PreSendChunkEvent;
 import net.minestom.server.event.trait.InstanceEvent;
 import net.minestom.server.instance.Chunk;
+import net.minestom.server.instance.DynamicChunk;
 import net.minestom.server.instance.Instance;
 import net.minestom.server.instance.block.Block;
 import net.minestom.server.listener.PlayerDiggingListener;
 import net.minestom.server.network.packet.server.play.BlockChangePacket;
 import net.minestom.server.utils.chunk.ChunkUtils;
 import org.jetbrains.annotations.NotNull;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
 
-import java.lang.ref.Reference;
-import java.lang.ref.WeakReference;
-import java.util.Iterator;
 import java.util.Objects;
 
 /**
@@ -36,99 +30,96 @@
  * @see ClientBlockHandlerSource
  */
 public class InstanceClientBlockHandler implements ClientBlockHandler {
-    private static final Logger LOGGER = LoggerFactory.getLogger(InstanceClientBlockHandler.class);
+    private final Instance instance;
+
+    private final Long2ObjectMap<Data> clientData;
 
-    private final Reference<Instance> instance;
-    private final Long2ObjectMap<Vec3I2ObjectMap<PositionedBlock>> clientBlocks;
     private final int chunkFloor;
     private final int chunkHeight;
 
-    private final EventNode<InstanceEvent> childNode;
-
     /**
      * <p>Constructs a new instance of this class bound to the provided {@link Instance}. This will add a few necessary
      * listeners to the given {@link EventNode}.</p>
      *
-     * <p>The lifetime of this object is free to exceed that of the Instance; no strong reference to it is retained.</p>
-     *
      * @param instance   the instance this handler is bound to
-     * @param globalNode the node to add block event listeners to
+     * @param chunkFloor the minimum y-coordinate of chunks in this instance
      */
-    public InstanceClientBlockHandler(@NotNull Instance instance, @NotNull EventNode<Event> globalNode, int chunkFloor,
-            int chunkHeight) {
-        //weakref necessary as instance field will be captured by the expiration predicate
-        this.instance = new WeakReference<>(Objects.requireNonNull(instance, "instance"));
-        this.clientBlocks = new Long2ObjectOpenHashMap<>();
+    public InstanceClientBlockHandler(@NotNull Instance instance, int chunkFloor, int chunkHeight) {
+        this.instance = Objects.requireNonNull(instance, "instance");
+        this.clientData = new Long2ObjectOpenHashMap<>();
         this.chunkFloor = chunkFloor;
         this.chunkHeight = chunkHeight;
 
-        this.childNode = EventNode.event("instance_client_block_handler{" + instance.getUniqueId() + "}",
-                EventFilter.from(InstanceEvent.class, Instance.class, InstanceEvent::getInstance), instanceEvent -> {
-                    Instance thisInstance = this.instance.get();
-                    return thisInstance != null && thisInstance == instanceEvent.getInstance();
-                });
-
-        childNode.addListener(InstanceUnregisterEvent.class, this::onInstanceUnregister);
-        childNode.addListener(PlayerChunkLoadEvent.class, this::onPlayerChunkLoad);
-        childNode.addListener(PreBlockChangeEvent.class, this::onPreBlockChange);
-        childNode.addListener(PlayerBlockBreakEvent.class, this::onPlayerBlockBreak);
-        childNode.addListener(PrePlayerStartDiggingEvent.class, this::onPrePlayerStartDigging);
-
-        globalNode.addChild(childNode);
+        EventNode<InstanceEvent> node = instance.eventNode();
+        node.addListener(PreBlockChangeEvent.class, this::onPreBlockChange);
+        node.addListener(PlayerBlockBreakEvent.class, this::onPlayerBlockBreak);
+        node.addListener(PrePlayerStartDiggingEvent.class, this::onPrePlayerStartDigging);
+        node.addListener(PreSendChunkEvent.class, this::onPreSendChunk);
+        node.addListener(InstanceChunkUnloadEvent.class, this::onChunkUnload);
     }
 
     @Override
     public void setClientBlock(@NotNull Block type, int x, int y, int z) {
-        Instance instance = this.instance.get();
+        Instance instance = this.instance;
         if (instance == null) {
             return;
         }
 
-        int cx = ChunkUtils.getChunkCoordinate(x);
-        int cz = ChunkUtils.getChunkCoordinate(z);
+        Chunk serverChunk = instance.getChunkAt(x, z);
+        if (serverChunk == null) {
+            return;
+        }
+
+        int cx = serverChunk.getChunkX();
+        int cz = serverChunk.getChunkZ();
+
         long index = ChunkUtils.getChunkIndex(cx, cz);
+        synchronized (clientData) {
+            Data data = clientData.get(index);
 
-        synchronized (clientBlocks) {
-            Vec3I2ObjectMap<PositionedBlock> positionedBlocks = clientBlocks.get(index);
-            if (positionedBlocks == null) {
-                clientBlocks.put(index,
-                        positionedBlocks = new HashVec3I2ObjectMap<>(0, chunkFloor, 0, 16, chunkHeight, 16));
+            if (data == null) {
+                data = new Data(new HashVec3I2ObjectMap<>(0, chunkFloor, 0, Chunk.CHUNK_SIZE_X, chunkHeight,
+                        Chunk.CHUNK_SIZE_Z));
+                clientData.put(index, data);
             }
 
-            PositionedBlock block = positionedBlocks.get(x, y, z);
+            PositionedBlock block = data.blocks.get(x, y, z);
             if (block == null) {
-                positionedBlocks.put(x, y, z, new PositionedBlock(type, x, y, z));
+                data.blocks.put(x, y, z, new PositionedBlock(type, x, y, z));
             }
             else {
                 block.block = type;
             }
 
-            Chunk chunk = instance.getChunk(cx, cz);
-            if (chunk != null) {
-                chunk.sendPacketToViewers(new BlockChangePacket(new Vec(x, y, z), type));
-            }
+            data.dirty = true;
+            serverChunk.sendPacketToViewers(new BlockChangePacket(new Vec(x, y, z), type));
         }
     }
 
+    @SuppressWarnings("SynchronizationOnLocalVariableOrMethodParameter")
     @Override
     public void clearClientBlocks() {
-        Instance instance = this.instance.get();
+        Instance instance = this.instance;
         if (instance == null) {
             return;
         }
 
-        synchronized (clientBlocks) {
-            for (Long2ObjectMap.Entry<Vec3I2ObjectMap<PositionedBlock>> entry : clientBlocks.long2ObjectEntrySet()) {
+        synchronized (clientData) {
+            for (Long2ObjectMap.Entry<Data> entry : clientData.long2ObjectEntrySet()) {
                 long index = entry.getLongKey();
                 int x = ChunkUtils.getChunkCoordX(index);
                 int z = ChunkUtils.getChunkCoordZ(index);
 
-                Chunk chunk = instance.getChunkAt(x, z);
-                Vec3I2ObjectMap<PositionedBlock> blocks = entry.getValue();
-                if (chunk != null) {
+                Chunk serverChunk = instance.getChunk(x, z);
+                if (serverChunk == null) {
+                    continue;
+                }
+
+                Vec3I2ObjectMap<PositionedBlock> blocks = entry.getValue().blocks;
+                synchronized (serverChunk) {
                     for (PositionedBlock block : blocks.values()) {
-                        Block serverBlock = chunk.getBlock(block.x, block.y, block.z);
-                        chunk.sendPacketToViewers(
+                        Block serverBlock = serverChunk.getBlock(block.x, block.y, block.z);
+                        serverChunk.sendPacketToViewers(
                                 new BlockChangePacket(new Vec(block.x, block.y, block.z), serverBlock));
                     }
                 }
@@ -136,13 +127,13 @@ public void clearClientBlocks() {
                 blocks.clear();
             }
 
-            clientBlocks.clear();
+            clientData.clear();
         }
     }
 
     @Override
     public void removeClientBlock(int x, int y, int z) {
-        Instance instance = this.instance.get();
+        Instance instance = this.instance;
         if (instance == null) {
             return;
         }
@@ -150,52 +141,106 @@ public void removeClientBlock(int x, int y, int z) {
         int cx = ChunkUtils.getChunkCoordinate(x);
         int cz = ChunkUtils.getChunkCoordinate(z);
         long index = ChunkUtils.getChunkIndex(cx, cz);
-        synchronized (clientBlocks) {
-            Vec3I2ObjectMap<PositionedBlock> blocks = clientBlocks.get(index);
+        synchronized (clientData) {
+            Data data = clientData.get(index);
+            if (data == null) {
+                return;
+            }
 
-            if (blocks != null) {
-                if (blocks.remove(x, y, z) != null) {
-                    Chunk chunk = instance.getChunk(cx, cz);
+            if (data.blocks.remove(x, y, z) != null) {
+                Chunk serverChunk = instance.getChunk(cx, cz);
 
-                    if (chunk != null) {
-                        Block serverBlock = chunk.getBlock(x, y, z);
+                if (serverChunk == null) {
+                    clientData.remove(index);
+                    return;
+                }
 
-                        //make sure player gets the actual block
-                        chunk.sendPacketToViewers(new BlockChangePacket(new Vec(x, y, z), serverBlock));
-                    }
+                Block serverBlock = serverChunk.getBlock(x, y, z);
 
-                    if (blocks.isEmpty()) {
-                        clientBlocks.remove(index);
-                    }
+                //make sure player gets the actual block
+                serverChunk.sendPacketToViewers(new BlockChangePacket(new Vec(x, y, z), serverBlock));
+
+                if (data.blocks.isEmpty()) {
+                    clientData.remove(index);
                 }
+
+                data.dirty = true;
             }
         }
     }
 
-    private void onInstanceUnregister(InstanceUnregisterEvent event) {
-        this.instance.clear();
-        synchronized (clientBlocks) {
-            this.clientBlocks.clear();
+    private static class Data {
+        private final Vec3I2ObjectMap<PositionedBlock> blocks;
+        private DynamicChunk chunk;
+        private boolean dirty;
+
+        public Data(Vec3I2ObjectMap<PositionedBlock> blocks) {
+            this.blocks = blocks;
         }
+    }
 
-        EventNode<? super InstanceEvent> parent = childNode.getParent();
-        if (parent != null) {
-            parent.removeChild(childNode);
+    @SuppressWarnings("SynchronizationOnLocalVariableOrMethodParameter")
+    private void onPreSendChunk(PreSendChunkEvent event) {
+        Instance instance = this.instance;
+        if (instance == null) {
+            return;
         }
-        else {
-            LOGGER.warn("Orphaned event node " + childNode.getName());
+
+        DynamicChunk serverChunk = event.chunk();
+
+        int cx = serverChunk.getChunkX();
+        int cz = serverChunk.getChunkZ();
+        long index = ChunkUtils.getChunkIndex(cx, cz);
+
+        synchronized (clientData) {
+            Data data = clientData.get(index);
+
+            if (data != null) {
+                DynamicChunk copy = data.chunk;
+
+                boolean updateCopyBlocks = false;
+                synchronized (serverChunk) {
+                    if (copy == null || copy.getLastChangeTime() != serverChunk.getLastChangeTime() || data.dirty) {
+                        copy = serverChunk.copy(instance, cx, cz);
+                        data.chunk = copy;
+                        updateCopyBlocks = true;
+                    }
+                }
+
+                if (updateCopyBlocks) {
+                    for (PositionedBlock positionedBlock : data.blocks.values()) {
+                        copy.setBlock(positionedBlock.x, positionedBlock.y, positionedBlock.z, positionedBlock.block);
+                    }
+
+                    data.dirty = false;
+                }
+
+                event.setChunk(copy);
+            }
+        }
+    }
+
+    private void onChunkUnload(InstanceChunkUnloadEvent event) {
+        Chunk chunk = event.getChunk();
+
+        int cx = chunk.getChunkX();
+        int cz = chunk.getChunkZ();
+        long index = ChunkUtils.getChunkIndex(cx, cz);
+
+        synchronized (clientData) {
+            clientData.remove(index);
         }
     }
 
     private void onPrePlayerStartDigging(PrePlayerStartDiggingEvent event) {
         Point blockPosition = event.getBlockPosition();
         long index = ChunkUtils.getChunkIndex(blockPosition);
-        synchronized (clientBlocks) {
-            Vec3I2ObjectMap<PositionedBlock> blocks = clientBlocks.get(index);
+        synchronized (clientData) {
+            Data data = clientData.get(index);
 
-            if (blocks != null) {
+            if (data != null) {
                 PositionedBlock block =
-                        blocks.get(blockPosition.blockX(), blockPosition.blockY(), blockPosition.blockZ());
+                        data.blocks.get(blockPosition.blockX(), blockPosition.blockY(), blockPosition.blockZ());
 
                 if (block != null) {
                     if (event.getResult().success()) {
@@ -211,14 +256,14 @@ private void onPrePlayerStartDigging(PrePlayerStartDiggingEvent event) {
     private void onPlayerBlockBreak(PlayerBlockBreakEvent event) {
         Point blockPosition = event.getBlockPosition();
         long index = ChunkUtils.getChunkIndex(blockPosition);
-        synchronized (clientBlocks) {
-            Vec3I2ObjectMap<PositionedBlock> blocks = clientBlocks.get(index);
+        synchronized (clientData) {
+            Data data = clientData.get(index);
 
-            if (blocks != null) {
+            if (data != null) {
                 //remove the client block; no need to send something else as it will be updated soon
-                if (blocks.remove(blockPosition.blockX(), blockPosition.blockY(), blockPosition.blockZ()) != null &&
-                        blocks.isEmpty()) {
-                    clientBlocks.remove(index);
+                if (data.blocks.remove(blockPosition.blockX(), blockPosition.blockY(), blockPosition.blockZ()) !=
+                        null && data.blocks.isEmpty()) {
+                    clientData.remove(index);
                 }
             }
         }
@@ -227,11 +272,11 @@ private void onPlayerBlockBreak(PlayerBlockBreakEvent event) {
     private void onPreBlockChange(PreBlockChangeEvent event) {
         Point blockPosition = event.blockPosition();
         long index = ChunkUtils.getChunkIndex(blockPosition);
-        synchronized (clientBlocks) {
-            Vec3I2ObjectMap<PositionedBlock> blocks = clientBlocks.get(index);
+        synchronized (clientData) {
+            Data data = clientData.get(index);
 
-            if (blocks != null) {
-                if (blocks.containsKey(blockPosition.blockX(), blockPosition.blockY(), blockPosition.blockZ())) {
+            if (data != null) {
+                if (data.blocks.containsKey(blockPosition.blockX(), blockPosition.blockY(), blockPosition.blockZ())) {
                     //allow the server to update the block, but don't tell the client
                     event.setSyncClient(false);
                 }
@@ -239,30 +284,6 @@ private void onPreBlockChange(PreBlockChangeEvent event) {
         }
     }
 
-    private void onPlayerChunkLoad(PlayerChunkLoadEvent event) {
-        int cx = event.getChunkX();
-        int cz = event.getChunkZ();
-
-        BlockChangePacket[] packets = null;
-        long index = ChunkUtils.getChunkIndex(cx, cz);
-        synchronized (clientBlocks) {
-            Vec3I2ObjectMap<PositionedBlock> blocks = clientBlocks.get(index);
-
-            if (blocks != null) {
-                Iterator<PositionedBlock> blockIterator = blocks.values().iterator();
-                packets = new BlockChangePacket[blocks.size()];
-                for (int i = 0; i < packets.length; i++) {
-                    PositionedBlock block = blockIterator.next();
-                    packets[i] = new BlockChangePacket(new Vec(block.x, block.y, block.z), block.block);
-                }
-            }
-        }
-
-        if (packets != null) {
-            event.getPlayer().sendPackets(packets);
-        }
-    }
-
     private static class PositionedBlock {
         private final int x;
         private final int y;
diff --git a/core/src/main/java/org/phantazm/core/config/InstanceConfig.java b/core/src/main/java/org/phantazm/core/config/InstanceConfig.java
index 765d86e8c..5ccfe4291 100644
--- a/core/src/main/java/org/phantazm/core/config/InstanceConfig.java
+++ b/core/src/main/java/org/phantazm/core/config/InstanceConfig.java
@@ -9,7 +9,7 @@
 /**
  * Config for a single {@link Instance}.
  */
-public record InstanceConfig(@NotNull Pos spawnPoint, long time, int timeRate) {
+public record InstanceConfig(@NotNull Pos spawnPoint, long time, int timeRate, int chunkLoadDistance) {
     /**
      * The default spawn point {@link Pos}.
      */
@@ -19,6 +19,8 @@ public record InstanceConfig(@NotNull Pos spawnPoint, long time, int timeRate) {
 
     public static final int DEFAULT_TIME_RATE = 0;
 
+    public static final int DEFAULT_CHUNK_LOAD_RANGE = 10;
+
     /**
      * Creates config regarding a single {@link Instance}.
      *
diff --git a/core/src/main/java/org/phantazm/core/entity/fakeplayer/MinimalFakePlayer.java b/core/src/main/java/org/phantazm/core/entity/fakeplayer/MinimalFakePlayer.java
index 49d294142..337073bef 100644
--- a/core/src/main/java/org/phantazm/core/entity/fakeplayer/MinimalFakePlayer.java
+++ b/core/src/main/java/org/phantazm/core/entity/fakeplayer/MinimalFakePlayer.java
@@ -15,7 +15,7 @@
 import java.util.Objects;
 import java.util.UUID;
 
-public class MinimalFakePlayer extends Entity {
+public class MinimalFakePlayer extends LivingEntity {
 
     private final SchedulerManager schedulerManager;
 
diff --git a/core/src/main/java/org/phantazm/core/game/scene/BasicRouterStore.java b/core/src/main/java/org/phantazm/core/game/scene/BasicRouterStore.java
new file mode 100644
index 000000000..9c64fc74e
--- /dev/null
+++ b/core/src/main/java/org/phantazm/core/game/scene/BasicRouterStore.java
@@ -0,0 +1,55 @@
+package org.phantazm.core.game.scene;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Unmodifiable;
+
+import java.util.*;
+import java.util.concurrent.ConcurrentHashMap;
+
+public class BasicRouterStore implements RouterStore {
+    private final Map<RouterKey<?, ?, ?>, SceneRouter<?, ?>> routerMap;
+
+    public BasicRouterStore() {
+        this.routerMap = new ConcurrentHashMap<>();
+    }
+
+    @SuppressWarnings("unchecked")
+    @Override
+    public <TScene extends Scene<?>, TRequest extends SceneJoinRequest, TRouter extends SceneRouter<TScene, TRequest>> @NotNull TRouter getRouter(
+            @NotNull RouterKey<TScene, TRequest, TRouter> routerKey) {
+        TRouter router = (TRouter)routerMap.get(routerKey);
+        if (router == null) {
+            throw new IllegalArgumentException("No router of type " + routerKey.router().getName());
+        }
+
+        return router;
+    }
+
+    @Override
+    public <TScene extends Scene<?>, TRequest extends SceneJoinRequest, TRouter extends SceneRouter<TScene, TRequest>> void putRouter(
+            @NotNull RouterKey<TScene, TRequest, TRouter> key, @NotNull SceneRouter<TScene, TRequest> router) {
+        Objects.requireNonNull(key, "key");
+        Objects.requireNonNull(router, "router");
+
+        if (routerMap.putIfAbsent(key, router) != null) {
+            throw new IllegalArgumentException("A router is already registered to type " + key.router().getName());
+        }
+    }
+
+    @Override
+    public @NotNull @Unmodifiable Collection<SceneRouter<?, ?>> getRouters() {
+        return List.copyOf(routerMap.values());
+    }
+
+    @Override
+    public @NotNull Optional<? extends Scene<?>> getCurrentScene(@NotNull UUID uuid) {
+        for (SceneRouter<?, ?> router : routerMap.values()) {
+            Optional<? extends Scene<?>> scene = router.getCurrentScene(uuid);
+            if (scene.isPresent()) {
+                return scene;
+            }
+        }
+
+        return Optional.empty();
+    }
+}
diff --git a/core/src/main/java/org/phantazm/core/game/scene/BasicSceneStore.java b/core/src/main/java/org/phantazm/core/game/scene/BasicSceneStore.java
deleted file mode 100644
index 2c5052091..000000000
--- a/core/src/main/java/org/phantazm/core/game/scene/BasicSceneStore.java
+++ /dev/null
@@ -1,34 +0,0 @@
-package org.phantazm.core.game.scene;
-
-import org.jetbrains.annotations.NotNull;
-
-import java.util.HashMap;
-import java.util.Map;
-import java.util.Objects;
-import java.util.Optional;
-
-/**
- * Basic implementation of a {@link SceneStore}.
- */
-public class BasicSceneStore implements SceneStore {
-
-    private final Map<SceneKey<?>, Scene<?>> scenes = new HashMap<>();
-
-    @SuppressWarnings("unchecked")
-    @Override
-    public <TScene extends Scene<?>> @NotNull Optional<TScene> getScene(@NotNull SceneKey<TScene> key) {
-        return Optional.ofNullable((TScene)scenes.get(key));
-    }
-
-    @Override
-    public <TScene extends Scene<?>> void addScene(@NotNull SceneKey<TScene> key, @NotNull TScene scene) {
-        Objects.requireNonNull(key, "key");
-        Objects.requireNonNull(scene, "scene");
-
-        if (scenes.containsKey(key)) {
-            throw new IllegalStateException("Scene already associated with key " + key);
-        }
-        scenes.put(key, scene);
-    }
-
-}
diff --git a/core/src/main/java/org/phantazm/core/game/scene/InstanceScene.java b/core/src/main/java/org/phantazm/core/game/scene/InstanceScene.java
index 27fe7b898..ad27c3618 100644
--- a/core/src/main/java/org/phantazm/core/game/scene/InstanceScene.java
+++ b/core/src/main/java/org/phantazm/core/game/scene/InstanceScene.java
@@ -3,7 +3,6 @@
 import com.github.steanky.toolkit.collection.Wrapper;
 import net.minestom.server.instance.Instance;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.UnmodifiableView;
 import org.phantazm.core.game.scene.fallback.SceneFallback;
 import org.phantazm.core.player.PlayerView;
 
@@ -15,24 +14,21 @@
  * @param <TRequest>
  */
 public abstract class InstanceScene<TRequest extends SceneJoinRequest> implements Scene<TRequest> {
+    private final UUID uuid;
     protected final Instance instance;
     protected final SceneFallback fallback;
-    protected final Map<UUID, PlayerView> players;
-    protected final Map<UUID, PlayerView> unmodifiablePlayers;
 
     private boolean shutdown = false;
 
-    public InstanceScene(@NotNull Instance instance, @NotNull Map<UUID, PlayerView> players,
-            @NotNull SceneFallback fallback) {
+    public InstanceScene(@NotNull UUID uuid, @NotNull Instance instance, @NotNull SceneFallback fallback) {
+        this.uuid = Objects.requireNonNull(uuid, "uuid");
         this.instance = Objects.requireNonNull(instance, "instance");
-        this.players = Objects.requireNonNull(players, "players");
-        this.unmodifiablePlayers = Collections.unmodifiableMap(players);
         this.fallback = Objects.requireNonNull(fallback, "fallback");
     }
 
     @Override
-    public @UnmodifiableView @NotNull Map<UUID, PlayerView> getPlayers() {
-        return unmodifiablePlayers;
+    public @NotNull UUID getUUID() {
+        return uuid;
     }
 
     @Override
@@ -61,15 +57,11 @@ public boolean isShutdown() {
 
     @Override
     public void shutdown() {
-        for (PlayerView player : players.values()) {
-            player.getPlayer().ifPresent(unused -> fallback.fallback(player));
-        }
-
-        players.clear();
         shutdown = true;
     }
 
     @Override
-    public void tick(long time) {
+    public @NotNull SceneFallback getFallback() {
+        return fallback;
     }
 }
diff --git a/core/src/main/java/org/phantazm/core/game/scene/RouteResult.java b/core/src/main/java/org/phantazm/core/game/scene/RouteResult.java
index bd0c1c720..2cd01b266 100644
--- a/core/src/main/java/org/phantazm/core/game/scene/RouteResult.java
+++ b/core/src/main/java/org/phantazm/core/game/scene/RouteResult.java
@@ -2,38 +2,24 @@
 
 import net.kyori.adventure.text.Component;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
 
 import java.util.Objects;
 import java.util.Optional;
 
-/**
- * Represents the result of routing in a {@link Scene}.
- */
-public record RouteResult(boolean success, @NotNull Optional<Component> message) {
-    /**
-     * The common successful RouteResult, with an empty message.
-     */
-    public static final RouteResult SUCCESSFUL = new RouteResult(true, Optional.empty());
+public record RouteResult<TScene extends Scene<?>>(@NotNull Optional<TScene> scene,
+                                                   @NotNull Optional<Component> message) {
 
+    public static <TScene extends Scene<?>> RouteResult<TScene> success(@NotNull TScene scene) {
+        return new RouteResult<>(Optional.of(scene), Optional.empty());
+    }
+
+    public static <TScene extends Scene<?>> RouteResult<TScene> failure(@NotNull Component message) {
+        return new RouteResult<>(Optional.empty(), Optional.of(message));
+    }
 
-    /**
-     * Creates a route result.
-     *
-     * @param success Whether the routing was successful
-     * @param message A message relating to the routing
-     */
     public RouteResult {
+        Objects.requireNonNull(scene, "scene");
         Objects.requireNonNull(message, "message");
     }
 
-    /**
-     * Creates a route result.
-     *
-     * @param success whether the routing was successful
-     * @param message the message, which may be null if none is present
-     */
-    public RouteResult(boolean success, @Nullable Component message) {
-        this(success, Optional.ofNullable(message));
-    }
 }
diff --git a/core/src/main/java/org/phantazm/core/game/scene/RouterKey.java b/core/src/main/java/org/phantazm/core/game/scene/RouterKey.java
new file mode 100644
index 000000000..87aacb516
--- /dev/null
+++ b/core/src/main/java/org/phantazm/core/game/scene/RouterKey.java
@@ -0,0 +1,7 @@
+package org.phantazm.core.game.scene;
+
+import org.jetbrains.annotations.NotNull;
+
+public record RouterKey<TScene extends Scene<?>, TRequest extends SceneJoinRequest, TRouter extends SceneRouter<TScene, TRequest>>(
+        @NotNull Class<TRouter> router) {
+}
diff --git a/core/src/main/java/org/phantazm/core/game/scene/RouterStore.java b/core/src/main/java/org/phantazm/core/game/scene/RouterStore.java
new file mode 100644
index 000000000..8f4893559
--- /dev/null
+++ b/core/src/main/java/org/phantazm/core/game/scene/RouterStore.java
@@ -0,0 +1,20 @@
+package org.phantazm.core.game.scene;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Unmodifiable;
+
+import java.util.Collection;
+import java.util.Optional;
+import java.util.UUID;
+
+public interface RouterStore {
+    @NotNull <TScene extends Scene<?>, TRequest extends SceneJoinRequest, TRouter extends SceneRouter<TScene, TRequest>> TRouter getRouter(
+            @NotNull RouterKey<TScene, TRequest, TRouter> routerKey);
+
+    <TScene extends Scene<?>, TRequest extends SceneJoinRequest, TRouter extends SceneRouter<TScene, TRequest>> void putRouter(
+            @NotNull RouterKey<TScene, TRequest, TRouter> key, @NotNull SceneRouter<TScene, TRequest> router);
+
+    @NotNull @Unmodifiable Collection<SceneRouter<?, ?>> getRouters();
+
+    @NotNull Optional<? extends Scene<?>> getCurrentScene(@NotNull UUID uuid);
+}
diff --git a/core/src/main/java/org/phantazm/core/game/scene/Scene.java b/core/src/main/java/org/phantazm/core/game/scene/Scene.java
index f9c73fe0b..352c305a0 100644
--- a/core/src/main/java/org/phantazm/core/game/scene/Scene.java
+++ b/core/src/main/java/org/phantazm/core/game/scene/Scene.java
@@ -3,6 +3,7 @@
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.UnmodifiableView;
 import org.phantazm.commons.Tickable;
+import org.phantazm.core.game.scene.fallback.SceneFallback;
 import org.phantazm.core.player.PlayerView;
 
 import java.util.Map;
@@ -15,22 +16,6 @@
  */
 public interface Scene<TRequest extends SceneJoinRequest> extends Tickable {
 
-    /**
-     * Routes a join request to the scene.
-     *
-     * @param joinRequest The request for the join
-     * @return The result of the join
-     */
-    @NotNull RouteResult join(@NotNull TRequest joinRequest);
-
-    /**
-     * Removes players from the scene.
-     *
-     * @param leavers The {@link UUID}s of the players to remove
-     * @return The result of the leave
-     */
-    @NotNull RouteResult leave(@NotNull Iterable<UUID> leavers);
-
     /**
      * Gets the {@link PlayerView}s that are associated with the scene.
      * Some players might not be in game.
@@ -39,6 +24,12 @@ public interface Scene<TRequest extends SceneJoinRequest> extends Tickable {
      */
     @UnmodifiableView @NotNull Map<UUID, PlayerView> getPlayers();
 
+    @NotNull UUID getUUID();
+
+    @NotNull TransferResult join(@NotNull TRequest joinRequest);
+
+    @NotNull TransferResult leave(@NotNull Iterable<UUID> leavers);
+
     /**
      * Gets the number of players that are considered "ingame" in the scene.
      * This count may differ from the number of entries in
@@ -84,4 +75,8 @@ public interface Scene<TRequest extends SceneJoinRequest> extends Tickable {
      */
     void setJoinable(boolean joinable);
 
+    @NotNull SceneFallback getFallback();
+
+    boolean isQuittable();
+
 }
diff --git a/core/src/main/java/org/phantazm/core/game/scene/SceneKey.java b/core/src/main/java/org/phantazm/core/game/scene/SceneKey.java
deleted file mode 100644
index 49c1a542b..000000000
--- a/core/src/main/java/org/phantazm/core/game/scene/SceneKey.java
+++ /dev/null
@@ -1,42 +0,0 @@
-package org.phantazm.core.game.scene;
-
-import org.jetbrains.annotations.NotNull;
-
-import java.util.Objects;
-
-/**
- * A key used to identify unique {@link Scene}.
- *
- * @param <TScene> The type of the associated {@link Scene}
- */
-@SuppressWarnings("unused")
-public record SceneKey<TScene extends Scene<?>>(@NotNull String key) {
-
-    /**
-     * Creates a {@link Scene} key.
-     *
-     * @param key The {@link String} representation of the key
-     */
-    public SceneKey {
-        Objects.requireNonNull(key, "key");
-    }
-
-    @Override
-    public boolean equals(Object o) {
-        if (this == o) {
-            return true;
-        }
-        if (o == null || getClass() != o.getClass()) {
-            return false;
-        }
-
-        SceneKey<?> that = (SceneKey<?>)o;
-        return key.equals(that.key);
-    }
-
-    @Override
-    public int hashCode() {
-        return key.hashCode();
-    }
-
-}
diff --git a/core/src/main/java/org/phantazm/core/game/scene/SceneProvider.java b/core/src/main/java/org/phantazm/core/game/scene/SceneProvider.java
index ef9489333..c9be2f678 100644
--- a/core/src/main/java/org/phantazm/core/game/scene/SceneProvider.java
+++ b/core/src/main/java/org/phantazm/core/game/scene/SceneProvider.java
@@ -34,4 +34,6 @@ public interface SceneProvider<TScene extends Scene<TRequest>, TRequest extends
      */
     void forceShutdown();
 
+    boolean hasActiveScenes();
+
 }
diff --git a/core/src/main/java/org/phantazm/core/game/scene/SceneProviderAbstract.java b/core/src/main/java/org/phantazm/core/game/scene/SceneProviderAbstract.java
index ae0865606..c193d2ba7 100644
--- a/core/src/main/java/org/phantazm/core/game/scene/SceneProviderAbstract.java
+++ b/core/src/main/java/org/phantazm/core/game/scene/SceneProviderAbstract.java
@@ -1,7 +1,10 @@
 package org.phantazm.core.game.scene;
 
+import net.minestom.server.MinecraftServer;
+import net.minestom.server.ServerProcess;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.UnmodifiableView;
+import org.phantazm.core.game.scene.event.SceneShutdownEvent;
 
 import java.util.*;
 
@@ -61,6 +64,11 @@ public void tick(long time) {
             if (scene.isShutdown()) {
                 cleanupScene(scene);
                 iterator.remove();
+
+                ServerProcess process = MinecraftServer.process();
+                if (process != null) {
+                    process.eventHandler().call(new SceneShutdownEvent(scene));
+                }
             }
             else {
                 scene.tick(time);
@@ -86,4 +94,14 @@ public void tick(long time) {
 
     protected abstract void cleanupScene(@NotNull TScene scene);
 
+    @Override
+    public boolean hasActiveScenes() {
+        for (TScene scene : scenes) {
+            if (scene.getIngamePlayerCount() > 0) {
+                return true;
+            }
+        }
+
+        return false;
+    }
 }
diff --git a/core/src/main/java/org/phantazm/core/game/scene/SceneRouter.java b/core/src/main/java/org/phantazm/core/game/scene/SceneRouter.java
new file mode 100644
index 000000000..88c32ea42
--- /dev/null
+++ b/core/src/main/java/org/phantazm/core/game/scene/SceneRouter.java
@@ -0,0 +1,62 @@
+package org.phantazm.core.game.scene;
+
+import org.jetbrains.annotations.NotNull;
+import org.phantazm.commons.Tickable;
+
+import java.util.Collection;
+import java.util.Optional;
+import java.util.UUID;
+
+public interface SceneRouter<TScene extends Scene<?>, TRequest extends SceneJoinRequest> extends Tickable {
+
+    @NotNull RouteResult<TScene> findScene(@NotNull TRequest joinRequest);
+
+    @NotNull Collection<TScene> getScenes();
+
+    @NotNull Optional<TScene> getCurrentScene(@NotNull UUID playerUUID);
+
+    @NotNull Collection<TScene> getScenesContainingPlayer(@NotNull UUID playerUUID);
+
+    /**
+     * Whether the scene is currently shutdown.
+     * Shutdown scenes should not allow more players.
+     *
+     * @return Whether the scene is shutdown
+     */
+    boolean isShutdown();
+
+    /**
+     * Shuts down the scene and breaks its current lifecycle.
+     */
+    void shutdown();
+
+    /**
+     * Checks whether the scene is considered joinable.
+     *
+     * @return Whether the scene is considered joinable
+     */
+    boolean isJoinable();
+
+    /**
+     * Sets whether the scene should be considered joinable.
+     * Joinable is defined on an implementation basis.
+     *
+     * @param joinable Whether the scene should be joinable
+     */
+    void setJoinable(boolean joinable);
+
+    /**
+     * Whether this router is a "game".
+     *
+     * @return true if this router represents a game, false otherwise
+     */
+    boolean isGame();
+
+    /**
+     * Whether this router currently has any scenes with players in them.
+     *
+     * @return true if this router has any scenes containing players, false otherwise
+     */
+    boolean hasActiveScenes();
+
+}
diff --git a/core/src/main/java/org/phantazm/core/game/scene/SceneStore.java b/core/src/main/java/org/phantazm/core/game/scene/SceneStore.java
deleted file mode 100644
index 76d9e85e3..000000000
--- a/core/src/main/java/org/phantazm/core/game/scene/SceneStore.java
+++ /dev/null
@@ -1,31 +0,0 @@
-package org.phantazm.core.game.scene;
-
-import org.jetbrains.annotations.NotNull;
-
-import java.util.Optional;
-
-/**
- * Store for {@link Scene}. These {@link Scene}s should be unique and are associated by a key.
- */
-public interface SceneStore {
-
-    /**
-     * Gets a {@link Scene} by a {@link SceneKey}.
-     *
-     * @param key      The key associated with the {@link Scene}
-     * @param <TScene> The type of the {@link Scene}
-     * @return An {@link Optional} of a {@link Scene}
-     */
-    <TScene extends Scene<?>> @NotNull Optional<TScene> getScene(@NotNull SceneKey<TScene> key);
-
-    /**
-     * Adds a {@link Scene} to the store
-     *
-     * @param key      The key to associate with the {@link Scene}
-     * @param scene    The {@link Scene} to add
-     * @param <TScene> The type of the {@link Scene}
-     * @throws IllegalStateException If a {@link Scene} with the given key has already been added
-     */
-    <TScene extends Scene<?>> void addScene(@NotNull SceneKey<TScene> key, @NotNull TScene scene);
-
-}
diff --git a/core/src/main/java/org/phantazm/core/game/scene/SceneTransferHelper.java b/core/src/main/java/org/phantazm/core/game/scene/SceneTransferHelper.java
new file mode 100644
index 000000000..f68f815ac
--- /dev/null
+++ b/core/src/main/java/org/phantazm/core/game/scene/SceneTransferHelper.java
@@ -0,0 +1,69 @@
+package org.phantazm.core.game.scene;
+
+import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.format.NamedTextColor;
+import org.jetbrains.annotations.NotNull;
+import org.phantazm.core.player.PlayerView;
+
+import java.util.*;
+
+public class SceneTransferHelper {
+
+    private final RouterStore routerStore;
+
+    public SceneTransferHelper(@NotNull RouterStore routerStore) {
+        this.routerStore = Objects.requireNonNull(routerStore, "routerStore");
+    }
+
+    public <TJoinRequest extends SceneJoinRequest> void transfer(@NotNull Scene<TJoinRequest> to,
+            @NotNull TJoinRequest joinRequest, @NotNull Collection<PlayerView> leavers, @NotNull PlayerView leader) {
+        boolean anyFailures = false;
+        Collection<Runnable> leaveExecutors = new ArrayList<>(leavers.size());
+        for (PlayerView leaver : leavers) {
+            Optional<? extends Scene<?>> oldSceneOptional = routerStore.getCurrentScene(leaver.getUUID());
+            if (oldSceneOptional.isEmpty()) {
+                continue;
+            }
+
+            Scene<?> oldScene = oldSceneOptional.get();
+            if (oldScene == to) {
+                continue;
+            }
+
+            TransferResult leaveResult = oldScene.leave(Collections.singleton(leaver.getUUID()));
+            if (leaveResult.executor().isPresent()) {
+                leaveExecutors.add(leaveResult.executor().get());
+            }
+            else {
+                anyFailures = true;
+                leaveResult.message().ifPresent(message -> {
+                    leaver.getPlayer().ifPresent(player -> player.sendMessage(message));
+                });
+            }
+        }
+
+        if (anyFailures) {
+            leader.getPlayer().ifPresent(leaderPlayer -> {
+                leaderPlayer.sendMessage(
+                        Component.text("Failed to join because not all players could leave their " + "previous scenes.",
+                                NamedTextColor.RED));
+            });
+            return;
+        }
+
+        for (Runnable leaveExecutor : leaveExecutors) {
+            leaveExecutor.run();
+        }
+
+        TransferResult joinResult = to.join(joinRequest);
+        if (joinResult.executor().isPresent()) {
+            joinResult.executor().get().run();
+        }
+        else if (joinResult.message().isPresent()) {
+            leader.getPlayer().ifPresent(leaderPlayer -> {
+                leaderPlayer.sendMessage(joinResult.message().get());
+            });
+        }
+    }
+
+}
diff --git a/core/src/main/java/org/phantazm/core/game/scene/TransferResult.java b/core/src/main/java/org/phantazm/core/game/scene/TransferResult.java
new file mode 100644
index 000000000..52d276736
--- /dev/null
+++ b/core/src/main/java/org/phantazm/core/game/scene/TransferResult.java
@@ -0,0 +1,33 @@
+package org.phantazm.core.game.scene;
+
+import net.kyori.adventure.text.Component;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.Objects;
+import java.util.Optional;
+
+/**
+ * Represents the result of transferring a player to or from a {@link Scene}.
+ */
+public record TransferResult(@NotNull Optional<Runnable> executor, @NotNull Optional<Component> message) {
+
+    /**
+     * Creates a transfer result.
+     *
+     * @param message A message relating to the routing
+     */
+    public TransferResult {
+        Objects.requireNonNull(executor, "executor");
+        Objects.requireNonNull(message, "message");
+    }
+
+    public static @NotNull TransferResult success(@NotNull Runnable executor) {
+        return new TransferResult(Optional.of(executor), Optional.empty());
+    }
+
+    public static @NotNull TransferResult failure(@Nullable Component message) {
+        return new TransferResult(Optional.empty(), Optional.ofNullable(message));
+    }
+
+}
diff --git a/core/src/main/java/org/phantazm/core/game/scene/Utils.java b/core/src/main/java/org/phantazm/core/game/scene/Utils.java
new file mode 100644
index 000000000..c225b4ea3
--- /dev/null
+++ b/core/src/main/java/org/phantazm/core/game/scene/Utils.java
@@ -0,0 +1,48 @@
+package org.phantazm.core.game.scene;
+
+import net.minestom.server.MinecraftServer;
+import net.minestom.server.entity.Player;
+import net.minestom.server.instance.EntityTracker;
+import net.minestom.server.instance.Instance;
+import net.minestom.server.network.packet.server.ServerPacket;
+import net.minestom.server.utils.time.TimeUnit;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Objects;
+
+public class Utils {
+    /**
+     * Handles player transfer between instances, sending list packets.
+     *
+     * @param oldInstance the old instance; is {@code null} if the player is logging in for the first time
+     * @param player      the player
+     */
+    public static void handleInstanceTransfer(@NotNull Instance oldInstance, @NotNull Player player) {
+        Instance newInstance = Objects.requireNonNull(player.getInstance(), "player instance");
+        if (newInstance == oldInstance) {
+            return;
+        }
+
+        ServerPacket playerRemove = player.getRemovePlayerToList();
+        ServerPacket playerAdd = player.getAddPlayerToList();
+
+        for (Player oldPlayer : oldInstance.getEntityTracker().entities(EntityTracker.Target.PLAYERS)) {
+            oldPlayer.sendPacket(playerRemove);
+            player.sendPacket(oldPlayer.getRemovePlayerToList());
+        }
+
+        for (Player newInstancePlayer : newInstance.getEntityTracker().entities(EntityTracker.Target.PLAYERS)) {
+            if (newInstancePlayer == player) {
+                continue;
+            }
+
+            player.sendPacket(newInstancePlayer.getAddPlayerToList());
+            newInstancePlayer.sendPacket(playerAdd);
+
+            MinecraftServer.getSchedulerManager().buildTask(() -> {
+                player.updateNewViewer(newInstancePlayer);
+                newInstancePlayer.updateNewViewer(player);
+            }).delay(20, TimeUnit.SERVER_TICK).schedule();
+        }
+    }
+}
diff --git a/core/src/main/java/org/phantazm/core/game/scene/command/QuitCommand.java b/core/src/main/java/org/phantazm/core/game/scene/command/QuitCommand.java
new file mode 100644
index 000000000..aad743c74
--- /dev/null
+++ b/core/src/main/java/org/phantazm/core/game/scene/command/QuitCommand.java
@@ -0,0 +1,59 @@
+package org.phantazm.core.game.scene.command;
+
+import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.format.NamedTextColor;
+import net.minestom.server.command.builder.Command;
+import net.minestom.server.entity.Player;
+import org.jetbrains.annotations.NotNull;
+import org.phantazm.core.game.scene.RouterStore;
+import org.phantazm.core.game.scene.TransferResult;
+import org.phantazm.core.player.PlayerViewProvider;
+
+import java.util.Collections;
+import java.util.Objects;
+
+public final class QuitCommand {
+
+    private QuitCommand() {
+        throw new UnsupportedOperationException();
+    }
+
+    public static @NotNull Command quitCommand(@NotNull RouterStore routerStore,
+            @NotNull PlayerViewProvider viewProvider) {
+        Objects.requireNonNull(routerStore, "routerStore");
+        Objects.requireNonNull(viewProvider, "viewProvider");
+
+        Command command = new Command("quit", "leave", "l");
+        command.addConditionalSyntax((sender, commandString) -> {
+            if (commandString == null) {
+                return sender instanceof Player;
+            }
+
+            if (!(sender instanceof Player)) {
+                sender.sendMessage(Component.text("You have to be a player to use that command!", NamedTextColor.RED));
+                return false;
+            }
+
+            return true;
+        }, (sender, context) -> {
+            Player player = (Player)sender;
+            routerStore.getCurrentScene(player.getUuid()).ifPresent(scene -> {
+                if (!scene.isQuittable()) {
+                    sender.sendMessage(Component.text("You can't quit this scene.", NamedTextColor.RED));
+                    return;
+                }
+
+                TransferResult result = scene.leave(Collections.singleton(player.getUuid()));
+                if (result.executor().isPresent()) {
+                    result.executor().get().run();
+                    scene.getFallback().fallback(viewProvider.fromPlayer(player));
+                }
+                else {
+                    result.message().ifPresent(sender::sendMessage);
+                }
+            });
+        });
+
+        return command;
+    }
+}
diff --git a/core/src/main/java/org/phantazm/core/game/scene/event/SceneEvent.java b/core/src/main/java/org/phantazm/core/game/scene/event/SceneEvent.java
new file mode 100644
index 000000000..f21cd9f94
--- /dev/null
+++ b/core/src/main/java/org/phantazm/core/game/scene/event/SceneEvent.java
@@ -0,0 +1,9 @@
+package org.phantazm.core.game.scene.event;
+
+import net.minestom.server.event.Event;
+import org.jetbrains.annotations.NotNull;
+import org.phantazm.core.game.scene.Scene;
+
+public interface SceneEvent extends Event {
+    @NotNull Scene<?> getScene();
+}
diff --git a/core/src/main/java/org/phantazm/core/game/scene/event/SceneShutdownEvent.java b/core/src/main/java/org/phantazm/core/game/scene/event/SceneShutdownEvent.java
new file mode 100644
index 000000000..a983d699d
--- /dev/null
+++ b/core/src/main/java/org/phantazm/core/game/scene/event/SceneShutdownEvent.java
@@ -0,0 +1,19 @@
+package org.phantazm.core.game.scene.event;
+
+import org.jetbrains.annotations.NotNull;
+import org.phantazm.core.game.scene.Scene;
+
+import java.util.Objects;
+
+public class SceneShutdownEvent implements SceneEvent {
+    private final Scene<?> scene;
+
+    public SceneShutdownEvent(@NotNull Scene<?> scene) {
+        this.scene = Objects.requireNonNull(scene, "scene");
+    }
+
+    @Override
+    public @NotNull Scene<?> getScene() {
+        return scene;
+    }
+}
diff --git a/core/src/main/java/org/phantazm/core/game/scene/lobby/BasicLobbyJoinRequest.java b/core/src/main/java/org/phantazm/core/game/scene/lobby/BasicLobbyJoinRequest.java
index 524c17f48..52a8cf99d 100644
--- a/core/src/main/java/org/phantazm/core/game/scene/lobby/BasicLobbyJoinRequest.java
+++ b/core/src/main/java/org/phantazm/core/game/scene/lobby/BasicLobbyJoinRequest.java
@@ -1,5 +1,6 @@
 package org.phantazm.core.game.scene.lobby;
 
+import it.unimi.dsi.fastutil.Pair;
 import net.minestom.server.entity.GameMode;
 import net.minestom.server.entity.Player;
 import net.minestom.server.instance.Instance;
@@ -7,6 +8,7 @@
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.UnmodifiableView;
 import org.phantazm.core.config.InstanceConfig;
+import org.phantazm.core.game.scene.Utils;
 import org.phantazm.core.player.PlayerView;
 
 import java.util.ArrayList;
@@ -44,36 +46,32 @@ public BasicLobbyJoinRequest(@NotNull ConnectionManager connectionManager,
 
     @Override
     public void handleJoin(@NotNull Instance instance, @NotNull InstanceConfig instanceConfig) {
-        List<Player> teleportedPlayers = new ArrayList<>(players.size());
+        List<Pair<Player, Instance>> teleportedPlayers = new ArrayList<>(players.size());
         List<CompletableFuture<?>> futures = new ArrayList<>(players.size());
         for (PlayerView view : players) {
             view.getPlayer().ifPresent(player -> {
                 player.setGameMode(GameMode.ADVENTURE);
 
-                teleportedPlayers.add(player);
-                futures.add(player.setInstance(instance, instanceConfig.spawnPoint()));
+                teleportedPlayers.add(Pair.of(player, player.getInstance()));
+                if (player.getInstance() == instance) {
+                    futures.add(player.teleport(instanceConfig.spawnPoint()));
+                }
+                else {
+                    futures.add(player.setInstance(instance, instanceConfig.spawnPoint()));
+                }
             });
         }
 
         CompletableFuture.allOf(futures.toArray(EMPTY_COMPLETABLE_FUTURE_ARRAY)).thenRun(() -> {
             for (int i = 0; i < futures.size(); ++i) {
-                Player teleportedPlayer = teleportedPlayers.get(i);
+                Pair<Player, Instance> pair = teleportedPlayers.get(i);
 
-                for (Player otherPlayer : connectionManager.getOnlinePlayers()) {
-                    if (otherPlayer.getInstance() != instance) {
-                        otherPlayer.removeViewer(teleportedPlayer);
-                        teleportedPlayer.sendPacket(otherPlayer.getRemovePlayerToList());
-                        teleportedPlayer.removeViewer(otherPlayer);
-                        otherPlayer.sendPacket(teleportedPlayer.getRemovePlayerToList());
-                    } else {
-                        teleportedPlayer.sendPacket(otherPlayer.getAddPlayerToList());
-                        otherPlayer.addViewer(teleportedPlayer);
-                        otherPlayer.sendPacket(teleportedPlayer.getAddPlayerToList());
-                        teleportedPlayer.addViewer(otherPlayer);
-                    }
-                }
+                Player teleportedPlayer = pair.first();
+                Instance oldInstance = pair.second();
+
+                Utils.handleInstanceTransfer(oldInstance, teleportedPlayer);
             }
-        });
+        }).join();
     }
 
 }
diff --git a/core/src/main/java/org/phantazm/core/game/scene/lobby/BasicLobbyProvider.java b/core/src/main/java/org/phantazm/core/game/scene/lobby/BasicLobbyProvider.java
index 9e91f1a5b..c5071e0a5 100644
--- a/core/src/main/java/org/phantazm/core/game/scene/lobby/BasicLobbyProvider.java
+++ b/core/src/main/java/org/phantazm/core/game/scene/lobby/BasicLobbyProvider.java
@@ -1,5 +1,10 @@
 package org.phantazm.core.game.scene.lobby;
 
+import com.github.steanky.element.core.ElementException;
+import com.github.steanky.element.core.context.ContextManager;
+import com.github.steanky.element.core.context.ElementContext;
+import com.github.steanky.ethylene.core.ConfigElement;
+import com.github.steanky.ethylene.core.collection.ConfigList;
 import net.minestom.server.event.EventNode;
 import net.minestom.server.event.inventory.InventoryPreClickEvent;
 import net.minestom.server.event.item.ItemDropEvent;
@@ -8,27 +13,33 @@
 import net.minestom.server.event.player.*;
 import net.minestom.server.event.trait.InstanceEvent;
 import net.minestom.server.instance.Instance;
-import net.minestom.server.instance.InstanceManager;
 import org.jetbrains.annotations.NotNull;
+import org.phantazm.core.ElementUtils;
 import org.phantazm.core.config.InstanceConfig;
 import org.phantazm.core.game.scene.SceneProviderAbstract;
 import org.phantazm.core.game.scene.fallback.SceneFallback;
 import org.phantazm.core.instance.InstanceLoader;
+import org.phantazm.core.npc.NPC;
+import org.phantazm.core.npc.NPCHandler;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
-import java.util.List;
-import java.util.Objects;
+import java.util.*;
+import java.util.function.Consumer;
 
 /**
  * Basic implementation of a {@link LobbyProviderAbstract}.
  */
 public class BasicLobbyProvider extends LobbyProviderAbstract {
-    private final InstanceLoader instanceLoader;
+    private static final Logger LOGGER = LoggerFactory.getLogger(BasicLobbyProvider.class);
+    private static final Consumer<? super ElementException> HANDLER = ElementUtils.logging(LOGGER, "npc");
 
+    private final InstanceLoader instanceLoader;
     private final List<String> lobbyPaths;
-
     private final SceneFallback fallback;
-
     private final InstanceConfig instanceConfig;
+    private final List<ElementContext> npcContexts;
+    private final boolean quittable;
 
     /**
      * Creates a basic implementation of a {@link SceneProviderAbstract}.
@@ -42,13 +53,25 @@ public class BasicLobbyProvider extends LobbyProviderAbstract {
      * @param instanceConfig    The {@link InstanceConfig} for the {@link Lobby}s
      */
     public BasicLobbyProvider(int maximumLobbies, int newLobbyThreshold, @NotNull InstanceLoader instanceLoader,
-            @NotNull List<String> lobbyPaths, @NotNull SceneFallback fallback, @NotNull InstanceConfig instanceConfig) {
+            @NotNull List<String> lobbyPaths, @NotNull SceneFallback fallback, @NotNull InstanceConfig instanceConfig,
+            @NotNull ContextManager contextManager, @NotNull ConfigList npcConfigs, boolean quittable) {
         super(maximumLobbies, newLobbyThreshold);
 
         this.instanceLoader = Objects.requireNonNull(instanceLoader, "instanceLoader");
         this.lobbyPaths = List.copyOf(Objects.requireNonNull(lobbyPaths, "lobbyPaths"));
         this.fallback = Objects.requireNonNull(fallback, "fallback");
         this.instanceConfig = Objects.requireNonNull(instanceConfig, "instanceConfig");
+
+
+        List<ElementContext> npcContexts = new ArrayList<>(npcConfigs.size());
+        for (ConfigElement element : npcConfigs) {
+            if (element.isNode()) {
+                npcContexts.add(contextManager.makeContext(element.asNode()));
+            }
+        }
+
+        this.npcContexts = List.copyOf(npcContexts);
+        this.quittable = quittable;
     }
 
     @Override
@@ -72,12 +95,25 @@ public BasicLobbyProvider(int maximumLobbies, int newLobbyThreshold, @NotNull In
         });
         eventNode.addListener(PlayerBlockBreakEvent.class, event -> event.setCancelled(true));
 
-        return new Lobby(instance, instanceConfig, fallback);
+        List<NPC> npcs = new ArrayList<>(npcContexts.size());
+        for (ElementContext context : npcContexts) {
+            NPC npc = context.provide(HANDLER, () -> null);
+            if (npc != null) {
+                npcs.add(npc);
+            }
+        }
+
+        Lobby lobby = new Lobby(UUID.randomUUID(), instance, instanceConfig, fallback,
+                new NPCHandler(List.copyOf(npcs), instance), quittable);
+        eventNode.addListener(PlayerDisconnectEvent.class,
+                event -> lobby.leave(Collections.singleton(event.getPlayer().getUuid())).executor()
+                        .ifPresent(Runnable::run));
+
+        return lobby;
     }
 
     @Override
     protected void cleanupScene(@NotNull Lobby scene) {
-
+        scene.cleanup();
     }
-
 }
diff --git a/core/src/main/java/org/phantazm/core/game/scene/lobby/Lobby.java b/core/src/main/java/org/phantazm/core/game/scene/lobby/Lobby.java
index 34df8ce1c..8459c419b 100644
--- a/core/src/main/java/org/phantazm/core/game/scene/lobby/Lobby.java
+++ b/core/src/main/java/org/phantazm/core/game/scene/lobby/Lobby.java
@@ -5,10 +5,12 @@
 import net.minestom.server.entity.Player;
 import net.minestom.server.instance.Instance;
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.UnmodifiableView;
 import org.phantazm.core.config.InstanceConfig;
 import org.phantazm.core.game.scene.InstanceScene;
-import org.phantazm.core.game.scene.RouteResult;
+import org.phantazm.core.game.scene.TransferResult;
 import org.phantazm.core.game.scene.fallback.SceneFallback;
+import org.phantazm.core.npc.NPCHandler;
 import org.phantazm.core.player.PlayerView;
 
 import java.util.*;
@@ -18,6 +20,9 @@
  */
 public class Lobby extends InstanceScene<LobbyJoinRequest> {
     private final InstanceConfig instanceConfig;
+    private final Map<UUID, PlayerView> players;
+    private final NPCHandler npcHandler;
+    private final boolean quittable;
 
     private boolean joinable = true;
 
@@ -28,18 +33,23 @@ public class Lobby extends InstanceScene<LobbyJoinRequest> {
      * @param instanceConfig The {@link InstanceConfig} used for the lobby's {@link Instance}
      * @param fallback       A fallback for the lobby
      */
-    public Lobby(@NotNull Instance instance, @NotNull InstanceConfig instanceConfig, @NotNull SceneFallback fallback) {
-        super(instance, new HashMap<>(), fallback);
+    public Lobby(@NotNull UUID uuid, @NotNull Instance instance, @NotNull InstanceConfig instanceConfig,
+            @NotNull SceneFallback fallback, @NotNull NPCHandler npcHandler, boolean quittable) {
+        super(uuid, instance, fallback);
         this.instanceConfig = Objects.requireNonNull(instanceConfig, "instanceConfig");
+        this.players = new HashMap<>();
+        this.npcHandler = Objects.requireNonNull(npcHandler, "npcHandler");
+        this.npcHandler.spawnAll();
+        this.quittable = quittable;
     }
 
     @Override
-    public @NotNull RouteResult join(@NotNull LobbyJoinRequest joinRequest) {
+    public @NotNull TransferResult join(@NotNull LobbyJoinRequest joinRequest) {
         if (isShutdown()) {
-            return new RouteResult(false, Component.text("Lobby is shutdown."));
+            return TransferResult.failure(Component.text("Lobby is shutdown."));
         }
         if (!isJoinable()) {
-            return new RouteResult(false, Component.text("Lobby is not joinable."));
+            return TransferResult.failure(Component.text("Lobby is not joinable."));
         }
 
         Collection<PlayerView> playerViews = joinRequest.getPlayers();
@@ -53,19 +63,20 @@ public Lobby(@NotNull Instance instance, @NotNull InstanceConfig instanceConfig,
         }
 
         if (joiners.isEmpty()) {
-            return new RouteResult(false, Component.text("Everybody is already in the lobby."));
+            return TransferResult.failure(Component.text("Everybody is already in the lobby."));
         }
 
-        for (Pair<PlayerView, Player> player : joiners) {
-            joinRequest.handleJoin(instance, instanceConfig);
-            players.put(player.first().getUUID(), player.first());
-        }
+        return TransferResult.success(() -> {
+            for (Pair<PlayerView, Player> player : joiners) {
+                players.put(player.first().getUUID(), player.first());
+            }
 
-        return RouteResult.SUCCESSFUL;
+            joinRequest.handleJoin(instance, instanceConfig);
+        });
     }
 
     @Override
-    public @NotNull RouteResult leave(@NotNull Iterable<UUID> leavers) {
+    public @NotNull TransferResult leave(@NotNull Iterable<UUID> leavers) {
         boolean anyInside = false;
         for (UUID uuid : leavers) {
             if (players.containsKey(uuid)) {
@@ -75,14 +86,19 @@ public Lobby(@NotNull Instance instance, @NotNull InstanceConfig instanceConfig,
         }
 
         if (!anyInside) {
-            return new RouteResult(false, Component.text("None of the players are in the lobby."));
+            return TransferResult.failure(Component.text("None of the players are in the lobby."));
         }
 
-        for (UUID uuid : leavers) {
-            players.remove(uuid);
-        }
+        return TransferResult.success(() -> {
+            for (UUID uuid : leavers) {
+                players.remove(uuid);
+            }
+        });
+    }
 
-        return RouteResult.SUCCESSFUL;
+    @Override
+    public @UnmodifiableView @NotNull Map<UUID, PlayerView> getPlayers() {
+        return players;
     }
 
     @Override
@@ -94,4 +110,27 @@ public boolean isJoinable() {
     public void setJoinable(boolean joinable) {
         this.joinable = joinable;
     }
+
+    @Override
+    public boolean isQuittable() {
+        return quittable;
+    }
+
+    @Override
+    public void shutdown() {
+        for (PlayerView player : players.values()) {
+            fallback.fallback(player);
+        }
+
+        super.shutdown();
+    }
+
+    public void cleanup() {
+        this.npcHandler.end();
+    }
+
+    @Override
+    public void tick(long time) {
+        this.npcHandler.tick(time);
+    }
 }
diff --git a/core/src/main/java/org/phantazm/core/game/scene/lobby/LobbyProviderAbstract.java b/core/src/main/java/org/phantazm/core/game/scene/lobby/LobbyProviderAbstract.java
index ba280eead..127309a43 100644
--- a/core/src/main/java/org/phantazm/core/game/scene/lobby/LobbyProviderAbstract.java
+++ b/core/src/main/java/org/phantazm/core/game/scene/lobby/LobbyProviderAbstract.java
@@ -3,6 +3,7 @@
 import org.jetbrains.annotations.NotNull;
 import org.phantazm.core.game.scene.SceneProvider;
 import org.phantazm.core.game.scene.SceneProviderAbstract;
+import org.phantazm.core.player.PlayerView;
 
 import java.util.Optional;
 
@@ -31,7 +32,14 @@ public LobbyProviderAbstract(int maximumLobbies, int newLobbyThreshold) {
         Lobby maximumLobby = null;
         int maximumWeighting = Integer.MIN_VALUE;
 
+        sceneLoop:
         for (Lobby lobby : getScenes()) {
+            for (PlayerView playerView : request.getPlayers()) {
+                if (lobby.getPlayers().containsKey(playerView.getUUID())) {
+                    continue sceneLoop;
+                }
+            }
+
             int joinWeight = lobby.getJoinWeight(request);
 
             if (joinWeight > maximumWeighting) {
diff --git a/core/src/main/java/org/phantazm/core/game/scene/lobby/LobbyRouter.java b/core/src/main/java/org/phantazm/core/game/scene/lobby/LobbyRouter.java
index 3c32d5463..cdb50a422 100644
--- a/core/src/main/java/org/phantazm/core/game/scene/lobby/LobbyRouter.java
+++ b/core/src/main/java/org/phantazm/core/game/scene/lobby/LobbyRouter.java
@@ -2,61 +2,20 @@
 
 import net.kyori.adventure.text.Component;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.UnmodifiableView;
 import org.phantazm.core.game.scene.RouteResult;
 import org.phantazm.core.game.scene.Scene;
 import org.phantazm.core.game.scene.SceneProvider;
-import org.phantazm.core.player.PlayerView;
+import org.phantazm.core.game.scene.SceneRouter;
 
 import java.util.*;
 
 /**
  * {@link Scene} router for {@link Lobby}s.
  */
-public class LobbyRouter implements Scene<LobbyRouteRequest> {
+public class LobbyRouter implements SceneRouter<Lobby, LobbyRouteRequest> {
 
     private final Map<String, SceneProvider<Lobby, LobbyJoinRequest>> lobbyProviders;
 
-    private final Map<UUID, Lobby> playerLobbyMap = new HashMap<>();
-
-    private final Map<UUID, PlayerView> unmodifiablePlayers = new AbstractMap<>() {
-
-        @Override
-        public boolean containsKey(Object key) {
-            if (!(key instanceof UUID uuid)) {
-                return false;
-            }
-
-            return playerLobbyMap.containsKey(uuid);
-        }
-
-        @Override
-        public PlayerView get(Object key) {
-            if (!(key instanceof UUID uuid)) {
-                return null;
-            }
-
-            Lobby lobby = playerLobbyMap.get(uuid);
-            if (lobby == null) {
-                return null;
-            }
-
-            return lobby.getPlayers().get(uuid);
-        }
-
-        @NotNull
-        @Override
-        public Set<Entry<UUID, PlayerView>> entrySet() {
-            Set<Entry<UUID, PlayerView>> entrySet = new HashSet<>();
-            for (Lobby lobby : playerLobbyMap.values()) {
-                entrySet.addAll(lobby.getPlayers().entrySet());
-            }
-
-            return Collections.unmodifiableSet(entrySet);
-        }
-
-    };
-
     private boolean shutdown = false;
 
     private boolean joinable = true;
@@ -71,78 +30,50 @@ public LobbyRouter(@NotNull Map<String, SceneProvider<Lobby, LobbyJoinRequest>>
     }
 
     @Override
-    public @NotNull RouteResult join(@NotNull LobbyRouteRequest routeRequest) {
-        if (isShutdown()) {
-            return new RouteResult(false, Component.text("The router is shutdown."));
-        }
-        if (!isJoinable()) {
-            return new RouteResult(false, Component.text("The router is not joinable."));
-        }
-
-        SceneProvider<Lobby, LobbyJoinRequest> lobbyProvider = lobbyProviders.get(routeRequest.targetLobbyName());
-        if (lobbyProvider == null) {
-            return new RouteResult(false,
-                    Component.text("No lobbies exist under the name " + routeRequest.targetLobbyName() + "."));
-        }
-
-        LobbyJoinRequest joinRequest = routeRequest.joinRequest();
-        Optional<Lobby> lobbyOptional = lobbyProvider.provideScene(joinRequest);
-        if (lobbyOptional.isPresent()) {
-            Lobby lobby = lobbyOptional.get();
-            RouteResult result = lobby.join(joinRequest);
-            if (result.success()) {
-                for (PlayerView playerView : routeRequest.joinRequest().getPlayers()) {
-                    Lobby oldLobby = playerLobbyMap.get(playerView.getUUID());
-                    if (oldLobby != null && oldLobby != lobby) {
-                        oldLobby.leave(List.of(playerView.getUUID()));
-                    }
-
-                    playerLobbyMap.put(playerView.getUUID(), lobby);
-                }
-            }
-
-            return result;
+    public @NotNull Collection<Lobby> getScenes() {
+        Collection<Lobby> scenes = new ArrayList<>();
+        for (SceneProvider<Lobby, LobbyJoinRequest> sceneProvider : lobbyProviders.values()) {
+            scenes.addAll(sceneProvider.getScenes());
         }
 
-        return new RouteResult(false, Component.text("No lobbies are joinable."));
+        return scenes;
     }
 
     @Override
-    public @NotNull RouteResult leave(@NotNull Iterable<UUID> leavers) {
-        for (UUID uuid : leavers) {
-            if (!playerLobbyMap.containsKey(uuid)) {
-                return new RouteResult(false, Component.text(uuid + " is not part of a scene in the lobby router."));
+    public @NotNull Optional<Lobby> getCurrentScene(@NotNull UUID playerUUID) {
+        for (SceneProvider<Lobby, LobbyJoinRequest> sceneProvider : lobbyProviders.values()) {
+            for (Lobby lobby : sceneProvider.getScenes()) {
+                if (lobby.getPlayers().containsKey(playerUUID)) {
+                    return Optional.of(lobby);
+                }
             }
         }
 
-        for (UUID uuid : leavers) {
-            playerLobbyMap.get(uuid).leave(List.of(uuid));
-        }
-
-        return RouteResult.SUCCESSFUL;
+        return Optional.empty();
     }
 
     @Override
-    public @UnmodifiableView @NotNull Map<UUID, PlayerView> getPlayers() {
-        return unmodifiablePlayers;
+    public @NotNull Collection<Lobby> getScenesContainingPlayer(@NotNull UUID playerUUID) {
+        return getCurrentScene(playerUUID).map(Collections::singleton).orElse(Collections.emptySet());
     }
 
     @Override
-    public int getIngamePlayerCount() {
-        int playerCount = 0;
-
-        for (SceneProvider<Lobby, LobbyJoinRequest> lobbyProvider : lobbyProviders.values()) {
-            for (Lobby lobby : lobbyProvider.getScenes()) {
-                playerCount += lobby.getPlayers().size();
-            }
+    public @NotNull RouteResult<Lobby> findScene(@NotNull LobbyRouteRequest routeRequest) {
+        if (isShutdown()) {
+            return RouteResult.failure(Component.text("The router is shutdown."));
+        }
+        if (!isJoinable()) {
+            return RouteResult.failure(Component.text("The router is not joinable."));
         }
 
-        return playerCount;
-    }
+        SceneProvider<Lobby, LobbyJoinRequest> lobbyProvider = lobbyProviders.get(routeRequest.targetLobbyName());
+        if (lobbyProvider == null) {
+            return RouteResult.failure(
+                    Component.text("No lobbies exist under the name " + routeRequest.targetLobbyName() + "."));
+        }
 
-    @Override
-    public int getJoinWeight(@NotNull LobbyRouteRequest request) {
-        return -(getIngamePlayerCount() + request.getRequestWeight());
+        return lobbyProvider.provideScene(routeRequest.joinRequest()).map(RouteResult::success)
+                .orElseGet(() -> RouteResult.failure(Component.text("No lobbies are joinable.")));
     }
 
     @Override
@@ -155,7 +86,6 @@ public void shutdown() {
         for (SceneProvider<Lobby, LobbyJoinRequest> lobbyProvider : lobbyProviders.values()) {
             lobbyProvider.forceShutdown();
         }
-        playerLobbyMap.clear();
 
         shutdown = true;
     }
@@ -170,6 +100,22 @@ public void setJoinable(boolean joinable) {
         this.joinable = joinable;
     }
 
+    @Override
+    public boolean isGame() {
+        return false;
+    }
+
+    @Override
+    public boolean hasActiveScenes() {
+        for (SceneProvider<Lobby, LobbyJoinRequest> sceneProvider : lobbyProviders.values()) {
+            if (sceneProvider.hasActiveScenes()) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
     @Override
     public void tick(long time) {
         for (SceneProvider<Lobby, LobbyJoinRequest> sceneProvider : lobbyProviders.values()) {
diff --git a/core/src/main/java/org/phantazm/core/game/scene/lobby/LobbyRouterFallback.java b/core/src/main/java/org/phantazm/core/game/scene/lobby/LobbyRouterFallback.java
index c8c29dc5f..3a67dd5e0 100644
--- a/core/src/main/java/org/phantazm/core/game/scene/lobby/LobbyRouterFallback.java
+++ b/core/src/main/java/org/phantazm/core/game/scene/lobby/LobbyRouterFallback.java
@@ -2,11 +2,13 @@
 
 import net.minestom.server.network.ConnectionManager;
 import org.jetbrains.annotations.NotNull;
+import org.phantazm.core.game.scene.TransferResult;
 import org.phantazm.core.game.scene.fallback.SceneFallback;
 import org.phantazm.core.player.PlayerView;
 
-import java.util.List;
+import java.util.Collections;
 import java.util.Objects;
+import java.util.Optional;
 
 /**
  * A {@link SceneFallback} which routes to a lobby.
@@ -34,9 +36,21 @@ public LobbyRouterFallback(@NotNull ConnectionManager connectionManager, @NotNul
 
     @Override
     public boolean fallback(@NotNull PlayerView player) {
-        return lobbyRouter.join(
-                        new LobbyRouteRequest(lobbyName, new BasicLobbyJoinRequest(connectionManager, List.of(player))))
-                .success();
+        LobbyJoinRequest joinRequest = new BasicLobbyJoinRequest(connectionManager, Collections.singleton(player));
+        LobbyRouteRequest routeRequest = new LobbyRouteRequest(lobbyName, joinRequest);
+        Optional<Lobby> lobbyOptional = lobbyRouter.findScene(routeRequest).scene();
+        if (lobbyOptional.isEmpty()) {
+            return false;
+        }
+
+        Lobby lobby = lobbyOptional.get();
+        TransferResult result = lobby.join(joinRequest);
+        if (result.executor().isEmpty()) {
+            return false;
+        }
+
+        result.executor().get().run();
+        return true;
     }
 
 }
diff --git a/core/src/main/java/org/phantazm/core/game/scene/lobby/LoginLobbyJoinRequest.java b/core/src/main/java/org/phantazm/core/game/scene/lobby/LoginLobbyJoinRequest.java
index 13128ae2c..f661db0b6 100644
--- a/core/src/main/java/org/phantazm/core/game/scene/lobby/LoginLobbyJoinRequest.java
+++ b/core/src/main/java/org/phantazm/core/game/scene/lobby/LoginLobbyJoinRequest.java
@@ -9,6 +9,7 @@
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.UnmodifiableView;
 import org.phantazm.core.config.InstanceConfig;
+import org.phantazm.core.game.scene.Utils;
 import org.phantazm.core.player.PlayerView;
 import org.phantazm.core.player.PlayerViewProvider;
 
@@ -21,8 +22,6 @@
  */
 public class LoginLobbyJoinRequest implements LobbyJoinRequest {
 
-    private final ConnectionManager connectionManager;
-
     private final PlayerLoginEvent event;
 
     private final PlayerViewProvider viewProvider;
@@ -33,9 +32,7 @@ public class LoginLobbyJoinRequest implements LobbyJoinRequest {
      * @param event        The {@link PlayerLoginEvent} associated with the new player
      * @param viewProvider The {@link PlayerViewProvider} for the server
      */
-    public LoginLobbyJoinRequest(@NotNull ConnectionManager connectionManager, @NotNull PlayerLoginEvent event,
-            @NotNull PlayerViewProvider viewProvider) {
-        this.connectionManager = Objects.requireNonNull(connectionManager, "connectionManager");
+    public LoginLobbyJoinRequest(@NotNull PlayerLoginEvent event, @NotNull PlayerViewProvider viewProvider) {
         this.event = Objects.requireNonNull(event, "event");
         this.viewProvider = Objects.requireNonNull(viewProvider, "viewProvider");
     }
@@ -51,21 +48,4 @@ public void handleJoin(@NotNull Instance instance, @NotNull InstanceConfig insta
         event.getPlayer().setRespawnPoint(instanceConfig.spawnPoint());
         event.getPlayer().setGameMode(GameMode.ADVENTURE);
     }
-
-    /**
-     * Handles when the player's login is complete.
-     * This should be fired from a handler to a {@link PlayerSpawnEvent}, as this occurs when a player
-     * has spawned for the first time.
-     */
-    public void onPlayerLoginComplete() {
-        for (Player otherPlayer : connectionManager.getOnlinePlayers()) {
-            if (otherPlayer.getInstance() != event.getSpawningInstance()) {
-                otherPlayer.removeViewer(event.getPlayer());
-                event.getPlayer().sendPacket(otherPlayer.getRemovePlayerToList());
-                event.getPlayer().removeViewer(otherPlayer);
-                otherPlayer.sendPacket(event.getPlayer().getRemovePlayerToList());
-            }
-        }
-    }
-
 }
diff --git a/core/src/main/java/org/phantazm/core/guild/GuildHolder.java b/core/src/main/java/org/phantazm/core/guild/GuildHolder.java
new file mode 100644
index 000000000..fe65e3f5f
--- /dev/null
+++ b/core/src/main/java/org/phantazm/core/guild/GuildHolder.java
@@ -0,0 +1,11 @@
+package org.phantazm.core.guild;
+
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Collection;
+import java.util.Map;
+import java.util.UUID;
+
+public record GuildHolder<TGuild>(@NotNull Map<? super UUID, TGuild> uuidToGuild, @NotNull Collection<TGuild> guilds) {
+
+}
diff --git a/core/src/main/java/org/phantazm/core/guild/invite/InvitationManager.java b/core/src/main/java/org/phantazm/core/guild/invite/InvitationManager.java
index 5ad25e697..668b32be8 100644
--- a/core/src/main/java/org/phantazm/core/guild/invite/InvitationManager.java
+++ b/core/src/main/java/org/phantazm/core/guild/invite/InvitationManager.java
@@ -40,21 +40,21 @@ public InvitationManager(@NotNull GuildMemberManager<TMember> memberManager,
     public void tick(long time) {
         ++ticks;
 
-        for (Invitation invitation = invitations.poll(); invitation != null; invitation = invitations.poll()) {
-            if (invitation.expirationTime() > ticks) {
-                break;
-            }
-
+        Invitation invitation = invitations.peek();
+        while (invitation != null && invitation.expirationTime <= ticks) {
             if (latestInviteTimes.getLong(invitation.invitee().getUUID()) == invitation.expirationTime()) {
                 latestInviteTimes.removeLong(invitation.invitee().getUUID());
             }
             notification.notifyExpiry(invitation.invitee());
+
+            invitations.remove();
+            invitation = invitations.peek();
         }
     }
 
     public void invite(@NotNull TMember inviter, @NotNull PlayerView invitee) {
         if (invitationDuration == 0) {
-            notification.notifyInvitation(inviter, invitee);
+            notification.notifyInvitation(inviter, invitee, invitationDuration);
             notification.notifyExpiry(invitee);
             return;
         }
@@ -62,7 +62,7 @@ public void invite(@NotNull TMember inviter, @NotNull PlayerView invitee) {
         long expirationTime = ticks + invitationDuration;
         invitations.add(new Invitation(invitee, expirationTime));
         latestInviteTimes.put(invitee.getUUID(), expirationTime);
-        notification.notifyInvitation(inviter, invitee);
+        notification.notifyInvitation(inviter, invitee, invitationDuration);
     }
 
     public boolean hasInvitation(@NotNull UUID candidate) {
diff --git a/core/src/main/java/org/phantazm/core/guild/invite/InvitationNotification.java b/core/src/main/java/org/phantazm/core/guild/invite/InvitationNotification.java
index e27b7738f..c2b1d9e2d 100644
--- a/core/src/main/java/org/phantazm/core/guild/invite/InvitationNotification.java
+++ b/core/src/main/java/org/phantazm/core/guild/invite/InvitationNotification.java
@@ -8,7 +8,7 @@ public interface InvitationNotification<TMember extends GuildMember> {
 
     void notifyJoin(@NotNull TMember member);
 
-    void notifyInvitation(@NotNull TMember inviter, @NotNull PlayerView invitee);
+    void notifyInvitation(@NotNull TMember inviter, @NotNull PlayerView invitee, long invitationDuration);
 
     void notifyExpiry(@NotNull PlayerView invitee);
 
diff --git a/core/src/main/java/org/phantazm/core/guild/party/Party.java b/core/src/main/java/org/phantazm/core/guild/party/Party.java
index 1dfd9d84e..0c55924e4 100644
--- a/core/src/main/java/org/phantazm/core/guild/party/Party.java
+++ b/core/src/main/java/org/phantazm/core/guild/party/Party.java
@@ -7,6 +7,7 @@
 import org.phantazm.core.guild.Guild;
 import org.phantazm.core.guild.GuildMemberManager;
 import org.phantazm.core.guild.invite.InvitationManager;
+import org.phantazm.core.guild.party.notification.PartyNotification;
 import org.phantazm.core.guild.permission.MultipleMemberPermission;
 import org.phantazm.core.guild.permission.SingleMemberPermission;
 import org.phantazm.core.player.PlayerView;
@@ -26,19 +27,23 @@ public class Party extends Guild<PartyMember> implements Tickable {
 
     private final SingleMemberPermission<PartyMember> invitePermission;
 
+    private final SingleMemberPermission<PartyMember> joinPermission;
+
     private final Wrapper<PartyMember> owner;
 
     public Party(@NotNull GuildMemberManager<PartyMember> memberManager,
             @NotNull Function<? super PlayerView, ? extends PartyMember> memberCreator, @NotNull Audience audience,
             @NotNull PartyNotification notification, @NotNull InvitationManager<PartyMember> invitationManager,
             @NotNull MultipleMemberPermission<PartyMember> kickPermission,
-            @NotNull SingleMemberPermission<PartyMember> invitePermission, @NotNull Wrapper<PartyMember> owner) {
+            @NotNull SingleMemberPermission<PartyMember> invitePermission,
+            @NotNull SingleMemberPermission<PartyMember> joinPermission, @NotNull Wrapper<PartyMember> owner) {
         super(memberManager, memberCreator);
         this.audience = Objects.requireNonNull(audience, "audience");
         this.notification = Objects.requireNonNull(notification, "notification");
         this.invitationManager = Objects.requireNonNull(invitationManager, "invitationManager");
         this.kickPermission = Objects.requireNonNull(kickPermission, "kickPermission");
         this.invitePermission = Objects.requireNonNull(invitePermission, "invitePermission");
+        this.joinPermission = Objects.requireNonNull(joinPermission, "joinPermission");
         this.owner = Objects.requireNonNull(owner, "owner");
     }
 
@@ -62,6 +67,10 @@ public Party(@NotNull GuildMemberManager<PartyMember> memberManager,
         return invitePermission;
     }
 
+    public @NotNull SingleMemberPermission<PartyMember> getJoinPermission() {
+        return joinPermission;
+    }
+
     public @NotNull Wrapper<PartyMember> getOwner() {
         return owner;
     }
diff --git a/core/src/main/java/org/phantazm/core/guild/party/PartyConfig.java b/core/src/main/java/org/phantazm/core/guild/party/PartyConfig.java
new file mode 100644
index 000000000..7457c5d61
--- /dev/null
+++ b/core/src/main/java/org/phantazm/core/guild/party/PartyConfig.java
@@ -0,0 +1,10 @@
+package org.phantazm.core.guild.party;
+
+import org.jetbrains.annotations.NotNull;
+import org.phantazm.core.guild.party.command.PartyCommandConfig;
+import org.phantazm.core.guild.party.notification.PartyNotificationConfig;
+
+public record PartyConfig(@NotNull PartyNotificationConfig notificationConfig,
+                          @NotNull PartyCommandConfig commandConfig, int creatorRank, int defaultRank, long invitationDuration, int minimumKickRank, int minimumInviteRank,
+                          int minimumJoinRank) {
+}
diff --git a/core/src/main/java/org/phantazm/core/guild/party/PartyCreator.java b/core/src/main/java/org/phantazm/core/guild/party/PartyCreator.java
index b8c5f81b6..d09b2d440 100644
--- a/core/src/main/java/org/phantazm/core/guild/party/PartyCreator.java
+++ b/core/src/main/java/org/phantazm/core/guild/party/PartyCreator.java
@@ -2,22 +2,34 @@
 
 import com.github.steanky.toolkit.collection.Wrapper;
 import net.kyori.adventure.audience.Audience;
+import net.kyori.adventure.text.minimessage.MiniMessage;
 import org.jetbrains.annotations.NotNull;
 import org.phantazm.core.guild.GuildMemberManager;
 import org.phantazm.core.guild.invite.InvitationManager;
+import org.phantazm.core.guild.party.notification.PartyNotification;
+import org.phantazm.core.guild.party.notification.PartyNotificationConfig;
 import org.phantazm.core.guild.permission.MultipleMemberPermission;
 import org.phantazm.core.guild.permission.RankMultipleMemberPermission;
 import org.phantazm.core.guild.permission.RankSingleMemberPermission;
 import org.phantazm.core.guild.permission.SingleMemberPermission;
 import org.phantazm.core.player.PlayerView;
+import org.phantazm.core.time.AnalogTickFormatter;
+import org.phantazm.core.time.TickFormatter;
 
 import java.util.HashMap;
 import java.util.Map;
+import java.util.Objects;
 import java.util.UUID;
 import java.util.function.Function;
 
 public class PartyCreator {
 
+    private final PartyNotificationConfig notificationConfig;
+
+    private final MiniMessage miniMessage;
+
+    private final TickFormatter tickFormatter;
+
     private final int creatorRank;
 
     private final int defaultRank;
@@ -28,13 +40,20 @@ public class PartyCreator {
 
     private final int minimumInviteRank;
 
-    public PartyCreator(int creatorRank, int defaultRank, long invitationDuration, int minimumKickRank,
-            int minimumInviteRank) {
+    private final int minimumJoinRank;
+
+    public PartyCreator(@NotNull PartyNotificationConfig notificationConfig, @NotNull TickFormatter tickFormatter,
+            @NotNull MiniMessage miniMessage, int creatorRank, int defaultRank, long invitationDuration,
+            int minimumKickRank, int minimumInviteRank, int minimumJoinRank) {
+        this.notificationConfig = Objects.requireNonNull(notificationConfig, "notificationConfig");
+        this.tickFormatter = Objects.requireNonNull(tickFormatter, "tickFormatter");
+        this.miniMessage = Objects.requireNonNull(miniMessage, "miniMessage");
         this.creatorRank = creatorRank;
         this.defaultRank = defaultRank;
         this.invitationDuration = invitationDuration;
         this.minimumKickRank = minimumKickRank;
         this.minimumInviteRank = minimumInviteRank;
+        this.minimumJoinRank = minimumJoinRank;
     }
 
     public @NotNull Party createPartyFor(@NotNull PlayerView playerView) {
@@ -48,18 +67,129 @@ public PartyCreator(int creatorRank, int defaultRank, long invitationDuration, i
 
         Function<? super PlayerView, ? extends PartyMember> memberCreator = this::createMember;
         Audience audience = new PartyAudience(members.values());
-        PartyNotification notification = new PartyNotification(members.values(), ownerWrapper);
+        PartyNotification notification =
+                new PartyNotification(members.values(), ownerWrapper, notificationConfig, tickFormatter, miniMessage);
         InvitationManager<PartyMember> invitationManager =
                 new InvitationManager<>(memberManager, memberCreator, notification, invitationDuration);
         MultipleMemberPermission<PartyMember> kickPermission = new RankMultipleMemberPermission<>(minimumKickRank);
         SingleMemberPermission<PartyMember> invitePermission = new RankSingleMemberPermission<>(minimumInviteRank);
+        SingleMemberPermission<PartyMember> joinPermission = new RankSingleMemberPermission<>(minimumJoinRank);
 
         return new Party(memberManager, memberCreator, audience, notification, invitationManager, kickPermission,
-                invitePermission, ownerWrapper);
+                invitePermission, joinPermission, ownerWrapper);
     }
 
     private PartyMember createMember(PlayerView playerView) {
         return new PartyMember(playerView, defaultRank);
     }
 
+    public static class Builder {
+
+        private PartyNotificationConfig notificationConfig =
+                new PartyNotificationConfig("", "", "", "", "", "", "", "", "", "", "", "");
+
+        private TickFormatter tickFormatter = new AnalogTickFormatter(new AnalogTickFormatter.Data(false));
+
+        private MiniMessage miniMessage = MiniMessage.miniMessage();
+
+        private int creatorRank = 1;
+
+        private int defaultRank = 0;
+
+        private long invitationDuration = 1200;
+
+        private int minimumKickRank = 1;
+
+        private int minimumInviteRank = 1;
+
+        private int minimumJoinRank = 1;
+
+        public @NotNull PartyNotificationConfig getNotificationConfig() {
+            return notificationConfig;
+        }
+
+        public @NotNull Builder setNotificationConfig(@NotNull PartyNotificationConfig notificationConfig) {
+            this.notificationConfig = Objects.requireNonNull(notificationConfig, "notificationConfig");
+            return this;
+        }
+
+        public @NotNull TickFormatter getTickFormatter() {
+            return tickFormatter;
+        }
+
+        public @NotNull Builder setTickFormatter(@NotNull TickFormatter tickFormatter) {
+            this.tickFormatter = Objects.requireNonNull(tickFormatter, "tickFormatter");
+            return this;
+        }
+
+        public @NotNull MiniMessage getMiniMessage() {
+            return miniMessage;
+        }
+
+        public @NotNull Builder setMiniMessage(@NotNull MiniMessage miniMessage) {
+            this.miniMessage = Objects.requireNonNull(miniMessage, "miniMessage");
+            return this;
+        }
+
+        public int getCreatorRank() {
+            return creatorRank;
+        }
+
+        public @NotNull Builder setCreatorRank(int creatorRank) {
+            this.creatorRank = creatorRank;
+            return this;
+        }
+
+        public int getDefaultRank() {
+            return defaultRank;
+        }
+
+        public @NotNull Builder setDefaultRank(int defaultRank) {
+            this.defaultRank = defaultRank;
+            return this;
+        }
+
+        public long getInvitationDuration() {
+            return invitationDuration;
+        }
+
+        public @NotNull Builder setInvitationDuration(long invitationDuration) {
+            this.invitationDuration = invitationDuration;
+            return this;
+        }
+
+        public int getMinimumKickRank() {
+            return minimumKickRank;
+        }
+
+        public @NotNull Builder setMinimumKickRank(int minimumKickRank) {
+            this.minimumKickRank = minimumKickRank;
+            return this;
+        }
+
+        public int getMinimumInviteRank() {
+            return minimumInviteRank;
+        }
+
+        public @NotNull Builder setMinimumInviteRank(int minimumInviteRank) {
+            this.minimumInviteRank = minimumInviteRank;
+            return this;
+        }
+
+        public int getMinimumJoinRank() {
+            return minimumJoinRank;
+        }
+
+        public @NotNull Builder setMinimumJoinRank(int minimumJoinRank) {
+            this.minimumJoinRank = minimumJoinRank;
+            return this;
+        }
+
+        public @NotNull PartyCreator build() {
+            return new PartyCreator(notificationConfig, tickFormatter, miniMessage, creatorRank, defaultRank,
+                    invitationDuration, minimumKickRank, minimumInviteRank, minimumJoinRank);
+        }
+
+    }
+
 }
diff --git a/core/src/main/java/org/phantazm/core/guild/party/PartyNotification.java b/core/src/main/java/org/phantazm/core/guild/party/PartyNotification.java
deleted file mode 100644
index 5d3d70fff..000000000
--- a/core/src/main/java/org/phantazm/core/guild/party/PartyNotification.java
+++ /dev/null
@@ -1,150 +0,0 @@
-package org.phantazm.core.guild.party;
-
-import com.github.steanky.toolkit.collection.Wrapper;
-import net.kyori.adventure.audience.Audience;
-import net.kyori.adventure.audience.ForwardingAudience;
-import net.kyori.adventure.text.Component;
-import net.kyori.adventure.text.ComponentLike;
-import net.kyori.adventure.text.event.ClickEvent;
-import net.kyori.adventure.text.format.NamedTextColor;
-import org.jetbrains.annotations.NotNull;
-import org.phantazm.core.guild.invite.InvitationNotification;
-import org.phantazm.core.player.PlayerView;
-
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.Objects;
-import java.util.concurrent.CompletableFuture;
-
-public class PartyNotification implements InvitationNotification<PartyMember> {
-
-    private final Audience audience;
-
-    private final Wrapper<PartyMember> owner;
-
-    public PartyNotification(@NotNull Collection<? extends PartyMember> partyMembers,
-            @NotNull Wrapper<PartyMember> owner) {
-        Objects.requireNonNull(partyMembers, "partyMembers");
-        this.audience = (ForwardingAudience)() -> {
-            Collection<Audience> audiences = new ArrayList<>(partyMembers.size());
-
-            for (PartyMember member : partyMembers) {
-                member.getPlayerView().getPlayer().ifPresent(audiences::add);
-            }
-
-            return audiences;
-        };
-        this.owner = Objects.requireNonNull(owner, "owner");
-    }
-
-    @Override
-    public void notifyJoin(@NotNull PartyMember newMember) {
-        newMember.getPlayerView().getDisplayName().thenAccept(displayName -> {
-            ComponentLike message = Component.text().append(displayName, Component.text(" has joined the party."))
-                    .color(NamedTextColor.GOLD);
-            audience.sendMessage(message);
-        });
-
-        owner.get().getPlayerView().getDisplayName().thenAccept(displayName -> {
-            newMember.getPlayerView().getPlayer().ifPresent(player -> {
-                ComponentLike message =
-                        Component.text().append(Component.text("Joined "), displayName, Component.text("'s party."))
-                                .color(NamedTextColor.GREEN);
-                player.sendMessage(message);
-            });
-        });
-    }
-
-    @Override
-    public void notifyInvitation(@NotNull PartyMember inviter, @NotNull PlayerView invitee) {
-        CompletableFuture<? extends Component> inviterName = inviter.getPlayerView().getDisplayName();
-        CompletableFuture<? extends Component> inviteeName = invitee.getDisplayName();
-
-        CompletableFuture.allOf(inviterName, inviteeName).thenRun(() -> {
-            ComponentLike message = Component.text()
-                    .append(inviterName.join(), Component.text(" has invited "), inviteeName.join(),
-                            Component.text(" to the party.")).color(NamedTextColor.GOLD);
-            audience.sendMessage(message);
-        });
-
-        if (inviter == owner.get()) {
-            inviterName.thenAccept(displayName -> {
-                invitee.getPlayer().ifPresent(player -> {
-                    ComponentLike message = Component.text()
-                            .append(displayName, Component.text(" has invited you to join their party. Click "),
-                                    Component.text("here", NamedTextColor.GOLD)
-                                            .clickEvent(ClickEvent.runCommand("/party join " + player.getUsername())),
-                                    Component.text(" to join!")).color(NamedTextColor.GOLD);
-                    player.sendMessage(message);
-                });
-            });
-        }
-        else {
-            CompletableFuture<String> ownerName = owner.get().getPlayerView().getUsername();
-            CompletableFuture<? extends Component> ownerDisplayName = owner.get().getPlayerView().getDisplayName();
-            CompletableFuture.allOf(ownerName, ownerDisplayName, inviterName).thenRun(() -> {
-                invitee.getPlayer().ifPresent(player -> {
-                    ComponentLike message = Component.text()
-                            .append(inviterName.join(), Component.text(" has invited you to join "),
-                                    ownerDisplayName.join(), Component.text("'s party. Click "),
-                                    Component.text("here", NamedTextColor.GOLD)
-                                            .clickEvent(ClickEvent.runCommand("/party join " + ownerName.join())),
-                                    Component.text(" to join!")).color(NamedTextColor.GOLD);
-                    player.sendMessage(message);
-                });
-            });
-        }
-    }
-
-    @Override
-    public void notifyExpiry(@NotNull PlayerView invitee) {
-        invitee.getDisplayName().thenAccept(displayName -> {
-            ComponentLike message = Component.text()
-                    .append(Component.text("The invitation to "), displayName, Component.text(" has expired."))
-                    .color(NamedTextColor.GOLD);
-            audience.sendMessage(message);
-        });
-
-        owner.get().getPlayerView().getDisplayName().thenAccept(displayName -> {
-            invitee.getPlayer().ifPresent(player -> {
-                ComponentLike message = Component.text().append(Component.text("The invitation to "), displayName,
-                        Component.text("'s party has expired.")).color(NamedTextColor.GOLD);
-                player.sendMessage(message);
-            });
-        });
-    }
-
-    public void notifyLeave(@NotNull PartyMember oldMember) {
-        oldMember.getPlayerView().getDisplayName().thenAccept(displayName -> {
-            ComponentLike message = Component.text().append(displayName, Component.text(" has left the party."))
-                    .color(NamedTextColor.GOLD);
-            audience.sendMessage(message);
-        });
-
-        oldMember.getPlayerView().getPlayer().ifPresent(player -> {
-            player.sendMessage(Component.text("Left the party.", NamedTextColor.GREEN));
-        });
-    }
-
-    public void notifyKick(@NotNull PartyMember kicker, @NotNull PartyMember toKick) {
-        CompletableFuture<? extends Component> kickerName = kicker.getPlayerView().getDisplayName();
-        CompletableFuture<? extends Component> toKickName = toKick.getPlayerView().getDisplayName();
-
-        CompletableFuture.allOf(kickerName, toKickName).thenRun(() -> {
-            ComponentLike message = Component.text()
-                    .append(toKickName.join(), Component.text(" was kicked by "), kickerName.join(),
-                            Component.text(".")).color(NamedTextColor.GOLD);
-            audience.sendMessage(message);
-        });
-
-        kickerName.thenAccept(name -> {
-            toKick.getPlayerView().getPlayer().ifPresent(player -> {
-                ComponentLike message =
-                        Component.text().append(Component.text("You were kicked by "), name, Component.text("."))
-                                .color(NamedTextColor.GOLD);
-                player.sendMessage(message);
-            });
-        });
-    }
-
-}
diff --git a/core/src/main/java/org/phantazm/core/guild/party/command/PartyCommand.java b/core/src/main/java/org/phantazm/core/guild/party/command/PartyCommand.java
index 284d575ea..04a0a9379 100644
--- a/core/src/main/java/org/phantazm/core/guild/party/command/PartyCommand.java
+++ b/core/src/main/java/org/phantazm/core/guild/party/command/PartyCommand.java
@@ -1,24 +1,34 @@
 package org.phantazm.core.guild.party.command;
 
+import net.kyori.adventure.text.minimessage.MiniMessage;
 import net.minestom.server.command.builder.Command;
 import org.jetbrains.annotations.NotNull;
+import org.phantazm.core.guild.GuildHolder;
 import org.phantazm.core.guild.party.Party;
 import org.phantazm.core.guild.party.PartyCreator;
 import org.phantazm.core.player.PlayerViewProvider;
 
-import java.util.Map;
-import java.util.UUID;
+import java.util.Random;
 
 public class PartyCommand {
 
-    public static Command command(@NotNull Map<? super UUID, Party> parties, @NotNull PlayerViewProvider viewProvider,
-            @NotNull PartyCreator partyCreator) {
+    private PartyCommand() {
+        throw new UnsupportedOperationException();
+    }
+
+    public static @NotNull Command partyCommand(@NotNull PartyCommandConfig config, @NotNull MiniMessage miniMessage,
+            @NotNull GuildHolder<Party> partyHolder, @NotNull PlayerViewProvider viewProvider,
+            @NotNull PartyCreator partyCreator, @NotNull Random random) {
         Command command = new Command("party", "p");
-        command.addSubcommand(PartyCreateCommand.createCommand(parties, viewProvider, partyCreator));
-        command.addSubcommand(PartyJoinCommand.joinCommand(parties, viewProvider));
-        command.addSubcommand(PartyLeaveCommand.leaveCommand(parties));
-        command.addSubcommand(PartyKickCommand.kickCommand(parties, viewProvider));
-        command.addSubcommand(PartyInviteCommand.inviteCommand(parties, viewProvider));
+        command.addSubcommand(PartyCreateCommand.createCommand(config, partyHolder, viewProvider, partyCreator));
+        command.addSubcommand(
+                PartyJoinCommand.joinCommand(config, miniMessage, partyHolder.uuidToGuild(), viewProvider));
+        command.addSubcommand(PartyLeaveCommand.leaveCommand(config, partyHolder.uuidToGuild(), random));
+        command.addSubcommand(PartyKickCommand.kickCommand(config, miniMessage, partyHolder.uuidToGuild(),
+                viewProvider));
+        command.addSubcommand(
+                PartyInviteCommand.inviteCommand(config, miniMessage, partyHolder, viewProvider, partyCreator));
+        command.addSubcommand(PartyListCommand.listCommand(config, miniMessage, partyHolder.uuidToGuild()));
 
         return command;
     }
diff --git a/core/src/main/java/org/phantazm/core/guild/party/command/PartyCommandConfig.java b/core/src/main/java/org/phantazm/core/guild/party/command/PartyCommandConfig.java
new file mode 100644
index 000000000..c86e2e115
--- /dev/null
+++ b/core/src/main/java/org/phantazm/core/guild/party/command/PartyCommandConfig.java
@@ -0,0 +1,25 @@
+package org.phantazm.core.guild.party.command;
+
+import net.kyori.adventure.text.Component;
+import org.jetbrains.annotations.NotNull;
+
+public record PartyCommandConfig(@NotNull Component notInParty,
+                                 @NotNull Component alreadyInParty,
+                                 @NotNull Component mustBeAPlayer,
+                                 @NotNull String playerNotOnlineFormat,
+                                 @NotNull String cannotFindPlayerFormat,
+                                 @NotNull Component createCommandSuccess,
+                                 @NotNull Component cannotInvitePlayers,
+                                 @NotNull Component automaticPartyCreation,
+                                 @NotNull Component cannotInviteSelf,
+                                 @NotNull String inviteeAlreadyInPartyFormat,
+                                 @NotNull String toJoinNotInParty,
+                                 @NotNull Component noInvite,
+                                 @NotNull Component cannotKickMembers,
+                                 @NotNull String toKickNotInPartyFormat,
+                                 @NotNull Component cannotKickSelf,
+                                 @NotNull String cannotKickOtherFormat,
+                                 @NotNull String listFormat,
+                                 @NotNull String onlineMemberFormat,
+                                 @NotNull String offlineMemberFormat) {
+}
diff --git a/core/src/main/java/org/phantazm/core/guild/party/command/PartyCreateCommand.java b/core/src/main/java/org/phantazm/core/guild/party/command/PartyCreateCommand.java
index 5901a958e..a9214c68b 100644
--- a/core/src/main/java/org/phantazm/core/guild/party/command/PartyCreateCommand.java
+++ b/core/src/main/java/org/phantazm/core/guild/party/command/PartyCreateCommand.java
@@ -5,19 +5,24 @@
 import net.minestom.server.command.builder.Command;
 import net.minestom.server.entity.Player;
 import org.jetbrains.annotations.NotNull;
+import org.phantazm.core.guild.GuildHolder;
 import org.phantazm.core.guild.party.Party;
 import org.phantazm.core.guild.party.PartyCreator;
 import org.phantazm.core.player.PlayerViewProvider;
 
-import java.util.Map;
 import java.util.Objects;
-import java.util.UUID;
 
 public class PartyCreateCommand {
 
-    public static Command createCommand(@NotNull Map<? super UUID, Party> parties,
-            @NotNull PlayerViewProvider viewProvider, @NotNull PartyCreator partyCreator) {
-        Objects.requireNonNull(parties, "parties");
+    private PartyCreateCommand() {
+        throw new UnsupportedOperationException();
+    }
+
+    public static @NotNull Command createCommand(@NotNull PartyCommandConfig config,
+            @NotNull GuildHolder<Party> partyHolder, @NotNull PlayerViewProvider viewProvider,
+            @NotNull PartyCreator partyCreator) {
+        Objects.requireNonNull(config, "config");
+        Objects.requireNonNull(partyHolder, "partyHolder");
         Objects.requireNonNull(viewProvider, "viewProvider");
         Objects.requireNonNull(partyCreator, "partyCreator");
 
@@ -28,22 +33,24 @@ public static Command createCommand(@NotNull Map<? super UUID, Party> parties,
             }
 
             if (!(sender instanceof Player player)) {
-                sender.sendMessage(Component.text("You have to be a player to use that command!", NamedTextColor.RED));
+                sender.sendMessage(config.mustBeAPlayer());
                 return false;
             }
 
-            Party party = parties.get(player.getUuid());
+            Party party = partyHolder.uuidToGuild().get(player.getUuid());
             if (party != null) {
-                sender.sendMessage(Component.text("You are already in a party!", NamedTextColor.RED));
+                sender.sendMessage(config.alreadyInParty());
                 return false;
             }
 
             return true;
         }, (sender, context) -> {
             Player player = (Player)sender;
-            parties.put(player.getUuid(), partyCreator.createPartyFor(viewProvider.fromPlayer(player)));
+            Party party = partyCreator.createPartyFor(viewProvider.fromPlayer(player));
+            partyHolder.guilds().add(party);
+            partyHolder.uuidToGuild().put(player.getUuid(), party);
 
-            sender.sendMessage(Component.text("You are now in a party.", NamedTextColor.GREEN));
+            sender.sendMessage(config.createCommandSuccess());
         });
 
         return command;
diff --git a/core/src/main/java/org/phantazm/core/guild/party/command/PartyInviteCommand.java b/core/src/main/java/org/phantazm/core/guild/party/command/PartyInviteCommand.java
index a5ee4fb45..9fcd71f8c 100644
--- a/core/src/main/java/org/phantazm/core/guild/party/command/PartyInviteCommand.java
+++ b/core/src/main/java/org/phantazm/core/guild/party/command/PartyInviteCommand.java
@@ -1,26 +1,36 @@
 package org.phantazm.core.guild.party.command;
 
 import net.kyori.adventure.text.Component;
-import net.kyori.adventure.text.format.NamedTextColor;
+import net.kyori.adventure.text.minimessage.MiniMessage;
+import net.kyori.adventure.text.minimessage.tag.resolver.Placeholder;
+import net.kyori.adventure.text.minimessage.tag.resolver.TagResolver;
 import net.minestom.server.command.builder.Command;
 import net.minestom.server.command.builder.arguments.Argument;
 import net.minestom.server.command.builder.arguments.ArgumentType;
 import net.minestom.server.entity.Player;
 import org.jetbrains.annotations.NotNull;
+import org.phantazm.core.guild.GuildHolder;
 import org.phantazm.core.guild.party.Party;
+import org.phantazm.core.guild.party.PartyCreator;
 import org.phantazm.core.guild.party.PartyMember;
 import org.phantazm.core.player.PlayerViewProvider;
 
-import java.util.Map;
 import java.util.Objects;
-import java.util.UUID;
 
 public class PartyInviteCommand {
 
-    public static Command inviteCommand(@NotNull Map<? super UUID, ? extends Party> parties,
-            @NotNull PlayerViewProvider viewProvider) {
-        Objects.requireNonNull(parties, "parties");
+    private PartyInviteCommand() {
+        throw new UnsupportedOperationException();
+    }
+
+    public static @NotNull Command inviteCommand(@NotNull PartyCommandConfig config, @NotNull MiniMessage miniMessage,
+            @NotNull GuildHolder<Party> partyHolder, @NotNull PlayerViewProvider viewProvider,
+            @NotNull PartyCreator partyCreator) {
+        Objects.requireNonNull(config, "config");
+        Objects.requireNonNull(miniMessage, "miniMessage");
+        Objects.requireNonNull(partyHolder, "partyHolder");
         Objects.requireNonNull(viewProvider, "viewProvider");
+        Objects.requireNonNull(partyCreator, "partyCreator");
 
         Argument<String> nameArgument = ArgumentType.Word("name");
 
@@ -31,58 +41,66 @@ public static Command inviteCommand(@NotNull Map<? super UUID, ? extends Party>
             }
 
             if (!(sender instanceof Player player)) {
-                sender.sendMessage(Component.text("You have to be a player to use that command!", NamedTextColor.RED));
+                sender.sendMessage(config.mustBeAPlayer());
                 return false;
             }
 
-            Party party = parties.get(player.getUuid());
-            if (party == null) {
-                sender.sendMessage(Component.text("You have to be in a party!", NamedTextColor.RED));
-                return false;
-            }
-
-            PartyMember member = party.getMemberManager().getMember(player.getUuid());
-            if (!party.getInvitePermission().hasPermission(member)) {
-                sender.sendMessage(Component.text("You can't invite players!", NamedTextColor.RED));
-                return false;
+            Party party = partyHolder.uuidToGuild().get(player.getUuid());
+            if (party != null) {
+                PartyMember member = party.getMemberManager().getMember(player.getUuid());
+                if (!party.getInvitePermission().hasPermission(member)) {
+                    sender.sendMessage(config.cannotInvitePlayers());
+                    return false;
+                }
             }
 
             return true;
         }, (sender, context) -> {
             String name = context.get(nameArgument);
 
-            UUID uuid = ((Player) sender).getUuid();
-            Party inviterParty = parties.get(uuid);
-            PartyMember inviter = inviterParty.getMemberManager().getMember(uuid);
+            Player player = ((Player)sender);
+            Party tempParty = partyHolder.uuidToGuild().get(player.getUuid());
+            if (tempParty == null) {
+                tempParty = partyCreator.createPartyFor(viewProvider.fromPlayer(player));
+                partyHolder.guilds().add(tempParty);
+                partyHolder.uuidToGuild().put(player.getUuid(), tempParty);
+
+                sender.sendMessage(config.automaticPartyCreation());
+            }
+            Party inviterParty = tempParty;
+
+            PartyMember inviter = tempParty.getMemberManager().getMember(player.getUuid());
 
             viewProvider.fromName(name).thenAccept(playerViewOptional -> {
                 playerViewOptional.ifPresentOrElse(playerView -> {
-                    if (playerView.getUUID().equals(uuid)) {
-                        sender.sendMessage(Component.text("You can't invite yourself!", NamedTextColor.RED));
+                    if (playerView.getUUID().equals(player.getUuid())) {
+                        sender.sendMessage(config.cannotInviteSelf());
                         return;
                     }
 
-                    Party otherParty = parties.get(playerView.getUUID());
+                    Party otherParty = partyHolder.uuidToGuild().get(playerView.getUUID());
                     if (otherParty == inviterParty) {
                         playerView.getDisplayName().thenAccept(displayName -> {
-                            sender.sendMessage(Component.text().append(displayName,
-                                    Component.text(" is already in the party.").color(NamedTextColor.RED)));
+                            TagResolver inviteePlaceholder = Placeholder.component("invitee", displayName);
+                            Component message = miniMessage.deserialize(config.inviteeAlreadyInPartyFormat(),
+                                    inviteePlaceholder);
+                            sender.sendMessage(message);
                         });
                         return;
                     }
 
                     if (playerView.getPlayer().isEmpty()) {
                         playerView.getDisplayName().thenAccept(displayName -> {
-                            sender.sendMessage(Component.text().append(displayName,
-                                    Component.text(" is not online.")).color(NamedTextColor.RED));
+                            TagResolver playerPlaceholder = Placeholder.component("player", displayName);
+                            sender.sendMessage(miniMessage.deserialize(config.playerNotOnlineFormat(), playerPlaceholder));
                         });
                         return;
                     }
 
                     inviterParty.getInvitationManager().invite(inviter, playerView);
                 }, () -> {
-                    sender.sendMessage(
-                            Component.text("Can't find anyone with the username " + name + "!", NamedTextColor.RED));
+                    TagResolver usernamePlaceholder = Placeholder.unparsed("username", name);
+                    sender.sendMessage(miniMessage.deserialize(config.cannotFindPlayerFormat(), usernamePlaceholder));
                 });
             });
         }, nameArgument);
diff --git a/core/src/main/java/org/phantazm/core/guild/party/command/PartyJoinCommand.java b/core/src/main/java/org/phantazm/core/guild/party/command/PartyJoinCommand.java
index 3b1f112fa..1449edcff 100644
--- a/core/src/main/java/org/phantazm/core/guild/party/command/PartyJoinCommand.java
+++ b/core/src/main/java/org/phantazm/core/guild/party/command/PartyJoinCommand.java
@@ -1,14 +1,15 @@
 package org.phantazm.core.guild.party.command;
 
 import net.kyori.adventure.text.Component;
-import net.kyori.adventure.text.format.NamedTextColor;
+import net.kyori.adventure.text.minimessage.MiniMessage;
+import net.kyori.adventure.text.minimessage.tag.resolver.Placeholder;
+import net.kyori.adventure.text.minimessage.tag.resolver.TagResolver;
 import net.minestom.server.command.builder.Command;
 import net.minestom.server.command.builder.arguments.Argument;
 import net.minestom.server.command.builder.arguments.ArgumentType;
 import net.minestom.server.entity.Player;
 import org.jetbrains.annotations.NotNull;
 import org.phantazm.core.guild.party.Party;
-import org.phantazm.core.guild.party.PartyMember;
 import org.phantazm.core.player.PlayerViewProvider;
 
 import java.util.Map;
@@ -17,27 +18,32 @@
 
 public class PartyJoinCommand {
 
-    public static Command joinCommand(@NotNull Map<? super UUID, Party> parties,
-            @NotNull PlayerViewProvider viewProvider) {
-        Objects.requireNonNull(parties, "parties");
-        Objects.requireNonNull(viewProvider, "viewProvider");
+    private PartyJoinCommand() {
+        throw new UnsupportedOperationException();
+    }
 
-        Command command = new Command("join");
+    public static @NotNull Command joinCommand(@NotNull PartyCommandConfig config, @NotNull MiniMessage miniMessage,
+            @NotNull Map<? super UUID, Party> partyMap, @NotNull PlayerViewProvider viewProvider) {
+        Objects.requireNonNull(config, "config");
+        Objects.requireNonNull(miniMessage, "miniMessage");
+        Objects.requireNonNull(partyMap, "partyMap");
+        Objects.requireNonNull(viewProvider, "viewProvider");
 
         Argument<String> nameArgument = ArgumentType.Word("name");
+        Command command = new Command("join");
         command.addConditionalSyntax((sender, commandString) -> {
             if (commandString == null) {
                 return sender instanceof Player;
             }
 
             if (!(sender instanceof Player player)) {
-                sender.sendMessage(Component.text("You have to be a player to use that command!", NamedTextColor.RED));
+                sender.sendMessage(config.mustBeAPlayer());
                 return false;
             }
 
-            Party party = parties.get(player.getUuid());
+            Party party = partyMap.get(player.getUuid());
             if (party != null) {
-                sender.sendMessage(Component.text("You are already in a party!", NamedTextColor.GREEN));
+                sender.sendMessage(config.alreadyInParty());
                 return false;
             }
 
@@ -46,29 +52,32 @@ public static Command joinCommand(@NotNull Map<? super UUID, Party> parties,
             String name = context.get(nameArgument);
             viewProvider.fromName(name).thenAccept(playerViewOptional -> {
                 playerViewOptional.ifPresentOrElse(playerView -> {
-                    Party party = parties.get(playerView.getUUID());
+                    Party party = partyMap.get(playerView.getUUID());
                     if (party == null) {
                         playerView.getDisplayName().thenAccept(displayName -> {
-                            sender.sendMessage(Component.text().append(displayName,
-                                    Component.text(" is not in a party.").color(NamedTextColor.RED)));
+                            TagResolver targetPlaceholder = Placeholder.component("target", displayName);
+                            Component message = miniMessage.deserialize(config.toJoinNotInParty(), targetPlaceholder);
+                            sender.sendMessage(message);
                         });
                         return;
                     }
 
                     Player player = (Player)sender;
-                    Party previousParty = parties.get(player.getUuid());
+                    if (!party.getInvitationManager().hasInvitation(player.getUuid())) {
+                        sender.sendMessage(config.noInvite());
+                        return;
+                    }
+
+                    Party previousParty = partyMap.get(player.getUuid());
                     if (previousParty != null) {
                         previousParty.getMemberManager().removeMember(player.getUuid());
                     }
 
-                    PartyMember newMember = party.getMemberCreator().apply(viewProvider.fromPlayer(player));
-                    party.getMemberManager().addMember(newMember);
-                    parties.put(player.getUuid(), party);
-
-                    party.getNotification().notifyJoin(newMember);
+                    party.getInvitationManager().acceptInvitation(viewProvider.fromPlayer(player));
+                    partyMap.put(player.getUuid(), party);
                 }, () -> {
-                    sender.sendMessage(
-                            Component.text("Can't find anyone with the username " + name + "!", NamedTextColor.RED));
+                    TagResolver usernamePlaceholder = Placeholder.unparsed("username", name);
+                    sender.sendMessage(miniMessage.deserialize(config.cannotFindPlayerFormat(), usernamePlaceholder));
                 });
             });
         }, nameArgument);
diff --git a/core/src/main/java/org/phantazm/core/guild/party/command/PartyKickCommand.java b/core/src/main/java/org/phantazm/core/guild/party/command/PartyKickCommand.java
index b4546d54f..ce2948b6e 100644
--- a/core/src/main/java/org/phantazm/core/guild/party/command/PartyKickCommand.java
+++ b/core/src/main/java/org/phantazm/core/guild/party/command/PartyKickCommand.java
@@ -1,7 +1,9 @@
 package org.phantazm.core.guild.party.command;
 
 import net.kyori.adventure.text.Component;
-import net.kyori.adventure.text.format.NamedTextColor;
+import net.kyori.adventure.text.minimessage.MiniMessage;
+import net.kyori.adventure.text.minimessage.tag.resolver.Placeholder;
+import net.kyori.adventure.text.minimessage.tag.resolver.TagResolver;
 import net.minestom.server.command.builder.Command;
 import net.minestom.server.command.builder.arguments.Argument;
 import net.minestom.server.command.builder.arguments.ArgumentType;
@@ -19,9 +21,15 @@
 
 public class PartyKickCommand {
 
-    public static Command kickCommand(@NotNull Map<? super UUID, ? extends Party> parties,
-            @NotNull PlayerViewProvider viewProvider) {
-        Objects.requireNonNull(parties, "parties");
+    private PartyKickCommand() {
+        throw new UnsupportedOperationException();
+    }
+
+    public static @NotNull Command kickCommand(@NotNull PartyCommandConfig config, @NotNull MiniMessage miniMessage,
+            @NotNull Map<? super UUID, ? extends Party> partyMap, @NotNull PlayerViewProvider viewProvider) {
+        Objects.requireNonNull(config, "config");
+        Objects.requireNonNull(miniMessage, "miniMessage");
+        Objects.requireNonNull(partyMap, "partyMap");
         Objects.requireNonNull(viewProvider, "viewProvider");
 
         Command command = new Command("kick");
@@ -31,7 +39,7 @@ public static Command kickCommand(@NotNull Map<? super UUID, ? extends Party> pa
                 return;
             }
 
-            Party party = parties.get(player.getUuid());
+            Party party = partyMap.get(player.getUuid());
             if (party == null) {
                 return;
             }
@@ -57,19 +65,19 @@ public static Command kickCommand(@NotNull Map<? super UUID, ? extends Party> pa
             }
 
             if (!(sender instanceof Player player)) {
-                sender.sendMessage(Component.text("You have to be a player to use that command!", NamedTextColor.RED));
+                sender.sendMessage(config.mustBeAPlayer());
                 return false;
             }
 
-            Party party = parties.get(player.getUuid());
+            Party party = partyMap.get(player.getUuid());
             if (party == null) {
-                sender.sendMessage(Component.text("You have to be in a party!", NamedTextColor.RED));
+                sender.sendMessage(config.notInParty());
                 return false;
             }
 
             PartyMember member = party.getMemberManager().getMember(player.getUuid());
             if (!party.getKickPermission().hasPermission(member)) {
-                sender.sendMessage(Component.text("You can't kick members!", NamedTextColor.RED));
+                sender.sendMessage(config.cannotKickMembers());
                 return false;
             }
 
@@ -78,7 +86,7 @@ public static Command kickCommand(@NotNull Map<? super UUID, ? extends Party> pa
             String name = context.get(nameArgument);
 
             UUID uuid = ((Player)sender).getUuid();
-            Party party = parties.get(uuid);
+            Party party = partyMap.get(uuid);
             PartyMember kicker = party.getMemberManager().getMember(uuid);
 
             viewProvider.fromName(name).thenAccept(playerViewOptional -> {
@@ -86,32 +94,34 @@ public static Command kickCommand(@NotNull Map<? super UUID, ? extends Party> pa
                     PartyMember toKick = party.getMemberManager().getMember(playerView.getUUID());
                     if (toKick == null) {
                         playerView.getDisplayName().thenAccept(displayName -> {
-                            sender.sendMessage(
-                                    Component.text().append(displayName, Component.text(" is not in the party."))
-                                            .color(NamedTextColor.RED));
+                            TagResolver toKickPlaceholder = Placeholder.component("kicked", displayName);
+                            Component message =
+                                    miniMessage.deserialize(config.toKickNotInPartyFormat(), toKickPlaceholder);
+                            sender.sendMessage(message);
                         });
                         return;
                     }
 
                     if (toKick == kicker) {
-                        sender.sendMessage(Component.text("You can't kick yourself!", NamedTextColor.RED));
+                        sender.sendMessage(config.cannotKickSelf());
                     }
 
                     if (!party.getKickPermission().canExecute(kicker, toKick)) {
                         playerView.getDisplayName().thenAccept(displayName -> {
-                            sender.sendMessage(Component.text()
-                                    .append(Component.text("You can't kick "), displayName, Component.text("!"))
-                                    .color(NamedTextColor.RED));
+                            TagResolver kickedPlaceholder = Placeholder.component("kicked", displayName);
+                            Component message =
+                                    miniMessage.deserialize(config.cannotKickOtherFormat(), kickedPlaceholder);
+                            sender.sendMessage(message);
                         });
                         return;
                     }
 
                     party.getMemberManager().removeMember(playerView.getUUID());
-                    parties.remove(playerView.getUUID());
+                    partyMap.remove(playerView.getUUID());
                     party.getNotification().notifyKick(kicker, toKick);
                 }, () -> {
-                    sender.sendMessage(
-                            Component.text("Can't find anyone with the username " + name + "!", NamedTextColor.RED));
+                    TagResolver usernamePlaceholder = Placeholder.unparsed("username", name);
+                    sender.sendMessage(miniMessage.deserialize(config.cannotFindPlayerFormat(), usernamePlaceholder));
                 });
             });
         }, nameArgument);
diff --git a/core/src/main/java/org/phantazm/core/guild/party/command/PartyLeaveCommand.java b/core/src/main/java/org/phantazm/core/guild/party/command/PartyLeaveCommand.java
index c3eebddfe..9c4ccf5a4 100644
--- a/core/src/main/java/org/phantazm/core/guild/party/command/PartyLeaveCommand.java
+++ b/core/src/main/java/org/phantazm/core/guild/party/command/PartyLeaveCommand.java
@@ -5,17 +5,23 @@
 import net.minestom.server.command.builder.Command;
 import net.minestom.server.entity.Player;
 import org.jetbrains.annotations.NotNull;
+import org.phantazm.core.guild.GuildHolder;
 import org.phantazm.core.guild.party.Party;
 import org.phantazm.core.guild.party.PartyMember;
 
-import java.util.Map;
-import java.util.Objects;
-import java.util.UUID;
+import java.util.*;
 
 public class PartyLeaveCommand {
 
-    public static Command leaveCommand(@NotNull Map<? super UUID, ? extends Party> parties) {
-        Objects.requireNonNull(parties, "parties");
+    private PartyLeaveCommand() {
+        throw new UnsupportedOperationException();
+    }
+
+    public static @NotNull Command leaveCommand(@NotNull PartyCommandConfig config,
+            @NotNull Map<? super UUID, ? extends Party> partyMap, @NotNull Random random) {
+        Objects.requireNonNull(config, "config");
+        Objects.requireNonNull(partyMap, "partyMap");
+        Objects.requireNonNull(random, "random");
 
         Command command = new Command("leave");
         command.addConditionalSyntax((sender, commandString) -> {
@@ -24,24 +30,51 @@ public static Command leaveCommand(@NotNull Map<? super UUID, ? extends Party> p
             }
 
             if (!(sender instanceof Player player)) {
-                sender.sendMessage(Component.text("You have to be a player to use that command!", NamedTextColor.RED));
+                sender.sendMessage(config.mustBeAPlayer());
                 return false;
             }
 
-            Party party = parties.get(player.getUuid());
+            Party party = partyMap.get(player.getUuid());
             if (party == null) {
-                sender.sendMessage(Component.text("You have to be in a party!", NamedTextColor.RED));
+                sender.sendMessage(config.notInParty());
                 return false;
             }
 
             return true;
         }, (sender, context) -> {
             UUID uuid = ((Player)sender).getUuid();
-            Party party = parties.remove(uuid);
+            Party party = partyMap.remove(uuid);
             PartyMember oldMember = party.getMemberManager().removeMember(uuid);
 
             party.getNotification().notifyLeave(oldMember);
-            sender.sendMessage(Component.text("Left the party.", NamedTextColor.GREEN));
+
+            if (party.getOwner().get().getPlayerView().getUUID().equals(uuid)) {
+                if (party.getMemberManager().getMembers().isEmpty()) {
+                    party.getOwner().set(null);
+                }
+                else {
+                    Collection<PartyMember> online = new ArrayList<>(), offline = new ArrayList<>();
+                    for (PartyMember member : party.getMemberManager().getMembers().values()) {
+                        if (member.getPlayerView().getPlayer().isPresent()) {
+                            online.add(member);
+                        }
+                        else {
+                            offline.add(member);
+                        }
+                    }
+
+                    Collection<PartyMember> candidates = online.size() != 0 ? online : offline;
+                    int memberIndex = random.nextInt(candidates.size());
+                    Iterator<PartyMember> memberIterator = candidates.iterator();
+                    PartyMember newOwner = memberIterator.next();
+                    for (int i = 0; i < memberIndex; ++i) {
+                        newOwner = memberIterator.next();
+                    }
+
+                    party.getOwner().set(newOwner);
+                    party.getNotification().notifyTransfer(oldMember, newOwner);
+                }
+            }
         });
 
         return command;
diff --git a/core/src/main/java/org/phantazm/core/guild/party/command/PartyListCommand.java b/core/src/main/java/org/phantazm/core/guild/party/command/PartyListCommand.java
new file mode 100644
index 000000000..7d4eefa23
--- /dev/null
+++ b/core/src/main/java/org/phantazm/core/guild/party/command/PartyListCommand.java
@@ -0,0 +1,111 @@
+package org.phantazm.core.guild.party.command;
+
+import it.unimi.dsi.fastutil.booleans.BooleanArrayList;
+import it.unimi.dsi.fastutil.booleans.BooleanList;
+import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.minimessage.MiniMessage;
+import net.kyori.adventure.text.minimessage.tag.resolver.Placeholder;
+import net.kyori.adventure.text.minimessage.tag.resolver.TagResolver;
+import net.minestom.server.command.builder.Command;
+import net.minestom.server.entity.Player;
+import org.jetbrains.annotations.NotNull;
+import org.phantazm.commons.MiniMessageUtils;
+import org.phantazm.core.guild.party.Party;
+import org.phantazm.core.guild.party.PartyMember;
+import org.phantazm.core.player.PlayerView;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.*;
+import java.util.concurrent.CompletableFuture;
+
+public class PartyListCommand {
+
+    private static final Logger LOGGER = LoggerFactory.getLogger(PartyListCommand.class);
+
+    private static final CompletableFuture<?>[] EMPTY_COMPLETABLE_FUTURE_ARRAY = new CompletableFuture[0];
+
+    private PartyListCommand() {
+        throw new UnsupportedOperationException();
+    }
+
+    public static @NotNull Command listCommand(@NotNull PartyCommandConfig config, @NotNull MiniMessage miniMessage,
+            @NotNull Map<? super UUID, Party> partyMap) {
+        Objects.requireNonNull(config, "config");
+        Objects.requireNonNull(miniMessage, "miniMessage");
+        Objects.requireNonNull(partyMap, "partyMap");
+
+        Command command = new Command("list");
+        command.addConditionalSyntax((sender, commandString) -> {
+            if (commandString == null) {
+                return sender instanceof Player;
+            }
+
+            if (!(sender instanceof Player player)) {
+                sender.sendMessage(config.mustBeAPlayer());
+                return false;
+            }
+
+            Party party = partyMap.get(player.getUuid());
+            if (party == null) {
+                sender.sendMessage(config.notInParty());
+                return false;
+            }
+
+            return true;
+        }, (sender, context) -> {
+            Party party = partyMap.get(((Player)sender).getUuid());
+            int memberCount = party.getMemberManager().getMembers().size();
+            List<CompletableFuture<? extends Component>> displayNameFutures = new ArrayList<>(memberCount);
+            BooleanList online = new BooleanArrayList(memberCount);
+            for (PartyMember member : party.getMemberManager().getMembers().values()) {
+                PlayerView playerView = member.getPlayerView();
+                displayNameFutures.add(playerView.getDisplayName());
+                online.add(playerView.getPlayer().isPresent());
+            }
+            displayNameFutures.add(party.getOwner().get().getPlayerView().getDisplayName());
+
+            CompletableFuture.allOf(displayNameFutures.toArray(EMPTY_COMPLETABLE_FUTURE_ARRAY))
+                    .whenComplete((ignored, throwable) -> {
+                        if (throwable != null) {
+                            LOGGER.warn("Exception while sending list message", throwable);
+                            return;
+                        }
+
+                        Collection<Component> displayNames = new ArrayList<>(memberCount);
+                        int onlineCount = 0;
+                        for (int i = 0; i < memberCount; ++i) {
+                            TagResolver memberPlaceholder =
+                                    Placeholder.component("member", displayNameFutures.get(i).join());
+                            if (online.getBoolean(i)) {
+                                ++onlineCount;
+                                displayNames.add(
+                                        miniMessage.deserialize(config.onlineMemberFormat(), memberPlaceholder));
+                            }
+                            else {
+                                displayNames.add(
+                                        miniMessage.deserialize(config.offlineMemberFormat(), memberPlaceholder));
+                            }
+                        }
+
+                        TagResolver ownerPlaceholder = Placeholder.component("owner",
+                                displayNameFutures.get(displayNameFutures.size() - 1).join());
+                        TagResolver memberCountPlaceholder =
+                                Placeholder.component("member_count", Component.text(memberCount));
+                        TagResolver onlineCountPlaceholder =
+                                Placeholder.component("online_count", Component.text(onlineCount));
+                        TagResolver offlineCountPlaceholder =
+                                Placeholder.component("offline_count", Component.text(memberCount - onlineCount));
+                        TagResolver membersPlaceholder = MiniMessageUtils.list("members", displayNames);
+
+                        Component message =
+                                miniMessage.deserialize(config.listFormat(), ownerPlaceholder, membersPlaceholder,
+                                        onlineCountPlaceholder, offlineCountPlaceholder, memberCountPlaceholder);
+                        sender.sendMessage(message);
+                    });
+        });
+
+        return command;
+    }
+
+}
diff --git a/core/src/main/java/org/phantazm/core/guild/party/command/PartyWarpCommand.java b/core/src/main/java/org/phantazm/core/guild/party/command/PartyWarpCommand.java
new file mode 100644
index 000000000..449066f35
--- /dev/null
+++ b/core/src/main/java/org/phantazm/core/guild/party/command/PartyWarpCommand.java
@@ -0,0 +1,83 @@
+package org.phantazm.core.guild.party.command;
+
+import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.format.NamedTextColor;
+import net.minestom.server.command.builder.Command;
+import net.minestom.server.entity.Player;
+import org.jetbrains.annotations.NotNull;
+import org.phantazm.core.game.scene.Scene;
+import org.phantazm.core.game.scene.SceneTransferHelper;
+import org.phantazm.core.guild.GuildMember;
+import org.phantazm.core.guild.party.Party;
+import org.phantazm.core.guild.party.PartyMember;
+import org.phantazm.core.player.PlayerView;
+import org.phantazm.core.player.PlayerViewProvider;
+
+import java.util.*;
+import java.util.function.Function;
+
+public class PartyWarpCommand {
+
+    public static @NotNull Command warpCommand(@NotNull Map<? super UUID, ? extends Party> partyMap,
+            @NotNull PlayerViewProvider viewProvider,
+            @NotNull Function<? super UUID, Optional<? extends Scene<?>>> sceneMapper,
+            @NotNull SceneTransferHelper transferHelper) {
+        Objects.requireNonNull(partyMap, "partyMap");
+        Objects.requireNonNull(viewProvider, "viewProvider");
+        Objects.requireNonNull(sceneMapper, "sceneMapper");
+        Objects.requireNonNull(transferHelper, "transferHelper");
+
+        Command command = new Command("warp");
+//        command.addConditionalSyntax((sender, commandString) -> {
+//            if (commandString == null) {
+//                return sender instanceof Player;
+//            }
+//
+//            if (!(sender instanceof Player player)) {
+//                sender.sendMessage(Component.text("You have to be a player to use that command!", NamedTextColor.RED));
+//                return false;
+//            }
+//
+//            Optional<? extends Scene<?>> sceneOptional = sceneMapper.apply(player.getUuid());
+//            if (sceneOptional.isEmpty()) {
+//                sender.sendMessage(Component.text("You have to be in a scene!", NamedTextColor.RED));
+//                return false;
+//            }
+//
+//            Party party = partyMap.get(player.getUuid());
+//            if (party == null) {
+//                sender.sendMessage(Component.text("You have to be in a party!", NamedTextColor.GREEN));
+//                return false;
+//            }
+//
+//            PartyMember member = party.getMemberManager().getMember(player.getUuid());
+//            if (!party.getJoinPermission().hasPermission(member)) {
+//                sender.sendMessage(Component.text("You don't have permission to warp players!", NamedTextColor.RED));
+//                return false;
+//            }
+//
+//            return true;
+//        }, (sender, context) -> {
+//            Player joiner = (Player)sender;
+//
+//            sceneMapper.apply(joiner.getUuid()).ifPresent(scene -> {
+//                Party party = partyMap.get(joiner.getUuid());
+//                Collection<PlayerView> playerViews;
+//                if (party == null) {
+//                    playerViews = Collections.singleton(viewProvider.fromPlayer(joiner));
+//                }
+//                else {
+//                    playerViews = new ArrayList<>(party.getMemberManager().getMembers().size());
+//                    for (GuildMember guildMember : party.getMemberManager().getMembers().values()) {
+//                        playerViews.add(guildMember.getPlayerView());
+//                    }
+//                }
+//
+//                transferHelper.transfer(scene);
+//            });
+//        });
+
+        return command;
+    }
+
+}
diff --git a/core/src/main/java/org/phantazm/core/guild/party/notification/PartyNotification.java b/core/src/main/java/org/phantazm/core/guild/party/notification/PartyNotification.java
new file mode 100644
index 000000000..fe254bf25
--- /dev/null
+++ b/core/src/main/java/org/phantazm/core/guild/party/notification/PartyNotification.java
@@ -0,0 +1,238 @@
+package org.phantazm.core.guild.party.notification;
+
+import com.github.steanky.toolkit.collection.Wrapper;
+import net.kyori.adventure.audience.Audience;
+import net.kyori.adventure.audience.ForwardingAudience;
+import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.minimessage.MiniMessage;
+import net.kyori.adventure.text.minimessage.tag.resolver.Formatter;
+import net.kyori.adventure.text.minimessage.tag.resolver.Placeholder;
+import net.kyori.adventure.text.minimessage.tag.resolver.TagResolver;
+import net.minestom.server.utils.time.TimeUnit;
+import org.jetbrains.annotations.NotNull;
+import org.phantazm.core.guild.invite.InvitationNotification;
+import org.phantazm.core.guild.party.PartyMember;
+import org.phantazm.core.player.PlayerView;
+import org.phantazm.core.time.TickFormatter;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.time.Duration;
+import java.time.LocalDate;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Objects;
+import java.util.concurrent.CompletableFuture;
+
+public class PartyNotification implements InvitationNotification<PartyMember> {
+
+    private static final Logger LOGGER = LoggerFactory.getLogger(PartyNotification.class);
+
+    private final Audience audience;
+
+    private final Wrapper<PartyMember> owner;
+
+    private final PartyNotificationConfig config;
+
+    private final TickFormatter tickFormatter;
+
+    private final MiniMessage miniMessage;
+
+    public PartyNotification(@NotNull Collection<? extends PartyMember> partyMembers,
+            @NotNull Wrapper<PartyMember> owner, @NotNull PartyNotificationConfig config,
+            @NotNull TickFormatter tickFormatter, @NotNull MiniMessage miniMessage) {
+        Objects.requireNonNull(partyMembers, "partyMembers");
+        this.audience = (ForwardingAudience)() -> {
+            Collection<Audience> audiences = new ArrayList<>(partyMembers.size());
+
+            for (PartyMember member : partyMembers) {
+                member.getPlayerView().getPlayer().ifPresent(audiences::add);
+            }
+
+            return audiences;
+        };
+        this.owner = Objects.requireNonNull(owner, "owner");
+        this.config = Objects.requireNonNull(config, "config");
+        this.tickFormatter = Objects.requireNonNull(tickFormatter, "tickFormatter");
+        this.miniMessage = Objects.requireNonNull(miniMessage, "miniMessage");
+    }
+
+    @Override
+    public void notifyJoin(@NotNull PartyMember newMember) {
+        newMember.getPlayerView().getDisplayName().thenAccept(displayName -> {
+            TagResolver joinerPlaceholder = Placeholder.component("joiner", displayName);
+            Component message = miniMessage.deserialize(config.joinToPartyFormat(), joinerPlaceholder);
+
+            audience.sendMessage(message);
+        });
+
+        owner.get().getPlayerView().getDisplayName().thenAccept(displayName -> {
+            newMember.getPlayerView().getPlayer().ifPresent(player -> {
+                TagResolver ownerPlaceholder = Placeholder.component("owner", displayName);
+                Component message = miniMessage.deserialize(config.joinToJoinerFormat(), ownerPlaceholder);
+                player.sendMessage(message);
+            });
+        });
+    }
+
+    @Override
+    public void notifyInvitation(@NotNull PartyMember inviter, @NotNull PlayerView invitee, long invitationDuration) {
+        CompletableFuture<? extends Component> inviterDisplayName = inviter.getPlayerView().getDisplayName();
+        CompletableFuture<? extends Component> inviteeDisplayName = invitee.getDisplayName();
+
+        CompletableFuture.allOf(inviterDisplayName, inviteeDisplayName).whenComplete((ignored, throwable) -> {
+            if (throwable != null) {
+                LOGGER.warn("Exception while sending invitation message", throwable);
+                return;
+            }
+
+            TagResolver inviterPlaceholder = Placeholder.component("inviter", inviterDisplayName.join());
+            TagResolver inviteePlaceholder = Placeholder.component("invitee", inviteeDisplayName.join());
+            TagResolver durationPlaceholder =
+                    Placeholder.unparsed("duration", tickFormatter.format(invitationDuration));
+            Component message =
+                    miniMessage.deserialize(config.inviteToPartyFormat(), inviterPlaceholder, inviteePlaceholder,
+                            durationPlaceholder);
+            audience.sendMessage(message);
+        });
+
+        if (inviter == owner.get()) {
+            CompletableFuture<String> ownerUsername = inviter.getPlayerView().getUsername();
+            CompletableFuture.allOf(ownerUsername, inviterDisplayName).whenComplete((ignored, throwable) -> {
+                if (throwable != null) {
+                    LOGGER.warn("Exception while sending invitation message", throwable);
+                    return;
+                }
+
+                invitee.getPlayer().ifPresent(player -> {
+                    TagResolver ownerUsernamePlaceholder = Placeholder.parsed("owner-username", ownerUsername.join());
+                    TagResolver ownerPlaceholder = Placeholder.component("owner", inviterDisplayName.join());
+                    Component message =
+                            miniMessage.deserialize(config.inviteToInviteeFromOwnerFormat(), ownerUsernamePlaceholder,
+                                    ownerPlaceholder);
+                    player.sendMessage(message);
+                });
+            });
+        }
+        else {
+            CompletableFuture<String> ownerUsername = owner.get().getPlayerView().getUsername();
+            CompletableFuture<? extends Component> ownerDisplayName = owner.get().getPlayerView().getDisplayName();
+            CompletableFuture.allOf(ownerUsername, ownerDisplayName, inviterDisplayName)
+                    .whenComplete((ignored, throwable) -> {
+                        if (throwable != null) {
+                            LOGGER.warn("Exception while sending invitation message", throwable);
+                            return;
+                        }
+
+                        invitee.getPlayer().ifPresent(player -> {
+                            TagResolver ownerUsernamePlaceholder =
+                                    Placeholder.parsed("owner-username", ownerUsername.join());
+                            TagResolver ownerPlaceholder = Placeholder.component("owner", ownerDisplayName.join());
+                            TagResolver inviterPlaceholder =
+                                    Placeholder.component("inviter", inviterDisplayName.join());
+                            TagResolver durationPlaceholder = Formatter.date("duration",
+                                    Duration.of(invitationDuration, TimeUnit.SERVER_TICK).addTo(LocalDate.EPOCH));
+
+                            Component message = miniMessage.deserialize(config.inviteToInviteeFromOtherFormat(),
+                                    ownerUsernamePlaceholder, ownerPlaceholder, inviterPlaceholder,
+                                    durationPlaceholder);
+                            player.sendMessage(message);
+                        });
+                    });
+        }
+    }
+
+    @Override
+    public void notifyExpiry(@NotNull PlayerView invitee) {
+        invitee.getDisplayName().whenComplete((displayName, throwable) -> {
+            if (throwable != null) {
+                LOGGER.warn("Exception while sending invitation message", throwable);
+                return;
+            }
+
+            TagResolver inviteePlaceholder = Placeholder.component("invitee", displayName);
+            Component message = miniMessage.deserialize(config.expiryToPartyFormat(), inviteePlaceholder);
+            audience.sendMessage(message);
+        });
+
+        owner.get().getPlayerView().getDisplayName().whenComplete((displayName, throwable) -> {
+            if (throwable != null) {
+                LOGGER.warn("Exception while sending invitation expiry message", throwable);
+                return;
+            }
+
+            invitee.getPlayer().ifPresent(player -> {
+                TagResolver ownerPlaceholder = Placeholder.component("owner", displayName);
+                Component message = miniMessage.deserialize(config.expiryToInviteeFormat(), ownerPlaceholder);
+                player.sendMessage(message);
+            });
+        });
+    }
+
+    public void notifyLeave(@NotNull PartyMember oldMember) {
+        oldMember.getPlayerView().getDisplayName().whenComplete((displayName, throwable) -> {
+            if (throwable != null) {
+                LOGGER.warn("Exception while sending party leave message", throwable);
+                return;
+            }
+
+            TagResolver leaverPlaceholder = Placeholder.component("leaver", displayName);
+            Component message = miniMessage.deserialize(config.leaveToPartyFormat(), leaverPlaceholder);
+            audience.sendMessage(message);
+        });
+
+        oldMember.getPlayerView().getPlayer().ifPresent(player -> {
+            Component message = miniMessage.deserialize(config.leaveToLeaverFormat());
+            player.sendMessage(message);
+        });
+    }
+
+    public void notifyKick(@NotNull PartyMember kicker, @NotNull PartyMember toKick) {
+        CompletableFuture<? extends Component> kickerName = kicker.getPlayerView().getDisplayName();
+        CompletableFuture<? extends Component> toKickName = toKick.getPlayerView().getDisplayName();
+
+        CompletableFuture.allOf(kickerName, toKickName).whenComplete((ignored, throwable) -> {
+            if (throwable != null) {
+                LOGGER.warn("Exception while sending kick message", throwable);
+                return;
+            }
+
+            TagResolver kickerPlaceholder = Placeholder.component("kicker", kickerName.join());
+            TagResolver kickedPlaceholder = Placeholder.component("kicked", toKickName.join());
+            Component message =
+                    miniMessage.deserialize(config.kickToPartyFormat(), kickerPlaceholder, kickedPlaceholder);
+            audience.sendMessage(message);
+        });
+
+        kickerName.whenComplete((name, throwable) -> {
+            if (throwable != null) {
+                LOGGER.warn("Exception while sending kick message", throwable);
+                return;
+            }
+
+            toKick.getPlayerView().getPlayer().ifPresent(player -> {
+                TagResolver kickerPlaceholder = Placeholder.component("kicker", name);
+                Component message = miniMessage.deserialize(config.kickToKickedFormat(), kickerPlaceholder);
+                player.sendMessage(message);
+            });
+        });
+    }
+
+    public void notifyTransfer(@NotNull PartyMember from, @NotNull PartyMember to) {
+        CompletableFuture<? extends Component> fromDisplayName = from.getPlayerView().getDisplayName();
+        CompletableFuture<? extends Component> toDisplayName = to.getPlayerView().getDisplayName();
+
+        CompletableFuture.allOf(fromDisplayName, toDisplayName).whenComplete((ignored, throwable) -> {
+            if (throwable != null) {
+                LOGGER.warn("Exception while sending kick message", throwable);
+                return;
+            }
+
+            TagResolver fromPlaceholder = Placeholder.component("from", fromDisplayName.join());
+            TagResolver toPlaceholder = Placeholder.component("to", toDisplayName.join());
+            Component message = miniMessage.deserialize(config.transferFormat(), fromPlaceholder, toPlaceholder);
+            audience.sendMessage(message);
+        });
+    }
+
+}
diff --git a/core/src/main/java/org/phantazm/core/guild/party/notification/PartyNotificationConfig.java b/core/src/main/java/org/phantazm/core/guild/party/notification/PartyNotificationConfig.java
new file mode 100644
index 000000000..b2f3bdd0d
--- /dev/null
+++ b/core/src/main/java/org/phantazm/core/guild/party/notification/PartyNotificationConfig.java
@@ -0,0 +1,19 @@
+package org.phantazm.core.guild.party.notification;
+
+import org.jetbrains.annotations.NotNull;
+
+public record PartyNotificationConfig(
+        @NotNull String joinToPartyFormat,
+        @NotNull String joinToJoinerFormat,
+        @NotNull String inviteToPartyFormat,
+        @NotNull String inviteToInviteeFromOwnerFormat,
+        @NotNull String inviteToInviteeFromOtherFormat,
+        @NotNull String expiryToPartyFormat,
+        @NotNull String expiryToInviteeFormat,
+        @NotNull String leaveToPartyFormat,
+        @NotNull String leaveToLeaverFormat,
+        @NotNull String kickToPartyFormat,
+        @NotNull String kickToKickedFormat,
+        @NotNull String transferFormat
+) {
+}
diff --git a/core/src/main/java/org/phantazm/core/hologram/InstanceHologram.java b/core/src/main/java/org/phantazm/core/hologram/InstanceHologram.java
index f99d17e38..3217fa108 100644
--- a/core/src/main/java/org/phantazm/core/hologram/InstanceHologram.java
+++ b/core/src/main/java/org/phantazm/core/hologram/InstanceHologram.java
@@ -9,9 +9,7 @@
 import net.minestom.server.instance.Instance;
 import org.jetbrains.annotations.NotNull;
 
-import java.util.AbstractList;
-import java.util.ArrayList;
-import java.util.Objects;
+import java.util.*;
 
 /**
  * Instance-wide Hologram implementation. This object retains a strong reference to its instance, and therefore should
@@ -139,6 +137,30 @@ public void add(int index, @NotNull Component component) {
         }
     }
 
+    @Override
+    public boolean addAll(int index, @NotNull Collection<? extends Component> c) {
+        boolean changed;
+        synchronized (sync) {
+            changed = components.addAll(index, c);
+            armorStands.addAll(index, c.stream().map(this::constructEntity).toList());
+            updateArmorStands();
+        }
+
+        return changed;
+    }
+
+    @Override
+    public boolean addAll(@NotNull Collection<? extends Component> c) {
+        boolean changed;
+        synchronized (sync) {
+            changed = components.addAll(c);
+            armorStands.addAll(c.stream().map(this::constructEntity).toList());
+            updateArmorStands();
+        }
+
+        return changed;
+    }
+
     @Override
     public @NotNull Component remove(int index) {
         synchronized (sync) {
diff --git a/core/src/main/java/org/phantazm/core/npc/AnimationTicker.java b/core/src/main/java/org/phantazm/core/npc/AnimationTicker.java
new file mode 100644
index 000000000..ca54764a5
--- /dev/null
+++ b/core/src/main/java/org/phantazm/core/npc/AnimationTicker.java
@@ -0,0 +1,67 @@
+package org.phantazm.core.npc;
+
+import com.github.steanky.element.core.annotation.*;
+import net.minestom.server.MinecraftServer;
+import net.minestom.server.entity.Entity;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.List;
+import java.util.function.Consumer;
+
+@Model("npc.entity.ticker.animation")
+@Cache(false)
+public class AnimationTicker implements EntityTicker {
+    private final List<Frame> frames;
+
+    private Frame current;
+    private int currentIndex;
+    private long lastFrameTime;
+
+    @FactoryMethod
+    public AnimationTicker(@NotNull @Child("frames") List<Frame> frames) {
+        this.frames = frames;
+        this.current = frames.isEmpty() ? null : frames.get(0);
+        this.lastFrameTime = System.currentTimeMillis();
+    }
+
+    @Override
+    public void accept(long time, @NotNull Entity entity) {
+        Frame current = this.current;
+        if (current == null) {
+            return;
+        }
+
+        long ticksSinceLastFrame = (time - lastFrameTime) / MinecraftServer.TICK_MS;
+        if (ticksSinceLastFrame >= current.data.ticks) {
+            current.effect.accept(entity);
+
+            int newIndex = (currentIndex + 1) % frames.size();
+
+            this.current = frames.get(newIndex);
+            currentIndex = newIndex;
+            lastFrameTime = time;
+        }
+    }
+
+    @Model("npc.entity.ticker.animation.frame")
+    @Cache(false)
+    public static class Frame {
+        private final Data data;
+        private final Consumer<? super Entity> effect;
+
+        @FactoryMethod
+        public Frame(@NotNull Data data, @NotNull @Child("effect") Consumer<? super Entity> effect) {
+            this.data = data;
+            this.effect = effect;
+        }
+
+        @DataObject
+        public record Data(long ticks, @NotNull @ChildPath("effect") String effect) {
+        }
+    }
+
+    @DataObject
+    public record Data(@NotNull @ChildPath("frames") List<String> frames) {
+
+    }
+}
diff --git a/core/src/main/java/org/phantazm/core/npc/EntityNPC.java b/core/src/main/java/org/phantazm/core/npc/EntityNPC.java
new file mode 100644
index 000000000..ae5214014
--- /dev/null
+++ b/core/src/main/java/org/phantazm/core/npc/EntityNPC.java
@@ -0,0 +1,86 @@
+package org.phantazm.core.npc;
+
+import com.github.steanky.element.core.annotation.*;
+import net.minestom.server.coordinate.Pos;
+import net.minestom.server.entity.Entity;
+import net.minestom.server.entity.Player;
+import net.minestom.server.instance.Instance;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.phantazm.core.npc.interactor.Interactor;
+
+import java.util.UUID;
+import java.util.function.Consumer;
+import java.util.function.Supplier;
+
+@Model("npc.entity")
+@Cache(false)
+public class EntityNPC implements NPC {
+    private final Data data;
+    private final Supplier<? extends Entity> entity;
+    private final Consumer<? super Entity> settings;
+    private final EntityTicker ticker;
+    private final Interactor interactor;
+
+    private Entity npc;
+
+    @FactoryMethod
+    public EntityNPC(@NotNull Data data, @NotNull @Child("entity") Supplier<? extends Entity> entity,
+            @NotNull @Child("settings") Consumer<? super Entity> settings,
+            @NotNull @Child("ticker") EntityTicker ticker, @NotNull @Child("interactor") Interactor interactor) {
+        this.data = data;
+        this.entity = entity;
+        this.settings = settings;
+        this.ticker = ticker;
+        this.interactor = interactor;
+    }
+
+    @Override
+    public void handleInteraction(@NotNull Player interactor) {
+        this.interactor.interact(interactor);
+    }
+
+    @Override
+    public void spawn(@NotNull Instance instance) {
+        Entity npc = this.npc;
+        if (npc != null) {
+            npc.remove();
+        }
+
+        npc = entity.get();
+        settings.accept(npc);
+
+        npc.setInstance(instance, data.location).join();
+        this.npc = npc;
+    }
+
+    @Override
+    public void despawn() {
+        Entity npc = this.npc;
+        if (npc != null) {
+            npc.remove();
+        }
+    }
+
+    @Override
+    public @Nullable UUID uuid() {
+        Entity npc = this.npc;
+        return npc == null ? null : npc.getUuid();
+    }
+
+    @Override
+    public void tick(long time) {
+        Entity npc = this.npc;
+        if (npc != null) {
+            ticker.accept(time, npc);
+        }
+    }
+
+    @DataObject
+    public record Data(@NotNull Pos location,
+                       @NotNull @ChildPath("entity") String entity,
+                       @NotNull @ChildPath("settings") String settings,
+                       @NotNull @ChildPath("ticker") String ticker,
+                       @NotNull @ChildPath("interactor") String interactor) {
+    }
+}
diff --git a/core/src/main/java/org/phantazm/core/npc/EntityTicker.java b/core/src/main/java/org/phantazm/core/npc/EntityTicker.java
new file mode 100644
index 000000000..07b4f2f42
--- /dev/null
+++ b/core/src/main/java/org/phantazm/core/npc/EntityTicker.java
@@ -0,0 +1,8 @@
+package org.phantazm.core.npc;
+
+import net.minestom.server.entity.Entity;
+import org.jetbrains.annotations.NotNull;
+
+public interface EntityTicker {
+    void accept(long time, @NotNull Entity entity);
+}
diff --git a/core/src/main/java/org/phantazm/core/npc/NPC.java b/core/src/main/java/org/phantazm/core/npc/NPC.java
new file mode 100644
index 000000000..203911923
--- /dev/null
+++ b/core/src/main/java/org/phantazm/core/npc/NPC.java
@@ -0,0 +1,19 @@
+package org.phantazm.core.npc;
+
+import net.minestom.server.entity.Player;
+import net.minestom.server.instance.Instance;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.phantazm.commons.Tickable;
+
+import java.util.UUID;
+
+public interface NPC extends Tickable {
+    void handleInteraction(@NotNull Player interactor);
+
+    void spawn(@NotNull Instance instance);
+
+    void despawn();
+
+    @Nullable UUID uuid();
+}
diff --git a/core/src/main/java/org/phantazm/core/npc/NPCHandler.java b/core/src/main/java/org/phantazm/core/npc/NPCHandler.java
new file mode 100644
index 000000000..589350e2c
--- /dev/null
+++ b/core/src/main/java/org/phantazm/core/npc/NPCHandler.java
@@ -0,0 +1,66 @@
+package org.phantazm.core.npc;
+
+import net.minestom.server.entity.Entity;
+import net.minestom.server.event.EventFilter;
+import net.minestom.server.event.EventNode;
+import net.minestom.server.event.player.PlayerEntityInteractEvent;
+import net.minestom.server.event.trait.InstanceEvent;
+import net.minestom.server.instance.Instance;
+import org.jetbrains.annotations.NotNull;
+import org.phantazm.commons.Tickable;
+
+import java.util.List;
+import java.util.Objects;
+
+public class NPCHandler implements Tickable {
+    private final Instance instance;
+    private final List<NPC> npcs;
+    private final EventNode<InstanceEvent> instanceEventNode;
+    private final EventNode<InstanceEvent> handlerNode;
+
+    public NPCHandler(@NotNull List<NPC> npcs, @NotNull Instance instance) {
+        this.instance = Objects.requireNonNull(instance, "instance");
+        this.npcs = List.copyOf(npcs);
+        this.instanceEventNode = instance.eventNode();
+
+        this.handlerNode = EventNode.event("npc_handler_{" + instance.getUniqueId() + "}",
+                EventFilter.from(InstanceEvent.class, Instance.class, InstanceEvent::getInstance), event -> true);
+
+        handlerNode.addListener(PlayerEntityInteractEvent.class, this::entityInteractEvent);
+        instanceEventNode.addChild(handlerNode);
+    }
+
+    private void entityInteractEvent(PlayerEntityInteractEvent event) {
+        if (event.getInstance() != instance) {
+            return;
+        }
+
+        Entity entity = event.getTarget();
+        for (NPC npc : npcs) {
+            if (entity.getUuid().equals(npc.uuid())) {
+                npc.handleInteraction(event.getPlayer());
+            }
+        }
+    }
+
+    public void spawnAll() {
+        for (NPC npc : npcs) {
+            npc.spawn(instance);
+        }
+    }
+
+    public void end() {
+        for (NPC npc : npcs) {
+            npc.despawn();
+        }
+
+        instanceEventNode.removeChild(handlerNode);
+    }
+
+    @Override
+    public void tick(long time) {
+        for (NPC npc : npcs) {
+            npc.tick(time);
+        }
+    }
+}
diff --git a/core/src/main/java/org/phantazm/core/npc/NoTicker.java b/core/src/main/java/org/phantazm/core/npc/NoTicker.java
new file mode 100644
index 000000000..a77cc63ab
--- /dev/null
+++ b/core/src/main/java/org/phantazm/core/npc/NoTicker.java
@@ -0,0 +1,21 @@
+package org.phantazm.core.npc;
+
+import com.github.steanky.element.core.annotation.Cache;
+import com.github.steanky.element.core.annotation.FactoryMethod;
+import com.github.steanky.element.core.annotation.Model;
+import net.minestom.server.entity.Entity;
+import org.jetbrains.annotations.NotNull;
+
+@Model("npc.entity.ticker.none")
+@Cache
+public class NoTicker implements EntityTicker {
+    @FactoryMethod
+    public NoTicker() {
+
+    }
+
+    @Override
+    public void accept(long time, @NotNull Entity entity) {
+
+    }
+}
diff --git a/core/src/main/java/org/phantazm/core/npc/interactor/CommandInteractor.java b/core/src/main/java/org/phantazm/core/npc/interactor/CommandInteractor.java
new file mode 100644
index 000000000..61521d633
--- /dev/null
+++ b/core/src/main/java/org/phantazm/core/npc/interactor/CommandInteractor.java
@@ -0,0 +1,29 @@
+package org.phantazm.core.npc.interactor;
+
+import com.github.steanky.element.core.annotation.Cache;
+import com.github.steanky.element.core.annotation.DataObject;
+import com.github.steanky.element.core.annotation.FactoryMethod;
+import com.github.steanky.element.core.annotation.Model;
+import net.minestom.server.MinecraftServer;
+import net.minestom.server.entity.Player;
+import org.jetbrains.annotations.NotNull;
+
+@Model("npc.interactor.command")
+@Cache
+public class CommandInteractor implements Interactor {
+    private final Data data;
+
+    @FactoryMethod
+    public CommandInteractor(@NotNull Data data) {
+        this.data = data;
+    }
+
+    @Override
+    public void interact(@NotNull Player player) {
+        MinecraftServer.getCommandManager().execute(player, data.command);
+    }
+
+    @DataObject
+    public record Data(@NotNull String command) {
+    }
+}
diff --git a/core/src/main/java/org/phantazm/core/npc/interactor/Interactor.java b/core/src/main/java/org/phantazm/core/npc/interactor/Interactor.java
new file mode 100644
index 000000000..6c1bbb58d
--- /dev/null
+++ b/core/src/main/java/org/phantazm/core/npc/interactor/Interactor.java
@@ -0,0 +1,8 @@
+package org.phantazm.core.npc.interactor;
+
+import net.minestom.server.entity.Player;
+import org.jetbrains.annotations.NotNull;
+
+public interface Interactor {
+    void interact(@NotNull Player player);
+}
diff --git a/core/src/main/java/org/phantazm/core/npc/interactor/NoInteractor.java b/core/src/main/java/org/phantazm/core/npc/interactor/NoInteractor.java
new file mode 100644
index 000000000..d0ece8a37
--- /dev/null
+++ b/core/src/main/java/org/phantazm/core/npc/interactor/NoInteractor.java
@@ -0,0 +1,20 @@
+package org.phantazm.core.npc.interactor;
+
+import com.github.steanky.element.core.annotation.Cache;
+import com.github.steanky.element.core.annotation.FactoryMethod;
+import com.github.steanky.element.core.annotation.Model;
+import net.minestom.server.entity.Player;
+import org.jetbrains.annotations.NotNull;
+
+@Model("npc.interactor.none")
+@Cache
+public class NoInteractor implements Interactor {
+    @FactoryMethod
+    public NoInteractor() {
+    }
+
+    @Override
+    public void interact(@NotNull Player player) {
+
+    }
+}
diff --git a/core/src/main/java/org/phantazm/core/npc/settings/BasicEntitySettings.java b/core/src/main/java/org/phantazm/core/npc/settings/BasicEntitySettings.java
new file mode 100644
index 000000000..d603d0172
--- /dev/null
+++ b/core/src/main/java/org/phantazm/core/npc/settings/BasicEntitySettings.java
@@ -0,0 +1,115 @@
+package org.phantazm.core.npc.settings;
+
+import com.github.steanky.element.core.annotation.Cache;
+import com.github.steanky.element.core.annotation.DataObject;
+import com.github.steanky.element.core.annotation.FactoryMethod;
+import com.github.steanky.element.core.annotation.Model;
+import com.github.steanky.ethylene.core.ConfigElement;
+import com.github.steanky.ethylene.core.ConfigPrimitive;
+import com.github.steanky.ethylene.core.collection.ConfigList;
+import com.github.steanky.ethylene.mapper.annotation.Default;
+import net.kyori.adventure.text.Component;
+import net.minestom.server.entity.Entity;
+import net.minestom.server.entity.EquipmentSlot;
+import net.minestom.server.entity.LivingEntity;
+import net.minestom.server.entity.metadata.EntityMeta;
+import net.minestom.server.entity.metadata.other.ArmorStandMeta;
+import net.minestom.server.item.ItemStack;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Map;
+import java.util.function.Consumer;
+
+@Model("npc.entity.settings")
+@Cache
+public class BasicEntitySettings implements Consumer<Entity> {
+    private final Data data;
+
+    @FactoryMethod
+    public BasicEntitySettings(@NotNull Data data) {
+        this.data = data;
+    }
+
+    @Override
+    public void accept(Entity entity) {
+        EntityMeta meta = entity.getEntityMeta();
+
+        if (!data.displayName.equals(Component.empty())) {
+            meta.setCustomNameVisible(true);
+            meta.setCustomName(data.displayName);
+        }
+
+        meta.setHasNoGravity(!data.hasGravity);
+        entity.setHasPhysics(data.hasPhysics);
+        meta.setOnFire(data.onFire);
+        meta.setPose(data.pose);
+        meta.setInvisible(data.invisible);
+        meta.setHasGlowingEffect(data.glowing);
+
+        if (entity instanceof LivingEntity livingEntity) {
+            for (Map.Entry<EquipmentSlot, ItemStack> entry : data.equipment.entrySet()) {
+                livingEntity.setEquipment(entry.getKey(), entry.getValue());
+            }
+        }
+
+        if (meta instanceof ArmorStandMeta armorStandMeta) {
+            armorStandMeta.setSmall(data.small);
+        }
+    }
+
+    @DataObject
+    public record Data(@NotNull Component displayName,
+                       boolean hasGravity,
+                       boolean hasPhysics,
+                       boolean onFire,
+                       boolean invisible,
+                       boolean small,
+                       boolean glowing,
+                       @NotNull Entity.Pose pose,
+                       @NotNull Map<EquipmentSlot, ItemStack> equipment) {
+        @Default("displayName")
+        public static ConfigElement defaultDisplayName() {
+            return ConfigPrimitive.of("");
+        }
+
+        @Default("hasGravity")
+        public static ConfigElement defaultHasGravity() {
+            return ConfigPrimitive.of(false);
+        }
+
+        @Default("hasPhysics")
+        public static ConfigElement defaultHasPhysics() {
+            return ConfigPrimitive.of(false);
+        }
+
+        @Default("onFire")
+        public static ConfigElement defaultOnFire() {
+            return ConfigPrimitive.of(false);
+        }
+
+        @Default("invisible")
+        public static ConfigElement defaultInvisible() {
+            return ConfigPrimitive.of(false);
+        }
+
+        @Default("small")
+        public static ConfigElement defaultSmall() {
+            return ConfigPrimitive.of(false);
+        }
+
+        @Default("glowing")
+        public static ConfigElement defaultGlowing() {
+            return ConfigPrimitive.of(false);
+        }
+
+        @Default("pose")
+        public static ConfigElement defaultPose() {
+            return ConfigPrimitive.of("STANDING");
+        }
+
+        @Default("equipment")
+        public static ConfigElement defaultEquipment() {
+            return ConfigList.of();
+        }
+    }
+}
diff --git a/core/src/main/java/org/phantazm/core/npc/supplier/MobEntitySupplier.java b/core/src/main/java/org/phantazm/core/npc/supplier/MobEntitySupplier.java
new file mode 100644
index 000000000..c0c05832e
--- /dev/null
+++ b/core/src/main/java/org/phantazm/core/npc/supplier/MobEntitySupplier.java
@@ -0,0 +1,32 @@
+package org.phantazm.core.npc.supplier;
+
+import com.github.steanky.element.core.annotation.Cache;
+import com.github.steanky.element.core.annotation.DataObject;
+import com.github.steanky.element.core.annotation.FactoryMethod;
+import com.github.steanky.element.core.annotation.Model;
+import net.minestom.server.entity.Entity;
+import net.minestom.server.entity.EntityType;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.function.Supplier;
+
+@Model("npc.entity.supplier.mob")
+@Cache
+public class MobEntitySupplier implements Supplier<Entity> {
+    private final Data data;
+
+    @FactoryMethod
+    public MobEntitySupplier(@NotNull Data data) {
+        this.data = data;
+    }
+
+    @Override
+    public Entity get() {
+        return new Entity(data.entityType);
+    }
+
+    @DataObject
+    public record Data(@NotNull EntityType entityType) {
+
+    }
+}
diff --git a/core/src/main/java/org/phantazm/core/npc/supplier/PlayerEntitySupplier.java b/core/src/main/java/org/phantazm/core/npc/supplier/PlayerEntitySupplier.java
new file mode 100644
index 000000000..cb32f3b1b
--- /dev/null
+++ b/core/src/main/java/org/phantazm/core/npc/supplier/PlayerEntitySupplier.java
@@ -0,0 +1,41 @@
+package org.phantazm.core.npc.supplier;
+
+import com.github.steanky.element.core.annotation.Cache;
+import com.github.steanky.element.core.annotation.DataObject;
+import com.github.steanky.element.core.annotation.FactoryMethod;
+import com.github.steanky.element.core.annotation.Model;
+import com.github.steanky.ethylene.core.ConfigElement;
+import com.github.steanky.ethylene.core.ConfigPrimitive;
+import com.github.steanky.ethylene.mapper.annotation.Default;
+import net.minestom.server.MinecraftServer;
+import net.minestom.server.entity.Entity;
+import net.minestom.server.entity.PlayerSkin;
+import org.jetbrains.annotations.NotNull;
+import org.phantazm.core.entity.fakeplayer.MinimalFakePlayer;
+
+import java.util.function.Supplier;
+
+@Model("npc.entity.supplier.player")
+@Cache
+public class PlayerEntitySupplier implements Supplier<Entity> {
+    private final Data data;
+
+    @FactoryMethod
+    public PlayerEntitySupplier(@NotNull Data data) {
+        this.data = data;
+    }
+
+    @Override
+    public Entity get() {
+        return new MinimalFakePlayer(MinecraftServer.getSchedulerManager(), data.playerName,
+                PlayerSkin.fromUuid(data.skinUUID.replace("-", "")));
+    }
+
+    @DataObject
+    public record Data(@NotNull String playerName, @NotNull String skinUUID) {
+        @Default("playerName")
+        public static ConfigElement defaultPlayerName() {
+            return ConfigPrimitive.of("");
+        }
+    }
+}
diff --git a/core/src/main/java/org/phantazm/core/time/AnalogTickFormatter.java b/core/src/main/java/org/phantazm/core/time/AnalogTickFormatter.java
index 664ce8fd6..ce583357f 100644
--- a/core/src/main/java/org/phantazm/core/time/AnalogTickFormatter.java
+++ b/core/src/main/java/org/phantazm/core/time/AnalogTickFormatter.java
@@ -4,9 +4,6 @@
 import com.github.steanky.element.core.annotation.DataObject;
 import com.github.steanky.element.core.annotation.FactoryMethod;
 import com.github.steanky.element.core.annotation.Model;
-import net.kyori.adventure.text.Component;
-import net.kyori.adventure.text.TextComponent;
-import net.kyori.adventure.text.format.TextColor;
 import net.minestom.server.MinecraftServer;
 import org.jetbrains.annotations.NotNull;
 
@@ -23,7 +20,7 @@ public AnalogTickFormatter(@NotNull Data data) {
     }
 
     @Override
-    public @NotNull Component format(long ticks) {
+    public @NotNull String format(long ticks) {
         long elapsedSeconds;
         if (data.ceil) {
             elapsedSeconds = (long)Math.ceil((double)ticks / MinecraftServer.TICK_PER_SECOND);
@@ -35,20 +32,20 @@ public AnalogTickFormatter(@NotNull Data data) {
         long minutes = (elapsedSeconds % 3600) / 60;
         long seconds = elapsedSeconds % 60;
 
-        Component separator = Component.text(":", data.separatorColor);
-        TextComponent.Builder builder = Component.text().color(data.digitColor);
+        String separator = ":";
+        StringBuilder builder = new StringBuilder();
         if (hours != 0) {
-            builder.append(Component.text(hours)).append(separator);
+            builder.append(hours).append(separator);
         }
 
-        builder.append(Component.text(String.format("%02d", minutes))).append(separator);
-        builder.append(Component.text(String.format("%02d", seconds)));
+        builder.append(String.format("%02d", minutes)).append(separator);
+        builder.append(String.format("%02d", seconds));
 
-        return builder.build();
+        return builder.toString();
     }
 
     @DataObject
-    public record Data(@NotNull TextColor digitColor, @NotNull TextColor separatorColor, boolean ceil) {
+    public record Data(boolean ceil) {
 
     }
 }
diff --git a/core/src/main/java/org/phantazm/core/time/DurationTickFormatter.java b/core/src/main/java/org/phantazm/core/time/DurationTickFormatter.java
index 37ed66e8b..65bc8161b 100644
--- a/core/src/main/java/org/phantazm/core/time/DurationTickFormatter.java
+++ b/core/src/main/java/org/phantazm/core/time/DurationTickFormatter.java
@@ -4,9 +4,6 @@
 import com.github.steanky.element.core.annotation.DataObject;
 import com.github.steanky.element.core.annotation.FactoryMethod;
 import com.github.steanky.element.core.annotation.Model;
-import net.kyori.adventure.text.Component;
-import net.kyori.adventure.text.TextComponent;
-import net.kyori.adventure.text.format.TextColor;
 import net.minestom.server.MinecraftServer;
 import org.jetbrains.annotations.NotNull;
 
@@ -24,7 +21,7 @@ public DurationTickFormatter(@NotNull Data data) {
     }
 
     @Override
-    public @NotNull Component format(long ticks) {
+    public @NotNull String format(long ticks) {
         long elapsedSeconds;
         if (data.ceil) {
             elapsedSeconds = (long)Math.ceil((double)ticks / MinecraftServer.TICK_PER_SECOND);
@@ -36,39 +33,39 @@ public DurationTickFormatter(@NotNull Data data) {
         long minutes = (elapsedSeconds % 3600) / 60;
         long seconds = elapsedSeconds % 60;
 
-        TextComponent.Builder builder = Component.text().color(data.color);
+        StringBuilder builder = new StringBuilder();
         if (hours != 0) {
-            builder.append(Component.text(hours));
+            builder.append(hours);
             if (data.verbose) {
-                builder.append(Component.text(" hours"));
+                builder.append(" hours");
             }
             else {
-                builder.append(Component.text("h"));
+                builder.append("h");
             }
         }
         if (minutes != 0) {
-            builder.append(Component.text(minutes));
+            builder.append(minutes);
             if (data.verbose) {
-                builder.append(Component.text(" minutes"));
+                builder.append(" minutes");
             }
             else {
-                builder.append(Component.text("m"));
+                builder.append("m");
             }
         }
         if ((hours == 0 && minutes == 0) || seconds != 0) {
-            builder.append(Component.text(seconds));
+            builder.append(seconds);
             if (data.verbose) {
-                builder.append(Component.text(" seconds"));
+                builder.append(" seconds");
             }
             else {
-                builder.append(Component.text("s"));
+                builder.append("s");
             }
         }
 
-        return builder.build();
+        return builder.toString();
     }
 
     @DataObject
-    public record Data(@NotNull TextColor color, boolean verbose, boolean ceil) {
+    public record Data(boolean verbose, boolean ceil) {
     }
 }
diff --git a/core/src/main/java/org/phantazm/core/time/PrecisionSecondTickFormatter.java b/core/src/main/java/org/phantazm/core/time/PrecisionSecondTickFormatter.java
index b6845838b..312d2f614 100644
--- a/core/src/main/java/org/phantazm/core/time/PrecisionSecondTickFormatter.java
+++ b/core/src/main/java/org/phantazm/core/time/PrecisionSecondTickFormatter.java
@@ -4,8 +4,6 @@
 import com.github.steanky.element.core.annotation.DataObject;
 import com.github.steanky.element.core.annotation.FactoryMethod;
 import com.github.steanky.element.core.annotation.Model;
-import net.kyori.adventure.text.Component;
-import net.kyori.adventure.text.format.TextColor;
 import net.minestom.server.MinecraftServer;
 import org.jetbrains.annotations.NotNull;
 
@@ -22,13 +20,11 @@ public PrecisionSecondTickFormatter(@NotNull Data data) {
     }
 
     @Override
-    public @NotNull Component format(long ticks) {
-        return Component.text(
-                String.format("%." + data.decimalPlaces + "f", ((double)ticks / MinecraftServer.TICK_PER_SECOND)),
-                data.color);
+    public @NotNull String format(long ticks) {
+        return String.format("%." + data.decimalPlaces + "f", ((double)ticks / MinecraftServer.TICK_PER_SECOND));
     }
 
     @DataObject
-    public record Data(@NotNull TextColor color, int decimalPlaces) {
+    public record Data(int decimalPlaces) {
     }
 }
diff --git a/core/src/main/java/org/phantazm/core/time/TickFormatter.java b/core/src/main/java/org/phantazm/core/time/TickFormatter.java
index df0539549..fc8725367 100644
--- a/core/src/main/java/org/phantazm/core/time/TickFormatter.java
+++ b/core/src/main/java/org/phantazm/core/time/TickFormatter.java
@@ -1,10 +1,9 @@
 package org.phantazm.core.time;
 
-import net.kyori.adventure.text.Component;
 import org.jetbrains.annotations.NotNull;
 
 public interface TickFormatter {
 
-    @NotNull Component format(long ticks);
+    @NotNull String format(long ticks);
 
 }
diff --git a/core/src/main/java/org/phantazm/core/tracker/BoundedTracker.java b/core/src/main/java/org/phantazm/core/tracker/BoundedTracker.java
index 630dd69a6..9d14f5245 100644
--- a/core/src/main/java/org/phantazm/core/tracker/BoundedTracker.java
+++ b/core/src/main/java/org/phantazm/core/tracker/BoundedTracker.java
@@ -10,11 +10,11 @@
 import java.util.function.Consumer;
 
 public interface BoundedTracker<T extends Bounded> {
-    @NotNull Optional<T> closestInRangeToCenter(@NotNull Point origin, double distance);
-
     @NotNull Optional<T> closestInRangeToBounds(@NotNull Point origin, double width, double height, double depth,
             double distance);
 
+    @NotNull Optional<T> closestInRangeToBounds(@NotNull Point origin, double distance);
+
     default @NotNull Optional<T> closestInRangeToBounds(@NotNull Point origin, double width, double height,
             double distance) {
         return closestInRangeToBounds(origin, width, height, width, distance);
diff --git a/core/src/main/java/org/phantazm/core/tracker/BoundedTrackerImpl.java b/core/src/main/java/org/phantazm/core/tracker/BoundedTrackerImpl.java
index 7ba917947..6465efb04 100644
--- a/core/src/main/java/org/phantazm/core/tracker/BoundedTrackerImpl.java
+++ b/core/src/main/java/org/phantazm/core/tracker/BoundedTrackerImpl.java
@@ -60,7 +60,8 @@ private static <T extends Bounded> Long2ObjectMap<Object[]> chunkItems(Collectio
     }
 
     @Override
-    public @NotNull Optional<T> closestInRangeToCenter(@NotNull Point origin, double distance) {
+    public @NotNull Optional<T> closestInRangeToBounds(@NotNull Point origin, double width, double height, double depth,
+            double distance) {
         int startX = (int)Math.floor(origin.x() - distance) >> 4;
         int startZ = (int)Math.floor(origin.z() - distance) >> 4;
 
@@ -70,6 +71,9 @@ private static <T extends Bounded> Long2ObjectMap<Object[]> chunkItems(Collectio
         T closest = null;
         double closestDistance = Double.POSITIVE_INFINITY;
 
+        double halfWidth = width / 2;
+        double halfDepth = depth / 2;
+
         for (int cx = startX; cx <= endX; cx++) {
             for (int cz = startZ; cz <= endZ; cz++) {
                 Object[] chunkItems = chunkedItems.get(ChunkUtils.getChunkIndex(cx, cz));
@@ -77,10 +81,20 @@ private static <T extends Bounded> Long2ObjectMap<Object[]> chunkItems(Collectio
                     for (Object item : chunkItems) {
                         T boundedItem = (T)item;
 
-                        double thisDistance = origin.distanceSquared(boundedItem.center());
-                        if (thisDistance < closestDistance && thisDistance <= distance * distance) {
-                            closest = boundedItem;
-                            closestDistance = thisDistance;
+                        for (Bounds3I bounds : boundedItem.bounds()) {
+                            double boundX = MathUtils.clamp(origin.x(), bounds.originX(), bounds.maxX());
+                            double boundY = MathUtils.clamp(origin.y(), bounds.originY(), bounds.maxY());
+                            double boundZ = MathUtils.clamp(origin.z(), bounds.originZ(), bounds.maxZ());
+
+                            double agentX = MathUtils.clamp(boundX, origin.x() - halfWidth, origin.x() + halfWidth);
+                            double agentY = MathUtils.clamp(boundY, origin.y(), origin.y() + height);
+                            double agentZ = MathUtils.clamp(boundZ, origin.z() - halfDepth, origin.z() + halfDepth);
+
+                            double thisDistance = Vec3D.distanceSquared(boundX, boundY, boundZ, agentX, agentY, agentZ);
+                            if (thisDistance < distance * distance && thisDistance < closestDistance) {
+                                closest = boundedItem;
+                                closestDistance = thisDistance;
+                            }
                         }
                     }
                 }
@@ -91,8 +105,7 @@ private static <T extends Bounded> Long2ObjectMap<Object[]> chunkItems(Collectio
     }
 
     @Override
-    public @NotNull Optional<T> closestInRangeToBounds(@NotNull Point origin, double width, double height, double depth,
-            double distance) {
+    public @NotNull Optional<T> closestInRangeToBounds(@NotNull Point origin, double distance) {
         int startX = (int)Math.floor(origin.x() - distance) >> 4;
         int startZ = (int)Math.floor(origin.z() - distance) >> 4;
 
@@ -102,9 +115,6 @@ private static <T extends Bounded> Long2ObjectMap<Object[]> chunkItems(Collectio
         T closest = null;
         double closestDistance = Double.POSITIVE_INFINITY;
 
-        double halfWidth = width / 2;
-        double halfDepth = depth / 2;
-
         for (int cx = startX; cx <= endX; cx++) {
             for (int cz = startZ; cz <= endZ; cz++) {
                 Object[] chunkItems = chunkedItems.get(ChunkUtils.getChunkIndex(cx, cz));
@@ -117,11 +127,8 @@ private static <T extends Bounded> Long2ObjectMap<Object[]> chunkItems(Collectio
                             double boundY = MathUtils.clamp(origin.y(), bounds.originY(), bounds.maxY());
                             double boundZ = MathUtils.clamp(origin.z(), bounds.originZ(), bounds.maxZ());
 
-                            double agentX = MathUtils.clamp(boundX, origin.x() - halfWidth, origin.x() + halfWidth);
-                            double agentY = MathUtils.clamp(boundY, origin.y(), origin.y() + height);
-                            double agentZ = MathUtils.clamp(boundZ, origin.z() - halfDepth, origin.z() + halfDepth);
-
-                            double thisDistance = Vec3D.distanceSquared(boundX, boundY, boundZ, agentX, agentY, agentZ);
+                            double thisDistance =
+                                    Vec3D.distanceSquared(boundX, boundY, boundZ, origin.x(), origin.y(), origin.z());
                             if (thisDistance < distance * distance && thisDistance < closestDistance) {
                                 closest = boundedItem;
                                 closestDistance = thisDistance;
diff --git a/core/src/test/java/org/phantazm/core/game/scene/lobby/LobbyIntegrationTest.java b/core/src/test/java/org/phantazm/core/game/scene/lobby/LobbyIntegrationTest.java
index 85431f909..873a48999 100644
--- a/core/src/test/java/org/phantazm/core/game/scene/lobby/LobbyIntegrationTest.java
+++ b/core/src/test/java/org/phantazm/core/game/scene/lobby/LobbyIntegrationTest.java
@@ -8,20 +8,19 @@
 import org.jetbrains.annotations.NotNull;
 import org.junit.jupiter.api.Test;
 import org.phantazm.core.config.InstanceConfig;
-import org.phantazm.core.game.scene.RouteResult;
+import org.phantazm.core.game.scene.TransferResult;
 import org.phantazm.core.game.scene.fallback.SceneFallback;
+import org.phantazm.core.npc.NPCHandler;
 import org.phantazm.core.player.PlayerView;
 
 import java.util.Collections;
+import java.util.List;
 import java.util.Optional;
 import java.util.UUID;
 import java.util.concurrent.CompletableFuture;
 
-import static org.junit.jupiter.api.Assertions.assertFalse;
-import static org.junit.jupiter.api.Assertions.assertTrue;
-import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.ArgumentMatchers.eq;
-import static org.mockito.Mockito.*;
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.Mockito.mock;
 
 @EnvTest
 public class LobbyIntegrationTest {
@@ -32,28 +31,30 @@ public class LobbyIntegrationTest {
     public void testShutdown(Env env) {
         Instance instance = env.createFlatInstance();
         InstanceConfig instanceConfig = new InstanceConfig(InstanceConfig.DEFAULT_POS, InstanceConfig.DEFAULT_TIME,
-                InstanceConfig.DEFAULT_TIME_RATE);
+                InstanceConfig.DEFAULT_TIME_RATE, InstanceConfig.DEFAULT_CHUNK_LOAD_RANGE);
         SceneFallback sceneFallback = (ignored) -> true;
-        Lobby lobby = new Lobby(instance, instanceConfig, sceneFallback);
+        Lobby lobby = new Lobby(UUID.randomUUID(), instance, instanceConfig, sceneFallback,
+                new NPCHandler(List.of(), instance), true);
         PlayerView playerView = mock(PlayerView.class);
 
         lobby.shutdown();
         assertTrue(lobby.isShutdown());
 
-        RouteResult result =
+        TransferResult result =
                 lobby.join(new BasicLobbyJoinRequest(env.process().connection(), Collections.singleton(playerView)));
-        assertFalse(result.success());
+        assertFalse(result.executor().isPresent());
     }
 
+    /* TODO: fix
     @Test
     public void testJoin(Env env) {
-        Instance instance = mock(Instance.class);
+        Instance instance = env.createFlatInstance();
         InstanceConfig instanceConfig = new InstanceConfig(InstanceConfig.DEFAULT_POS, InstanceConfig.DEFAULT_TIME,
-                InstanceConfig.DEFAULT_TIME_RATE);
+                InstanceConfig.DEFAULT_TIME_RATE, InstanceConfig.DEFAULT_CHUNK_LOAD_RANGE);
         SceneFallback sceneFallback = (ignored) -> true;
-        Lobby lobby = new Lobby(instance, instanceConfig, sceneFallback);
-        Player player = mock(Player.class);
-        when(player.setInstance(any(), any())).thenReturn(CompletableFuture.completedFuture(null));
+        Lobby lobby = new Lobby(UUID.randomUUID(), instance, instanceConfig, sceneFallback,
+                new NPCHandler(List.of(), instance));
+        Player player = env.createPlayer(instance, instanceConfig.spawnPoint());
         PlayerView playerView = new PlayerView() {
             @Override
             public @NotNull UUID getUUID() {
@@ -87,11 +88,13 @@ public void testJoin(Env env) {
 
         };
 
-        RouteResult result =
+        TransferResult result =
                 lobby.join(new BasicLobbyJoinRequest(env.process().connection(), Collections.singleton(playerView)));
 
         assertTrue(result.success());
-        verify(player).setInstance(eq(instance), eq(instanceConfig.spawnPoint()));
+        assertEquals(instance, player.getInstance());
+        assertEquals(instanceConfig.spawnPoint(), player.getPosition());
     }
+    */
 
 }
diff --git a/core/src/test/java/org/phantazm/core/game/scene/lobby/LobbyRouterIntegrationTest.java b/core/src/test/java/org/phantazm/core/game/scene/lobby/LobbyRouterIntegrationTest.java
index e588eea4d..ae4a666de 100644
--- a/core/src/test/java/org/phantazm/core/game/scene/lobby/LobbyRouterIntegrationTest.java
+++ b/core/src/test/java/org/phantazm/core/game/scene/lobby/LobbyRouterIntegrationTest.java
@@ -3,14 +3,15 @@
 import net.minestom.testing.Env;
 import net.minestom.testing.EnvTest;
 import org.junit.jupiter.api.Test;
-import org.phantazm.core.game.scene.Scene;
 import org.phantazm.core.game.scene.SceneProvider;
+import org.phantazm.core.game.scene.SceneRouter;
 
 import java.util.Collections;
 import java.util.List;
 import java.util.Map;
 
 import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 import static org.mockito.Mockito.mock;
 
 @EnvTest
@@ -22,13 +23,13 @@ public void testJoinRejectionWhenNotJoinable(Env env) {
         String lobbyName = "main";
         Map<String, SceneProvider<Lobby, LobbyJoinRequest>> sceneProviders =
                 Collections.singletonMap(lobbyName, (SceneProvider<Lobby, LobbyJoinRequest>)mock(SceneProvider.class));
-        Scene<LobbyRouteRequest> router = new LobbyRouter(sceneProviders);
+        SceneRouter<Lobby, LobbyRouteRequest> router = new LobbyRouter(sceneProviders);
 
         router.setJoinable(false);
         LobbyRouteRequest request =
                 new LobbyRouteRequest(lobbyName, new BasicLobbyJoinRequest(env.process().connection(), List.of()));
 
-        assertFalse(router.join(request).success());
+        assertTrue(router.findScene(request).scene().isEmpty());
     }
 
     @SuppressWarnings("unchecked")
@@ -37,13 +38,13 @@ public void testJoinRejectionWhenShutdown(Env env) {
         String lobbyName = "main";
         Map<String, SceneProvider<Lobby, LobbyJoinRequest>> sceneProviders =
                 Collections.singletonMap(lobbyName, (SceneProvider<Lobby, LobbyJoinRequest>)mock(SceneProvider.class));
-        Scene<LobbyRouteRequest> router = new LobbyRouter(sceneProviders);
+        SceneRouter<Lobby, LobbyRouteRequest> router = new LobbyRouter(sceneProviders);
 
         router.shutdown();
         LobbyRouteRequest request =
                 new LobbyRouteRequest(lobbyName, new BasicLobbyJoinRequest(env.process().connection(), List.of()));
 
-        assertFalse(router.join(request).success());
+        assertTrue(router.findScene(request).scene().isEmpty());
     }
 
     @SuppressWarnings("unchecked")
@@ -52,12 +53,12 @@ public void testJoinRequestWithNoMatchingSceneProvider(Env env) {
         String lobbyName = "main";
         Map<String, SceneProvider<Lobby, LobbyJoinRequest>> sceneProviders =
                 Collections.singletonMap(lobbyName, (SceneProvider<Lobby, LobbyJoinRequest>)mock(SceneProvider.class));
-        Scene<LobbyRouteRequest> router = new LobbyRouter(sceneProviders);
+        SceneRouter<Lobby, LobbyRouteRequest> router = new LobbyRouter(sceneProviders);
 
         LobbyRouteRequest request =
                 new LobbyRouteRequest("notMain", new BasicLobbyJoinRequest(env.process().connection(), List.of()));
 
-        assertFalse(router.join(request).success());
+        assertTrue(router.findScene(request).scene().isEmpty());
     }
 
 }
diff --git a/core/src/test/java/org/phantazm/core/guild/invite/InvitationManagerIntegrationTest.java b/core/src/test/java/org/phantazm/core/guild/invite/InvitationManagerIntegrationTest.java
index 46cd8ec47..d5b4834ac 100644
--- a/core/src/test/java/org/phantazm/core/guild/invite/InvitationManagerIntegrationTest.java
+++ b/core/src/test/java/org/phantazm/core/guild/invite/InvitationManagerIntegrationTest.java
@@ -60,7 +60,8 @@ public void notifyJoin(@NotNull GuildMember member) {
             }
 
             @Override
-            public void notifyInvitation(@NotNull GuildMember inviter, @NotNull PlayerView invitee) {
+            public void notifyInvitation(@NotNull GuildMember inviter, @NotNull PlayerView invitee,
+                    long invitationDuration) {
 
             }
 
diff --git a/core/src/test/java/org/phantazm/core/guild/party/command/AbstractPartyCommandIntegrationTest.java b/core/src/test/java/org/phantazm/core/guild/party/command/AbstractPartyCommandIntegrationTest.java
index adef870cd..cf6762d1a 100644
--- a/core/src/test/java/org/phantazm/core/guild/party/command/AbstractPartyCommandIntegrationTest.java
+++ b/core/src/test/java/org/phantazm/core/guild/party/command/AbstractPartyCommandIntegrationTest.java
@@ -1,27 +1,31 @@
 package org.phantazm.core.guild.party.command;
 
+import net.kyori.adventure.text.Component;
 import net.minestom.testing.EnvTest;
 import org.jetbrains.annotations.NotNull;
 import org.junit.jupiter.api.BeforeEach;
+import org.phantazm.core.guild.GuildHolder;
 import org.phantazm.core.guild.party.Party;
 import org.phantazm.core.player.IdentitySource;
 
-import java.util.HashMap;
-import java.util.Map;
-import java.util.Optional;
-import java.util.UUID;
+import java.util.*;
 import java.util.concurrent.CompletableFuture;
 
 @EnvTest
 public class AbstractPartyCommandIntegrationTest {
 
-    protected Map<? super UUID, Party> parties;
+    protected PartyCommandConfig commandConfig =
+            new PartyCommandConfig(Component.empty(), Component.empty(), Component.empty(), "", "", Component.empty(),
+                    Component.empty(), Component.empty(), Component.empty(), "", "", Component.empty(),
+                    Component.empty(), "", Component.empty(), "", "", "", "");
+
+    protected GuildHolder<Party> partyHolder;
 
     protected IdentitySource identitySource;
 
     @BeforeEach
     public void setup() {
-        parties = new HashMap<>();
+        partyHolder = new GuildHolder<>(new HashMap<>(), new ArrayList<>());
         identitySource = new IdentitySource() {
             @Override
             public @NotNull CompletableFuture<Optional<String>> getName(@NotNull UUID uuid) {
diff --git a/core/src/test/java/org/phantazm/core/guild/party/command/PartyCreateCommandIntegrationTest.java b/core/src/test/java/org/phantazm/core/guild/party/command/PartyCreateCommandIntegrationTest.java
index a345d044b..d5955d540 100644
--- a/core/src/test/java/org/phantazm/core/guild/party/command/PartyCreateCommandIntegrationTest.java
+++ b/core/src/test/java/org/phantazm/core/guild/party/command/PartyCreateCommandIntegrationTest.java
@@ -1,5 +1,6 @@
 package org.phantazm.core.guild.party.command;
 
+import net.kyori.adventure.text.minimessage.MiniMessage;
 import net.minestom.server.command.builder.Command;
 import net.minestom.server.coordinate.Pos;
 import net.minestom.server.entity.Player;
@@ -7,11 +8,14 @@
 import net.minestom.testing.Env;
 import net.minestom.testing.EnvTest;
 import org.junit.jupiter.api.Test;
+import org.phantazm.core.guild.party.Party;
 import org.phantazm.core.guild.party.PartyCreator;
 import org.phantazm.core.player.BasicPlayerViewProvider;
 import org.phantazm.core.player.PlayerViewProvider;
 
-import static org.junit.jupiter.api.Assertions.assertTrue;
+import java.util.Random;
+
+import static org.junit.jupiter.api.Assertions.*;
 
 @EnvTest
 public class PartyCreateCommandIntegrationTest extends AbstractPartyCommandIntegrationTest {
@@ -20,15 +24,37 @@ public class PartyCreateCommandIntegrationTest extends AbstractPartyCommandInteg
     @Test
     public void testCreateCreatesParty(Env env) {
         PlayerViewProvider viewProvider = new BasicPlayerViewProvider(identitySource, env.process().connection());
-        PartyCreator partyCreator = new PartyCreator(1, 0, 20, 1, 1);
-        Command command = PartyCommand.command(parties, viewProvider, partyCreator);
+        PartyCreator partyCreator = new PartyCreator.Builder().build();
+        Command command = PartyCommand.partyCommand(commandConfig, MiniMessage.miniMessage(), partyHolder, viewProvider,
+                partyCreator, new Random());
         env.process().command().register(command);
         Instance instance = env.createFlatInstance();
         Player player = env.createPlayer(instance, Pos.ZERO);
 
         env.process().command().execute(player, "party create");
 
-        assertTrue(parties.containsKey(player.getUuid()));
+        Party party = partyHolder.uuidToGuild().get(player.getUuid());
+        assertNotNull(party);
+        assertEquals(1, partyHolder.guilds().size());
+        assertEquals(party, partyHolder.guilds().iterator().next());
+    }
+
+    @SuppressWarnings({"UnstableApiUsage", "JUnitMalformedDeclaration"})
+    @Test
+    public void testCreateDoesNotCreatePartyIfAlreadyInParty(Env env) {
+        PlayerViewProvider viewProvider = new BasicPlayerViewProvider(identitySource, env.process().connection());
+        PartyCreator partyCreator = new PartyCreator.Builder().build();
+        Command command = PartyCommand.partyCommand(commandConfig, MiniMessage.miniMessage(), partyHolder, viewProvider,
+                partyCreator, new Random());
+        env.process().command().register(command);
+        Instance instance = env.createFlatInstance();
+        Player player = env.createPlayer(instance, Pos.ZERO);
+        env.process().command().execute(player, "party create");
+        Party party = partyHolder.uuidToGuild().get(player.getUuid());
+
+        env.process().command().execute(player, "party create");
+
+        assertEquals(party, partyHolder.uuidToGuild().get(player.getUuid()));
     }
 
 }
diff --git a/core/src/test/java/org/phantazm/core/guild/party/command/PartyInviteCommandIntegrationTest.java b/core/src/test/java/org/phantazm/core/guild/party/command/PartyInviteCommandIntegrationTest.java
index bfd8241d4..b228215be 100644
--- a/core/src/test/java/org/phantazm/core/guild/party/command/PartyInviteCommandIntegrationTest.java
+++ b/core/src/test/java/org/phantazm/core/guild/party/command/PartyInviteCommandIntegrationTest.java
@@ -1,5 +1,6 @@
 package org.phantazm.core.guild.party.command;
 
+import net.kyori.adventure.text.minimessage.MiniMessage;
 import net.minestom.server.command.builder.Command;
 import net.minestom.server.coordinate.Pos;
 import net.minestom.server.entity.Player;
@@ -12,8 +13,9 @@
 import org.phantazm.core.player.BasicPlayerViewProvider;
 import org.phantazm.core.player.PlayerViewProvider;
 
-import static org.junit.jupiter.api.Assertions.assertFalse;
-import static org.junit.jupiter.api.Assertions.assertTrue;
+import java.util.Random;
+
+import static org.junit.jupiter.api.Assertions.*;
 
 @EnvTest
 public class PartyInviteCommandIntegrationTest extends AbstractPartyCommandIntegrationTest {
@@ -22,14 +24,14 @@ public class PartyInviteCommandIntegrationTest extends AbstractPartyCommandInteg
     @Test
     public void testCanInviteWithInvitePermission(Env env) {
         PlayerViewProvider viewProvider = new BasicPlayerViewProvider(identitySource, env.process().connection());
-        PartyCreator partyCreator = new PartyCreator(1, 0, 20, 1, 1);
-        Command command = PartyCommand.command(parties, viewProvider, partyCreator);
+        PartyCreator partyCreator = new PartyCreator.Builder().build();
+        Command command = PartyCommand.partyCommand(commandConfig, MiniMessage.miniMessage(), partyHolder, viewProvider, partyCreator, new Random());
         env.process().command().register(command);
         Instance instance = env.createFlatInstance();
         Player firstPlayer = env.createPlayer(instance, Pos.ZERO);
         firstPlayer.setUsernameField("first");
         env.process().command().execute(firstPlayer, "party create");
-        Party party = parties.get(firstPlayer.getUuid());
+        Party party = partyHolder.uuidToGuild().get(firstPlayer.getUuid());
         Player secondPlayer = env.createPlayer(instance, Pos.ZERO);
         secondPlayer.setUsernameField("second");
 
@@ -42,14 +44,14 @@ public void testCanInviteWithInvitePermission(Env env) {
     @Test
     public void testCanInviteOtherPlayerInPartyWithInvitePermission(Env env) {
         PlayerViewProvider viewProvider = new BasicPlayerViewProvider(identitySource, env.process().connection());
-        PartyCreator partyCreator = new PartyCreator(1, 0, 20, 1, 1);
-        Command command = PartyCommand.command(parties, viewProvider, partyCreator);
+        PartyCreator partyCreator = new PartyCreator.Builder().build();
+        Command command = PartyCommand.partyCommand(commandConfig, MiniMessage.miniMessage(), partyHolder, viewProvider, partyCreator, new Random());
         env.process().command().register(command);
         Instance instance = env.createFlatInstance();
         Player firstPlayer = env.createPlayer(instance, Pos.ZERO);
         firstPlayer.setUsernameField("first");
         env.process().command().execute(firstPlayer, "party create");
-        Party party = parties.get(firstPlayer.getUuid());
+        Party party = partyHolder.uuidToGuild().get(firstPlayer.getUuid());
         Player secondPlayer = env.createPlayer(instance, Pos.ZERO);
         secondPlayer.setUsernameField("second");
         env.process().command().execute(secondPlayer, "party create");
@@ -63,14 +65,14 @@ public void testCanInviteOtherPlayerInPartyWithInvitePermission(Env env) {
     @Test
     public void testCannotInviteWithoutInvitePermission(Env env) {
         PlayerViewProvider viewProvider = new BasicPlayerViewProvider(identitySource, env.process().connection());
-        PartyCreator partyCreator = new PartyCreator(1, 0, 20, 1, 2);
-        Command command = PartyCommand.command(parties, viewProvider, partyCreator);
+        PartyCreator partyCreator = new PartyCreator.Builder().setMinimumInviteRank(2).build();
+        Command command = PartyCommand.partyCommand(commandConfig, MiniMessage.miniMessage(), partyHolder, viewProvider, partyCreator, new Random());
         env.process().command().register(command);
         Instance instance = env.createFlatInstance();
         Player firstPlayer = env.createPlayer(instance, Pos.ZERO);
         firstPlayer.setUsernameField("first");
         env.process().command().execute(firstPlayer, "party create");
-        Party party = parties.get(firstPlayer.getUuid());
+        Party party = partyHolder.uuidToGuild().get(firstPlayer.getUuid());
         Player secondPlayer = env.createPlayer(instance, Pos.ZERO);
         secondPlayer.setUsernameField("second");
 
@@ -83,17 +85,38 @@ public void testCannotInviteWithoutInvitePermission(Env env) {
     @Test
     public void testCannotInviteSelf(Env env) {
         PlayerViewProvider viewProvider = new BasicPlayerViewProvider(identitySource, env.process().connection());
-        PartyCreator partyCreator = new PartyCreator(1, 0, 20, 1, 1);
-        Command command = PartyCommand.command(parties, viewProvider, partyCreator);
+        PartyCreator partyCreator = new PartyCreator.Builder().build();
+        Command command = PartyCommand.partyCommand(commandConfig, MiniMessage.miniMessage(), partyHolder, viewProvider, partyCreator, new Random());
         env.process().command().register(command);
         Instance instance = env.createFlatInstance();
         Player player = env.createPlayer(instance, Pos.ZERO);
         env.process().command().execute(player, "party create");
-        Party party = parties.get(player.getUuid());
+        Party party = partyHolder.uuidToGuild().get(player.getUuid());
 
         env.process().command().execute(player, "party invite " + player.getUsername());
 
         assertFalse(party.getInvitationManager().hasInvitation(player.getUuid()));
     }
 
+    @SuppressWarnings({"UnstableApiUsage", "JUnitMalformedDeclaration"})
+    @Test
+    public void testPartyCreatedOnInviteWithoutAlreadyBeingInParty(Env env) {
+        PlayerViewProvider viewProvider = new BasicPlayerViewProvider(identitySource, env.process().connection());
+        PartyCreator partyCreator = new PartyCreator.Builder().build();
+        Command command = PartyCommand.partyCommand(commandConfig, MiniMessage.miniMessage(), partyHolder, viewProvider, partyCreator, new Random());
+        env.process().command().register(command);
+        Instance instance = env.createFlatInstance();
+        Player firstPlayer = env.createPlayer(instance, Pos.ZERO);
+        firstPlayer.setUsernameField("first");
+        Player secondPlayer = env.createPlayer(instance, Pos.ZERO);
+        secondPlayer.setUsernameField("second");
+
+        env.process().command().execute(firstPlayer, "party invite second");
+
+        Party party = partyHolder.uuidToGuild().get(firstPlayer.getUuid());
+        assertEquals(1, partyHolder.guilds().size());
+        assertEquals(party, partyHolder.guilds().iterator().next());
+        assertTrue(party.getInvitationManager().hasInvitation(secondPlayer.getUuid()));
+    }
+
 }
diff --git a/core/src/test/java/org/phantazm/core/guild/party/command/PartyJoinCommandIntegrationTest.java b/core/src/test/java/org/phantazm/core/guild/party/command/PartyJoinCommandIntegrationTest.java
index a12be179c..297d61ac8 100644
--- a/core/src/test/java/org/phantazm/core/guild/party/command/PartyJoinCommandIntegrationTest.java
+++ b/core/src/test/java/org/phantazm/core/guild/party/command/PartyJoinCommandIntegrationTest.java
@@ -1,5 +1,6 @@
 package org.phantazm.core.guild.party.command;
 
+import net.kyori.adventure.text.minimessage.MiniMessage;
 import net.minestom.server.command.builder.Command;
 import net.minestom.server.coordinate.Pos;
 import net.minestom.server.entity.Player;
@@ -12,6 +13,8 @@
 import org.phantazm.core.player.BasicPlayerViewProvider;
 import org.phantazm.core.player.PlayerViewProvider;
 
+import java.util.Random;
+
 import static org.junit.jupiter.api.Assertions.*;
 
 @EnvTest
@@ -21,39 +24,62 @@ public class PartyJoinCommandIntegrationTest extends AbstractPartyCommandIntegra
     @Test
     public void testNotInPartyAfterJoiningOtherPlayerNotInParty(Env env) {
         PlayerViewProvider viewProvider = new BasicPlayerViewProvider(identitySource, env.process().connection());
-        PartyCreator partyCreator = new PartyCreator(1, 0, 20, 1, 1);
-        Command command = PartyCommand.command(parties, viewProvider, partyCreator);
+        PartyCreator partyCreator = new PartyCreator.Builder().build();
+        Command command = PartyCommand.partyCommand(commandConfig, MiniMessage.miniMessage(), partyHolder, viewProvider, partyCreator, new Random());
+        env.process().command().register(command);
+        Instance instance = env.createFlatInstance();
+        Player firstPlayer = env.createPlayer(instance, Pos.ZERO);
+        firstPlayer.setUsernameField("first");
+        Player secondPlayer = env.createPlayer(instance, Pos.ZERO);
+        secondPlayer.setUsernameField("second");
+
+        env.process().command().execute(secondPlayer, "party join first");
+
+        assertFalse(partyHolder.uuidToGuild().containsKey(firstPlayer.getUuid()));
+        assertFalse(partyHolder.uuidToGuild().containsKey(secondPlayer.getUuid()));
+    }
+
+    @SuppressWarnings({"UnstableApiUsage", "JUnitMalformedDeclaration"})
+    @Test
+    public void testNotInPartyWithoutInviteAndJoiningOtherPlayerInParty(Env env) {
+        PlayerViewProvider viewProvider = new BasicPlayerViewProvider(identitySource, env.process().connection());
+        PartyCreator partyCreator = new PartyCreator.Builder().build();
+        Command command = PartyCommand.partyCommand(commandConfig, MiniMessage.miniMessage(), partyHolder, viewProvider, partyCreator, new Random());
         env.process().command().register(command);
         Instance instance = env.createFlatInstance();
         Player firstPlayer = env.createPlayer(instance, Pos.ZERO);
         firstPlayer.setUsernameField("first");
+        env.process().command().execute(firstPlayer, "party create");
+        Party party = partyHolder.uuidToGuild().get(firstPlayer.getUuid());
         Player secondPlayer = env.createPlayer(instance, Pos.ZERO);
         secondPlayer.setUsernameField("second");
 
         env.process().command().execute(secondPlayer, "party join first");
 
-        assertFalse(parties.containsKey(firstPlayer.getUuid()));
-        assertFalse(parties.containsKey(secondPlayer.getUuid()));
+        assertFalse(partyHolder.uuidToGuild().containsKey(secondPlayer.getUuid()));
+        assertFalse(party.getMemberManager().hasMember(secondPlayer.getUuid()));
     }
 
     @SuppressWarnings({"UnstableApiUsage", "JUnitMalformedDeclaration"})
     @Test
-    public void testInPartyAfterJoiningOtherPlayerInParty(Env env) {
+    public void testInPartyAfterInviteAndJoiningOtherPlayerInParty(Env env) {
         PlayerViewProvider viewProvider = new BasicPlayerViewProvider(identitySource, env.process().connection());
-        PartyCreator partyCreator = new PartyCreator(1, 0, 20, 1, 1);
-        Command command = PartyCommand.command(parties, viewProvider, partyCreator);
+        PartyCreator partyCreator = new PartyCreator.Builder().build();
+        Command command = PartyCommand.partyCommand(commandConfig, MiniMessage.miniMessage(), partyHolder, viewProvider, partyCreator, new Random());
         env.process().command().register(command);
         Instance instance = env.createFlatInstance();
         Player firstPlayer = env.createPlayer(instance, Pos.ZERO);
         firstPlayer.setUsernameField("first");
         env.process().command().execute(firstPlayer, "party create");
-        Party party = parties.get(firstPlayer.getUuid());
+        Party party = partyHolder.uuidToGuild().get(firstPlayer.getUuid());
         Player secondPlayer = env.createPlayer(instance, Pos.ZERO);
         secondPlayer.setUsernameField("second");
+        party.getInvitationManager().invite(party.getMemberManager().getMember(firstPlayer.getUuid()),
+                viewProvider.fromPlayer(secondPlayer));
 
         env.process().command().execute(secondPlayer, "party join first");
 
-        assertEquals(party, parties.get(secondPlayer.getUuid()));
+        assertEquals(party, partyHolder.uuidToGuild().get(secondPlayer.getUuid()));
         assertTrue(party.getMemberManager().hasMember(secondPlayer.getUuid()));
     }
 
diff --git a/core/src/test/java/org/phantazm/core/guild/party/command/PartyKickCommandIntegrationTest.java b/core/src/test/java/org/phantazm/core/guild/party/command/PartyKickCommandIntegrationTest.java
index 16f930afb..736189d4c 100644
--- a/core/src/test/java/org/phantazm/core/guild/party/command/PartyKickCommandIntegrationTest.java
+++ b/core/src/test/java/org/phantazm/core/guild/party/command/PartyKickCommandIntegrationTest.java
@@ -1,5 +1,6 @@
 package org.phantazm.core.guild.party.command;
 
+import net.kyori.adventure.text.minimessage.MiniMessage;
 import net.minestom.server.command.builder.Command;
 import net.minestom.server.coordinate.Pos;
 import net.minestom.server.entity.Player;
@@ -11,6 +12,8 @@
 import org.phantazm.core.player.BasicPlayerViewProvider;
 import org.phantazm.core.player.PlayerViewProvider;
 
+import java.util.Random;
+
 import static org.junit.jupiter.api.Assertions.*;
 
 public class PartyKickCommandIntegrationTest extends AbstractPartyCommandIntegrationTest {
@@ -19,21 +22,22 @@ public class PartyKickCommandIntegrationTest extends AbstractPartyCommandIntegra
     @Test
     public void testCanKickWithSufficientRankAndGreaterRankThanTarget(Env env) {
         PlayerViewProvider viewProvider = new BasicPlayerViewProvider(identitySource, env.process().connection());
-        PartyCreator partyCreator = new PartyCreator(1, 0, 20, 1, 1);
-        Command command = PartyCommand.command(parties, viewProvider, partyCreator);
+        PartyCreator partyCreator = new PartyCreator.Builder().build();
+        Command command = PartyCommand.partyCommand(commandConfig, MiniMessage.miniMessage(), partyHolder, viewProvider, partyCreator, new Random());
         env.process().command().register(command);
         Instance instance = env.createFlatInstance();
         Player firstPlayer = env.createPlayer(instance, Pos.ZERO);
         firstPlayer.setUsernameField("first");
         env.process().command().execute(firstPlayer, "party create");
-        Party party = parties.get(firstPlayer.getUuid());
+        Party party = partyHolder.uuidToGuild().get(firstPlayer.getUuid());
         Player secondPlayer = env.createPlayer(instance, Pos.ZERO);
         secondPlayer.setUsernameField("second");
+        env.process().command().execute(firstPlayer, "party invite second");
         env.process().command().execute(secondPlayer, "party join first");
 
         env.process().command().execute(firstPlayer, "party kick second");
 
-        assertFalse(parties.containsKey(secondPlayer.getUuid()));
+        assertFalse(partyHolder.uuidToGuild().containsKey(secondPlayer.getUuid()));
         assertFalse(party.getMemberManager().hasMember(secondPlayer.getUuid()));
     }
 
@@ -41,21 +45,22 @@ public void testCanKickWithSufficientRankAndGreaterRankThanTarget(Env env) {
     @Test
     public void testCannotKickWithoutSufficientRankAndGreaterRankThanTarget(Env env) {
         PlayerViewProvider viewProvider = new BasicPlayerViewProvider(identitySource, env.process().connection());
-        PartyCreator partyCreator = new PartyCreator(1, 0, 20, 2, 1);
-        Command command = PartyCommand.command(parties, viewProvider, partyCreator);
+        PartyCreator partyCreator = new PartyCreator.Builder().setMinimumKickRank(2).build();
+        Command command = PartyCommand.partyCommand(commandConfig, MiniMessage.miniMessage(), partyHolder, viewProvider, partyCreator, new Random());
         env.process().command().register(command);
         Instance instance = env.createFlatInstance();
         Player firstPlayer = env.createPlayer(instance, Pos.ZERO);
         firstPlayer.setUsernameField("first");
         env.process().command().execute(firstPlayer, "party create");
-        Party party = parties.get(firstPlayer.getUuid());
+        Party party = partyHolder.uuidToGuild().get(firstPlayer.getUuid());
         Player secondPlayer = env.createPlayer(instance, Pos.ZERO);
         secondPlayer.setUsernameField("second");
+        env.process().command().execute(firstPlayer, "party invite second");
         env.process().command().execute(secondPlayer, "party join first");
 
         env.process().command().execute(firstPlayer, "party kick second");
 
-        assertEquals(party, parties.get(secondPlayer.getUuid()));
+        assertEquals(party, partyHolder.uuidToGuild().get(secondPlayer.getUuid()));
         assertTrue(party.getMemberManager().hasMember(secondPlayer.getUuid()));
     }
 
@@ -63,22 +68,23 @@ public void testCannotKickWithoutSufficientRankAndGreaterRankThanTarget(Env env)
     @Test
     public void testCannotKickWithSufficientRankAndEqualRankToTarget(Env env) {
         PlayerViewProvider viewProvider = new BasicPlayerViewProvider(identitySource, env.process().connection());
-        PartyCreator partyCreator = new PartyCreator(1, 0, 20, 2, 1);
-        Command command = PartyCommand.command(parties, viewProvider, partyCreator);
+        PartyCreator partyCreator = new PartyCreator.Builder().setDefaultRank(2).build();
+        Command command = PartyCommand.partyCommand(commandConfig, MiniMessage.miniMessage(), partyHolder, viewProvider, partyCreator, new Random());
         env.process().command().register(command);
         Instance instance = env.createFlatInstance();
         Player firstPlayer = env.createPlayer(instance, Pos.ZERO);
         firstPlayer.setUsernameField("first");
         env.process().command().execute(firstPlayer, "party create");
-        Party party = parties.get(firstPlayer.getUuid());
+        Party party = partyHolder.uuidToGuild().get(firstPlayer.getUuid());
         Player secondPlayer = env.createPlayer(instance, Pos.ZERO);
         secondPlayer.setUsernameField("second");
+        env.process().command().execute(firstPlayer, "party invite second");
         env.process().command().execute(secondPlayer, "party join first");
         party.getMemberManager().getMember(secondPlayer.getUuid()).setRank(1);
 
         env.process().command().execute(firstPlayer, "party kick second");
 
-        assertEquals(party, parties.get(secondPlayer.getUuid()));
+        assertEquals(party, partyHolder.uuidToGuild().get(secondPlayer.getUuid()));
         assertTrue(party.getMemberManager().hasMember(secondPlayer.getUuid()));
     }
 
@@ -86,17 +92,17 @@ public void testCannotKickWithSufficientRankAndEqualRankToTarget(Env env) {
     @Test
     public void testCannotKickSelf(Env env) {
         PlayerViewProvider viewProvider = new BasicPlayerViewProvider(identitySource, env.process().connection());
-        PartyCreator partyCreator = new PartyCreator(1, 0, 20, 2, 1);
-        Command command = PartyCommand.command(parties, viewProvider, partyCreator);
+        PartyCreator partyCreator = new PartyCreator.Builder().setDefaultRank(2).build();
+        Command command = PartyCommand.partyCommand(commandConfig, MiniMessage.miniMessage(), partyHolder, viewProvider, partyCreator, new Random());
         env.process().command().register(command);
         Instance instance = env.createFlatInstance();
         Player player = env.createPlayer(instance, Pos.ZERO);
         env.process().command().execute(player, "party create");
-        Party party = parties.get(player.getUuid());
+        Party party = partyHolder.uuidToGuild().get(player.getUuid());
 
         env.process().command().execute(player, "party kick " + player.getUsername());
 
-        assertEquals(party, parties.get(player.getUuid()));
+        assertEquals(party, partyHolder.uuidToGuild().get(player.getUuid()));
         assertTrue(party.getMemberManager().hasMember(player.getUuid()));
     }
 
diff --git a/core/src/test/java/org/phantazm/core/guild/party/command/PartyLeaveCommandIntegrationTest.java b/core/src/test/java/org/phantazm/core/guild/party/command/PartyLeaveCommandIntegrationTest.java
index 6824e6b39..c842b8285 100644
--- a/core/src/test/java/org/phantazm/core/guild/party/command/PartyLeaveCommandIntegrationTest.java
+++ b/core/src/test/java/org/phantazm/core/guild/party/command/PartyLeaveCommandIntegrationTest.java
@@ -1,5 +1,6 @@
 package org.phantazm.core.guild.party.command;
 
+import net.kyori.adventure.text.minimessage.MiniMessage;
 import net.minestom.server.command.builder.Command;
 import net.minestom.server.coordinate.Pos;
 import net.minestom.server.entity.Player;
@@ -12,27 +13,55 @@
 import org.phantazm.core.player.BasicPlayerViewProvider;
 import org.phantazm.core.player.PlayerViewProvider;
 
-import static org.junit.jupiter.api.Assertions.assertFalse;
+import java.util.Random;
+
+import static org.junit.jupiter.api.Assertions.*;
 
 @EnvTest
 public class PartyLeaveCommandIntegrationTest extends AbstractPartyCommandIntegrationTest {
 
     @SuppressWarnings({"UnstableApiUsage", "JUnitMalformedDeclaration"})
     @Test
-    public void testNotInPartyAfterLeaving(Env env) {
+    public void testNotInPartyAfterLeavingAndOwnerIsNullNoOtherMembers(Env env) {
         PlayerViewProvider viewProvider = new BasicPlayerViewProvider(identitySource, env.process().connection());
-        PartyCreator partyCreator = new PartyCreator(1, 0, 20, 1, 1);
-        Command command = PartyCommand.command(parties, viewProvider, partyCreator);
+        PartyCreator partyCreator = new PartyCreator.Builder().build();
+        Command command = PartyCommand.partyCommand(commandConfig, MiniMessage.miniMessage(), partyHolder, viewProvider, partyCreator, new Random());
         env.process().command().register(command);
         Instance instance = env.createFlatInstance();
         Player player = env.createPlayer(instance, Pos.ZERO);
         env.process().command().execute(player, "party create");
-        Party party = parties.get(player.getUuid());
+        Party party = partyHolder.uuidToGuild().get(player.getUuid());
 
         env.process().command().execute(player, "party leave");
 
-        assertFalse(parties.containsKey(player.getUuid()));
+        assertFalse(partyHolder.uuidToGuild().containsKey(player.getUuid()));
         assertFalse(party.getMemberManager().hasMember(player.getUuid()));
+        assertNull(party.getOwner().get());
+    }
+
+    @SuppressWarnings({"UnstableApiUsage", "JUnitMalformedDeclaration"})
+    @Test
+    public void testOwnerIsNotNullAfterLeavingWithOtherMembers(Env env) {
+        PlayerViewProvider viewProvider = new BasicPlayerViewProvider(identitySource, env.process().connection());
+        PartyCreator partyCreator = new PartyCreator.Builder().build();
+        Command command = PartyCommand.partyCommand(commandConfig, MiniMessage.miniMessage(), partyHolder, viewProvider, partyCreator, new Random());
+        env.process().command().register(command);
+        Instance instance = env.createFlatInstance();
+        Player firstPlayer = env.createPlayer(instance, Pos.ZERO);
+        firstPlayer.setUsernameField("first");
+        env.process().command().execute(firstPlayer, "party create");
+        Player secondPlayer = env.createPlayer(instance, Pos.ZERO);
+        Party party = partyHolder.uuidToGuild().get(firstPlayer.getUuid());
+        secondPlayer.setUsernameField("second");
+        env.process().command().execute(firstPlayer, "party invite second");
+        env.process().command().execute(secondPlayer, "party join first");
+
+        env.process().command().execute(firstPlayer, "party leave");
+
+        assertFalse(partyHolder.uuidToGuild().containsKey(firstPlayer.getUuid()));
+        assertFalse(party.getMemberManager().hasMember(firstPlayer.getUuid()));
+        assertNotNull(party.getOwner().get());
+        assertNotEquals(firstPlayer.getUuid(), party.getOwner().get().getPlayerView().getUUID());
     }
 
 }
diff --git a/defaultRunData/server-1/lobbies-config.toml b/defaultRunData/server-1/lobbies-config.toml
deleted file mode 100644
index a5316103e..000000000
--- a/defaultRunData/server-1/lobbies-config.toml
+++ /dev/null
@@ -1,15 +0,0 @@
-instancesPath = "./lobbies"
-kickMessage = "<red>Couldn't find where to send you!"
-mainLobbyName = "main"
-
-[lobbies.main]
-lobbyPaths = ["main"]
-maxPlayers = 10
-maxLobbies = 10
-
-[lobbies.main.instanceConfig.spawnPoint]
-x = 0.0
-y = 0.0
-z = 0.0
-yaw = 0.0
-pitch = 0.0
diff --git a/defaultRunData/server-1/lobbies-config.yml b/defaultRunData/server-1/lobbies-config.yml
new file mode 100644
index 000000000..27ed3d79e
--- /dev/null
+++ b/defaultRunData/server-1/lobbies-config.yml
@@ -0,0 +1,13 @@
+instancesPath: "./lobbies"
+kickMessage: "<red>Couldn't find where to send you!"
+mainLobbyName: "main"
+
+lobbies:
+    main:
+        lobbyPaths: [ "main" ]
+        maxPlayers: 10
+        maxLobbies: 10
+
+        instanceConfig:
+            time: 18000
+            spawnPoint: { x: 8.0, y: -59.0, z: 8.0, yaw: 0.0, pitch: 0.0 }
diff --git a/defaultRunData/server-1/lobbies/main/DIM-1/data/raids.dat b/defaultRunData/server-1/lobbies/main/DIM-1/data/raids.dat
new file mode 100644
index 000000000..9bcedf7eb
Binary files /dev/null and b/defaultRunData/server-1/lobbies/main/DIM-1/data/raids.dat differ
diff --git a/defaultRunData/server-1/lobbies/main/DIM1/data/raids_end.dat b/defaultRunData/server-1/lobbies/main/DIM1/data/raids_end.dat
new file mode 100644
index 000000000..9bcedf7eb
Binary files /dev/null and b/defaultRunData/server-1/lobbies/main/DIM1/data/raids_end.dat differ
diff --git a/defaultRunData/server-1/lobbies/main/data/raids.dat b/defaultRunData/server-1/lobbies/main/data/raids.dat
new file mode 100644
index 000000000..9bcedf7eb
Binary files /dev/null and b/defaultRunData/server-1/lobbies/main/data/raids.dat differ
diff --git a/defaultRunData/server-1/lobbies/main/entities/r.-1.-1.mca b/defaultRunData/server-1/lobbies/main/entities/r.-1.-1.mca
new file mode 100644
index 000000000..e69de29bb
diff --git a/defaultRunData/server-1/lobbies/main/entities/r.-1.0.mca b/defaultRunData/server-1/lobbies/main/entities/r.-1.0.mca
new file mode 100644
index 000000000..e69de29bb
diff --git a/defaultRunData/server-1/lobbies/main/entities/r.0.-1.mca b/defaultRunData/server-1/lobbies/main/entities/r.0.-1.mca
new file mode 100644
index 000000000..e69de29bb
diff --git a/defaultRunData/server-1/lobbies/main/entities/r.0.0.mca b/defaultRunData/server-1/lobbies/main/entities/r.0.0.mca
new file mode 100644
index 000000000..e69de29bb
diff --git a/defaultRunData/server-1/lobbies/main/level.dat b/defaultRunData/server-1/lobbies/main/level.dat
new file mode 100644
index 000000000..7dcd08c78
Binary files /dev/null and b/defaultRunData/server-1/lobbies/main/level.dat differ
diff --git a/defaultRunData/server-1/lobbies/main/level.dat_old b/defaultRunData/server-1/lobbies/main/level.dat_old
new file mode 100644
index 000000000..7dcd08c78
Binary files /dev/null and b/defaultRunData/server-1/lobbies/main/level.dat_old differ
diff --git a/defaultRunData/server-1/lobbies/main/region/r.-1.-1.mca b/defaultRunData/server-1/lobbies/main/region/r.-1.-1.mca
new file mode 100644
index 000000000..e07646ee2
Binary files /dev/null and b/defaultRunData/server-1/lobbies/main/region/r.-1.-1.mca differ
diff --git a/defaultRunData/server-1/lobbies/main/region/r.-1.0.mca b/defaultRunData/server-1/lobbies/main/region/r.-1.0.mca
new file mode 100644
index 000000000..207ebdc02
Binary files /dev/null and b/defaultRunData/server-1/lobbies/main/region/r.-1.0.mca differ
diff --git a/defaultRunData/server-1/lobbies/main/region/r.0.-1.mca b/defaultRunData/server-1/lobbies/main/region/r.0.-1.mca
new file mode 100644
index 000000000..1da46eabe
Binary files /dev/null and b/defaultRunData/server-1/lobbies/main/region/r.0.-1.mca differ
diff --git a/defaultRunData/server-1/lobbies/main/region/r.0.0.mca b/defaultRunData/server-1/lobbies/main/region/r.0.0.mca
new file mode 100644
index 000000000..27f71b547
Binary files /dev/null and b/defaultRunData/server-1/lobbies/main/region/r.0.0.mca differ
diff --git a/defaultRunData/server-1/lobbies/main/session.lock b/defaultRunData/server-1/lobbies/main/session.lock
new file mode 100644
index 000000000..0d7e5f854
--- /dev/null
+++ b/defaultRunData/server-1/lobbies/main/session.lock
@@ -0,0 +1 @@
+☃
\ No newline at end of file
diff --git a/defaultRunData/server-1/party.toml b/defaultRunData/server-1/party.toml
new file mode 100644
index 000000000..90f5e273f
--- /dev/null
+++ b/defaultRunData/server-1/party.toml
@@ -0,0 +1,42 @@
+creatorRank = 1
+defaultRank = 0
+invitationDuration = 1200
+minimumKickRank = 1
+minimumInviteRank = 1
+minimumJoinRank = 1
+
+[tickFormatter]
+type = "core.tick_formatter.precision_second"
+decimalPlaces = 1
+
+[notificationConfig]
+joinToPartyFormat = "<gradient:#ff6c33:#ff76b5><st>⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯</st></gradient><br><#fffa9e>»</#fffa9e> <green><joiner></green> <#9096ad>has joined the party.</#9096ad><br><gradient:#ff6c33:#ff76b5><st>⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯</st></gradient>"
+joinToJoinerFormat = "<gradient:#ff6c33:#ff76b5><st>⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯</st></gradient><br><#fffa9e>»</#fffa9e> <#9096ad>Joined</#9096ad> <green><owner></green><#c0c9ed>'s</#c0c9ed> <#9096ad>party.</#9096ad><br><gradient:#ff6c33:#ff76b5><st>⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯</st></gradient>"
+inviteToPartyFormat = "<gradient:#ff6c33:#ff76b5><st>⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯</st></gradient><br><#fffa9e>»</#fffa9e> <green><inviter></green> <#9096ad>has invited</#9096ad> <green><invitee></green> <#9096ad>to the party. They have <red><duration></red><#b8bfde>s</#b8bfde> to accept.</#9096ad><br><gradient:#ff6c33:#ff76b5><st>⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯</st></gradient>"
+inviteToInviteeFromOwnerFormat = "<gradient:#ff6c33:#ff76b5><st>⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯</st></gradient><br><#fffa9e>»</#fffa9e> <green><owner></green> <#9096ad>has invited you to join their party. Click <red><b><u><click:run_command:'/party join <owner-username>'>HERE</click></u></b></red> to accept.</#9096ad><br><gradient:#ff6c33:#ff76b5><st>⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯</st></gradient>"
+inviteToInviteeFromOtherFormat = "<gradient:#ff6c33:#ff76b5><st>⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯</st></gradient><br><#fffa9e>»</#fffa9e> <green><inviter></green> <#9096ad>has invited you to join</#9096ad> <green><owner></green><#c0c9ed>'s</#c0c9ed> <#9096ad>party. Click <red><b><u><click:run_command:'/party join <owner-username>'>HERE</click></u></b></red> to accept.</#9096ad><br><gradient:#ff6c33:#ff76b5><st>⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯</st></gradient>"
+expiryToPartyFormat = "<gradient:#ff6c33:#ff76b5><st>⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯</st></gradient><br><#fffa9e>»</#fffa9e> <#9096ad>The invitation to <green><invitee></green> has expired.</#9096ad><br><gradient:#ff6c33:#ff76b5><st>⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯</st></gradient>"
+expiryToInviteeFormat = "<gradient:#ff6c33:#ff76b5><st>⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯</st></gradient><br><#fffa9e>»</#fffa9e> <#9096ad>The invitation to <green><owner></green><#c0c9ed>'s</#c0c9ed> party has expired.</#9096ad><br><gradient:#ff6c33:#ff76b5><st>⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯</st></gradient>"
+leaveToPartyFormat = "<gradient:#ff6c33:#ff76b5><st>⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯</st></gradient><br><#fffa9e>»</#fffa9e> <#9096ad><green><leaver></green> has left the party.</#9096ad><br><gradient:#ff6c33:#ff76b5><st>⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯</st></gradient>"
+leaveToLeaverFormat = "<gradient:#ff6c33:#ff76b5><st>⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯</st></gradient><br><#fffa9e>»</#fffa9e> <#9096ad>You left the party.</#9096ad><br><gradient:#ff6c33:#ff76b5><st>⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯</st></gradient>"
+kickToPartyFormat = "<gradient:#ff6c33:#ff76b5><st>⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯</st></gradient><br><#fffa9e>»</#fffa9e> <#9096ad><green><kicker></green> has kicked <green><kicked></green> out of the party.</#9096ad><br><gradient:#ff6c33:#ff76b5><st>⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯</st></gradient>"
+kickToKickedFormat = "<gradient:#ff6c33:#ff76b5><st>⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯</st></gradient><br><#fffa9e>»</#fffa9e> <#9096ad>You were kicked out of the party by <green><kicker></green>.</#9096ad><br><gradient:#ff6c33:#ff76b5><st>⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯</st></gradient>"
+transferFormat = "<gradient:#ff6c33:#ff76b5><st>⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯</st></gradient><br><#fffa9e>»</#fffa9e> <#9096ad>The party has been transferred from <green><from></green> to <green><to></green>.</#9096ad><br><gradient:#ff6c33:#ff76b5><st>⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯</st></gradient>"
+
+[commandConfig]
+notInParty = "<gradient:#ff6c33:#ff76b5><st>⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯</st></gradient><br><#fffa9e>»</#fffa9e> <red>You have to be in a party!</red><br><gradient:#ff6c33:#ff76b5><st>⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯</st></gradient>"
+alreadyInParty = "<gradient:#ff6c33:#ff76b5><st>⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯</st></gradient><br><#fffa9e>»</#fffa9e> <red>You are already in a party!</red><br><gradient:#ff6c33:#ff76b5><st>⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯</st></gradient>"
+mustBeAPlayer = "<gradient:#ff6c33:#ff76b5><st>⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯</st></gradient><br><#fffa9e>»</#fffa9e> <red>You have to be a player!</red><br><gradient:#ff6c33:#ff76b5><st>⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯</st></gradient>"
+playerNotOnlineFormat = "<gradient:#ff6c33:#ff76b5><st>⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯</st></gradient><br><#fffa9e>»</#fffa9e> <red><player> is not online.</red><br><gradient:#ff6c33:#ff76b5><st>⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯</st></gradient>"
+cannotFindPlayerFormat = "<gradient:#ff6c33:#ff76b5><st>⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯</st></gradient><br><#fffa9e>»</#fffa9e> <red>Cannot find anyone with the username <username>.</red><br><gradient:#ff6c33:#ff76b5><st>⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯</st></gradient>"
+createCommandSuccess = "<gradient:#ff6c33:#ff76b5><st>⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯</st></gradient><br><#fffa9e>»</#fffa9e> <#9096ad>Created a party.</#9096ad><br><gradient:#ff6c33:#ff76b5><st>⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯</st></gradient>"
+cannotInvitePlayers = "<gradient:#ff6c33:#ff76b5><st>⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯</st></gradient><br><#fffa9e>»</#fffa9e> <red>You can't invite players!</red><br><gradient:#ff6c33:#ff76b5><st>⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯</st></gradient>"
+automaticPartyCreation = "<gradient:#ff6c33:#ff76b5><st>⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯</st></gradient><br><#fffa9e>»</#fffa9e> <#9096ad>Automatically created a party.</#9096ad><br><gradient:#ff6c33:#ff76b5><st>⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯</st></gradient>"
+cannotInviteSelf = "<gradient:#ff6c33:#ff76b5><st>⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯</st></gradient><br><#fffa9e>»</#fffa9e> <red>You can't invite yourself!</red><br><gradient:#ff6c33:#ff76b5><st>⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯</st></gradient>"
+inviteeAlreadyInPartyFormat = "<gradient:#ff6c33:#ff76b5><st>⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯</st></gradient><br><#fffa9e>»</#fffa9e> <red><green><invitee></green> is already in a party!</red><br><gradient:#ff6c33:#ff76b5><st>⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯</st></gradient>"
+toJoinNotInParty = "<gradient:#ff6c33:#ff76b5><st>⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯</st></gradient><br><#fffa9e>»</#fffa9e> <red><green><target></green> is not in a party!</red><br><gradient:#ff6c33:#ff76b5><st>⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯</st></gradient>"
+cannotKickMembers = "<gradient:#ff6c33:#ff76b5><st>⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯</st></gradient><br><#fffa9e>»</#fffa9e> <red>You can't kick other members!</red><br><gradient:#ff6c33:#ff76b5><st>⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯</st></gradient>"
+noInvite = "<gradient:#ff6c33:#ff76b5><st>⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯</st></gradient><br><#fffa9e>»</#fffa9e> <red>You don't have an invite!</red><br><gradient:#ff6c33:#ff76b5><st>⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯</st></gradient>"
+toKickNotInPartyFormat = "<gradient:#ff6c33:#ff76b5><st>⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯</st></gradient><br><#fffa9e>»</#fffa9e> <red><green><kicked></green> isn't in your party!</red><br><gradient:#ff6c33:#ff76b5><st>⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯</st></gradient>"
+cannotKickSelf = "<gradient:#ff6c33:#ff76b5><st>⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯</st></gradient><br><#fffa9e>»</#fffa9e> <red>You can't kick yourself!</red><br><gradient:#ff6c33:#ff76b5><st>⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯</st></gradient>"
+cannotKickOtherFormat = "<gradient:#ff6c33:#ff76b5><st>⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯</st></gradient><br><#fffa9e>»</#fffa9e> <red>You can't kick <green><kicked></green>!</red><br><gradient:#ff6c33:#ff76b5><st>⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯</st></gradient>"
diff --git a/defaultRunData/server-1/permissions.yml b/defaultRunData/server-1/permissions.yml
new file mode 100644
index 000000000..fd5cf01dc
--- /dev/null
+++ b/defaultRunData/server-1/permissions.yml
@@ -0,0 +1,5 @@
+groupPermissions:
+    -   key: admin
+        value:
+            - '*'
+groups: [ ]
diff --git a/defaultRunData/server-1/shutdown-config.toml b/defaultRunData/server-1/shutdown-config.toml
new file mode 100644
index 000000000..e69de29bb
diff --git a/defaultRunData/server-1/whisper.toml b/defaultRunData/server-1/whisper.toml
new file mode 100644
index 000000000..b0362162e
--- /dev/null
+++ b/defaultRunData/server-1/whisper.toml
@@ -0,0 +1,5 @@
+toTargetFormat = "<b><#d277c1>From</#d277c1></b> <sender> <#b8bfde>></#b8bfde> <#9096ad><message></#9096ad>"
+toSenderFormat = "<b><#d277c1>To</#d277c1></b> <target> <#b8bfde>></#b8bfde> <#9096ad><message></#9096ad>"
+fallbackNameColor = { r = 152, g = 255, b = 152 }
+consoleName = "<dark_red>Console</dark_red>"
+defaultName = "Unknown"
diff --git a/defaultRunData/server-1/zombies.db b/defaultRunData/server-1/zombies.db
new file mode 100644
index 000000000..1d0665356
Binary files /dev/null and b/defaultRunData/server-1/zombies.db differ
diff --git a/defaultRunData/server-1/zombies.hikari.properties b/defaultRunData/server-1/zombies.hikari.properties
new file mode 100644
index 000000000..6e2cae748
--- /dev/null
+++ b/defaultRunData/server-1/zombies.hikari.properties
@@ -0,0 +1,2 @@
+dataSourceClassName=org.sqlite.SQLiteDataSource
+dataSource.url=jdbc:sqlite:zombies.db
diff --git a/defaultRunData/velocity/velocity.jar b/defaultRunData/velocity/velocity.jar
index 6437fb404..0ea796c10 100644
Binary files a/defaultRunData/velocity/velocity.jar and b/defaultRunData/velocity/velocity.jar differ
diff --git a/defaultRunData/velocity/velocity.toml b/defaultRunData/velocity/velocity.toml
index 429addec3..f62f352f9 100644
--- a/defaultRunData/velocity/velocity.toml
+++ b/defaultRunData/velocity/velocity.toml
@@ -94,10 +94,10 @@ compression-level = -1
 login-ratelimit = 3000
 
 # Specify a custom timeout for connection timeouts here. The default is five seconds.
-connection-timeout = 5000
+connection-timeout = 86400000
 
 # Specify a read timeout for connections here. The default is 30 seconds.
-read-timeout = 30000
+read-timeout = 86400000
 
 # Enables compatibility with HAProxy's PROXY protocol. If you don't know what this is for, then
 # don't enable it.
diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml
index 517b4b9a3..83d2cd328 100644
--- a/gradle/libs.versions.toml
+++ b/gradle/libs.versions.toml
@@ -3,13 +3,13 @@ metadata.format.version = "1.1"
 [versions]
 adventure = "4.12.0"
 
-ethylene = "0.19.1"
+ethylene = "0.20.1"
 
 examination = "1.3.0"
 
 junit-jupiter = "5.9.0"
 
-minestom = "3f0d31f441"
+minestom = "d9cd6dd44e"
 
 toolkit = "0.3.0"
 
@@ -27,7 +27,7 @@ caffeine = { module = "com.github.ben-manes.caffeine:caffeine", version = "3.1.1
 
 commons-lang3 = { module = "org.apache.commons:commons-lang3", version = "3.12.0" }
 
-element-core = { module = "com.github.steanky:element-core", version = "0.14.2" }
+element-core = { module = "com.github.steanky:element-core", version = "0.14.3" }
 
 ethylene-core = { module = "com.github.steanky:ethylene-core", version.ref = "ethylene" }
 ethylene-hjson = { module = "com.github.steanky:ethylene-hjson", version.ref = "ethylene" }
@@ -41,13 +41,19 @@ fabric-api = { module = "net.fabricmc.fabric-api:fabric-api", version = "0.83.0+
 
 fastutil = { module = "it.unimi.dsi:fastutil", version = "8.5.8" }
 
+hikariCP = { module = "com.zaxxer:HikariCP", version = "5.0.1" }
+
 jetbrains-annotations = { module = "org.jetbrains:annotations", version = "23.0.0" }
 
+jOOQ = { module = "org.jooq:jooq", version = "3.18.4" }
+
 junit-jupiter-api = { module = "org.junit.jupiter:junit-jupiter-api", version.ref = "junit-jupiter" }
 junit-jupiter-engine = { module = "org.junit.jupiter:junit-jupiter-engine", version.ref = "junit-jupiter" }
 
 libgui = { module = "io.github.cottonmc:LibGui", version = "7.1.0+1.19.4" }
 
+mariadb = { module = "org.mariadb.jdbc:mariadb-java-client", version = "3.0.10" }
+
 minecraft = { module = "com.mojang:minecraft", version = "1.19.4" }
 
 minestom = { module = "org.phantazm.Minestom:Minestom", version.ref = "minestom" }
@@ -56,10 +62,12 @@ minestom-testing = { module = "org.phantazm.Minestom:testing", version.ref = "mi
 
 mockito-junit-jupiter = { module = "org.mockito:mockito-junit-jupiter", version = "4.7.0" }
 
-proxima-core = { module = "com.github.steanky:proxima-core", version = "0.4.3" }
+proxima-core = { module = "com.github.steanky:proxima-core", version = "0.6.1" }
 
 renderer = { module = "com.github.0x3C50:Renderer", version = "e1bb03f45e" }
 
+sqlite = { module = "org.xerial:sqlite-jdbc", version = "3.42.0.0" }
+
 snakeyaml = { module = "org.snakeyaml:snakeyaml-engine", version = "2.3" }
 
 toolkit-collection = { module = "com.github.steanky:toolkit-collection", version.ref = "toolkit" }
diff --git a/minestom b/minestom
new file mode 160000
index 000000000..05a7ad75b
--- /dev/null
+++ b/minestom
@@ -0,0 +1 @@
+Subproject commit 05a7ad75b4e0879bcba9c49afdd7ae0457cb67d3
diff --git a/mob/build.gradle.kts b/mob/build.gradle.kts
index 2ea367de2..b62641911 100644
--- a/mob/build.gradle.kts
+++ b/mob/build.gradle.kts
@@ -4,7 +4,6 @@ plugins {
 
 dependencies {
     api(projects.phantazmProximaMinestom)
-    implementation(projects.phantazmCore)
-    implementation(projects.phantazmCommons)
-    implementation(libs.adventure.text.minimessage)
+    api(projects.phantazmCore)
+    api(projects.phantazmCommons)
 }
diff --git a/mob/src/main/java/org/phantazm/mob/PhantazmMob.java b/mob/src/main/java/org/phantazm/mob/PhantazmMob.java
index 86e13c6b7..0d3a37102 100644
--- a/mob/src/main/java/org/phantazm/mob/PhantazmMob.java
+++ b/mob/src/main/java/org/phantazm/mob/PhantazmMob.java
@@ -1,6 +1,8 @@
 package org.phantazm.mob;
 
 import net.kyori.adventure.key.Key;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Unmodifiable;
 import org.phantazm.mob.skill.Skill;
 import org.phantazm.proxima.bindings.minestom.ProximaEntity;
 
@@ -8,9 +10,9 @@
 import java.util.Map;
 
 public interface PhantazmMob {
-    MobModel model();
+    @NotNull MobModel model();
 
-    ProximaEntity entity();
+    @NotNull ProximaEntity entity();
 
-    Map<Key, Collection<Skill>> triggers();
+    @NotNull @Unmodifiable Map<Key, Collection<Skill>> triggers();
 }
diff --git a/mob/src/main/java/org/phantazm/mob/skill/RadialDamageEntitySkill.java b/mob/src/main/java/org/phantazm/mob/skill/RadialDamageEntitySkill.java
new file mode 100644
index 000000000..3aae5f826
--- /dev/null
+++ b/mob/src/main/java/org/phantazm/mob/skill/RadialDamageEntitySkill.java
@@ -0,0 +1,61 @@
+package org.phantazm.mob.skill;
+
+import com.github.steanky.element.core.annotation.*;
+import net.minestom.server.entity.LivingEntity;
+import net.minestom.server.entity.damage.DamageType;
+import org.jetbrains.annotations.NotNull;
+import org.phantazm.mob.PhantazmMob;
+import org.phantazm.mob.target.TargetSelector;
+
+import java.util.Objects;
+
+@Model("mob.skill.radial_damage")
+@Cache(false)
+public class RadialDamageEntitySkill implements Skill {
+
+    private final Data data;
+    private final TargetSelector<Object> selector;
+
+    @FactoryMethod
+    public RadialDamageEntitySkill(@NotNull Data data, @NotNull @Child("selector") TargetSelector<Object> selector) {
+        this.data = Objects.requireNonNull(data, "data");
+        this.selector = Objects.requireNonNull(selector, "selector");
+    }
+
+    @SuppressWarnings("unchecked")
+    @Override
+    public void use(@NotNull PhantazmMob self) {
+        selector.selectTarget(self).ifPresent(object -> {
+            LivingEntity selfEntity = self.entity();
+            if (object instanceof Iterable<?> iterable) {
+                Iterable<LivingEntity> entityIterable = (Iterable<LivingEntity>)iterable;
+                for (LivingEntity entity : entityIterable) {
+                    double damage = calculateDamage(entity.getDistance(selfEntity));
+                    entity.damage(DamageType.fromEntity(selfEntity), (float)damage, data.bypassArmor);
+                }
+            }
+            else if (object instanceof LivingEntity living) {
+                double damage = calculateDamage(living.getDistance(selfEntity));
+                living.damage(DamageType.fromEntity(selfEntity), (float)damage, data.bypassArmor);
+            }
+        });
+    }
+
+    private double calculateDamage(double distanceToEntity) {
+        return ((data.damage * Math.sqrt(data.range)) / data.range) *
+                (Math.sqrt(Math.max(0, -distanceToEntity + data.range)));
+    }
+
+    @DataObject
+    public record Data(@NotNull @ChildPath("selector") String selector,
+                       float damage,
+                       boolean bypassArmor,
+                       double range) {
+
+        public Data {
+            Objects.requireNonNull(selector, "selector");
+        }
+
+    }
+
+}
diff --git a/mob/src/main/java/org/phantazm/mob/skill/RandomTimerSkill.java b/mob/src/main/java/org/phantazm/mob/skill/RandomTimerSkill.java
index 8f3e54992..e7ffb5ba3 100644
--- a/mob/src/main/java/org/phantazm/mob/skill/RandomTimerSkill.java
+++ b/mob/src/main/java/org/phantazm/mob/skill/RandomTimerSkill.java
@@ -2,6 +2,9 @@
 
 import com.github.steanky.element.core.annotation.*;
 import com.github.steanky.element.core.annotation.document.Description;
+import com.github.steanky.ethylene.core.ConfigElement;
+import com.github.steanky.ethylene.core.ConfigPrimitive;
+import com.github.steanky.ethylene.mapper.annotation.Default;
 import net.minestom.server.MinecraftServer;
 import net.minestom.server.entity.Entity;
 import net.minestom.server.tag.Tag;
@@ -123,17 +126,32 @@ public boolean needsTicking() {
     @DataObject
     public record Data(@Description(
             "The number of times this skill should repeat its action. A negative number will repeat " +
-                    "infinitely") int repeat,
+                    "infinitely. Defaults to -1.") int repeat,
 
                        @Description("The minimum activation interval") long minInterval,
                        @Description("The maximum activation interval") long maxInterval,
 
-                       @Description("Whether the timer will start in an activated state") boolean requiresActivation,
+                       @Description(
+                               "Whether the timer will start in an activated state. Defaults to false.") boolean requiresActivation,
 
                        @Description(
-                               "Whether the timer should restart itself if it is activated while running") boolean resetOnActivation,
+                               "Whether the timer should restart itself if it is activated while running. Defaults to false.") boolean resetOnActivation,
 
                        @Description("The skill to call when the timer activates") @ChildPath(
                                "delegate") String delegate) {
+        @Default("repeat")
+        public static @NotNull ConfigElement repeatDefault() {
+            return ConfigPrimitive.of(-1);
+        }
+
+        @Default("requiresActivation")
+        public static @NotNull ConfigElement requiresActivationDefault() {
+            return ConfigPrimitive.of(false);
+        }
+
+        @Default("resetOnActivation")
+        public static @NotNull ConfigElement resetOnActivationDefault() {
+            return ConfigPrimitive.of(false);
+        }
     }
 }
diff --git a/proxima-minestom/build.gradle.kts b/proxima-minestom/build.gradle.kts
index b373b97aa..b45299f6c 100644
--- a/proxima-minestom/build.gradle.kts
+++ b/proxima-minestom/build.gradle.kts
@@ -4,5 +4,5 @@ plugins {
 
 dependencies {
     api(libs.proxima.core)
-    implementation(projects.phantazmCore)
+    api(projects.phantazmCore)
 }
diff --git a/proxima-minestom/src/main/java/org/phantazm/proxima/bindings/minestom/BasicInstanceSpaceHandler.java b/proxima-minestom/src/main/java/org/phantazm/proxima/bindings/minestom/BasicInstanceSpaceHandler.java
index 6756ee57c..6093b6681 100644
--- a/proxima-minestom/src/main/java/org/phantazm/proxima/bindings/minestom/BasicInstanceSpaceHandler.java
+++ b/proxima-minestom/src/main/java/org/phantazm/proxima/bindings/minestom/BasicInstanceSpaceHandler.java
@@ -2,64 +2,25 @@
 
 import net.minestom.server.collision.Shape;
 import net.minestom.server.coordinate.Vec;
-import net.minestom.server.event.Event;
-import net.minestom.server.event.EventFilter;
 import net.minestom.server.event.EventNode;
 import net.minestom.server.event.instance.BlockChangeEvent;
 import net.minestom.server.event.instance.InstanceChunkUnloadEvent;
-import net.minestom.server.event.instance.InstanceUnregisterEvent;
 import net.minestom.server.event.trait.InstanceEvent;
 import net.minestom.server.instance.Instance;
 import net.minestom.server.instance.block.Block;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-import org.phantazm.commons.LogicUtils;
 
 import java.util.Objects;
 
 public class BasicInstanceSpaceHandler implements InstanceSpaceHandler {
     private final InstanceSpace space;
-    private final EventNode<Event> root;
-    private final EventNode<InstanceEvent> child;
 
-    private final Object sync;
-    private volatile boolean eventsRegistered;
-
-    public BasicInstanceSpaceHandler(@NotNull InstanceSpace instanceSpace, @NotNull EventNode<Event> root) {
+    public BasicInstanceSpaceHandler(@NotNull InstanceSpace instanceSpace) {
         this.space = Objects.requireNonNull(instanceSpace, "instanceSpace");
-        this.root = Objects.requireNonNull(root, "root");
-
-        this.child = EventNode.event("proxima_cache_synchronize_{" +
-                        LogicUtils.nullCoalesce(instanceSpace.instance(), Instance::getUniqueId) + "}",
-                EventFilter.from(InstanceEvent.class, Instance.class, InstanceEvent::getInstance),
-                event -> event.getInstance() == space.instance());
-
-        this.child.addListener(InstanceUnregisterEvent.class, this::unregisterInstance);
-        this.child.addListener(InstanceChunkUnloadEvent.class, this::chunkUnload);
-        this.child.addListener(BlockChangeEvent.class, this::blockChange);
-
-        this.sync = new Object();
-    }
-
-    public void registerEvents() {
-        synchronized (sync) {
-            if (eventsRegistered) {
-                return;
-            }
-
-            root.addChild(this.child);
-            eventsRegistered = true;
-        }
-    }
-
-    private void unregisterInstance(InstanceUnregisterEvent event) {
-        EventNode<? super InstanceEvent> parent = child.getParent();
-        if (parent == null) {
-            throw new IllegalStateException("event node " + child.getName() + " was orphaned");
-        }
 
-        parent.removeChild(child);
-        space.clearCache();
+        EventNode<InstanceEvent> node = instanceSpace.instance().eventNode();
+        node.addListener(InstanceChunkUnloadEvent.class, this::chunkUnload);
+        node.addListener(BlockChangeEvent.class, this::blockChange);
     }
 
     private void chunkUnload(InstanceChunkUnloadEvent event) {
@@ -95,7 +56,7 @@ private void blockChange(BlockChangeEvent event) {
     }
 
     @Override
-    public @Nullable Instance instance() {
+    public @NotNull Instance instance() {
         return space.instance();
     }
 }
diff --git a/proxima-minestom/src/main/java/org/phantazm/proxima/bindings/minestom/InstanceSettingsFunction.java b/proxima-minestom/src/main/java/org/phantazm/proxima/bindings/minestom/InstanceSettingsFunction.java
index 8e370612d..4a7af5ce0 100644
--- a/proxima-minestom/src/main/java/org/phantazm/proxima/bindings/minestom/InstanceSettingsFunction.java
+++ b/proxima-minestom/src/main/java/org/phantazm/proxima/bindings/minestom/InstanceSettingsFunction.java
@@ -6,70 +6,29 @@
 import com.github.steanky.vector.Vec3I2ObjectMap;
 import net.minestom.server.event.Event;
 import net.minestom.server.event.EventNode;
+import net.minestom.server.event.instance.InstanceUnregisterEvent;
 import net.minestom.server.instance.Instance;
 import net.minestom.server.instance.WorldBorder;
 import net.minestom.server.world.DimensionType;
 import org.jetbrains.annotations.NotNull;
 
-import java.util.Map;
-import java.util.Objects;
-import java.util.WeakHashMap;
-import java.util.concurrent.locks.StampedLock;
+import java.util.*;
+import java.util.concurrent.ConcurrentHashMap;
 import java.util.function.Function;
 
 public class InstanceSettingsFunction implements Function<Instance, InstanceSpawner.InstanceSettings> {
-    private static final int MAX_READ_TRIES = 10;
-
-    private final EventNode<Event> rootNode;
-
-    private final StampedLock stampedLock;
-    private final Map<Instance, InstanceSpawner.InstanceSettings> settingsMap;
+    private final Map<UUID, InstanceSpawner.InstanceSettings> settingsMap;
 
     public InstanceSettingsFunction(@NotNull EventNode<Event> rootNode) {
-        this.rootNode = Objects.requireNonNull(rootNode, "rootNode");
-        this.stampedLock = new StampedLock();
-        this.settingsMap = new WeakHashMap<>();
+        this.settingsMap = new ConcurrentHashMap<>();
+        rootNode.addListener(InstanceUnregisterEvent.class, this::onInstanceUnregister);
     }
 
     @Override
     public @NotNull InstanceSpawner.InstanceSettings apply(@NotNull Instance instance) {
-        InstanceSpawner.InstanceSettings settings = null;
-
-        boolean lockBroken = true;
-        int tries = 0;
-        do {
-            long optimisticStamp = stampedLock.tryOptimisticRead();
-            try {
-                settings = settingsMap.get(instance);
-            }
-            catch (Throwable ignored) {
-            }
-
-            if (stampedLock.validate(optimisticStamp)) {
-                lockBroken = false;
-                break;
-            }
-        } while (++tries <= MAX_READ_TRIES);
-
-        if (lockBroken) {
-            long fullReadLock = stampedLock.readLock();
-            try {
-                settings = settingsMap.get(instance);
-            }
-            finally {
-                stampedLock.unlockRead(fullReadLock);
-            }
-        }
-
-        if (settings != null) {
-            return settings;
-        }
-
-        long writeLock = stampedLock.writeLock();
-        try {
-            settings = settingsMap.get(instance);
-            if (settings != null) {
-                return settings;
+        return settingsMap.computeIfAbsent(instance.getUniqueId(), ignored -> {
+            if (!instance.isRegistered()) {
+                throw new IllegalArgumentException("Cannot get settings for unregistered instance");
             }
 
             DimensionType dimensionType = instance.getDimensionType();
@@ -89,16 +48,17 @@ public InstanceSettingsFunction(@NotNull EventNode<Event> rootNode) {
 
             InstanceSpace instanceSpace = new InstanceSpace(instance);
             ThreadLocal<Vec3I2ObjectMap<Node>> local = ThreadLocal.withInitial(() -> new HashVec3I2ObjectMap<>(bounds));
-            BasicInstanceSpaceHandler instanceSpaceHandler = new BasicInstanceSpaceHandler(instanceSpace, rootNode);
-            instanceSpaceHandler.registerEvents();
+            BasicInstanceSpaceHandler instanceSpaceHandler = new BasicInstanceSpaceHandler(instanceSpace);
 
-            settings = new InstanceSpawner.InstanceSettings(local, instanceSpaceHandler);
-            settingsMap.put(instance, settings);
+            return new InstanceSpawner.InstanceSettings(local, instanceSpaceHandler);
+        });
+    }
 
-            return settings;
-        }
-        finally {
-            stampedLock.unlockWrite(writeLock);
+    private void onInstanceUnregister(InstanceUnregisterEvent event) {
+        InstanceSpawner.InstanceSettings settings = settingsMap.remove(event.getInstance().getUniqueId());
+
+        if (settings != null) {
+            settings.spaceHandler().space().clearCache();
         }
     }
 }
diff --git a/proxima-minestom/src/main/java/org/phantazm/proxima/bindings/minestom/InstanceSpace.java b/proxima-minestom/src/main/java/org/phantazm/proxima/bindings/minestom/InstanceSpace.java
index aaf224454..1e26c2267 100644
--- a/proxima-minestom/src/main/java/org/phantazm/proxima/bindings/minestom/InstanceSpace.java
+++ b/proxima-minestom/src/main/java/org/phantazm/proxima/bindings/minestom/InstanceSpace.java
@@ -13,8 +13,6 @@
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
-import java.lang.ref.Reference;
-import java.lang.ref.WeakReference;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Map;
@@ -30,7 +28,7 @@ public class InstanceSpace extends ConcurrentCachingSpace {
         splitMap = new ConcurrentHashMap<>();
     }
 
-    private final Reference<Instance> instanceReference;
+    private final Instance instance;
     private volatile Vec3IFunction<? extends Solid> overrideFunction;
 
     public InstanceSpace(@NotNull Instance instance) {
@@ -39,17 +37,12 @@ public InstanceSpace(@NotNull Instance instance) {
 
     public InstanceSpace(@NotNull Instance instance, @NotNull Vec3IFunction<? extends Solid> overrideFunction) {
         super(instance.getDimensionType().getMinY());
-        this.instanceReference = new WeakReference<>(Objects.requireNonNull(instance, "instance"));
+        this.instance = Objects.requireNonNull(instance, "instance");
         this.overrideFunction = Objects.requireNonNull(overrideFunction, "overrideFunction");
     }
 
     @Override
     public @Nullable Solid loadSolid(int x, int y, int z) {
-        Instance instance = instanceReference.get();
-        if (instance == null) {
-            return null;
-        }
-
         Chunk chunk = instance.getChunk(x >> 4, z >> 4);
         if (chunk == null) {
             return null;
@@ -148,8 +141,8 @@ public InstanceSpace(@NotNull Instance instance, @NotNull Vec3IFunction<? extend
         return cachedSolid(shape);
     }
 
-    public @Nullable Instance instance() {
-        return instanceReference.get();
+    public @NotNull Instance instance() {
+        return instance;
     }
 
     public void setOverrideFunction(@NotNull Vec3IFunction<? extends Solid> overrideFunction) {
diff --git a/proxima-minestom/src/main/java/org/phantazm/proxima/bindings/minestom/InstanceSpaceHandler.java b/proxima-minestom/src/main/java/org/phantazm/proxima/bindings/minestom/InstanceSpaceHandler.java
index a8b9b37f8..0ff1206b4 100644
--- a/proxima-minestom/src/main/java/org/phantazm/proxima/bindings/minestom/InstanceSpaceHandler.java
+++ b/proxima-minestom/src/main/java/org/phantazm/proxima/bindings/minestom/InstanceSpaceHandler.java
@@ -2,10 +2,9 @@
 
 import net.minestom.server.instance.Instance;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
 
 public interface InstanceSpaceHandler {
     @NotNull InstanceSpace space();
 
-    @Nullable Instance instance();
+    @NotNull Instance instance();
 }
diff --git a/proxima-minestom/src/main/java/org/phantazm/proxima/bindings/minestom/Pathfinding.java b/proxima-minestom/src/main/java/org/phantazm/proxima/bindings/minestom/Pathfinding.java
index 538e16fe2..b77faf66f 100644
--- a/proxima-minestom/src/main/java/org/phantazm/proxima/bindings/minestom/Pathfinding.java
+++ b/proxima-minestom/src/main/java/org/phantazm/proxima/bindings/minestom/Pathfinding.java
@@ -17,7 +17,6 @@
 import com.github.steanky.vector.Vec3D;
 import com.github.steanky.vector.Vec3I2ObjectMap;
 import com.github.steanky.vector.Vec3IBiPredicate;
-import net.minestom.server.coordinate.Vec;
 import net.minestom.server.entity.*;
 import org.jetbrains.annotations.NotNull;
 import org.phantazm.proxima.bindings.minestom.controller.Controller;
@@ -28,6 +27,8 @@
 import java.util.function.BiPredicate;
 
 public class Pathfinding {
+    public static final double PATH_EPSILON = 1E-3;
+
     public interface Factory {
         @NotNull Pathfinding make(@NotNull Pathfinder pathfinder,
                 @NotNull ThreadLocal<Vec3I2ObjectMap<Node>> nodeMapLocal, @NotNull InstanceSpaceHandler spaceHandler,
@@ -73,7 +74,10 @@ public Pathfinding(@NotNull Pathfinder pathfinder, @NotNull ThreadLocal<Vec3I2Ob
     }
 
     public @NotNull PositionResolver positionResolverForTarget(@NotNull Entity entity) {
-        return PositionResolver.seekBelow(spaceHandler.space(), 8, entity.getEntityType().width(), Vec.EPSILON);
+        EntityType type = entity.getEntityType();
+        return PositionResolver.asIfByInitial(
+                new BasicNodeSnapper(spaceHandler.space(), type.width(), type.height(), fallTolerance(), jumpHeight(),
+                        PATH_EPSILON), 16, type.width(), PATH_EPSILON);
     }
 
     public @NotNull BiPredicate<Vec3D, Vec3D> targetChangePredicate(@NotNull Entity entity) {
@@ -135,7 +139,7 @@ public boolean isValidTarget(@NotNull Entity targetEntity) {
 
     protected @NotNull NodeSnapper nodeSnapper() {
         return new BasicNodeSnapper(spaceHandler.space(), entityType.width(), entityType.height(), fallTolerance(),
-                jumpHeight(), Vec.EPSILON);
+                jumpHeight(), PATH_EPSILON);
     }
 
     protected @NotNull Explorer explorer() {
diff --git a/proxima-minestom/src/main/java/org/phantazm/proxima/bindings/minestom/ProximaEntity.java b/proxima-minestom/src/main/java/org/phantazm/proxima/bindings/minestom/ProximaEntity.java
index 046d4099b..d0f0220e0 100644
--- a/proxima-minestom/src/main/java/org/phantazm/proxima/bindings/minestom/ProximaEntity.java
+++ b/proxima-minestom/src/main/java/org/phantazm/proxima/bindings/minestom/ProximaEntity.java
@@ -29,6 +29,8 @@
  * An entity with navigation capabilities based on the Proxima library.
  */
 public class ProximaEntity extends LivingEntity {
+    private static final double NODE_REACH_DISTANCE = 0.4;
+
     protected final Pathfinding pathfinding;
     protected final List<GoalGroup> goalGroups;
 
@@ -258,7 +260,8 @@ protected boolean initPath(@NotNull PathResult pathResult) {
 
     protected boolean withinDistance(@NotNull Node node) {
         Pos position = getPosition();
-        return position.distanceSquared(new Vec(node.x + 0.5, node.y + node.blockOffset, node.z + 0.5)) < 0.0625;
+        return position.distanceSquared(new Vec(node.x + 0.5, node.y + node.blockOffset, node.z + 0.5)) <
+                NODE_REACH_DISTANCE;
     }
 
     protected boolean moveAlongPath(long time) {
diff --git a/proxima-minestom/src/main/java/org/phantazm/proxima/bindings/minestom/controller/GroundController.java b/proxima-minestom/src/main/java/org/phantazm/proxima/bindings/minestom/controller/GroundController.java
index 121d6381f..7cf50f6c2 100644
--- a/proxima-minestom/src/main/java/org/phantazm/proxima/bindings/minestom/controller/GroundController.java
+++ b/proxima-minestom/src/main/java/org/phantazm/proxima/bindings/minestom/controller/GroundController.java
@@ -24,11 +24,14 @@
 import java.util.function.Predicate;
 
 public class GroundController implements Controller {
+    private static final double ENTITY_COLLISION_FACTOR = 10;
+
     private final LivingEntity entity;
     private final double step;
     private final TrackerPredicate trackerPredicate;
 
     private boolean jumping;
+    private double jumpTargetHeight;
 
     private double lastH = -1;
     private double lastB = -1;
@@ -101,14 +104,12 @@ public boolean test(LivingEntity candidate) {
                 else {
                     double pZ = -vX;
                     if (iterations % 2 == 0) {
-                        candidate.setVelocity(
-                                new Vec(vZ * scaleFactor * MinecraftServer.TICK_PER_SECOND, oldVelocity.y(),
-                                        pZ * scaleFactor * MinecraftServer.TICK_PER_SECOND));
+                        candidate.setVelocity(new Vec(vZ * scaleFactor * ENTITY_COLLISION_FACTOR, oldVelocity.y(),
+                                pZ * scaleFactor * ENTITY_COLLISION_FACTOR));
                     }
                     else {
-                        candidate.setVelocity(
-                                new Vec(-vZ * scaleFactor * MinecraftServer.TICK_PER_SECOND, oldVelocity.y(),
-                                        -pZ * scaleFactor * MinecraftServer.TICK_PER_SECOND));
+                        candidate.setVelocity(new Vec(-vZ * scaleFactor * ENTITY_COLLISION_FACTOR, oldVelocity.y(),
+                                -pZ * scaleFactor * ENTITY_COLLISION_FACTOR));
                     }
                 }
             }
@@ -167,12 +168,10 @@ public void advance(@NotNull Node current, @NotNull Node target, @Nullable Entit
         assert chunk != null;
 
         if (jumping) {
-            if (entityPos.y() > exactTargetY + Vec.EPSILON) {
-
-
+            if (entityPos.y() > jumpTargetHeight + Vec.EPSILON) {
                 PhysicsResult physics = CollisionUtils.handlePhysics(instance, chunk, entity.getBoundingBox(),
-                        new Pos(entityPos.x(), exactTargetY + Vec.EPSILON, entityPos.z()), new Vec(speedX, 0, speedZ),
-                        null);
+                        new Pos(entityPos.x(), jumpTargetHeight + Vec.EPSILON, entityPos.z()),
+                        new Vec(speedX, 0, speedZ), null);
 
                 if (!physics.hasCollision()) {
                     entity.refreshPosition(physics.newPosition().withView(PositionUtils.getLookYaw(dX, dZ), 0));
@@ -198,20 +197,22 @@ else if (entity.isOnGround()) {
 
             Pos pos = physicsResult.newPosition().withView(PositionUtils.getLookYaw(dX, dZ), 0);
 
-            if (entityPos.y() < exactTargetY && physicsResult.hasCollision()) {
-                double currentTarget = current.y + current.blockOffset;
-
-                double nodeDiff = Double.NEGATIVE_INFINITY;
+            double currentTarget = current.y + current.blockOffset;
+            if ((entityPos.y() < exactTargetY - Vec.EPSILON || entityPos.y() < currentTarget - Vec.EPSILON) &&
+                    physicsResult.hasCollision()) {
+                double actualDiff = Double.NEGATIVE_INFINITY;
                 if (currentTarget - Vec.EPSILON > entityPos.y()) {
-                    nodeDiff = currentTarget - entityPos.y();
+                    actualDiff = currentTarget - entityPos.y();
+                    jumpTargetHeight = currentTarget;
                 }
 
                 double targetDiff = exactTargetY - entityPos.y();
-                if (targetDiff > nodeDiff) {
-                    nodeDiff = targetDiff;
+                if (targetDiff > actualDiff) {
+                    actualDiff = targetDiff;
+                    jumpTargetHeight = exactTargetY;
                 }
 
-                stepOrJump(nodeDiff, speedX, speedZ, instance, deltaMove, pos);
+                stepOrJump(actualDiff, speedX, speedZ, instance, deltaMove, pos);
                 return;
             }
 
diff --git a/server/build.gradle.kts b/server/build.gradle.kts
index 0c168a1fb..9dc7998f7 100644
--- a/server/build.gradle.kts
+++ b/server/build.gradle.kts
@@ -22,6 +22,9 @@ dependencies {
     implementation(libs.ethylene.json)
     implementation(libs.element.core)
     implementation(libs.ethylene.mapper)
+
+    runtimeOnly(libs.mariadb)
+    runtimeOnly(libs.sqlite)
 }
 
 tasks.getByName<CopyLibs>("copyLibs") {
diff --git a/server/src/main/java/org/phantazm/server/Chat.java b/server/src/main/java/org/phantazm/server/ChatFeature.java
similarity index 94%
rename from server/src/main/java/org/phantazm/server/Chat.java
rename to server/src/main/java/org/phantazm/server/ChatFeature.java
index 38fb295b0..c7f7d5fc2 100644
--- a/server/src/main/java/org/phantazm/server/Chat.java
+++ b/server/src/main/java/org/phantazm/server/ChatFeature.java
@@ -25,7 +25,7 @@
 /**
  * Entrypoint for chat-related features.
  */
-public final class Chat {
+public final class ChatFeature {
     /**
      * The default {@link ChatChannel} name for players.
      */
@@ -33,7 +33,7 @@ public final class Chat {
 
     public static final String SELF_CHAT_CHANNEL_NAME = "self";
 
-    private Chat() {
+    private ChatFeature() {
         throw new UnsupportedOperationException();
     }
 
@@ -44,9 +44,8 @@ private Chat() {
      * @param viewProvider   A {@link PlayerViewProvider} to create {@link PlayerView}s
      * @param commandManager The {@link CommandManager} to register chat commands to
      */
-    static void initialize(@NotNull EventNode<Event> node, @NotNull PlayerViewProvider viewProvider, @NotNull Map<?
-            super UUID, ? extends Party> parties,
-            @NotNull CommandManager commandManager) {
+    static void initialize(@NotNull EventNode<Event> node, @NotNull PlayerViewProvider viewProvider,
+            @NotNull Map<? super UUID, ? extends Party> parties, @NotNull CommandManager commandManager) {
         Map<String, ChatChannel> channels = new HashMap<>() {
             @Override
             public boolean remove(Object key, Object value) {
diff --git a/server/src/main/java/org/phantazm/server/CommandFeature.java b/server/src/main/java/org/phantazm/server/CommandFeature.java
new file mode 100644
index 000000000..62899f569
--- /dev/null
+++ b/server/src/main/java/org/phantazm/server/CommandFeature.java
@@ -0,0 +1,16 @@
+package org.phantazm.server;
+
+import net.minestom.server.command.CommandManager;
+import org.jetbrains.annotations.NotNull;
+import org.phantazm.core.game.scene.RouterStore;
+import org.phantazm.core.game.scene.command.QuitCommand;
+import org.phantazm.core.player.PlayerViewProvider;
+
+public class CommandFeature {
+
+    static void initialize(@NotNull CommandManager commandManager, @NotNull RouterStore routerStore,
+            @NotNull PlayerViewProvider viewProvider) {
+        commandManager.register(QuitCommand.quitCommand(routerStore, viewProvider));
+    }
+
+}
diff --git a/server/src/main/java/org/phantazm/server/Config.java b/server/src/main/java/org/phantazm/server/ConfigFeature.java
similarity index 78%
rename from server/src/main/java/org/phantazm/server/Config.java
rename to server/src/main/java/org/phantazm/server/ConfigFeature.java
index 43ede3c23..c079fc94c 100644
--- a/server/src/main/java/org/phantazm/server/Config.java
+++ b/server/src/main/java/org/phantazm/server/ConfigFeature.java
@@ -1,6 +1,7 @@
 package org.phantazm.server;
 
 import com.github.steanky.ethylene.codec.toml.TomlCodec;
+import com.github.steanky.ethylene.codec.yaml.YamlCodec;
 import com.github.steanky.ethylene.core.BasicConfigHandler;
 import com.github.steanky.ethylene.core.ConfigCodec;
 import com.github.steanky.ethylene.core.ConfigHandler;
@@ -9,16 +10,18 @@
 import org.phantazm.server.config.loader.LobbiesConfigProcessor;
 import org.phantazm.server.config.loader.PathfinderConfigProcessor;
 import org.phantazm.server.config.loader.ServerConfigProcessor;
+import org.phantazm.server.config.loader.ShutdownConfigProcessor;
 import org.phantazm.server.config.lobby.LobbiesConfig;
 import org.phantazm.server.config.server.PathfinderConfig;
 import org.phantazm.server.config.server.ServerConfig;
+import org.phantazm.server.config.server.ShutdownConfig;
 
 import java.nio.file.Path;
 
 /**
  * Entrypoint for configuration-related features.
  */
-public final class Config {
+public final class ConfigFeature {
     /**
      * The location of the server configuration file.
      */
@@ -26,12 +29,18 @@ public final class Config {
     /**
      * The location of the lobbies configuration file.
      */
-    public static final Path LOBBIES_CONFIG_PATH = Path.of("./lobbies-config.toml");
+    public static final Path LOBBIES_CONFIG_PATH = Path.of("./lobbies-config.yml");
 
     /**
      * The location of the pathfinder configuration file.
      */
     public static final Path PATHFINDER_CONFIG_PATH = Path.of("./pathfinder-config.toml");
+
+    /**
+     * The location of the shutdown configuration file.
+     */
+    public static final Path SHUTDOWN_CONFIG_PATH = Path.of("./shutdown-config.toml");
+
     /**
      * The {@link ConfigHandler.ConfigKey} instance used to refer to the primary {@link ServerConfig} loader.
      */
@@ -49,9 +58,15 @@ public final class Config {
     public static final ConfigHandler.ConfigKey<PathfinderConfig> PATHFINDER_CONFIG_KEY =
             new ConfigHandler.ConfigKey<>(PathfinderConfig.class, "pathfinder_config");
 
+    /**
+     * The {@link ConfigHandler.ConfigKey} instance used to refer to the primary {@link PathfinderConfig} loader.
+     */
+    public static final ConfigHandler.ConfigKey<ShutdownConfig> SHUTDOWN_CONFIG_KEY =
+            new ConfigHandler.ConfigKey<>(ShutdownConfig.class, "pathfinder_config");
+
     private static ConfigHandler handler;
 
-    private Config() {
+    private ConfigFeature() {
         throw new UnsupportedOperationException();
     }
 
@@ -68,11 +83,15 @@ static void initialize() {
 
         handler.registerLoader(LOBBIES_CONFIG_KEY,
                 new SyncFileConfigLoader<>(new LobbiesConfigProcessor(), LobbiesConfig.DEFAULT, LOBBIES_CONFIG_PATH,
-                        codec));
+                        new YamlCodec()));
 
         handler.registerLoader(PATHFINDER_CONFIG_KEY,
                 new SyncFileConfigLoader<>(new PathfinderConfigProcessor(), PathfinderConfig.DEFAULT,
                         PATHFINDER_CONFIG_PATH, codec));
+
+        handler.registerLoader(SHUTDOWN_CONFIG_KEY,
+                new SyncFileConfigLoader<>(new ShutdownConfigProcessor(), ShutdownConfig.DEFAULT, SHUTDOWN_CONFIG_PATH,
+                        codec));
     }
 
     /**
diff --git a/server/src/main/java/org/phantazm/server/Element.java b/server/src/main/java/org/phantazm/server/ElementFeature.java
similarity index 96%
rename from server/src/main/java/org/phantazm/server/Element.java
rename to server/src/main/java/org/phantazm/server/ElementFeature.java
index 9aef34ae4..fba17f3ea 100644
--- a/server/src/main/java/org/phantazm/server/Element.java
+++ b/server/src/main/java/org/phantazm/server/ElementFeature.java
@@ -11,7 +11,7 @@
 /**
  * Initializes features related to Element.
  */
-public final class Element {
+public final class ElementFeature {
     private static ContextManager contextManager;
 
     static void initialize(@NotNull MappingProcessorSource mappingProcessorSource, @NotNull KeyParser keyParser) {
diff --git a/server/src/main/java/org/phantazm/server/EquipmentFeature.java b/server/src/main/java/org/phantazm/server/EquipmentFeature.java
index a254a8439..31da1de60 100644
--- a/server/src/main/java/org/phantazm/server/EquipmentFeature.java
+++ b/server/src/main/java/org/phantazm/server/EquipmentFeature.java
@@ -24,6 +24,7 @@
 import org.phantazm.zombies.equipment.gun.audience.EntityInstanceAudienceProvider;
 import org.phantazm.zombies.equipment.gun.audience.PlayerAudienceProvider;
 import org.phantazm.zombies.equipment.gun.effect.*;
+import org.phantazm.zombies.equipment.gun.event.GunShootEvent;
 import org.phantazm.zombies.equipment.gun.reload.StateReloadTester;
 import org.phantazm.zombies.equipment.gun.reload.actionbar.GradientActionBarChooser;
 import org.phantazm.zombies.equipment.gun.reload.actionbar.StaticActionBarChooser;
@@ -354,6 +355,19 @@ private Optional<Equipment> loadGun(Pair<EquipmentData, List<ElementContext>> pa
 
                 GunModel model = new GunModel(rootLevel, levels);
                 Gun gun = new Gun(equipmentKey, equipmentModule.getPlayerView()::getPlayer, model);
+                equipmentModule.getEventNode().addListener(GunShootEvent.class, event -> {
+                    if (event.gun() != gun) {
+                        return;
+                    }
+
+                    equipmentModule.getMapStats().setShots(equipmentModule.getMapStats().getShots() + 1);
+
+                    if (!event.shot().headshotTargets().isEmpty()) {
+                        equipmentModule.getMapStats().setHeadshotHits(equipmentModule.getMapStats().getHeadshotHits() + 1);
+                    } else if (!event.shot().regularTargets().isEmpty()) {
+                        equipmentModule.getMapStats().setRegularHits(equipmentModule.getMapStats().getRegularHits() + 1);
+                    }
+                });
 
                 return Optional.of(gun);
             }
diff --git a/server/src/main/java/org/phantazm/server/Ethylene.java b/server/src/main/java/org/phantazm/server/EthyleneFeature.java
similarity index 63%
rename from server/src/main/java/org/phantazm/server/Ethylene.java
rename to server/src/main/java/org/phantazm/server/EthyleneFeature.java
index 289369f9d..acd743f00 100644
--- a/server/src/main/java/org/phantazm/server/Ethylene.java
+++ b/server/src/main/java/org/phantazm/server/EthyleneFeature.java
@@ -5,6 +5,7 @@
 import com.github.steanky.ethylene.mapper.MappingProcessorSource;
 import com.github.steanky.ethylene.mapper.signature.ScalarSignature;
 import com.github.steanky.ethylene.mapper.signature.Signature;
+import com.github.steanky.ethylene.mapper.signature.SignatureParameter;
 import com.github.steanky.ethylene.mapper.type.Token;
 import com.github.steanky.vector.Bounds3D;
 import com.github.steanky.vector.Vec3D;
@@ -24,8 +25,12 @@
 import net.kyori.adventure.title.TitlePart;
 import net.kyori.adventure.util.RGBLike;
 import net.minestom.server.color.Color;
+import net.minestom.server.coordinate.Pos;
+import net.minestom.server.entity.EntityType;
+import net.minestom.server.instance.block.Block;
 import net.minestom.server.item.ItemStack;
 import net.minestom.server.particle.Particle;
+import net.minestom.server.permission.Permission;
 import org.jetbrains.annotations.NotNull;
 import org.jglrxavpok.hephaistos.nbt.NBTCompound;
 import org.jglrxavpok.hephaistos.nbt.NBTException;
@@ -39,22 +44,24 @@
 /**
  * Initializes features related to Ethylene.
  */
-public final class Ethylene {
-    private static final Logger LOGGER = LoggerFactory.getLogger(Mob.class);
+public final class EthyleneFeature {
+    private static final Logger LOGGER = LoggerFactory.getLogger(MobFeature.class);
 
     private static MappingProcessorSource mappingProcessorSource;
     private static KeyParser keyParser;
 
     static void initialize(@NotNull KeyParser keyParser) {
-        Ethylene.keyParser = Objects.requireNonNull(keyParser, "keyParser");
+        EthyleneFeature.keyParser = Objects.requireNonNull(keyParser, "keyParser");
 
         mappingProcessorSource =
                 MappingProcessorSource.builder().withCustomSignature(vec3I()).withCustomSignature(sound())
                         .withCustomSignature(style()).withCustomSignature(textColor()).withCustomSignature(vec3D())
-                        .withCustomSignature(bounds3D()).withCustomSignature(rgbLike()).withScalarSignature(key())
-                        .withScalarSignature(uuid()).withScalarSignature(component()).withScalarSignature(itemStack())
-                        .withScalarSignature(titlePartComponent()).withScalarSignature(namedTextColor())
-                        .withScalarSignature(particle())
+                        .withCustomSignature(pos()).withCustomSignature(bounds3D()).withCustomSignature(rgbLike())
+                        .withScalarSignature(key()).withScalarSignature(uuid()).withScalarSignature(component())
+                        .withScalarSignature(itemStack()).withScalarSignature(titlePartComponent())
+                        .withScalarSignature(namedTextColor()).withScalarSignature(particle())
+                        .withScalarSignature(block()).withScalarSignature(permission())
+                        .withScalarSignature(entityType())
                         .withTypeImplementation(Object2IntOpenHashMap.class, Object2IntMap.class)
                         .withTypeImplementation(IntOpenHashSet.class, IntSet.class).withStandardSignatures()
                         .withStandardTypeImplementations().ignoringLengths().build();
@@ -62,18 +69,33 @@ static void initialize(@NotNull KeyParser keyParser) {
         LOGGER.info("Ethylene initialized.");
     }
 
+    private static Signature<Pos> pos() {
+        return Signature.builder(Token.ofClass(Pos.class),
+                        (ignored, args) -> new Pos(args.get(0), args.get(1), args.get(2), args.get(3), args.get(4)),
+                        pos -> List.of(pos.x(), pos.y(), pos.z(), pos.yaw(), pos.pitch()),
+                        Map.entry("x", SignatureParameter.parameter(Token.DOUBLE)),
+                        Map.entry("y", SignatureParameter.parameter(Token.DOUBLE)),
+                        Map.entry("z", SignatureParameter.parameter(Token.DOUBLE)),
+                        Map.entry("yaw", SignatureParameter.parameter(Token.FLOAT)),
+                        Map.entry("pitch", SignatureParameter.parameter(Token.FLOAT))).matchingNames().matchingTypeHints()
+                .build();
+    }
+
     private static Signature<Vec3I> vec3I() {
         return Signature.builder(Token.ofClass(Vec3I.class),
-                (ignored, args) -> Vec3I.immutable(args.get(0), args.get(1), args.get(2)),
-                vec -> List.of(vec.x(), vec.y(), vec.z()), Map.entry("x", Token.INTEGER), Map.entry("y", Token.INTEGER),
-                Map.entry("z", Token.INTEGER)).matchingNames().matchingTypeHints().build();
+                        (ignored, args) -> Vec3I.immutable(args.get(0), args.get(1), args.get(2)),
+                        vec -> List.of(vec.x(), vec.y(), vec.z()), Map.entry("x", SignatureParameter.parameter(Token.INTEGER)),
+                        Map.entry("y", SignatureParameter.parameter(Token.INTEGER)),
+                        Map.entry("z", SignatureParameter.parameter(Token.INTEGER))).matchingNames().matchingTypeHints()
+                .build();
     }
 
     private static Signature<Vec3D> vec3D() {
         return Signature.builder(Token.ofClass(Vec3D.class),
                 (ignored, args) -> Vec3D.immutable(args.get(0), args.get(1), args.get(2)),
-                vec -> List.of(vec.x(), vec.y(), vec.z()), Map.entry("x", Token.DOUBLE), Map.entry("y", Token.DOUBLE),
-                Map.entry("z", Token.DOUBLE)).matchingNames().matchingTypeHints().build();
+                vec -> List.of(vec.x(), vec.y(), vec.z()), Map.entry("x", SignatureParameter.parameter(Token.DOUBLE)),
+                Map.entry("y", SignatureParameter.parameter(Token.DOUBLE)),
+                Map.entry("z", SignatureParameter.parameter(Token.DOUBLE))).matchingNames().matchingTypeHints().build();
     }
 
     private static Signature<Sound> sound() {
@@ -82,8 +104,10 @@ private static Signature<Sound> sound() {
                             double pitch = args.get(3);
                             return Sound.sound((Key)args.get(0), (Sound.Source)args.get(1), (float)volume, (float)pitch);
                         }, sound -> List.of(sound.name(), sound.source(), sound.volume(), sound.pitch()),
-                        Map.entry("name", Token.ofClass(Key.class)), Map.entry("source", Token.ofClass(Sound.Source.class)),
-                        Map.entry("volume", Token.DOUBLE), Map.entry("pitch", Token.DOUBLE)).matchingNames().matchingTypeHints()
+                        Map.entry("name", SignatureParameter.parameter(Token.ofClass(Key.class))),
+                        Map.entry("source", SignatureParameter.parameter(Token.ofClass(Sound.Source.class))),
+                        Map.entry("volume", SignatureParameter.parameter(Token.DOUBLE)),
+                        Map.entry("pitch", SignatureParameter.parameter(Token.DOUBLE))).matchingNames().matchingTypeHints()
                 .build();
     }
 
@@ -91,8 +115,9 @@ private static Signature<Bounds3D> bounds3D() {
         return Signature.builder(Token.ofClass(Bounds3D.class), (ignored, args) -> {
                             return Bounds3D.immutable(args.get(0), args.get(1));
                         }, bounds -> List.of(bounds.immutableOrigin(), bounds.immutableLengths()),
-                        Map.entry("origin", Token.ofClass(Vec3D.class)), Map.entry("lengths", Token.ofClass(Vec3D.class)))
-                .build();
+                        Map.entry("origin", SignatureParameter.parameter(Token.ofClass(Vec3D.class))),
+                        Map.entry("lengths", SignatureParameter.parameter(Token.ofClass(Vec3D.class)))).matchingNames()
+                .matchingTypeHints().build();
     }
 
     private static Signature<Style> style() {
@@ -104,9 +129,9 @@ private static Signature<Style> style() {
                             Collection<Object> textColors = new ArrayList<>(1);
                             textColors.add(style.color());
                             return textColors;
-                        }, Map.entry("textColor", Token.ofClass(TextColor.class)),
-                        Map.entry("textDecorations", Token.ofClass(TextDecoration[].class))).matchingNames().matchingTypeHints()
-                .build();
+                        }, Map.entry("textColor", SignatureParameter.parameter(Token.ofClass(TextColor.class))),
+                        Map.entry("textDecorations", SignatureParameter.parameter(Token.ofClass(TextDecoration[].class))))
+                .matchingNames().matchingTypeHints().build();
     }
 
     private static Signature<RGBLike> rgbLike() {
@@ -115,8 +140,10 @@ private static Signature<RGBLike> rgbLike() {
                             int g = args.get(1);
                             int b = args.get(2);
                             return new Color(r, g, b);
-                        }, color -> List.of(color.red(), color.green(), color.blue()), Map.entry("r", Token.INTEGER),
-                        Map.entry("g", Token.INTEGER), Map.entry("b", Token.INTEGER)).matchingNames().matchingTypeHints()
+                        }, color -> List.of(color.red(), color.green(), color.blue()),
+                        Map.entry("r", SignatureParameter.parameter(Token.INTEGER)),
+                        Map.entry("g", SignatureParameter.parameter(Token.INTEGER)),
+                        Map.entry("b", SignatureParameter.parameter(Token.INTEGER))).matchingNames().matchingTypeHints()
                 .build();
     }
 
@@ -126,11 +153,20 @@ private static Signature<TextColor> textColor() {
                             int g = args.get(1);
                             int b = args.get(2);
                             return TextColor.color(r, g, b);
-                        }, textColor -> List.of(textColor.red(), textColor.green(), textColor.blue()), Map.entry("r", Token.INTEGER),
-                        Map.entry("g", Token.INTEGER), Map.entry("b", Token.INTEGER)).matchingNames().matchingTypeHints()
+                        }, textColor -> List.of(textColor.red(), textColor.green(), textColor.blue()),
+                        Map.entry("r", SignatureParameter.parameter(Token.INTEGER)),
+                        Map.entry("g", SignatureParameter.parameter(Token.INTEGER)),
+                        Map.entry("b", SignatureParameter.parameter(Token.INTEGER))).matchingNames().matchingTypeHints()
                 .build();
     }
 
+    private static ScalarSignature<Permission> permission() {
+        return ScalarSignature.of(Token.ofClass(Permission.class), element -> new Permission(element.asString()),
+                permission -> permission == null
+                              ? ConfigPrimitive.NULL
+                              : ConfigPrimitive.of(permission.getPermissionName()));
+    }
+
     private static ScalarSignature<Particle> particle() {
         return ScalarSignature.of(Token.ofClass(Particle.class),
                 element -> Particle.fromNamespaceId(element.asString()),
@@ -149,6 +185,20 @@ private static ScalarSignature<ItemStack> itemStack() {
         }, itemStack -> itemStack == null ? ConfigPrimitive.NULL : ConfigPrimitive.of(itemStack.toItemNBT().toSNBT()));
     }
 
+    private static ScalarSignature<EntityType> entityType() {
+        return ScalarSignature.of(Token.ofClass(EntityType.class), element -> {
+            return EntityType.fromNamespaceId(element.asString());
+        }, entityType -> entityType == null
+                         ? ConfigPrimitive.NULL
+                         : ConfigPrimitive.of(entityType.namespace().asString()));
+    }
+
+    private static ScalarSignature<Block> block() {
+        return ScalarSignature.of(Token.ofClass(Block.class), element -> {
+            return Objects.requireNonNullElse(Block.fromNamespaceId(element.asString()), Block.AIR);
+        }, block -> block == null ? ConfigPrimitive.NULL : ConfigPrimitive.of(block.name()));
+    }
+
     private static ScalarSignature<TitlePart<Component>> titlePartComponent() {
         ConfigPrimitive title = ConfigPrimitive.of("TITLE");
         ConfigPrimitive subtitle = ConfigPrimitive.of("SUBTITLE");
diff --git a/server/src/main/java/org/phantazm/server/FeatureUtils.java b/server/src/main/java/org/phantazm/server/FeatureUtils.java
index d21f2a9a6..59143e2d2 100644
--- a/server/src/main/java/org/phantazm/server/FeatureUtils.java
+++ b/server/src/main/java/org/phantazm/server/FeatureUtils.java
@@ -5,6 +5,9 @@
 import org.jetbrains.annotations.Nullable;
 
 final class FeatureUtils {
+    private FeatureUtils() {
+    }
+
     @Contract("null -> fail")
     static <T> @NotNull T check(@Nullable T object) {
         if (object != null) {
diff --git a/server/src/main/java/org/phantazm/server/Lobbies.java b/server/src/main/java/org/phantazm/server/LobbyFeature.java
similarity index 81%
rename from server/src/main/java/org/phantazm/server/Lobbies.java
rename to server/src/main/java/org/phantazm/server/LobbyFeature.java
index 770315365..fd3ea7c47 100644
--- a/server/src/main/java/org/phantazm/server/Lobbies.java
+++ b/server/src/main/java/org/phantazm/server/LobbyFeature.java
@@ -1,5 +1,6 @@
 package org.phantazm.server;
 
+import com.github.steanky.element.core.context.ContextManager;
 import net.kyori.adventure.text.Component;
 import net.minestom.server.MinecraftServer;
 import net.minestom.server.event.Event;
@@ -11,10 +12,9 @@
 import net.minestom.server.timer.TaskSchedule;
 import org.jetbrains.annotations.NotNull;
 import org.phantazm.commons.FileUtils;
-import org.phantazm.core.game.scene.BasicSceneStore;
 import org.phantazm.core.game.scene.RouteResult;
 import org.phantazm.core.game.scene.SceneProvider;
-import org.phantazm.core.game.scene.SceneStore;
+import org.phantazm.core.game.scene.TransferResult;
 import org.phantazm.core.game.scene.fallback.CompositeFallback;
 import org.phantazm.core.game.scene.fallback.KickFallback;
 import org.phantazm.core.game.scene.fallback.SceneFallback;
@@ -36,14 +36,14 @@
 /**
  * Main entrypoint for lobby-related features.
  */
-public final class Lobbies {
-    private static final Logger LOGGER = LoggerFactory.getLogger(Lobbies.class);
+public final class LobbyFeature {
+    private static final Logger LOGGER = LoggerFactory.getLogger(LobbyFeature.class);
 
     private static LobbyRouter lobbyRouter;
 
     private static SceneFallback fallback;
 
-    private Lobbies() {
+    private LobbyFeature() {
         throw new UnsupportedOperationException();
     }
 
@@ -55,9 +55,7 @@ private Lobbies() {
      * @param lobbiesConfig      the {@link LobbiesConfig} used to determine lobby behavior
      */
     static void initialize(@NotNull EventNode<Event> node, @NotNull PlayerViewProvider playerViewProvider,
-            @NotNull LobbiesConfig lobbiesConfig) throws IOException {
-        SceneStore sceneStore = new BasicSceneStore();
-
+            @NotNull LobbiesConfig lobbiesConfig, @NotNull ContextManager contextManager) throws IOException {
         InstanceManager instanceManager = MinecraftServer.getInstanceManager();
         FileUtils.createDirectories(lobbiesConfig.instancesPath());
         InstanceLoader instanceLoader =
@@ -67,7 +65,6 @@ static void initialize(@NotNull EventNode<Event> node, @NotNull PlayerViewProvid
         Map<String, SceneProvider<Lobby, LobbyJoinRequest>> lobbyProviders =
                 new HashMap<>(lobbiesConfig.lobbies().size());
         lobbyRouter = new LobbyRouter(lobbyProviders);
-        sceneStore.addScene(SceneKeys.LOBBY_ROUTER, lobbyRouter);
 
         LobbyConfig mainLobbyConfig = lobbiesConfig.lobbies().get(lobbiesConfig.mainLobbyName());
         if (mainLobbyConfig == null) {
@@ -77,15 +74,16 @@ static void initialize(@NotNull EventNode<Event> node, @NotNull PlayerViewProvid
         LOGGER.info("Preloading {} lobby instances", lobbiesConfig.lobbies().size());
         for (LobbyConfig lobbyConfig : lobbiesConfig.lobbies().values()) {
             instanceLoader.preload(lobbyConfig.lobbyPaths(), lobbyConfig.instanceConfig().spawnPoint(),
-                    MinecraftServer.getChunkViewDistance());
+                    lobbyConfig.instanceConfig().chunkLoadDistance());
         }
 
         SceneProvider<Lobby, LobbyJoinRequest> mainLobbyProvider =
                 new BasicLobbyProvider(mainLobbyConfig.maxLobbies(), -mainLobbyConfig.maxPlayers(), instanceLoader,
-                        mainLobbyConfig.lobbyPaths(), finalFallback, mainLobbyConfig.instanceConfig());
+                        mainLobbyConfig.lobbyPaths(), finalFallback, mainLobbyConfig.instanceConfig(), contextManager,
+                        mainLobbyConfig.npcs(), false);
         lobbyProviders.put(lobbiesConfig.mainLobbyName(), mainLobbyProvider);
 
-        fallback = new LobbyRouterFallback(MinecraftServer.getConnectionManager(), Lobbies.getLobbyRouter(),
+        fallback = new LobbyRouterFallback(MinecraftServer.getConnectionManager(), LobbyFeature.getLobbyRouter(),
                 lobbiesConfig.mainLobbyName());
         SceneFallback regularFallback = new CompositeFallback(List.of(fallback, finalFallback));
 
@@ -94,23 +92,30 @@ static void initialize(@NotNull EventNode<Event> node, @NotNull PlayerViewProvid
                 lobbyProviders.put(lobby.getKey(),
                         new BasicLobbyProvider(lobby.getValue().maxLobbies(), -lobby.getValue().maxPlayers(),
                                 instanceLoader, lobby.getValue().lobbyPaths(), regularFallback,
-                                lobby.getValue().instanceConfig()));
+                                lobby.getValue().instanceConfig(), contextManager, mainLobbyConfig.npcs(), true));
             }
         }
 
         Map<UUID, LoginLobbyJoinRequest> loginJoinRequests = new HashMap<>();
 
         node.addListener(PlayerLoginEvent.class, event -> {
-            LoginLobbyJoinRequest joinRequest =
-                    new LoginLobbyJoinRequest(MinecraftServer.getConnectionManager(), event, playerViewProvider);
+            LoginLobbyJoinRequest joinRequest = new LoginLobbyJoinRequest(event, playerViewProvider);
             LobbyRouteRequest routeRequest = new LobbyRouteRequest(lobbiesConfig.mainLobbyName(), joinRequest);
 
-            RouteResult result = lobbyRouter.join(routeRequest);
-            if (!result.success()) {
-                finalFallback.fallback(playerViewProvider.fromPlayer(event.getPlayer()));
+            RouteResult<Lobby> routeResult = lobbyRouter.findScene(routeRequest);
+            boolean success = false;
+            if (routeResult.scene().isPresent()) {
+                Lobby lobby = routeResult.scene().get();
+                TransferResult transferResult = lobby.join(joinRequest);
+                if (transferResult.executor().isPresent()) {
+                    transferResult.executor().get().run();
+                    loginJoinRequests.put(event.getPlayer().getUuid(), joinRequest);
+                    success = true;
+                }
             }
-            else {
-                loginJoinRequests.put(event.getPlayer().getUuid(), joinRequest);
+
+            if (!success) {
+                finalFallback.fallback(playerViewProvider.fromPlayer(event.getPlayer()));
             }
         });
 
@@ -124,9 +129,6 @@ static void initialize(@NotNull EventNode<Event> node, @NotNull PlayerViewProvid
                 LOGGER.warn("Player {} spawned without a login join request", event.getPlayer().getUuid());
                 event.getPlayer().kick(Component.empty());
             }
-            else {
-                joinRequest.onPlayerLoginComplete();
-            }
         });
 
         MinecraftServer.getSchedulerManager().scheduleTask(() -> {
diff --git a/server/src/main/java/org/phantazm/server/Messaging.java b/server/src/main/java/org/phantazm/server/MessagingFeature.java
similarity index 97%
rename from server/src/main/java/org/phantazm/server/Messaging.java
rename to server/src/main/java/org/phantazm/server/MessagingFeature.java
index a5045a06b..c060a0313 100644
--- a/server/src/main/java/org/phantazm/server/Messaging.java
+++ b/server/src/main/java/org/phantazm/server/MessagingFeature.java
@@ -23,9 +23,9 @@
 /**
  * Main entrypoint for plugin messaging. This is used to communicate with the proxy and players.
  */
-public final class Messaging {
+public final class MessagingFeature {
 
-    private Messaging() {
+    private MessagingFeature() {
         throw new UnsupportedOperationException();
     }
 
diff --git a/server/src/main/java/org/phantazm/server/Mob.java b/server/src/main/java/org/phantazm/server/MobFeature.java
similarity index 97%
rename from server/src/main/java/org/phantazm/server/Mob.java
rename to server/src/main/java/org/phantazm/server/MobFeature.java
index 1aaf842a9..a5ba2052b 100644
--- a/server/src/main/java/org/phantazm/server/Mob.java
+++ b/server/src/main/java/org/phantazm/server/MobFeature.java
@@ -50,14 +50,14 @@
 /**
  * Main entrypoint for PhantazmMob related features.
  */
-public final class Mob {
-    private static final Logger LOGGER = LoggerFactory.getLogger(Mob.class);
+public final class MobFeature {
+    private static final Logger LOGGER = LoggerFactory.getLogger(MobFeature.class);
 
     private static ConfigProcessor<MobModel> MODEL_PROCESSOR;
     private static Map<Key, MobModel> models;
     private static Map<BooleanObjectPair<String>, ConfigProcessor<?>> processorMap;
 
-    private Mob() {
+    private MobFeature() {
         throw new UnsupportedOperationException();
     }
 
@@ -111,7 +111,7 @@ static void initialize(@NotNull ContextManager contextManager, @NotNull Path mob
         processorMap.put(BooleanObjectPair.of(false, Entity.Pose.class.getName()),
                 ConfigProcessor.enumProcessor(Entity.Pose.class));
 
-        Mob.processorMap = Map.copyOf(processorMap);
+        MobFeature.processorMap = Map.copyOf(processorMap);
 
         loadModels(mobPath, codec);
     }
@@ -139,6 +139,7 @@ private static void registerElementClasses(@NotNull ContextManager contextManage
         contextManager.registerElementClass(SendMessageSkill.class);
         contextManager.registerElementClass(JumpTowardsTargetSkill.class);
         contextManager.registerElementClass(SpawnParticleSkill.class);
+        contextManager.registerElementClass(RadialDamageEntitySkill.class);
 
         //mob meta skills
         contextManager.registerElementClass(TimerSkill.class);
diff --git a/server/src/main/java/org/phantazm/server/NPCFeature.java b/server/src/main/java/org/phantazm/server/NPCFeature.java
new file mode 100644
index 000000000..661415bbe
--- /dev/null
+++ b/server/src/main/java/org/phantazm/server/NPCFeature.java
@@ -0,0 +1,30 @@
+package org.phantazm.server;
+
+import com.github.steanky.element.core.context.ContextManager;
+import org.jetbrains.annotations.NotNull;
+import org.phantazm.core.npc.AnimationTicker;
+import org.phantazm.core.npc.EntityNPC;
+import org.phantazm.core.npc.NoTicker;
+import org.phantazm.core.npc.interactor.NoInteractor;
+import org.phantazm.core.npc.settings.BasicEntitySettings;
+import org.phantazm.core.npc.supplier.MobEntitySupplier;
+import org.phantazm.core.npc.interactor.CommandInteractor;
+import org.phantazm.core.npc.supplier.PlayerEntitySupplier;
+
+public class NPCFeature {
+    private NPCFeature() {
+        throw new UnsupportedOperationException();
+    }
+
+    static void initialize(@NotNull ContextManager contextManager) {
+        contextManager.registerElementClass(CommandInteractor.class);
+        contextManager.registerElementClass(NoInteractor.class);
+        contextManager.registerElementClass(EntityNPC.class);
+        contextManager.registerElementClass(MobEntitySupplier.class);
+        contextManager.registerElementClass(PlayerEntitySupplier.class);
+        contextManager.registerElementClass(BasicEntitySettings.class);
+        contextManager.registerElementClass(AnimationTicker.class);
+        contextManager.registerElementClass(AnimationTicker.Frame.class);
+        contextManager.registerElementClass(NoTicker.class);
+    }
+}
diff --git a/server/src/main/java/org/phantazm/server/PartyFeature.java b/server/src/main/java/org/phantazm/server/PartyFeature.java
index b86573e14..38350c347 100644
--- a/server/src/main/java/org/phantazm/server/PartyFeature.java
+++ b/server/src/main/java/org/phantazm/server/PartyFeature.java
@@ -1,37 +1,73 @@
 package org.phantazm.server;
 
+import com.github.steanky.element.core.context.ContextManager;
+import com.github.steanky.ethylene.core.ConfigCodec;
+import com.github.steanky.ethylene.core.ConfigElement;
+import com.github.steanky.ethylene.core.bridge.Configuration;
+import com.github.steanky.ethylene.core.processor.ConfigProcessor;
+import com.github.steanky.ethylene.mapper.MappingProcessorSource;
+import com.github.steanky.ethylene.mapper.type.Token;
+import net.kyori.adventure.text.minimessage.MiniMessage;
 import net.minestom.server.command.CommandManager;
 import net.minestom.server.command.builder.Command;
 import net.minestom.server.timer.SchedulerManager;
 import net.minestom.server.timer.TaskSchedule;
 import org.jetbrains.annotations.NotNull;
+import org.phantazm.core.guild.GuildHolder;
 import org.phantazm.core.guild.party.Party;
+import org.phantazm.core.guild.party.PartyConfig;
 import org.phantazm.core.guild.party.PartyCreator;
 import org.phantazm.core.guild.party.command.PartyCommand;
 import org.phantazm.core.player.PlayerViewProvider;
+import org.phantazm.core.time.TickFormatter;
 
-import java.util.HashMap;
-import java.util.Map;
-import java.util.UUID;
+import java.io.IOException;
+import java.nio.file.Path;
+import java.util.*;
 
 public class PartyFeature {
 
-    private static final Map<? super UUID, Party> parties = new HashMap<>();
+    private static final GuildHolder<Party> partyHolder = new GuildHolder<>(new HashMap<>(), new ArrayList<>());
 
-    public static void initialize(@NotNull CommandManager commandManager, @NotNull PlayerViewProvider viewProvider,
-            @NotNull SchedulerManager schedulerManager) {
-        PartyCreator partyCreator = new PartyCreator(1, 0, 20, 1, 1);
-        Command partyCommand = PartyCommand.command(parties, viewProvider, partyCreator);
+    private PartyFeature() {
+        throw new UnsupportedOperationException();
+    }
+
+    static void initialize(@NotNull CommandManager commandManager, @NotNull PlayerViewProvider viewProvider,
+            @NotNull SchedulerManager schedulerManager, @NotNull MappingProcessorSource mappingProcessorSource,
+            @NotNull ContextManager contextManager, @NotNull ConfigCodec partyCodec, @NotNull MiniMessage miniMessage)
+            throws IOException {
+        ConfigProcessor<PartyConfig> partyConfigProcessor =
+                mappingProcessorSource.processorFor(Token.ofClass(PartyConfig.class));
+        String partyFileName =
+                partyCodec.getPreferredExtensions().isEmpty() ? "party" : "party." + partyCodec.getPreferredExtension();
+        ConfigElement partyConfigNode = Configuration.read(Path.of(partyFileName), partyCodec);
+        TickFormatter tickFormatter =
+                contextManager.makeContext(partyConfigNode.getNodeOrThrow("tickFormatter")).provide();
+        PartyConfig partyConfig = partyConfigProcessor.dataFromElement(partyConfigNode);
+
+        PartyCreator partyCreator = new PartyCreator.Builder().setNotificationConfig(partyConfig.notificationConfig())
+                .setTickFormatter(tickFormatter).setMiniMessage(miniMessage).setCreatorRank(partyConfig.creatorRank())
+                .setDefaultRank(partyConfig.defaultRank()).setInvitationDuration(partyConfig.invitationDuration())
+                .setMinimumKickRank(partyConfig.minimumKickRank()).setMinimumInviteRank(partyConfig.minimumInviteRank())
+                .setMinimumJoinRank(partyConfig.minimumJoinRank()).build();
+        Command partyCommand =
+                PartyCommand.partyCommand(partyConfig.commandConfig(), miniMessage, partyHolder, viewProvider,
+                        partyCreator, new Random());
         commandManager.register(partyCommand);
 
         schedulerManager.scheduleTask(() -> {
-            for (Party party : parties.values()) {
-                party.tick(System.currentTimeMillis());
+            Set<Party> ticked = Collections.newSetFromMap(new IdentityHashMap<>());
+            long time = System.currentTimeMillis();
+            for (Party party : partyHolder.guilds()) {
+                if (ticked.add(party)) {
+                    party.tick(time);
+                }
             }
         }, TaskSchedule.immediate(), TaskSchedule.nextTick());
     }
 
-    public static @NotNull Map<? super UUID, Party> getParties() {
-        return parties;
+    public static @NotNull GuildHolder<Party> getPartyHolder() {
+        return partyHolder;
     }
 }
diff --git a/server/src/main/java/org/phantazm/server/PhantazmServer.java b/server/src/main/java/org/phantazm/server/PhantazmServer.java
index d1eff3265..de76c2461 100644
--- a/server/src/main/java/org/phantazm/server/PhantazmServer.java
+++ b/server/src/main/java/org/phantazm/server/PhantazmServer.java
@@ -3,13 +3,16 @@
 import com.github.steanky.element.core.context.ContextManager;
 import com.github.steanky.element.core.key.BasicKeyParser;
 import com.github.steanky.element.core.key.KeyParser;
+import com.github.steanky.ethylene.codec.toml.TomlCodec;
 import com.github.steanky.ethylene.codec.yaml.YamlCodec;
+import com.github.steanky.ethylene.core.ConfigCodec;
 import com.github.steanky.ethylene.core.ConfigHandler;
 import com.github.steanky.ethylene.core.processor.ConfigProcessException;
 import com.github.steanky.ethylene.mapper.MappingProcessorSource;
 import com.github.steanky.ethylene.mapper.type.Token;
 import net.kyori.adventure.text.Component;
 import net.kyori.adventure.text.format.NamedTextColor;
+import net.kyori.adventure.text.minimessage.MiniMessage;
 import net.minestom.server.MinecraftServer;
 import net.minestom.server.command.CommandManager;
 import net.minestom.server.event.Event;
@@ -21,6 +24,8 @@
 import net.minestom.server.extras.velocity.VelocityProxy;
 import org.jetbrains.annotations.Nullable;
 import org.phantazm.commons.Namespaces;
+import org.phantazm.core.game.scene.BasicRouterStore;
+import org.phantazm.core.game.scene.RouterStore;
 import org.phantazm.core.game.scene.fallback.CompositeFallback;
 import org.phantazm.core.game.scene.fallback.KickFallback;
 import org.phantazm.core.player.BasicPlayerViewProvider;
@@ -30,6 +35,7 @@
 import org.phantazm.server.config.server.PathfinderConfig;
 import org.phantazm.server.config.server.ServerConfig;
 import org.phantazm.server.config.server.ServerInfoConfig;
+import org.phantazm.server.config.server.ShutdownConfig;
 import org.phantazm.server.player.BasicLoginValidator;
 import org.phantazm.server.player.LoginValidator;
 import org.phantazm.zombies.equipment.EquipmentData;
@@ -58,6 +64,10 @@ public final class PhantazmServer {
 
     public static final Path BANS_FILE = Path.of("./bans.txt");
     public static final Path WHITELIST_FILE = Path.of("./whitelist.txt");
+    public static final Path PERMISSIONS_FILE = Path.of("./permissions.yml");
+    public static final Path MOBS_PATH = Path.of("./mobs");
+
+    private static LoginValidator loginValidator;
 
     /**
      * Starting point for the server.
@@ -72,13 +82,14 @@ public static void main(String[] args) {
         ServerConfig serverConfig;
         LobbiesConfig lobbiesConfig;
         PathfinderConfig pathfinderConfig;
+        ShutdownConfig shutdownConfig;
         try {
             LOGGER.info("Loading server configuration data.");
-            Config.initialize();
-            ConfigHandler handler = Config.getHandler();
+            ConfigFeature.initialize();
+            ConfigHandler handler = ConfigFeature.getHandler();
             handler.writeDefaultsAndGet();
 
-            serverConfig = handler.loadDataNow(Config.SERVER_CONFIG_KEY);
+            serverConfig = handler.loadDataNow(ConfigFeature.SERVER_CONFIG_KEY);
             ServerInfoConfig serverInfoConfig = serverConfig.serverInfoConfig();
             if (isUnsafe(args)) {
                 LOGGER.warn("""
@@ -116,8 +127,9 @@ else if (serverInfoConfig.isUnsafeConfiguration()) {
                 return;
             }
 
-            lobbiesConfig = handler.loadDataNow(Config.LOBBIES_CONFIG_KEY);
-            pathfinderConfig = handler.loadDataNow(Config.PATHFINDER_CONFIG_KEY);
+            lobbiesConfig = handler.loadDataNow(ConfigFeature.LOBBIES_CONFIG_KEY);
+            pathfinderConfig = handler.loadDataNow(ConfigFeature.PATHFINDER_CONFIG_KEY);
+            shutdownConfig = handler.loadDataNow(ConfigFeature.SHUTDOWN_CONFIG_KEY);
             LOGGER.info("Server configuration loaded successfully.");
         }
         catch (ConfigProcessException e) {
@@ -126,13 +138,13 @@ else if (serverInfoConfig.isUnsafeConfiguration()) {
             return;
         }
 
-        LoginValidator loginValidator =
+        loginValidator =
                 new BasicLoginValidator(serverConfig.serverInfoConfig().whitelist(), WHITELIST_FILE, BANS_FILE);
 
         EventNode<Event> node = MinecraftServer.getGlobalEventHandler();
         try {
             LOGGER.info("Initializing features.");
-            initializeFeatures(node, serverConfig, pathfinderConfig, lobbiesConfig, loginValidator);
+            initializeFeatures(node, serverConfig, shutdownConfig, pathfinderConfig, lobbiesConfig, loginValidator);
             LOGGER.info("Features initialized successfully.");
         }
         catch (Exception exception) {
@@ -142,11 +154,7 @@ else if (serverInfoConfig.isUnsafeConfiguration()) {
         }
 
         Runtime.getRuntime().addShutdownHook(new Thread(() -> {
-            if (!MinecraftServer.isStopping()) {
-                shutdown("interrupt");
-            }
-
-            loginValidator.flush();
+            shutdown("interrupt");
         }));
 
         MinecraftServer.setBrandName(BRAND_NAME);
@@ -162,7 +170,12 @@ else if (serverInfoConfig.isUnsafeConfiguration()) {
 
     public static void shutdown(@Nullable String reason) {
         LOGGER.info("Shutting down server. Reason: " + reason);
+
+        ZombiesFeature.end();
+        loginValidator.flush();
+
         MinecraftServer.stopCleanly();
+        ServerCommandFeature.flushPermissions();
     }
 
     private static boolean isUnsafe(String[] args) {
@@ -176,48 +189,63 @@ private static boolean isUnsafe(String[] args) {
     }
 
     private static void initializeFeatures(EventNode<Event> global, ServerConfig serverConfig,
-            PathfinderConfig pathfinderConfig, LobbiesConfig lobbiesConfig, LoginValidator loginValidator)
-            throws Exception {
+            ShutdownConfig shutdownConfig, PathfinderConfig pathfinderConfig, LobbiesConfig lobbiesConfig,
+            LoginValidator loginValidator) throws Exception {
+        RouterStore routerStore = new BasicRouterStore();
         BlockHandlerFeature.initialize(MinecraftServer.getBlockManager());
 
         KeyParser keyParser = new BasicKeyParser(Namespaces.PHANTAZM);
 
         SongFeature.initialize(keyParser);
-        Ethylene.initialize(keyParser);
+        EthyleneFeature.initialize(keyParser);
 
-        MappingProcessorSource mappingProcessorSource = Ethylene.getMappingProcessorSource();
-        Element.initialize(mappingProcessorSource, keyParser);
+        MappingProcessorSource mappingProcessorSource = EthyleneFeature.getMappingProcessorSource();
+        ElementFeature.initialize(mappingProcessorSource, keyParser);
 
-        ContextManager contextManager = Element.getContextManager();
+        ConfigCodec tomlCodec = new TomlCodec();
+        WhisperCommandFeature.initialize(MinecraftServer.getCommandManager(), MinecraftServer.getConnectionManager(),
+                mappingProcessorSource, tomlCodec);
+
+        ContextManager contextManager = ElementFeature.getContextManager();
 
         TickFormatterFeature.initialize(contextManager);
+        NPCFeature.initialize(contextManager);
 
         PlayerViewProvider viewProvider =
                 new BasicPlayerViewProvider(IdentitySource.MOJANG, MinecraftServer.getConnectionManager());
 
-        ValidationFeature.initialize(global, loginValidator);
+        CommandFeature.initialize(MinecraftServer.getCommandManager(), routerStore, viewProvider);
+
         PartyFeature.initialize(MinecraftServer.getCommandManager(), viewProvider,
-                MinecraftServer.getSchedulerManager());
-        Lobbies.initialize(global, viewProvider, lobbiesConfig);
-        Chat.initialize(global, viewProvider, PartyFeature.getParties(), MinecraftServer.getCommandManager());
-        Messaging.initialize(global, serverConfig.serverInfoConfig().authType());
+                MinecraftServer.getSchedulerManager(), mappingProcessorSource, contextManager, tomlCodec,
+                MiniMessage.miniMessage());
+        LobbyFeature.initialize(global, viewProvider, lobbiesConfig, contextManager);
+        ChatFeature.initialize(global, viewProvider, PartyFeature.getPartyHolder().uuidToGuild(),
+                MinecraftServer.getCommandManager());
+        MessagingFeature.initialize(global, serverConfig.serverInfoConfig().authType());
 
-        Proxima.initialize(global, contextManager, pathfinderConfig);
+        ProximaFeature.initialize(global, contextManager, pathfinderConfig);
 
-        Mob.initialize(contextManager, Path.of("./mobs/"), new YamlCodec());
-        EquipmentFeature.initialize(keyParser, contextManager,
-                new YamlCodec(() -> new Load(LoadSettings.builder().build()),
-                        () -> new Dump(DumpSettings.builder().setDefaultFlowStyle(FlowStyle.BLOCK).build())),
+        ConfigCodec codec = new YamlCodec(() -> new Load(LoadSettings.builder().build()),
+                () -> new Dump(DumpSettings.builder().setDefaultFlowStyle(FlowStyle.BLOCK).build()));
+
+        MobFeature.initialize(contextManager, MOBS_PATH, codec);
+        EquipmentFeature.initialize(keyParser, contextManager, codec,
                 mappingProcessorSource.processorFor(Token.ofClass(EquipmentData.class)));
 
         CommandManager commandManager = MinecraftServer.getCommandManager();
-        ZombiesFeature.initialize(global, contextManager, Mob.getProcessorMap(), Proxima.getSpawner(), keyParser,
-                MinecraftServer.getConnectionManager(), Proxima.instanceSettingsFunction(), viewProvider,
-                commandManager, new CompositeFallback(List.of(Lobbies.getFallback(),
+        ZombiesFeature.initialize(global, contextManager, MobFeature.getProcessorMap(), ProximaFeature.getSpawner(),
+                keyParser, ProximaFeature.instanceSettingsFunction(), viewProvider, commandManager,
+                new CompositeFallback(List.of(LobbyFeature.getFallback(),
                         new KickFallback(Component.text("Failed to send you to lobby", NamedTextColor.RED)))),
-                PartyFeature.getParties());
+                PartyFeature.getPartyHolder().uuidToGuild(), routerStore);
+
+        ServerCommandFeature.initialize(commandManager, loginValidator, serverConfig.serverInfoConfig().whitelist(),
+                mappingProcessorSource, codec, routerStore, shutdownConfig);
+        ValidationFeature.initialize(global, loginValidator, ServerCommandFeature.permissionHandler());
 
-        ServerCommandFeature.initialize(commandManager, loginValidator, serverConfig.serverInfoConfig().whitelist());
+        routerStore.putRouter(RouterKeys.ZOMBIES_SCENE_ROUTER, ZombiesFeature.zombiesSceneRouter());
+        routerStore.putRouter(RouterKeys.LOBBY_SCENE_ROUTER, LobbyFeature.getLobbyRouter());
     }
 
     private static void startServer(EventNode<Event> node, MinecraftServer server, ServerConfig serverConfig) {
diff --git a/server/src/main/java/org/phantazm/server/Proxima.java b/server/src/main/java/org/phantazm/server/ProximaFeature.java
similarity index 97%
rename from server/src/main/java/org/phantazm/server/Proxima.java
rename to server/src/main/java/org/phantazm/server/ProximaFeature.java
index d59fc56e5..e4a44471f 100644
--- a/server/src/main/java/org/phantazm/server/Proxima.java
+++ b/server/src/main/java/org/phantazm/server/ProximaFeature.java
@@ -15,12 +15,12 @@
 import java.util.concurrent.TimeUnit;
 import java.util.function.Function;
 
-public final class Proxima {
+public final class ProximaFeature {
     private static Pathfinder pathfinder;
     private static Function<? super Instance, ? extends InstanceSpawner.InstanceSettings> settingsFunction;
     private static Spawner spawner;
 
-    private Proxima() {
+    private ProximaFeature() {
         throw new UnsupportedOperationException();
     }
 
diff --git a/server/src/main/java/org/phantazm/server/RouterKeys.java b/server/src/main/java/org/phantazm/server/RouterKeys.java
new file mode 100644
index 000000000..07006a5a9
--- /dev/null
+++ b/server/src/main/java/org/phantazm/server/RouterKeys.java
@@ -0,0 +1,17 @@
+package org.phantazm.server;
+
+import org.phantazm.core.game.scene.RouterKey;
+import org.phantazm.core.game.scene.lobby.Lobby;
+import org.phantazm.core.game.scene.lobby.LobbyRouteRequest;
+import org.phantazm.core.game.scene.lobby.LobbyRouter;
+import org.phantazm.zombies.scene.ZombiesRouteRequest;
+import org.phantazm.zombies.scene.ZombiesScene;
+import org.phantazm.zombies.scene.ZombiesSceneRouter;
+
+public class RouterKeys {
+    public static final RouterKey<ZombiesScene, ZombiesRouteRequest, ZombiesSceneRouter> ZOMBIES_SCENE_ROUTER =
+            new RouterKey<>(ZombiesSceneRouter.class);
+
+    public static final RouterKey<Lobby, LobbyRouteRequest, LobbyRouter> LOBBY_SCENE_ROUTER =
+            new RouterKey<>(LobbyRouter.class);
+}
diff --git a/server/src/main/java/org/phantazm/server/SceneKeys.java b/server/src/main/java/org/phantazm/server/SceneKeys.java
deleted file mode 100644
index fdb2585cc..000000000
--- a/server/src/main/java/org/phantazm/server/SceneKeys.java
+++ /dev/null
@@ -1,20 +0,0 @@
-package org.phantazm.server;
-
-import org.phantazm.core.game.scene.SceneKey;
-import org.phantazm.core.game.scene.lobby.LobbyRouter;
-
-/**
- * A static class container for reusable {@link SceneKey}s.
- */
-public final class SceneKeys {
-
-    /**
-     * Lobbies
-     */
-    public static final SceneKey<LobbyRouter> LOBBY_ROUTER = new SceneKey<>("lobby_dispatcher");
-
-    private SceneKeys() {
-        throw new UnsupportedOperationException();
-    }
-
-}
diff --git a/server/src/main/java/org/phantazm/server/ServerCommandFeature.java b/server/src/main/java/org/phantazm/server/ServerCommandFeature.java
index 320858dbc..b285a7c61 100644
--- a/server/src/main/java/org/phantazm/server/ServerCommandFeature.java
+++ b/server/src/main/java/org/phantazm/server/ServerCommandFeature.java
@@ -1,24 +1,53 @@
 package org.phantazm.server;
 
+import com.github.steanky.ethylene.core.ConfigCodec;
+import com.github.steanky.ethylene.mapper.MappingProcessorSource;
+import net.minestom.server.MinecraftServer;
 import net.minestom.server.command.CommandManager;
-import net.minestom.server.command.builder.Command;
+import net.minestom.server.permission.Permission;
 import org.jetbrains.annotations.NotNull;
+import org.phantazm.core.game.scene.RouterStore;
 import org.phantazm.core.player.IdentitySource;
-import org.phantazm.server.command.BanCommand;
-import org.phantazm.server.command.PardonCommand;
-import org.phantazm.server.command.WhitelistCommand;
+import org.phantazm.server.command.server.*;
+import org.phantazm.server.config.server.ShutdownConfig;
+import org.phantazm.server.permission.FilePermissionHandler;
+import org.phantazm.server.permission.PermissionHandler;
 import org.phantazm.server.player.LoginValidator;
 
 public final class ServerCommandFeature {
-    static void initialize(@NotNull CommandManager commandManager, @NotNull LoginValidator loginValidator,
-            boolean whitelist) {
-        Command stopCommand = new Command("stop");
-        stopCommand.setDefaultExecutor((sender, context) -> PhantazmServer.shutdown("stop command"));
+    public static final Permission ALL_PERMISSIONS = new Permission("*");
+
+    private static PermissionHandler permissionHandler;
 
-        commandManager.register(stopCommand);
+    private ServerCommandFeature() {
+    }
+
+    static void initialize(@NotNull CommandManager commandManager, @NotNull LoginValidator loginValidator,
+            boolean whitelist, @NotNull MappingProcessorSource mappingProcessorSource,
+            @NotNull ConfigCodec permissionsCodec, @NotNull RouterStore routerStore,
+            @NotNull ShutdownConfig shutdownConfig) {
+        ServerCommandFeature.permissionHandler =
+                new FilePermissionHandler(mappingProcessorSource, permissionsCodec, PhantazmServer.PERMISSIONS_FILE);
 
+        commandManager.register(new StopCommand());
         commandManager.register(new BanCommand(IdentitySource.MOJANG, loginValidator));
         commandManager.register(new PardonCommand(IdentitySource.MOJANG, loginValidator));
         commandManager.register(new WhitelistCommand(IdentitySource.MOJANG, loginValidator, whitelist));
+        commandManager.register(new PermissionCommand(permissionHandler, IdentitySource.MOJANG));
+        commandManager.register(
+                new OrderlyShutdownCommand(routerStore, shutdownConfig, MinecraftServer.getGlobalEventHandler()));
+        commandManager.register(new DebugCommand());
+
+        commandManager.getConsoleSender().addPermission(ALL_PERMISSIONS);
+    }
+
+    public static @NotNull PermissionHandler permissionHandler() {
+        return FeatureUtils.check(permissionHandler);
+    }
+
+    public static void flushPermissions() {
+        if (permissionHandler != null) {
+            permissionHandler.flush();
+        }
     }
 }
diff --git a/server/src/main/java/org/phantazm/server/SongFeature.java b/server/src/main/java/org/phantazm/server/SongFeature.java
index 34d0ea8c1..45d02e39a 100644
--- a/server/src/main/java/org/phantazm/server/SongFeature.java
+++ b/server/src/main/java/org/phantazm/server/SongFeature.java
@@ -12,6 +12,9 @@ public class SongFeature {
 
     private static SongLoader songLoader;
 
+    private SongFeature() {
+    }
+
     static void initialize(@NotNull KeyParser keyParser) {
         SongFeature.songLoader = new NBSSongLoader(SONG_PATH, keyParser);
         SongFeature.songLoader.load();
diff --git a/server/src/main/java/org/phantazm/server/ValidationFeature.java b/server/src/main/java/org/phantazm/server/ValidationFeature.java
index f04063967..b9b79ac41 100644
--- a/server/src/main/java/org/phantazm/server/ValidationFeature.java
+++ b/server/src/main/java/org/phantazm/server/ValidationFeature.java
@@ -6,14 +6,33 @@
 import net.minestom.server.event.EventNode;
 import net.minestom.server.event.player.AsyncPlayerPreLoginEvent;
 import org.jetbrains.annotations.NotNull;
+import org.phantazm.server.permission.PermissionHandler;
 import org.phantazm.server.player.LoginValidator;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.UUID;
 
 public class ValidationFeature {
-    static void initialize(@NotNull EventNode<Event> rootNode, @NotNull LoginValidator validator) {
+    private static final Logger LOGGER = LoggerFactory.getLogger(ValidationFeature.class);
+
+    private ValidationFeature() {
+    }
+
+    static void initialize(@NotNull EventNode<Event> rootNode, @NotNull LoginValidator validator,
+            @NotNull PermissionHandler permissionHandler) {
         rootNode.addListener(AsyncPlayerPreLoginEvent.class, event -> {
-            BooleanObjectPair<Component> validationResult = validator.validateLogin(event.getPlayerUuid());
-            if (!validationResult.firstBoolean()) {
-                event.getPlayer().kick(validationResult.second());
+            try {
+                UUID uuid = event.getPlayerUuid();
+                BooleanObjectPair<Component> validationResult = validator.validateLogin(uuid);
+                if (!validationResult.firstBoolean()) {
+                    event.getPlayer().kick(validationResult.second());
+                }
+
+                permissionHandler.applyPermissions(uuid, event.getPlayer());
+            }
+            catch (Throwable e) {
+                LOGGER.warn("Error during AsyncPlayerPreLoginEvent", e);
             }
         });
     }
diff --git a/server/src/main/java/org/phantazm/server/WhisperCommandFeature.java b/server/src/main/java/org/phantazm/server/WhisperCommandFeature.java
new file mode 100644
index 000000000..6fb937fb7
--- /dev/null
+++ b/server/src/main/java/org/phantazm/server/WhisperCommandFeature.java
@@ -0,0 +1,41 @@
+package org.phantazm.server;
+
+import com.github.steanky.ethylene.codec.toml.TomlCodec;
+import com.github.steanky.ethylene.core.ConfigCodec;
+import com.github.steanky.ethylene.core.bridge.Configuration;
+import com.github.steanky.ethylene.core.processor.ConfigProcessor;
+import com.github.steanky.ethylene.mapper.MappingProcessorSource;
+import com.github.steanky.ethylene.mapper.type.Token;
+import net.kyori.adventure.text.minimessage.MiniMessage;
+import net.minestom.server.command.CommandManager;
+import net.minestom.server.network.ConnectionManager;
+import org.jetbrains.annotations.NotNull;
+import org.phantazm.server.command.whisper.ReplyCommand;
+import org.phantazm.server.command.whisper.WhisperCommand;
+import org.phantazm.server.command.whisper.WhisperConfig;
+import org.phantazm.server.command.whisper.WhisperManager;
+
+import java.io.IOException;
+import java.nio.file.Path;
+
+public class WhisperCommandFeature {
+    static void initialize(@NotNull CommandManager commandManager, @NotNull ConnectionManager connectionManager,
+            @NotNull MappingProcessorSource mappingProcessorSource, @NotNull ConfigCodec whisperCodec)
+            throws IOException {
+        ConfigProcessor<WhisperConfig> whisperConfigProcessor =
+                mappingProcessorSource.processorFor(Token.ofClass(WhisperConfig.class));
+        String whisperFileName = whisperCodec.getPreferredExtensions().isEmpty()
+                                 ? "whisper"
+                                 : "whisper." + whisperCodec.getPreferredExtension();
+        WhisperConfig whisperConfig =
+                Configuration.read(Path.of(whisperFileName), whisperCodec,
+                        whisperConfigProcessor);
+        WhisperManager whisperManager =
+                new WhisperManager(connectionManager, commandManager.getConsoleSender(), whisperConfig,
+                        MiniMessage.miniMessage());
+
+        commandManager.register(WhisperCommand.whisperCommand(connectionManager, whisperManager));
+        commandManager.register(ReplyCommand.replyCommand(whisperManager));
+    }
+
+}
diff --git a/server/src/main/java/org/phantazm/server/ZombiesFeature.java b/server/src/main/java/org/phantazm/server/ZombiesFeature.java
index d6d22847b..bfe8bc723 100644
--- a/server/src/main/java/org/phantazm/server/ZombiesFeature.java
+++ b/server/src/main/java/org/phantazm/server/ZombiesFeature.java
@@ -5,6 +5,8 @@
 import com.github.steanky.ethylene.codec.yaml.YamlCodec;
 import com.github.steanky.ethylene.core.ConfigCodec;
 import com.github.steanky.ethylene.core.processor.ConfigProcessor;
+import com.zaxxer.hikari.HikariConfig;
+import com.zaxxer.hikari.HikariDataSource;
 import it.unimi.dsi.fastutil.booleans.BooleanObjectPair;
 import net.kyori.adventure.key.Key;
 import net.kyori.adventure.key.Keyed;
@@ -14,7 +16,6 @@
 import net.minestom.server.event.EventNode;
 import net.minestom.server.instance.DynamicChunk;
 import net.minestom.server.instance.Instance;
-import net.minestom.server.network.ConnectionManager;
 import net.minestom.server.network.packet.server.play.TeamsPacket;
 import net.minestom.server.scoreboard.Team;
 import net.minestom.server.scoreboard.TeamManager;
@@ -27,6 +28,8 @@
 import org.phantazm.core.VecUtils;
 import org.phantazm.core.equipment.LinearUpgradePath;
 import org.phantazm.core.equipment.NoUpgradePath;
+import org.phantazm.core.game.scene.RouterStore;
+import org.phantazm.core.game.scene.SceneTransferHelper;
 import org.phantazm.core.game.scene.fallback.SceneFallback;
 import org.phantazm.core.guild.party.Party;
 import org.phantazm.core.instance.AnvilFileSystemInstanceLoader;
@@ -38,8 +41,10 @@
 import org.phantazm.core.player.PlayerViewProvider;
 import org.phantazm.proxima.bindings.minestom.InstanceSpawner;
 import org.phantazm.proxima.bindings.minestom.Spawner;
+import org.phantazm.stats.zombies.*;
 import org.phantazm.zombies.Attributes;
 import org.phantazm.zombies.command.ZombiesCommand;
+import org.phantazm.zombies.corpse.CorpseCreator;
 import org.phantazm.zombies.map.FileSystemMapLoader;
 import org.phantazm.zombies.map.Loader;
 import org.phantazm.zombies.map.MapInfo;
@@ -93,6 +98,9 @@
 import java.io.IOException;
 import java.nio.file.Path;
 import java.util.*;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.TimeUnit;
 import java.util.function.Function;
 
 public final class ZombiesFeature {
@@ -106,14 +114,17 @@ public final class ZombiesFeature {
     private static Map<Key, PowerupInfo> powerups;
     private static MobSpawnerSource mobSpawnerSource;
     private static ZombiesSceneRouter sceneRouter;
+    private static ExecutorService databaseExecutor;
+    private static HikariDataSource dataSource;
+    private static ZombiesDatabase database;
 
     static void initialize(@NotNull EventNode<Event> globalEventNode, @NotNull ContextManager contextManager,
             @NotNull Map<BooleanObjectPair<String>, ConfigProcessor<?>> processorMap, @NotNull Spawner spawner,
-            @NotNull KeyParser keyParser, @NotNull ConnectionManager connectionManager,
+            @NotNull KeyParser keyParser,
             @NotNull Function<? super Instance, ? extends InstanceSpawner.InstanceSettings> instanceSpaceFunction,
             @NotNull PlayerViewProvider viewProvider, @NotNull CommandManager commandManager,
-            @NotNull SceneFallback sceneFallback, @NotNull Map<? super UUID, ? extends Party> parties)
-            throws IOException {
+            @NotNull SceneFallback sceneFallback, @NotNull Map<? super UUID, ? extends Party> parties,
+            @NotNull RouterStore routerStore) throws IOException {
         Attributes.registerAll();
         registerElementClasses(contextManager);
 
@@ -130,25 +141,38 @@ static void initialize(@NotNull EventNode<Event> globalEventNode, @NotNull Conte
         for (MapInfo map : maps.values()) {
             instanceLoader.preload(map.settings().instancePath(),
                     VecUtils.toPoint(map.settings().origin().add(map.settings().spawn())),
-                    MinecraftServer.getChunkViewDistance());
+                    map.settings().chunkLoadRange());
         }
 
         Map<Key, ZombiesSceneProvider> providers = new HashMap<>(maps.size());
         TeamManager teamManager = MinecraftServer.getTeamManager();
+
+        // https://bugs.mojang.com/browse/MC-87984
+        Team mobNoPushTeam =
+                teamManager.createBuilder("mobNoPush").collisionRule(TeamsPacket.CollisionRule.PUSH_OTHER_TEAMS)
+                        .build();
         Team corpseTeam = teamManager.createBuilder("corpses").collisionRule(TeamsPacket.CollisionRule.NEVER)
                 .nameTagVisibility(TeamsPacket.NameTagVisibility.NEVER).build();
+
+        databaseExecutor = Executors.newSingleThreadExecutor();
+        HikariConfig config = new HikariConfig("./zombies.hikari.properties");
+        dataSource = new HikariDataSource(config);
+        ZombiesSQLFetcher sqlFetcher = new JooqZombiesSQLFetcher();
+        database = new SQLZombiesDatabase(databaseExecutor, dataSource, sqlFetcher);
         for (Map.Entry<Key, MapInfo> entry : maps.entrySet()) {
             ZombiesSceneProvider provider =
-                    new ZombiesSceneProvider(2, instanceSpaceFunction, entry.getValue(), connectionManager,
-                            MinecraftServer.getInstanceManager(), instanceLoader, sceneFallback, globalEventNode,
-                            ZombiesFeature.mobSpawnerSource(), Mob.getModels(),
+                    new ZombiesSceneProvider(20, instanceSpaceFunction, entry.getValue(), instanceLoader, sceneFallback,
+                            globalEventNode, ZombiesFeature.mobSpawnerSource(), MobFeature.getModels(),
                             new BasicClientBlockHandlerSource(instance -> {
                                 DimensionType dimensionType = instance.getDimensionType();
-                                return new InstanceClientBlockHandler(instance, globalEventNode,
-                                        dimensionType.getMinY(), dimensionType.getHeight());
-                            }), contextManager, keyParser, ZombiesFeature.powerups(),
-                            new BasicZombiesPlayerSource(EquipmentFeature::createEquipmentCreator, corpseTeam,
-                                    Mob.getModels()));
+                                return new InstanceClientBlockHandler(instance, dimensionType.getMinY(),
+                                        dimensionType.getHeight());
+                            }, globalEventNode), contextManager, keyParser, mobNoPushTeam, corpseTeam, database,
+                            ZombiesFeature.powerups(),
+                            new BasicZombiesPlayerSource(EquipmentFeature::createEquipmentCreator,
+                                    MobFeature.getModels()),
+                            mapDependencyProvider -> contextManager.makeContext(entry.getValue().corpse())
+                                    .provide(mapDependencyProvider));
             providers.put(entry.getKey(), provider);
         }
 
@@ -158,9 +182,9 @@ static void initialize(@NotNull EventNode<Event> globalEventNode, @NotNull Conte
                 .scheduleTask(() -> sceneRouter.tick(System.currentTimeMillis()), TaskSchedule.immediate(),
                         TaskSchedule.nextTick());
 
+        SceneTransferHelper transferHelper = new SceneTransferHelper(routerStore);
         commandManager.register(
-                new ZombiesCommand(parties, sceneRouter, keyParser, maps, viewProvider, ZombiesFeature::getPlayerScene,
-                        sceneFallback));
+                new ZombiesCommand(parties, sceneRouter, keyParser, maps, viewProvider, transferHelper, sceneFallback));
     }
 
     private static void registerElementClasses(ContextManager contextManager) {
@@ -181,6 +205,7 @@ private static void registerElementClasses(ContextManager contextManager) {
         contextManager.registerElementClass(MapFlagPredicate.class);
         contextManager.registerElementClass(InteractingPredicate.class);
         contextManager.registerElementClass(PlayerFlagPredicate.class);
+        contextManager.registerElementClass(PlayerInGamePredicate.class);
         contextManager.registerElementClass(PlayerStatePredicate.class);
         contextManager.registerElementClass(UuidPredicate.class);
         contextManager.registerElementClass(TypePredicate.class);
@@ -297,6 +322,11 @@ private static void registerElementClasses(ContextManager contextManager) {
         //Player conditions
         contextManager.registerElementClass(EquipmentCondition.class);
 
+        //Corpses
+        contextManager.registerElementClass(CorpseCreator.class);
+        contextManager.registerElementClass(CorpseCreator.TimeLine.class);
+        contextManager.registerElementClass(CorpseCreator.StaticLine.class);
+
         LOGGER.info("Registered Zombies element classes.");
     }
 
@@ -338,15 +368,47 @@ private static <T extends Keyed> Map<Key, T> loadFeature(String featureName, Loa
     }
 
     public static @NotNull Optional<ZombiesScene> getPlayerScene(@NotNull UUID playerUUID) {
-        return FeatureUtils.check(sceneRouter).getScene(playerUUID);
+        return FeatureUtils.check(sceneRouter).getCurrentScene(playerUUID);
     }
 
     public static @NotNull Optional<ZombiesPlayer> getZombiesPlayer(@NotNull UUID playerUUID) {
-        return FeatureUtils.check(sceneRouter).getScene(playerUUID)
+        return FeatureUtils.check(sceneRouter).getCurrentScene(playerUUID)
                 .map(scene -> scene.getZombiesPlayers().get(playerUUID));
     }
 
     public static @NotNull ZombiesSceneRouter zombiesSceneRouter() {
         return FeatureUtils.check(sceneRouter);
     }
+
+    public static @NotNull ZombiesDatabase getDatabase() {
+        return FeatureUtils.check(database);
+    }
+
+    public static void end() {
+        if (dataSource != null) {
+            dataSource.close();
+        }
+
+        if (databaseExecutor != null) {
+            databaseExecutor.shutdown();
+
+            try {
+                LOGGER.info(
+                        "Shutting down database executor. Please allow for one minute before shutdown " + "completes.");
+                if (!databaseExecutor.awaitTermination(1L, TimeUnit.MINUTES)) {
+                    databaseExecutor.shutdownNow();
+
+                    LOGGER.warn(
+                            "Not all database tasks completed. Please allow for one minute for tasks to be canceled.");
+                    if (!databaseExecutor.awaitTermination(1L, TimeUnit.MINUTES)) {
+                        LOGGER.warn("Database tasks failed to cancel.");
+                    }
+                }
+            }
+            catch (InterruptedException e) {
+                databaseExecutor.shutdownNow();
+                Thread.currentThread().interrupt();
+            }
+        }
+    }
 }
diff --git a/server/src/main/java/org/phantazm/server/command/BanCommand.java b/server/src/main/java/org/phantazm/server/command/server/BanCommand.java
similarity index 83%
rename from server/src/main/java/org/phantazm/server/command/BanCommand.java
rename to server/src/main/java/org/phantazm/server/command/server/BanCommand.java
index 47e809f9c..befe0f3c9 100644
--- a/server/src/main/java/org/phantazm/server/command/BanCommand.java
+++ b/server/src/main/java/org/phantazm/server/command/server/BanCommand.java
@@ -1,4 +1,4 @@
-package org.phantazm.server.command;
+package org.phantazm.server.command.server;
 
 import net.kyori.adventure.text.Component;
 import net.kyori.adventure.text.minimessage.MiniMessage;
@@ -8,18 +8,22 @@
 import net.minestom.server.command.builder.arguments.ArgumentType;
 import net.minestom.server.command.builder.arguments.ArgumentWord;
 import net.minestom.server.entity.Player;
+import net.minestom.server.permission.Permission;
 import org.jetbrains.annotations.NotNull;
 import org.phantazm.core.player.IdentitySource;
 import org.phantazm.server.player.LoginValidator;
 
 public class BanCommand extends Command {
+    public static final Permission PERMISSION = new Permission("admin.ban");
+
     private static final ArgumentWord PLAYER_ARGUMENT = ArgumentType.Word("player");
     private static final Argument<String> REASON = ArgumentType.String("reason").setDefaultValue("");
 
     public BanCommand(@NotNull IdentitySource identitySource, @NotNull LoginValidator loginValidator) {
         super("ban");
 
-        addSyntax((sender, context) -> {
+        setCondition((sender, commandString) -> sender.hasPermission(PERMISSION));
+        addConditionalSyntax(getCondition(), (sender, context) -> {
             String name = context.get(PLAYER_ARGUMENT);
             identitySource.getUUID(name).whenComplete((uuidOptional, throwable) -> {
                 uuidOptional.ifPresent(uuid -> {
diff --git a/server/src/main/java/org/phantazm/server/command/server/DebugCommand.java b/server/src/main/java/org/phantazm/server/command/server/DebugCommand.java
new file mode 100644
index 000000000..d4d19121f
--- /dev/null
+++ b/server/src/main/java/org/phantazm/server/command/server/DebugCommand.java
@@ -0,0 +1,45 @@
+package org.phantazm.server.command.server;
+
+import net.minestom.server.MinecraftServer;
+import net.minestom.server.command.builder.Command;
+import net.minestom.server.instance.EntityTracker;
+import net.minestom.server.instance.Instance;
+import net.minestom.server.permission.Permission;
+
+public class DebugCommand extends Command {
+    public static final Permission PERMISSION = new Permission("admin.debug");
+    public static final Permission EVENT_PERMISSION = new Permission("admin.debug.event");
+    public static final Permission INSTANCE_PERMISSION = new Permission("admin.debug.instance");
+
+    public DebugCommand() {
+        super("debug");
+        setCondition((sender, commandString) -> sender.hasPermission(PERMISSION));
+
+        addSubcommand(new DebugEvent());
+        addSubcommand(new DebugInstance());
+    }
+
+    private static class DebugEvent extends Command {
+        private DebugEvent() {
+            super("event");
+
+            setCondition((sender, commandString) -> sender.hasPermission(EVENT_PERMISSION));
+            addConditionalSyntax(getCondition(),
+                    (sender, context) -> sender.sendMessage(MinecraftServer.getGlobalEventHandler().toString()));
+        }
+    }
+
+    private static class DebugInstance extends Command {
+        private DebugInstance() {
+            super("instance");
+
+            setCondition((sender, commandString) -> sender.hasPermission(INSTANCE_PERMISSION));
+            addConditionalSyntax(getCondition(), (sender, context) -> {
+                for (Instance instance : MinecraftServer.getInstanceManager().getInstances()) {
+                    sender.sendMessage(instance.getUniqueId() + ": " +
+                            instance.getEntityTracker().entities(EntityTracker.Target.PLAYERS).size() + " player");
+                }
+            });
+        }
+    }
+}
diff --git a/server/src/main/java/org/phantazm/server/command/server/OrderlyShutdownCommand.java b/server/src/main/java/org/phantazm/server/command/server/OrderlyShutdownCommand.java
new file mode 100644
index 000000000..e120a3e8f
--- /dev/null
+++ b/server/src/main/java/org/phantazm/server/command/server/OrderlyShutdownCommand.java
@@ -0,0 +1,95 @@
+package org.phantazm.server.command.server;
+
+import net.minestom.server.MinecraftServer;
+import net.minestom.server.adventure.audience.Audiences;
+import net.minestom.server.command.builder.Command;
+import net.minestom.server.event.Event;
+import net.minestom.server.event.EventNode;
+import net.minestom.server.permission.Permission;
+import net.minestom.server.timer.TaskSchedule;
+import org.jetbrains.annotations.NotNull;
+import org.phantazm.core.game.scene.RouterStore;
+import org.phantazm.core.game.scene.SceneRouter;
+import org.phantazm.core.game.scene.event.SceneShutdownEvent;
+import org.phantazm.server.config.server.ShutdownConfig;
+
+import java.util.Objects;
+
+public class OrderlyShutdownCommand extends Command {
+    public static final Permission PERMISSION = new Permission("admin.orderly_shutdown");
+
+    private final RouterStore routerStore;
+    private boolean initialized;
+    private long shutdownStart;
+
+    public OrderlyShutdownCommand(@NotNull RouterStore routerStore, @NotNull ShutdownConfig shutdownConfig,
+            @NotNull EventNode<Event> globalNode) {
+        super("orderly_shutdown");
+        this.routerStore = Objects.requireNonNull(routerStore, "routerStore");
+
+        setCondition((sender, commandString) -> sender.hasPermission(PERMISSION));
+        addConditionalSyntax(getCondition(), (sender, context) -> {
+            if (initialized) {
+                sender.sendMessage("Orderly shutdown has already been initialized");
+                return;
+            }
+
+            initialized = true;
+            shutdownStart = System.currentTimeMillis();
+
+            for (SceneRouter<?, ?> router : routerStore.getRouters()) {
+                if (router.isGame()) {
+                    router.setJoinable(false);
+                }
+            }
+
+            MinecraftServer.getSchedulerManager().scheduleTask(() -> {
+                long elapsedMs = System.currentTimeMillis() - shutdownStart;
+                if (elapsedMs > shutdownConfig.forceShutdownWarningTime()) {
+                    Audiences.all().sendMessage(shutdownConfig.forceShutdownMessage());
+                }
+                else {
+                    Audiences.all().sendMessage(shutdownConfig.shutdownMessage());
+                }
+            }, TaskSchedule.immediate(), TaskSchedule.millis(shutdownConfig.warningInterval()));
+
+            MinecraftServer.getSchedulerManager().scheduleTask(() -> {
+                long elapsedMs = System.currentTimeMillis() - shutdownStart;
+                if (elapsedMs > shutdownConfig.forceShutdownTime()) {
+                    System.exit(0); //exit even if we've got games
+                    return;
+                }
+
+                if (noGamesActive()) {
+                    System.exit(0);
+                }
+            }, TaskSchedule.immediate(), TaskSchedule.tick(20));
+
+            globalNode.addListener(SceneShutdownEvent.class, this::onSceneShutdown);
+
+            if (noGamesActive()) {
+                System.exit(0);
+            }
+        });
+    }
+
+    private boolean noGamesActive() {
+        for (SceneRouter<?, ?> router : routerStore.getRouters()) {
+            if (!router.isGame()) {
+                continue;
+            }
+
+            if (router.hasActiveScenes()) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    private void onSceneShutdown(@NotNull SceneShutdownEvent event) {
+        if (noGamesActive()) {
+            System.exit(0);
+        }
+    }
+}
diff --git a/server/src/main/java/org/phantazm/server/command/PardonCommand.java b/server/src/main/java/org/phantazm/server/command/server/PardonCommand.java
similarity index 80%
rename from server/src/main/java/org/phantazm/server/command/PardonCommand.java
rename to server/src/main/java/org/phantazm/server/command/server/PardonCommand.java
index 48a12f38d..47227a39a 100644
--- a/server/src/main/java/org/phantazm/server/command/PardonCommand.java
+++ b/server/src/main/java/org/phantazm/server/command/server/PardonCommand.java
@@ -1,21 +1,25 @@
-package org.phantazm.server.command;
+package org.phantazm.server.command.server;
 
 import net.minestom.server.command.builder.Command;
 import net.minestom.server.command.builder.arguments.Argument;
 import net.minestom.server.command.builder.arguments.ArgumentType;
 import net.minestom.server.command.builder.arguments.ArgumentWord;
+import net.minestom.server.permission.Permission;
 import org.jetbrains.annotations.NotNull;
 import org.phantazm.core.player.IdentitySource;
 import org.phantazm.server.player.LoginValidator;
 
 public class PardonCommand extends Command {
+    public static final Permission PERMISSION = new Permission("admin.pardon");
+
     private static final ArgumentWord PLAYER_ARGUMENT = ArgumentType.Word("player");
     private static final Argument<String> REASON = ArgumentType.String("reason").setDefaultValue("");
 
     public PardonCommand(@NotNull IdentitySource identitySource, @NotNull LoginValidator loginValidator) {
         super("pardon");
 
-        addSyntax((sender, context) -> {
+        setCondition((sender, commandString) -> sender.hasPermission(PERMISSION));
+        addConditionalSyntax(getCondition(), (sender, context) -> {
             String name = context.get(PLAYER_ARGUMENT);
             identitySource.getUUID(name).whenComplete((uuidOptional, throwable) -> {
                 uuidOptional.ifPresent(uuid -> {
diff --git a/server/src/main/java/org/phantazm/server/command/server/PermissionCommand.java b/server/src/main/java/org/phantazm/server/command/server/PermissionCommand.java
new file mode 100644
index 000000000..0706a6882
--- /dev/null
+++ b/server/src/main/java/org/phantazm/server/command/server/PermissionCommand.java
@@ -0,0 +1,136 @@
+package org.phantazm.server.command.server;
+
+import net.minestom.server.command.builder.Command;
+import net.minestom.server.command.builder.arguments.ArgumentType;
+import net.minestom.server.command.builder.arguments.ArgumentWord;
+import net.minestom.server.permission.Permission;
+import org.jetbrains.annotations.NotNull;
+import org.phantazm.core.player.IdentitySource;
+import org.phantazm.server.permission.PermissionHandler;
+
+import java.util.UUID;
+
+public class PermissionCommand extends Command {
+    public static final Permission PERMISSION = new Permission("admin.permission");
+
+    public static final Permission PERMISSION_FLUSH = new Permission("admin.permission.flush");
+    public static final Permission PERMISSION_RELOAD = new Permission("admin.permission.reload");
+
+    public static final Permission PERMISSION_ADD_GROUP = new Permission("admin.permission.group.add");
+    public static final Permission PERMISSION_REMOVE_GROUP = new Permission("admin.permission.group.remove");
+
+    public static final Permission PERMISSION_GROUP_SET = new Permission("admin.permission.group.set");
+    public static final Permission PERMISSION_GROUP_CLEAR = new Permission("admin.permission.group.clear");
+
+    private static final ArgumentWord PLAYER_ARGUMENT = ArgumentType.Word("player");
+    private static final ArgumentWord GROUP_ARGUMENT = ArgumentType.Word("group");
+    private static final ArgumentWord PERMISSION_ARGUMENT = ArgumentType.Word("permission");
+
+    public PermissionCommand(@NotNull PermissionHandler permissionHandler, @NotNull IdentitySource identitySource) {
+        super("permission");
+
+        setCondition((sender, commandString) -> sender.hasPermission(PERMISSION));
+        addSubcommand(new Add(permissionHandler));
+        addSubcommand(new Remove(permissionHandler));
+        addSubcommand(new GroupSet(permissionHandler, identitySource));
+        addSubcommand(new GroupClear(permissionHandler, identitySource));
+        addSubcommand(new Reload(permissionHandler));
+        addSubcommand(new Flush(permissionHandler));
+    }
+
+    private static class Reload extends Command {
+        private Reload(PermissionHandler permissionHandler) {
+            super("reload");
+
+            setCondition((sender, commandString) -> sender.hasPermission(PERMISSION_RELOAD));
+            addConditionalSyntax(getCondition(), (sender, context) -> {
+                permissionHandler.reload();
+            });
+        }
+    }
+
+    private static class Flush extends Command {
+        private Flush(PermissionHandler permissionHandler) {
+            super("flush");
+
+            setCondition((sender, commandString) -> sender.hasPermission(PERMISSION_FLUSH));
+            addConditionalSyntax(getCondition(), (sender, context) -> {
+                permissionHandler.flush();
+            });
+        }
+    }
+
+    private static class GroupSet extends Command {
+        private GroupSet(PermissionHandler permissionHandler, IdentitySource identitySource) {
+            super("group_set");
+
+            setCondition((sender, commandString) -> sender.hasPermission(PERMISSION_GROUP_SET));
+            addConditionalSyntax(getCondition(), (sender, context) -> {
+                String group = context.get(GROUP_ARGUMENT);
+                String player = context.get(PLAYER_ARGUMENT);
+                identitySource.getUUID(player).whenComplete((uuidOptional, throwable) -> {
+                    if (uuidOptional.isPresent()) {
+                        UUID uuid = uuidOptional.get();
+                        permissionHandler.addToGroup(uuid, group);
+                        sender.sendMessage("Added " + uuid + " (" + player + ") to group " + group);
+                    }
+                    else {
+                        sender.sendMessage("Error when resolving player UUID");
+                    }
+                });
+            }, GROUP_ARGUMENT, PLAYER_ARGUMENT);
+        }
+    }
+
+    private static class GroupClear extends Command {
+        private GroupClear(PermissionHandler permissionHandler, IdentitySource identitySource) {
+            super("group_clear");
+
+            setCondition((sender, commandString) -> sender.hasPermission(PERMISSION_GROUP_CLEAR));
+            addConditionalSyntax(getCondition(), (sender, context) -> {
+                String group = context.get(GROUP_ARGUMENT);
+                String player = context.get(PLAYER_ARGUMENT);
+                identitySource.getUUID(player).whenComplete((uuidOptional, throwable) -> {
+                    if (uuidOptional.isPresent()) {
+                        UUID uuid = uuidOptional.get();
+                        permissionHandler.removeFromGroup(uuid, group);
+                        sender.sendMessage("Removed " + uuid + " (" + player + ") from group " + group);
+                    }
+                    else {
+                        sender.sendMessage("Error when resolving player UUID");
+                    }
+                });
+            }, GROUP_ARGUMENT, PLAYER_ARGUMENT);
+        }
+    }
+
+    private static class Add extends Command {
+        private Add(PermissionHandler permissionHandler) {
+            super("add");
+
+            setCondition((sender, commandString) -> sender.hasPermission(PERMISSION_ADD_GROUP));
+            addConditionalSyntax(getCondition(), (sender, context) -> {
+                String group = context.get(GROUP_ARGUMENT);
+                String permission = context.get(PERMISSION_ARGUMENT);
+
+                permissionHandler.addGroupPermission(group, new Permission(permission));
+                sender.sendMessage("Added permission " + permission + " to group " + group);
+            }, GROUP_ARGUMENT, PERMISSION_ARGUMENT);
+        }
+    }
+
+    private static class Remove extends Command {
+        private Remove(PermissionHandler permissionHandler) {
+            super("remove");
+
+            setCondition((sender, commandString) -> sender.hasPermission(PERMISSION_REMOVE_GROUP));
+            addConditionalSyntax(getCondition(), (sender, context) -> {
+                String group = context.get(GROUP_ARGUMENT);
+                String permission = context.get(PERMISSION_ARGUMENT);
+
+                permissionHandler.removeGroupPermission(group, new Permission(permission));
+                sender.sendMessage("Removed permission " + permission + " from group " + group);
+            }, GROUP_ARGUMENT, PERMISSION_ARGUMENT);
+        }
+    }
+}
diff --git a/server/src/main/java/org/phantazm/server/command/server/StopCommand.java b/server/src/main/java/org/phantazm/server/command/server/StopCommand.java
new file mode 100644
index 000000000..ea95950cb
--- /dev/null
+++ b/server/src/main/java/org/phantazm/server/command/server/StopCommand.java
@@ -0,0 +1,16 @@
+package org.phantazm.server.command.server;
+
+import net.minestom.server.command.builder.Command;
+import net.minestom.server.permission.Permission;
+import org.phantazm.server.PhantazmServer;
+
+public class StopCommand extends Command {
+    public static final Permission PERMISSION = new Permission("admin.stop");
+
+    public StopCommand() {
+        super("stop");
+
+        setCondition((sender, commandString) -> sender.hasPermission(PERMISSION));
+        addConditionalSyntax(getCondition(), (sender, context) -> PhantazmServer.shutdown("stop command"));
+    }
+}
diff --git a/server/src/main/java/org/phantazm/server/command/WhitelistCommand.java b/server/src/main/java/org/phantazm/server/command/server/WhitelistCommand.java
similarity index 85%
rename from server/src/main/java/org/phantazm/server/command/WhitelistCommand.java
rename to server/src/main/java/org/phantazm/server/command/server/WhitelistCommand.java
index 5aa8b3b6f..f706b925d 100644
--- a/server/src/main/java/org/phantazm/server/command/WhitelistCommand.java
+++ b/server/src/main/java/org/phantazm/server/command/server/WhitelistCommand.java
@@ -1,15 +1,17 @@
-package org.phantazm.server.command;
+package org.phantazm.server.command.server;
 
 import net.minestom.server.MinecraftServer;
 import net.minestom.server.command.builder.Command;
 import net.minestom.server.command.builder.arguments.ArgumentType;
 import net.minestom.server.command.builder.arguments.ArgumentWord;
 import net.minestom.server.entity.Player;
+import net.minestom.server.permission.Permission;
 import org.jetbrains.annotations.NotNull;
 import org.phantazm.core.player.IdentitySource;
 import org.phantazm.server.player.LoginValidator;
 
 public class WhitelistCommand extends Command {
+    public static final Permission PERMISSION = new Permission("admin.whitelist");
     private static final ArgumentWord PLAYER_ARGUMENT = ArgumentType.Word("player");
 
     public WhitelistCommand(@NotNull IdentitySource identitySource, @NotNull LoginValidator loginValidator,
@@ -24,7 +26,8 @@ private static class Add extends Command {
         private Add(@NotNull IdentitySource identitySource, @NotNull LoginValidator loginValidator) {
             super("add");
 
-            addSyntax((sender, context) -> {
+            setCondition((sender, commandString) -> sender.hasPermission(PERMISSION));
+            addConditionalSyntax(getCondition(), (sender, context) -> {
                 String name = context.get(PLAYER_ARGUMENT);
                 identitySource.getUUID(name).whenComplete((uuidOptional, throwable) -> {
                     uuidOptional.ifPresent(uuid -> {
@@ -46,7 +49,8 @@ private Remove(@NotNull IdentitySource identitySource, @NotNull LoginValidator l
                 boolean whitelist) {
             super("remove");
 
-            addSyntax((sender, context) -> {
+            setCondition((sender, commandString) -> sender.hasPermission(PERMISSION));
+            addConditionalSyntax(getCondition(), (sender, context) -> {
                 String name = context.get(PLAYER_ARGUMENT);
                 identitySource.getUUID(name).whenComplete((uuidOptional, throwable) -> {
                     uuidOptional.ifPresent(uuid -> {
diff --git a/server/src/main/java/org/phantazm/server/command/whisper/ReplyCommand.java b/server/src/main/java/org/phantazm/server/command/whisper/ReplyCommand.java
new file mode 100644
index 000000000..30c1d8d36
--- /dev/null
+++ b/server/src/main/java/org/phantazm/server/command/whisper/ReplyCommand.java
@@ -0,0 +1,44 @@
+package org.phantazm.server.command.whisper;
+
+import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.format.NamedTextColor;
+import net.minestom.server.command.ConsoleSender;
+import net.minestom.server.command.builder.Command;
+import net.minestom.server.command.builder.arguments.Argument;
+import net.minestom.server.command.builder.arguments.ArgumentType;
+import net.minestom.server.entity.Player;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Objects;
+
+public class ReplyCommand {
+
+    public static @NotNull Command replyCommand(@NotNull WhisperManager whisperManager) {
+        Objects.requireNonNull(whisperManager, "whisperManager");
+
+        Argument<String[]> message = ArgumentType.StringArray("message");
+        Command command = new Command("reply", "r");
+        command.addConditionalSyntax((sender, commandString) -> {
+            if (commandString == null) {
+                return sender instanceof Player || sender instanceof ConsoleSender;
+            }
+
+            if (!(sender instanceof Player || sender instanceof ConsoleSender)) {
+                sender.sendMessage(Component.text("You have to be a player or the console to use that command!",
+                        NamedTextColor.RED));
+                return false;
+            }
+
+            return true;
+        }, (sender, context) -> {
+            whisperManager.getLastConverser(sender).ifPresentOrElse(target -> {
+                whisperManager.whisper(sender, target, String.join(" ", context.get(message)));
+            }, () -> {
+                sender.sendMessage(Component.text("Nobody has spoken to you.", NamedTextColor.RED));
+            });
+        }, message);
+
+        return command;
+    }
+
+}
diff --git a/server/src/main/java/org/phantazm/server/command/whisper/WhisperCommand.java b/server/src/main/java/org/phantazm/server/command/whisper/WhisperCommand.java
new file mode 100644
index 000000000..40c560699
--- /dev/null
+++ b/server/src/main/java/org/phantazm/server/command/whisper/WhisperCommand.java
@@ -0,0 +1,56 @@
+package org.phantazm.server.command.whisper;
+
+import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.format.NamedTextColor;
+import net.kyori.adventure.text.minimessage.MiniMessage;
+import net.kyori.adventure.text.minimessage.tag.resolver.Placeholder;
+import net.kyori.adventure.text.minimessage.tag.resolver.TagResolver;
+import net.minestom.server.command.ConsoleSender;
+import net.minestom.server.command.builder.Command;
+import net.minestom.server.command.builder.arguments.Argument;
+import net.minestom.server.command.builder.arguments.ArgumentType;
+import net.minestom.server.entity.Player;
+import net.minestom.server.network.ConnectionManager;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Objects;
+
+public class WhisperCommand {
+
+    public static @NotNull Command whisperCommand(@NotNull ConnectionManager connectionManager,
+            @NotNull WhisperManager whisperManager) {
+        Objects.requireNonNull(connectionManager, "connectionManager");
+        Objects.requireNonNull(whisperManager, "whisperManager");
+
+        Command command = new Command("whisper", "w", "msg");
+        Argument<String> target = ArgumentType.Word("target");
+        Argument<String[]> message = ArgumentType.StringArray("message");
+
+        command.addConditionalSyntax((sender, commandString) -> {
+            if (commandString == null) {
+                return sender instanceof Player || sender instanceof ConsoleSender;
+            }
+
+            if (!(sender instanceof Player || sender instanceof ConsoleSender)) {
+                sender.sendMessage(Component.text("You have to be a player or the console to use that command!",
+                        NamedTextColor.RED));
+                return false;
+            }
+
+            return true;
+        }, (sender, context) -> {
+            String name = context.get(target);
+            Player targetPlayer = connectionManager.getPlayer(name);
+
+            if (targetPlayer == null) {
+                sender.sendMessage(Component.text(name + " is not online."));
+                return;
+            }
+
+            whisperManager.whisper(sender, targetPlayer, String.join(" ", context.get(message)));
+        }, target, message);
+
+        return command;
+    }
+
+}
diff --git a/server/src/main/java/org/phantazm/server/command/whisper/WhisperConfig.java b/server/src/main/java/org/phantazm/server/command/whisper/WhisperConfig.java
new file mode 100644
index 000000000..f45863416
--- /dev/null
+++ b/server/src/main/java/org/phantazm/server/command/whisper/WhisperConfig.java
@@ -0,0 +1,11 @@
+package org.phantazm.server.command.whisper;
+
+import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.format.TextColor;
+import org.jetbrains.annotations.NotNull;
+
+public record WhisperConfig(@NotNull String toTargetFormat, @NotNull String toSenderFormat,
+                            @NotNull TextColor fallbackNameColor, @NotNull Component consoleName,
+                            @NotNull Component defaultName) {
+
+}
diff --git a/server/src/main/java/org/phantazm/server/command/whisper/WhisperManager.java b/server/src/main/java/org/phantazm/server/command/whisper/WhisperManager.java
new file mode 100644
index 000000000..a7aaf5a30
--- /dev/null
+++ b/server/src/main/java/org/phantazm/server/command/whisper/WhisperManager.java
@@ -0,0 +1,108 @@
+package org.phantazm.server.command.whisper;
+
+import net.kyori.adventure.audience.Audience;
+import net.kyori.adventure.identity.Identity;
+import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.minimessage.MiniMessage;
+import net.kyori.adventure.text.minimessage.tag.resolver.Placeholder;
+import net.kyori.adventure.text.minimessage.tag.resolver.TagResolver;
+import net.minestom.server.command.ConsoleSender;
+import net.minestom.server.entity.Player;
+import net.minestom.server.network.ConnectionManager;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.*;
+
+public class WhisperManager {
+
+    private final Map<UUID, UUID> previousConverser = new HashMap<>();
+
+    private final ConsoleSender consoleSender;
+
+    private final ConnectionManager connectionManager;
+
+    private final WhisperConfig whisperConfig;
+
+    private final MiniMessage miniMessage;
+
+    public WhisperManager(@NotNull ConnectionManager connectionManager, @NotNull ConsoleSender consoleSender,
+            @NotNull WhisperConfig whisperConfig, @NotNull MiniMessage miniMessage) {
+        this.connectionManager = Objects.requireNonNull(connectionManager, "connectionManager");
+        this.consoleSender = Objects.requireNonNull(consoleSender, "consoleSender");
+        this.whisperConfig = Objects.requireNonNull(whisperConfig, "whisperConfig");
+        this.miniMessage = Objects.requireNonNull(miniMessage, "miniMessage");
+    }
+
+    public void whisper(@NotNull Audience sender, @NotNull Audience target, @NotNull String message) {
+        TagResolver senderPlaceholder = Placeholder.component("sender", resolveDisplayName(sender));
+        TagResolver targetPlaceholder = Placeholder.component("target", resolveDisplayName(target));
+        TagResolver messagePlaceholder = Placeholder.unparsed("message", message);
+
+        Component toTarget =
+                miniMessage.deserialize(whisperConfig.toTargetFormat(), senderPlaceholder, targetPlaceholder,
+                        messagePlaceholder);
+        target.sendMessage(toTarget);
+
+        Component toSender =
+                miniMessage.deserialize(whisperConfig.toSenderFormat(), senderPlaceholder, targetPlaceholder,
+                        messagePlaceholder);
+        sender.sendMessage(toSender);
+
+        UUID senderUUID = resolveUUID(sender);
+        UUID targetUUID = resolveUUID(target);
+
+        if (senderUUID != null && targetUUID != null) {
+            previousConverser.put(targetUUID, senderUUID);
+        }
+    }
+
+    public @NotNull Optional<Audience> getLastConverser(@NotNull Audience audience) {
+        UUID audienceUUID = resolveUUID(audience);
+        if (audienceUUID == null) {
+            return Optional.empty();
+        }
+
+        UUID lastConverserUUID = previousConverser.get(audienceUUID);
+        if (lastConverserUUID == null) {
+            return Optional.empty();
+        }
+
+        if (lastConverserUUID.equals(Identity.nil().uuid())) {
+            return Optional.of(consoleSender);
+        }
+
+        return Optional.ofNullable(connectionManager.getPlayer(lastConverserUUID));
+    }
+
+    private Component resolveDisplayName(Audience audience) {
+        if (audience instanceof Player player) {
+            Component displayName = player.getDisplayName();
+            if (displayName != null) {
+                return displayName.colorIfAbsent(whisperConfig.fallbackNameColor());
+            }
+
+            return Component.text(player.getUsername(), whisperConfig.fallbackNameColor());
+        }
+
+        if (audience instanceof ConsoleSender) {
+            return whisperConfig.consoleName();
+        }
+
+        Optional<Component> displayName = audience.get(Identity.DISPLAY_NAME);
+        return displayName.map(component -> component.colorIfAbsent(whisperConfig.fallbackNameColor()))
+                .orElse(whisperConfig.defaultName());
+    }
+
+    private @Nullable UUID resolveUUID(Audience audience) {
+        if (audience instanceof Player player) {
+            return player.getUuid();
+        }
+        else if (audience instanceof ConsoleSender) {
+            return consoleSender.identity().uuid();
+        }
+
+        return null;
+    }
+
+}
diff --git a/server/src/main/java/org/phantazm/server/config/loader/LobbiesConfigProcessor.java b/server/src/main/java/org/phantazm/server/config/loader/LobbiesConfigProcessor.java
index 5ea801cbd..391892a88 100644
--- a/server/src/main/java/org/phantazm/server/config/loader/LobbiesConfigProcessor.java
+++ b/server/src/main/java/org/phantazm/server/config/loader/LobbiesConfigProcessor.java
@@ -52,7 +52,11 @@ public class LobbiesConfigProcessor implements ConfigProcessor<LobbiesConfig> {
                 long time = instanceConfigNode.getNumberOrDefault(InstanceConfig.DEFAULT_TIME, "time").longValue();
                 int timeRate =
                         instanceConfigNode.getNumberOrDefault(InstanceConfig.DEFAULT_TIME_RATE, "timeRate").intValue();
-                InstanceConfig instanceConfig = new InstanceConfig(new Pos(x, y, z, yaw, pitch), time, timeRate);
+                int chunkLoadRange =
+                        instanceConfigNode.getNumberOrDefault(InstanceConfig.DEFAULT_CHUNK_LOAD_RANGE, "chunkLoadRange")
+                                .intValue();
+                InstanceConfig instanceConfig =
+                        new InstanceConfig(new Pos(x, y, z, yaw, pitch), time, timeRate, chunkLoadRange);
 
                 ConfigList lobbyPathsList = lobby.getValue().getListOrThrow("lobbyPaths");
                 List<String> lobbyPaths = new ArrayList<>(lobbyPathsList.size());
@@ -63,7 +67,9 @@ public class LobbiesConfigProcessor implements ConfigProcessor<LobbiesConfig> {
                 int maxPlayers = lobby.getValue().getNumberOrThrow("maxPlayers").intValue();
                 int maxLobbies = lobby.getValue().getNumberOrThrow("maxLobbies").intValue();
 
-                lobbies.put(lobby.getKey(), new LobbyConfig(instanceConfig, lobbyPaths, maxPlayers, maxLobbies));
+                ConfigList npcs = lobby.getValue().getListOrDefault(ConfigList::of, "npcs");
+
+                lobbies.put(lobby.getKey(), new LobbyConfig(instanceConfig, lobbyPaths, maxPlayers, maxLobbies, npcs));
             }
 
             return new LobbiesConfig(instancesPath, kickMessage, mainLobbyName, lobbies);
@@ -89,6 +95,8 @@ public class LobbiesConfigProcessor implements ConfigProcessor<LobbiesConfig> {
 
             ConfigNode instanceConfigNode = new LinkedConfigNode(1);
             instanceConfigNode.put("spawnPoint", spawnPointNode);
+            instanceConfigNode.putNumber("time", lobby.getValue().instanceConfig().time());
+            instanceConfigNode.putNumber("timeRate", lobby.getValue().instanceConfig().timeRate());
 
             ConfigList lobbyPathsList = new ArrayConfigList(lobby.getValue().lobbyPaths().size());
             for (String subPath : lobby.getValue().lobbyPaths()) {
@@ -99,6 +107,7 @@ public class LobbiesConfigProcessor implements ConfigProcessor<LobbiesConfig> {
             lobbyNode.put("lobbyPaths", lobbyPathsList);
             lobbyNode.putNumber("maxPlayers", lobby.getValue().maxPlayers());
             lobbyNode.putNumber("maxLobbies", lobby.getValue().maxLobbies());
+            lobbyNode.put("npcs", lobby.getValue().npcs());
 
             lobbiesNode.put(lobby.getKey(), lobbyNode);
         }
diff --git a/server/src/main/java/org/phantazm/server/config/loader/ServerConfigProcessor.java b/server/src/main/java/org/phantazm/server/config/loader/ServerConfigProcessor.java
index 0137fda5c..485178263 100644
--- a/server/src/main/java/org/phantazm/server/config/loader/ServerConfigProcessor.java
+++ b/server/src/main/java/org/phantazm/server/config/loader/ServerConfigProcessor.java
@@ -60,7 +60,6 @@ public class ServerConfigProcessor implements ConfigProcessor<ServerConfig> {
         PingListConfig pingListConfig = serverConfig.pingListConfig();
         pingList.put("description", COMPONENT_PROCESSOR.elementFromData(pingListConfig.description()));
 
-
         ConfigNode configNode = new LinkedConfigNode(3);
         configNode.put("serverInfo", serverInfo);
         configNode.put("pingList", pingList);
diff --git a/server/src/main/java/org/phantazm/server/config/loader/ShutdownConfigProcessor.java b/server/src/main/java/org/phantazm/server/config/loader/ShutdownConfigProcessor.java
new file mode 100644
index 000000000..bef005af2
--- /dev/null
+++ b/server/src/main/java/org/phantazm/server/config/loader/ShutdownConfigProcessor.java
@@ -0,0 +1,47 @@
+package org.phantazm.server.config.loader;
+
+import com.github.steanky.ethylene.core.ConfigElement;
+import com.github.steanky.ethylene.core.collection.ConfigNode;
+import com.github.steanky.ethylene.core.processor.ConfigProcessor;
+import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.minimessage.MiniMessage;
+import org.jetbrains.annotations.NotNull;
+import org.phantazm.server.config.server.ShutdownConfig;
+
+public class ShutdownConfigProcessor implements ConfigProcessor<ShutdownConfig> {
+    @Override
+    public ShutdownConfig dataFromElement(@NotNull ConfigElement element) {
+        Component shutdownMessage = MiniMessage.miniMessage().deserialize(element.getStringOrDefault(
+                () -> MiniMessage.miniMessage().serialize(ShutdownConfig.DEFAULT.shutdownMessage()),
+                "shutdownMessage"));
+
+        Component forceShutdownMessage = MiniMessage.miniMessage().deserialize(element.getStringOrDefault(
+                () -> MiniMessage.miniMessage().serialize(ShutdownConfig.DEFAULT.forceShutdownMessage()),
+                "forceShutdownMessage"));
+
+        long warningInterval =
+                element.getNumberOrDefault(ShutdownConfig.DEFAULT.warningInterval(), "warningInterval").longValue();
+
+        long forceShutdownTime =
+                element.getNumberOrDefault(ShutdownConfig.DEFAULT.forceShutdownTime(), "forceShutdownTime").longValue();
+
+        long forceShutdownWarningTime = element.getNumberOrDefault(ShutdownConfig.DEFAULT.forceShutdownWarningTime(),
+                "forceShutdownWarningTime").longValue();
+
+        return new ShutdownConfig(shutdownMessage, forceShutdownMessage, warningInterval, forceShutdownTime,
+                forceShutdownWarningTime);
+    }
+
+    @Override
+    public @NotNull ConfigElement elementFromData(ShutdownConfig shutdownConfig) {
+        ConfigNode configNode = ConfigNode.of();
+        configNode.putString("shutdownMessage", MiniMessage.miniMessage().serialize(shutdownConfig.shutdownMessage()));
+        configNode.putString("forceShutdownMessage",
+                MiniMessage.miniMessage().serialize(shutdownConfig.forceShutdownMessage()));
+        configNode.putNumber("warningInterval", shutdownConfig.warningInterval());
+        configNode.putNumber("forceShutdownTime", shutdownConfig.forceShutdownTime());
+        configNode.putNumber("forceShutdownWarningTime", shutdownConfig.forceShutdownWarningTime());
+
+        return configNode;
+    }
+}
diff --git a/server/src/main/java/org/phantazm/server/config/lobby/LobbyConfig.java b/server/src/main/java/org/phantazm/server/config/lobby/LobbyConfig.java
index 52eb87243..52fde72e8 100644
--- a/server/src/main/java/org/phantazm/server/config/lobby/LobbyConfig.java
+++ b/server/src/main/java/org/phantazm/server/config/lobby/LobbyConfig.java
@@ -1,5 +1,6 @@
 package org.phantazm.server.config.lobby;
 
+import com.github.steanky.ethylene.core.collection.ConfigList;
 import net.minestom.server.instance.Instance;
 import org.jetbrains.annotations.NotNull;
 import org.phantazm.core.config.InstanceConfig;
@@ -19,7 +20,8 @@
 public record LobbyConfig(@NotNull InstanceConfig instanceConfig,
                           @NotNull List<String> lobbyPaths,
                           int maxPlayers,
-                          int maxLobbies) {
+                          int maxLobbies,
+                          @NotNull ConfigList npcs) {
 
     /**
      * The default number of max players.
diff --git a/server/src/main/java/org/phantazm/server/config/server/ShutdownConfig.java b/server/src/main/java/org/phantazm/server/config/server/ShutdownConfig.java
new file mode 100644
index 000000000..866ac42fd
--- /dev/null
+++ b/server/src/main/java/org/phantazm/server/config/server/ShutdownConfig.java
@@ -0,0 +1,16 @@
+package org.phantazm.server.config.server;
+
+import net.kyori.adventure.text.Component;
+import org.jetbrains.annotations.NotNull;
+
+public record ShutdownConfig(@NotNull Component shutdownMessage,
+                             @NotNull Component forceShutdownMessage,
+                             long warningInterval,
+                             long forceShutdownTime,
+                             long forceShutdownWarningTime) {
+    /**
+     * The default ShutdownConfig instance.
+     */
+    public static final ShutdownConfig DEFAULT = new ShutdownConfig(Component.text("The server is shutting down soon!"),
+            Component.text("The server will forcefully shut down soon!"), 60000, 1800000L, 1500000L);
+}
diff --git a/server/src/main/java/org/phantazm/server/permission/FilePermissionHandler.java b/server/src/main/java/org/phantazm/server/permission/FilePermissionHandler.java
new file mode 100644
index 000000000..5252b3c73
--- /dev/null
+++ b/server/src/main/java/org/phantazm/server/permission/FilePermissionHandler.java
@@ -0,0 +1,173 @@
+package org.phantazm.server.permission;
+
+import com.github.steanky.ethylene.core.ConfigCodec;
+import com.github.steanky.ethylene.core.bridge.Configuration;
+import com.github.steanky.ethylene.core.processor.ConfigProcessor;
+import com.github.steanky.ethylene.mapper.MappingProcessorSource;
+import com.github.steanky.ethylene.mapper.type.Token;
+import net.minestom.server.MinecraftServer;
+import net.minestom.server.command.CommandSender;
+import net.minestom.server.entity.Player;
+import net.minestom.server.permission.Permission;
+import org.jetbrains.annotations.NotNull;
+import org.phantazm.commons.FileUtils;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.nio.file.Path;
+import java.util.*;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.CopyOnWriteArraySet;
+
+public class FilePermissionHandler implements PermissionHandler {
+    private static final Logger LOGGER = LoggerFactory.getLogger(FilePermissionHandler.class);
+
+    private final Path permissionsFile;
+    private final ConfigCodec configCodec;
+    private final ConfigProcessor<PermissionData> permissionDataConfigProcessor;
+
+    private PermissionData permissionData;
+
+    public FilePermissionHandler(@NotNull MappingProcessorSource mappingProcessorSource,
+            @NotNull ConfigCodec configCodec, @NotNull Path permissionsFile) {
+        this.permissionsFile = Objects.requireNonNull(permissionsFile, "permissionsFile");
+        this.configCodec = Objects.requireNonNull(configCodec, "configCodec");
+
+        this.permissionDataConfigProcessor = mappingProcessorSource.processorFor(Token.ofClass(PermissionData.class));
+        this.permissionData = load(permissionsFile, configCodec, permissionDataConfigProcessor);
+    }
+
+    private static PermissionData load(Path permissionsFile, ConfigCodec configCodec,
+            ConfigProcessor<PermissionData> permissionDataConfigProcessor) {
+        PermissionData permissionData;
+        try {
+            FileUtils.createFileIfNotExists(permissionsFile);
+            permissionData = Configuration.read(permissionsFile, configCodec, permissionDataConfigProcessor);
+        }
+        catch (Throwable e) {
+            LOGGER.warn("Exception reading permissions file", e);
+            permissionData = new PermissionData(new ConcurrentHashMap<>(), new ConcurrentHashMap<>());
+        }
+
+        return permissionData;
+    }
+
+    @Override
+    public void applyPermissions(@NotNull UUID uuid, @NotNull CommandSender sender) {
+        Set<String> groups = permissionData.groups().get(uuid);
+        if (groups != null) {
+            for (String group : groups) {
+                applyTo(sender, group);
+            }
+        }
+    }
+
+    @Override
+    public void flush() {
+        try {
+            FileUtils.createFileIfNotExists(permissionsFile);
+            Configuration.write(permissionsFile, configCodec, permissionDataConfigProcessor, permissionData);
+        }
+        catch (Throwable e) {
+            LOGGER.warn("Exception writing permissions file", e);
+        }
+    }
+
+    @Override
+    public void reload() {
+        this.permissionData = load(permissionsFile, configCodec, permissionDataConfigProcessor);
+        synchronizeAll();
+    }
+
+    @Override
+    public void addGroupPermission(@NotNull String group, @NotNull Permission permission) {
+        Objects.requireNonNull(group, "group");
+        Objects.requireNonNull(permission, "permission");
+
+        permissionData.groupPermissions().computeIfAbsent(group, ignored -> new CopyOnWriteArraySet<>())
+                .add(permission);
+
+        synchronizeAll();
+    }
+
+    @Override
+    public void removeGroupPermission(@NotNull String group, @NotNull Permission permission) {
+        Objects.requireNonNull(group, "group");
+        Objects.requireNonNull(permission, "permission");
+
+        Map<String, CopyOnWriteArraySet<Permission>> groupPermissions = permissionData.groupPermissions();
+        Set<Permission> permissions = groupPermissions.get(group);
+        if (permissions != null) {
+            permissions.remove(permission);
+
+            if (permissions.isEmpty()) {
+                groupPermissions.remove(group);
+            }
+
+            synchronizeAll();
+        }
+    }
+
+    @Override
+    public void addToGroup(@NotNull UUID uuid, @NotNull String group) {
+        Objects.requireNonNull(uuid, "uuid");
+        Objects.requireNonNull(group, "group");
+
+        permissionData.groups().computeIfAbsent(uuid, ignored -> new CopyOnWriteArraySet<>()).add(group);
+
+        Player player = MinecraftServer.getConnectionManager().getPlayer(uuid);
+        if (player != null) {
+            synchronize(player);
+        }
+    }
+
+    @Override
+    public void removeFromGroup(@NotNull UUID uuid, @NotNull String group) {
+        Objects.requireNonNull(uuid, "uuid");
+        Objects.requireNonNull(group, "group");
+
+        Map<UUID, CopyOnWriteArraySet<String>> playerGroups = permissionData.groups();
+        Set<String> groups = playerGroups.get(uuid);
+        if (groups != null) {
+            groups.remove(group);
+
+            if (groups.isEmpty()) {
+                playerGroups.remove(uuid);
+            }
+
+            Player player = MinecraftServer.getConnectionManager().getPlayer(uuid);
+            if (player != null) {
+                synchronize(player);
+            }
+        }
+    }
+
+    private void synchronizeAll() {
+        for (Player player : MinecraftServer.getConnectionManager().getOnlinePlayers()) {
+            synchronize(player);
+        }
+    }
+
+    private void synchronize(Player player) {
+        Set<String> permissionGroups = permissionData.groups().get(player.getUuid());
+        player.getAllPermissions().clear();
+
+        if (permissionGroups != null) {
+            for (String group : permissionGroups) {
+                applyTo(player, group);
+            }
+        }
+
+        player.sendPacket(MinecraftServer.getCommandManager().createDeclareCommandsPacket(player));
+    }
+
+    private void applyTo(CommandSender sender, String groupName) {
+        Set<Permission> permissions = permissionData.groupPermissions().get(groupName);
+
+        if (permissions != null) {
+            for (Permission permission : permissions) {
+                sender.addPermission(permission);
+            }
+        }
+    }
+}
diff --git a/server/src/main/java/org/phantazm/server/permission/PermissionData.java b/server/src/main/java/org/phantazm/server/permission/PermissionData.java
new file mode 100644
index 000000000..40a32bdda
--- /dev/null
+++ b/server/src/main/java/org/phantazm/server/permission/PermissionData.java
@@ -0,0 +1,12 @@
+package org.phantazm.server.permission;
+
+import net.minestom.server.permission.Permission;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.UUID;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.CopyOnWriteArraySet;
+
+public record PermissionData(@NotNull ConcurrentHashMap<String, CopyOnWriteArraySet<Permission>> groupPermissions,
+                             @NotNull ConcurrentHashMap<UUID, CopyOnWriteArraySet<String>> groups) {
+}
diff --git a/server/src/main/java/org/phantazm/server/permission/PermissionHandler.java b/server/src/main/java/org/phantazm/server/permission/PermissionHandler.java
new file mode 100644
index 000000000..42e325840
--- /dev/null
+++ b/server/src/main/java/org/phantazm/server/permission/PermissionHandler.java
@@ -0,0 +1,23 @@
+package org.phantazm.server.permission;
+
+import net.minestom.server.command.CommandSender;
+import net.minestom.server.permission.Permission;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.UUID;
+
+public interface PermissionHandler {
+    void applyPermissions(@NotNull UUID uuid, @NotNull CommandSender sender);
+
+    void flush();
+
+    void reload();
+
+    void addGroupPermission(@NotNull String group, @NotNull Permission permission);
+
+    void removeGroupPermission(@NotNull String group, @NotNull Permission permission);
+
+    void addToGroup(@NotNull UUID uuid, @NotNull String group);
+
+    void removeFromGroup(@NotNull UUID uuid, @NotNull String group);
+}
diff --git a/settings.gradle.kts b/settings.gradle.kts
index 98b90110d..3d7706d49 100644
--- a/settings.gradle.kts
+++ b/settings.gradle.kts
@@ -7,6 +7,7 @@ if (localSettings.exists()) {
     apply(localSettings)
 }
 
+includeBuild("./minestom")
 pluginManagement {
     repositories {
         //necessary for phantazm-zombies-mapeditor module which contains a Fabric mod
@@ -32,6 +33,7 @@ sequenceOf(
     "mob",
     "proxima-minestom",
     "server",
+    "stats",
     "velocity",
     "zombies",
     "zombies-mapdata",
diff --git a/stats/build.gradle.kts b/stats/build.gradle.kts
new file mode 100644
index 000000000..3eb56f4a5
--- /dev/null
+++ b/stats/build.gradle.kts
@@ -0,0 +1,9 @@
+plugins {
+    id("phantazm.java-library-conventions")
+}
+
+dependencies {
+    api(libs.adventure.key)
+    api(libs.jooq)
+    api(libs.hikariCP)
+}
diff --git a/stats/src/main/java/org/phantazm/stats/zombies/BasicZombiesPlayerMapStats.java b/stats/src/main/java/org/phantazm/stats/zombies/BasicZombiesPlayerMapStats.java
new file mode 100644
index 000000000..c3e433059
--- /dev/null
+++ b/stats/src/main/java/org/phantazm/stats/zombies/BasicZombiesPlayerMapStats.java
@@ -0,0 +1,206 @@
+package org.phantazm.stats.zombies;
+
+import net.kyori.adventure.key.Key;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.Objects;
+import java.util.Optional;
+import java.util.UUID;
+
+public class BasicZombiesPlayerMapStats implements ZombiesPlayerMapStats {
+
+    private final UUID playerUUID;
+
+    private final Key mapKey;
+
+    private int gamesPlayed;
+
+    private int wins;
+
+    private Long bestTime;
+
+    private int roundsSurvived;
+
+    private int kills;
+
+    private int coinsGained;
+
+    private int coinsSpent;
+
+    private int knocks;
+
+    private int deaths;
+
+    private int revives;
+
+    private int shots;
+
+    private int regularHits;
+
+    private int headshotHits;
+
+    public BasicZombiesPlayerMapStats(@NotNull UUID playerUUID, @NotNull Key mapKey, int gamesPlayed, int wins,
+            @Nullable Long bestTime, int roundsSurvived, int kills, int knocks, int coinsGained, int coinsSpent,
+            int deaths, int revives, int shots, int regularHits, int headshotHits) {
+        this.playerUUID = Objects.requireNonNull(playerUUID, "playerUUID");
+        this.mapKey = Objects.requireNonNull(mapKey, "mapKey");
+        this.gamesPlayed = gamesPlayed;
+        this.wins = wins;
+        this.bestTime = bestTime;
+        this.roundsSurvived = roundsSurvived;
+        this.kills = kills;
+        this.coinsGained = coinsGained;
+        this.coinsSpent = coinsSpent;
+        this.knocks = knocks;
+        this.deaths = deaths;
+        this.revives = revives;
+        this.shots = shots;
+        this.regularHits = regularHits;
+        this.headshotHits = headshotHits;
+    }
+
+    public static ZombiesPlayerMapStats createBasicStats(@NotNull UUID playerUUID, @NotNull Key mapKey) {
+        return new BasicZombiesPlayerMapStats(playerUUID, mapKey, 0, 0, null, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
+    }
+
+    @Override
+    public @NotNull UUID getPlayerUUID() {
+        return playerUUID;
+    }
+
+    @Override
+    public @NotNull Key getMapKey() {
+        return mapKey;
+    }
+
+    @Override
+    public int getGamesPlayed() {
+        return gamesPlayed;
+    }
+
+    @Override
+    public void setGamesPlayed(int gamesPlayed) {
+        this.gamesPlayed = gamesPlayed;
+    }
+
+    @Override
+    public int getWins() {
+        return wins;
+    }
+
+    @Override
+    public void setWins(int wins) {
+        this.wins = wins;
+    }
+
+    @Override
+    public @NotNull Optional<Long> getBestTime() {
+        return Optional.ofNullable(bestTime);
+    }
+
+    @Override
+    public void setBestTime(@Nullable Long bestTime) {
+        this.bestTime = bestTime;
+    }
+
+    @Override
+    public int getRoundsSurvived() {
+        return roundsSurvived;
+    }
+
+    @Override
+    public void setRoundsSurvived(int roundsSurvived) {
+        this.roundsSurvived = roundsSurvived;
+    }
+
+    @Override
+    public int getKills() {
+        return kills;
+    }
+
+    @Override
+    public void setKills(int kills) {
+        this.kills = kills;
+    }
+
+    @Override
+    public int getCoinsGained() {
+        return coinsGained;
+    }
+
+    @Override
+    public void setCoinsGained(int coinsGained) {
+        this.coinsGained = coinsGained;
+    }
+
+    @Override
+    public int getCoinsSpent() {
+        return coinsSpent;
+    }
+
+    @Override
+    public void setCoinsSpent(int coinsSpent) {
+        this.coinsSpent = coinsSpent;
+    }
+
+    @Override
+    public int getKnocks() {
+        return knocks;
+    }
+
+    @Override
+    public void setKnocks(int knocks) {
+        this.knocks = knocks;
+    }
+
+    @Override
+    public int getDeaths() {
+        return deaths;
+    }
+
+    @Override
+    public void setDeaths(int deaths) {
+        this.deaths = deaths;
+    }
+
+    @Override
+    public int getRevives() {
+        return revives;
+    }
+
+    @Override
+    public void setRevives(int revives) {
+        this.revives = revives;
+    }
+
+    @Override
+    public int getShots() {
+        return shots;
+    }
+
+    @Override
+    public void setShots(int shots) {
+        this.shots = shots;
+    }
+
+    @Override
+    public int getRegularHits() {
+        return regularHits;
+    }
+
+    @Override
+    public void setRegularHits(int regularShots) {
+        this.regularHits = regularShots;
+    }
+
+    @Override
+    public int getHeadshotHits() {
+        return headshotHits;
+    }
+
+    @Override
+    public void setHeadshotHits(int headshots) {
+        this.headshotHits = headshots;
+    }
+}
diff --git a/stats/src/main/java/org/phantazm/stats/zombies/BestTime.java b/stats/src/main/java/org/phantazm/stats/zombies/BestTime.java
new file mode 100644
index 000000000..f1adc0d32
--- /dev/null
+++ b/stats/src/main/java/org/phantazm/stats/zombies/BestTime.java
@@ -0,0 +1,8 @@
+package org.phantazm.stats.zombies;
+
+import org.jetbrains.annotations.NotNull;
+
+import java.util.UUID;
+
+public record BestTime(@NotNull UUID uuid, long time) {
+}
diff --git a/stats/src/main/java/org/phantazm/stats/zombies/JooqZombiesSQLFetcher.java b/stats/src/main/java/org/phantazm/stats/zombies/JooqZombiesSQLFetcher.java
new file mode 100644
index 000000000..30b3cb70b
--- /dev/null
+++ b/stats/src/main/java/org/phantazm/stats/zombies/JooqZombiesSQLFetcher.java
@@ -0,0 +1,65 @@
+package org.phantazm.stats.zombies;
+
+import net.kyori.adventure.key.Key;
+import org.jetbrains.annotations.NotNull;
+import org.jooq.impl.SQLDataType;
+
+import java.sql.Connection;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.UUID;
+
+import static org.jooq.impl.DSL.*;
+
+public class JooqZombiesSQLFetcher implements ZombiesSQLFetcher {
+
+    @Override
+    public void synchronizeZombiesPlayerMapStats(@NotNull Connection connection,
+            @NotNull ZombiesPlayerMapStats mapStats) {
+        using(connection).insertInto(table("zombies_player_map_stats"), field("player_uuid"), field("map_key"),
+                        field("games_played"), field("wins"), field("best_time"), field("rounds_survived"), field("kills"),
+                        field("coins_gained"), field("coins_spent"), field("knocks"), field("deaths"), field("revives"),
+                        field("shots"), field("regular_hits"), field("headshot_hits"))
+                .values(mapStats.getPlayerUUID().toString(), mapStats.getMapKey().asString(), mapStats.getGamesPlayed(),
+                        mapStats.getWins(), mapStats.getBestTime().orElse(null), mapStats.getRoundsSurvived(),
+                        mapStats.getKills(), mapStats.getCoinsGained(), mapStats.getCoinsSpent(), mapStats.getKnocks(),
+                        mapStats.getDeaths(), mapStats.getRevives(), mapStats.getShots(), mapStats.getRegularHits(),
+                        mapStats.getHeadshotHits()).onDuplicateKeyUpdate()
+                .set(field("games_played"), field("games_played", SQLDataType.INTEGER).plus(mapStats.getGamesPlayed()))
+                .set(field("wins"), field("wins", SQLDataType.INTEGER).plus(mapStats.getWins())).set(field("best_time"),
+                        mapStats.getBestTime().isPresent() ? when(field("best_time").isNotNull(),
+                                least(field("best_time"), mapStats.getBestTime().get())).otherwise(
+                                inline(null, SQLDataType.INTEGER)) : field("best_time", SQLDataType.BIGINT))
+                .set(field("rounds_survived"),
+                        field("rounds_survived", SQLDataType.INTEGER).plus(mapStats.getRoundsSurvived()))
+                .set(field("kills"), field("kills", SQLDataType.INTEGER).plus(mapStats.getRoundsSurvived()))
+                .set(field("coins_gained"), field("coins_gained", SQLDataType.INTEGER).plus(mapStats.getCoinsGained()))
+                .set(field("coins_spent"), field("coins_spent", SQLDataType.INTEGER).plus(mapStats.getCoinsSpent()))
+                .set(field("knocks"), field("knocks", SQLDataType.INTEGER).plus(mapStats.getKnocks()))
+                .set(field("deaths"), field("deaths", SQLDataType.INTEGER).plus(mapStats.getDeaths()))
+                .set(field("revives"), field("revives", SQLDataType.INTEGER).plus(mapStats.getRevives()))
+                .set(field("shots"), field("shots", SQLDataType.INTEGER).plus(mapStats.getShots()))
+                .set(field("regular_hits"), field("regular_hits", SQLDataType.INTEGER).plus(mapStats.getRegularHits()))
+                .set(field("headshot_hits"),
+                        field("headshot_hits", SQLDataType.INTEGER).plus(mapStats.getHeadshotHits())).execute();
+    }
+
+    @Override
+    public @NotNull List<BestTime> getBestTimes(@NotNull Connection connection, @NotNull Key mapKey)
+            throws SQLException {
+        List<BestTime> bestTimes = new ArrayList<>();
+        try (ResultSet resultSet = using(connection).select(field("player_uuid"), field("best_time"))
+                .from(table("zombies_player_map_stats")).where(field("map_key").eq(mapKey.asString()))
+                .and(field("best_time").isNotNull()).orderBy(field("best_time")).fetchResultSet()) {
+            while (resultSet.next()) {
+                UUID uuid = UUID.fromString(resultSet.getString("player_uuid"));
+                long bestTime = resultSet.getLong("best_time");
+                bestTimes.add(new BestTime(uuid, bestTime));
+            }
+        }
+
+        return bestTimes;
+    }
+}
diff --git a/stats/src/main/java/org/phantazm/stats/zombies/SQLZombiesDatabase.java b/stats/src/main/java/org/phantazm/stats/zombies/SQLZombiesDatabase.java
new file mode 100644
index 000000000..d00444d42
--- /dev/null
+++ b/stats/src/main/java/org/phantazm/stats/zombies/SQLZombiesDatabase.java
@@ -0,0 +1,63 @@
+package org.phantazm.stats.zombies;
+
+import net.kyori.adventure.key.Key;
+import org.jetbrains.annotations.NotNull;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import javax.sql.DataSource;
+import java.sql.Connection;
+import java.sql.SQLException;
+import java.util.List;
+import java.util.Objects;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.Executor;
+
+public class SQLZombiesDatabase implements ZombiesDatabase {
+
+    private static final Logger LOGGER = LoggerFactory.getLogger(SQLZombiesDatabase.class);
+
+    private final Executor executor;
+
+    private final DataSource dataSource;
+
+    private final ZombiesSQLFetcher sqlFetcher;
+
+    public SQLZombiesDatabase(@NotNull Executor executor, @NotNull DataSource dataSource,
+            @NotNull ZombiesSQLFetcher sqlFetcher) {
+        this.executor = Objects.requireNonNull(executor, "executor");
+        this.dataSource = Objects.requireNonNull(dataSource, "dataSource");
+        this.sqlFetcher = Objects.requireNonNull(sqlFetcher, "sqlFetcher");
+    }
+
+    @Override
+    public @NotNull CompletableFuture<Void> synchronizeZombiesPlayerMapStats(@NotNull ZombiesPlayerMapStats stats) {
+        return CompletableFuture.runAsync(() -> {
+            try (Connection connection = dataSource.getConnection()) {
+                sqlFetcher.synchronizeZombiesPlayerMapStats(connection, stats);
+            }
+            catch (SQLException e) {
+                throw new RuntimeException(e);
+            }
+        }, executor).whenComplete(this::logException);
+    }
+
+    @Override
+    public CompletableFuture<List<BestTime>> getBestTimes(@NotNull Key mapKey) {
+        return CompletableFuture.supplyAsync(() -> {
+            try (Connection connection = dataSource.getConnection()) {
+                return sqlFetcher.getBestTimes(connection, mapKey);
+            }
+            catch (SQLException e) {
+                throw new RuntimeException(e);
+            }
+        }, executor).whenComplete(this::logException);
+    }
+
+    private <T> void logException(T ignored, Throwable throwable) {
+        if (throwable != null) {
+            LOGGER.warn("Exception while querying database", throwable);
+        }
+    }
+
+}
diff --git a/stats/src/main/java/org/phantazm/stats/zombies/ZombiesDatabase.java b/stats/src/main/java/org/phantazm/stats/zombies/ZombiesDatabase.java
new file mode 100644
index 000000000..a07821b51
--- /dev/null
+++ b/stats/src/main/java/org/phantazm/stats/zombies/ZombiesDatabase.java
@@ -0,0 +1,14 @@
+package org.phantazm.stats.zombies;
+
+import net.kyori.adventure.key.Key;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.List;
+import java.util.concurrent.CompletableFuture;
+
+public interface ZombiesDatabase {
+
+    @NotNull CompletableFuture<Void> synchronizeZombiesPlayerMapStats(@NotNull ZombiesPlayerMapStats stats);
+
+    CompletableFuture<List<BestTime>> getBestTimes(@NotNull Key mapKey);
+}
diff --git a/stats/src/main/java/org/phantazm/stats/zombies/ZombiesPlayerMapStats.java b/stats/src/main/java/org/phantazm/stats/zombies/ZombiesPlayerMapStats.java
new file mode 100644
index 000000000..21060b812
--- /dev/null
+++ b/stats/src/main/java/org/phantazm/stats/zombies/ZombiesPlayerMapStats.java
@@ -0,0 +1,68 @@
+package org.phantazm.stats.zombies;
+
+import net.kyori.adventure.key.Key;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.Optional;
+import java.util.UUID;
+
+public interface ZombiesPlayerMapStats {
+
+    @NotNull UUID getPlayerUUID();
+
+    @NotNull Key getMapKey();
+
+    int getGamesPlayed();
+
+    void setGamesPlayed(int gamesPlayed);
+
+    int getWins();
+
+    void setWins(int wins);
+
+    @NotNull Optional<Long> getBestTime();
+
+    void setBestTime(@Nullable Long bestTime);
+
+    int getRoundsSurvived();
+
+    void setRoundsSurvived(int roundsSurvived);
+
+    int getKills();
+
+    void setKills(int kills);
+
+    int getCoinsGained();
+
+    void setCoinsGained(int goldGained);
+
+    int getCoinsSpent();
+
+    void setCoinsSpent(int goldSpent);
+
+    int getKnocks();
+
+    void setKnocks(int knocks);
+
+    int getDeaths();
+
+    void setDeaths(int deaths);
+
+    int getRevives();
+
+    void setRevives(int revives);
+
+    int getShots();
+
+    void setShots(int shots);
+
+    int getRegularHits();
+
+    void setRegularHits(int regularShots);
+
+    int getHeadshotHits();
+
+    void setHeadshotHits(int headshots);
+
+}
diff --git a/stats/src/main/java/org/phantazm/stats/zombies/ZombiesSQLFetcher.java b/stats/src/main/java/org/phantazm/stats/zombies/ZombiesSQLFetcher.java
new file mode 100644
index 000000000..4dea92b8e
--- /dev/null
+++ b/stats/src/main/java/org/phantazm/stats/zombies/ZombiesSQLFetcher.java
@@ -0,0 +1,16 @@
+package org.phantazm.stats.zombies;
+
+import net.kyori.adventure.key.Key;
+import org.jetbrains.annotations.NotNull;
+
+import java.sql.Connection;
+import java.sql.SQLException;
+import java.util.List;
+
+public interface ZombiesSQLFetcher {
+
+    void synchronizeZombiesPlayerMapStats(@NotNull Connection connection, @NotNull ZombiesPlayerMapStats mapStats);
+
+    @NotNull List<BestTime> getBestTimes(@NotNull Connection connection, @NotNull Key mapKey) throws SQLException;
+
+}
diff --git a/zombies-mapdata/src/main/java/org/phantazm/zombies/map/FileSystemMapLoader.java b/zombies-mapdata/src/main/java/org/phantazm/zombies/map/FileSystemMapLoader.java
index d833aac9d..0b411a79f 100644
--- a/zombies-mapdata/src/main/java/org/phantazm/zombies/map/FileSystemMapLoader.java
+++ b/zombies-mapdata/src/main/java/org/phantazm/zombies/map/FileSystemMapLoader.java
@@ -108,10 +108,16 @@ public FileSystemMapLoader(@NotNull Path root, @NotNull ConfigCodec codec) {
 
         String sidebarSettingsPath =
                 "settings" + (codec.getPreferredExtensions().isEmpty() ? "" : "." + codec.getPreferredExtension());
+        String corpsePath =
+                "corpse" + (codec.getPreferredExtensions().isEmpty() ? "" : "." + codec.getPreferredExtension());
+
         ConfigNode scoreboard =
                 Configuration.read(paths.sidebar.resolve(sidebarSettingsPath), codec, MapProcessors.sidebar());
 
-        return new MapInfo(mapSettingsInfo, rooms, doors, shops, windows, rounds, spawnrules, spawnpoints, scoreboard);
+        ConfigNode corpse = Configuration.read(mapDirectory.resolve(corpsePath), codec).asNode();
+
+        return new MapInfo(mapSettingsInfo, rooms, doors, shops, windows, rounds, spawnrules, spawnpoints, scoreboard,
+                corpse);
     }
 
     @Override
@@ -189,6 +195,7 @@ public void save(@NotNull MapInfo data) throws IOException {
         }
 
         Configuration.write(paths.sidebar.resolve("settings" + extension), data.scoreboard(), codec);
+        Configuration.write(mapDirectory.resolve("corpse" + extension), data.corpse(), codec);
     }
 
     @Override
diff --git a/zombies-mapdata/src/main/java/org/phantazm/zombies/map/MapInfo.java b/zombies-mapdata/src/main/java/org/phantazm/zombies/map/MapInfo.java
index 75151b7ea..3ae5bb5a1 100644
--- a/zombies-mapdata/src/main/java/org/phantazm/zombies/map/MapInfo.java
+++ b/zombies-mapdata/src/main/java/org/phantazm/zombies/map/MapInfo.java
@@ -19,7 +19,8 @@ public record MapInfo(@NotNull MapSettingsInfo settings,
                       @NotNull List<RoundInfo> rounds,
                       @NotNull List<SpawnruleInfo> spawnrules,
                       @NotNull List<SpawnpointInfo> spawnpoints,
-                      @NotNull ConfigNode scoreboard) implements Keyed {
+                      @NotNull ConfigNode scoreboard,
+                      @NotNull ConfigNode corpse) implements Keyed {
     /**
      * Constructs a new instances of this record.
      *
@@ -36,7 +37,7 @@ public record MapInfo(@NotNull MapSettingsInfo settings,
     public MapInfo(@NotNull MapSettingsInfo settings, @NotNull List<RoomInfo> rooms, @NotNull List<DoorInfo> doors,
             @NotNull List<ShopInfo> shops, @NotNull List<WindowInfo> windows, @NotNull List<RoundInfo> rounds,
             @NotNull List<SpawnruleInfo> spawnrules, @NotNull List<SpawnpointInfo> spawnpoints,
-            @NotNull ConfigNode scoreboard) {
+            @NotNull ConfigNode scoreboard, @NotNull ConfigNode corpse) {
         this.settings = Objects.requireNonNull(settings, "settings");
         this.rooms = Objects.requireNonNull(rooms, "rooms");
         this.doors = Objects.requireNonNull(doors, "doors");
@@ -46,6 +47,7 @@ public MapInfo(@NotNull MapSettingsInfo settings, @NotNull List<RoomInfo> rooms,
         this.spawnrules = Objects.requireNonNull(spawnrules, "spawnrules");
         this.spawnpoints = Objects.requireNonNull(spawnpoints, "spawnpoints");
         this.scoreboard = Objects.requireNonNull(scoreboard, "scoreboard");
+        this.corpse = Objects.requireNonNull(corpse, "corpse");
     }
 
     @Override
diff --git a/zombies-mapdata/src/main/java/org/phantazm/zombies/map/MapProcessors.java b/zombies-mapdata/src/main/java/org/phantazm/zombies/map/MapProcessors.java
index 9a528632c..487c08985 100644
--- a/zombies-mapdata/src/main/java/org/phantazm/zombies/map/MapProcessors.java
+++ b/zombies-mapdata/src/main/java/org/phantazm/zombies/map/MapProcessors.java
@@ -260,6 +260,7 @@ public MapSettingsInfo dataFromElement(@NotNull ConfigElement element) throws Co
             }
 
             Key id = ConfigProcessors.key().dataFromElement(element.getElementOrThrow("id"));
+            int chunkLoadRange = element.getNumberOrDefault(10, "chunkLoadRange").intValue();
             List<String> instancePath =
                     ConfigProcessor.STRING.listProcessor().dataFromElement(element.getListOrThrow("instancePath"));
             Vec3I origin = VectorConfigProcessors.vec3I().dataFromElement(element.getElementOrThrow("origin"));
@@ -294,24 +295,50 @@ public MapSettingsInfo dataFromElement(@NotNull ConfigElement element) throws Co
             int rollsPerChest = element.getNumberOrThrow("rollsPerChest").intValue();
             float punchDamage = element.getNumberOrThrow("punchDamage").floatValue();
             float punchRange = element.getNumberOrThrow("punchRange").floatValue();
+            boolean mobPlayerCollisions = element.getBooleanOrThrow("mobPlayerCollisions");
 
             List<Integer> milestoneRounds = integerList.dataFromElement(element.getElementOrThrow("milestoneRounds"));
             Map<Key, List<Key>> defaultEquipment =
                     keyToListKeyMap.dataFromElement(element.getElementOrThrow("defaultEquipment"));
             Map<Key, EquipmentGroupInfo> equipmentGroups =
                     keyToEquipmentGroup.dataFromElement(element.getElementOrThrow("equipmentGroups"));
-            return new MapSettingsInfo(mapDataVersion, id, instancePath, origin, minimumProtocolVersion,
+            Sound countdownTickSound =
+                    ConfigProcessors.sound().dataFromElement(element.getElementOrThrow("countdownTickSound"));
+            String countdownTimeFormat = element.getStringOrThrow("countdownTimeFormat");
+            String winTitleFormat = element.getStringOrThrow("winTitleFormat");
+            String winSubtitleFormat = element.getStringOrThrow("winSubtitleFormat");
+            String lossTitleFormat = element.getStringOrThrow("lossTitleFormat");
+            String lossSubtitleFormat = element.getStringOrThrow("lossSubtitleFormat");
+            String reviveStatusToReviverFormat = element.getStringOrThrow("reviveStatusToReviverFormat");
+            String reviveStatusToKnockedFormat = element.getStringOrThrow("reviveStatusToKnockedFormat");
+            String dyingStatusFormat = element.getStringOrThrow("dyingStatusFormat");
+            String knockedMessageToKnockedFormat = element.getStringOrThrow("knockedMessageToKnockedFormat");
+            String knockedMessageToOthersFormat = element.getStringOrThrow("knockedMessageToOthersFormat");
+            String knockedTitleFormat = element.getStringOrThrow("knockedTitleFormat");
+            String knockedSubtitleFormat = element.getStringOrThrow("knockedSubtitleFormat");
+            String deathMessageToKilledFormat = element.getStringOrThrow("deathMessageToKilledFormat");
+            String deathMessageToOthersFormat = element.getStringOrThrow("deathMessageToOthersFormat");
+            String rejoinMessageFormat = element.getStringOrThrow("rejoinMessageFormat");
+            String quitMessageFormat = element.getStringOrThrow("quitMessageFormat");
+            String endGameStatsFormat = element.getStringOrThrow("endGameStatsFormat");
+            return new MapSettingsInfo(mapDataVersion, chunkLoadRange, id, instancePath, origin, minimumProtocolVersion,
                     maximumProtocolVersion, spawn, pitch, yaw, displayName, displayItemTag, introMessages,
                     scoreboardHeader, leaderboardPosition, leaderboardLength, worldTime, maxPlayers, minPlayers,
                     startingCoins, repairCoins, windowRepairRadius, powerupPickupRadius, windowRepairTicks,
                     corpseDeathTicks, healTicks, reviveRadius, canWallshoot, perksLostOnDeath, baseReviveTicks,
-                    rollsPerChest, punchDamage, punchRange, milestoneRounds, defaultEquipment, equipmentGroups);
+                    rollsPerChest, punchDamage, punchRange, mobPlayerCollisions, milestoneRounds, defaultEquipment,
+                    equipmentGroups, countdownTickSound, countdownTimeFormat, winTitleFormat, winSubtitleFormat,
+                    lossTitleFormat, lossSubtitleFormat, reviveStatusToReviverFormat, reviveStatusToKnockedFormat,
+                    dyingStatusFormat, knockedMessageToKnockedFormat, knockedMessageToOthersFormat, knockedTitleFormat,
+                    knockedSubtitleFormat, deathMessageToKilledFormat, deathMessageToOthersFormat, rejoinMessageFormat,
+                    quitMessageFormat, endGameStatsFormat);
         }
 
         @Override
         public @NotNull ConfigElement elementFromData(MapSettingsInfo mapConfig) throws ConfigProcessException {
             ConfigNode node = new LinkedConfigNode(29);
             node.putNumber("mapDataVersion", mapConfig.mapDataVersion());
+            node.putNumber("chunkLoadRange", mapConfig.chunkLoadRange());
             node.put("id", ConfigProcessors.key().elementFromData(mapConfig.id()));
             node.put("instancePath", ConfigProcessor.STRING.listProcessor().elementFromData(mapConfig.instancePath()));
             node.put("origin", VectorConfigProcessors.vec3I().elementFromData(mapConfig.origin()));
@@ -344,9 +371,28 @@ public MapSettingsInfo dataFromElement(@NotNull ConfigElement element) throws Co
             node.putNumber("rollsPerChest", mapConfig.rollsPerChest());
             node.putNumber("punchDamage", mapConfig.punchDamage());
             node.putNumber("punchRange", mapConfig.punchRange());
+            node.putBoolean("mobPlayerCollisions", mapConfig.mobPlayerCollisions());
             node.put("milestoneRounds", integerList.elementFromData(mapConfig.milestoneRounds()));
             node.put("defaultEquipment", keyToListKeyMap.elementFromData(mapConfig.defaultEquipment()));
             node.put("equipmentGroups", keyToEquipmentGroup.elementFromData(mapConfig.equipmentGroups()));
+            node.put("countdownTickSound", ConfigProcessors.sound().elementFromData(mapConfig.countdownTickSound()));
+            node.putString("countdownTimeFormat", mapConfig.countdownTimeFormat());
+            node.putString("winTitleFormat", mapConfig.winTitleFormat());
+            node.putString("winSubtitleFormat", mapConfig.winSubtitleFormat());
+            node.putString("lossTitleFormat", mapConfig.lossTitleFormat());
+            node.putString("lossSubtitleFormat", mapConfig.lossSubtitleFormat());
+            node.putString("reviveStatusToReviverFormat", mapConfig.reviveStatusToReviverFormat());
+            node.putString("reviveStatusToKnockedFormat", mapConfig.reviveStatusToKnockedFormat());
+            node.putString("dyingStatusFormat", mapConfig.dyingStatusFormat());
+            node.putString("knockedMessageToKnockedFormat", mapConfig.knockedMessageToKnockedFormat());
+            node.putString("knockedMessageToOthersFormat", mapConfig.knockedMessageToOthersFormat());
+            node.putString("knockedTitleFormat", mapConfig.knockedTitleFormat());
+            node.putString("knockedSubtitleFormat", mapConfig.knockedTitleFormat());
+            node.putString("deathMessageToKilledFormat", mapConfig.deathMessageToKilledFormat());
+            node.putString("deathMessageToOthersFormat", mapConfig.deathMessageToOthersFormat());
+            node.putString("rejoinMessageFormat", mapConfig.rejoinMessageFormat());
+            node.putString("quitMessageFormat", mapConfig.quitMessageFormat());
+            node.putString("endGameStatsFormat", mapConfig.endGameStatsFormat());
             return node;
         }
     };
diff --git a/zombies-mapdata/src/main/java/org/phantazm/zombies/map/MapSettingsInfo.java b/zombies-mapdata/src/main/java/org/phantazm/zombies/map/MapSettingsInfo.java
index 264782e32..90347ef8f 100644
--- a/zombies-mapdata/src/main/java/org/phantazm/zombies/map/MapSettingsInfo.java
+++ b/zombies-mapdata/src/main/java/org/phantazm/zombies/map/MapSettingsInfo.java
@@ -2,6 +2,7 @@
 
 import com.github.steanky.vector.Vec3I;
 import net.kyori.adventure.key.Key;
+import net.kyori.adventure.sound.Sound;
 import net.kyori.adventure.text.Component;
 import org.jetbrains.annotations.NotNull;
 
@@ -11,6 +12,7 @@
  * Defines the general settings for a map.
  */
 public record MapSettingsInfo(int mapDataVersion,
+                              int chunkLoadRange,
                               @NotNull Key id,
                               @NotNull List<String> instancePath,
                               @NotNull Vec3I origin,
@@ -42,9 +44,28 @@ public record MapSettingsInfo(int mapDataVersion,
                               int rollsPerChest,
                               float punchDamage,
                               float punchRange,
+                              boolean mobPlayerCollisions,
                               @NotNull List<Integer> milestoneRounds,
                               @NotNull Map<Key, List<Key>> defaultEquipment,
-                              @NotNull Map<Key, EquipmentGroupInfo> equipmentGroups) {
+                              @NotNull Map<Key, EquipmentGroupInfo> equipmentGroups,
+                              @NotNull Sound countdownTickSound,
+                              @NotNull String countdownTimeFormat,
+                              @NotNull String winTitleFormat,
+                              @NotNull String winSubtitleFormat,
+                              @NotNull String lossTitleFormat,
+                              @NotNull String lossSubtitleFormat,
+                              @NotNull String reviveStatusToReviverFormat,
+                              @NotNull String reviveStatusToKnockedFormat,
+                              @NotNull String dyingStatusFormat,
+                              @NotNull String knockedMessageToKnockedFormat,
+                              @NotNull String knockedMessageToOthersFormat,
+                              @NotNull String knockedTitleFormat,
+                              @NotNull String knockedSubtitleFormat,
+                              @NotNull String deathMessageToKilledFormat,
+                              @NotNull String deathMessageToOthersFormat,
+                              @NotNull String rejoinMessageFormat,
+                              @NotNull String quitMessageFormat,
+                              @NotNull String endGameStatsFormat) {
 
     public static final int MAP_DATA_VERSION = 1;
 
@@ -103,9 +124,11 @@ public record MapSettingsInfo(int mapDataVersion,
      *               otherwise specified
      */
     public MapSettingsInfo(@NotNull Key id, @NotNull Vec3I origin) {
-        this(MAP_DATA_VERSION, id, List.of(), origin, 47, -1, Vec3I.ORIGIN, 0, 0, Component.text(id.value()),
+        this(MAP_DATA_VERSION, 10, id, List.of(), origin, 47, -1, Vec3I.ORIGIN, 0, 0, Component.text(id.value()),
                 "{id:\"stone\",Count:1,tag:{Name:\"" + id.value() + "\"}}", new ArrayList<>(0),
                 Component.text(id.value()), Vec3I.ORIGIN, 15, 0, 4, 1, 0, 20, 3, 1, 20, 500, 20, 2, false, false, 30, 5,
-                0, 4.5F, new ArrayList<>(0), new HashMap<>(0), new HashMap<>());
+                0, 4.5F, false, new ArrayList<>(0), new HashMap<>(0), new HashMap<>(),
+                Sound.sound(Key.key("minecraft:entity.wolf.howl"), Sound.Source.MASTER, 1.0F, 1.0F), "", "", "", "",
+                "", "", "", "", "", "", "", "", "", "", "", "", "");
     }
 }
diff --git a/zombies-mapeditor/build.gradle.kts b/zombies-mapeditor/build.gradle.kts
index a2eb03b2d..37a2c6f9b 100644
--- a/zombies-mapeditor/build.gradle.kts
+++ b/zombies-mapeditor/build.gradle.kts
@@ -58,6 +58,7 @@ dependencies {
     include(projects.phantazmCommons)
     include(projects.phantazmMessaging)
     include(projects.phantazmZombiesMapdata)
+    include(libs.vector.core)
     include(libs.adventure.api)
     include(libs.adventure.key)
     include(libs.adventure.text.minimessage)
diff --git a/zombies-mapeditor/src/main/java/org/phantazm/zombies/mapeditor/client/ui/MainGui.java b/zombies-mapeditor/src/main/java/org/phantazm/zombies/mapeditor/client/ui/MainGui.java
index f5c102238..29dfe498d 100644
--- a/zombies-mapeditor/src/main/java/org/phantazm/zombies/mapeditor/client/ui/MainGui.java
+++ b/zombies-mapeditor/src/main/java/org/phantazm/zombies/mapeditor/client/ui/MainGui.java
@@ -106,7 +106,7 @@ public MainGui(@NotNull EditorSession session) {
 
             session.addMap(new MapInfo(new MapSettingsInfo(mapKey, session.getFirstSelection()), new ArrayList<>(),
                     new ArrayList<>(), new ArrayList<>(), new ArrayList<>(), new ArrayList<>(), new ArrayList<>(),
-                    new ArrayList<>(), new LinkedConfigNode(0)));
+                    new ArrayList<>(), new LinkedConfigNode(0), new LinkedConfigNode()));
             session.setCurrent(mapKey);
 
             refreshMainGui(session);
diff --git a/zombies/build.gradle.kts b/zombies/build.gradle.kts
index 599163540..6973d4926 100644
--- a/zombies/build.gradle.kts
+++ b/zombies/build.gradle.kts
@@ -4,9 +4,10 @@ plugins {
 }
 
 dependencies {
-    implementation(projects.phantazmCore)
-    implementation(projects.phantazmMob)
-    implementation(projects.phantazmZombiesMapdata)
+    api(projects.phantazmCore)
+    api(projects.phantazmMob)
+    api(projects.phantazmStats)
+    api(projects.phantazmZombiesMapdata)
 }
 
 elementAutodoc {
diff --git a/zombies/src/main/java/org/phantazm/zombies/ExtraNodeKeys.java b/zombies/src/main/java/org/phantazm/zombies/ExtraNodeKeys.java
index b3cfaaec2..ba8b2495a 100644
--- a/zombies/src/main/java/org/phantazm/zombies/ExtraNodeKeys.java
+++ b/zombies/src/main/java/org/phantazm/zombies/ExtraNodeKeys.java
@@ -4,5 +4,5 @@ public final class ExtraNodeKeys {
     private ExtraNodeKeys() {
     }
 
-    public static final String RESIST_INSTAKILL = "resistInstaKill";
+    public static final String RESIST_INSTAKILL = "resistInstakill";
 }
diff --git a/zombies/src/main/java/org/phantazm/zombies/Tags.java b/zombies/src/main/java/org/phantazm/zombies/Tags.java
index 984ac1c9b..37b5b3b9b 100644
--- a/zombies/src/main/java/org/phantazm/zombies/Tags.java
+++ b/zombies/src/main/java/org/phantazm/zombies/Tags.java
@@ -13,4 +13,6 @@ private Tags() {
     public static final Tag<UUID> LAST_HIT_BY = Tag.UUID("last_hit");
 
     public static final Tag<Integer> ARMOR_TIER = Tag.Integer("armor_tier").defaultValue(-1);
+
+    public static final Tag<Long> LAST_SHOP_ACTIVATE = Tag.Long("last_shop_activate").defaultValue(-1L);
 }
diff --git a/zombies/src/main/java/org/phantazm/zombies/coin/BasicPlayerCoins.java b/zombies/src/main/java/org/phantazm/zombies/coin/BasicPlayerCoins.java
index 9cf90ddf2..fde324256 100644
--- a/zombies/src/main/java/org/phantazm/zombies/coin/BasicPlayerCoins.java
+++ b/zombies/src/main/java/org/phantazm/zombies/coin/BasicPlayerCoins.java
@@ -3,6 +3,7 @@
 import net.kyori.adventure.text.Component;
 import org.jetbrains.annotations.NotNull;
 import org.phantazm.core.player.PlayerView;
+import org.phantazm.stats.zombies.ZombiesPlayerMapStats;
 import org.phantazm.zombies.coin.component.TransactionComponentCreator;
 
 import java.util.ArrayList;
@@ -12,13 +13,15 @@
 
 public class BasicPlayerCoins implements PlayerCoins {
     private final PlayerView playerView;
+    private final ZombiesPlayerMapStats stats;
     private final TransactionComponentCreator componentCreator;
     private volatile int coins;
     private final Object sync;
 
-    public BasicPlayerCoins(@NotNull PlayerView playerView, @NotNull TransactionComponentCreator componentCreator,
-            int initialCoins) {
+    public BasicPlayerCoins(@NotNull PlayerView playerView, @NotNull ZombiesPlayerMapStats stats,
+            @NotNull TransactionComponentCreator componentCreator, int initialCoins) {
         this.playerView = Objects.requireNonNull(playerView, "playerView");
+        this.stats = Objects.requireNonNull(stats, "stats");
         this.componentCreator = Objects.requireNonNull(componentCreator, "componentCreator");
         this.coins = initialCoins;
 
@@ -66,6 +69,12 @@ public void applyTransaction(@NotNull TransactionResult result) {
                 return;
             }
 
+            if (result.change() > 0) {
+                stats.setCoinsGained(stats.getCoinsGained() + result.change());
+            } else {
+                stats.setCoinsSpent(stats.getCoinsSpent() - result.change());
+            }
+
             coins += result.change();
             playerView.getPlayer().ifPresent(player -> {
                 Component message =
diff --git a/zombies/src/main/java/org/phantazm/zombies/command/AmmoRefillCommand.java b/zombies/src/main/java/org/phantazm/zombies/command/AmmoRefillCommand.java
index a3342dedd..b6a207ec5 100644
--- a/zombies/src/main/java/org/phantazm/zombies/command/AmmoRefillCommand.java
+++ b/zombies/src/main/java/org/phantazm/zombies/command/AmmoRefillCommand.java
@@ -4,6 +4,7 @@
 import net.kyori.adventure.text.format.NamedTextColor;
 import net.minestom.server.command.builder.Command;
 import net.minestom.server.entity.Player;
+import net.minestom.server.permission.Permission;
 import org.jetbrains.annotations.NotNull;
 import org.phantazm.core.inventory.InventoryAccess;
 import org.phantazm.core.inventory.InventoryObject;
@@ -17,10 +18,13 @@
 import java.util.function.Function;
 
 public class AmmoRefillCommand extends Command {
-    public AmmoRefillCommand(@NotNull Function<? super UUID, ? extends Optional<ZombiesScene>> sceneMapper) {
+    public static final Permission PERMISSION = new Permission("zombies.playtest.ammo_refill");
+
+    public AmmoRefillCommand(@NotNull Function<? super UUID, Optional<ZombiesScene>> sceneMapper) {
         super("ammo_refill");
 
-        setDefaultExecutor((sender, context) -> {
+        setCondition((sender, commandString) -> sender.hasPermission(PERMISSION));
+        addConditionalSyntax(getCondition(), (sender, context) -> {
             if (!(sender instanceof Player player)) {
                 sender.sendMessage(Component.text("You have to be a player to use that command!", NamedTextColor.RED));
                 return;
diff --git a/zombies/src/main/java/org/phantazm/zombies/command/GiveCoinsCommand.java b/zombies/src/main/java/org/phantazm/zombies/command/CoinsCommand.java
similarity index 83%
rename from zombies/src/main/java/org/phantazm/zombies/command/GiveCoinsCommand.java
rename to zombies/src/main/java/org/phantazm/zombies/command/CoinsCommand.java
index dffb5ca1e..380089e8b 100644
--- a/zombies/src/main/java/org/phantazm/zombies/command/GiveCoinsCommand.java
+++ b/zombies/src/main/java/org/phantazm/zombies/command/CoinsCommand.java
@@ -5,6 +5,7 @@
 import net.minestom.server.command.builder.arguments.ArgumentEnum;
 import net.minestom.server.command.builder.arguments.ArgumentType;
 import net.minestom.server.entity.Player;
+import net.minestom.server.permission.Permission;
 import org.jetbrains.annotations.NotNull;
 import org.phantazm.zombies.coin.PlayerCoins;
 import org.phantazm.zombies.coin.TransactionResult;
@@ -16,7 +17,9 @@
 import java.util.UUID;
 import java.util.function.Function;
 
-public class GiveCoinsCommand extends Command {
+public class CoinsCommand extends Command {
+    public static final Permission PERMISSION = new Permission("zombies.playtest.coins");
+
     public enum CoinAction {
         GIVE,
         TAKE,
@@ -27,11 +30,12 @@ public enum CoinAction {
             ArgumentType.Enum("action", CoinAction.class).setFormat(ArgumentEnum.Format.LOWER_CASED);
     private static final Argument<Integer> COIN_AMOUNT_ARGUMENT = ArgumentType.Integer("amount");
 
-    public GiveCoinsCommand(@NotNull Function<? super UUID, ? extends Optional<ZombiesScene>> sceneMapper) {
+    public CoinsCommand(@NotNull Function<? super UUID, Optional<ZombiesScene>> sceneMapper) {
         super("coins");
         Objects.requireNonNull(sceneMapper, "sceneMapper");
 
-        addConditionalSyntax((sender, commandString) -> sender instanceof Player, (sender, context) -> {
+        setCondition((sender, commandString) -> sender.hasPermission(PERMISSION));
+        addConditionalSyntax(getCondition(), (sender, context) -> {
             UUID uuid = ((Player)sender).getUuid();
             sceneMapper.apply(uuid).ifPresent(scene -> {
                 ZombiesPlayer zombiesPlayer = scene.getZombiesPlayers().get(uuid);
diff --git a/zombies/src/main/java/org/phantazm/zombies/command/FlagToggleCommand.java b/zombies/src/main/java/org/phantazm/zombies/command/FlagToggleCommand.java
index 9defd6955..4fab1b9ae 100644
--- a/zombies/src/main/java/org/phantazm/zombies/command/FlagToggleCommand.java
+++ b/zombies/src/main/java/org/phantazm/zombies/command/FlagToggleCommand.java
@@ -1,11 +1,14 @@
 package org.phantazm.zombies.command;
 
+import com.github.steanky.element.core.key.Constants;
 import com.github.steanky.element.core.key.KeyParser;
 import net.kyori.adventure.key.Key;
 import net.minestom.server.command.builder.Command;
 import net.minestom.server.command.builder.arguments.ArgumentString;
 import net.minestom.server.command.builder.arguments.ArgumentType;
 import net.minestom.server.entity.Player;
+import net.minestom.server.permission.Permission;
+import org.intellij.lang.annotations.Subst;
 import org.jetbrains.annotations.NotNull;
 import org.phantazm.zombies.scene.ZombiesScene;
 
@@ -14,17 +17,21 @@
 import java.util.function.Function;
 
 public class FlagToggleCommand extends Command {
+    public static final Permission PERMISSION = new Permission("zombies.playtest.flag_toggle");
+
     private static final ArgumentString FLAG_ARGUMENT = ArgumentType.String("flag");
 
-    public FlagToggleCommand(@NotNull Function<? super UUID, ? extends Optional<ZombiesScene>> sceneMapper,
+    public FlagToggleCommand(@NotNull Function<? super UUID, Optional<ZombiesScene>> sceneMapper,
             @NotNull KeyParser keyParser) {
         super("toggle_flag");
 
-        addConditionalSyntax((sender, commandString) -> sender instanceof Player, (sender, context) -> {
+        setCondition((sender, commandString) -> sender.hasPermission(PERMISSION));
+        addConditionalSyntax(getCondition(), (sender, context) -> {
             Player player = (Player)sender;
             UUID uuid = player.getUuid();
 
             sceneMapper.apply(uuid).ifPresent(scene -> {
+                @Subst(Constants.NAMESPACE_OR_KEY)
                 String flag = context.get(FLAG_ARGUMENT);
 
                 if (keyParser.isValidKey(flag)) {
diff --git a/zombies/src/main/java/org/phantazm/zombies/command/GodmodeCommand.java b/zombies/src/main/java/org/phantazm/zombies/command/GodmodeCommand.java
index 6411d97a6..c63476234 100644
--- a/zombies/src/main/java/org/phantazm/zombies/command/GodmodeCommand.java
+++ b/zombies/src/main/java/org/phantazm/zombies/command/GodmodeCommand.java
@@ -4,6 +4,7 @@
 import net.kyori.adventure.text.format.NamedTextColor;
 import net.minestom.server.command.builder.Command;
 import net.minestom.server.entity.Player;
+import net.minestom.server.permission.Permission;
 import org.jetbrains.annotations.NotNull;
 import org.phantazm.zombies.Flags;
 import org.phantazm.zombies.map.Flaggable;
@@ -15,10 +16,13 @@
 import java.util.function.Function;
 
 public class GodmodeCommand extends Command {
-    public GodmodeCommand(@NotNull Function<? super UUID, ? extends Optional<ZombiesScene>> sceneMapper) {
+    public static final Permission PERMISSION = new Permission("zombies.playtest.godmode");
+
+    public GodmodeCommand(@NotNull Function<? super UUID, Optional<ZombiesScene>> sceneMapper) {
         super("godmode");
 
-        setDefaultExecutor((sender, context) -> {
+        setCondition((sender, commandString) -> sender.hasPermission(PERMISSION));
+        addConditionalSyntax(getCondition(), (sender, context) -> {
             if (!(sender instanceof Player player)) {
                 sender.sendMessage(Component.text("You have to be a player to use that command!", NamedTextColor.RED));
                 return;
diff --git a/zombies/src/main/java/org/phantazm/zombies/command/KillAllCommand.java b/zombies/src/main/java/org/phantazm/zombies/command/KillAllCommand.java
index 322db5ae8..d76c6e090 100644
--- a/zombies/src/main/java/org/phantazm/zombies/command/KillAllCommand.java
+++ b/zombies/src/main/java/org/phantazm/zombies/command/KillAllCommand.java
@@ -4,6 +4,7 @@
 import net.kyori.adventure.text.format.NamedTextColor;
 import net.minestom.server.command.builder.Command;
 import net.minestom.server.entity.Player;
+import net.minestom.server.permission.Permission;
 import org.jetbrains.annotations.NotNull;
 import org.phantazm.mob.PhantazmMob;
 import org.phantazm.zombies.Tags;
@@ -15,11 +16,14 @@
 import java.util.function.Function;
 
 public class KillAllCommand extends Command {
-    public KillAllCommand(@NotNull Function<? super UUID, ? extends Optional<ZombiesScene>> sceneMapper) {
+    public static final Permission PERMISSION = new Permission("zombies.playtest.killall");
+
+    public KillAllCommand(@NotNull Function<? super UUID, Optional<ZombiesScene>> sceneMapper) {
         super("killall");
         Objects.requireNonNull(sceneMapper, "sceneMapper");
 
-        setDefaultExecutor((sender, context) -> {
+        setCondition((sender, commandString) -> sender.hasPermission(PERMISSION));
+        addConditionalSyntax(getCondition(), (sender, context) -> {
             if (!(sender instanceof Player player)) {
                 sender.sendMessage(Component.text("You have to be a player to use that command!", NamedTextColor.RED));
                 return;
diff --git a/zombies/src/main/java/org/phantazm/zombies/command/QuitCommand.java b/zombies/src/main/java/org/phantazm/zombies/command/QuitCommand.java
deleted file mode 100644
index 5126cf9e5..000000000
--- a/zombies/src/main/java/org/phantazm/zombies/command/QuitCommand.java
+++ /dev/null
@@ -1,38 +0,0 @@
-package org.phantazm.zombies.command;
-
-import net.kyori.adventure.text.Component;
-import net.kyori.adventure.text.format.NamedTextColor;
-import net.minestom.server.command.builder.Command;
-import net.minestom.server.entity.Player;
-import org.jetbrains.annotations.NotNull;
-import org.phantazm.core.game.scene.RouteResult;
-import org.phantazm.core.game.scene.Scene;
-import org.phantazm.core.game.scene.fallback.SceneFallback;
-import org.phantazm.core.player.PlayerViewProvider;
-import org.phantazm.zombies.scene.ZombiesRouteRequest;
-
-import java.util.Collections;
-
-public class QuitCommand extends Command {
-    public QuitCommand(@NotNull Scene<ZombiesRouteRequest> router, @NotNull SceneFallback fallback,
-            @NotNull PlayerViewProvider viewProvider) {
-        super("quit");
-
-        addConditionalSyntax((sender, commandString) -> {
-            if (sender instanceof Player) {
-                return true;
-            }
-
-            sender.sendMessage(Component.text("You have to be a player to use that command!", NamedTextColor.RED));
-            return false;
-        }, (sender, context) -> {
-            Player player = (Player)sender;
-            RouteResult result = router.leave(Collections.singleton(player.getUuid()));
-            if (result.success()) {
-                fallback.fallback(viewProvider.fromPlayer(player));
-            } else {
-                result.message().ifPresent(sender::sendMessage);
-            }
-        });
-    }
-}
diff --git a/zombies/src/main/java/org/phantazm/zombies/command/RoundCommand.java b/zombies/src/main/java/org/phantazm/zombies/command/RoundCommand.java
index c7349ffd4..02785a139 100644
--- a/zombies/src/main/java/org/phantazm/zombies/command/RoundCommand.java
+++ b/zombies/src/main/java/org/phantazm/zombies/command/RoundCommand.java
@@ -7,6 +7,7 @@
 import net.minestom.server.command.builder.arguments.ArgumentType;
 import net.minestom.server.command.builder.suggestion.SuggestionEntry;
 import net.minestom.server.entity.Player;
+import net.minestom.server.permission.Permission;
 import org.jetbrains.annotations.NotNull;
 import org.phantazm.mob.PhantazmMob;
 import org.phantazm.zombies.map.handler.RoundHandler;
@@ -21,7 +22,9 @@
 import java.util.function.Function;
 
 public class RoundCommand extends Command {
-    public RoundCommand(@NotNull Function<? super UUID, ? extends Optional<ZombiesScene>> sceneMapper) {
+    public static final Permission PERMISSION = new Permission("zombies.playtest.round");
+
+    public RoundCommand(@NotNull Function<? super UUID, Optional<ZombiesScene>> sceneMapper) {
         super("round");
         Objects.requireNonNull(sceneMapper, "sceneMapper");
 
@@ -38,7 +41,8 @@ public RoundCommand(@NotNull Function<? super UUID, ? extends Optional<ZombiesSc
                     });
                 });
 
-        addConditionalSyntax((sender, commandString) -> sender instanceof Player, (sender, context) -> {
+        setCondition((sender, commandString) -> sender.hasPermission(PERMISSION));
+        addConditionalSyntax(getCondition(), (sender, context) -> {
             UUID uuid = ((Player)sender).getUuid();
             sceneMapper.apply(uuid).ifPresent(scene -> {
                 RoundHandler handler = scene.getMap().roundHandler();
diff --git a/zombies/src/main/java/org/phantazm/zombies/command/ZombiesCommand.java b/zombies/src/main/java/org/phantazm/zombies/command/ZombiesCommand.java
index 3a7c89844..da76906a7 100644
--- a/zombies/src/main/java/org/phantazm/zombies/command/ZombiesCommand.java
+++ b/zombies/src/main/java/org/phantazm/zombies/command/ZombiesCommand.java
@@ -4,43 +4,39 @@
 import net.kyori.adventure.key.Key;
 import net.minestom.server.command.builder.Command;
 import org.jetbrains.annotations.NotNull;
-import org.phantazm.core.game.scene.Scene;
+import org.phantazm.core.game.scene.SceneTransferHelper;
 import org.phantazm.core.game.scene.fallback.SceneFallback;
 import org.phantazm.core.guild.party.Party;
 import org.phantazm.core.player.PlayerViewProvider;
 import org.phantazm.zombies.map.MapInfo;
-import org.phantazm.zombies.scene.ZombiesRouteRequest;
-import org.phantazm.zombies.scene.ZombiesScene;
+import org.phantazm.zombies.scene.ZombiesJoinHelper;
 import org.phantazm.zombies.scene.ZombiesSceneRouter;
 
 import java.util.Map;
 import java.util.Objects;
-import java.util.Optional;
 import java.util.UUID;
-import java.util.function.Function;
 
 public class ZombiesCommand extends Command {
-    public ZombiesCommand(@NotNull Map<? super UUID, ? extends Party> parties,
-            @NotNull ZombiesSceneRouter router,
-            @NotNull KeyParser keyParser,
-            @NotNull Map<Key, MapInfo> maps, @NotNull PlayerViewProvider viewProvider,
-            @NotNull Function<? super UUID, ? extends Optional<ZombiesScene>> sceneMapper, @NotNull SceneFallback fallback) {
+    public ZombiesCommand(@NotNull Map<? super UUID, ? extends Party> parties, @NotNull ZombiesSceneRouter router,
+            @NotNull KeyParser keyParser, @NotNull Map<Key, MapInfo> maps, @NotNull PlayerViewProvider viewProvider,
+            @NotNull SceneTransferHelper transferHelper, @NotNull SceneFallback fallback) {
         super("zombies");
 
+        Objects.requireNonNull(parties, "parties");
         Objects.requireNonNull(router, "router");
         Objects.requireNonNull(keyParser, "keyParser");
         Objects.requireNonNull(maps, "maps");
         Objects.requireNonNull(viewProvider, "viewProvider");
         Objects.requireNonNull(fallback, "fallback");
 
-        addSubcommand(new ZombiesJoinCommand(parties, router, keyParser, maps, viewProvider));
-        addSubcommand(new GiveCoinsCommand(sceneMapper));
-        addSubcommand(new RoundCommand(sceneMapper));
-        addSubcommand(new KillAllCommand(sceneMapper));
-        addSubcommand(new GodmodeCommand(sceneMapper));
-        addSubcommand(new AmmoRefillCommand(sceneMapper));
-        addSubcommand(new FlagToggleCommand(sceneMapper, keyParser));
-        addSubcommand(new QuitCommand(router, fallback, viewProvider));
-        addSubcommand(new ZombiesRejoinCommand(router, viewProvider, parties));
+        ZombiesJoinHelper joinHelper = new ZombiesJoinHelper(viewProvider, router, transferHelper);
+        addSubcommand(new ZombiesJoinCommand(parties, viewProvider, keyParser, maps, joinHelper));
+        addSubcommand(new CoinsCommand(router::getCurrentScene));
+        addSubcommand(new RoundCommand(router::getCurrentScene));
+        addSubcommand(new KillAllCommand(router::getCurrentScene));
+        addSubcommand(new GodmodeCommand(router::getCurrentScene));
+        addSubcommand(new AmmoRefillCommand(router::getCurrentScene));
+        addSubcommand(new FlagToggleCommand(router::getCurrentScene, keyParser));
+        addSubcommand(new ZombiesRejoinCommand(router, viewProvider, joinHelper));
     }
 }
diff --git a/zombies/src/main/java/org/phantazm/zombies/command/ZombiesJoinCommand.java b/zombies/src/main/java/org/phantazm/zombies/command/ZombiesJoinCommand.java
index a13923c93..11910034c 100644
--- a/zombies/src/main/java/org/phantazm/zombies/command/ZombiesJoinCommand.java
+++ b/zombies/src/main/java/org/phantazm/zombies/command/ZombiesJoinCommand.java
@@ -11,29 +11,29 @@
 import net.minestom.server.entity.Player;
 import org.intellij.lang.annotations.Subst;
 import org.jetbrains.annotations.NotNull;
-import org.phantazm.core.game.scene.RouteResult;
-import org.phantazm.core.game.scene.Scene;
 import org.phantazm.core.guild.GuildMember;
 import org.phantazm.core.guild.party.Party;
+import org.phantazm.core.guild.party.PartyMember;
 import org.phantazm.core.player.PlayerView;
 import org.phantazm.core.player.PlayerViewProvider;
 import org.phantazm.zombies.map.MapInfo;
-import org.phantazm.zombies.scene.ZombiesRouteRequest;
+import org.phantazm.zombies.scene.ZombiesJoinHelper;
 
 import java.util.*;
 
 public class ZombiesJoinCommand extends Command {
-    public ZombiesJoinCommand(@NotNull Map<? super UUID, ? extends Party> parties,
-            @NotNull Scene<ZombiesRouteRequest> router, @NotNull KeyParser keyParser, @NotNull Map<Key, MapInfo> maps,
-            @NotNull PlayerViewProvider viewProvider) {
+    public ZombiesJoinCommand(@NotNull Map<? super UUID, ? extends Party> partyMap,
+            @NotNull PlayerViewProvider viewProvider, @NotNull KeyParser keyParser, @NotNull Map<Key, MapInfo> maps,
+            @NotNull ZombiesJoinHelper joinHelper) {
         super("join");
 
         Argument<String> mapKeyArgument = ArgumentType.String("map-key");
 
-        Objects.requireNonNull(router, "router");
+        Objects.requireNonNull(partyMap, "partyMap");
+        Objects.requireNonNull(viewProvider, "viewProvider");
         Objects.requireNonNull(keyParser, "keyParser");
         Objects.requireNonNull(maps, "maps");
-        Objects.requireNonNull(viewProvider, "viewProvider");
+        Objects.requireNonNull(joinHelper, "joinHelper");
 
         mapKeyArgument.setSuggestionCallback((sender, context, suggestion) -> {
             for (Map.Entry<Key, MapInfo> entry : maps.entrySet()) {
@@ -42,12 +42,26 @@ public ZombiesJoinCommand(@NotNull Map<? super UUID, ? extends Party> parties,
             }
         });
         addConditionalSyntax((sender, commandString) -> {
-            if (sender instanceof Player) {
-                return true;
+            if (commandString == null) {
+                return sender instanceof Player;
+            }
+
+            if (!(sender instanceof Player player)) {
+                sender.sendMessage(Component.text("You have to be a player to use that command!", NamedTextColor.RED));
+                return false;
+            }
+
+            Party party = partyMap.get(player.getUuid());
+            if (party != null) {
+                PartyMember member = party.getMemberManager().getMember(player.getUuid());
+                if (!party.getJoinPermission().hasPermission(member)) {
+                    sender.sendMessage(Component.text("You don't have permission in your party to join games!",
+                            NamedTextColor.RED));
+                    return false;
+                }
             }
 
-            sender.sendMessage(Component.text("You have to be a player to use that command!", NamedTextColor.RED));
-            return false;
+            return true;
         }, (sender, context) -> {
             @Subst("test_map")
             String mapKeyString = context.get(mapKeyArgument);
@@ -56,17 +70,17 @@ public ZombiesJoinCommand(@NotNull Map<? super UUID, ? extends Party> parties,
                 return;
             }
 
-            Key mapKey = keyParser.parseKey(mapKeyString);
-            if (!maps.containsKey(mapKey)) {
+            Key targetMap = keyParser.parseKey(mapKeyString);
+            if (!maps.containsKey(targetMap)) {
                 sender.sendMessage(Component.text("Invalid map!", NamedTextColor.RED));
                 return;
             }
 
-            Player player = (Player)sender;
+            Player joiner = (Player)sender;
+            Party party = partyMap.get(joiner.getUuid());
             Collection<PlayerView> playerViews;
-            Party party = parties.get(player.getUuid());
             if (party == null) {
-                playerViews = Collections.singleton(viewProvider.fromPlayer(player));
+                playerViews = Collections.singleton(viewProvider.fromPlayer(joiner));
             }
             else {
                 playerViews = new ArrayList<>(party.getMemberManager().getMembers().size());
@@ -75,8 +89,7 @@ public ZombiesJoinCommand(@NotNull Map<? super UUID, ? extends Party> parties,
                 }
             }
 
-            RouteResult result = router.join(ZombiesRouteRequest.joinGame(mapKey, () -> playerViews));
-            result.message().ifPresent(sender::sendMessage);
+            joinHelper.joinGame(joiner, playerViews, targetMap);
         }, mapKeyArgument);
     }
 
diff --git a/zombies/src/main/java/org/phantazm/zombies/command/ZombiesRejoinCommand.java b/zombies/src/main/java/org/phantazm/zombies/command/ZombiesRejoinCommand.java
index d4c5ff529..03e7c00d2 100644
--- a/zombies/src/main/java/org/phantazm/zombies/command/ZombiesRejoinCommand.java
+++ b/zombies/src/main/java/org/phantazm/zombies/command/ZombiesRejoinCommand.java
@@ -8,44 +8,47 @@
 import net.minestom.server.command.builder.suggestion.SuggestionEntry;
 import net.minestom.server.entity.Player;
 import org.jetbrains.annotations.NotNull;
-import org.phantazm.core.game.scene.RouteResult;
-import org.phantazm.core.guild.GuildMember;
-import org.phantazm.core.guild.party.Party;
-import org.phantazm.core.player.PlayerView;
 import org.phantazm.core.player.PlayerViewProvider;
-import org.phantazm.zombies.scene.ZombiesRouteRequest;
+import org.phantazm.zombies.scene.ZombiesJoinHelper;
 import org.phantazm.zombies.scene.ZombiesScene;
 import org.phantazm.zombies.scene.ZombiesSceneRouter;
 
-import java.util.*;
+import java.util.Objects;
+import java.util.Optional;
+import java.util.UUID;
 
 public class ZombiesRejoinCommand extends Command {
-    public ZombiesRejoinCommand(@NotNull ZombiesSceneRouter router, @NotNull PlayerViewProvider viewProvider,
-            @NotNull Map<? super UUID, ? extends Party> parties) {
+    public ZombiesRejoinCommand(@NotNull ZombiesSceneRouter router,
+            @NotNull PlayerViewProvider viewProvider, @NotNull ZombiesJoinHelper joinHelper) {
         super("rejoin");
 
         Objects.requireNonNull(router, "router");
         Objects.requireNonNull(viewProvider, "viewProvider");
-        Objects.requireNonNull(parties, "parties");
+        Objects.requireNonNull(joinHelper, "joinHelper");
 
         Argument<UUID> targetGameArgument = ArgumentType.UUID("target-game");
-        targetGameArgument.setSuggestionCallback(((sender, context, suggestion) -> {
+        targetGameArgument.setSuggestionCallback((sender, context, suggestion) -> {
             if (!(sender instanceof Player player)) {
                 return;
             }
 
-            UUID uuid = player.getUuid();
-            for (ZombiesScene scene : router.getScenes()) {
-                if (!scene.getPlayers().containsKey(uuid)) {
+            Optional<ZombiesScene> currentScene = router.getCurrentScene(player.getUuid());
+            for (ZombiesScene scene : router.getScenesContainingPlayer(player.getUuid())) {
+                if (currentScene.isPresent() && currentScene.get() == scene) {
                     continue;
                 }
 
-                SuggestionEntry entry = new SuggestionEntry(scene.getUuid().toString(), scene.getMapSettingsInfo().displayName());
+                SuggestionEntry entry =
+                        new SuggestionEntry(scene.getUUID().toString(), scene.getMapSettingsInfo().displayName());
                 suggestion.addEntry(entry);
             }
-        }));
+        });
 
         addConditionalSyntax((sender, commandString) -> {
+            if (commandString == null) {
+                return sender instanceof Player;
+            }
+
             if (!(sender instanceof Player)) {
                 sender.sendMessage(Component.text("You have to be a player to use that command!", NamedTextColor.RED));
                 return false;
@@ -55,9 +58,15 @@ public ZombiesRejoinCommand(@NotNull ZombiesSceneRouter router, @NotNull PlayerV
         }, (sender, context) -> {
             UUID targetGame = context.get(targetGameArgument);
 
+            Optional<ZombiesScene> currentScene = router.getCurrentScene(sender.identity().uuid());
+
             boolean anyMatch = false;
-            for (ZombiesScene scene : router.getScenes()) {
-                if (scene.getUuid().equals(targetGame)) {
+            for (ZombiesScene scene : router.getScenesContainingPlayer(sender.identity().uuid())) {
+                if (currentScene.isPresent() && currentScene.get() == scene) {
+                    continue;
+                }
+
+                if (scene.getUUID().equals(targetGame)) {
                     anyMatch = true;
                     break;
                 }
@@ -68,21 +77,7 @@ public ZombiesRejoinCommand(@NotNull ZombiesSceneRouter router, @NotNull PlayerV
                 return;
             }
 
-            Player player = (Player)sender;
-            Collection<PlayerView> playerViews;
-            Party party = parties.get(player.getUuid());
-            if (party == null) {
-                playerViews = Collections.singleton(viewProvider.fromPlayer(player));
-            }
-            else {
-                playerViews = new ArrayList<>(party.getMemberManager().getMembers().size());
-                for (GuildMember guildMember : party.getMemberManager().getMembers().values()) {
-                    playerViews.add(guildMember.getPlayerView());
-                }
-            }
-
-            RouteResult result = router.join(ZombiesRouteRequest.rejoinGame(targetGame, () -> playerViews));
-            result.message().ifPresent(sender::sendMessage);
+            joinHelper.rejoinGame(((Player)sender), targetGame);
         }, targetGameArgument);
     }
 }
diff --git a/zombies/src/main/java/org/phantazm/zombies/corpse/Corpse.java b/zombies/src/main/java/org/phantazm/zombies/corpse/Corpse.java
deleted file mode 100644
index ec9189f00..000000000
--- a/zombies/src/main/java/org/phantazm/zombies/corpse/Corpse.java
+++ /dev/null
@@ -1,95 +0,0 @@
-package org.phantazm.zombies.corpse;
-
-import net.kyori.adventure.text.Component;
-import net.kyori.adventure.text.format.NamedTextColor;
-import net.kyori.adventure.text.format.Style;
-import net.kyori.adventure.text.format.TextDecoration;
-import net.minestom.server.entity.Entity;
-import org.jetbrains.annotations.NotNull;
-import org.phantazm.commons.Activable;
-import org.phantazm.core.entity.fakeplayer.MinimalFakePlayer;
-import org.phantazm.core.hologram.Hologram;
-import org.phantazm.core.time.TickFormatter;
-import org.phantazm.zombies.player.state.revive.ReviveHandler;
-
-import java.util.Objects;
-
-public class Corpse implements Activable {
-
-    private final Hologram hologram;
-
-    private final MinimalFakePlayer corpseEntity;
-
-    private final TickFormatter tickFormatter;
-
-    public Corpse(@NotNull Hologram hologram, @NotNull MinimalFakePlayer corpseEntity,
-            @NotNull TickFormatter tickFormatter) {
-        this.hologram = Objects.requireNonNull(hologram, "hologram");
-        this.corpseEntity = Objects.requireNonNull(corpseEntity, "corpseEntity");
-        this.tickFormatter = Objects.requireNonNull(tickFormatter, "tickFormatter");
-    }
-
-    @Override
-    public void start() {
-        hologram.add(Component.text("███████████████", NamedTextColor.YELLOW));
-        hologram.add(Component.empty());
-        hologram.add(Component.empty());
-        hologram.add(Component.text("███████████████", NamedTextColor.YELLOW));
-
-        corpseEntity.init();
-        corpseEntity.setPose(Entity.Pose.SLEEPING);
-    }
-
-    public void tick(@NotNull ReviveHandler reviveHandler) {
-        if (reviveHandler.isReviving()) {
-            hologram.set(1,
-                    Component.text("REVIVING...").style(Style.style(NamedTextColor.YELLOW, TextDecoration.BOLD)));
-            hologram.set(2, tickFormatter.format(reviveHandler.getTicksUntilRevive()).append(Component.text("s")));
-        }
-        else {
-            hologram.set(1, Component.text("HOLD SNEAK TO REVIVE!")
-                    .style(Style.style(NamedTextColor.YELLOW, TextDecoration.BOLD)));
-            hologram.set(2, tickFormatter.format(reviveHandler.getTicksUntilDeath()));
-        }
-    }
-
-    public void disable() {
-        hologram.clear();
-    }
-
-    public void remove() {
-        disable();
-        corpseEntity.remove();
-    }
-
-    public @NotNull Activable asKnockActivable(@NotNull ReviveHandler reviveHandler) {
-        Objects.requireNonNull(reviveHandler, "reviveHandler");
-
-        return new Activable() {
-            @Override
-            public void start() {
-                Corpse.this.start();
-            }
-
-            @Override
-            public void tick(long time) {
-                Corpse.this.tick(reviveHandler);
-            }
-
-            @Override
-            public void end() {
-                Corpse.this.remove();
-            }
-        };
-    }
-
-    public @NotNull Activable asDeathActivable() {
-        return new Activable() {
-            @Override
-            public void end() {
-                Corpse.this.disable();
-            }
-        };
-    }
-
-}
diff --git a/zombies/src/main/java/org/phantazm/zombies/corpse/CorpseCreator.java b/zombies/src/main/java/org/phantazm/zombies/corpse/CorpseCreator.java
new file mode 100644
index 000000000..9c84de5ce
--- /dev/null
+++ b/zombies/src/main/java/org/phantazm/zombies/corpse/CorpseCreator.java
@@ -0,0 +1,237 @@
+package org.phantazm.zombies.corpse;
+
+import com.github.steanky.element.core.annotation.*;
+import com.github.steanky.element.core.dependency.DependencyProvider;
+import com.github.steanky.ethylene.core.ConfigElement;
+import com.github.steanky.ethylene.core.ConfigPrimitive;
+import com.github.steanky.ethylene.mapper.annotation.Default;
+import net.kyori.adventure.text.Component;
+import net.minestom.server.MinecraftServer;
+import net.minestom.server.coordinate.Point;
+import net.minestom.server.entity.Entity;
+import net.minestom.server.entity.Player;
+import net.minestom.server.entity.PlayerSkin;
+import net.minestom.server.instance.Instance;
+import net.minestom.server.scoreboard.Team;
+import org.jetbrains.annotations.NotNull;
+import org.phantazm.commons.Activable;
+import org.phantazm.core.ComponentUtils;
+import org.phantazm.core.entity.fakeplayer.MinimalFakePlayer;
+import org.phantazm.core.hologram.Hologram;
+import org.phantazm.core.hologram.InstanceHologram;
+import org.phantazm.core.time.TickFormatter;
+import org.phantazm.zombies.player.ZombiesPlayer;
+import org.phantazm.zombies.player.state.revive.ReviveHandler;
+
+import java.util.List;
+import java.util.UUID;
+
+@Model("zombies.corpse")
+@Cache(false)
+public class CorpseCreator {
+    public interface Source {
+        @NotNull CorpseCreator make(@NotNull DependencyProvider mapDependencyProvider);
+    }
+
+    private final Data data;
+    private final List<CorpseLine> idleLines;
+    private final List<CorpseLine> revivingLines;
+    private final Team corpseTeam;
+
+    @FactoryMethod
+    public CorpseCreator(@NotNull Data data, @NotNull @Child("idle_lines") List<CorpseLine> idleLines,
+            @NotNull @Child("reviving_lines") List<CorpseLine> revivingLines, @NotNull Team corpseTeam) {
+        this.data = data;
+        this.idleLines = List.copyOf(idleLines);
+        this.revivingLines = List.copyOf(revivingLines);
+        this.corpseTeam = corpseTeam;
+    }
+
+    public @NotNull CorpseCreator.Corpse forPlayer(@NotNull Instance instance, @NotNull ZombiesPlayer zombiesPlayer,
+            @NotNull Point deathLocation, @NotNull ReviveHandler reviveHandler) {
+        PlayerSkin skin = zombiesPlayer.getPlayer().map(Player::getSkin).orElse(null);
+        String corpseUsername = UUID.randomUUID().toString().substring(0, 16);
+        MinimalFakePlayer corpseEntity =
+                new MinimalFakePlayer(MinecraftServer.getSchedulerManager(), corpseUsername, skin);
+
+        Hologram hologram = new InstanceHologram(deathLocation.add(0, data.hologramHeightOffset, 0), data.hologramGap);
+
+        hologram.setInstance(instance);
+        corpseEntity.setInstance(instance, deathLocation.add(0, data.corpseHeightOffset, 0));
+        corpseTeam.addMember(corpseUsername);
+
+        return new Corpse(reviveHandler, hologram, corpseEntity, idleLines, revivingLines);
+    }
+
+    @DataObject
+    public record Data(double hologramGap,
+                       double hologramHeightOffset,
+                       double corpseHeightOffset,
+                       @NotNull @ChildPath("idle_lines") List<String> idleLines,
+                       @NotNull @ChildPath("reviving_lines") List<String> revivingLines) {
+        @Default("hologramGap")
+        public static ConfigElement defaultHologramGap() {
+            return ConfigPrimitive.of(0.0);
+        }
+
+        @Default("hologramHeightOffset")
+        public static ConfigElement defaultHologramHeightOffset() {
+            return ConfigPrimitive.of(1.0);
+        }
+
+        @Default("corpseHeightOffset")
+        public static ConfigElement defaultCorpseHeightOffset() {
+            return ConfigPrimitive.of(0.25);
+        }
+    }
+
+    public interface CorpseLine {
+        @NotNull Component update(@NotNull Corpse corpse, long time);
+    }
+
+    @Model("zombies.corpse.line.static")
+    @Cache
+    public static class StaticLine implements CorpseLine {
+        private final Data data;
+
+        @FactoryMethod
+        public StaticLine(@NotNull Data data) {
+            this.data = data;
+        }
+
+        @Override
+        public @NotNull Component update(@NotNull Corpse corpse, long time) {
+            return data.message;
+        }
+
+        @DataObject
+        public record Data(@NotNull Component message) {
+        }
+    }
+
+    @Model("zombies.corpse.line.time")
+    @Cache
+    public static class TimeLine implements CorpseLine {
+        private final Data data;
+        private final TickFormatter tickFormatter;
+
+        @FactoryMethod
+        public TimeLine(@NotNull Data data, @NotNull @Child("tick_formatter") TickFormatter tickFormatter) {
+            this.data = data;
+            this.tickFormatter = tickFormatter;
+        }
+
+        @Override
+        public @NotNull Component update(@NotNull Corpse corpse, long time) {
+            return ComponentUtils.tryFormat(data.formatString, tickFormatter.format(data.ticksUntilRevive
+                                                                                    ? corpse.reviveHandler.getTicksUntilRevive()
+                                                                                    : corpse.reviveHandler.getTicksUntilDeath()));
+        }
+
+        @DataObject
+        public record Data(@NotNull String formatString,
+                           boolean ticksUntilRevive,
+                           @NotNull @ChildPath("tick_formatter") String tickFormatter) {
+        }
+    }
+
+    public class Corpse implements Activable {
+        private final ReviveHandler reviveHandler;
+
+        private final Hologram hologram;
+        private final MinimalFakePlayer corpseEntity;
+
+        private final List<CorpseLine> idleLines;
+        private final List<CorpseLine> revivingLines;
+
+        private List<CorpseLine> currentLines;
+
+        private Corpse(@NotNull ReviveHandler reviveHandler, @NotNull Hologram hologram,
+                @NotNull MinimalFakePlayer corpseEntity, @NotNull List<CorpseLine> idleLines,
+                @NotNull List<CorpseLine> revivingLines) {
+            this.reviveHandler = reviveHandler;
+            this.hologram = hologram;
+            this.corpseEntity = corpseEntity;
+            this.idleLines = idleLines;
+            this.revivingLines = revivingLines;
+        }
+
+        @Override
+        public void start() {
+            for (CorpseLine corpseLine : idleLines) {
+                hologram.add(corpseLine.update(this, System.currentTimeMillis()));
+            }
+
+            this.currentLines = idleLines;
+
+            corpseEntity.init();
+            corpseEntity.setPose(Entity.Pose.SLEEPING);
+        }
+
+        public @NotNull ReviveHandler reviveHandler() {
+            return reviveHandler;
+        }
+
+        public void tick(long time) {
+            List<CorpseLine> currentLines = this.currentLines;
+            if (currentLines == null) {
+                return;
+            }
+
+            List<CorpseLine> newLines = reviveHandler.isReviving() ? revivingLines : idleLines;
+            if (newLines != currentLines) {
+                hologram.clear();
+                hologram.addAll(newLines.stream().map(line -> line.update(this, time)).toList());
+                this.currentLines = newLines;
+                return;
+            }
+
+            for (int i = 0; i < CorpseCreator.this.idleLines.size(); i++) {
+                Component newLine = currentLines.get(i).update(this, time);
+                Component oldLine = hologram.get(i);
+
+                if (!newLine.equals(oldLine)) {
+                    hologram.set(i, newLine);
+                }
+            }
+        }
+
+        public void disable() {
+            hologram.clear();
+        }
+
+        public void remove() {
+            disable();
+            corpseEntity.remove();
+        }
+
+        public @NotNull Activable asKnockActivable() {
+            return new Activable() {
+                @Override
+                public void start() {
+                    Corpse.this.start();
+                }
+
+                @Override
+                public void tick(long time) {
+                    Corpse.this.tick(time);
+                }
+
+                @Override
+                public void end() {
+                    Corpse.this.remove();
+                }
+            };
+        }
+
+        public @NotNull Activable asDeathActivable() {
+            return new Activable() {
+                @Override
+                public void end() {
+                    Corpse.this.disable();
+                }
+            };
+        }
+
+    }
+}
diff --git a/zombies/src/main/java/org/phantazm/zombies/damage/ZombiesDamageType.java b/zombies/src/main/java/org/phantazm/zombies/damage/ZombiesDamageType.java
new file mode 100644
index 000000000..88cb2e941
--- /dev/null
+++ b/zombies/src/main/java/org/phantazm/zombies/damage/ZombiesDamageType.java
@@ -0,0 +1,13 @@
+package org.phantazm.zombies.damage;
+
+import net.minestom.server.entity.damage.DamageType;
+
+public class ZombiesDamageType {
+
+    public static final DamageType BOMBING = new DamageType("zombies.bombing");
+
+    private ZombiesDamageType() {
+        throw new UnsupportedOperationException();
+    }
+
+}
diff --git a/zombies/src/main/java/org/phantazm/zombies/equipment/gun/ZombiesEquipmentModule.java b/zombies/src/main/java/org/phantazm/zombies/equipment/gun/ZombiesEquipmentModule.java
index 9f3716096..c993244eb 100644
--- a/zombies/src/main/java/org/phantazm/zombies/equipment/gun/ZombiesEquipmentModule.java
+++ b/zombies/src/main/java/org/phantazm/zombies/equipment/gun/ZombiesEquipmentModule.java
@@ -14,6 +14,7 @@
 import org.phantazm.mob.spawner.MobSpawner;
 import org.phantazm.zombies.map.objects.MapObjects;
 import org.phantazm.zombies.player.ZombiesPlayer;
+import org.phantazm.stats.zombies.ZombiesPlayerMapStats;
 
 import java.util.*;
 import java.util.function.Function;
@@ -25,6 +26,7 @@
 public class ZombiesEquipmentModule implements DependencyModule {
     private final Map<? super UUID, ? extends ZombiesPlayer> playerMap;
     private final PlayerView playerView;
+    private final ZombiesPlayerMapStats mapStats;
     private final MobSpawner mobSpawner;
     private final MobStore mobStore;
     private final EventNode<Event> eventNode;
@@ -34,12 +36,13 @@ public class ZombiesEquipmentModule implements DependencyModule {
     private final Function<? super Key, ? extends MobModel> mobModelFunction;
 
     public ZombiesEquipmentModule(@NotNull Map<? super UUID, ? extends ZombiesPlayer> playerMap,
-            @NotNull PlayerView playerView, @NotNull MobSpawner mobSpawner, @NotNull MobStore mobStore,
-            @NotNull EventNode<Event> eventNode, @NotNull Random random, @NotNull MapObjects mapObjects,
-            @NotNull Supplier<? extends ZombiesPlayer> zombiesPlayerSupplier,
+            @NotNull PlayerView playerView, @NotNull ZombiesPlayerMapStats mapStats, @NotNull MobSpawner mobSpawner,
+            @NotNull MobStore mobStore, @NotNull EventNode<Event> eventNode, @NotNull Random random,
+            @NotNull MapObjects mapObjects, @NotNull Supplier<? extends ZombiesPlayer> zombiesPlayerSupplier,
             @NotNull Function<? super Key, ? extends MobModel> mobModelFunction) {
         this.playerMap = Objects.requireNonNull(playerMap, "playerMap");
         this.playerView = Objects.requireNonNull(playerView, "playerView");
+        this.mapStats = Objects.requireNonNull(mapStats, "mapStats");
         this.mobSpawner = Objects.requireNonNull(mobSpawner, "mobSpawner");
         this.mobStore = Objects.requireNonNull(mobStore, "mobStore");
         this.eventNode = Objects.requireNonNull(eventNode, "eventNode");
@@ -57,6 +60,10 @@ public ZombiesEquipmentModule(@NotNull Map<? super UUID, ? extends ZombiesPlayer
         return playerView;
     }
 
+    public @NotNull ZombiesPlayerMapStats getMapStats() {
+        return mapStats;
+    }
+
     public @NotNull Supplier<Optional<? extends Entity>> getPlayerSupplier() {
         return playerView::getPlayer;
     }
diff --git a/zombies/src/main/java/org/phantazm/zombies/equipment/gun/event/GunShootEvent.java b/zombies/src/main/java/org/phantazm/zombies/equipment/gun/event/GunShootEvent.java
new file mode 100644
index 000000000..f8f5fcfb0
--- /dev/null
+++ b/zombies/src/main/java/org/phantazm/zombies/equipment/gun/event/GunShootEvent.java
@@ -0,0 +1,16 @@
+package org.phantazm.zombies.equipment.gun.event;
+
+import net.minestom.server.entity.Entity;
+import net.minestom.server.event.trait.EntityInstanceEvent;
+import org.jetbrains.annotations.NotNull;
+import org.phantazm.zombies.equipment.gun.Gun;
+import org.phantazm.zombies.equipment.gun.shoot.GunShot;
+
+public record GunShootEvent(@NotNull Gun gun, @NotNull GunShot shot, @NotNull Entity entity) implements EntityInstanceEvent {
+
+    @Override
+    public @NotNull Entity getEntity() {
+        return entity;
+    }
+
+}
diff --git a/zombies/src/main/java/org/phantazm/zombies/equipment/gun/shoot/blockiteration/BasicBlockIteration.java b/zombies/src/main/java/org/phantazm/zombies/equipment/gun/shoot/blockiteration/BasicBlockIteration.java
index 015049dc5..5ee5c7f97 100644
--- a/zombies/src/main/java/org/phantazm/zombies/equipment/gun/shoot/blockiteration/BasicBlockIteration.java
+++ b/zombies/src/main/java/org/phantazm/zombies/equipment/gun/shoot/blockiteration/BasicBlockIteration.java
@@ -1,39 +1,51 @@
 package org.phantazm.zombies.equipment.gun.shoot.blockiteration;
 
 import com.github.steanky.element.core.annotation.Cache;
+import com.github.steanky.element.core.annotation.DataObject;
 import com.github.steanky.element.core.annotation.FactoryMethod;
 import com.github.steanky.element.core.annotation.Model;
+import net.kyori.adventure.key.Key;
 import net.minestom.server.coordinate.Point;
 import net.minestom.server.coordinate.Vec;
 import net.minestom.server.instance.block.Block;
 import org.jetbrains.annotations.NotNull;
 
+import java.util.Collection;
+import java.util.Objects;
+import java.util.Set;
+
 /**
  * A {@link BlockIteration} method based solely on ray tracing.
  */
 @Model("zombies.gun.block_iteration.block")
 @Cache
 public class BasicBlockIteration implements BlockIteration {
-    private static final Context CONTEXT = new Context() {
-        @SuppressWarnings("UnstableApiUsage")
-        @Override
-        public boolean isValidEndpoint(@NotNull Point blockLocation, @NotNull Block block) {
-            return !block.registry().collisionShape().relativeEnd().isZero();
-        }
-
-        @Override
-        public boolean acceptRaytracedBlock(@NotNull Vec intersection, @NotNull Block block) {
-            return true;
-        }
-    };
+    private final Data data;
 
     @FactoryMethod
-    public BasicBlockIteration() {
-
+    public BasicBlockIteration(@NotNull Data data) {
+        this.data = Objects.requireNonNull(data, "data");
     }
 
     @Override
     public @NotNull Context createContext() {
-        return CONTEXT;
+        return new Context() {
+            @SuppressWarnings("UnstableApiUsage")
+            @Override
+            public boolean isValidEndpoint(@NotNull Point blockLocation, @NotNull Block block) {
+                return !data.passableBlocks().contains(block.key()) && !block.registry().collisionShape().relativeEnd().isZero();
+            }
+
+            @Override
+            public boolean acceptRaytracedBlock(@NotNull Vec intersection, @NotNull Block block) {
+                return true;
+            }
+        };
     }
+
+    @DataObject
+    public record Data(@NotNull Set<Key> passableBlocks) {
+
+    }
+
 }
diff --git a/zombies/src/main/java/org/phantazm/zombies/equipment/gun/shoot/blockiteration/WallshotBlockIteration.java b/zombies/src/main/java/org/phantazm/zombies/equipment/gun/shoot/blockiteration/WallshotBlockIteration.java
index 82a903c20..db9466f2b 100644
--- a/zombies/src/main/java/org/phantazm/zombies/equipment/gun/shoot/blockiteration/WallshotBlockIteration.java
+++ b/zombies/src/main/java/org/phantazm/zombies/equipment/gun/shoot/blockiteration/WallshotBlockIteration.java
@@ -13,6 +13,7 @@
 
 import java.util.Collection;
 import java.util.Objects;
+import java.util.Set;
 
 /**
  * A {@link BlockIteration} method that employs a technique called "wallshooting".
@@ -61,6 +62,6 @@ public boolean acceptRaytracedBlock(@NotNull Vec intersection, @NotNull Block bl
     }
 
     @DataObject
-    public record Data(@NotNull Collection<Key> passableBlocks) {
+    public record Data(@NotNull Set<Key> passableBlocks) {
     }
 }
diff --git a/zombies/src/main/java/org/phantazm/zombies/equipment/gun/shoot/fire/Firer.java b/zombies/src/main/java/org/phantazm/zombies/equipment/gun/shoot/fire/Firer.java
index d66695dcf..be13086d2 100644
--- a/zombies/src/main/java/org/phantazm/zombies/equipment/gun/shoot/fire/Firer.java
+++ b/zombies/src/main/java/org/phantazm/zombies/equipment/gun/shoot/fire/Firer.java
@@ -25,8 +25,4 @@ public interface Firer extends GunTickEffect {
      */
     void fire(@NotNull Gun gun, @NotNull GunState state, @NotNull Pos start, @NotNull Collection<UUID> previousHits);
 
-    void addExtraShotHandler(ShotHandler shotHandler);
-
-    void removeExtraShotHandler(ShotHandler shotHandler);
-
 }
diff --git a/zombies/src/main/java/org/phantazm/zombies/equipment/gun/shoot/fire/HitScanFirer.java b/zombies/src/main/java/org/phantazm/zombies/equipment/gun/shoot/fire/HitScanFirer.java
index 52f4375bb..e548fd613 100644
--- a/zombies/src/main/java/org/phantazm/zombies/equipment/gun/shoot/fire/HitScanFirer.java
+++ b/zombies/src/main/java/org/phantazm/zombies/equipment/gun/shoot/fire/HitScanFirer.java
@@ -4,9 +4,11 @@
 import net.minestom.server.coordinate.Point;
 import net.minestom.server.coordinate.Pos;
 import net.minestom.server.entity.Entity;
+import net.minestom.server.event.EventDispatcher;
 import org.jetbrains.annotations.NotNull;
 import org.phantazm.zombies.equipment.gun.Gun;
 import org.phantazm.zombies.equipment.gun.GunState;
+import org.phantazm.zombies.equipment.gun.event.GunShootEvent;
 import org.phantazm.zombies.equipment.gun.shoot.GunHit;
 import org.phantazm.zombies.equipment.gun.shoot.GunShot;
 import org.phantazm.zombies.equipment.gun.shoot.endpoint.ShotEndpointSelector;
@@ -49,37 +51,29 @@ public HitScanFirer(@NotNull Supplier<Optional<? extends Entity>> entitySupplier
     @Override
     public void fire(@NotNull Gun gun, @NotNull GunState state, @NotNull Pos start,
             @NotNull Collection<UUID> previousHits) {
-        entitySupplier.get().ifPresent(player -> {
+        entitySupplier.get().ifPresent(entity -> {
             Optional<Point> endOptional = endSelector.getEnd(start);
             if (endOptional.isEmpty()) {
                 return;
             }
             Point end = endOptional.get();
 
-            TargetFinder.Result target = targetFinder.findTarget(player, start, end, previousHits);
+            TargetFinder.Result target = targetFinder.findTarget(entity, start, end, previousHits);
             for (GunHit hit : target.regular()) {
                 previousHits.add(hit.entity().getUuid());
             }
             for (GunHit hit : target.headshot()) {
                 previousHits.add(hit.entity().getUuid());
             }
+
+            GunShot shot = new GunShot(start, end, target.regular(), target.headshot());
+            EventDispatcher.call(new GunShootEvent(gun, shot, entity));
             for (ShotHandler shotHandler : shotHandlers) {
-                shotHandler.handle(gun, state, player, previousHits,
-                        new GunShot(start, end, target.regular(), target.headshot()));
+                shotHandler.handle(gun, state, entity, previousHits, shot);
             }
         });
     }
 
-    @Override
-    public void addExtraShotHandler(ShotHandler shotHandler) {
-
-    }
-
-    @Override
-    public void removeExtraShotHandler(ShotHandler shotHandler) {
-
-    }
-
     @Override
     public void tick(@NotNull GunState state, long time) {
         for (ShotHandler handler : shotHandlers) {
diff --git a/zombies/src/main/java/org/phantazm/zombies/equipment/gun/shoot/fire/SpreadFirer.java b/zombies/src/main/java/org/phantazm/zombies/equipment/gun/shoot/fire/SpreadFirer.java
index 7e92c2361..35c6af764 100644
--- a/zombies/src/main/java/org/phantazm/zombies/equipment/gun/shoot/fire/SpreadFirer.java
+++ b/zombies/src/main/java/org/phantazm/zombies/equipment/gun/shoot/fire/SpreadFirer.java
@@ -6,7 +6,6 @@
 import org.jetbrains.annotations.NotNull;
 import org.phantazm.zombies.equipment.gun.Gun;
 import org.phantazm.zombies.equipment.gun.GunState;
-import org.phantazm.zombies.equipment.gun.shoot.handler.ShotHandler;
 
 import java.util.*;
 
@@ -62,22 +61,6 @@ public void fire(@NotNull Gun gun, @NotNull GunState state, @NotNull Pos start,
         }
     }
 
-    @Override
-    public void addExtraShotHandler(@NotNull ShotHandler shotHandler) {
-        Objects.requireNonNull(shotHandler, "shotHandler");
-        for (Firer firer : subFirers) {
-            firer.addExtraShotHandler(shotHandler);
-        }
-    }
-
-    @Override
-    public void removeExtraShotHandler(@NotNull ShotHandler shotHandler) {
-        Objects.requireNonNull(shotHandler, "shotHandler");
-        for (Firer firer : subFirers) {
-            firer.removeExtraShotHandler(shotHandler);
-        }
-    }
-
     @Override
     public void tick(@NotNull GunState state, long time) {
         for (Firer firer : subFirers) {
diff --git a/zombies/src/main/java/org/phantazm/zombies/equipment/gun/shoot/fire/projectile/ProjectileFirer.java b/zombies/src/main/java/org/phantazm/zombies/equipment/gun/shoot/fire/projectile/ProjectileFirer.java
index b7eb8069e..acb093398 100644
--- a/zombies/src/main/java/org/phantazm/zombies/equipment/gun/shoot/fire/projectile/ProjectileFirer.java
+++ b/zombies/src/main/java/org/phantazm/zombies/equipment/gun/shoot/fire/projectile/ProjectileFirer.java
@@ -6,6 +6,7 @@
 import net.minestom.server.coordinate.Pos;
 import net.minestom.server.entity.Entity;
 import net.minestom.server.event.Event;
+import net.minestom.server.event.EventDispatcher;
 import net.minestom.server.event.EventNode;
 import net.minestom.server.event.entity.projectile.ProjectileCollideWithBlockEvent;
 import net.minestom.server.event.entity.projectile.ProjectileCollideWithEntityEvent;
@@ -19,6 +20,7 @@
 import org.phantazm.proxima.bindings.minestom.ProximaEntity;
 import org.phantazm.zombies.equipment.gun.Gun;
 import org.phantazm.zombies.equipment.gun.GunState;
+import org.phantazm.zombies.equipment.gun.event.GunShootEvent;
 import org.phantazm.zombies.equipment.gun.shoot.GunHit;
 import org.phantazm.zombies.equipment.gun.shoot.GunShot;
 import org.phantazm.zombies.equipment.gun.shoot.endpoint.ShotEndpointSelector;
@@ -111,16 +113,6 @@ public void fire(@NotNull Gun gun, @NotNull GunState state, @NotNull Pos start,
         });
     }
 
-    @Override
-    public void addExtraShotHandler(ShotHandler shotHandler) {
-
-    }
-
-    @Override
-    public void removeExtraShotHandler(ShotHandler shotHandler) {
-
-    }
-
     @Override
     public void tick(@NotNull GunState state, long time) {
         for (AliveProjectile aliveProjectile = removalQueue.peek();
@@ -193,8 +185,9 @@ private void onProjectileCollision(@NotNull FiredShot firedShot, @NotNull Entity
                 firedShot.previousHits().add(hit.entity().getUuid());
             }
 
+            GunShot shot = new GunShot(firedShot.start(), collision, target.regular(), target.headshot());
+            EventDispatcher.call(new GunShootEvent(firedShot.gun, shot, firedShot.shooter()));
             for (ShotHandler shotHandler : shotHandlers) {
-                GunShot shot = new GunShot(firedShot.start(), collision, target.regular(), target.headshot());
                 shotHandler.handle(firedShot.gun(), firedShot.state(), firedShot.shooter(), firedShot.previousHits(),
                         shot);
             }
diff --git a/zombies/src/main/java/org/phantazm/zombies/equipment/perk/equipment/interactor/MeleeInteractorCreator.java b/zombies/src/main/java/org/phantazm/zombies/equipment/perk/equipment/interactor/MeleeInteractorCreator.java
index bc86db5dd..b08d5de32 100644
--- a/zombies/src/main/java/org/phantazm/zombies/equipment/perk/equipment/interactor/MeleeInteractorCreator.java
+++ b/zombies/src/main/java/org/phantazm/zombies/equipment/perk/equipment/interactor/MeleeInteractorCreator.java
@@ -18,8 +18,17 @@
 import org.jetbrains.annotations.NotNull;
 import org.phantazm.core.RayUtils;
 import org.phantazm.mob.MobStore;
+import org.phantazm.mob.PhantazmMob;
+import org.phantazm.zombies.ExtraNodeKeys;
+import org.phantazm.zombies.Flags;
+import org.phantazm.zombies.coin.ModifierSourceGroups;
+import org.phantazm.zombies.coin.PlayerCoins;
+import org.phantazm.zombies.coin.Transaction;
+import org.phantazm.zombies.map.Flaggable;
+import org.phantazm.zombies.map.objects.MapObjects;
 import org.phantazm.zombies.player.ZombiesPlayer;
 
+import java.util.Collection;
 import java.util.Objects;
 
 @Description("""
@@ -30,27 +39,32 @@
 public class MeleeInteractorCreator implements PerkInteractorCreator {
     private final Data data;
     private final MobStore mobStore;
+    private final Flaggable mapFlags;
 
     @FactoryMethod
-    public MeleeInteractorCreator(@NotNull Data data, @NotNull MobStore mobStore) {
+    public MeleeInteractorCreator(@NotNull Data data, @NotNull MobStore mobStore, @NotNull MapObjects mapObjects) {
         this.data = Objects.requireNonNull(data, "data");
         this.mobStore = Objects.requireNonNull(mobStore, "mobStore");
+        this.mapFlags = mapObjects.module().flags();
     }
 
     @Override
     public @NotNull PerkInteractor forPlayer(@NotNull ZombiesPlayer zombiesPlayer) {
-        return new Interactor(data, zombiesPlayer, mobStore);
+        return new Interactor(data, zombiesPlayer, mobStore, mapFlags);
     }
 
     private static class Interactor implements PerkInteractor {
         private final Data data;
         private final ZombiesPlayer zombiesPlayer;
         private final MobStore mobStore;
+        private final Flaggable mapFlags;
 
-        private Interactor(@NotNull Data data, @NotNull ZombiesPlayer zombiesPlayer, @NotNull MobStore mobStore) {
+        private Interactor(@NotNull Data data, @NotNull ZombiesPlayer zombiesPlayer, @NotNull MobStore mobStore,
+                Flaggable mapFlags) {
             this.data = Objects.requireNonNull(data, "data");
             this.zombiesPlayer = Objects.requireNonNull(zombiesPlayer, "zombiesPlayer");
             this.mobStore = Objects.requireNonNull(mobStore, "mobStore");
+            this.mapFlags = mapFlags;
         }
 
         @Override
@@ -94,9 +108,24 @@ public boolean leftClick() {
                     return false;
                 }
 
-                double angle = feetPos.yaw() * (Math.PI / 180);
-                hit.entity.damage(DamageType.fromPlayer(player), data.damage, data.bypassArmor);
-                hit.entity.takeKnockback(data.knockback, Math.sin(angle), -Math.cos(angle));
+                PhantazmMob hitMob = mobStore.getMob(hit.entity().getUuid());
+                if ((mapFlags.hasFlag(Flags.INSTA_KILL) || zombiesPlayer.flags().hasFlag(Flags.INSTA_KILL)) &&
+                        (hitMob != null && !hitMob.model().getExtraNode()
+                                .getBooleanOrDefault(false, ExtraNodeKeys.RESIST_INSTAKILL))) {
+                    hit.entity.kill();
+                }
+                else {
+                    double angle = feetPos.yaw() * (Math.PI / 180);
+                    hit.entity.damage(DamageType.fromPlayer(player), data.damage, data.bypassArmor);
+                    hit.entity.takeKnockback(data.knockback, Math.sin(angle), -Math.cos(angle));
+                }
+
+                PlayerCoins coins = zombiesPlayer.module().getCoins();
+                Collection<Transaction.Modifier> modifiers = zombiesPlayer.module().compositeTransactionModifiers()
+                        .modifiers(ModifierSourceGroups.MOB_COIN_GAIN);
+
+                coins.runTransaction(new Transaction(modifiers, data.coins)).applyIfAffordable(coins);
+
                 return true;
             }).orElse(false);
         }
@@ -112,6 +141,7 @@ public record Data(@Description("The reach of this weapon") double reach,
                        @Description("The damage it does on a successful hit") float damage,
                        @Description("The amount of knockback the weapon deals; 0.4 is the vanilla knockback from an " +
                                "unarmed hand") float knockback,
+                       @Description("The number of coins to give on a successful hit.") int coins,
                        @Description("Whether damage from this weapon should bypass enemy armor") boolean bypassArmor) {
     }
 
diff --git a/zombies/src/main/java/org/phantazm/zombies/kill/BasicPlayerKills.java b/zombies/src/main/java/org/phantazm/zombies/kill/BasicPlayerKills.java
index 61f17076b..949ac5420 100644
--- a/zombies/src/main/java/org/phantazm/zombies/kill/BasicPlayerKills.java
+++ b/zombies/src/main/java/org/phantazm/zombies/kill/BasicPlayerKills.java
@@ -2,13 +2,24 @@
 
 import org.jetbrains.annotations.NotNull;
 import org.phantazm.mob.PhantazmMob;
+import org.phantazm.stats.zombies.ZombiesPlayerMapStats;
+
+import java.util.Objects;
 
 public class BasicPlayerKills implements PlayerKills {
+
+    private final ZombiesPlayerMapStats stats;
+
     private int kills = 0;
 
+    public BasicPlayerKills(@NotNull ZombiesPlayerMapStats stats) {
+        this.stats = Objects.requireNonNull(stats, "stats");
+    }
+
     @Override
     public void onKill(@NotNull PhantazmMob mob) {
         ++kills;
+        stats.setKills(stats.getKills() + 1);
     }
 
     @Override
diff --git a/zombies/src/main/java/org/phantazm/zombies/leaderboard/BestTimeLeaderboard.java b/zombies/src/main/java/org/phantazm/zombies/leaderboard/BestTimeLeaderboard.java
new file mode 100644
index 000000000..835c3b56a
--- /dev/null
+++ b/zombies/src/main/java/org/phantazm/zombies/leaderboard/BestTimeLeaderboard.java
@@ -0,0 +1,108 @@
+package org.phantazm.zombies.leaderboard;
+
+import net.kyori.adventure.key.Key;
+import net.kyori.adventure.text.Component;
+import org.jetbrains.annotations.NotNull;
+import org.phantazm.core.hologram.Hologram;
+import org.phantazm.core.player.PlayerViewProvider;
+import org.phantazm.core.time.TickFormatter;
+import org.phantazm.stats.zombies.BestTime;
+import org.phantazm.stats.zombies.ZombiesDatabase;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+import java.util.Objects;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.Future;
+
+public class BestTimeLeaderboard {
+
+    private static final Logger LOGGER = LoggerFactory.getLogger(BestTimeLeaderboard.class);
+
+    private final ZombiesDatabase database;
+
+    private final Hologram hologram;
+
+    private final Component mapName;
+
+    private final Key mapKey;
+
+    private final TickFormatter tickFormatter;
+
+    private final PlayerViewProvider viewProvider;
+
+    private final int maxLength;
+
+    private final Collection<Future<?>> nameFutures = new ArrayList<>();
+
+    private Future<?> bestTimesFuture = null;
+
+    public BestTimeLeaderboard(@NotNull ZombiesDatabase database, @NotNull Hologram hologram,
+            @NotNull Component mapName, @NotNull Key mapKey, @NotNull TickFormatter tickFormatter,
+            @NotNull PlayerViewProvider viewProvider, int maxLength) {
+        this.database = Objects.requireNonNull(database, "database");
+        this.hologram = Objects.requireNonNull(hologram, "hologram");
+        this.mapName = Objects.requireNonNull(mapName, "mapName");
+        this.mapKey = Objects.requireNonNull(mapKey, "mapKey");
+        this.tickFormatter = Objects.requireNonNull(tickFormatter, "tickFormatter");
+        this.viewProvider = Objects.requireNonNull(viewProvider, "viewProvider");
+        this.maxLength = maxLength;
+    }
+
+    public void start() {
+        hologram.add(Component.textOfChildren(Component.text("Zombies - "), mapName));
+        for (int i = 0; i < maxLength; ++i) {
+            hologram.add(Component.text((i + 1) + ". - Loading..."));
+        }
+
+        bestTimesFuture = database.getBestTimes(mapKey).whenComplete(((bestTimes, throwable) -> {
+            if (throwable != null) {
+                LOGGER.warn("Failed to fetch best times", throwable);
+                return;
+            }
+
+            updateBestTimes(bestTimes);
+        }));
+    }
+
+    public void updateBestTimes(@NotNull List<BestTime> bestTimes) {
+        while (hologram.size() != bestTimes.size() + 1) {
+            hologram.remove(hologram.size() - 1);
+        }
+
+        for (int i = 0; i < bestTimes.size(); ++i) {
+            BestTime time = bestTimes.get(i);
+            Component timeComponent = Component.text(tickFormatter.format(time.time()));
+            hologram.set(i, Component.textOfChildren(Component.text((i + 1) + ". - Loading... - "), timeComponent));
+
+            int finalI = i;
+            CompletableFuture<?> future =
+                    viewProvider.fromUUID(time.uuid()).getDisplayName().whenComplete((displayName, throwable) -> {
+                        if (throwable != null) {
+                            LOGGER.warn("Failed to fetch display name for {}", time.uuid());
+                            return;
+                        }
+
+                        hologram.set(finalI,
+                                Component.textOfChildren(Component.text((finalI + 1) + ". - "), displayName,
+                                        Component.text(" - "), timeComponent));
+                    });
+            nameFutures.add(future);
+        }
+    }
+
+    public void end() {
+        if (bestTimesFuture != null) {
+            bestTimesFuture.cancel(true);
+        }
+
+        for (Future<?> future : nameFutures) {
+            future.cancel(true);
+        }
+        nameFutures.clear();
+    }
+
+}
diff --git a/zombies/src/main/java/org/phantazm/zombies/listener/PhantazmMobDeathListener.java b/zombies/src/main/java/org/phantazm/zombies/listener/PhantazmMobDeathListener.java
index ac70f1f44..61a89511a 100644
--- a/zombies/src/main/java/org/phantazm/zombies/listener/PhantazmMobDeathListener.java
+++ b/zombies/src/main/java/org/phantazm/zombies/listener/PhantazmMobDeathListener.java
@@ -41,7 +41,7 @@ public class PhantazmMobDeathListener extends PhantazmMobEventListener<EntityDea
     private static final Vec OFFSET = new Vec(0.5, 0, 0.5);
 
     private final KeyParser keyParser;
-    private final Supplier<? extends Optional<Round>> roundSupplier;
+    private final Supplier<Optional<Round>> roundSupplier;
     private final PowerupHandler powerupHandler;
 
     private final BoundedTracker<Room> roomTracker;
@@ -49,7 +49,7 @@ public class PhantazmMobDeathListener extends PhantazmMobEventListener<EntityDea
     private final Map<? super UUID, ? extends ZombiesPlayer> playerMap;
 
     public PhantazmMobDeathListener(@NotNull KeyParser keyParser, @NotNull Instance instance,
-            @NotNull MobStore mobStore, @NotNull Supplier<? extends Optional<Round>> roundSupplier,
+            @NotNull MobStore mobStore, @NotNull Supplier<Optional<Round>> roundSupplier,
             @NotNull PowerupHandler powerupHandler, @NotNull BoundedTracker<Room> roomTracker,
             @NotNull BoundedTracker<Window> windowTracker,
             @NotNull Map<? super UUID, ? extends ZombiesPlayer> playerMap) {
@@ -116,21 +116,35 @@ private void trySpawnPowerup(Entity entity) {
 
             Window nearestWindow = windowOptional.get();
             Bounds3I frameRegion = nearestWindow.getWindowInfo().frameRegion();
-            Point windowCenter = nearestWindow.center();
-            Point toWindow = windowCenter.sub(position);
+            Point center = nearestWindow.getCenter();
 
-            Vec axis = new Vec(Integer.signum((int)Math.rint(toWindow.x())), 0,
-                    Integer.signum((int)Math.rint(toWindow.z())));
+            boolean xSmaller = frameRegion.lengthX() < frameRegion.lengthZ();
 
-            Vec mulVec = new Vec(Math.abs(axis.x()) * (frameRegion.lengthX() / 2D), 0,
-                    Math.abs(axis.z()) * (frameRegion.lengthZ() / 2D));
+            Vec normal = new Vec(xSmaller ? 1 : 0, 0, xSmaller ? 0 : 1);
 
-            Point spawnCandidate = windowCenter.add(axis.mul(mulVec)).add(axis.mul(OFFSET));
-            if (roomTracker.atPoint(spawnCandidate).isEmpty()) {
-                LOGGER.warn("Tried to adjust powerup location to " + spawnCandidate + ", but it is not inside a room");
+            normal = normal.mul(xSmaller ? frameRegion.lengthX() / 2.0 : frameRegion.lengthZ() / 2.0)
+                    .add(OFFSET.mul(normal));
+
+            Vec otherNormal = normal.mul(-1);
+
+            Vec targetNormal;
+            if (roomTracker.atPoint(center.add(normal)).isPresent()) {
+                targetNormal = normal;
+            }
+            else if (roomTracker.atPoint(center.add(otherNormal)).isPresent()) {
+                targetNormal = otherNormal;
+            }
+            else {
+                targetNormal = normal;
+                LOGGER.warn("Unable to find matching room at window near " + center);
+            }
+
+            Point test = seekDown(center.add(targetNormal));
+            if (roomTracker.atPoint(test).isEmpty()) {
+                LOGGER.warn("Spawning powerup outside of a room");
             }
 
-            powerupHandler.spawn(key, seekDown(spawnCandidate));
+            powerupHandler.spawn(key, test);
         }
     }
 
diff --git a/zombies/src/main/java/org/phantazm/zombies/listener/PlayerDamageEventListener.java b/zombies/src/main/java/org/phantazm/zombies/listener/PlayerDamageEventListener.java
index 79fe9a735..e28f101db 100644
--- a/zombies/src/main/java/org/phantazm/zombies/listener/PlayerDamageEventListener.java
+++ b/zombies/src/main/java/org/phantazm/zombies/listener/PlayerDamageEventListener.java
@@ -1,6 +1,7 @@
 package org.phantazm.zombies.listener;
 
 import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.format.NamedTextColor;
 import net.minestom.server.coordinate.Pos;
 import net.minestom.server.entity.Entity;
 import net.minestom.server.entity.Player;
@@ -13,6 +14,7 @@
 import org.jetbrains.annotations.NotNull;
 import org.phantazm.mob.PhantazmMob;
 import org.phantazm.zombies.Flags;
+import org.phantazm.zombies.damage.ZombiesDamageType;
 import org.phantazm.zombies.event.ZombiesPlayerDeathEvent;
 import org.phantazm.zombies.map.objects.MapObjects;
 import org.phantazm.zombies.player.ZombiesPlayer;
@@ -98,6 +100,8 @@ private Component getKiller(@NotNull EntityDamageEvent event) {
         else if (damageType instanceof EntityProjectileDamage projectileDamage) {
             Entity shooter = projectileDamage.getShooter();
             return getEntityName(Objects.requireNonNullElseGet(shooter, projectileDamage::getProjectile));
+        } else if (damageType.getIdentifier().equals(ZombiesDamageType.BOMBING.getIdentifier())) {
+            return Component.text("Bombing", NamedTextColor.DARK_RED);
         }
 
         return null;
diff --git a/zombies/src/main/java/org/phantazm/zombies/listener/PlayerQuitListener.java b/zombies/src/main/java/org/phantazm/zombies/listener/PlayerQuitListener.java
index 3fc881a8d..76b8ec886 100644
--- a/zombies/src/main/java/org/phantazm/zombies/listener/PlayerQuitListener.java
+++ b/zombies/src/main/java/org/phantazm/zombies/listener/PlayerQuitListener.java
@@ -4,8 +4,6 @@
 import net.minestom.server.instance.Instance;
 import org.jetbrains.annotations.NotNull;
 import org.phantazm.zombies.player.ZombiesPlayer;
-import org.phantazm.zombies.player.state.ZombiesPlayerStateKeys;
-import org.phantazm.zombies.player.state.context.NoContext;
 import org.phantazm.zombies.scene.LeaveHandler;
 
 import java.util.Collections;
@@ -25,6 +23,7 @@ public PlayerQuitListener(@NotNull Instance instance,
 
     @Override
     protected void accept(@NotNull ZombiesPlayer zombiesPlayer, @NotNull PlayerDisconnectEvent event) {
-        leaveHandler.leave(Collections.singleton(zombiesPlayer.module().getPlayerView().getUUID()));
+        leaveHandler.leave(Collections.singleton(zombiesPlayer.module().getPlayerView().getUUID())).executor()
+                .ifPresent(Runnable::run);
     }
 }
diff --git a/zombies/src/main/java/org/phantazm/zombies/map/Spawnpoint.java b/zombies/src/main/java/org/phantazm/zombies/map/Spawnpoint.java
index 19c0feda3..558acd7a1 100644
--- a/zombies/src/main/java/org/phantazm/zombies/map/Spawnpoint.java
+++ b/zombies/src/main/java/org/phantazm/zombies/map/Spawnpoint.java
@@ -12,7 +12,6 @@
 import org.phantazm.mob.PhantazmMob;
 import org.phantazm.mob.spawner.MobSpawner;
 import org.phantazm.zombies.player.ZombiesPlayer;
-import org.phantazm.zombies.player.ZombiesPlayerModule;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -85,10 +84,18 @@ public Spawnpoint(@NotNull Point mapOrigin, @NotNull SpawnpointInfo spawnInfo, @
             this.linkedWindow = null;
         }
 
-        this.linkedRoom = roomTracker.atPoint(spawnPoint).orElse(null);
+        Room linkedRoom = roomTracker.atPoint(spawnPoint).orElse(null);
         if (linkedRoom == null && linkedWindow == null) {
-            LOGGER.warn("No linked room or window found for spawnpoint at ~" + spawnPoint);
+            Optional<Room> room = roomTracker.closestInRangeToBounds(spawnPoint, 1, 1, 10);
+            if (room.isEmpty()) {
+                LOGGER.warn("No linked room or window found for spawnpoint at ~" + spawnPoint);
+            }
+            else {
+                linkedRoom = room.get();
+            }
         }
+
+        this.linkedRoom = linkedRoom;
     }
 
     public @NotNull Point spawnPoint() {
@@ -130,12 +137,11 @@ else if (linkedRoom != null && !linkedRoom.isOpen()) {
         double slaSquared = spawnrule.slaSquared();
         boolean inRange = false;
         for (ZombiesPlayer player : zombiesPlayers) {
-            ZombiesPlayerModule module = player.module();
-            if (!(module.getMeta().canTriggerSLA())) {
+            if (!player.canTriggerSLA()) {
                 continue;
             }
 
-            Optional<Player> playerOptional = module.getPlayerView().getPlayer();
+            Optional<Player> playerOptional = player.getPlayer();
             if (playerOptional.isPresent()) {
                 if (playerOptional.get().getPosition().distanceSquared(spawnPoint) < slaSquared) {
                     inRange = true;
diff --git a/zombies/src/main/java/org/phantazm/zombies/map/Window.java b/zombies/src/main/java/org/phantazm/zombies/map/Window.java
index 9bac8aacc..5553db77e 100644
--- a/zombies/src/main/java/org/phantazm/zombies/map/Window.java
+++ b/zombies/src/main/java/org/phantazm/zombies/map/Window.java
@@ -69,9 +69,7 @@ public Window(@NotNull Point mapOrigin, @NotNull Instance instance, @NotNull Win
             throw new IllegalArgumentException("Zero-volume window");
         }
 
-        Optional<Room> closestRoom =
-                roomTracker.closestInRangeToBounds(center.sub(0, frame.lengthY() / 2D, 0), frame.lengthX(),
-                        frame.lengthY(), frame.lengthZ(), 10);
+        Optional<Room> closestRoom = roomTracker.closestInRangeToBounds(center, 10);
         if (closestRoom.isEmpty()) {
             this.linkedRoom = null;
             LOGGER.warn("No linkable room found within 10 blocks for window at ~" + center);
diff --git a/zombies/src/main/java/org/phantazm/zombies/map/ZombiesMap.java b/zombies/src/main/java/org/phantazm/zombies/map/ZombiesMap.java
index f69be2d19..db51fbbac 100644
--- a/zombies/src/main/java/org/phantazm/zombies/map/ZombiesMap.java
+++ b/zombies/src/main/java/org/phantazm/zombies/map/ZombiesMap.java
@@ -67,7 +67,6 @@ public ZombiesMap(@NotNull MapObjects mapObjects, @NotNull SongPlayer songPlayer
 
     @Override
     public void tick(long time) {
-        mapObjects.tick(time);
         songPlayer.tick(time);
         powerupHandler.tick(time);
         roundHandler.tick(time);
diff --git a/zombies/src/main/java/org/phantazm/zombies/map/action/door/DoorSendOpenedRoomsAction.java b/zombies/src/main/java/org/phantazm/zombies/map/action/door/DoorSendOpenedRoomsAction.java
index 7c1ee32aa..c3127f4c4 100644
--- a/zombies/src/main/java/org/phantazm/zombies/map/action/door/DoorSendOpenedRoomsAction.java
+++ b/zombies/src/main/java/org/phantazm/zombies/map/action/door/DoorSendOpenedRoomsAction.java
@@ -3,13 +3,16 @@
 import com.github.steanky.element.core.annotation.DataObject;
 import com.github.steanky.element.core.annotation.FactoryMethod;
 import com.github.steanky.element.core.annotation.Model;
+import com.github.steanky.ethylene.core.ConfigElement;
+import com.github.steanky.ethylene.core.ConfigPrimitive;
+import com.github.steanky.ethylene.mapper.annotation.Default;
 import net.kyori.adventure.key.Key;
 import net.kyori.adventure.text.Component;
-import net.kyori.adventure.text.TextComponent;
-import net.kyori.adventure.text.format.Style;
+import net.kyori.adventure.text.minimessage.MiniMessage;
 import net.kyori.adventure.title.TitlePart;
 import net.minestom.server.instance.Instance;
 import org.jetbrains.annotations.NotNull;
+import org.phantazm.core.ComponentUtils;
 import org.phantazm.zombies.map.Door;
 import org.phantazm.zombies.map.Room;
 import org.phantazm.zombies.map.action.Action;
@@ -18,10 +21,7 @@
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
-import java.util.List;
-import java.util.Map;
-import java.util.Objects;
-import java.util.Optional;
+import java.util.*;
 import java.util.function.Supplier;
 
 @Model("zombies.map.door.action.send_opened_rooms")
@@ -48,27 +48,24 @@ public void perform(@NotNull Door door) {
             lastInteractorOptional.get().module().getPlayerView().getUsername().whenComplete((username, err) -> {
                 if (err != null) {
                     LOGGER.warn("Error resolving display name of door-opening player", err);
+                    return;
                 }
 
                 if (username != null) {
-                    instance.sendTitlePart(data.openerNameTitlePart,
-                            Component.text().style(data.openerNameFormatStyle).append(Component.text(username))
-                                    .build());
+                    instance.sendTitlePart(data.nameTitlePart,
+                            ComponentUtils.tryFormat(data.nameFormatString, username));
                 }
                 else {
                     LOGGER.warn("Null username");
-                    instance.sendTitlePart(data.openerNameTitlePart, UNKNOWN_COMPONENT);
+                    instance.sendTitlePart(data.nameTitlePart, UNKNOWN_COMPONENT);
                 }
             });
         }
         else {
             LOGGER.warn("Interacting player was null, cannot announce opener");
-            instance.sendTitlePart(data.openerNameTitlePart, UNKNOWN_COMPONENT);
+            instance.sendTitlePart(data.nameTitlePart, UNKNOWN_COMPONENT);
         }
 
-        TextComponent.Builder builder =
-                Component.text().style(data.openedRoomsFormatStyle).append(Component.text("opened "));
-
         Map<? super Key, ? extends Room> roomMap = mapObjects.get().roomMap();
         List<Room> opensTo =
                 door.doorInfo().opensTo().stream().map(target -> (Room)roomMap.get(target)).filter(room -> {
@@ -79,30 +76,36 @@ public void perform(@NotNull Door door) {
                     return !room.isOpen();
                 }).toList();
 
+        StringBuilder builder = new StringBuilder();
         boolean appendedRoom = false;
         for (int i = 0; i < opensTo.size(); i++) {
             Room room = opensTo.get(i);
 
-            builder.append(room.getRoomInfo().displayName());
+            builder.append(MiniMessage.miniMessage().serialize(room.getRoomInfo().displayName()));
             appendedRoom = true;
 
             if (i < opensTo.size() - 1) {
-                builder.append(Component.text(", "));
+                builder.append(data.separator);
             }
         }
 
         if (!appendedRoom) {
-            builder.append(UNKNOWN_COMPONENT);
+            builder.append("...");
         }
 
-        instance.sendTitlePart(data.openedRoomsTitlePart, builder.build());
+        instance.sendTitlePart(data.openedRoomsTitlePart,
+                ComponentUtils.tryFormat(data.openedRoomsFormatString, builder.toString()));
     }
 
     @DataObject
-    public record Data(@NotNull Style openerNameFormatStyle,
-                       @NotNull Style openedRoomsFormatStyle,
-                       @NotNull TitlePart<Component> openerNameTitlePart,
+    public record Data(@NotNull String nameFormatString,
+                       @NotNull String openedRoomsFormatString,
+                       @NotNull String separator,
+                       @NotNull TitlePart<Component> nameTitlePart,
                        @NotNull TitlePart<Component> openedRoomsTitlePart) {
-
+        @Default("separator")
+        public static ConfigElement separatorDefault() {
+            return ConfigPrimitive.of(", ");
+        }
     }
 }
diff --git a/zombies/src/main/java/org/phantazm/zombies/map/action/round/AnnounceRoundAction.java b/zombies/src/main/java/org/phantazm/zombies/map/action/round/AnnounceRoundAction.java
index 69bbcc94c..9781a8008 100644
--- a/zombies/src/main/java/org/phantazm/zombies/map/action/round/AnnounceRoundAction.java
+++ b/zombies/src/main/java/org/phantazm/zombies/map/action/round/AnnounceRoundAction.java
@@ -3,6 +3,9 @@
 import com.github.steanky.element.core.annotation.DataObject;
 import com.github.steanky.element.core.annotation.FactoryMethod;
 import com.github.steanky.element.core.annotation.Model;
+import com.github.steanky.ethylene.core.ConfigElement;
+import com.github.steanky.ethylene.core.ConfigPrimitive;
+import com.github.steanky.ethylene.mapper.annotation.Default;
 import net.kyori.adventure.text.Component;
 import net.kyori.adventure.text.minimessage.MiniMessage;
 import net.kyori.adventure.title.TitlePart;
@@ -11,6 +14,7 @@
 import org.phantazm.zombies.map.Round;
 import org.phantazm.zombies.map.action.Action;
 
+import java.util.IllegalFormatException;
 import java.util.Objects;
 
 /**
@@ -35,8 +39,8 @@ public AnnounceRoundAction(@NotNull Data data, @NotNull Instance instance) {
 
     @Override
     public void perform(@NotNull Round round) {
-        instance.sendTitlePart(data.titlePart,
-                MiniMessage.miniMessage().deserialize(data.formatMessage.formatted(round.getRoundInfo().round())));
+        String message = data.format ? data.formatMessage.formatted(round.getRoundInfo().round()) : data.formatMessage;
+        instance.sendTitlePart(data.titlePart, MiniMessage.miniMessage().deserialize(message));
     }
 
     /**
@@ -45,8 +49,13 @@ public void perform(@NotNull Round round) {
      * @param formatMessage the MiniMessage-compatible string. The format specifier %d will be replaced by the current
      *                      round number (1-indexed)
      * @param titlePart     which Component-accepting {@link TitlePart} to send the message to
+     * @param format        whether or not to format the message with the current round
      */
     @DataObject
-    public record Data(@NotNull String formatMessage, @NotNull TitlePart<Component> titlePart) {
+    public record Data(@NotNull String formatMessage, @NotNull TitlePart<Component> titlePart, boolean format) {
+        @Default("format")
+        public static ConfigElement formatDefault() {
+            return ConfigPrimitive.of(true);
+        }
     }
 }
diff --git a/zombies/src/main/java/org/phantazm/zombies/map/action/round/PlaySoundAction.java b/zombies/src/main/java/org/phantazm/zombies/map/action/round/PlaySoundAction.java
index 1a551df35..c928e2870 100644
--- a/zombies/src/main/java/org/phantazm/zombies/map/action/round/PlaySoundAction.java
+++ b/zombies/src/main/java/org/phantazm/zombies/map/action/round/PlaySoundAction.java
@@ -30,8 +30,10 @@ public PlaySoundAction(@NotNull Data data, @NotNull Random random,
     @Override
     public void perform(@NotNull Round round) {
         for (ZombiesPlayer zombiesPlayer : playerMap.values()) {
-            zombiesPlayer.getPlayer()
-                    .ifPresent(player -> player.playSound(Sound.sound(data.sound).seed(random.nextLong()).build()));
+            if (!zombiesPlayer.hasQuit()) {
+                zombiesPlayer.getPlayer()
+                        .ifPresent(player -> player.playSound(Sound.sound(data.sound).seed(random.nextLong()).build()));
+            }
         }
     }
 
diff --git a/zombies/src/main/java/org/phantazm/zombies/map/action/round/SelectBombedRoom.java b/zombies/src/main/java/org/phantazm/zombies/map/action/round/SelectBombedRoom.java
index 15e1f40be..698fd197d 100644
--- a/zombies/src/main/java/org/phantazm/zombies/map/action/round/SelectBombedRoom.java
+++ b/zombies/src/main/java/org/phantazm/zombies/map/action/round/SelectBombedRoom.java
@@ -11,17 +11,18 @@
 import net.minestom.server.attribute.AttributeModifier;
 import net.minestom.server.attribute.AttributeOperation;
 import net.minestom.server.coordinate.Point;
-import net.minestom.server.entity.Player;
 import net.minestom.server.entity.damage.DamageType;
 import net.minestom.server.instance.Instance;
 import net.minestom.server.potion.Potion;
 import net.minestom.server.potion.PotionEffect;
 import net.minestom.server.potion.TimedPotion;
 import org.jetbrains.annotations.NotNull;
+import org.phantazm.commons.CancellableState;
 import org.phantazm.commons.TickableTask;
 import org.phantazm.core.particle.ParticleWrapper;
 import org.phantazm.zombies.Attributes;
 import org.phantazm.zombies.Flags;
+import org.phantazm.zombies.damage.ZombiesDamageType;
 import org.phantazm.zombies.map.Room;
 import org.phantazm.zombies.map.Round;
 import org.phantazm.zombies.map.action.Action;
@@ -43,6 +44,7 @@ public class SelectBombedRoom implements Action<Round> {
     private final Instance instance;
     private final ParticleWrapper particle;
     private final Map<? super UUID, ? extends ZombiesPlayer> playerMap;
+    private final UUID stateId;
 
     private final List<TargetedAttribute> modifiers;
 
@@ -65,6 +67,7 @@ public SelectBombedRoom(@NotNull Data data, @NotNull Supplier<? extends MapObjec
         }
 
         this.modifiers = List.copyOf(modifiers);
+        this.stateId = UUID.randomUUID();
     }
 
     @Override
@@ -95,6 +98,13 @@ public boolean isFinished() {
                 return finished;
             }
 
+            @Override
+            public void end() {
+                for (ZombiesPlayer zombiesPlayer : playerMap.values()) {
+                    zombiesPlayer.removeCancellable(stateId);
+                }
+            }
+
             @Override
             public void tick(long time) {
                 if (!flagSet) {
@@ -108,6 +118,27 @@ public void tick(long time) {
                     room.flags().clearFlag(Flags.BOMBED_ROOM);
                     flagSet = false;
                     finished = true;
+
+                    for (ZombiesPlayer zombiesPlayer : playerMap.values()) {
+                        zombiesPlayer.getPlayer().ifPresent(player -> {
+                            if (!zombiesPlayer.canDoGenericActions()) {
+                                zombiesPlayer.removeCancellable(stateId);
+                            }
+                            else {
+                                Optional<Room> roomOptional = objects.roomTracker().atPoint(player.getPosition());
+                                if (roomOptional.isPresent()) {
+                                    Room currentRoom = roomOptional.get();
+                                    if (!currentRoom.flags().hasFlag(Flags.BOMBED_ROOM)) {
+                                        zombiesPlayer.removeCancellable(stateId);
+                                    }
+                                }
+                                else {
+                                    zombiesPlayer.removeCancellable(stateId);
+                                }
+                            }
+                        });
+                    }
+
                     return;
                 }
 
@@ -116,7 +147,7 @@ public void tick(long time) {
 
                 if (++ticks % 4 == 0) {
                     for (ZombiesPlayer zombiesPlayer : playerMap.values()) {
-                        if (!zombiesPlayer.isAlive()) {
+                        if (!zombiesPlayer.canDoGenericActions() || zombiesPlayer.flags().hasFlag(Flags.GODMODE)) {
                             continue;
                         }
 
@@ -125,20 +156,20 @@ public void tick(long time) {
                             if (roomOptional.isPresent()) {
                                 Room currentRoom = roomOptional.get();
                                 if (currentRoom == room) {
-                                    applyModifiers(player);
+                                    applyModifiers(zombiesPlayer);
 
                                     if (ticks % 40 == 0) {
                                         player.sendMessage(data.inAreaMessage);
                                     }
 
-                                    player.damage(DamageType.VOID, data.damage, true);
+                                    player.damage(ZombiesDamageType.BOMBING, data.damage, true);
                                 }
                                 else if (!currentRoom.flags().hasFlag(Flags.BOMBED_ROOM)) {
-                                    removeModifiers(player);
+                                    zombiesPlayer.removeCancellable(stateId);
                                 }
                             }
                             else {
-                                removeModifiers(player);
+                                zombiesPlayer.removeCancellable(stateId);
                             }
                         });
                     }
@@ -147,28 +178,34 @@ else if (!currentRoom.flags().hasFlag(Flags.BOMBED_ROOM)) {
         }, (long)data.gracePeriod * MinecraftServer.TICK_MS);
     }
 
-    private void applyModifiers(Player player) {
-        for (TargetedAttribute modifier : modifiers) {
-            player.getAttribute(Objects.requireNonNullElse(Attribute.fromKey(modifier.attribute), Attributes.NIL))
-                    .addModifier(modifier.modifier);
-        }
-
-        for (TimedPotion potion : player.getActiveEffects()) {
-            if (potion.getPotion() == NAUSEA) {
-                return;
-            }
-        }
+    private void applyModifiers(ZombiesPlayer player) {
+        player.registerCancellable(CancellableState.named(stateId, () -> {
+            player.getPlayer().ifPresent(actualPlayer -> {
+                for (TargetedAttribute modifier : modifiers) {
+                    actualPlayer.getAttribute(
+                                    Objects.requireNonNullElse(Attribute.fromKey(modifier.attribute), Attributes.NIL))
+                            .addModifier(modifier.modifier);
+                }
 
-        player.addEffect(NAUSEA);
-    }
+                for (TimedPotion potion : actualPlayer.getActiveEffects()) {
+                    if (potion.getPotion() == NAUSEA) {
+                        return;
+                    }
+                }
 
-    private void removeModifiers(Player player) {
-        for (TargetedAttribute modifier : modifiers) {
-            player.getAttribute(Objects.requireNonNullElse(Attribute.fromKey(modifier.attribute), Attributes.NIL))
-                    .removeModifier(modifier.modifier.getId());
-        }
+                actualPlayer.addEffect(NAUSEA);
+            });
+        }, () -> {
+            player.getPlayer().ifPresent(actualPlayer -> {
+                for (TargetedAttribute modifier : modifiers) {
+                    actualPlayer.getAttribute(
+                                    Objects.requireNonNullElse(Attribute.fromKey(modifier.attribute), Attributes.NIL))
+                            .removeModifier(modifier.modifier.getId());
+                }
 
-        player.removeEffect(PotionEffect.NAUSEA);
+                actualPlayer.removeEffect(PotionEffect.NAUSEA);
+            });
+        }), false);
     }
 
     private Vec3D randomPoint(Point origin, Room room) {
diff --git a/zombies/src/main/java/org/phantazm/zombies/map/handler/BasicRoundHandler.java b/zombies/src/main/java/org/phantazm/zombies/map/handler/BasicRoundHandler.java
index 94f15ec9f..21744fb43 100644
--- a/zombies/src/main/java/org/phantazm/zombies/map/handler/BasicRoundHandler.java
+++ b/zombies/src/main/java/org/phantazm/zombies/map/handler/BasicRoundHandler.java
@@ -2,12 +2,12 @@
 
 import org.jetbrains.annotations.NotNull;
 import org.phantazm.zombies.map.Round;
+import org.phantazm.zombies.player.ZombiesPlayer;
 
-import java.util.List;
-import java.util.Objects;
-import java.util.Optional;
+import java.util.*;
 
 public class BasicRoundHandler implements RoundHandler {
+    private final Collection<? extends ZombiesPlayer> zombiesPlayers;
     private final List<Round> rounds;
 
     private Round currentRound;
@@ -15,7 +15,8 @@ public class BasicRoundHandler implements RoundHandler {
 
     private boolean hasEnded;
 
-    public BasicRoundHandler(@NotNull List<Round> rounds) {
+    public BasicRoundHandler(@NotNull Collection<? extends ZombiesPlayer> zombiesPlayers, @NotNull List<Round> rounds) {
+        this.zombiesPlayers = Objects.requireNonNull(zombiesPlayers, "zombiesPlayers");
         this.rounds = Objects.requireNonNull(rounds, "rounds");
 
         if (rounds.isEmpty()) {
@@ -29,6 +30,11 @@ public void tick(long time) {
             currentRound.tick(time);
 
             if (!currentRound.isActive()) {
+                for (ZombiesPlayer zombiesPlayer : zombiesPlayers) {
+                    zombiesPlayer.module().getStats()
+                            .setRoundsSurvived(zombiesPlayer.module().getStats().getRoundsSurvived() + 1);
+                }
+
                 if (++roundIndex < rounds.size()) {
                     currentRound = rounds.get(roundIndex);
                     currentRound.startRound(time);
diff --git a/zombies/src/main/java/org/phantazm/zombies/map/handler/BasicWindowHandler.java b/zombies/src/main/java/org/phantazm/zombies/map/handler/BasicWindowHandler.java
index deecf114e..feb232c33 100644
--- a/zombies/src/main/java/org/phantazm/zombies/map/handler/BasicWindowHandler.java
+++ b/zombies/src/main/java/org/phantazm/zombies/map/handler/BasicWindowHandler.java
@@ -110,11 +110,33 @@ public void tick(long time) {
         while (repairOperationIterator.hasNext()) {
             RepairOperation repairOperation = repairOperationIterator.next();
             ZombiesPlayer zombiesPlayer = repairOperation.zombiesPlayer;
-            if (!zombiesPlayer.isAlive()) {
+            if (!zombiesPlayer.canRepairWindow()) {
                 repairOperationIterator.remove();
                 continue;
             }
 
+            {
+                Optional<Player> playerOptional = zombiesPlayer.getPlayer();
+                if (playerOptional.isEmpty()) {
+                    repairOperationIterator.remove();
+                    continue;
+                }
+
+                Player player = playerOptional.get();
+                Window targetWindow = repairOperation.window;
+
+                BoundingBox boundingBox = player.getBoundingBox();
+                double width = boundingBox.width();
+                double height = boundingBox.height();
+
+                Optional<Window> windowOptional =
+                        windowTracker.closestInRangeToBounds(player.getPosition(), width, height, repairRadius);
+                if (windowOptional.isEmpty() || windowOptional.get() != targetWindow) {
+                    repairOperationIterator.remove();
+                    continue;
+                }
+            }
+
             long elapsedMS = time - repairOperation.lastRepairTime;
             long elapsedTicks = elapsedMS / MinecraftServer.TICK_MS;
 
diff --git a/zombies/src/main/java/org/phantazm/zombies/map/objects/BasicMapObjects.java b/zombies/src/main/java/org/phantazm/zombies/map/objects/BasicMapObjects.java
index ecb4bd136..eb6233145 100644
--- a/zombies/src/main/java/org/phantazm/zombies/map/objects/BasicMapObjects.java
+++ b/zombies/src/main/java/org/phantazm/zombies/map/objects/BasicMapObjects.java
@@ -5,7 +5,6 @@
 import net.minestom.server.coordinate.Point;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Unmodifiable;
-import org.phantazm.commons.BasicTickTaskScheduler;
 import org.phantazm.commons.TickTaskScheduler;
 import org.phantazm.core.tracker.BoundedTracker;
 import org.phantazm.mob.spawner.MobSpawner;
@@ -36,7 +35,7 @@ public BasicMapObjects(@NotNull List<Spawnpoint> spawnpoints, @NotNull BoundedTr
             @NotNull BoundedTracker<Shop> shops, @NotNull BoundedTracker<Door> doors,
             @NotNull BoundedTracker<Room> rooms, @NotNull List<Round> rounds,
             @NotNull DependencyProvider mapDependencyProvider, @NotNull MobSpawner mobSpawner, @NotNull Point mapOrigin,
-            @NotNull Module module) {
+            @NotNull Module module, @NotNull TickTaskScheduler taskScheduler) {
         this.spawnpoints = List.copyOf(spawnpoints);
         this.rounds = List.copyOf(rounds);
 
@@ -57,7 +56,7 @@ public BasicMapObjects(@NotNull List<Spawnpoint> spawnpoints, @NotNull BoundedTr
 
         this.roomMap = Map.copyOf(map);
         this.mapOrigin = mapOrigin;
-        this.taskScheduler = new BasicTickTaskScheduler();
+        this.taskScheduler = Objects.requireNonNull(taskScheduler, "taskScheduler");
     }
 
     @Override
@@ -119,9 +118,4 @@ public BasicMapObjects(@NotNull List<Spawnpoint> spawnpoints, @NotNull BoundedTr
     public @NotNull TickTaskScheduler taskScheduler() {
         return taskScheduler;
     }
-
-    @Override
-    public void tick(long time) {
-        taskScheduler.tick(time);
-    }
 }
diff --git a/zombies/src/main/java/org/phantazm/zombies/map/objects/BasicMapObjectsSource.java b/zombies/src/main/java/org/phantazm/zombies/map/objects/BasicMapObjectsSource.java
index b876609bd..3f2e301b4 100644
--- a/zombies/src/main/java/org/phantazm/zombies/map/objects/BasicMapObjectsSource.java
+++ b/zombies/src/main/java/org/phantazm/zombies/map/objects/BasicMapObjectsSource.java
@@ -18,7 +18,10 @@
 import net.minestom.server.event.EventNode;
 import net.minestom.server.instance.Instance;
 import net.minestom.server.instance.block.Block;
+import net.minestom.server.scoreboard.Team;
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.phantazm.commons.TickTaskScheduler;
 import org.phantazm.core.ClientBlockHandler;
 import org.phantazm.core.ClientBlockHandlerSource;
 import org.phantazm.core.ElementUtils;
@@ -79,11 +82,13 @@ public BasicMapObjectsSource(@NotNull MapInfo mapInfo, @NotNull ContextManager c
     public @NotNull MapObjects make(@NotNull Instance instance,
             @NotNull Map<? super UUID, ? extends ZombiesPlayer> playerMap,
             @NotNull Supplier<? extends RoundHandler> roundHandlerSupplier, @NotNull MobStore mobStore,
-            @NotNull Wrapper<PowerupHandler> powerupHandler, @NotNull Wrapper<WindowHandler> windowHandler,
-            @NotNull Wrapper<EventNode<Event>> eventNode, @NotNull SongPlayer songPlayer) {
+            @Nullable Team mobNoPushTeam, @NotNull Wrapper<PowerupHandler> powerupHandler,
+            @NotNull Wrapper<WindowHandler> windowHandler, @NotNull Wrapper<EventNode<Event>> eventNode,
+            @NotNull SongPlayer songPlayer, @NotNull TickTaskScheduler tickTaskScheduler, @NotNull Team corpseTeam) {
         Random random = new Random();
         ClientBlockHandler clientBlockHandler = clientBlockHandlerSource.forInstance(instance);
-        SpawnDistributor spawnDistributor = new BasicSpawnDistributor(mobModels::get, random, playerMap.values());
+        SpawnDistributor spawnDistributor =
+                new BasicSpawnDistributor(mobModels::get, random, playerMap.values(), mobNoPushTeam);
 
         Flaggable flaggable = new BasicFlaggable();
         TransactionModifierSource transactionModifierSource = new BasicTransactionModifierSource();
@@ -100,7 +105,7 @@ public BasicMapObjectsSource(@NotNull MapInfo mapInfo, @NotNull ContextManager c
         Module module =
                 new Module(keyParser, instance, random, roundHandlerSupplier, flaggable, transactionModifierSource,
                         slotDistributor, playerMap, respawnPos, mapObjectsWrapper, powerupHandler, windowHandler,
-                        eventNode, mobStore, songPlayer);
+                        eventNode, mobStore, songPlayer, corpseTeam);
 
         DependencyProvider provider = new ModuleDependencyProvider(keyParser, module);
 
@@ -129,7 +134,7 @@ public BasicMapObjectsSource(@NotNull MapInfo mapInfo, @NotNull ContextManager c
 
         MapObjects mapObjects =
                 new BasicMapObjects(spawnpoints, windowTracker, shopTracker, doorTracker, roomTracker, rounds, provider,
-                        mobSpawner, origin, module);
+                        mobSpawner, origin, module, tickTaskScheduler);
         mapObjectsWrapper.set(mapObjects);
 
         return mapObjects;
@@ -274,6 +279,7 @@ public static class Module implements DependencyModule, MapObjects.Module {
         private final Wrapper<EventNode<Event>> eventNode;
         private final MobStore mobStore;
         private final SongPlayer songPlayer;
+        private final Team corpseTeam;
 
         private Module(KeyParser keyParser, Instance instance, Random random,
                 Supplier<? extends RoundHandler> roundHandlerSupplier, Flaggable flaggable,
@@ -281,7 +287,7 @@ private Module(KeyParser keyParser, Instance instance, Random random,
                 Map<? super UUID, ? extends ZombiesPlayer> playerMap, Pos respawnPos,
                 Supplier<? extends MapObjects> mapObjectsSupplier, Wrapper<PowerupHandler> powerupHandler,
                 Wrapper<WindowHandler> windowHandler, Wrapper<EventNode<Event>> eventNode, MobStore mobStore,
-                SongPlayer songPlayer) {
+                SongPlayer songPlayer, Team corpseTeam) {
             this.keyParser = Objects.requireNonNull(keyParser, "keyParser");
             this.instance = Objects.requireNonNull(instance, "instance");
             this.random = Objects.requireNonNull(random, "random");
@@ -297,6 +303,7 @@ private Module(KeyParser keyParser, Instance instance, Random random,
             this.eventNode = Objects.requireNonNull(eventNode, "eventNode");
             this.mobStore = Objects.requireNonNull(mobStore, "mobStore");
             this.songPlayer = Objects.requireNonNull(songPlayer, "songPlayer");
+            this.corpseTeam = Objects.requireNonNull(corpseTeam, "corpseTeam");
         }
 
         @Override
@@ -378,5 +385,10 @@ private Module(KeyParser keyParser, Instance instance, Random random,
         public @NotNull SongPlayer songPlayer() {
             return songPlayer;
         }
+
+        @Override
+        public @NotNull Team corpseTeam() {
+            return corpseTeam;
+        }
     }
 }
diff --git a/zombies/src/main/java/org/phantazm/zombies/map/objects/MapObjects.java b/zombies/src/main/java/org/phantazm/zombies/map/objects/MapObjects.java
index b97f195be..71ca427d5 100644
--- a/zombies/src/main/java/org/phantazm/zombies/map/objects/MapObjects.java
+++ b/zombies/src/main/java/org/phantazm/zombies/map/objects/MapObjects.java
@@ -9,10 +9,11 @@
 import net.minestom.server.event.Event;
 import net.minestom.server.event.EventNode;
 import net.minestom.server.instance.Instance;
+import net.minestom.server.scoreboard.Team;
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
 import org.jetbrains.annotations.Unmodifiable;
 import org.phantazm.commons.TickTaskScheduler;
-import org.phantazm.commons.Tickable;
 import org.phantazm.core.gui.SlotDistributor;
 import org.phantazm.core.sound.SongPlayer;
 import org.phantazm.core.tracker.BoundedTracker;
@@ -29,7 +30,7 @@
 import java.util.*;
 import java.util.function.Supplier;
 
-public interface MapObjects extends Tickable {
+public interface MapObjects {
     @Unmodifiable @NotNull List<Spawnpoint> spawnpoints();
 
     @Unmodifiable @NotNull List<Round> rounds();
@@ -58,8 +59,9 @@ public interface MapObjects extends Tickable {
         @NotNull MapObjects make(@NotNull Instance instance,
                 @NotNull Map<? super UUID, ? extends ZombiesPlayer> playerMap,
                 @NotNull Supplier<? extends RoundHandler> roundHandlerSupplier, @NotNull MobStore mobStore,
-                @NotNull Wrapper<PowerupHandler> powerupHandler, @NotNull Wrapper<WindowHandler> windowHandler,
-                @NotNull Wrapper<EventNode<Event>> eventNode, @NotNull SongPlayer songPlayer);
+                @Nullable Team mobNoPushTeam, @NotNull Wrapper<PowerupHandler> powerupHandler,
+                @NotNull Wrapper<WindowHandler> windowHandler, @NotNull Wrapper<EventNode<Event>> eventNode,
+                @NotNull SongPlayer songPlayer, @NotNull TickTaskScheduler tickTaskScheduler, @NotNull Team corpseTeam);
     }
 
     interface Module {
@@ -94,5 +96,7 @@ interface Module {
         @NotNull MobStore mobStore();
 
         @NotNull SongPlayer songPlayer();
+
+        @NotNull Team corpseTeam();
     }
 }
diff --git a/zombies/src/main/java/org/phantazm/zombies/map/shop/Shop.java b/zombies/src/main/java/org/phantazm/zombies/map/shop/Shop.java
index 46b1863cb..febc73cc8 100644
--- a/zombies/src/main/java/org/phantazm/zombies/map/shop/Shop.java
+++ b/zombies/src/main/java/org/phantazm/zombies/map/shop/Shop.java
@@ -1,11 +1,13 @@
 package org.phantazm.zombies.map.shop;
 
 import net.minestom.server.coordinate.Point;
+import net.minestom.server.entity.Player;
 import net.minestom.server.instance.Instance;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Unmodifiable;
 import org.phantazm.commons.Tickable;
 import org.phantazm.core.tracker.BoundedBase;
+import org.phantazm.zombies.Tags;
 import org.phantazm.zombies.map.ShopInfo;
 import org.phantazm.zombies.map.shop.display.ShopDisplay;
 import org.phantazm.zombies.map.shop.interactor.ShopInteractor;
@@ -13,8 +15,11 @@
 
 import java.util.List;
 import java.util.Objects;
+import java.util.Optional;
 
 public class Shop extends BoundedBase implements Tickable {
+    public static final long SHOP_ACTIVATION_DELAY = 500L;
+
     private final Point mapOrigin;
     private final Instance instance;
     private final ShopInfo shopInfo;
@@ -82,6 +87,16 @@ public void initialize() {
     }
 
     public void handleInteraction(@NotNull PlayerInteraction interaction) {
+        Optional<Player> playerOptional = interaction.player().getPlayer();
+        if (playerOptional.isPresent()) {
+            Player player = playerOptional.get();
+
+            long lastActivate = player.getTag(Tags.LAST_SHOP_ACTIVATE);
+            if (lastActivate != -1 && System.currentTimeMillis() - lastActivate < SHOP_ACTIVATION_DELAY) {
+                return;
+            }
+        }
+
         boolean success = shopInfo.predicateEvaluation().evaluate(predicates, interaction);
         List<ShopInteractor> interactorsToCall = success ? successInteractors : failureInteractors;
 
@@ -92,6 +107,8 @@ public void handleInteraction(@NotNull PlayerInteraction interaction) {
         for (ShopDisplay display : displays) {
             display.update(this, interaction, success);
         }
+
+        playerOptional.ifPresent(player -> player.setTag(Tags.LAST_SHOP_ACTIVATE, System.currentTimeMillis()));
     }
 
     @Override
diff --git a/zombies/src/main/java/org/phantazm/zombies/map/shop/predicate/PlayerInGamePredicate.java b/zombies/src/main/java/org/phantazm/zombies/map/shop/predicate/PlayerInGamePredicate.java
new file mode 100644
index 000000000..1024c7fe4
--- /dev/null
+++ b/zombies/src/main/java/org/phantazm/zombies/map/shop/predicate/PlayerInGamePredicate.java
@@ -0,0 +1,24 @@
+package org.phantazm.zombies.map.shop.predicate;
+
+import com.github.steanky.element.core.annotation.DataObject;
+import com.github.steanky.element.core.annotation.FactoryMethod;
+import com.github.steanky.element.core.annotation.Model;
+import org.jetbrains.annotations.NotNull;
+import org.phantazm.zombies.map.shop.PlayerInteraction;
+
+@Model("zombies.map.shop.predicate.in_game")
+public class PlayerInGamePredicate extends PredicateBase<PlayerInGamePredicate.Data> {
+    @FactoryMethod
+    public PlayerInGamePredicate(@NotNull Data data) {
+        super(data);
+    }
+
+    @Override
+    public boolean canInteract(@NotNull PlayerInteraction interaction) {
+        return interaction.player().module().getMeta().isInGame();
+    }
+
+    @DataObject
+    public record Data() {
+    }
+}
diff --git a/zombies/src/main/java/org/phantazm/zombies/player/BasicZombiesPlayer.java b/zombies/src/main/java/org/phantazm/zombies/player/BasicZombiesPlayer.java
index c5e5bafb6..d35170568 100644
--- a/zombies/src/main/java/org/phantazm/zombies/player/BasicZombiesPlayer.java
+++ b/zombies/src/main/java/org/phantazm/zombies/player/BasicZombiesPlayer.java
@@ -4,6 +4,8 @@
 import net.kyori.adventure.audience.ForwardingAudience;
 import net.minestom.server.entity.Player;
 import org.jetbrains.annotations.NotNull;
+import org.phantazm.commons.CancellableState;
+import org.phantazm.commons.TickTaskScheduler;
 import org.phantazm.core.inventory.InventoryObject;
 import org.phantazm.core.inventory.InventoryProfile;
 import org.phantazm.zombies.Attributes;
@@ -12,19 +14,20 @@
 import org.phantazm.zombies.player.state.context.QuitPlayerStateContext;
 import org.phantazm.zombies.scene.ZombiesScene;
 
-import java.util.List;
-import java.util.Objects;
-import java.util.Optional;
+import java.util.*;
 
 public class BasicZombiesPlayer implements ZombiesPlayer, ForwardingAudience {
-
     private final ZombiesScene scene;
-
     private final ZombiesPlayerModule module;
+    private final Map<UUID, CancellableState> stateMap;
+    private final TickTaskScheduler taskScheduler;
 
-    public BasicZombiesPlayer(@NotNull ZombiesScene scene, @NotNull ZombiesPlayerModule module) {
+    public BasicZombiesPlayer(@NotNull ZombiesScene scene, @NotNull ZombiesPlayerModule module,
+            @NotNull Map<UUID, CancellableState> stateMap, @NotNull TickTaskScheduler taskScheduler) {
         this.scene = Objects.requireNonNull(scene, "scene");
         this.module = Objects.requireNonNull(module, "module");
+        this.stateMap = Objects.requireNonNull(stateMap, "stateMap");
+        this.taskScheduler = Objects.requireNonNull(taskScheduler, "taskScheduler");
     }
 
     @Override
@@ -43,6 +46,30 @@ public long getReviveTime() {
         return scene;
     }
 
+    @Override
+    public void registerCancellable(@NotNull CancellableState cancellable, boolean endOld) {
+        if (hasQuit()) {
+            return;
+        }
+
+        CancellableState oldCancellable = stateMap.put(cancellable.id(), cancellable);
+
+        if (oldCancellable != null && endOld) {
+            oldCancellable.end();
+        }
+
+        cancellable.start();
+    }
+
+    @Override
+    public void removeCancellable(@NotNull UUID id) {
+        CancellableState state = stateMap.remove(id);
+
+        if (state != null) {
+            state.end();
+        }
+    }
+
     @Override
     public void start() {
         module.getStateSwitcher().start();
@@ -57,6 +84,7 @@ public void tick(long time) {
         }
 
         module.getStateSwitcher().tick(time);
+        taskScheduler.tick(time);
     }
 
     @Override
@@ -88,7 +116,6 @@ private void inventoryTick(Player player, long time) {
         return module.flags();
     }
 
-
     @Override
     public @NotNull Iterable<? extends Audience> audiences() {
         Optional<Player> playerOptional = getPlayer();
diff --git a/zombies/src/main/java/org/phantazm/zombies/player/BasicZombiesPlayerSource.java b/zombies/src/main/java/org/phantazm/zombies/player/BasicZombiesPlayerSource.java
index 97a8a4869..05fbfbc72 100644
--- a/zombies/src/main/java/org/phantazm/zombies/player/BasicZombiesPlayerSource.java
+++ b/zombies/src/main/java/org/phantazm/zombies/player/BasicZombiesPlayerSource.java
@@ -5,9 +5,6 @@
 import net.kyori.adventure.text.Component;
 import net.kyori.adventure.text.format.NamedTextColor;
 import net.kyori.adventure.text.format.TextDecoration;
-import net.minestom.server.MinecraftServer;
-import net.minestom.server.entity.Player;
-import net.minestom.server.entity.PlayerSkin;
 import net.minestom.server.event.Event;
 import net.minestom.server.event.EventNode;
 import net.minestom.server.instance.Instance;
@@ -15,18 +12,17 @@
 import net.minestom.server.network.packet.server.play.ScoreboardObjectivePacket;
 import net.minestom.server.scoreboard.Sidebar;
 import net.minestom.server.scoreboard.TabList;
-import net.minestom.server.scoreboard.Team;
 import org.apache.commons.lang3.StringUtils;
 import org.jetbrains.annotations.NotNull;
 import org.jglrxavpok.hephaistos.nbt.NBTCompound;
 import org.jglrxavpok.hephaistos.nbt.NBTException;
 import org.jglrxavpok.hephaistos.parser.SNBTParser;
 import org.phantazm.commons.Activable;
-import org.phantazm.core.entity.fakeplayer.MinimalFakePlayer;
+import org.phantazm.commons.BasicTickTaskScheduler;
+import org.phantazm.commons.CancellableState;
+import org.phantazm.commons.TickTaskScheduler;
 import org.phantazm.core.equipment.EquipmentCreator;
 import org.phantazm.core.equipment.EquipmentHandler;
-import org.phantazm.core.hologram.Hologram;
-import org.phantazm.core.hologram.InstanceHologram;
 import org.phantazm.core.inventory.*;
 import org.phantazm.core.player.PlayerView;
 import org.phantazm.core.time.PrecisionSecondTickFormatter;
@@ -39,7 +35,7 @@
 import org.phantazm.zombies.coin.PlayerCoins;
 import org.phantazm.zombies.coin.TransactionModifierSource;
 import org.phantazm.zombies.coin.component.BasicTransactionComponentCreator;
-import org.phantazm.zombies.corpse.Corpse;
+import org.phantazm.zombies.corpse.CorpseCreator;
 import org.phantazm.zombies.equipment.gun.ZombiesEquipmentModule;
 import org.phantazm.zombies.kill.BasicPlayerKills;
 import org.phantazm.zombies.kill.PlayerKills;
@@ -56,11 +52,14 @@
 import org.phantazm.zombies.player.state.revive.NearbyReviverFinder;
 import org.phantazm.zombies.player.state.revive.ReviveHandler;
 import org.phantazm.zombies.scene.ZombiesScene;
+import org.phantazm.stats.zombies.BasicZombiesPlayerMapStats;
+import org.phantazm.stats.zombies.ZombiesPlayerMapStats;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
 import java.io.StringReader;
 import java.util.*;
+import java.util.concurrent.ConcurrentHashMap;
 import java.util.function.BiFunction;
 import java.util.function.Function;
 import java.util.function.Supplier;
@@ -70,15 +69,12 @@ public class BasicZombiesPlayerSource implements ZombiesPlayer.Source {
 
     private final Function<ZombiesEquipmentModule, EquipmentCreator> equipmentCreatorFunction;
 
-    private final Team corpseTeam;
-
     private final Map<Key, MobModel> mobModelMap;
 
     public BasicZombiesPlayerSource(
             @NotNull Function<ZombiesEquipmentModule, EquipmentCreator> equipmentCreatorFunction,
-            @NotNull Team corpseTeam, @NotNull Map<Key, MobModel> mobModelMap) {
+            @NotNull Map<Key, MobModel> mobModelMap) {
         this.equipmentCreatorFunction = Objects.requireNonNull(equipmentCreatorFunction, "equipmentCreatorFunction");
-        this.corpseTeam = Objects.requireNonNull(corpseTeam, "corpseTeam");
         this.mobModelMap = Objects.requireNonNull(mobModelMap, "mobModelMap");
     }
 
@@ -89,13 +85,15 @@ public BasicZombiesPlayerSource(
             @NotNull MapSettingsInfo mapSettingsInfo, @NotNull Instance instance, @NotNull PlayerView playerView,
             @NotNull TransactionModifierSource mapTransactionModifierSource, @NotNull Flaggable flaggable,
             @NotNull EventNode<Event> eventNode, @NotNull Random random, @NotNull MapObjects mapObjects,
-            @NotNull MobStore mobStore, @NotNull MobSpawner mobSpawner) {
+            @NotNull MobStore mobStore, @NotNull MobSpawner mobSpawner, @NotNull CorpseCreator corpseCreator) {
         TransactionModifierSource playerTransactionModifierSource = new BasicTransactionModifierSource();
 
         ZombiesPlayerMeta meta = new ZombiesPlayerMeta();
+        ZombiesPlayerMapStats stats =
+                BasicZombiesPlayerMapStats.createBasicStats(playerView.getUUID(), mapSettingsInfo.id());
 
-        PlayerCoins coins = new BasicPlayerCoins(playerView, new BasicTransactionComponentCreator(), 0);
-        PlayerKills kills = new BasicPlayerKills();
+        PlayerCoins coins = new BasicPlayerCoins(playerView, stats, new BasicTransactionComponentCreator(), 0);
+        PlayerKills kills = new BasicPlayerKills(stats);
 
         InventoryProfile livingProfile = new BasicInventoryProfile(45);
 
@@ -140,7 +138,7 @@ public BasicZombiesPlayerSource(
 
         Wrapper<ZombiesPlayer> zombiesPlayerWrapper = Wrapper.ofNull();
         ZombiesEquipmentModule equipmentModule =
-                new ZombiesEquipmentModule(zombiesPlayers, playerView, mobSpawner, mobStore, eventNode, random,
+                new ZombiesEquipmentModule(zombiesPlayers, playerView, stats, mobSpawner, mobStore, eventNode, random,
                         mapObjects, zombiesPlayerWrapper, mobModelMap::get);
         EquipmentCreator equipmentCreator = equipmentCreatorFunction.apply(equipmentModule);
 
@@ -150,76 +148,75 @@ public BasicZombiesPlayerSource(
 
         Function<NoContext, ZombiesPlayerState> aliveStateCreator = unused -> {
             return new BasicZombiesPlayerState(Component.text("ALIVE"), ZombiesPlayerStateKeys.ALIVE.key(),
-                    List.of(new BasicAliveStateActivable(accessRegistry, playerView, meta, sidebar, tabList)));
+                    List.of(new BasicAliveStateActivable(accessRegistry, playerView, sidebar, tabList)));
         };
         BiFunction<DeadPlayerStateContext, Collection<Activable>, ZombiesPlayerState> deadStateCreator =
                 (context, activables) -> {
                     List<Activable> combinedActivables = new ArrayList<>(activables);
                     combinedActivables.add(
-                            new BasicDeadStateActivable(accessRegistry, context, instance, playerView, meta, sidebar,
-                                    tabList));
+                            new BasicDeadStateActivable(accessRegistry, context, instance, playerView, mapSettingsInfo,
+                                    sidebar, tabList, stats));
                     return new BasicZombiesPlayerState(Component.text("DEAD").color(NamedTextColor.RED),
                             ZombiesPlayerStateKeys.DEAD.key(), combinedActivables);
                 };
         Function<KnockedPlayerStateContext, ZombiesPlayerState> knockedStateCreator = context -> {
-            Hologram hologram =
-                    new InstanceHologram(context.getKnockLocation().add(0, 0.5, 0), 0, Hologram.Alignment.LOWER);
-            hologram.setInstance(instance);
-
-            PlayerSkin skin = playerView.getPlayer().map(Player::getSkin).orElse(null);
-            String corpseUsername = UUID.randomUUID().toString().substring(0, 16);
-            MinimalFakePlayer corpseEntity =
-                    new MinimalFakePlayer(MinecraftServer.getSchedulerManager(), corpseUsername, skin);
-
-            corpseEntity.setInstance(instance, context.getKnockLocation().add(0, 0.25, 0));
-            corpseTeam.addMember(corpseUsername);
-            TickFormatter tickFormatter =
-                    new PrecisionSecondTickFormatter(new PrecisionSecondTickFormatter.Data(NamedTextColor.RED, 1));
-            Corpse corpse = new Corpse(hologram, corpseEntity, tickFormatter);
+            TickFormatter tickFormatter = new PrecisionSecondTickFormatter(new PrecisionSecondTickFormatter.Data(1));
 
+            Wrapper<CorpseCreator.Corpse> corpseWrapper = Wrapper.ofNull();
             Supplier<ZombiesPlayerState> deadStateSupplier = () -> {
                 DeadPlayerStateContext deathContext = DeadPlayerStateContext.killed(context.getKiller().orElse(null),
                         context.getKnockRoom().orElse(null));
-                return deadStateCreator.apply(deathContext, List.of(corpse.asDeathActivable(), new Activable() {
-                    @Override
-                    public void end() {
-                        meta.setCorpse(null);
-                    }
-                }));
+                return deadStateCreator.apply(deathContext,
+                        List.of(corpseWrapper.get().asDeathActivable(), new Activable() {
+                            @Override
+                            public void end() {
+                                meta.setCorpse(null);
+                            }
+                        }));
             };
 
             ReviveHandler reviveHandler =
                     new ReviveHandler(() -> aliveStateCreator.apply(NoContext.INSTANCE), deadStateSupplier,
                             new NearbyReviverFinder(zombiesPlayers, playerView, mapSettingsInfo.reviveRadius()), 500L);
 
+            CorpseCreator.Corpse corpse =
+                    corpseCreator.forPlayer(instance, zombiesPlayerWrapper.get(), context.getKnockLocation(),
+                            reviveHandler);
+
+            corpseWrapper.set(corpse);
             return new KnockedPlayerState(reviveHandler,
-                    List.of(new BasicKnockedStateActivable(context, instance, playerView, reviveHandler, tickFormatter,
-                            meta, sidebar, tabList), corpse.asKnockActivable(reviveHandler), new Activable() {
-                        @Override
-                        public void start() {
-                            meta.setCorpse(corpse);
-                        }
-                    }));
+                    List.of(new BasicKnockedStateActivable(context, instance, playerView, mapSettingsInfo,
+                                    reviveHandler, tickFormatter, sidebar, tabList, stats), corpse.asKnockActivable(),
+                            new Activable() {
+                                @Override
+                                public void start() {
+                                    meta.setCorpse(corpse);
+                                }
+                            }));
         };
+        Map<UUID, CancellableState> stateMap = new ConcurrentHashMap<>();
+        TickTaskScheduler taskScheduler = new BasicTickTaskScheduler();
         Function<QuitPlayerStateContext, ZombiesPlayerState> quitStateCreator = unused -> {
             return new BasicZombiesPlayerState(Component.text("QUIT").color(NamedTextColor.RED),
                     ZombiesPlayerStateKeys.QUIT.key(),
-                    List.of(new BasicQuitStateActivable(instance, zombiesPlayers.values(), playerView, meta, sidebar,
-                            tabList)));
+                    List.of(new BasicQuitStateActivable(instance, playerView, mapSettingsInfo, sidebar, tabList,
+                            stateMap, taskScheduler)));
         };
-        PlayerStateSwitcher stateSwitcher = new PlayerStateSwitcher();
+
         Map<PlayerStateKey<?>, Function<?, ? extends ZombiesPlayerState>> stateFunctions =
                 Map.of(ZombiesPlayerStateKeys.ALIVE, aliveStateCreator, ZombiesPlayerStateKeys.DEAD,
                         (Function<DeadPlayerStateContext, ZombiesPlayerState>)context -> deadStateCreator.apply(context,
                                 List.of()), ZombiesPlayerStateKeys.KNOCKED, knockedStateCreator,
                         ZombiesPlayerStateKeys.QUIT, quitStateCreator);
 
+        PlayerStateSwitcher stateSwitcher = new PlayerStateSwitcher();
+
         ZombiesPlayerModule module =
                 new ZombiesPlayerModule(playerView, meta, coins, kills, equipmentHandler, equipmentCreator,
                         accessRegistry, stateSwitcher, stateFunctions, sidebar, tabList, mapTransactionModifierSource,
-                        playerTransactionModifierSource, flaggable);
+                        playerTransactionModifierSource, flaggable, stats);
 
-        ZombiesPlayer zombiesPlayer = new BasicZombiesPlayer(scene, module);
+        ZombiesPlayer zombiesPlayer = new BasicZombiesPlayer(scene, module, stateMap, taskScheduler);
         zombiesPlayerWrapper.set(zombiesPlayer);
         return zombiesPlayer;
     }
diff --git a/zombies/src/main/java/org/phantazm/zombies/player/ZombiesPlayer.java b/zombies/src/main/java/org/phantazm/zombies/player/ZombiesPlayer.java
index 697237fb6..dfcf0ec02 100644
--- a/zombies/src/main/java/org/phantazm/zombies/player/ZombiesPlayer.java
+++ b/zombies/src/main/java/org/phantazm/zombies/player/ZombiesPlayer.java
@@ -2,6 +2,7 @@
 
 import net.kyori.adventure.audience.Audience;
 import net.kyori.adventure.key.Key;
+import net.minestom.server.entity.Entity;
 import net.minestom.server.entity.GameMode;
 import net.minestom.server.entity.Player;
 import net.minestom.server.event.Event;
@@ -9,6 +10,7 @@
 import net.minestom.server.instance.Instance;
 import org.jetbrains.annotations.NotNull;
 import org.phantazm.commons.Activable;
+import org.phantazm.commons.CancellableState;
 import org.phantazm.core.equipment.Equipment;
 import org.phantazm.core.inventory.InventoryObject;
 import org.phantazm.core.inventory.InventoryProfile;
@@ -16,6 +18,7 @@
 import org.phantazm.mob.MobStore;
 import org.phantazm.mob.spawner.MobSpawner;
 import org.phantazm.zombies.coin.TransactionModifierSource;
+import org.phantazm.zombies.corpse.CorpseCreator;
 import org.phantazm.zombies.map.Door;
 import org.phantazm.zombies.map.Flaggable;
 import org.phantazm.zombies.map.MapSettingsInfo;
@@ -25,6 +28,7 @@
 import org.phantazm.zombies.player.state.ZombiesPlayerStateKeys;
 import org.phantazm.zombies.powerup.Powerup;
 import org.phantazm.zombies.scene.ZombiesScene;
+import org.phantazm.zombies.stage.Stage;
 
 import java.util.Map;
 import java.util.Optional;
@@ -41,6 +45,10 @@ public interface ZombiesPlayer extends Activable, Flaggable.Source, Audience {
 
     @NotNull ZombiesScene getScene();
 
+    void registerCancellable(@NotNull CancellableState cancellable, boolean endOld);
+
+    void removeCancellable(@NotNull UUID id);
+
     default @NotNull Optional<Equipment> getHeldEquipment() {
         Optional<Player> playerOptional = module().getPlayerView().getPlayer();
         if (playerOptional.isEmpty()) {
@@ -103,30 +111,55 @@ default boolean hasQuit() {
     }
 
     default boolean canPickupPowerup(@NotNull Powerup powerup) {
-        return isAlive();
+        return canDoGenericActions();
     }
 
     default boolean canOpenDoor(@NotNull Door door) {
-        return isAlive();
+        return canDoGenericActions();
     }
 
     default boolean canRepairWindow() {
-        return isAlive();
+        return canDoGenericActions();
     }
 
     default boolean canTakeDamage() {
-        return isAlive();
+        return canDoGenericActions();
     }
 
     default boolean canBeTargeted() {
-        return isAlive() && getPlayer().map(player -> {
+        return canDoGenericActions() && getPlayer().map(player -> {
             GameMode mode = player.getGameMode();
             return mode == GameMode.SURVIVAL || mode == GameMode.ADVENTURE;
         }).orElse(false);
     }
 
+    default boolean canDoGenericActions() {
+        return isAlive() && isInGame();
+    }
+
+    default boolean canRevive() {
+        if (!canDoGenericActions()) {
+            return false;
+        }
+
+        return getPlayer().filter(value -> value.getPose() == Entity.Pose.SNEAKING).isPresent();
+    }
+
+    default boolean canTriggerSLA() {
+        return canDoGenericActions();
+    }
+
+    default boolean isInGame() {
+        return module().getMeta().isInGame();
+    }
+
     default boolean inStage(@NotNull Key stageKey) {
-        return getScene().getCurrentStage().key().equals(stageKey);
+        Stage currentStage = getScene().getCurrentStage();
+        if (currentStage == null) {
+            return false;
+        }
+
+        return currentStage.key().equals(stageKey);
     }
 
     default @NotNull String getUsername() {
@@ -146,7 +179,7 @@ interface Source {
                 @NotNull MapSettingsInfo mapSettingsInfo, @NotNull Instance instance, @NotNull PlayerView playerView,
                 @NotNull TransactionModifierSource mapTransactionModifierSource, @NotNull Flaggable flaggable,
                 @NotNull EventNode<Event> eventNode, @NotNull Random random, @NotNull MapObjects mapObjects,
-                @NotNull MobStore mobStore, @NotNull MobSpawner mobSpawner);
+                @NotNull MobStore mobStore, @NotNull MobSpawner mobSpawner, @NotNull CorpseCreator corpseCreator);
 
     }
 
diff --git a/zombies/src/main/java/org/phantazm/zombies/player/ZombiesPlayerMeta.java b/zombies/src/main/java/org/phantazm/zombies/player/ZombiesPlayerMeta.java
index 3f1fef05a..1dada2210 100644
--- a/zombies/src/main/java/org/phantazm/zombies/player/ZombiesPlayerMeta.java
+++ b/zombies/src/main/java/org/phantazm/zombies/player/ZombiesPlayerMeta.java
@@ -1,30 +1,26 @@
 package org.phantazm.zombies.player;
 
 import org.jetbrains.annotations.Nullable;
-import org.phantazm.zombies.corpse.Corpse;
+import org.phantazm.zombies.corpse.CorpseCreator;
 
 import java.util.Optional;
 
 //TODO: rename
 public class ZombiesPlayerMeta {
 
-    private Corpse corpse = null;
+    private CorpseCreator.Corpse corpse = null;
 
     private boolean inGame = false;
 
-    private boolean canRevive = false;
-
     private boolean isReviving = false;
 
-    private boolean canTriggerSLA = true;
-
     private int windowRepairAmount = 1;
 
-    public Optional<Corpse> getCorpse() {
+    public Optional<CorpseCreator.Corpse> getCorpse() {
         return Optional.ofNullable(corpse);
     }
 
-    public void setCorpse(@Nullable Corpse corpse) {
+    public void setCorpse(@Nullable CorpseCreator.Corpse corpse) {
         this.corpse = corpse;
     }
 
@@ -36,14 +32,6 @@ public void setInGame(boolean inGame) {
         this.inGame = inGame;
     }
 
-    public boolean isCanRevive() {
-        return canRevive;
-    }
-
-    public void setCanRevive(boolean canRevive) {
-        this.canRevive = canRevive;
-    }
-
     public boolean isReviving() {
         return isReviving;
     }
@@ -52,14 +40,6 @@ public void setReviving(boolean reviving) {
         isReviving = reviving;
     }
 
-    public boolean canTriggerSLA() {
-        return canTriggerSLA;
-    }
-
-    public void setCanTriggerSLA(boolean canTriggerSLA) {
-        this.canTriggerSLA = canTriggerSLA;
-    }
-
     public int getWindowRepairAmount() {
         return windowRepairAmount;
     }
diff --git a/zombies/src/main/java/org/phantazm/zombies/player/ZombiesPlayerModule.java b/zombies/src/main/java/org/phantazm/zombies/player/ZombiesPlayerModule.java
index e9f5e5db1..88a708d4c 100644
--- a/zombies/src/main/java/org/phantazm/zombies/player/ZombiesPlayerModule.java
+++ b/zombies/src/main/java/org/phantazm/zombies/player/ZombiesPlayerModule.java
@@ -17,6 +17,7 @@
 import org.phantazm.zombies.player.state.PlayerStateKey;
 import org.phantazm.zombies.player.state.PlayerStateSwitcher;
 import org.phantazm.zombies.player.state.ZombiesPlayerState;
+import org.phantazm.stats.zombies.ZombiesPlayerMapStats;
 
 import java.util.Map;
 import java.util.Objects;
@@ -39,6 +40,7 @@ public class ZombiesPlayerModule implements DependencyModule {
     private final TransactionModifierSource playerTransactionModifierSource;
     private final TransactionModifierSource compositeTransactionModifierSource;
     private final Flaggable flaggable;
+    private final ZombiesPlayerMapStats stats;
 
     public ZombiesPlayerModule(@NotNull PlayerView playerView, @NotNull ZombiesPlayerMeta meta,
             @NotNull PlayerCoins coins, @NotNull PlayerKills kills, @NotNull EquipmentHandler equipmentHandler,
@@ -47,7 +49,8 @@ public ZombiesPlayerModule(@NotNull PlayerView playerView, @NotNull ZombiesPlaye
             @NotNull Map<PlayerStateKey<?>, Function<?, ? extends ZombiesPlayerState>> stateFunctions,
             @NotNull Sidebar sidebar,
             @NotNull TabList tabList, @NotNull TransactionModifierSource mapTransactionModifierSource,
-            @NotNull TransactionModifierSource playerTransactionModifierSource, @NotNull Flaggable flaggable) {
+            @NotNull TransactionModifierSource playerTransactionModifierSource, @NotNull Flaggable flaggable,
+            @NotNull ZombiesPlayerMapStats stats) {
         this.playerView = Objects.requireNonNull(playerView, "playerView");
         this.meta = Objects.requireNonNull(meta, "meta");
         this.coins = Objects.requireNonNull(coins, "coins");
@@ -64,6 +67,7 @@ public ZombiesPlayerModule(@NotNull PlayerView playerView, @NotNull ZombiesPlaye
         this.compositeTransactionModifierSource =
                 TransactionModifierSource.compositeView(mapTransactionModifierSource, playerTransactionModifierSource);
         this.flaggable = Objects.requireNonNull(flaggable, "flags");
+        this.stats = Objects.requireNonNull(stats, "stats");
     }
 
     public @NotNull ZombiesPlayerMeta getMeta() {
@@ -123,4 +127,8 @@ public ZombiesPlayerModule(@NotNull PlayerView playerView, @NotNull ZombiesPlaye
     public @NotNull Flaggable flags() {
         return flaggable;
     }
+
+    public @NotNull ZombiesPlayerMapStats getStats() {
+        return stats;
+    }
 }
diff --git a/zombies/src/main/java/org/phantazm/zombies/player/state/BasicAliveStateActivable.java b/zombies/src/main/java/org/phantazm/zombies/player/state/BasicAliveStateActivable.java
index dc17d69a9..d3b9b11ba 100644
--- a/zombies/src/main/java/org/phantazm/zombies/player/state/BasicAliveStateActivable.java
+++ b/zombies/src/main/java/org/phantazm/zombies/player/state/BasicAliveStateActivable.java
@@ -9,24 +9,21 @@
 import org.phantazm.core.inventory.InventoryAccessRegistry;
 import org.phantazm.core.player.PlayerView;
 import org.phantazm.zombies.Attributes;
-import org.phantazm.zombies.player.ZombiesPlayerMeta;
 
 import java.util.Objects;
 
 public class BasicAliveStateActivable implements Activable {
     private final InventoryAccessRegistry accessRegistry;
     private final PlayerView playerView;
-    private final ZombiesPlayerMeta meta;
     private final Sidebar sidebar;
     private final TabList tabList;
 
     private long lastHeal;
 
     public BasicAliveStateActivable(@NotNull InventoryAccessRegistry accessRegistry, @NotNull PlayerView playerView,
-            @NotNull ZombiesPlayerMeta meta, @NotNull Sidebar sidebar, @NotNull TabList tabList) {
+            @NotNull Sidebar sidebar, @NotNull TabList tabList) {
         this.accessRegistry = Objects.requireNonNull(accessRegistry, "accessRegistry");
         this.playerView = Objects.requireNonNull(playerView, "playerView");
-        this.meta = Objects.requireNonNull(meta, "meta");
         this.sidebar = Objects.requireNonNull(sidebar, "sidebar");
         this.tabList = Objects.requireNonNull(tabList, "tabList");
     }
@@ -43,10 +40,6 @@ public void start() {
         });
 
         accessRegistry.switchAccess(InventoryKeys.ALIVE_ACCESS);
-
-        meta.setInGame(true);
-        meta.setCanRevive(true);
-        meta.setCanTriggerSLA(true);
     }
 
     @Override
diff --git a/zombies/src/main/java/org/phantazm/zombies/player/state/BasicDeadStateActivable.java b/zombies/src/main/java/org/phantazm/zombies/player/state/BasicDeadStateActivable.java
index 567c54089..6cbe1eaef 100644
--- a/zombies/src/main/java/org/phantazm/zombies/player/state/BasicDeadStateActivable.java
+++ b/zombies/src/main/java/org/phantazm/zombies/player/state/BasicDeadStateActivable.java
@@ -1,39 +1,52 @@
 package org.phantazm.zombies.player.state;
 
+import net.kyori.adventure.audience.Audience;
 import net.kyori.adventure.text.Component;
-import net.kyori.adventure.text.TextComponent;
+import net.kyori.adventure.text.minimessage.MiniMessage;
+import net.kyori.adventure.text.minimessage.tag.resolver.Placeholder;
+import net.kyori.adventure.text.minimessage.tag.resolver.TagResolver;
+import net.kyori.adventure.title.TitlePart;
+import net.minestom.server.adventure.audience.PacketGroupingAudience;
 import net.minestom.server.entity.GameMode;
+import net.minestom.server.entity.Player;
 import net.minestom.server.instance.Instance;
 import net.minestom.server.scoreboard.Sidebar;
 import net.minestom.server.scoreboard.TabList;
 import org.jetbrains.annotations.NotNull;
 import org.phantazm.commons.Activable;
+import org.phantazm.commons.MiniMessageUtils;
 import org.phantazm.core.inventory.InventoryAccessRegistry;
 import org.phantazm.core.player.PlayerView;
-import org.phantazm.zombies.player.ZombiesPlayerMeta;
+import org.phantazm.stats.zombies.ZombiesPlayerMapStats;
+import org.phantazm.zombies.map.MapSettingsInfo;
 import org.phantazm.zombies.player.state.context.DeadPlayerStateContext;
 
-import java.util.Objects;
+import java.util.*;
 
 public class BasicDeadStateActivable implements Activable {
+    private static final TagResolver[] EMPTY_TAG_RESOLVER_ARRAY = new TagResolver[0];
     private final InventoryAccessRegistry accessRegistry;
     private final DeadPlayerStateContext context;
     private final Instance instance;
     private final PlayerView playerView;
-    private final ZombiesPlayerMeta meta;
+    private final MapSettingsInfo settings;
     private final Sidebar sidebar;
     private final TabList tabList;
+    private final ZombiesPlayerMapStats stats;
+    private final MiniMessage miniMessage = MiniMessage.miniMessage();
 
     public BasicDeadStateActivable(@NotNull InventoryAccessRegistry accessRegistry,
             @NotNull DeadPlayerStateContext context, @NotNull Instance instance, @NotNull PlayerView playerView,
-            @NotNull ZombiesPlayerMeta meta, @NotNull Sidebar sidebar, @NotNull TabList tabList) {
+            @NotNull MapSettingsInfo settings, @NotNull Sidebar sidebar, @NotNull TabList tabList,
+            @NotNull ZombiesPlayerMapStats stats) {
         this.accessRegistry = Objects.requireNonNull(accessRegistry, "accessRegistry");
         this.context = Objects.requireNonNull(context, "context");
         this.instance = Objects.requireNonNull(instance, "instance");
         this.playerView = Objects.requireNonNull(playerView, "playerView");
-        this.meta = Objects.requireNonNull(meta, "meta");
+        this.settings = Objects.requireNonNull(settings, "settings");
         this.sidebar = Objects.requireNonNull(sidebar, "sidebar");
         this.tabList = Objects.requireNonNull(tabList, "tabList");
+        this.stats = Objects.requireNonNull(stats, "stats");
     }
 
     @Override
@@ -45,14 +58,24 @@ public void start() {
             tabList.addViewer(player);
         });
         playerView.getDisplayName().thenAccept(displayName -> {
-            instance.sendMessage(buildDeathMessage(displayName));
+            if (context.isRejoin()) {
+                TagResolver rejoinerPlaceholder = Placeholder.component("rejoiner", displayName);
+                instance.sendMessage(miniMessage.deserialize(settings.rejoinMessageFormat(), rejoinerPlaceholder));
+                return;
+            }
+
+            Set<Player> players = new HashSet<>(instance.getPlayers());
+            TagResolver[] tagResolvers = getTagResolvers(displayName);
+            playerView.getPlayer().ifPresent(player -> {
+                players.remove(player);
+                player.sendMessage(miniMessage.deserialize(settings.deathMessageToKilledFormat(), tagResolvers));
+            });
+            Audience instanceAudience = PacketGroupingAudience.of(players);
+            instanceAudience.sendMessage(miniMessage.deserialize(settings.deathMessageToOthersFormat(), tagResolvers));
         });
 
+        stats.setDeaths(stats.getDeaths() + 1);
         accessRegistry.switchAccess(InventoryKeys.DEAD_ACCESS);
-
-        meta.setInGame(true);
-        meta.setCanRevive(false);
-        meta.setCanTriggerSLA(false);
     }
 
     @Override
@@ -67,25 +90,21 @@ public void end() {
         accessRegistry.switchAccess(null);
     }
 
-    private @NotNull Component buildDeathMessage(@NotNull Component displayName) {
-        if (context.isRejoin()) {
-            return Component.textOfChildren(displayName, Component.text(" rejoined."));
+    private TagResolver[] getTagResolvers(@NotNull Component displayName) {
+        boolean knockedRoomPresent = context.getDeathRoomName().isPresent();
+        boolean killerPresent = context.getKiller().isPresent();
+        List<TagResolver> tagResolvers = new ArrayList<>();
+        tagResolvers.add(Placeholder.component("killed", displayName));
+        tagResolvers.add(MiniMessageUtils.optional("death_room_present", knockedRoomPresent));
+        tagResolvers.add(MiniMessageUtils.optional("killer_present", killerPresent));
+        if (knockedRoomPresent) {
+            tagResolvers.add(Placeholder.component("death_room", context.getDeathRoomName().get()));
+        }
+        if (killerPresent) {
+            tagResolvers.add(Placeholder.component("killer", context.getKiller().get()));
         }
 
-        TextComponent.Builder builder = Component.text();
-        builder.append(displayName);
-        builder.append(Component.text(" was killed"));
-        context.getDeathRoomName().ifPresent(deathRoomName -> {
-            builder.append(Component.text(" in "));
-            builder.append(deathRoomName);
-        });
-        context.getKiller().ifPresent(killer -> {
-            builder.append(Component.text(" by "));
-            builder.append(killer);
-        });
-        builder.append(Component.text("."));
-
-        return builder.build();
+        return tagResolvers.toArray(EMPTY_TAG_RESOLVER_ARRAY);
     }
 
 }
diff --git a/zombies/src/main/java/org/phantazm/zombies/player/state/BasicKnockedStateActivable.java b/zombies/src/main/java/org/phantazm/zombies/player/state/BasicKnockedStateActivable.java
index 573afe4fe..1bfe9982b 100644
--- a/zombies/src/main/java/org/phantazm/zombies/player/state/BasicKnockedStateActivable.java
+++ b/zombies/src/main/java/org/phantazm/zombies/player/state/BasicKnockedStateActivable.java
@@ -1,34 +1,46 @@
 package org.phantazm.zombies.player.state;
 
 import com.github.steanky.toolkit.collection.Wrapper;
+import net.kyori.adventure.audience.Audience;
 import net.kyori.adventure.text.Component;
-import net.kyori.adventure.text.TextComponent;
+import net.kyori.adventure.text.minimessage.MiniMessage;
+import net.kyori.adventure.text.minimessage.tag.resolver.Placeholder;
+import net.kyori.adventure.text.minimessage.tag.resolver.TagResolver;
+import net.kyori.adventure.title.TitlePart;
+import net.minestom.server.adventure.audience.PacketGroupingAudience;
 import net.minestom.server.attribute.Attribute;
 import net.minestom.server.coordinate.Pos;
 import net.minestom.server.entity.GameMode;
+import net.minestom.server.entity.Player;
 import net.minestom.server.instance.Instance;
 import net.minestom.server.scoreboard.Sidebar;
 import net.minestom.server.scoreboard.TabList;
 import org.jetbrains.annotations.NotNull;
 import org.phantazm.commons.Activable;
+import org.phantazm.commons.MiniMessageUtils;
 import org.phantazm.core.player.PlayerView;
 import org.phantazm.core.time.TickFormatter;
+import org.phantazm.stats.zombies.ZombiesPlayerMapStats;
+import org.phantazm.zombies.map.MapSettingsInfo;
 import org.phantazm.zombies.player.ZombiesPlayer;
-import org.phantazm.zombies.player.ZombiesPlayerMeta;
 import org.phantazm.zombies.player.state.context.KnockedPlayerStateContext;
 import org.phantazm.zombies.player.state.revive.ReviveHandler;
 
-import java.util.Objects;
+import java.util.*;
 import java.util.concurrent.CompletableFuture;
 
 public class BasicKnockedStateActivable implements Activable {
 
+    private static final TagResolver[] EMPTY_TAG_RESOLVER_ARRAY = new TagResolver[0];
+
     private final KnockedPlayerStateContext context;
 
     private final Instance instance;
 
     private final PlayerView playerView;
 
+    private final MapSettingsInfo settings;
+
     private final ReviveHandler reviveHandler;
 
     private final TickFormatter tickFormatter;
@@ -37,19 +49,23 @@ public class BasicKnockedStateActivable implements Activable {
 
     private final TabList tabList;
 
-    private final ZombiesPlayerMeta meta;
+    private final ZombiesPlayerMapStats stats;
+
+    private final MiniMessage miniMessage = MiniMessage.miniMessage();
 
     public BasicKnockedStateActivable(@NotNull KnockedPlayerStateContext context, @NotNull Instance instance,
-            @NotNull PlayerView playerView, @NotNull ReviveHandler reviveHandler, @NotNull TickFormatter tickFormatter,
-            @NotNull ZombiesPlayerMeta meta, @NotNull Sidebar sidebar, @NotNull TabList tabList) {
+            @NotNull PlayerView playerView, @NotNull MapSettingsInfo settings, @NotNull ReviveHandler reviveHandler,
+            @NotNull TickFormatter tickFormatter, @NotNull Sidebar sidebar, @NotNull TabList tabList,
+            @NotNull ZombiesPlayerMapStats stats) {
         this.context = Objects.requireNonNull(context, "context");
         this.instance = Objects.requireNonNull(instance, "instance");
         this.playerView = Objects.requireNonNull(playerView, "playerView");
+        this.settings = Objects.requireNonNull(settings, "settings");
         this.reviveHandler = Objects.requireNonNull(reviveHandler, "reviveHandler");
         this.tickFormatter = Objects.requireNonNull(tickFormatter, "tickFormatter");
-        this.meta = Objects.requireNonNull(meta, "meta");
         this.sidebar = Objects.requireNonNull(sidebar, "sidebar");
-        this.tabList = tabList;
+        this.tabList = Objects.requireNonNull(tabList, "tabList");
+        this.stats = Objects.requireNonNull(stats, "stats");
     }
 
     @Override
@@ -66,24 +82,40 @@ public void start() {
             context.getVehicle().addPassenger(player);
         });
         playerView.getDisplayName().thenAccept(displayName -> {
-            instance.sendMessage(buildDeathMessage(displayName));
+            Set<Player> players = new HashSet<>(instance.getPlayers());
+            TagResolver[] tagResolvers = getTagResolvers(displayName);
+            playerView.getPlayer().ifPresent(player -> {
+                players.remove(player);
+                player.sendMessage(miniMessage.deserialize(settings.knockedMessageToKnockedFormat(), tagResolvers));
+            });
+            Audience instanceAudience = PacketGroupingAudience.of(players);
+            instanceAudience.sendMessage(
+                    miniMessage.deserialize(settings.knockedMessageToOthersFormat(), tagResolvers));
+            instanceAudience.sendTitlePart(TitlePart.TITLE,
+                    miniMessage.deserialize(settings.knockedTitleFormat(), tagResolvers));
+            instanceAudience.sendTitlePart(TitlePart.SUBTITLE,
+                    miniMessage.deserialize(settings.knockedSubtitleFormat(), tagResolvers));
         });
-        meta.setInGame(true);
-        meta.setCanRevive(false);
-        meta.setCanTriggerSLA(false);
+
+        stats.setKnocks(stats.getKnocks() + 1);
     }
 
     @Override
     public void tick(long time) {
-        reviveHandler.getReviver().ifPresentOrElse(reviver -> {
-            Wrapper<Component> knockedDisplayName = Wrapper.ofNull(), reviverDisplayName = Wrapper.ofNull();
-            CompletableFuture<Void> knockedFuture = playerView.getDisplayName().thenAccept(knockedDisplayName::set);
-            CompletableFuture<Void> reviverFuture =
-                    reviver.module().getPlayerView().getDisplayName().thenAccept(reviverDisplayName::set);
-            CompletableFuture.allOf(knockedFuture, reviverFuture).thenAccept(v -> {
-                sendReviveStatus(reviver, knockedDisplayName.get(), reviverDisplayName.get());
+        if (reviveHandler.isReviving()) {
+            reviveHandler.getReviver().ifPresent(reviver -> {
+                Wrapper<Component> knockedDisplayName = Wrapper.ofNull(), reviverDisplayName = Wrapper.ofNull();
+                CompletableFuture<Void> knockedFuture = playerView.getDisplayName().thenAccept(knockedDisplayName::set);
+                CompletableFuture<Void> reviverFuture =
+                        reviver.module().getPlayerView().getDisplayName().thenAccept(reviverDisplayName::set);
+                CompletableFuture.allOf(knockedFuture, reviverFuture).thenAccept(v -> {
+                    sendReviveStatus(reviver, knockedDisplayName.get(), reviverDisplayName.get());
+                });
             });
-        }, this::sendDyingStatus);
+        }
+        else {
+            sendDyingStatus();
+        }
     }
 
     @Override
@@ -92,9 +124,10 @@ public void end() {
             player.setInvisible(false);
             player.setFlying(false);
             player.setAllowFlying(false);
-            player.setFlyingSpeed(Attribute.FLYING_SPEED.defaultValue());
+            player.setFlyingSpeed(0.4F);
             player.getAttribute(Attribute.MOVEMENT_SPEED).setBaseValue(0.1F);
             player.setGameMode(GameMode.ADVENTURE);
+            player.sendActionBar(Component.empty());
             sidebar.addViewer(player);
             tabList.addViewer(player);
             context.getVehicle().remove();
@@ -105,37 +138,47 @@ public void end() {
     private void sendReviveStatus(@NotNull ZombiesPlayer reviver, @NotNull Component knockedDisplayName,
             @NotNull Component reviverDisplayName) {
         reviver.module().getPlayerView().getPlayer().ifPresent(reviverPlayer -> {
-            reviverPlayer.sendActionBar(
-                    Component.textOfChildren(Component.text("Reviving "), knockedDisplayName, Component.text(" - "),
-                            tickFormatter.format(reviveHandler.getTicksUntilRevive())));
+            TagResolver knockedNamePlaceholder = Placeholder.component("knocked", knockedDisplayName);
+            TagResolver timePlaceholder =
+                    Placeholder.unparsed("time", tickFormatter.format(reviveHandler.getTicksUntilRevive()));
+            Component message = miniMessage.deserialize(settings.reviveStatusToReviverFormat(), knockedNamePlaceholder,
+                    timePlaceholder);
+            reviverPlayer.sendActionBar(message);
         });
         playerView.getPlayer().ifPresent(player -> {
-            player.sendActionBar(Component.textOfChildren(reviverDisplayName, Component.text(" is reviving you - "),
-                    tickFormatter.format(reviveHandler.getTicksUntilRevive())));
+            TagResolver reviverNamePlaceholder = Placeholder.component("reviver", reviverDisplayName);
+            TagResolver timePlaceholder =
+                    Placeholder.unparsed("time", tickFormatter.format(reviveHandler.getTicksUntilRevive()));
+            Component message = miniMessage.deserialize(settings.reviveStatusToKnockedFormat(), reviverNamePlaceholder,
+                    timePlaceholder);
+            player.sendActionBar(message);
         });
     }
 
     private void sendDyingStatus() {
         playerView.getPlayer().ifPresent(player -> {
-            player.sendActionBar(Component.textOfChildren(Component.text("You are dying - "),
-                    tickFormatter.format(Math.max(reviveHandler.getTicksUntilDeath(), 0))));
+            TagResolver timePlaceholder = Placeholder.component("time",
+                    Component.text(tickFormatter.format(Math.max(reviveHandler.getTicksUntilDeath(), 0))));
+            player.sendActionBar(miniMessage.deserialize(settings.dyingStatusFormat(), timePlaceholder));
         });
     }
 
-    private @NotNull Component buildDeathMessage(@NotNull Component displayName) {
-        TextComponent.Builder builder = Component.text();
-        builder.append(displayName);
-        builder.append(Component.text(" was knocked down"));
-        context.getKnockRoom().ifPresent(room -> {
-            builder.append(Component.text(" in "));
-            builder.append(room);
-        });
-        context.getKiller().ifPresent(killer -> {
-            builder.append(Component.text(" by "));
-            builder.append(killer);
-        });
-        builder.append(Component.text("."));
-
-        return builder.build();
+    private TagResolver[] getTagResolvers(@NotNull Component displayName) {
+        boolean knockedRoomPresent = context.getKnockRoom().isPresent();
+        boolean killerPresent = context.getKiller().isPresent();
+        List<TagResolver> tagResolvers = new ArrayList<>();
+        tagResolvers.add(Placeholder.component("knocked", displayName));
+        tagResolvers.add(MiniMessageUtils.optional("knocked_room_present", knockedRoomPresent));
+        tagResolvers.add(MiniMessageUtils.optional("killer_present", killerPresent));
+        tagResolvers.add(Placeholder.unparsed("time", tickFormatter.format(reviveHandler.getTicksUntilDeath())));
+        if (knockedRoomPresent) {
+            tagResolvers.add(Placeholder.component("knocked_room", context.getKnockRoom().get()));
+        }
+        if (killerPresent) {
+            tagResolvers.add(Placeholder.component("killer", context.getKiller().get()));
+        }
+
+        return tagResolvers.toArray(EMPTY_TAG_RESOLVER_ARRAY);
     }
+
 }
diff --git a/zombies/src/main/java/org/phantazm/zombies/player/state/BasicQuitStateActivable.java b/zombies/src/main/java/org/phantazm/zombies/player/state/BasicQuitStateActivable.java
index 211272815..d21b647ab 100644
--- a/zombies/src/main/java/org/phantazm/zombies/player/state/BasicQuitStateActivable.java
+++ b/zombies/src/main/java/org/phantazm/zombies/player/state/BasicQuitStateActivable.java
@@ -1,38 +1,43 @@
 package org.phantazm.zombies.player.state;
 
 import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.minimessage.MiniMessage;
+import net.kyori.adventure.text.minimessage.tag.resolver.Placeholder;
+import net.kyori.adventure.text.minimessage.tag.resolver.TagResolver;
 import net.minestom.server.instance.Instance;
 import net.minestom.server.scoreboard.Sidebar;
 import net.minestom.server.scoreboard.TabList;
 import org.jetbrains.annotations.NotNull;
 import org.phantazm.commons.Activable;
+import org.phantazm.commons.CancellableState;
+import org.phantazm.commons.TickTaskScheduler;
 import org.phantazm.core.player.PlayerView;
-import org.phantazm.zombies.player.ZombiesPlayer;
-import org.phantazm.zombies.player.ZombiesPlayerMeta;
+import org.phantazm.zombies.map.MapSettingsInfo;
 
-import java.util.Collection;
+import java.util.Map;
 import java.util.Objects;
+import java.util.UUID;
 
 public class BasicQuitStateActivable implements Activable {
-
     private final Instance instance;
-
     private final PlayerView playerView;
-
-    private final ZombiesPlayerMeta meta;
-
+    private final MapSettingsInfo settings;
     private final Sidebar sidebar;
-
     private final TabList tabList;
+    private final Map<UUID, CancellableState> stateMap;
+    private final TickTaskScheduler scheduler;
+    private final MiniMessage miniMessage = MiniMessage.miniMessage();
 
-    public BasicQuitStateActivable(@NotNull Instance instance,
-            @NotNull Collection<? extends ZombiesPlayer> zombiesPlayers, @NotNull PlayerView playerView,
-            @NotNull ZombiesPlayerMeta meta, @NotNull Sidebar sidebar, @NotNull TabList tabList) {
+    public BasicQuitStateActivable(@NotNull Instance instance, @NotNull PlayerView playerView,
+            @NotNull MapSettingsInfo settings, @NotNull Sidebar sidebar, @NotNull TabList tabList,
+            @NotNull Map<UUID, CancellableState> stateMap, @NotNull TickTaskScheduler scheduler) {
         this.instance = Objects.requireNonNull(instance, "instance");
         this.playerView = Objects.requireNonNull(playerView, "playerView");
-        this.meta = Objects.requireNonNull(meta, "meta");
+        this.settings = Objects.requireNonNull(settings, "settings");
         this.sidebar = Objects.requireNonNull(sidebar, "sidebar");
         this.tabList = Objects.requireNonNull(tabList, "tabList");
+        this.stateMap = Objects.requireNonNull(stateMap, "stateMap");
+        this.scheduler = Objects.requireNonNull(scheduler, "scheduler");
     }
 
     @Override
@@ -43,12 +48,18 @@ public void start() {
             player.setExp(0);
             sidebar.removeViewer(player);
             tabList.removeViewer(player);
+            player.setHealth(player.getMaxHealth());
+        });
+        playerView.getDisplayName().thenAccept(displayName -> {
+            TagResolver quitterPlaceholder = Placeholder.component("quitter", displayName);
+            instance.sendMessage(miniMessage.deserialize(settings.quitMessageFormat(), quitterPlaceholder));
         });
-        playerView.getDisplayName()
-                .thenAccept(displayName -> instance.sendMessage(displayName.append(Component.text(" quit."))));
-        meta.setInGame(false);
-        meta.setCanRevive(false);
-        meta.setCanTriggerSLA(false);
-    }
 
+        for (CancellableState state : stateMap.values()) {
+            state.end();
+        }
+
+        scheduler.end();
+        stateMap.clear();
+    }
 }
diff --git a/zombies/src/main/java/org/phantazm/zombies/player/state/PlayerStateSwitcher.java b/zombies/src/main/java/org/phantazm/zombies/player/state/PlayerStateSwitcher.java
index febb6333d..71d1e5281 100644
--- a/zombies/src/main/java/org/phantazm/zombies/player/state/PlayerStateSwitcher.java
+++ b/zombies/src/main/java/org/phantazm/zombies/player/state/PlayerStateSwitcher.java
@@ -8,7 +8,6 @@ public class PlayerStateSwitcher implements Activable {
     private ZombiesPlayerState state;
 
     public PlayerStateSwitcher() {
-
     }
 
     @Override
diff --git a/zombies/src/main/java/org/phantazm/zombies/player/state/revive/NearbyReviverFinder.java b/zombies/src/main/java/org/phantazm/zombies/player/state/revive/NearbyReviverFinder.java
index 1dad135af..ea7e9b8ca 100644
--- a/zombies/src/main/java/org/phantazm/zombies/player/state/revive/NearbyReviverFinder.java
+++ b/zombies/src/main/java/org/phantazm/zombies/player/state/revive/NearbyReviverFinder.java
@@ -51,20 +51,12 @@ public ZombiesPlayer get() {
                 .nearbyEntitiesUntil(knockedPosition, reviveRadius, EntityTracker.Target.PLAYERS, candidate -> {
                     UUID candidateUUID = candidate.getUuid();
                     ZombiesPlayer revivingPlayer = zombiesPlayers.get(candidateUUID);
-                    if (revivingPlayer == null) {
-                        return false;
-                    }
-
-                    if (candidateUUID.equals(playerView.getUUID())) {
-                        return false;
-                    }
-
-                    if (!revivingPlayer.isAlive()) {
+                    if (revivingPlayer == null || candidateUUID.equals(playerView.getUUID()) || !revivingPlayer.canRevive()) {
                         return false;
                     }
 
                     ZombiesPlayerMeta meta = revivingPlayer.module().getMeta();
-                    if (!(meta.isCanRevive() && !meta.isReviving())) {
+                    if (meta.isReviving()) {
                         return false;
                     }
 
@@ -72,11 +64,7 @@ public ZombiesPlayer get() {
                     if (reviverPlayerOptional.isEmpty()) {
                         return false;
                     }
-
                     Player player = reviverPlayerOptional.get();
-                    if (player.getPose() != Entity.Pose.SNEAKING) {
-                        return false;
-                    }
 
                     if (player.getPosition().distance(knockedPosition) <= reviveRadius) {
                         playerWrapper.set(revivingPlayer);
diff --git a/zombies/src/main/java/org/phantazm/zombies/player/state/revive/ReviveHandler.java b/zombies/src/main/java/org/phantazm/zombies/player/state/revive/ReviveHandler.java
index bb7497b04..188e2b91f 100644
--- a/zombies/src/main/java/org/phantazm/zombies/player/state/revive/ReviveHandler.java
+++ b/zombies/src/main/java/org/phantazm/zombies/player/state/revive/ReviveHandler.java
@@ -1,6 +1,6 @@
 package org.phantazm.zombies.player.state.revive;
 
-import net.minestom.server.entity.Entity;
+import net.kyori.adventure.text.Component;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.phantazm.commons.Activable;
@@ -54,7 +54,7 @@ public void tick(long time) {
             }
 
             if (reviver != null) {
-                reviver.module().getMeta().setReviving(false);
+                clearReviverState();
             }
 
             reviver = null;
@@ -66,7 +66,8 @@ public void tick(long time) {
             }
 
             if (reviver != null) {
-                reviver.module().getMeta().setReviving(false);
+                reviver.module().getStats().setRevives(reviver.module().getStats().getRevives() + 1);
+                clearReviverState();
             }
 
             reviver = null;
@@ -84,9 +85,8 @@ public void tick(long time) {
                 --ticksUntilDeath;
             }
         }
-        else if (!reviver.module().getMeta().isCanRevive() ||
-                !reviver.getPlayer().map(player -> player.getPose() == Entity.Pose.SNEAKING).orElse(true)) {
-            reviver.module().getMeta().setReviving(false);
+        else if (!reviver.canRevive()) {
+            clearReviverState();
             reviver = null;
             ticksUntilRevive = -1;
         }
@@ -97,10 +97,7 @@ else if (!reviver.module().getMeta().isCanRevive() ||
 
     @Override
     public void end() {
-        if (reviver != null) {
-            reviver.module().getMeta().setReviving(false);
-        }
-
+        clearReviverState();
         reviver = null;
     }
 
@@ -113,9 +110,7 @@ public void setReviver(@Nullable ZombiesPlayer reviver) {
             return;
         }
 
-        if (this.reviver != null) {
-            this.reviver.module().getMeta().setReviving(false);
-        }
+        clearReviverState();
         this.reviver = reviver;
         if (reviver != null) {
             ticksUntilDeath = deathTime;
@@ -127,6 +122,13 @@ public void setReviver(@Nullable ZombiesPlayer reviver) {
         }
     }
 
+    private void clearReviverState() {
+        if (reviver != null) {
+            reviver.module().getMeta().setReviving(false);
+            reviver.getPlayer().ifPresent(player -> player.sendActionBar(Component.empty()));
+        }
+    }
+
     public boolean isReviving() {
         return reviver != null;
     }
diff --git a/zombies/src/main/java/org/phantazm/zombies/powerup/action/AttributeModifierAction.java b/zombies/src/main/java/org/phantazm/zombies/powerup/action/AttributeModifierAction.java
index 4789ae199..f8a1210f4 100644
--- a/zombies/src/main/java/org/phantazm/zombies/powerup/action/AttributeModifierAction.java
+++ b/zombies/src/main/java/org/phantazm/zombies/powerup/action/AttributeModifierAction.java
@@ -5,6 +5,7 @@
 import net.minestom.server.attribute.AttributeModifier;
 import net.minestom.server.attribute.AttributeOperation;
 import org.jetbrains.annotations.NotNull;
+import org.phantazm.commons.CancellableState;
 import org.phantazm.zombies.Attributes;
 import org.phantazm.zombies.player.ZombiesPlayer;
 import org.phantazm.zombies.powerup.Powerup;
@@ -62,16 +63,20 @@ private Action(Data data, DeactivationPredicate deactivationPredicate,
         }
 
         private void applyAttribute(ZombiesPlayer player) {
-            player.getPlayer().ifPresent(p -> {
-                p.getAttribute(attribute).addModifier(
-                        new AttributeModifier(attributeUID, attributeName, data.amount, data.attributeOperation));
-            });
+            player.registerCancellable(CancellableState.named(attributeUID, () -> {
+                player.getPlayer().ifPresent(p -> {
+                    p.getAttribute(attribute).addModifier(
+                            new AttributeModifier(attributeUID, attributeName, data.amount, data.attributeOperation));
+                });
+            }, () -> {
+                player.getPlayer().ifPresent(p -> {
+                    p.getAttribute(attribute).removeModifier(attributeUID);
+                });
+            }), true);
         }
 
         private void removeAttribute(ZombiesPlayer player) {
-            player.getPlayer().ifPresent(p -> {
-                p.getAttribute(attribute).removeModifier(attributeUID);
-            });
+            player.removeCancellable(attributeUID);
         }
 
         @Override
@@ -80,6 +85,10 @@ public void activate(@NotNull Powerup powerup, @NotNull ZombiesPlayer player, lo
 
             if (data.global) {
                 for (ZombiesPlayer zombiesPlayer : playerMap.values()) {
+                    if (zombiesPlayer.hasQuit()) {
+                        continue;
+                    }
+
                     applyAttribute(zombiesPlayer);
                 }
             }
@@ -92,6 +101,10 @@ public void activate(@NotNull Powerup powerup, @NotNull ZombiesPlayer player, lo
         public void deactivate(@NotNull ZombiesPlayer player) {
             if (data.global) {
                 for (ZombiesPlayer zombiesPlayer : playerMap.values()) {
+                    if (zombiesPlayer.hasQuit()) {
+                        continue;
+                    }
+
                     removeAttribute(zombiesPlayer);
                 }
             }
diff --git a/zombies/src/main/java/org/phantazm/zombies/powerup/action/BossBarTimerAction.java b/zombies/src/main/java/org/phantazm/zombies/powerup/action/BossBarTimerAction.java
index 92d75a7fe..bc53e1b92 100644
--- a/zombies/src/main/java/org/phantazm/zombies/powerup/action/BossBarTimerAction.java
+++ b/zombies/src/main/java/org/phantazm/zombies/powerup/action/BossBarTimerAction.java
@@ -6,11 +6,14 @@
 import net.minestom.server.MinecraftServer;
 import net.minestom.server.instance.Instance;
 import org.jetbrains.annotations.NotNull;
+import org.phantazm.commons.CancellableState;
 import org.phantazm.commons.MathUtils;
 import org.phantazm.zombies.player.ZombiesPlayer;
 import org.phantazm.zombies.powerup.Powerup;
 import org.phantazm.zombies.powerup.predicate.DeactivationPredicate;
 
+import java.util.Map;
+import java.util.UUID;
 import java.util.function.Supplier;
 
 @Model("zombies.powerup.action.boss_bar_timer")
@@ -18,27 +21,32 @@
 public class BossBarTimerAction implements Supplier<PowerupAction> {
     private final Data data;
     private final Instance instance;
+    private final Map<? super UUID, ? extends ZombiesPlayer> playerMap;
 
     @FactoryMethod
-    public BossBarTimerAction(@NotNull Data data, @NotNull Instance instance) {
+    public BossBarTimerAction(@NotNull Data data, @NotNull Instance instance,
+            @NotNull Map<? super UUID, ? extends ZombiesPlayer> playerMap) {
         this.data = data;
         this.instance = instance;
+        this.playerMap = playerMap;
     }
 
     @Override
     public PowerupAction get() {
-        return new Action(data, instance);
+        return new Action(data, instance, playerMap);
     }
 
     private static class Action implements PowerupAction {
         private final Data data;
         private final Instance instance;
         private final DeactivationPredicate predicate;
+        private final Map<? super UUID, ? extends ZombiesPlayer> playerMap;
+        private final UUID id;
 
         private long startTime = -1;
         private BossBar bossBar;
 
-        private Action(Data data, Instance instance) {
+        private Action(Data data, Instance instance, Map<? super UUID, ? extends ZombiesPlayer> playerMap) {
             this.data = data;
             this.instance = instance;
             this.predicate = new DeactivationPredicate() {
@@ -52,11 +60,14 @@ public boolean shouldDeactivate(long time) {
                     return (time - startTime) / MinecraftServer.TICK_MS >= data.duration;
                 }
             };
+            this.playerMap = playerMap;
+            this.id = UUID.randomUUID();
         }
 
         @Override
         public void tick(long time) {
-            if (startTime < 0) {
+            BossBar bossBar = this.bossBar;
+            if (startTime < 0 || bossBar == null) {
                 return;
             }
 
@@ -68,14 +79,27 @@ public void tick(long time) {
         public void activate(@NotNull Powerup powerup, @NotNull ZombiesPlayer player, long time) {
             this.startTime = System.currentTimeMillis();
 
-            this.bossBar = BossBar.bossBar(data.name, 1.0F, data.color, data.overlay);
-            instance.showBossBar(this.bossBar);
+            BossBar bossBar = BossBar.bossBar(data.name, 1.0F, data.color, data.overlay);
+            instance.showBossBar(bossBar);
+
+            this.bossBar = bossBar;
+
+            for (ZombiesPlayer zombiesPlayer : playerMap.values()) {
+                zombiesPlayer.registerCancellable(CancellableState.named(id, () -> {
+                }, () -> zombiesPlayer.getPlayer().ifPresent(actualPlayer -> actualPlayer.hideBossBar(bossBar))), true);
+            }
         }
 
         @Override
         public void deactivate(@NotNull ZombiesPlayer player) {
+            BossBar bossBar = this.bossBar;
             if (bossBar != null) {
-                instance.hideBossBar(bossBar);
+                for (ZombiesPlayer zombiesPlayer : playerMap.values()) {
+                    zombiesPlayer.removeCancellable(id);
+                }
+
+                MinecraftServer.getBossBarManager().destroyBossBar(bossBar);
+                this.bossBar = null;
             }
         }
 
diff --git a/zombies/src/main/java/org/phantazm/zombies/powerup/action/PreventAmmoDrainAction.java b/zombies/src/main/java/org/phantazm/zombies/powerup/action/PreventAmmoDrainAction.java
index ce43c0da6..8488d494c 100644
--- a/zombies/src/main/java/org/phantazm/zombies/powerup/action/PreventAmmoDrainAction.java
+++ b/zombies/src/main/java/org/phantazm/zombies/powerup/action/PreventAmmoDrainAction.java
@@ -4,43 +4,54 @@
 import net.minestom.server.event.Event;
 import net.minestom.server.event.EventListener;
 import net.minestom.server.event.EventNode;
+import net.minestom.server.instance.Instance;
 import org.jetbrains.annotations.NotNull;
 import org.phantazm.zombies.event.GunLoseAmmoEvent;
 import org.phantazm.zombies.player.ZombiesPlayer;
 import org.phantazm.zombies.powerup.Powerup;
 import org.phantazm.zombies.powerup.predicate.DeactivationPredicate;
 
+import java.util.UUID;
 import java.util.function.Supplier;
 
 @Model("zombies.powerup.action.prevent_ammo_drain")
+@Cache(false)
 public class PreventAmmoDrainAction implements Supplier<PowerupAction> {
     private final Supplier<DeactivationPredicate> deactivationPredicate;
     private final Supplier<? extends EventNode<Event>> eventNode;
+    private final UUID instanceUUID;
 
     @FactoryMethod
     public PreventAmmoDrainAction(
             @NotNull @Child("deactivation_predicate") Supplier<DeactivationPredicate> deactivationPredicate,
-            @NotNull Supplier<? extends EventNode<Event>> eventNode) {
+            @NotNull Supplier<? extends EventNode<Event>> eventNode, @NotNull Instance instance) {
         this.deactivationPredicate = deactivationPredicate;
         this.eventNode = eventNode;
+        this.instanceUUID = instance.getUniqueId();
     }
 
     @Override
     public PowerupAction get() {
-        return new Action(deactivationPredicate.get(), eventNode.get());
+        return new Action(deactivationPredicate.get(), eventNode.get(), instanceUUID);
     }
 
     private static class Action extends PowerupActionBase {
         private final EventListener<GunLoseAmmoEvent> listener;
         private final EventNode<Event> eventNode;
+        private final UUID instanceUUID;
 
-        private Action(DeactivationPredicate deactivationPredicate, EventNode<Event> eventNode) {
+        private Action(DeactivationPredicate deactivationPredicate, EventNode<Event> eventNode, UUID instanceUUID) {
             super(deactivationPredicate);
             this.listener = EventListener.of(GunLoseAmmoEvent.class, this::gunLoseAmmo);
             this.eventNode = eventNode;
+            this.instanceUUID = instanceUUID;
         }
 
         private void gunLoseAmmo(GunLoseAmmoEvent event) {
+            if (!event.getInstance().getUniqueId().equals(instanceUUID)) {
+                return;
+            }
+
             event.setAmmoLost(0);
         }
 
diff --git a/zombies/src/main/java/org/phantazm/zombies/powerup/visual/HologramVisual.java b/zombies/src/main/java/org/phantazm/zombies/powerup/visual/HologramVisual.java
index cc8727f65..790f1ddfc 100644
--- a/zombies/src/main/java/org/phantazm/zombies/powerup/visual/HologramVisual.java
+++ b/zombies/src/main/java/org/phantazm/zombies/powerup/visual/HologramVisual.java
@@ -4,6 +4,9 @@
 import com.github.steanky.element.core.annotation.DataObject;
 import com.github.steanky.element.core.annotation.FactoryMethod;
 import com.github.steanky.element.core.annotation.Model;
+import com.github.steanky.ethylene.core.ConfigElement;
+import com.github.steanky.ethylene.core.ConfigPrimitive;
+import com.github.steanky.ethylene.mapper.annotation.Default;
 import net.kyori.adventure.text.Component;
 import net.minestom.server.MinecraftServer;
 import net.minestom.server.coordinate.Vec;
@@ -34,7 +37,14 @@ public PowerupVisual get() {
     }
 
     @DataObject
-    public record Data(@NotNull List<Component> lines, long timeUntilBlink, @NotNull List<Frame> blinkFrames) {
+    public record Data(@NotNull List<Component> lines,
+                       long timeUntilBlink,
+                       @NotNull List<Frame> blinkFrames,
+                       double heightOffset) {
+        @Default("heightOffset")
+        public static @NotNull ConfigElement heightOffsetDefault() {
+            return ConfigPrimitive.of(0.0);
+        }
     }
 
     public record Frame(@NotNull List<Component> components, long delay) {
@@ -104,7 +114,7 @@ public void spawn(double x, double y, double z) {
                 hologram.clear();
             }
 
-            this.hologram = new InstanceHologram(new Vec(x, y, z), 0, Hologram.Alignment.CENTERED);
+            this.hologram = new InstanceHologram(new Vec(x, y + data.heightOffset, z), 0, Hologram.Alignment.CENTERED);
             this.hologram.addAll(data.lines);
             this.hologram.setInstance(instance);
             this.start = System.currentTimeMillis();
diff --git a/zombies/src/main/java/org/phantazm/zombies/scene/LeaveHandler.java b/zombies/src/main/java/org/phantazm/zombies/scene/LeaveHandler.java
index f47313ae6..826c3866e 100644
--- a/zombies/src/main/java/org/phantazm/zombies/scene/LeaveHandler.java
+++ b/zombies/src/main/java/org/phantazm/zombies/scene/LeaveHandler.java
@@ -1,62 +1,72 @@
 package org.phantazm.zombies.scene;
 
+import it.unimi.dsi.fastutil.Pair;
 import net.kyori.adventure.text.Component;
 import net.kyori.adventure.text.format.NamedTextColor;
 import org.jetbrains.annotations.NotNull;
-import org.phantazm.core.game.scene.RouteResult;
-import org.phantazm.core.player.PlayerView;
+import org.phantazm.core.game.scene.TransferResult;
 import org.phantazm.zombies.player.ZombiesPlayer;
 import org.phantazm.zombies.player.state.ZombiesPlayerStateKeys;
 import org.phantazm.zombies.player.state.context.QuitPlayerStateContext;
 import org.phantazm.zombies.stage.Stage;
 import org.phantazm.zombies.stage.StageTransition;
 
-import java.util.Map;
-import java.util.Objects;
-import java.util.UUID;
+import java.util.*;
 
-public class LeaveHandler {
 
+public class LeaveHandler {
     private final StageTransition stageTransition;
 
-    private final Map<? super UUID, ? extends PlayerView> players;
-
     private final Map<? super UUID, ? extends ZombiesPlayer> zombiesPlayers;
 
-    public LeaveHandler(@NotNull StageTransition stageTransition, @NotNull Map<? super UUID, ? extends PlayerView> players,
+    public LeaveHandler(@NotNull StageTransition stageTransition,
             @NotNull Map<? super UUID, ? extends ZombiesPlayer> zombiesPlayers) {
         this.stageTransition = Objects.requireNonNull(stageTransition, "stageTransition");
-        this.players = Objects.requireNonNull(players, "players");
         this.zombiesPlayers = Objects.requireNonNull(zombiesPlayers, "zombiesPlayers");
     }
 
-    public RouteResult leave(@NotNull Iterable<UUID> leavers) {
+    /**
+     * Handles updating internal state when a player leaves mid-game; not necessary to call at the end of a game as it
+     * will get destroyed regardless. Does not transfer players to another scene; this ONLY updates internal state and
+     * reports whether or the operation was "successful" (if there were players removed from the internal state).
+     *
+     * @param leavers the players who are leaving
+     * @return a {@link TransferResult} representing the operation
+     */
+    public @NotNull TransferResult leave(@NotNull Iterable<UUID> leavers) {
+        List<Pair<UUID, ZombiesPlayer>> leavingPlayers = new ArrayList<>();
+
+        boolean failure = false;
         for (UUID leaver : leavers) {
-            if (!players.containsKey(leaver)) {
-                return new RouteResult(false,
-                        Component.text("Not all players are within the scene.", NamedTextColor.RED));
+            ZombiesPlayer zombiesPlayer = zombiesPlayers.get(leaver);
+            if (zombiesPlayer == null) {
+                failure = true;
+                continue;
             }
+
+            leavingPlayers.add(Pair.of(leaver, zombiesPlayer));
         }
 
-        for (UUID leaver : leavers) {
-            players.remove(leaver);
+        if (failure) {
+            return TransferResult.failure(Component.text("Not all players are within the scene.", NamedTextColor.RED));
+        }
 
+        return TransferResult.success(() -> {
             Stage stage = stageTransition.getCurrentStage();
-            ZombiesPlayer zombiesPlayer;
-            if (stage == null || !stage.hasPermanentPlayers()) {
-                zombiesPlayer = zombiesPlayers.remove(leaver);
-                zombiesPlayer.end();
-            }
-            else {
-                zombiesPlayer = zombiesPlayers.get(leaver);
+            for (Pair<UUID, ZombiesPlayer> pair : leavingPlayers) {
+                ZombiesPlayer zombiesPlayer = pair.right();
+                if (stage != null) {
+                    stage.onLeave(zombiesPlayer);
+                }
 
-                if (zombiesPlayer != null) {
-                    zombiesPlayer.setState(ZombiesPlayerStateKeys.QUIT, new QuitPlayerStateContext(true));
+                zombiesPlayer.setState(ZombiesPlayerStateKeys.QUIT, new QuitPlayerStateContext(true));
+
+                if (stage == null || !stage.hasPermanentPlayers()) {
+                    zombiesPlayers.remove(pair.left());
+                    zombiesPlayer.end();
                 }
             }
-        }
-
-        return RouteResult.SUCCESSFUL;
+        });
     }
 
 }
diff --git a/zombies/src/main/java/org/phantazm/zombies/scene/SceneContainer.java b/zombies/src/main/java/org/phantazm/zombies/scene/SceneContainer.java
deleted file mode 100644
index bd587311a..000000000
--- a/zombies/src/main/java/org/phantazm/zombies/scene/SceneContainer.java
+++ /dev/null
@@ -1,11 +0,0 @@
-package org.phantazm.zombies.scene;
-
-import org.jetbrains.annotations.NotNull;
-
-import java.util.Collection;
-
-public interface SceneContainer<TScene> {
-
-    @NotNull Collection<TScene> getScenes();
-
-}
diff --git a/zombies/src/main/java/org/phantazm/zombies/scene/ZombiesJoinHelper.java b/zombies/src/main/java/org/phantazm/zombies/scene/ZombiesJoinHelper.java
new file mode 100644
index 000000000..a69cb2bd0
--- /dev/null
+++ b/zombies/src/main/java/org/phantazm/zombies/scene/ZombiesJoinHelper.java
@@ -0,0 +1,52 @@
+package org.phantazm.zombies.scene;
+
+import net.kyori.adventure.key.Key;
+import net.minestom.server.entity.Player;
+import org.jetbrains.annotations.NotNull;
+import org.phantazm.core.game.scene.*;
+import org.phantazm.core.player.PlayerView;
+import org.phantazm.core.player.PlayerViewProvider;
+
+import java.util.*;
+import java.util.function.Function;
+
+public class ZombiesJoinHelper {
+
+    private final PlayerViewProvider viewProvider;
+
+    private final SceneRouter<ZombiesScene, ZombiesRouteRequest> router;
+
+    private final SceneTransferHelper transferHelper;
+
+    public ZombiesJoinHelper(@NotNull PlayerViewProvider viewProvider,
+            @NotNull SceneRouter<ZombiesScene, ZombiesRouteRequest> router,
+            @NotNull SceneTransferHelper transferHelper) {
+        this.viewProvider = Objects.requireNonNull(viewProvider, "viewProvider");
+        this.router = Objects.requireNonNull(router, "router");
+        this.transferHelper = Objects.requireNonNull(transferHelper, "transferHelper");
+    }
+
+    public void joinGame(@NotNull Player joiner, @NotNull Collection<PlayerView> playerViews, @NotNull Key targetMap) {
+        joinInternal(joiner, playerViews, joinRequest -> ZombiesRouteRequest.joinGame(targetMap, joinRequest));
+    }
+
+    public void rejoinGame(@NotNull Player joiner, @NotNull UUID targetGame) {
+        joinInternal(joiner, Collections.singleton(viewProvider.fromPlayer(joiner)),
+                joinRequest -> ZombiesRouteRequest.rejoinGame(targetGame, joinRequest));
+    }
+
+    private void joinInternal(@NotNull Player joiner, @NotNull Collection<PlayerView> playerViews,
+            @NotNull Function<ZombiesJoinRequest, ZombiesRouteRequest> routeRequestCreator) {
+        ZombiesJoinRequest joinRequest = () -> playerViews;
+        RouteResult<ZombiesScene> result = router.findScene(routeRequestCreator.apply(joinRequest));
+
+        if (result.message().isPresent()) {
+            joiner.sendMessage(result.message().get());
+        }
+        else if (result.scene().isPresent()) {
+            ZombiesScene scene = result.scene().get();
+            transferHelper.transfer(scene, joinRequest, playerViews, viewProvider.fromPlayer(joiner));
+        }
+    }
+
+}
diff --git a/zombies/src/main/java/org/phantazm/zombies/scene/ZombiesJoinRequest.java b/zombies/src/main/java/org/phantazm/zombies/scene/ZombiesJoinRequest.java
index 25fb20b90..af6c1fa05 100644
--- a/zombies/src/main/java/org/phantazm/zombies/scene/ZombiesJoinRequest.java
+++ b/zombies/src/main/java/org/phantazm/zombies/scene/ZombiesJoinRequest.java
@@ -5,6 +5,8 @@
 import org.phantazm.core.player.PlayerView;
 
 import java.util.Collection;
+import java.util.Set;
+import java.util.UUID;
 
 public interface ZombiesJoinRequest extends SceneJoinRequest {
 
diff --git a/zombies/src/main/java/org/phantazm/zombies/scene/ZombiesScene.java b/zombies/src/main/java/org/phantazm/zombies/scene/ZombiesScene.java
index 750fe2389..00990ce94 100644
--- a/zombies/src/main/java/org/phantazm/zombies/scene/ZombiesScene.java
+++ b/zombies/src/main/java/org/phantazm/zombies/scene/ZombiesScene.java
@@ -1,19 +1,24 @@
 package org.phantazm.zombies.scene;
 
 import com.github.steanky.vector.Vec3I;
+import it.unimi.dsi.fastutil.Pair;
 import net.kyori.adventure.text.Component;
 import net.kyori.adventure.text.format.NamedTextColor;
 import net.minestom.server.MinecraftServer;
 import net.minestom.server.coordinate.Pos;
 import net.minestom.server.entity.Player;
+import net.minestom.server.event.Event;
+import net.minestom.server.event.EventNode;
 import net.minestom.server.instance.Instance;
-import net.minestom.server.network.ConnectionManager;
 import net.minestom.server.network.player.GameProfile;
 import net.minestom.server.network.player.PlayerConnection;
 import net.minestom.server.network.player.PlayerSocketConnection;
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.UnmodifiableView;
+import org.phantazm.commons.TickTaskScheduler;
 import org.phantazm.core.game.scene.InstanceScene;
-import org.phantazm.core.game.scene.RouteResult;
+import org.phantazm.core.game.scene.TransferResult;
+import org.phantazm.core.game.scene.Utils;
 import org.phantazm.core.game.scene.fallback.SceneFallback;
 import org.phantazm.core.player.PlayerView;
 import org.phantazm.zombies.map.MapSettingsInfo;
@@ -24,41 +29,50 @@
 import org.phantazm.zombies.player.state.context.NoContext;
 import org.phantazm.zombies.stage.Stage;
 import org.phantazm.zombies.stage.StageTransition;
+import org.phantazm.stats.zombies.ZombiesDatabase;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
 import java.util.*;
 import java.util.concurrent.CompletableFuture;
 import java.util.function.Function;
+import java.util.stream.Collectors;
 
 public class ZombiesScene extends InstanceScene<ZombiesJoinRequest> {
     private static final Logger LOGGER = LoggerFactory.getLogger(ZombiesScene.class);
     private static final CompletableFuture<?>[] EMPTY_COMPLETABLE_FUTURE_ARRAY = new CompletableFuture[0];
-    private final UUID uuid;
-    private final ConnectionManager connectionManager;
     private final ZombiesMap map;
     private final Map<UUID, ZombiesPlayer> zombiesPlayers;
     private final MapSettingsInfo mapSettingsInfo;
     private final StageTransition stageTransition;
     private final LeaveHandler leaveHandler;
     private final Function<? super PlayerView, ? extends ZombiesPlayer> playerCreator;
+    private final TickTaskScheduler taskScheduler;
+    private final ZombiesDatabase database;
+    private final EventNode<Event> sceneNode;
 
     private boolean joinable = true;
 
-    public ZombiesScene(@NotNull UUID uuid, @NotNull ConnectionManager connectionManager, @NotNull ZombiesMap map,
-            @NotNull Map<UUID, PlayerView> players, @NotNull Map<UUID, ZombiesPlayer> zombiesPlayers,
+    public ZombiesScene(@NotNull UUID uuid, @NotNull ZombiesMap map, @NotNull Map<UUID, ZombiesPlayer> zombiesPlayers,
             @NotNull Instance instance, @NotNull SceneFallback fallback, @NotNull MapSettingsInfo mapSettingsInfo,
             @NotNull StageTransition stageTransition, @NotNull LeaveHandler leaveHandler,
-            @NotNull Function<? super PlayerView, ? extends ZombiesPlayer> playerCreator) {
-        super(instance, players, fallback);
-        this.uuid = Objects.requireNonNull(uuid, "uuid");
-        this.connectionManager = Objects.requireNonNull(connectionManager, "connectionManager");
+            @NotNull Function<? super PlayerView, ? extends ZombiesPlayer> playerCreator,
+            @NotNull TickTaskScheduler taskScheduler, @NotNull ZombiesDatabase database,
+            @NotNull EventNode<Event> sceneNode) {
+        super(uuid, instance, fallback);
         this.map = Objects.requireNonNull(map, "map");
         this.zombiesPlayers = Objects.requireNonNull(zombiesPlayers, "zombiesPlayers");
         this.mapSettingsInfo = Objects.requireNonNull(mapSettingsInfo, "mapSettingsInfo");
         this.stageTransition = Objects.requireNonNull(stageTransition, "stageTransition");
         this.leaveHandler = Objects.requireNonNull(leaveHandler, "leaveHandler");
         this.playerCreator = Objects.requireNonNull(playerCreator, "playerCreator");
+        this.taskScheduler = Objects.requireNonNull(taskScheduler, "taskScheduler");
+        this.database = Objects.requireNonNull(database, "database");
+        this.sceneNode = Objects.requireNonNull(sceneNode, "sceneNode");
+    }
+
+    public @NotNull EventNode<Event> getSceneNode() {
+        return sceneNode;
     }
 
     public @NotNull Map<UUID, ZombiesPlayer> getZombiesPlayers() {
@@ -77,10 +91,6 @@ public boolean isComplete() {
         return stageTransition.isComplete();
     }
 
-    public @NotNull UUID getUuid() {
-        return uuid;
-    }
-
     public @NotNull ZombiesMap getMap() {
         return map;
     }
@@ -90,13 +100,22 @@ public boolean isComplete() {
     }
 
     @Override
-    public @NotNull RouteResult join(@NotNull ZombiesJoinRequest joinRequest) {
+    public @NotNull TransferResult join(@NotNull ZombiesJoinRequest joinRequest) {
+        if (isShutdown()) {
+            return TransferResult.failure(Component.text("Game is shutdown."));
+        }
+        if (!isJoinable()) {
+            return TransferResult.failure(Component.text("Game is not joinable."));
+        }
+
         Collection<ZombiesPlayer> oldPlayers = new ArrayList<>(joinRequest.getPlayers().size());
         Collection<PlayerView> newPlayers = new ArrayList<>(joinRequest.getPlayers().size());
         for (PlayerView player : joinRequest.getPlayers()) {
             ZombiesPlayer zombiesPlayer = zombiesPlayers.get(player.getUUID());
             if (zombiesPlayer != null) {
-                oldPlayers.add(zombiesPlayer);
+                if (zombiesPlayer.hasQuit()) {
+                    oldPlayers.add(zombiesPlayer);
+                }
             }
             else {
                 newPlayers.add(player);
@@ -105,83 +124,95 @@ public boolean isComplete() {
 
         Stage stage = getCurrentStage();
         if (stage == null) {
-            return new RouteResult(false, Component.text("The game is not currently running.", NamedTextColor.RED));
+            return TransferResult.failure(Component.text("The game is not currently running.", NamedTextColor.RED));
         }
         if (stage.hasPermanentPlayers() && !newPlayers.isEmpty()) {
-            return new RouteResult(false, Component.text("The game is not accepting new players.", NamedTextColor.RED));
+            return TransferResult.failure(Component.text("The game is not accepting new players.", NamedTextColor.RED));
         }
 
         if (zombiesPlayers.size() + newPlayers.size() > mapSettingsInfo.maxPlayers()) {
-            return new RouteResult(false, Component.text("Too many players!", NamedTextColor.RED));
+            return TransferResult.failure(Component.text("Too many players!", NamedTextColor.RED));
         }
 
-        RouteResult protocolResult = checkWithinProtocolVersionBounds(newPlayers);
+        TransferResult protocolResult = checkWithinProtocolVersionBounds(newPlayers);
         if (protocolResult != null) {
             return protocolResult;
         }
 
-        for (ZombiesPlayer zombiesPlayer : oldPlayers) {
-            zombiesPlayer.setState(ZombiesPlayerStateKeys.DEAD, DeadPlayerStateContext.rejoin());
-        }
-
-        Vec3I spawn = mapSettingsInfo.origin().add(mapSettingsInfo.spawn());
-        Pos pos = new Pos(spawn.x(), spawn.y(), spawn.z(), mapSettingsInfo.yaw(), mapSettingsInfo.pitch());
-        List<PlayerView> teleportedViews = new ArrayList<>(newPlayers.size());
-        List<Player> teleportedPlayers = new ArrayList<>(newPlayers.size());
-        List<CompletableFuture<?>> futures = new ArrayList<>(newPlayers.size());
-        for (PlayerView view : newPlayers) {
-            view.getPlayer().ifPresent(player -> {
-                teleportedViews.add(view);
-                teleportedPlayers.add(player);
-                futures.add(player.setInstance(instance, pos));
-            });
-        }
+        return TransferResult.success(() -> {
+            Vec3I spawn = mapSettingsInfo.origin().add(mapSettingsInfo.spawn());
+            Pos pos = new Pos(spawn.x(), spawn.y(), spawn.z(), mapSettingsInfo.yaw(), mapSettingsInfo.pitch());
+            List<Pair<Player, Instance>> teleportedPlayers = new ArrayList<>(oldPlayers.size() + newPlayers.size());
+            List<CompletableFuture<?>> futures = new ArrayList<>(oldPlayers.size() + newPlayers.size());
+            List<Runnable> runnables = new ArrayList<>(oldPlayers.size() + newPlayers.size());
+            for (ZombiesPlayer zombiesPlayer : oldPlayers) {
+                zombiesPlayer.getPlayer().ifPresent(player -> {
+                    teleportedPlayers.add(Pair.of(player, player.getInstance()));
+                    if (player.getInstance() == instance) {
+                        futures.add(player.teleport(pos));
+                    }
+                    else {
+                        futures.add(player.setInstance(instance, pos));
+                    }
+                    runnables.add(() -> {
+                        zombiesPlayer.setState(ZombiesPlayerStateKeys.DEAD, DeadPlayerStateContext.rejoin());
+                    });
+                });
+            }
+            for (PlayerView view : newPlayers) {
+                view.getPlayer().ifPresent(player -> {
+                    teleportedPlayers.add(Pair.of(player, player.getInstance()));
+                    if (player.getInstance() == instance) {
+                        futures.add(player.teleport(pos));
+                    }
+                    else {
+                        futures.add(player.setInstance(instance, pos));
+                    }
+                    runnables.add(() -> {
+                        ZombiesPlayer zombiesPlayer = playerCreator.apply(view);
+                        zombiesPlayer.start();
+                        zombiesPlayer.setState(ZombiesPlayerStateKeys.ALIVE, NoContext.INSTANCE);
+                        zombiesPlayers.put(view.getUUID(), zombiesPlayer);
+                    });
+                });
+            }
 
-        CompletableFuture.allOf(futures.toArray(EMPTY_COMPLETABLE_FUTURE_ARRAY)).thenRun(() -> {
-            for (int i = 0; i < futures.size(); ++i) {
-                PlayerView view = teleportedViews.get(i);
-                Player teleportedPlayer = teleportedPlayers.get(i);
-                CompletableFuture<?> future = futures.get(i);
+            CompletableFuture.allOf(futures.toArray(EMPTY_COMPLETABLE_FUTURE_ARRAY)).whenComplete((ignored, error) -> {
+                for (int i = 0; i < futures.size(); i++) {
+                    Pair<Player, Instance> pair = teleportedPlayers.get(i);
+                    Player teleportedPlayer = pair.first();
+                    Instance oldInstance = pair.second();
 
-                if (future.isCompletedExceptionally()) {
-                    future.whenComplete((ignored, throwable) -> {
-                        LOGGER.warn("Failed to send {} to an instance", teleportedPlayer.getUuid(), throwable);
-                    });
-                    continue;
-                }
+                    CompletableFuture<?> future = futures.get(i);
+                    Runnable runnable = runnables.get(i);
 
-                for (Player otherPlayer : connectionManager.getOnlinePlayers()) {
-                    if (otherPlayer.getInstance() != instance) {
-                        otherPlayer.removeViewer(teleportedPlayer);
-                        teleportedPlayer.sendPacket(otherPlayer.getRemovePlayerToList());
-                        teleportedPlayer.removeViewer(otherPlayer);
-                        otherPlayer.sendPacket(teleportedPlayer.getRemovePlayerToList());
-                    } else {
-                        teleportedPlayer.sendPacket(otherPlayer.getAddPlayerToList());
-                        otherPlayer.addViewer(teleportedPlayer);
-                        otherPlayer.sendPacket(teleportedPlayer.getAddPlayerToList());
-                        teleportedPlayer.addViewer(otherPlayer);
+                    if (future.isCompletedExceptionally()) {
+                        future.whenComplete((ignored1, throwable) -> {
+                            LOGGER.warn("Failed to send {} to an instance", teleportedPlayer.getUuid(), throwable);
+                        });
+                        continue;
                     }
-                }
 
-                ZombiesPlayer zombiesPlayer = playerCreator.apply(view);
-                zombiesPlayer.start();
-                zombiesPlayer.setState(ZombiesPlayerStateKeys.ALIVE, NoContext.INSTANCE);
-                zombiesPlayers.put(view.getUUID(), zombiesPlayer);
-                players.put(view.getUUID(), view);
+                    Utils.handleInstanceTransfer(oldInstance, teleportedPlayer);
 
-                stage.onJoin(zombiesPlayer);
-            }
+                    runnable.run();
+                    stage.onJoin(zombiesPlayers.get(teleportedPlayer.getUuid()));
+                }
+            }).join();
         });
-
-        return RouteResult.SUCCESSFUL;
     }
 
     @Override
-    public @NotNull RouteResult leave(@NotNull Iterable<UUID> leavers) {
+    public @NotNull TransferResult leave(@NotNull Iterable<UUID> leavers) {
         return leaveHandler.leave(leavers);
     }
 
+    @Override
+    public @UnmodifiableView @NotNull Map<UUID, PlayerView> getPlayers() {
+        return zombiesPlayers.entrySet().stream()
+                .collect(Collectors.toMap(Map.Entry::getKey, entry -> entry.getValue().module().getPlayerView()));
+    }
+
     @Override
     public boolean isJoinable() {
         return joinable;
@@ -192,7 +223,12 @@ public void setJoinable(boolean joinable) {
         this.joinable = joinable;
     }
 
-    private RouteResult checkWithinProtocolVersionBounds(@NotNull Collection<PlayerView> newPlayers) {
+    @Override
+    public boolean isQuittable() {
+        return true;
+    }
+
+    private TransferResult checkWithinProtocolVersionBounds(@NotNull Collection<PlayerView> newPlayers) {
         for (PlayerView playerView : newPlayers) {
             Optional<Player> player = playerView.getPlayer();
             if (player.isEmpty()) {
@@ -205,11 +241,11 @@ private RouteResult checkWithinProtocolVersionBounds(@NotNull Collection<PlayerV
             int protocolVersion = getActualProtocolVersion(player.get().getPlayerConnection());
 
             if (hasMinimum && protocolVersion < mapSettingsInfo.minimumProtocolVersion()) {
-                return new RouteResult(false,
+                return TransferResult.failure(
                         Component.text("A player's Minecraft version is too old!", NamedTextColor.RED));
             }
             if (hasMaximum && protocolVersion > mapSettingsInfo.maximumProtocolVersion()) {
-                return new RouteResult(false,
+                return TransferResult.failure(
                         Component.text("A player's Minecraft version is too new!", NamedTextColor.RED));
             }
         }
@@ -255,9 +291,17 @@ public int getJoinWeight(@NotNull ZombiesJoinRequest request) {
 
     @Override
     public void shutdown() {
+        taskScheduler.end();
         for (ZombiesPlayer zombiesPlayer : zombiesPlayers.values()) {
+            database.synchronizeZombiesPlayerMapStats(zombiesPlayer.module().getStats());
+
+            if (!zombiesPlayer.hasQuit()) {
+                fallback.fallback(zombiesPlayer.module().getPlayerView());
+            }
+
             zombiesPlayer.end();
         }
+
         super.shutdown();
     }
 
@@ -269,9 +313,14 @@ public void tick(long time) {
             return;
         }
 
-        map.tick(time);
         stageTransition.tick(time);
+        map.tick(time);
+        taskScheduler.tick(time);
         for (ZombiesPlayer zombiesPlayer : zombiesPlayers.values()) {
+            if (zombiesPlayer.hasQuit()) {
+                continue;
+            }
+
             zombiesPlayer.tick(time);
         }
     }
diff --git a/zombies/src/main/java/org/phantazm/zombies/scene/ZombiesSceneProvider.java b/zombies/src/main/java/org/phantazm/zombies/scene/ZombiesSceneProvider.java
index 4d6911298..c8f622a38 100644
--- a/zombies/src/main/java/org/phantazm/zombies/scene/ZombiesSceneProvider.java
+++ b/zombies/src/main/java/org/phantazm/zombies/scene/ZombiesSceneProvider.java
@@ -10,7 +10,6 @@
 import it.unimi.dsi.fastutil.longs.LongList;
 import net.kyori.adventure.key.Key;
 import net.kyori.adventure.text.Component;
-import net.kyori.adventure.text.format.NamedTextColor;
 import net.minestom.server.coordinate.Pos;
 import net.minestom.server.event.Event;
 import net.minestom.server.event.EventNode;
@@ -20,9 +19,10 @@
 import net.minestom.server.event.item.ItemDropEvent;
 import net.minestom.server.event.player.*;
 import net.minestom.server.instance.Instance;
-import net.minestom.server.instance.InstanceManager;
-import net.minestom.server.network.ConnectionManager;
+import net.minestom.server.scoreboard.Team;
 import org.jetbrains.annotations.NotNull;
+import org.phantazm.commons.BasicTickTaskScheduler;
+import org.phantazm.commons.TickTaskScheduler;
 import org.phantazm.core.ClientBlockHandlerSource;
 import org.phantazm.core.VecUtils;
 import org.phantazm.core.game.scene.SceneProviderAbstract;
@@ -33,6 +33,7 @@
 import org.phantazm.core.sound.SongPlayer;
 import org.phantazm.core.time.AnalogTickFormatter;
 import org.phantazm.core.time.DurationTickFormatter;
+import org.phantazm.core.time.PrecisionSecondTickFormatter;
 import org.phantazm.core.time.TickFormatter;
 import org.phantazm.core.tracker.BoundedTracker;
 import org.phantazm.mob.MobModel;
@@ -41,6 +42,7 @@
 import org.phantazm.mob.trigger.EventTriggers;
 import org.phantazm.proxima.bindings.minestom.InstanceSpawner;
 import org.phantazm.zombies.Attributes;
+import org.phantazm.zombies.corpse.CorpseCreator;
 import org.phantazm.zombies.event.EntityDamageByGunEvent;
 import org.phantazm.zombies.listener.*;
 import org.phantazm.zombies.map.*;
@@ -57,6 +59,7 @@
 import org.phantazm.zombies.sidebar.SidebarModule;
 import org.phantazm.zombies.sidebar.SidebarUpdater;
 import org.phantazm.zombies.stage.*;
+import org.phantazm.stats.zombies.ZombiesDatabase;
 
 import java.util.*;
 import java.util.function.Function;
@@ -64,15 +67,15 @@
 
 public class ZombiesSceneProvider extends SceneProviderAbstract<ZombiesScene, ZombiesJoinRequest> {
     private final Function<? super Instance, ? extends InstanceSpawner.InstanceSettings> instanceSpaceFunction;
-    private final IdentityHashMap<ZombiesScene, SceneContext> contexts;
     private final MapInfo mapInfo;
-    private final ConnectionManager connectionManager;
-    private final InstanceManager instanceManager;
     private final InstanceLoader instanceLoader;
     private final SceneFallback sceneFallback;
-    private final EventNode<Event> eventNode;
+    private final EventNode<Event> rootNode;
     private final ContextManager contextManager;
     private final KeyParser keyParser;
+    private final Team mobNoPushTeam;
+    private final Team corpseTeam;
+    private final ZombiesDatabase database;
 
     private final MapObjects.Source mapObjectSource;
     private final ZombiesPlayer.Source zombiesPlayerSource;
@@ -81,29 +84,30 @@ public class ZombiesSceneProvider extends SceneProviderAbstract<ZombiesScene, Zo
     private final WindowHandler.Source windowHandlerSource;
     private final DoorHandler.Source doorHandlerSource;
 
+    private final CorpseCreator.Source corpseCreatorSource;
+
     public ZombiesSceneProvider(int maximumScenes,
             @NotNull Function<? super Instance, ? extends InstanceSpawner.InstanceSettings> instanceSpaceFunction,
-            @NotNull MapInfo mapInfo, @NotNull ConnectionManager connectionManager,
-            @NotNull InstanceManager instanceManager, @NotNull InstanceLoader instanceLoader,
-            @NotNull SceneFallback sceneFallback, @NotNull EventNode<Event> eventNode,
-            @NotNull MobSpawnerSource mobSpawnerSource, @NotNull Map<Key, MobModel> mobModels,
-            @NotNull ClientBlockHandlerSource clientBlockHandlerSource, @NotNull ContextManager contextManager,
-            @NotNull KeyParser keyParser, @NotNull Map<Key, PowerupInfo> powerups,
-            @NotNull ZombiesPlayer.Source zombiesPlayerSource) {
+            @NotNull MapInfo mapInfo, @NotNull InstanceLoader instanceLoader, @NotNull SceneFallback sceneFallback,
+            @NotNull EventNode<Event> rootNode, @NotNull MobSpawnerSource mobSpawnerSource,
+            @NotNull Map<Key, MobModel> mobModels, @NotNull ClientBlockHandlerSource clientBlockHandlerSource,
+            @NotNull ContextManager contextManager, @NotNull KeyParser keyParser, @NotNull Team mobNoPushTeam,
+            @NotNull Team corpseTeam, @NotNull ZombiesDatabase database, @NotNull Map<Key, PowerupInfo> powerups,
+            @NotNull ZombiesPlayer.Source zombiesPlayerSource, @NotNull CorpseCreator.Source corpseCreatorSource) {
         super(maximumScenes);
         this.instanceSpaceFunction = Objects.requireNonNull(instanceSpaceFunction, "instanceSpaceFunction");
-        this.contexts = new IdentityHashMap<>(maximumScenes);
         this.mapInfo = Objects.requireNonNull(mapInfo, "mapInfo");
-        this.connectionManager = Objects.requireNonNull(connectionManager, "connectionManager");
-        this.instanceManager = Objects.requireNonNull(instanceManager, "instanceManager");
         this.instanceLoader = Objects.requireNonNull(instanceLoader, "instanceLoader");
         this.sceneFallback = Objects.requireNonNull(sceneFallback, "sceneFallback");
-        this.eventNode = Objects.requireNonNull(eventNode, "eventNode");
+        this.rootNode = Objects.requireNonNull(rootNode, "eventNode");
         this.contextManager = Objects.requireNonNull(contextManager, "contextManager");
         this.keyParser = Objects.requireNonNull(keyParser, "keyParser");
+        this.database = Objects.requireNonNull(database, "database");
         Objects.requireNonNull(powerups, "powerups");
 
         MapSettingsInfo settingsInfo = mapInfo.settings();
+        this.mobNoPushTeam = settingsInfo.mobPlayerCollisions() ? null : mobNoPushTeam;
+        this.corpseTeam = Objects.requireNonNull(corpseTeam, "corpseTeam");
 
         this.mapObjectSource = new BasicMapObjectsSource(mapInfo, contextManager, mobSpawnerSource, mobModels,
                 clientBlockHandlerSource, keyParser);
@@ -115,10 +119,13 @@ public ZombiesSceneProvider(int maximumScenes,
                 new BasicWindowHandlerSource(settingsInfo.windowRepairRadius(), settingsInfo.windowRepairTicks(),
                         settingsInfo.repairCoins());
         this.doorHandlerSource = new BasicDoorHandlerSource();
+
+        this.corpseCreatorSource = Objects.requireNonNull(corpseCreatorSource, "corpseCreatorSource");
     }
 
     @Override
     protected @NotNull Optional<ZombiesScene> chooseScene(@NotNull ZombiesJoinRequest request) {
+        sceneLoop:
         for (ZombiesScene scene : getScenes()) {
             if (scene.isComplete() || !scene.isJoinable() || scene.isShutdown()) {
                 continue;
@@ -132,9 +139,17 @@ public ZombiesSceneProvider(int maximumScenes,
             int maxPlayers = scene.getMapSettingsInfo().maxPlayers();
             int currentPlayerCount = scene.getZombiesPlayers().size();
 
-            if (currentPlayerCount + request.getPlayers().size() <= maxPlayers) {
-                return Optional.of(scene);
+            if (currentPlayerCount + request.getPlayers().size() > maxPlayers) {
+                continue;
+            }
+
+            for (PlayerView view : request.getPlayers()) {
+                if (scene.getZombiesPlayers().containsKey(view.getUUID())) {
+                    continue sceneLoop;
+                }
             }
+
+            return Optional.of(scene);
         }
 
         return Optional.empty();
@@ -142,6 +157,13 @@ public ZombiesSceneProvider(int maximumScenes,
 
     @Override
     protected @NotNull ZombiesScene createScene(@NotNull ZombiesJoinRequest request) {
+        Wrapper<RoundHandler> roundHandlerWrapper = Wrapper.ofNull();
+        Wrapper<PowerupHandler> powerupHandlerWrapper = Wrapper.ofNull();
+        Wrapper<WindowHandler> windowHandlerWrapper = Wrapper.ofNull();
+        Wrapper<EventNode<Event>> eventNodeWrapper = Wrapper.ofNull();
+        Wrapper<Long> ticksSinceStart = Wrapper.of(0L);
+        Wrapper<ZombiesScene> sceneWrapper = Wrapper.ofNull();
+
         MapSettingsInfo settings = mapInfo.settings();
         Pos spawnPos = VecUtils.toPos(settings.origin().add(settings.spawn()));
 
@@ -154,18 +176,14 @@ public ZombiesSceneProvider(int maximumScenes,
         Map<UUID, ZombiesPlayer> zombiesPlayers = new LinkedHashMap<>(settings.maxPlayers());
 
         MobStore mobStore = new MobStore();
-
-        Wrapper<RoundHandler> roundHandlerWrapper = Wrapper.ofNull();
-        Wrapper<PowerupHandler> powerupHandlerWrapper = Wrapper.ofNull();
-        Wrapper<WindowHandler> windowHandlerWrapper = Wrapper.ofNull();
-        Wrapper<EventNode<Event>> eventNodeWrapper = Wrapper.ofNull();
+        TickTaskScheduler tickTaskScheduler = new BasicTickTaskScheduler();
 
         SongPlayer songPlayer = new BasicSongPlayer();
         MapObjects mapObjects =
-                createMapObjects(instance, zombiesPlayers, roundHandlerWrapper, mobStore, powerupHandlerWrapper,
-                        windowHandlerWrapper, eventNodeWrapper, songPlayer);
+                createMapObjects(instance, zombiesPlayers, roundHandlerWrapper, mobStore, mobNoPushTeam, corpseTeam,
+                        powerupHandlerWrapper, windowHandlerWrapper, eventNodeWrapper, songPlayer, tickTaskScheduler);
 
-        RoundHandler roundHandler = new BasicRoundHandler(mapObjects.rounds());
+        RoundHandler roundHandler = new BasicRoundHandler(zombiesPlayers.values(), mapObjects.rounds());
         roundHandlerWrapper.set(roundHandler);
 
         PowerupHandler powerupHandler =
@@ -183,16 +201,16 @@ public ZombiesSceneProvider(int maximumScenes,
                 new ZombiesMap(mapObjects, songPlayer, powerupHandler, roundHandler, shopHandler, windowHandler,
                         doorHandler, mobStore);
 
-        Wrapper<Long> ticksSinceStart = Wrapper.of(0L);
+
         SidebarModule sidebarModule =
                 new SidebarModule(zombiesPlayers, zombiesPlayers.values(), roundHandler, ticksSinceStart,
                         settings.maxPlayers());
         StageTransition stageTransition =
-                createStageTransition(instance, settings.introMessages(), mapObjects.module().random(),
-                        zombiesPlayers.values(), spawnPos, roundHandler, ticksSinceStart, sidebarModule, shopHandler);
+                createStageTransition(instance, mapObjects.module().random(), zombiesPlayers.values(), spawnPos,
+                        roundHandler, ticksSinceStart, sidebarModule, shopHandler);
+
+        LeaveHandler leaveHandler = new LeaveHandler(stageTransition, zombiesPlayers);
 
-        Map<UUID, PlayerView> players = new HashMap<>();
-        LeaveHandler leaveHandler = new LeaveHandler(stageTransition, players, zombiesPlayers);
 
         EventNode<Event> childNode =
                 createEventNode(instance, zombiesPlayers, mapObjects, roundHandler, shopHandler, windowHandler,
@@ -200,7 +218,9 @@ public ZombiesSceneProvider(int maximumScenes,
                         leaveHandler);
         eventNodeWrapper.set(childNode);
 
-        Wrapper<ZombiesScene> sceneWrapper = Wrapper.ofNull();
+        CorpseCreator corpseCreator = createCorpseCreator(mapObjects.mapDependencyProvider());
+
+
         Function<? super PlayerView, ? extends ZombiesPlayer> playerCreator = playerView -> {
             playerView.getPlayer().ifPresent(player -> {
                 player.getAttribute(Attributes.HEAL_TICKS).setBaseValue(settings.healTicks());
@@ -209,16 +229,13 @@ public ZombiesSceneProvider(int maximumScenes,
 
             return zombiesPlayerSource.createPlayer(sceneWrapper.get(), zombiesPlayers, settings, instance, playerView,
                     mapObjects.module().modifierSource(), new BasicFlaggable(), childNode, mapObjects.module().random(),
-                    mapObjects, mobStore, mapObjects.mobSpawner());
+                    mapObjects, mobStore, mapObjects.mobSpawner(), corpseCreator);
         };
 
-        ZombiesScene scene =
-                new ZombiesScene(UUID.randomUUID(), connectionManager, map, players, zombiesPlayers, instance,
-                        sceneFallback, settings, stageTransition, leaveHandler, playerCreator);
+        ZombiesScene scene = new ZombiesScene(UUID.randomUUID(), map, zombiesPlayers, instance, sceneFallback, settings,
+                stageTransition, leaveHandler, playerCreator, tickTaskScheduler, database, childNode);
         sceneWrapper.set(scene);
-
-        eventNode.addChild(childNode);
-        contexts.put(scene, new SceneContext(childNode));
+        rootNode.addChild(childNode);
 
         InstanceSpawner.InstanceSettings instanceSettings = instanceSpaceFunction.apply(instance);
         instanceSettings.spaceHandler().space().setOverrideFunction((x, y, z) -> {
@@ -234,20 +251,19 @@ public ZombiesSceneProvider(int maximumScenes,
 
     @Override
     protected void cleanupScene(@NotNull ZombiesScene scene) {
-        SceneContext context = contexts.remove(scene);
-        if (context == null) {
-            return;
-        }
+        rootNode.removeChild(scene.getSceneNode());
+    }
 
-        eventNode.removeChild(context.node());
+    private CorpseCreator createCorpseCreator(DependencyProvider mapDependencyProvider) {
+        return corpseCreatorSource.make(mapDependencyProvider);
     }
 
     private MapObjects createMapObjects(Instance instance, Map<? super UUID, ? extends ZombiesPlayer> zombiesPlayers,
-            Supplier<? extends RoundHandler> roundHandlerSupplier, MobStore mobStore,
-            Wrapper<PowerupHandler> powerupHandler, Wrapper<WindowHandler> windowHandler,
-            Wrapper<EventNode<Event>> eventNode, SongPlayer songPlayer) {
-        return mapObjectSource.make(instance, zombiesPlayers, roundHandlerSupplier, mobStore, powerupHandler,
-                windowHandler, eventNode, songPlayer);
+            Supplier<? extends RoundHandler> roundHandlerSupplier, MobStore mobStore, Team mobNoPushTeam,
+            Team corpseTeam, Wrapper<PowerupHandler> powerupHandler, Wrapper<WindowHandler> windowHandler,
+            Wrapper<EventNode<Event>> eventNode, SongPlayer songPlayer, TickTaskScheduler tickTaskScheduler) {
+        return mapObjectSource.make(instance, zombiesPlayers, roundHandlerSupplier, mobStore, mobNoPushTeam,
+                powerupHandler, windowHandler, eventNode, songPlayer, tickTaskScheduler, corpseTeam);
     }
 
     private PowerupHandler createPowerupHandler(Instance instance, Map<? super UUID, ? extends ZombiesPlayer> playerMap,
@@ -324,26 +340,23 @@ private DoorHandler createDoorHandler(BoundedTracker<Door> doorTracker, BoundedT
         return node;
     }
 
-    private @NotNull StageTransition createStageTransition(@NotNull Instance instance,
-            @NotNull List<Component> messages, @NotNull Random random,
+    private @NotNull StageTransition createStageTransition(@NotNull Instance instance, @NotNull Random random,
             @NotNull Collection<? extends ZombiesPlayer> zombiesPlayers, @NotNull Pos spawnPos,
             @NotNull RoundHandler roundHandler, @NotNull Wrapper<Long> ticksSinceStart,
             @NotNull SidebarModule sidebarModule, @NotNull ShopHandler shopHandler) {
         Stage idle = new IdleStage(zombiesPlayers, newSidebarUpdaterCreator(sidebarModule, ElementPath.of("idle")));
 
         LongList alertTicks = LongList.of(400L, 200L, 100L, 80L, 60L, 40L, 20L);
-        TickFormatter tickFormatter =
-                new DurationTickFormatter(new DurationTickFormatter.Data(NamedTextColor.YELLOW, true, false));
 
+        MapSettingsInfo settings = mapInfo.settings();
         Stage countdown =
-                new CountdownStage(instance, zombiesPlayers, messages, random, 400L, alertTicks, tickFormatter,
+                new CountdownStage(instance, zombiesPlayers, settings, random, 400L, alertTicks,
+                        new PrecisionSecondTickFormatter(new PrecisionSecondTickFormatter.Data(0)),
                         newSidebarUpdaterCreator(sidebarModule, ElementPath.of("countdown")));
-
-        MapSettingsInfo settings = mapInfo.settings();
-        Stage inGame = new InGameStage(instance, zombiesPlayers, spawnPos, roundHandler, ticksSinceStart,
+        Stage inGame = new InGameStage(instance, zombiesPlayers, settings, spawnPos, roundHandler, ticksSinceStart,
                 settings.defaultEquipment(), settings.equipmentGroups().keySet(),
-                newSidebarUpdaterCreator(sidebarModule, ElementPath.of("inGame")), shopHandler, new AnalogTickFormatter(
-                new AnalogTickFormatter.Data(NamedTextColor.WHITE, NamedTextColor.WHITE, false)));
+                newSidebarUpdaterCreator(sidebarModule, ElementPath.of("inGame")), shopHandler,
+                new AnalogTickFormatter(new AnalogTickFormatter.Data(false)));
         Stage end = new EndStage(instance, zombiesPlayers, 200L,
                 newSidebarUpdaterCreator(sidebarModule, ElementPath.of("end")));
         return new StageTransition(idle, countdown, inGame, end);
@@ -354,12 +367,4 @@ private DoorHandler createDoorHandler(BoundedTracker<Door> doorTracker, BoundedT
         ElementContext context = contextManager.makeContext(mapInfo.scoreboard());
         return new ElementSidebarUpdaterCreator(sidebarModule, context, keyParser, scoreboardSubNode);
     }
-
-    private record SceneContext(@NotNull EventNode<?> node) {
-
-        public SceneContext {
-            Objects.requireNonNull(node, "node");
-        }
-
-    }
 }
diff --git a/zombies/src/main/java/org/phantazm/zombies/scene/ZombiesSceneRouter.java b/zombies/src/main/java/org/phantazm/zombies/scene/ZombiesSceneRouter.java
index 2b10df561..d69e617dc 100644
--- a/zombies/src/main/java/org/phantazm/zombies/scene/ZombiesSceneRouter.java
+++ b/zombies/src/main/java/org/phantazm/zombies/scene/ZombiesSceneRouter.java
@@ -3,66 +3,51 @@
 import net.kyori.adventure.key.Key;
 import net.kyori.adventure.text.Component;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.UnmodifiableView;
 import org.phantazm.core.game.scene.RouteResult;
-import org.phantazm.core.game.scene.Scene;
 import org.phantazm.core.game.scene.SceneProvider;
-import org.phantazm.core.player.PlayerView;
+import org.phantazm.core.game.scene.SceneRouter;
+import org.phantazm.zombies.player.ZombiesPlayer;
 
 import java.util.*;
 
-public class ZombiesSceneRouter implements Scene<ZombiesRouteRequest>, SceneContainer<ZombiesScene> {
+public class ZombiesSceneRouter implements SceneRouter<ZombiesScene, ZombiesRouteRequest> {
     private final Map<Key, ? extends SceneProvider<ZombiesScene, ZombiesJoinRequest>> sceneProviders;
-    private final Map<UUID, ZombiesScene> playerSceneMap = new HashMap<>();
 
-    private final Map<UUID, PlayerView> unmodifiablePlayers = new AbstractMap<>() {
-
-        @Override
-        public boolean containsKey(Object key) {
-            if (!(key instanceof UUID uuid)) {
-                return false;
-            }
+    private boolean shutdown = false;
+    private boolean joinable = true;
 
-            return playerSceneMap.containsKey(uuid);
-        }
+    public ZombiesSceneRouter(
+            @NotNull Map<Key, ? extends SceneProvider<ZombiesScene, ZombiesJoinRequest>> sceneProviders) {
+        this.sceneProviders = Objects.requireNonNull(sceneProviders, "sceneProviders");
+    }
 
-        @Override
-        public PlayerView get(Object key) {
-            if (!(key instanceof UUID uuid)) {
-                return null;
-            }
+    @Override
+    public @NotNull Optional<ZombiesScene> getCurrentScene(@NotNull UUID uuid) {
+        for (SceneProvider<ZombiesScene, ZombiesJoinRequest> sceneProvider : sceneProviders.values()) {
+            for (ZombiesScene scene : sceneProvider.getScenes()) {
+                ZombiesPlayer player = scene.getZombiesPlayers().get(uuid);
 
-            ZombiesScene scene = playerSceneMap.get(uuid);
-            if (scene == null) {
-                return null;
+                if (player != null && !player.hasQuit()) {
+                    return Optional.of(scene);
+                }
             }
-
-            return scene.getPlayers().get(uuid);
         }
 
-        @NotNull
-        @Override
-        public Set<Entry<UUID, PlayerView>> entrySet() {
-            Set<Entry<UUID, PlayerView>> entrySet = new HashSet<>();
-            for (ZombiesScene scene : playerSceneMap.values()) {
-                entrySet.addAll(scene.getPlayers().entrySet());
-            }
+        return Optional.empty();
+    }
 
-            return Collections.unmodifiableSet(entrySet);
+    @Override
+    public @NotNull Collection<ZombiesScene> getScenesContainingPlayer(@NotNull UUID playerUUID) {
+        Collection<ZombiesScene> scenes = new ArrayList<>();
+        for (SceneProvider<ZombiesScene, ZombiesJoinRequest> sceneProvider : sceneProviders.values()) {
+            for (ZombiesScene scene : sceneProvider.getScenes()) {
+                if (scene.getZombiesPlayers().containsKey(playerUUID)) {
+                    scenes.add(scene);
+                }
+            }
         }
 
-    };
-
-    private boolean shutdown = false;
-    private boolean joinable = true;
-
-    public ZombiesSceneRouter(
-            @NotNull Map<Key, ? extends SceneProvider<ZombiesScene, ZombiesJoinRequest>> sceneProviders) {
-        this.sceneProviders = Objects.requireNonNull(sceneProviders, "sceneProviders");
-    }
-
-    public @NotNull Optional<ZombiesScene> getScene(@NotNull UUID uuid) {
-        return Optional.ofNullable(playerSceneMap.get(uuid));
+        return scenes;
     }
 
     @Override
@@ -73,12 +58,12 @@ public void tick(long time) {
     }
 
     @Override
-    public @NotNull RouteResult join(@NotNull ZombiesRouteRequest routeRequest) {
+    public @NotNull RouteResult<ZombiesScene> findScene(@NotNull ZombiesRouteRequest routeRequest) {
         if (isShutdown()) {
-            return new RouteResult(false, Component.text("The router is shutdown."));
+            return RouteResult.failure(Component.text("The router is shutdown."));
         }
         if (!isJoinable()) {
-            return new RouteResult(false, Component.text("The router is not joinable."));
+            return RouteResult.failure(Component.text("The router is not joinable."));
         }
 
         if (routeRequest.targetMap() != null) {
@@ -88,86 +73,24 @@ public void tick(long time) {
         return rejoinGame(routeRequest);
     }
 
-    private RouteResult joinGame(ZombiesRouteRequest routeRequest) {
+    private RouteResult<ZombiesScene> joinGame(ZombiesRouteRequest routeRequest) {
         SceneProvider<ZombiesScene, ZombiesJoinRequest> sceneProvider = sceneProviders.get(routeRequest.targetMap());
         if (sceneProvider == null) {
-            return new RouteResult(false, Component.text("No games exist with key " + routeRequest.targetMap() + "."));
-        }
-
-        ZombiesJoinRequest joinRequest = routeRequest.joinRequest();
-        Optional<ZombiesScene> sceneOptional = sceneProvider.provideScene(joinRequest);
-        if (sceneOptional.isPresent()) {
-            ZombiesScene scene = sceneOptional.get();
-            RouteResult result = scene.join(joinRequest);
-            if (result.success()) {
-                for (PlayerView playerView : routeRequest.joinRequest().getPlayers()) {
-                    ZombiesScene oldScene = playerSceneMap.get(playerView.getUUID());
-                    if (oldScene != null && oldScene != scene) {
-                        oldScene.leave(Collections.singleton(playerView.getUUID()));
-                    }
-
-                    playerSceneMap.put(playerView.getUUID(), scene);
-                }
-            }
-
-            return result;
+            return RouteResult.failure(Component.text("No games exist with key " + routeRequest.targetMap() + "."));
         }
 
-        return new RouteResult(false, Component.text("No games are joinable."));
+        return sceneProvider.provideScene(routeRequest.joinRequest()).map(RouteResult::success)
+                .orElseGet(() -> RouteResult.failure(Component.text("No games are joinable.")));
     }
 
-    // TODO: optimize
-    private RouteResult rejoinGame(ZombiesRouteRequest routeRequest) {
+    private RouteResult<ZombiesScene> rejoinGame(ZombiesRouteRequest routeRequest) {
         for (ZombiesScene scene : getScenes()) {
-            if (!scene.getUuid().equals(routeRequest.targetGame())) {
-                return scene.join(routeRequest.joinRequest());
-            }
-        }
-
-        return new RouteResult(false, Component.text("Not a valid game."));
-    }
-
-    @Override
-    public @NotNull RouteResult leave(@NotNull Iterable<UUID> leavers) {
-        for (UUID uuid : leavers) {
-            if (!playerSceneMap.containsKey(uuid)) {
-                return new RouteResult(false, Component.text(uuid + " is not part of a game in the Zombies router."));
+            if (scene.getUUID().equals(routeRequest.targetGame())) {
+                return RouteResult.success(scene);
             }
         }
 
-        for (UUID uuid : leavers) {
-            playerSceneMap.get(uuid).leave(Collections.singleton(uuid));
-        }
-
-        return RouteResult.SUCCESSFUL;
-    }
-
-    @Override
-    public @UnmodifiableView @NotNull Map<UUID, PlayerView> getPlayers() {
-        return unmodifiablePlayers;
-    }
-
-    @Override
-    public int getIngamePlayerCount() {
-        int playerCount = 0;
-
-        for (SceneProvider<ZombiesScene, ZombiesJoinRequest> sceneProvider : sceneProviders.values()) {
-            for (ZombiesScene scene : sceneProvider.getScenes()) {
-                playerCount += scene.getPlayers().size();
-            }
-        }
-
-        return playerCount;
-    }
-
-    @Override
-    public int getJoinWeight(@NotNull ZombiesRouteRequest request) {
-        int count = 0;
-        for (SceneProvider<ZombiesScene, ZombiesJoinRequest> sceneProvider : sceneProviders.values()) {
-            count += sceneProvider.getScenes().size();
-        }
-
-        return -count;
+        return RouteResult.failure(Component.text("Not a valid game."));
     }
 
     @Override
@@ -190,6 +113,11 @@ public void setJoinable(boolean joinable) {
         this.joinable = joinable;
     }
 
+    @Override
+    public boolean isGame() {
+        return true;
+    }
+
     @Override
     public @NotNull Collection<ZombiesScene> getScenes() {
         Collection<ZombiesScene> scenes = new ArrayList<>();
@@ -199,4 +127,15 @@ public void setJoinable(boolean joinable) {
 
         return scenes;
     }
+
+    @Override
+    public boolean hasActiveScenes() {
+        for (SceneProvider<ZombiesScene, ZombiesJoinRequest> sceneProvider : sceneProviders.values()) {
+            if (sceneProvider.hasActiveScenes()) {
+                return true;
+            }
+        }
+
+        return false;
+    }
 }
diff --git a/zombies/src/main/java/org/phantazm/zombies/sidebar/lineupdater/JoinedPlayersSidebarLineUpdater.java b/zombies/src/main/java/org/phantazm/zombies/sidebar/lineupdater/JoinedPlayersSidebarLineUpdater.java
index a78401d1a..720fd1ec3 100644
--- a/zombies/src/main/java/org/phantazm/zombies/sidebar/lineupdater/JoinedPlayersSidebarLineUpdater.java
+++ b/zombies/src/main/java/org/phantazm/zombies/sidebar/lineupdater/JoinedPlayersSidebarLineUpdater.java
@@ -1,10 +1,11 @@
 package org.phantazm.zombies.sidebar.lineupdater;
 
 import com.github.steanky.element.core.annotation.Cache;
+import com.github.steanky.element.core.annotation.DataObject;
 import com.github.steanky.element.core.annotation.FactoryMethod;
 import com.github.steanky.element.core.annotation.Model;
 import net.kyori.adventure.text.Component;
-import net.kyori.adventure.text.format.NamedTextColor;
+import net.kyori.adventure.text.minimessage.MiniMessage;
 import org.jetbrains.annotations.NotNull;
 import org.phantazm.zombies.player.ZombiesPlayer;
 
@@ -13,6 +14,7 @@
 @Model("zombies.sidebar.line_updater.joined_players")
 @Cache(false)
 public class JoinedPlayersSidebarLineUpdater implements SidebarLineUpdater {
+    private final Data data;
 
     private final Collection<? extends ZombiesPlayer> zombiesPlayers;
 
@@ -21,8 +23,9 @@ public class JoinedPlayersSidebarLineUpdater implements SidebarLineUpdater {
     private int currentPlayers = -1;
 
     @FactoryMethod
-    public JoinedPlayersSidebarLineUpdater(@NotNull Map<? super UUID, ? extends ZombiesPlayer> zombiesPlayers,
-            int maxPlayers) {
+    public JoinedPlayersSidebarLineUpdater(@NotNull Data data,
+            @NotNull Map<? super UUID, ? extends ZombiesPlayer> zombiesPlayers, int maxPlayers) {
+        this.data = data;
         this.zombiesPlayers = zombiesPlayers.values();
         this.maxPlayers = maxPlayers;
     }
@@ -36,10 +39,23 @@ public void invalidateCache() {
     public @NotNull Optional<Component> tick(long time) {
         if (currentPlayers == -1 || currentPlayers != zombiesPlayers.size()) {
             currentPlayers = zombiesPlayers.size();
-            return Optional.of(Component.textOfChildren(Component.text("Players: "),
-                    Component.text(currentPlayers + "/" + maxPlayers, NamedTextColor.GREEN)));
+
+            String formatted;
+            try {
+                formatted = String.format(data.formatString, currentPlayers, maxPlayers);
+            }
+            catch (IllegalFormatException ignored) {
+                formatted = data.formatString;
+            }
+
+            return Optional.of(MiniMessage.miniMessage().deserialize(formatted));
         }
 
         return Optional.empty();
     }
+
+    @DataObject
+    public record Data(@NotNull String formatString) {
+
+    }
 }
diff --git a/zombies/src/main/java/org/phantazm/zombies/sidebar/lineupdater/RemainingZombiesSidebarLineUpdater.java b/zombies/src/main/java/org/phantazm/zombies/sidebar/lineupdater/RemainingZombiesSidebarLineUpdater.java
index 385c12ff1..e14536a69 100644
--- a/zombies/src/main/java/org/phantazm/zombies/sidebar/lineupdater/RemainingZombiesSidebarLineUpdater.java
+++ b/zombies/src/main/java/org/phantazm/zombies/sidebar/lineupdater/RemainingZombiesSidebarLineUpdater.java
@@ -16,7 +16,7 @@
 @Model("zombies.sidebar.line_updater.remaining_zombies")
 public class RemainingZombiesSidebarLineUpdater implements SidebarLineUpdater {
     private final Data data;
-    private final Supplier<? extends Optional<Round>> roundSupplier;
+    private final Supplier<Optional<Round>> roundSupplier;
     private int lastRemainingZombies = -1;
 
     @FactoryMethod
diff --git a/zombies/src/main/java/org/phantazm/zombies/sidebar/lineupdater/RoundSidebarLineUpdater.java b/zombies/src/main/java/org/phantazm/zombies/sidebar/lineupdater/RoundSidebarLineUpdater.java
index 481043d3b..2975b4bf5 100644
--- a/zombies/src/main/java/org/phantazm/zombies/sidebar/lineupdater/RoundSidebarLineUpdater.java
+++ b/zombies/src/main/java/org/phantazm/zombies/sidebar/lineupdater/RoundSidebarLineUpdater.java
@@ -36,8 +36,8 @@ public void invalidateCache() {
         int newIndex = roundHandler.currentRoundIndex();
         if ((lastRoundIndex == -1 || lastRoundIndex != newIndex) && newIndex != -1) {
             lastRoundIndex = newIndex;
-            return Optional.of(
-                    MiniMessage.miniMessage().deserialize(String.format(data.formatString, lastRoundIndex + 1)));
+            return Optional.of(MiniMessage.miniMessage().deserialize(
+                    String.format(data.formatString, Math.min(lastRoundIndex + 1, roundHandler.roundCount()))));
         }
 
         return Optional.empty();
diff --git a/zombies/src/main/java/org/phantazm/zombies/sidebar/lineupdater/TicksLineUpdater.java b/zombies/src/main/java/org/phantazm/zombies/sidebar/lineupdater/TicksLineUpdater.java
index 0b605b8d9..942f7e747 100644
--- a/zombies/src/main/java/org/phantazm/zombies/sidebar/lineupdater/TicksLineUpdater.java
+++ b/zombies/src/main/java/org/phantazm/zombies/sidebar/lineupdater/TicksLineUpdater.java
@@ -3,8 +3,8 @@
 import com.github.steanky.element.core.annotation.*;
 import com.github.steanky.toolkit.collection.Wrapper;
 import net.kyori.adventure.text.Component;
-import net.kyori.adventure.text.JoinConfiguration;
 import org.jetbrains.annotations.NotNull;
+import org.phantazm.core.ComponentUtils;
 import org.phantazm.core.time.TickFormatter;
 
 import java.util.Objects;
@@ -36,15 +36,15 @@ public void invalidateCache() {
         if (lastTicks == -1 || lastTicks != ticksWrapper.get()) {
             lastTicks = ticksWrapper.get();
 
-            return Optional.of(Component.join(JoinConfiguration.noSeparators(), data.prefix,
-                    tickFormatter.format(ticksWrapper.get())));
+
+            return Optional.of(ComponentUtils.tryFormat(data.formatString, tickFormatter.format(ticksWrapper.get())));
         }
 
         return Optional.empty();
     }
 
     @DataObject
-    public record Data(@NotNull Component prefix, @NotNull @ChildPath("tick_formatter") String tickFormatterPath) {
+    public record Data(@NotNull String formatString, @NotNull @ChildPath("tick_formatter") String tickFormatterPath) {
 
         public Data {
             Objects.requireNonNull(tickFormatterPath, "tickFormatterPath");
diff --git a/zombies/src/main/java/org/phantazm/zombies/spawn/BasicSpawnDistributor.java b/zombies/src/main/java/org/phantazm/zombies/spawn/BasicSpawnDistributor.java
index 28ed0f501..a22703e03 100644
--- a/zombies/src/main/java/org/phantazm/zombies/spawn/BasicSpawnDistributor.java
+++ b/zombies/src/main/java/org/phantazm/zombies/spawn/BasicSpawnDistributor.java
@@ -3,7 +3,9 @@
 import it.unimi.dsi.fastutil.Pair;
 import net.kyori.adventure.key.Key;
 import net.minestom.server.entity.Player;
+import net.minestom.server.scoreboard.Team;
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
 import org.phantazm.mob.MobModel;
 import org.phantazm.mob.PhantazmMob;
 import org.phantazm.zombies.map.SpawnInfo;
@@ -23,11 +25,15 @@ public class BasicSpawnDistributor implements SpawnDistributor {
 
     private final Collection<? extends ZombiesPlayer> zombiesPlayers;
 
+    private final Team mobNoPushTeam;
+
     public BasicSpawnDistributor(@NotNull Function<? super Key, ? extends MobModel> modelFunction,
-            @NotNull Random random, @NotNull Collection<? extends ZombiesPlayer> zombiesPlayers) {
+            @NotNull Random random, @NotNull Collection<? extends ZombiesPlayer> zombiesPlayers,
+            @Nullable Team mobNoPushTeam) {
         this.modelFunction = Objects.requireNonNull(modelFunction, "modelFunction");
         this.random = Objects.requireNonNull(random, "random");
         this.zombiesPlayers = Objects.requireNonNull(zombiesPlayers, "zombiesPlayers");
+        this.mobNoPushTeam = mobNoPushTeam;
     }
 
     @Override
@@ -102,7 +108,12 @@ public BasicSpawnDistributor(@NotNull Function<? super Key, ? extends MobModel>
                 candidateIndex %= sortedSpawnpoints.size();
 
                 if (candidate.canSpawn(model, spawnType, zombiesPlayers)) {
-                    spawnedMobs.add(candidate.spawn(model));
+                    PhantazmMob mob = candidate.spawn(model);
+                    if (mobNoPushTeam != null) {
+                        mob.entity().setTeam(mobNoPushTeam);
+                    }
+
+                    spawnedMobs.add(mob);
                     spawned = true;
                     break;
                 }
diff --git a/zombies/src/main/java/org/phantazm/zombies/stage/CountdownStage.java b/zombies/src/main/java/org/phantazm/zombies/stage/CountdownStage.java
index aed2f27c1..b1108871f 100644
--- a/zombies/src/main/java/org/phantazm/zombies/stage/CountdownStage.java
+++ b/zombies/src/main/java/org/phantazm/zombies/stage/CountdownStage.java
@@ -5,10 +5,14 @@
 import net.kyori.adventure.key.Key;
 import net.kyori.adventure.sound.Sound;
 import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.minimessage.MiniMessage;
+import net.kyori.adventure.text.minimessage.tag.resolver.Placeholder;
+import net.kyori.adventure.text.minimessage.tag.resolver.TagResolver;
 import net.minestom.server.instance.Instance;
 import net.minestom.server.sound.SoundEvent;
 import org.jetbrains.annotations.NotNull;
 import org.phantazm.core.time.TickFormatter;
+import org.phantazm.zombies.map.MapSettingsInfo;
 import org.phantazm.zombies.player.ZombiesPlayer;
 import org.phantazm.zombies.sidebar.SidebarUpdater;
 
@@ -20,39 +24,44 @@ public class CountdownStage implements Stage {
 
     private final Collection<? extends ZombiesPlayer> zombiesPlayers;
 
-    private final Map<UUID, SidebarUpdater> sidebarUpdaters = new HashMap<>();
+    private final MapSettingsInfo settings;
 
-    private final List<Component> messages;
+    private final Map<UUID, SidebarUpdater> sidebarUpdaters = new HashMap<>();
 
     private final Random random;
 
     private final Wrapper<Long> ticksRemaining;
 
+    private final long initialTicks;
+
     private final LongList alertTicks;
 
     private final TickFormatter tickFormatter;
 
     private final Function<? super ZombiesPlayer, ? extends SidebarUpdater> sidebarUpdaterCreator;
 
+    private final MiniMessage miniMessage = MiniMessage.miniMessage();
+
     protected CountdownStage(@NotNull Instance instance, @NotNull Collection<? extends ZombiesPlayer> zombiesPlayers,
-            @NotNull Collection<Component> messages, @NotNull Random random, @NotNull Wrapper<Long> ticksRemaining,
+            @NotNull MapSettingsInfo settings, @NotNull Random random, @NotNull Wrapper<Long> ticksRemaining,
             @NotNull LongList alertTicks, @NotNull TickFormatter tickFormatter,
             @NotNull Function<? super ZombiesPlayer, ? extends SidebarUpdater> sidebarUpdaterCreator) {
         this.instance = Objects.requireNonNull(instance, "instance");
         this.zombiesPlayers = Objects.requireNonNull(zombiesPlayers, "zombiesPlayers");
-        this.messages = List.copyOf(messages);
+        this.settings = Objects.requireNonNull(settings, "settings");
         this.random = Objects.requireNonNull(random, "random");
         this.ticksRemaining = Objects.requireNonNull(ticksRemaining, "ticksRemaining");
+        this.initialTicks = ticksRemaining.get();
         this.alertTicks = Objects.requireNonNull(alertTicks, "alertTicks");
         this.tickFormatter = Objects.requireNonNull(tickFormatter, "tickFormatter");
         this.sidebarUpdaterCreator = Objects.requireNonNull(sidebarUpdaterCreator, "sidebarUpdaterCreator");
     }
 
     public CountdownStage(@NotNull Instance instance, @NotNull Collection<? extends ZombiesPlayer> zombiesPlayers,
-            @NotNull Collection<Component> messages, @NotNull Random random, long countdownTicks,
+            @NotNull MapSettingsInfo settings, @NotNull Random random, long countdownTicks,
             @NotNull LongList alertTicks, @NotNull TickFormatter tickFormatter,
             @NotNull Function<? super ZombiesPlayer, ? extends SidebarUpdater> sidebarUpdaterCreator) {
-        this(instance, zombiesPlayers, messages, random, Wrapper.of(countdownTicks), alertTicks, tickFormatter,
+        this(instance, zombiesPlayers, settings, random, Wrapper.of(countdownTicks), alertTicks, tickFormatter,
                 sidebarUpdaterCreator);
     }
 
@@ -69,23 +78,36 @@ public boolean shouldRevert() {
     @Override
     public void onJoin(@NotNull ZombiesPlayer zombiesPlayer) {
         zombiesPlayer.getPlayer().ifPresent(player -> {
-            if (!messages.isEmpty()) {
-                player.sendMessage(messages.get(random.nextInt(messages.size())));
+            if (!settings.introMessages().isEmpty()) {
+                player.sendMessage(settings.introMessages().get(random.nextInt(settings.introMessages().size())));
             }
         });
     }
 
+    @Override
+    public void onLeave(@NotNull ZombiesPlayer zombiesPlayer) {
+        SidebarUpdater updater = sidebarUpdaters.remove(zombiesPlayer.getUUID());
+        if (updater != null) {
+            updater.end();
+        }
+    }
+
     @Override
     public boolean hasPermanentPlayers() {
         return false;
     }
 
+    @Override
+    public void start() {
+        ticksRemaining.set(initialTicks);
+    }
+
     @Override
     public void tick(long time) {
         if (alertTicks.contains((long)ticksRemaining.get())) {
-            Component message = Component.textOfChildren(Component.text("The game starts in "),
-                    tickFormatter.format(ticksRemaining.get()), Component.text("."));
-            instance.playSound(Sound.sound(SoundEvent.BLOCK_NOTE_BLOCK_HAT, Sound.Source.MASTER, 1.0F, 1.0F));
+            TagResolver timePlaceholder = Placeholder.unparsed("time", tickFormatter.format(ticksRemaining.get()));
+            Component message = miniMessage.deserialize(settings.countdownTimeFormat(), timePlaceholder);
+            instance.playSound(settings.countdownTickSound());
             instance.sendMessage(message);
         }
         for (ZombiesPlayer zombiesPlayer : zombiesPlayers) {
diff --git a/zombies/src/main/java/org/phantazm/zombies/stage/EndStage.java b/zombies/src/main/java/org/phantazm/zombies/stage/EndStage.java
index fa18a97a3..42dcad938 100644
--- a/zombies/src/main/java/org/phantazm/zombies/stage/EndStage.java
+++ b/zombies/src/main/java/org/phantazm/zombies/stage/EndStage.java
@@ -52,12 +52,17 @@ public boolean shouldRevert() {
 
     @Override
     public void onJoin(@NotNull ZombiesPlayer zombiesPlayer) {
+        zombiesPlayer.module().getMeta().setInGame(false);
+    }
+
+    @Override
+    public void onLeave(@NotNull ZombiesPlayer zombiesPlayer) {
 
     }
 
     @Override
     public boolean hasPermanentPlayers() {
-        return true;
+        return false;
     }
 
     @Override
@@ -65,6 +70,8 @@ public void start() {
         instance.playSound(Sound.sound(SoundEvent.ENTITY_ENDER_DRAGON_DEATH, Sound.Source.MASTER, 1.0F, 1.0F));
 
         for (ZombiesPlayer zombiesPlayer : zombiesPlayers) {
+            zombiesPlayer.module().getMeta().setInGame(false);
+
             if (zombiesPlayer.isState(ZombiesPlayerStateKeys.KNOCKED)) {
                 zombiesPlayer.setState(ZombiesPlayerStateKeys.DEAD, DeadPlayerStateContext.killed(null, null));
             }
diff --git a/zombies/src/main/java/org/phantazm/zombies/stage/IdleStage.java b/zombies/src/main/java/org/phantazm/zombies/stage/IdleStage.java
index fa61e3eb7..a9689a953 100644
--- a/zombies/src/main/java/org/phantazm/zombies/stage/IdleStage.java
+++ b/zombies/src/main/java/org/phantazm/zombies/stage/IdleStage.java
@@ -36,6 +36,14 @@ public void onJoin(@NotNull ZombiesPlayer zombiesPlayer) {
 
     }
 
+    @Override
+    public void onLeave(@NotNull ZombiesPlayer zombiesPlayer) {
+        SidebarUpdater updater = sidebarUpdaters.remove(zombiesPlayer.getUUID());
+        if (updater != null) {
+            updater.end();
+        }
+    }
+
     @Override
     public void tick(long time) {
         for (ZombiesPlayer zombiesPlayer : zombiesPlayers) {
diff --git a/zombies/src/main/java/org/phantazm/zombies/stage/InGameStage.java b/zombies/src/main/java/org/phantazm/zombies/stage/InGameStage.java
index b5ec941f9..5aa9a9c4b 100644
--- a/zombies/src/main/java/org/phantazm/zombies/stage/InGameStage.java
+++ b/zombies/src/main/java/org/phantazm/zombies/stage/InGameStage.java
@@ -6,18 +6,22 @@
 import net.kyori.adventure.text.format.NamedTextColor;
 import net.kyori.adventure.text.format.Style;
 import net.kyori.adventure.text.format.TextDecoration;
+import net.kyori.adventure.text.minimessage.MiniMessage;
+import net.kyori.adventure.text.minimessage.tag.resolver.Placeholder;
+import net.kyori.adventure.text.minimessage.tag.resolver.TagResolver;
 import net.kyori.adventure.title.TitlePart;
-import net.minestom.server.MinecraftServer;
 import net.minestom.server.coordinate.Pos;
 import net.minestom.server.instance.Instance;
 import org.jetbrains.annotations.NotNull;
 import org.phantazm.core.equipment.EquipmentHandler;
 import org.phantazm.core.time.TickFormatter;
+import org.phantazm.zombies.map.MapSettingsInfo;
 import org.phantazm.zombies.map.handler.RoundHandler;
 import org.phantazm.zombies.map.handler.ShopHandler;
 import org.phantazm.zombies.player.ZombiesPlayer;
 import org.phantazm.zombies.player.ZombiesPlayerModule;
 import org.phantazm.zombies.sidebar.SidebarUpdater;
+import org.phantazm.stats.zombies.ZombiesPlayerMapStats;
 
 import java.util.*;
 import java.util.function.Function;
@@ -25,6 +29,7 @@
 public class InGameStage implements Stage {
     private final Instance instance;
     private final Collection<? extends ZombiesPlayer> zombiesPlayers;
+    private final MapSettingsInfo settings;
     private final Map<UUID, SidebarUpdater> sidebarUpdaters = new HashMap<>();
     private final Pos spawnPos;
     private final RoundHandler roundHandler;
@@ -34,16 +39,17 @@ public class InGameStage implements Stage {
     private final Function<? super ZombiesPlayer, ? extends SidebarUpdater> sidebarUpdaterCreator;
     private final ShopHandler shopHandler;
     private final TickFormatter tickFormatter;
-
-    private long startTime;
+    private final MiniMessage miniMessage = MiniMessage.miniMessage();
 
     public InGameStage(@NotNull Instance instance, @NotNull Collection<? extends ZombiesPlayer> zombiesPlayers,
-            @NotNull Pos spawnPos, @NotNull RoundHandler roundHandler, @NotNull Wrapper<Long> ticksSinceStart,
-            @NotNull Map<Key, List<Key>> defaultEquipment, @NotNull Set<Key> equipmentGroups,
+            @NotNull MapSettingsInfo settings, @NotNull Pos spawnPos, @NotNull RoundHandler roundHandler,
+            @NotNull Wrapper<Long> ticksSinceStart, @NotNull Map<Key, List<Key>> defaultEquipment,
+            @NotNull Set<Key> equipmentGroups,
             @NotNull Function<? super ZombiesPlayer, ? extends SidebarUpdater> sidebarUpdaterCreator,
             @NotNull ShopHandler shopHandler, @NotNull TickFormatter endTimeTickFormatter) {
         this.instance = Objects.requireNonNull(instance, "instance");
         this.zombiesPlayers = Objects.requireNonNull(zombiesPlayers, "zombiesPlayers");
+        this.settings = Objects.requireNonNull(settings, "settings");
         this.spawnPos = Objects.requireNonNull(spawnPos, "spawnPos");
         this.roundHandler = Objects.requireNonNull(roundHandler, "roundHandler");
         this.ticksSinceStart = Objects.requireNonNull(ticksSinceStart, "ticksSinceStart");
@@ -77,6 +83,11 @@ public boolean shouldRevert() {
 
     @Override
     public void onJoin(@NotNull ZombiesPlayer zombiesPlayer) {
+        zombiesPlayer.module().getMeta().setInGame(true);
+    }
+
+    @Override
+    public void onLeave(@NotNull ZombiesPlayer zombiesPlayer) {
 
     }
 
@@ -87,9 +98,9 @@ public boolean hasPermanentPlayers() {
 
     @Override
     public void start() {
-        this.startTime = System.currentTimeMillis();
-
         for (ZombiesPlayer zombiesPlayer : zombiesPlayers) {
+            zombiesPlayer.module().getMeta().setInGame(true);
+            zombiesPlayer.module().getStats().setGamesPlayed(zombiesPlayer.module().getStats().getGamesPlayed() + 1);
             zombiesPlayer.getPlayer().ifPresent(player -> {
                 player.teleport(spawnPos);
             });
@@ -142,8 +153,6 @@ public void tick(long time) {
 
     @Override
     public void end() {
-        long endTime = System.currentTimeMillis();
-
         boolean anyAlive = false;
         for (ZombiesPlayer zombiesPlayer : zombiesPlayers) {
             if (zombiesPlayer.isAlive()) {
@@ -152,41 +161,60 @@ public void end() {
             }
         }
 
-        Component finalTime = tickFormatter.format((endTime - startTime) / MinecraftServer.TICK_MS);
+        Component finalTime = Component.text(tickFormatter.format(ticksSinceStart.get()));
         int bestRound = Math.min(roundHandler.currentRoundIndex() + 1, roundHandler.roundCount());
 
+        TagResolver roundPlaceholder = Placeholder.component("round", Component.text(bestRound));
         if (anyAlive) {
-            instance.sendTitlePart(TitlePart.TITLE, Component.text("You Win!", NamedTextColor.GREEN));
-            instance.sendTitlePart(TitlePart.SUBTITLE, Component.text("You made it to Round ", NamedTextColor.GRAY)
-                    .append(Component.text(bestRound, NamedTextColor.WHITE)).append(Component.text("!")));
+            instance.sendTitlePart(TitlePart.TITLE, miniMessage.deserialize(settings.winTitleFormat(), roundPlaceholder));
+            instance.sendTitlePart(TitlePart.SUBTITLE, miniMessage.deserialize(settings.winSubtitleFormat(), roundPlaceholder));
+
+            for (ZombiesPlayer zombiesPlayer : zombiesPlayers) {
+                ZombiesPlayerMapStats stats = zombiesPlayer.module().getStats();
+                stats.setWins(stats.getWins() + 1);
+                stats.getBestTime().ifPresentOrElse(prevBest -> {
+                    if (ticksSinceStart.get() < prevBest) {
+                        stats.setBestTime(ticksSinceStart.get());
+                    }
+                }, () -> stats.setBestTime(ticksSinceStart.get()));
+            }
         }
         else {
-            instance.sendTitlePart(TitlePart.TITLE, Component.text("You lost...", NamedTextColor.RED));
+            instance.sendTitlePart(TitlePart.TITLE, miniMessage.deserialize(settings.lossTitleFormat(), roundPlaceholder));
+            instance.sendTitlePart(TitlePart.SUBTITLE, miniMessage.deserialize(settings.lossSubtitleFormat(), roundPlaceholder));
         }
 
         for (ZombiesPlayer zombiesPlayer : zombiesPlayers) {
-            zombiesPlayer.sendMessage(Component.text("==========================================",
-                    Style.style(NamedTextColor.GREEN, TextDecoration.STRIKETHROUGH)));
-
-            zombiesPlayer.sendMessage(
-                    Component.text("Zombies", NamedTextColor.YELLOW).append(Component.text(" - ", NamedTextColor.WHITE))
-                            .append(finalTime).append(Component.text(" (", NamedTextColor.GRAY))
-                            .append(Component.text("Round ", NamedTextColor.RED))
-                            .append(Component.text(bestRound, NamedTextColor.RED))
-                            .append(Component.text(")", NamedTextColor.GRAY)));
-
-            zombiesPlayer.sendMessage(Component.empty());
-
-            zombiesPlayer.sendMessage(
-                    Component.text("Zombie Kills", Style.style(TextDecoration.BOLD, NamedTextColor.WHITE))
-                            .append(Component.text(" - ", NamedTextColor.GRAY))
-                            .append(Component.text(zombiesPlayer.module().getKills().getKills(),
-                                    NamedTextColor.GREEN)));
-
-            zombiesPlayer.sendMessage(Component.empty());
+            if (zombiesPlayer.hasQuit()) {
+                continue;
+            }
 
-            zombiesPlayer.sendMessage(Component.text("==========================================",
-                    Style.style(NamedTextColor.GREEN, TextDecoration.STRIKETHROUGH)));
+            ZombiesPlayerMapStats stats = zombiesPlayer.module().getStats();
+            int gunAccuracy = stats.getShots() <= 0
+                              ? 100
+                              : (int)Math.rint(((double)(stats.getRegularHits() + stats.getHeadshotHits()) /
+                                      (double)stats.getShots()) * 100);
+            int headshotAccuracy = stats.getShots() <= 0
+                                   ? 100
+                                   : (int)Math.rint(((double)(stats.getHeadshotHits()) / (double)stats.getShots()) * 100);
+            TagResolver[] tagResolvers = new TagResolver[] {
+                    Placeholder.component("map", settings.displayName()),
+                    Placeholder.component("final_time", finalTime),
+                    Placeholder.component("best_round", Component.text(bestRound)),
+                    Placeholder.component("total_shots", Component.text(stats.getShots())),
+                    Placeholder.component("regular_hits", Component.text(stats.getRegularHits())),
+                    Placeholder.component("headshot_hits", Component.text(stats.getHeadshotHits())),
+                    Placeholder.component("gun_accuracy", Component.text(gunAccuracy)),
+                    Placeholder.component("headshot_accuracy", Component.text(headshotAccuracy)),
+                    Placeholder.component("kills", Component.text(stats.getKills())),
+                    Placeholder.component("coins_gained", Component.text(stats.getCoinsGained())),
+                    Placeholder.component("coins_spent", Component.text(stats.getCoinsSpent())),
+                    Placeholder.component("knocks", Component.text(stats.getKnocks())),
+                    Placeholder.component("deaths", Component.text(stats.getDeaths())),
+                    Placeholder.component("revives", Component.text(stats.getRevives()))
+            };
+
+            zombiesPlayer.sendMessage(miniMessage.deserialize(settings.endGameStatsFormat(), tagResolvers));
         }
 
         for (SidebarUpdater sidebarUpdater : sidebarUpdaters.values()) {
diff --git a/zombies/src/main/java/org/phantazm/zombies/stage/Stage.java b/zombies/src/main/java/org/phantazm/zombies/stage/Stage.java
index fda0b3a61..a1171c37d 100644
--- a/zombies/src/main/java/org/phantazm/zombies/stage/Stage.java
+++ b/zombies/src/main/java/org/phantazm/zombies/stage/Stage.java
@@ -21,110 +21,8 @@ public interface Stage extends Activable, Keyed {
 
     void onJoin(@NotNull ZombiesPlayer zombiesPlayer);
 
-    boolean hasPermanentPlayers();
-
-    class Builder {
-
-        private final Key key;
-
-        private final Collection<Activable> activables = new ArrayList<>();
-
-        private BooleanSupplier continueCondition;
-
-        private BooleanSupplier revertCondition = () -> false;
-
-        private Consumer<ZombiesPlayer> playerJoinHandler = unused -> {
-        };
-
-        private boolean hasPermanentPlayers;
-
-        public Builder(@NotNull Key key) {
-            this.key = Objects.requireNonNull(key, "key");
-        }
-
-        public @NotNull Builder setContinueCondition(@NotNull BooleanSupplier continueCondition) {
-            this.continueCondition = Objects.requireNonNull(continueCondition, "continueCondition");
-            return this;
-        }
-
-        public @NotNull Builder setRevertCondition(@NotNull BooleanSupplier revertCondition) {
-            this.revertCondition = Objects.requireNonNull(revertCondition, "revertCondition");
-            return this;
-        }
-
-        public @NotNull Builder setPlayerJoinHandler(@NotNull Consumer<ZombiesPlayer> playerJoinHandler) {
-            this.playerJoinHandler = Objects.requireNonNull(playerJoinHandler, "playerJoinHandler");
-            return this;
-        }
-
-        public @NotNull Builder setPermanentPlayers(boolean hasPermanentPlayers) {
-            this.hasPermanentPlayers = hasPermanentPlayers;
-            return this;
-        }
+    void onLeave(@NotNull ZombiesPlayer zombiesPlayer);
 
-        public @NotNull Builder addActivable(@NotNull Activable activable) {
-            activables.add(Objects.requireNonNull(activable, "activable"));
-            return this;
-        }
-
-        public @NotNull Builder addActivables(@NotNull Collection<Activable> activables) {
-            this.activables.addAll(List.copyOf(activables));
-            return this;
-        }
-
-        public @NotNull Stage build() {
-            Objects.requireNonNull(continueCondition, "continueCondition");
-
-            return new Stage() {
-
-                @Override
-                public @NotNull Key key() {
-                    return key;
-                }
-
-                @Override
-                public void start() {
-                    for (Activable activable : activables) {
-                        activable.start();
-                    }
-                }
-
-                @Override
-                public void tick(long time) {
-                    for (Activable activable : activables) {
-                        activable.tick(time);
-                    }
-                }
-
-                @Override
-                public void end() {
-                    for (Activable activable : activables) {
-                        activable.end();
-                    }
-                }
-
-                @Override
-                public boolean shouldContinue() {
-                    return continueCondition.getAsBoolean();
-                }
-
-                @Override
-                public boolean shouldRevert() {
-                    return revertCondition.getAsBoolean();
-                }
-
-                @Override
-                public void onJoin(@NotNull ZombiesPlayer zombiesPlayer) {
-                    playerJoinHandler.accept(Objects.requireNonNull(zombiesPlayer, "zombiesPlayer"));
-                }
-
-                @Override
-                public boolean hasPermanentPlayers() {
-                    return hasPermanentPlayers;
-                }
-            };
-        }
-
-    }
+    boolean hasPermanentPlayers();
 
 }
diff --git a/zombies/src/test/java/org/phantazm/zombies/equipment/gun/shoot/blockiteration/WallshotBlockIterationTest.java b/zombies/src/test/java/org/phantazm/zombies/equipment/gun/shoot/blockiteration/WallshotBlockIterationTest.java
index 142098f74..b8b8570bb 100644
--- a/zombies/src/test/java/org/phantazm/zombies/equipment/gun/shoot/blockiteration/WallshotBlockIterationTest.java
+++ b/zombies/src/test/java/org/phantazm/zombies/equipment/gun/shoot/blockiteration/WallshotBlockIterationTest.java
@@ -5,7 +5,7 @@
 import org.junit.jupiter.api.Test;
 
 import java.util.Collections;
-import java.util.List;
+import java.util.Set;
 
 import static org.junit.jupiter.api.Assertions.assertFalse;
 import static org.junit.jupiter.api.Assertions.assertTrue;
@@ -14,7 +14,7 @@ public class WallshotBlockIterationTest {
 
     @Test
     public void testAirDoesNotEndIteration() {
-        BlockIteration blockIteration = new WallshotBlockIteration(new WallshotBlockIteration.Data(List.of()));
+        BlockIteration blockIteration = new WallshotBlockIteration(new WallshotBlockIteration.Data(Set.of()));
         BlockIteration.Context context = blockIteration.createContext();
 
         assertFalse(context.acceptRaytracedBlock(Vec.ZERO, Block.AIR));
@@ -22,7 +22,7 @@ public void testAirDoesNotEndIteration() {
 
     @Test
     public void testStoneIsInitiallyValidEndpoint() {
-        BlockIteration blockIteration = new WallshotBlockIteration(new WallshotBlockIteration.Data(List.of()));
+        BlockIteration blockIteration = new WallshotBlockIteration(new WallshotBlockIteration.Data(Set.of()));
         BlockIteration.Context context = blockIteration.createContext();
 
         assertTrue(context.isValidEndpoint(Vec.ZERO, Block.STONE));
diff --git a/zombies/src/test/java/org/phantazm/zombies/game/coin/BasicPlayerCoinsTest.java b/zombies/src/test/java/org/phantazm/zombies/game/coin/BasicPlayerCoinsTest.java
index e790cfdd5..99ff065f1 100644
--- a/zombies/src/test/java/org/phantazm/zombies/game/coin/BasicPlayerCoinsTest.java
+++ b/zombies/src/test/java/org/phantazm/zombies/game/coin/BasicPlayerCoinsTest.java
@@ -1,10 +1,13 @@
 package org.phantazm.zombies.game.coin;
 
+import net.kyori.adventure.key.Key;
 import net.kyori.adventure.text.Component;
 import net.minestom.server.entity.Player;
 import org.jetbrains.annotations.NotNull;
 import org.junit.jupiter.api.Test;
 import org.phantazm.core.player.PlayerView;
+import org.phantazm.stats.zombies.BasicZombiesPlayerMapStats;
+import org.phantazm.stats.zombies.ZombiesPlayerMapStats;
 import org.phantazm.zombies.coin.BasicPlayerCoins;
 import org.phantazm.zombies.coin.PlayerCoins;
 import org.phantazm.zombies.coin.Transaction;
@@ -15,6 +18,7 @@
 import java.util.Collections;
 import java.util.List;
 import java.util.Optional;
+import java.util.UUID;
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.mockito.Mockito.mock;
@@ -30,7 +34,9 @@ private void setup(int initialCoins) {
         when(playerView.getPlayer()).thenReturn(Optional.of(player));
         TransactionComponentCreator componentCreator = new BasicTransactionComponentCreator();
 
-        coins = new BasicPlayerCoins(playerView, componentCreator, initialCoins);
+        coins = new BasicPlayerCoins(playerView,
+                BasicZombiesPlayerMapStats.createBasicStats(UUID.randomUUID(), Key.key("phantazm:test")),
+                componentCreator, initialCoins);
     }
 
     @Test
diff --git a/zombies/src/test/java/org/phantazm/zombies/game/player/state/revive/ReviveHandlerTest.java b/zombies/src/test/java/org/phantazm/zombies/game/player/state/revive/ReviveHandlerTest.java
index c0f0f8349..ec5bfd6da 100644
--- a/zombies/src/test/java/org/phantazm/zombies/game/player/state/revive/ReviveHandlerTest.java
+++ b/zombies/src/test/java/org/phantazm/zombies/game/player/state/revive/ReviveHandlerTest.java
@@ -3,6 +3,7 @@
 import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
+import org.phantazm.stats.zombies.ZombiesPlayerMapStats;
 import org.phantazm.zombies.player.ZombiesPlayer;
 import org.phantazm.zombies.player.ZombiesPlayerMeta;
 import org.phantazm.zombies.player.ZombiesPlayerModule;
@@ -29,6 +30,7 @@ public void setup() {
         meta = mock(ZombiesPlayerMeta.class);
         ZombiesPlayerModule module = mock(ZombiesPlayerModule.class);
         when(module.getMeta()).thenReturn(meta);
+        when(module.getStats()).thenReturn(mock(ZombiesPlayerMapStats.class));
         reviver = mock(ZombiesPlayer.class);
         when(reviver.module()).thenReturn(module);
     }
@@ -95,7 +97,6 @@ public void testDisabledReviverResetsRevive() {
                 new ReviveHandler(() -> aliveState, () -> deathState, () -> reviver, initialDeathTime);
 
         reviveHandler.tick(0L);
-        when(meta.isCanRevive()).thenReturn(false);
         reviveHandler.tick(0L);
 
         assertFalse(reviveHandler.isReviving());
diff --git a/zombies/src/test/java/org/phantazm/zombies/kill/BasicPlayerKillsTest.java b/zombies/src/test/java/org/phantazm/zombies/kill/BasicPlayerKillsTest.java
index 81bddcee2..40191de45 100644
--- a/zombies/src/test/java/org/phantazm/zombies/kill/BasicPlayerKillsTest.java
+++ b/zombies/src/test/java/org/phantazm/zombies/kill/BasicPlayerKillsTest.java
@@ -1,8 +1,14 @@
 package org.phantazm.zombies.kill;
 
+import net.kyori.adventure.key.Key;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
+import org.phantazm.commons.Namespaces;
 import org.phantazm.mob.PhantazmMob;
+import org.phantazm.stats.zombies.BasicZombiesPlayerMapStats;
+import org.phantazm.stats.zombies.ZombiesPlayerMapStats;
+
+import java.util.UUID;
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.mockito.Mockito.mock;
@@ -13,7 +19,9 @@ public class BasicPlayerKillsTest {
 
     @BeforeEach
     public void setup() {
-        kills = new BasicPlayerKills();
+        ZombiesPlayerMapStats mapStats = BasicZombiesPlayerMapStats.createBasicStats(UUID.randomUUID(),
+                Key.key(Namespaces.PHANTAZM, "test_map"));
+        kills = new BasicPlayerKills(mapStats);
     }
 
     @Test