diff --git a/.idea/runConfigurations/MainKt.xml b/.idea/runConfigurations/MainKt.xml
index 8762d9e4e..60dbe4dde 100644
--- a/.idea/runConfigurations/MainKt.xml
+++ b/.idea/runConfigurations/MainKt.xml
@@ -2,7 +2,7 @@
   <configuration default="false" name="MainKt" type="JetRunConfigurationType" nameIsGenerated="true">
     <option name="ALTERNATIVE_JRE_PATH" value="jbr-21" />
     <option name="ALTERNATIVE_JRE_PATH_ENABLED" value="true" />
-    <option name="MAIN_CLASS_NAME" value="MainKt" />
+    <option name="MAIN_CLASS_NAME" value="io.github.dockyardmc.MainKt" />
     <module name="io.github.dockyardmc.Dockyard.main" />
     <shortenClasspath name="NONE" />
     <option name="VM_PARAMETERS" value="-XX:+EnableDynamicAgentLoading -XX:+AllowEnhancedClassRedefinition" />
diff --git a/src/main/kotlin/io/github/dockyardmc/entity/Entity.kt b/src/main/kotlin/io/github/dockyardmc/entity/Entity.kt
index bf2b1b15d..68a3b8ba5 100644
--- a/src/main/kotlin/io/github/dockyardmc/entity/Entity.kt
+++ b/src/main/kotlin/io/github/dockyardmc/entity/Entity.kt
@@ -72,6 +72,8 @@ abstract class Entity(open var location: Location, open var world: World) : Disp
     val stuckArrows: Bindable<Int> = bindablePool.provideBindable(0)
     var gravityTickCount = 0
 
+    val maxHealth get() = health.defaultValue
+
     val potionEffects: BindableMap<PotionEffect, AppliedPotionEffect> = bindablePool.provideBindableMap()
     val isInvisible: Bindable<Boolean> = bindablePool.provideBindable(false)
     val isGlowing: Bindable<Boolean> = bindablePool.provideBindable(false)
@@ -193,6 +195,11 @@ abstract class Entity(open var location: Location, open var world: World) : Disp
         teleport(newLoc)
     }
 
+    open fun lookAt(targetLocation: Location) {
+        val newLoc = this.location.setDirection(targetLocation.toVector3d() - (this.location).toVector3d())
+        teleport(newLoc)
+    }
+
     open fun lookAtClientside(target: Entity, player: Player) {
         lookAtClientside(target, listOf(player))
     }
diff --git a/src/main/kotlin/io/github/dockyardmc/entity/TestZombie.kt b/src/main/kotlin/io/github/dockyardmc/entity/TestZombie.kt
deleted file mode 100644
index 018024995..000000000
--- a/src/main/kotlin/io/github/dockyardmc/entity/TestZombie.kt
+++ /dev/null
@@ -1,119 +0,0 @@
-package io.github.dockyardmc.entity
-
-import cz.lukynka.bindables.Bindable
-import de.metaphoriker.pathetic.api.pathing.configuration.HeuristicWeights
-import de.metaphoriker.pathetic.api.pathing.filter.filters.PassablePathFilter
-import io.github.dockyardmc.entity.ai.AIGoal
-import io.github.dockyardmc.entity.ai.AIManager
-import io.github.dockyardmc.events.EventPool
-import io.github.dockyardmc.events.PlayerDamageEntityEvent
-import io.github.dockyardmc.location.Location
-import io.github.dockyardmc.pathfinding.Navigator
-import io.github.dockyardmc.pathfinding.Pathfinder
-import io.github.dockyardmc.pathfinding.RequiredHeightPathfindingFilter
-import io.github.dockyardmc.registry.DamageTypes
-import io.github.dockyardmc.registry.EntityTypes
-import io.github.dockyardmc.registry.Sounds
-import io.github.dockyardmc.registry.registries.EntityType
-import io.github.dockyardmc.sounds.Sound
-import io.github.dockyardmc.sounds.playSound
-import io.github.dockyardmc.maths.randomFloat
-import kotlin.random.Random
-
-class TestZombie(location: Location) : Entity(location) {
-    override var type: EntityType = EntityTypes.ZOMBIE
-    override val health: Bindable<Float> = Bindable(20f)
-    override var inventorySize: Int = 0
-
-    val eventPool = EventPool()
-    val brain = AIManager(this)
-    val pathfinder = Pathfinder.createPathfinder {
-        async(true)
-        maxLength(25)
-        maxIterations(256)
-        heuristicWeights(HeuristicWeights.DIRECT_PATH_WEIGHTS)
-    }
-
-    val navigator = Navigator(this, 5, pathfinder, listOf(RequiredHeightPathfindingFilter(2), PassablePathFilter()))
-
-    init {
-
-        brain.addGoal(ZombieLookAroundAIGoal(this, 1))
-//        brain.addGoal(ZombieGroanAiGoal(this, 1))
-//        brain.addGoal(RandomWalkAroundGoal(this, 1, navigator))
-
-        eventPool.on<PlayerDamageEntityEvent> { event ->
-            val entity = event.entity
-            if (entity != this) return@on
-
-            entity.world.playSound(Sounds.ENTITY_ZOMBIE_HURT, pitch = Random.randomFloat(0.7f, 1.2f))
-            entity.damage(1f, DamageTypes.GENERIC, event.player, event.entity)
-            event.player.sendMessage("<red>${health.value}")
-        }
-
-//        eventPool.on<PlayerInteractWithEntityEvent> {
-//            val entity = it.entity
-//            val player = it.player
-//            if (entity != this) return@on
-//
-//            player.sendMessage("<red>[NPC] Zombie: <white>grrrrr")
-//            player.playSound(Sound("minecraft:entity.zombie.ambient", pitch = randomFloat(0.7f, 1.2f)))
-//        }
-    }
-
-    // when entity is despawned
-    override fun dispose() {
-        eventPool.dispose() // automatically unregister all above events
-        super.dispose()
-    }
-}
-
-
-class ZombieLookAroundAIGoal(override var entity: Entity, override var priority: Int) : AIGoal() {
-
-    val zombie = entity as TestZombie
-    val chancePerTick = 50
-
-    var lookingAroundTime: Int = 0
-
-    override fun startCondition(): Boolean {
-        return Random.nextInt(chancePerTick, 100) == chancePerTick
-    }
-
-    override fun start() {
-        lookingAroundTime = 10
-        zombie.teleport(zombie.location.clone().apply { pitch = 0f; yaw += Random.randomFloat(-90f, 90f) })
-    }
-
-    override fun end() {
-        cooldown = Random.nextInt(3, 5) * 20
-    }
-
-    override fun endCondition(): Boolean = lookingAroundTime <= 0
-
-    override fun tick() {
-        lookingAroundTime--
-    }
-}
-
-class ZombieGroanAiGoal(override var entity: Entity, override var priority: Int) : AIGoal() {
-
-    val zombie = entity as TestZombie
-    val chancePerTick = 50
-
-    override fun startCondition(): Boolean {
-        return Random.nextInt(chancePerTick, 100) == chancePerTick
-    }
-
-    override fun start() {
-        zombie.playSoundToViewers(Sound("minecraft:entity.zombie.ambient", pitch = Random.randomFloat(0.8f, 1.2f)))
-    }
-
-    override fun end() {
-        cooldown = Random.nextInt(1, 2) * 20
-    }
-
-    override fun endCondition(): Boolean = true
-
-    override fun tick() {}
-}
\ No newline at end of file
diff --git a/src/main/kotlin/io/github/dockyardmc/entity/Warden.kt b/src/main/kotlin/io/github/dockyardmc/entity/Warden.kt
index 05610f64d..7c6c3de94 100644
--- a/src/main/kotlin/io/github/dockyardmc/entity/Warden.kt
+++ b/src/main/kotlin/io/github/dockyardmc/entity/Warden.kt
@@ -12,7 +12,7 @@ import io.github.dockyardmc.protocol.packets.play.clientbound.EntityEvent
 import io.github.dockyardmc.registry.EntityTypes
 import io.github.dockyardmc.registry.registries.EntityType
 
-open class Warden(location: Location): Entity(location) {
+open class Warden(location: Location) : Entity(location) {
     override var type: EntityType = EntityTypes.WARDEN
     override val health: Bindable<Float> = Bindable(500f)
     override var inventorySize: Int = 0
@@ -27,7 +27,7 @@ open class Warden(location: Location): Entity(location) {
 
     fun playAnimation(animation: WardenAnimation) {
 
-        when(animation) {
+        when (animation) {
             WardenAnimation.EMERGE -> pose.value = EntityPose.EMERGING
             WardenAnimation.ROAR -> pose.value = EntityPose.ROARING
             WardenAnimation.SNIFF -> pose.value = EntityPose.SNIFFING
diff --git a/src/main/kotlin/io/github/dockyardmc/entity/Zombie.kt b/src/main/kotlin/io/github/dockyardmc/entity/Zombie.kt
new file mode 100644
index 000000000..3334022c2
--- /dev/null
+++ b/src/main/kotlin/io/github/dockyardmc/entity/Zombie.kt
@@ -0,0 +1,33 @@
+package io.github.dockyardmc.entity
+
+import cz.lukynka.bindables.Bindable
+import io.github.dockyardmc.entity.metadata.EntityMetaValue
+import io.github.dockyardmc.entity.metadata.EntityMetadata
+import io.github.dockyardmc.entity.metadata.EntityMetadataType
+import io.github.dockyardmc.location.Location
+import io.github.dockyardmc.protocol.packets.play.clientbound.ClientboundPlayerAnimationPacket
+import io.github.dockyardmc.protocol.packets.play.clientbound.EntityAnimation
+import io.github.dockyardmc.registry.EntityTypes
+import io.github.dockyardmc.registry.registries.EntityType
+
+open class Zombie(location: Location) : Entity(location) {
+    override var type: EntityType = EntityTypes.ZOMBIE
+    override val health: Bindable<Float> = bindablePool.provideBindable(20f)
+    override var inventorySize: Int = 0
+
+    val raisedArms: Bindable<Boolean> = bindablePool.provideBindable(false)
+
+    fun swingHands() {
+        this.sendPacketToViewers(ClientboundPlayerAnimationPacket(this, EntityAnimation.SWING_MAIN_ARM))
+    }
+
+    init {
+        raisedArms.valueChanged { event ->
+            if (event.newValue) {
+                this.metadata[EntityMetadataType.ZOMBIE_RAISED_ARMS] = EntityMetadata(EntityMetadataType.ZOMBIE_RAISED_ARMS, EntityMetaValue.BYTE, 0x0)
+            } else {
+                this.metadata.remove(EntityMetadataType.ZOMBIE_RAISED_ARMS)
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/main/kotlin/io/github/dockyardmc/entity/ai/AIManager.kt b/src/main/kotlin/io/github/dockyardmc/entity/ai/AIManager.kt
deleted file mode 100644
index 87ebd2671..000000000
--- a/src/main/kotlin/io/github/dockyardmc/entity/ai/AIManager.kt
+++ /dev/null
@@ -1,124 +0,0 @@
-package io.github.dockyardmc.entity.ai
-
-import io.github.dockyardmc.entity.Entity
-import io.github.dockyardmc.events.EventPool
-import io.github.dockyardmc.events.WorldTickEvent
-import io.github.dockyardmc.events.system.EventFilter
-import io.github.dockyardmc.utils.Disposable
-
-class AIManager(val entity: Entity) : Disposable {
-    val memory: MutableMap<String, AIMemory<*>> = mutableMapOf()
-    private val innerGoals: MutableList<AIGoal> = mutableListOf()
-    var currentGoal: AIGoal? = null
-    var forcedNextGoal: AIGoal? = null
-    var forcedNextGoalWaitForFinish: Boolean = false
-
-    private val eventPool: EventPool = EventPool().withFilter(EventFilter.containsWorld(entity.world))
-
-    val goals: List<AIGoal> get() = innerGoals.toList()
-
-    init {
-        eventPool.on<WorldTickEvent> { event ->
-            tick()
-        }
-    }
-
-    fun forget(key: String) {
-        memory.remove(key)
-    }
-
-    @Suppress("UNCHECKED_CAST")
-    fun <T> getMemory(key: String): T? = memory[key]?.value as T
-
-    fun addGoal(goal: AIGoal) {
-        innerGoals.sortByDescending { it.priority }
-        innerGoals.add(goal)
-    }
-
-    fun forceStartGoal(goal: AIGoal, waitForCurrentFinish: Boolean = false) {
-        forcedNextGoalWaitForFinish = waitForCurrentFinish
-        forcedNextGoal = goal
-    }
-
-    fun forceEndCurrentGoal() {
-        if (currentGoal != null) {
-            currentGoal!!.end()
-            currentGoal!!.isRunning = false
-        }
-    }
-
-    fun tick() {
-        if (forcedNextGoal != null && !forcedNextGoalWaitForFinish) {
-            if (currentGoal != null) {
-                currentGoal!!.end()
-                currentGoal!!.isRunning = false
-            }
-            forcedNextGoal!!.start()
-            forcedNextGoal!!.isRunning = true
-            return
-        }
-        goals.forEach { goal ->
-            if (!goal.isRunning && goal.cooldown > 0) {
-                goal.cooldown--
-                return@forEach
-            }
-            if (!goal.isRunning && goal.startCondition() && goal.cooldown <= 0 && currentGoal == null) {
-                val higherPriorityRunning = goals.any { it.isRunning && it.priority > goal.priority }
-                if (!higherPriorityRunning) {
-                    goal.start()
-                    goal.isRunning = true
-                    currentGoal = goal
-                    return@forEach
-                }
-            } else if (goal.isRunning && goal.endCondition()) {
-                goal.end()
-                goal.isRunning = false
-                currentGoal = null
-            } else if (goal.isRunning) {
-                val scheduledRemove = mutableListOf<String>()
-                memory.forEach memoryLoop@{
-                    if (it.value is ShortTermMemory<*>) {
-                        val shortTermMemory = it.value as ShortTermMemory<*>
-                        if (shortTermMemory.forgetAfter <= 0) {
-                            scheduledRemove.add(it.key)
-                            return@memoryLoop
-                        }
-                        shortTermMemory.forgetAfter--
-                    }
-                }
-                scheduledRemove.forEach(memory::remove)
-                goal.tick()
-            }
-        }
-    }
-
-    override fun dispose() {
-        eventPool.dispose()
-        memory.clear()
-        innerGoals.clear()
-        currentGoal = null
-        forcedNextGoal = null
-    }
-}
-
-interface AIMemory<T> {
-    val value: T
-}
-
-data class ShortTermMemory<T>(var forgetAfter: Int, override val value: T) : AIMemory<T>
-data class LongTermMemory<T>(override val value: T) : AIMemory<T>
-
-abstract class AIGoal {
-    abstract var entity: Entity
-    abstract var priority: Int
-
-    var isRunning: Boolean = false
-    open var cooldown: Int = 0
-
-    abstract fun startCondition(): Boolean
-    abstract fun start()
-    abstract fun end()
-    abstract fun endCondition(): Boolean
-    abstract fun tick()
-}
-
diff --git a/src/main/kotlin/io/github/dockyardmc/entity/ai/EntityBehaviourCoordinator.kt b/src/main/kotlin/io/github/dockyardmc/entity/ai/EntityBehaviourCoordinator.kt
new file mode 100644
index 000000000..f956779af
--- /dev/null
+++ b/src/main/kotlin/io/github/dockyardmc/entity/ai/EntityBehaviourCoordinator.kt
@@ -0,0 +1,107 @@
+package io.github.dockyardmc.entity.ai
+
+import io.github.dockyardmc.entity.Entity
+import io.github.dockyardmc.events.EventPool
+import io.github.dockyardmc.events.system.EventFilter
+import io.github.dockyardmc.pathfinding.IsSolidPathFilter
+import io.github.dockyardmc.pathfinding.Navigator
+import io.github.dockyardmc.pathfinding.Pathfinder
+import io.github.dockyardmc.pathfinding.RequiredHeightPathfindingFilter
+import io.github.dockyardmc.scheduler.runnables.inWholeMinecraftTicks
+import io.github.dockyardmc.scheduler.runnables.ticks
+import io.github.dockyardmc.utils.Disposable
+import io.github.dockyardmc.utils.Freezable
+import java.util.concurrent.CompletableFuture
+import java.util.concurrent.atomic.AtomicBoolean
+
+abstract class EntityBehaviourCoordinator(val entity: Entity) : Freezable(), Disposable {
+
+    val eventPool = EventPool().withFilter(EventFilter.containsEntity(entity))
+    val behaviours: MutableList<EntityBehaviourNode> = mutableListOf()
+    var activeBehaviour: EntityBehaviourNode? = null
+    private val isEvaluating = AtomicBoolean(false)
+    val pathfinder = Pathfinder.createPathfinder {
+        async(true)
+        maxIterations(300)
+        maxLength(60)
+    }
+
+    val navigator: Navigator = Navigator(entity, 15, pathfinder, listOf(RequiredHeightPathfindingFilter(2), IsSolidPathFilter()))
+
+    var generalTicks = 0
+    var frontStageTicks = 0
+    var backstageTicks = 0
+
+    override fun freeze() {
+        super.freeze()
+        navigator.cancelNavigating()
+        stopBehaviour()
+    }
+
+    fun tick() {
+        if (frozen) return
+        generalTicks++
+        backstageTicks++
+
+        evaluateBehaviours()
+
+        if (activeBehaviour?.getBehaviourFuture() != null && activeBehaviour?.getBehaviourFuture()!!.isDone) {
+            stopBehaviour()
+        }
+        if (activeBehaviour != null) {
+            frontStageTicks++
+            activeBehaviour!!.onGeneralTick(generalTicks)
+            activeBehaviour!!.onFrontstageTick(frontStageTicks)
+        }
+        behaviours.forEach { behaviour ->
+            if (behaviour == activeBehaviour) return@forEach
+            behaviour.onBackstageTick(backstageTicks)
+            if (behaviour.cooldown.inWholeMinecraftTicks > 0) {
+                behaviour.cooldown = behaviour.cooldown.minus(1.ticks)
+            }
+        }
+    }
+
+    fun stopBehaviour() {
+        activeBehaviour?.onStop(entity, true)
+        activeBehaviour?.getBehaviourFuture()?.cancel(true)
+        activeBehaviour = null
+    }
+
+    fun forceBehaviour(behaviourNode: EntityBehaviourNode) {
+        stopBehaviour()
+
+        behaviourNode.setBehaviourFuture(CompletableFuture<EntityBehaviourResult>())
+        this.activeBehaviour = behaviourNode
+        behaviourNode.onStart(entity)
+    }
+
+    fun evaluateBehaviours() {
+        if (isEvaluating.get()) return
+        isEvaluating.set(true)
+
+        val currentScorer = activeBehaviour?.getScorer(entity) ?: 0f
+
+        try {
+            val filtered = behaviours.filter { behaviour ->
+                behaviour != activeBehaviour && behaviour.getScorer(entity) != 0f && behaviour.cooldown.inWholeMinecraftTicks == 0
+            }
+            val bestNode = filtered.maxByOrNull { behaviour -> behaviour.getScorer(entity) }
+            if (bestNode != null) {
+                if ((activeBehaviour != null && activeBehaviour!!.interruptible && bestNode.getScorer(entity) > currentScorer) || activeBehaviour == null) {
+                    forceBehaviour(bestNode)
+                }
+            }
+
+        } finally {
+            isEvaluating.set(false)
+        }
+    }
+
+    override fun dispose() {
+        eventPool.dispose()
+        activeBehaviour?.onStop(entity, true)
+        activeBehaviour?.getBehaviourFuture()?.cancel(false)
+    }
+
+}
\ No newline at end of file
diff --git a/src/main/kotlin/io/github/dockyardmc/entity/ai/EntityBehaviourNode.kt b/src/main/kotlin/io/github/dockyardmc/entity/ai/EntityBehaviourNode.kt
new file mode 100644
index 000000000..e3b8064eb
--- /dev/null
+++ b/src/main/kotlin/io/github/dockyardmc/entity/ai/EntityBehaviourNode.kt
@@ -0,0 +1,27 @@
+package io.github.dockyardmc.entity.ai
+
+import io.github.dockyardmc.entity.Entity
+import io.github.dockyardmc.scheduler.runnables.ticks
+import java.util.concurrent.CompletableFuture
+import kotlin.time.Duration
+
+abstract class EntityBehaviourNode {
+    open val interruptible: Boolean = true
+    private var future = CompletableFuture<EntityBehaviourResult>()
+    var cooldown: Duration = 0.ticks
+
+    fun getBehaviourFuture(): CompletableFuture<EntityBehaviourResult> = future
+    fun setBehaviourFuture(newFuture: CompletableFuture<EntityBehaviourResult>) {
+        this.future = newFuture
+    }
+
+    abstract fun getScorer(entity: Entity): Float
+
+    abstract fun onStart(entity: Entity)
+
+    abstract fun onBackstageTick(tick: Int)
+    abstract fun onFrontstageTick(tick: Int)
+    abstract fun onGeneralTick(tick: Int)
+
+    abstract fun onStop(entity: Entity, interrupted: Boolean)
+}
\ No newline at end of file
diff --git a/src/main/kotlin/io/github/dockyardmc/entity/ai/EntityBehaviourResult.kt b/src/main/kotlin/io/github/dockyardmc/entity/ai/EntityBehaviourResult.kt
new file mode 100644
index 000000000..2d03c98d9
--- /dev/null
+++ b/src/main/kotlin/io/github/dockyardmc/entity/ai/EntityBehaviourResult.kt
@@ -0,0 +1,7 @@
+package io.github.dockyardmc.entity.ai
+
+enum class EntityBehaviourResult {
+    SUCCESS,
+    INTERRUPTED,
+    FAILED
+}
\ No newline at end of file
diff --git a/src/main/kotlin/io/github/dockyardmc/entity/ai/goals/PlayAmbientNoiseAIGoal.kt b/src/main/kotlin/io/github/dockyardmc/entity/ai/goals/PlayAmbientNoiseAIGoal.kt
deleted file mode 100644
index 78deb11f6..000000000
--- a/src/main/kotlin/io/github/dockyardmc/entity/ai/goals/PlayAmbientNoiseAIGoal.kt
+++ /dev/null
@@ -1,25 +0,0 @@
-package io.github.dockyardmc.entity.ai.goals
-
-import io.github.dockyardmc.entity.Entity
-import io.github.dockyardmc.entity.ai.AIGoal
-import io.github.dockyardmc.sounds.Sound
-import kotlin.random.Random
-
-class PlayAmbientNoiseAIGoal(override var entity: Entity, override var priority: Int, val chancePerTick: Int, val sound: String): AIGoal() {
-
-    override fun startCondition(): Boolean {
-        return Random.nextInt(chancePerTick, 100) == chancePerTick
-    }
-
-    override fun start() {
-        entity.playSoundToViewers(Sound(sound), entity.location)
-    }
-
-    override fun tick() {
-    }
-
-    override fun end() {
-    }
-
-    override fun endCondition(): Boolean = true
-}
\ No newline at end of file
diff --git a/src/main/kotlin/io/github/dockyardmc/entity/ai/goals/RandomLookAroundAIGoal.kt b/src/main/kotlin/io/github/dockyardmc/entity/ai/goals/RandomLookAroundAIGoal.kt
deleted file mode 100644
index b3d5db4b3..000000000
--- a/src/main/kotlin/io/github/dockyardmc/entity/ai/goals/RandomLookAroundAIGoal.kt
+++ /dev/null
@@ -1,42 +0,0 @@
-package io.github.dockyardmc.entity.ai.goals
-
-import io.github.dockyardmc.entity.Entity
-import io.github.dockyardmc.entity.ai.AIGoal
-import io.github.dockyardmc.maths.vectors.Vector3d
-import kotlin.math.cos
-import kotlin.math.sin
-import kotlin.random.Random
-
-class RandomLookAroundAIGoal(override var entity: Entity, override var priority: Int, val chancePerTick: Int): AIGoal() {
-
-    var lookTime = 0
-    var lookingDirection: Vector3d = Vector3d(0.0)
-
-    override fun startCondition(): Boolean {
-        return Random.nextInt(chancePerTick, 100) == chancePerTick
-    }
-
-    override fun start() {
-        lookTime = 10
-        lookingDirection = getRandomDirection()
-    }
-
-    override fun tick() {
-        lookTime--
-        entity.teleport(entity.location.setDirection(lookingDirection))
-    }
-
-    override fun end() {
-    }
-
-    override fun endCondition(): Boolean = this.lookTime <= 0
-
-    private fun getRandomDirection(): Vector3d {
-        val n: Double = Math.PI * 2 * Random.nextDouble()
-        return Vector3d(
-            cos(n),
-            0.0,
-            sin(n)
-        )
-    }
-}
\ No newline at end of file
diff --git a/src/main/kotlin/io/github/dockyardmc/entity/ai/goals/RandomWalkAroundGoal.kt b/src/main/kotlin/io/github/dockyardmc/entity/ai/goals/RandomWalkAroundGoal.kt
deleted file mode 100644
index 2310c5212..000000000
--- a/src/main/kotlin/io/github/dockyardmc/entity/ai/goals/RandomWalkAroundGoal.kt
+++ /dev/null
@@ -1,60 +0,0 @@
-package io.github.dockyardmc.entity.ai.goals
-
-import io.github.dockyardmc.entity.Entity
-import io.github.dockyardmc.entity.ai.AIGoal
-import io.github.dockyardmc.location.Location
-import io.github.dockyardmc.pathfinding.Navigator
-import io.github.dockyardmc.pathfinding.PatheticPlatformDockyard.toPathPosition
-import io.github.dockyardmc.pathfinding.PathfindingHelper
-import kotlin.random.Random
-
-class RandomWalkAroundGoal(override var entity: Entity, override var priority: Int, val navigator: Navigator) : AIGoal() {
-
-    val chancePerTick = 35
-    val startingLocation = entity.location
-    var hasFinishedWalking = false
-
-    override fun startCondition(): Boolean {
-        return Random.nextInt(chancePerTick, 100) == chancePerTick
-    }
-
-    override fun start() {
-        hasFinishedWalking = false
-        var locationToPathfindTo: Location? = null
-        startingLocation.getBlocksInRadius(10).shuffled().forEach { location ->
-            if (!PathfindingHelper.isTraversable(location.block, location)) return@forEach
-            val start = entity.location.getBlockLocation().subtract(0, 1, 0).toPathPosition()
-            val end = location.toPathPosition()
-
-            navigator.pathfinder.findPath(start, end, navigator.filters).thenAccept { result ->
-                if (!result.successful()) return@thenAccept
-                locationToPathfindTo = location
-            }
-        }
-
-        if (locationToPathfindTo == null) {
-            hasFinishedWalking = true
-            return
-        }
-
-        navigator.updatePathfindingPath(locationToPathfindTo!!)
-        navigator.navigationCompleteDispatcher.subscribe {
-            hasFinishedWalking = true
-        }
-    }
-
-    override fun end() {
-        navigator.cancelNavigating()
-        hasFinishedWalking = false
-    }
-
-    override fun endCondition(): Boolean {
-        return hasFinishedWalking
-    }
-
-    override fun tick() {
-
-    }
-
-}
-
diff --git a/src/main/kotlin/io/github/dockyardmc/entity/handlers/EntityMetadataHandler.kt b/src/main/kotlin/io/github/dockyardmc/entity/handlers/EntityMetadataHandler.kt
index e2fa58c0a..6f03a6ed9 100644
--- a/src/main/kotlin/io/github/dockyardmc/entity/handlers/EntityMetadataHandler.kt
+++ b/src/main/kotlin/io/github/dockyardmc/entity/handlers/EntityMetadataHandler.kt
@@ -10,7 +10,6 @@ import io.github.dockyardmc.entity.metadata.getEntityMetadataState
 import io.github.dockyardmc.player.EntityPose
 import io.github.dockyardmc.player.PersistentPlayer
 import io.github.dockyardmc.scroll.extensions.toComponent
-import java.lang.IllegalStateException
 
 class EntityMetadataHandler(override val entity: Entity) : EntityHandler {
 
@@ -30,6 +29,14 @@ class EntityMetadataHandler(override val entity: Entity) : EntityHandler {
         }
     }
 
+    fun remove(key: EntityMetadataType) {
+        synchronized(metadata) {
+            metadata.remove(key)
+            entity.sendMetadataPacketToViewers()
+            entity.sendSelfMetadataIfPlayer()
+        }
+    }
+
     operator fun get(key: EntityMetadataType): EntityMetadata {
         return getOrNull(key) ?: throw NoSuchElementException("No entity metadata with type ${key.name} present")
     }
diff --git a/src/main/kotlin/io/github/dockyardmc/entity/metadata/EntityMetadata.kt b/src/main/kotlin/io/github/dockyardmc/entity/metadata/EntityMetadata.kt
index cd5b138af..ad88d55bd 100644
--- a/src/main/kotlin/io/github/dockyardmc/entity/metadata/EntityMetadata.kt
+++ b/src/main/kotlin/io/github/dockyardmc/entity/metadata/EntityMetadata.kt
@@ -192,6 +192,7 @@ enum class EntityMetadataType(var protocolIndex: Int) {
     LIVING_ENTITY_NUMBER_OF_BEE_STRINGERS(13),
     LIVING_ENTITY_LOCATION_OF_BED(14),
     ARMOR_STAND_BITMASK(15),
+    ZOMBIE_RAISED_ARMS(15),
     ARMOR_STAND_HEAD_ROTATION(16),
     ARMOR_STAND_BODY_ROTATION(17),
     ARMOR_STAND_LEFT_ARM_ROTATION(18),
diff --git a/src/main/kotlin/io/github/dockyardmc/location/Location.kt b/src/main/kotlin/io/github/dockyardmc/location/Location.kt
index 4f1e7319b..b01381fdd 100644
--- a/src/main/kotlin/io/github/dockyardmc/location/Location.kt
+++ b/src/main/kotlin/io/github/dockyardmc/location/Location.kt
@@ -89,6 +89,14 @@ data class Location(
 
     fun distance(other: Location): Double = sqrt((this.x - other.x).pow(2.0) + (this.y - other.y).pow(2.0) + (this.z - other.z).pow(2.0))
 
+    fun distanceSquared(other: Location): Double {
+        val dx = this.x - other.x
+        val dy = this.y - other.y
+        val dz = this.z - other.z
+
+        return dx * dx + dy * dy + dz * dz
+    }
+
     fun distanceVector(other: Location): Vector3d {
         val dx = this.x - other.x
         val dy = this.y - other.y
@@ -173,6 +181,10 @@ data class Location(
         return sameBlock(point.x, point.y, point.z)
     }
 
+    fun sameBlock(location: Location): Boolean {
+        return this.sameBlock(location.getBlockLocation().toVector3())
+    }
+
     fun sameBlock(blockX: Int, blockY: Int, blockZ: Int): Boolean {
         return this.blockX == blockX && this.blockY == blockY && this.blockZ == blockZ
     }
diff --git a/src/main/kotlin/io/github/dockyardmc/maths/vectors/Vector3.kt b/src/main/kotlin/io/github/dockyardmc/maths/vectors/Vector3.kt
index 4e6242162..8b67757fa 100644
--- a/src/main/kotlin/io/github/dockyardmc/maths/vectors/Vector3.kt
+++ b/src/main/kotlin/io/github/dockyardmc/maths/vectors/Vector3.kt
@@ -15,7 +15,7 @@ data class Vector3(
     var x: Int,
     var y: Int,
     var z: Int,
-): NetworkWritable {
+) : NetworkWritable {
     constructor() : this(0, 0, 0)
     constructor(single: Int) : this(single, single, single)
 
@@ -86,13 +86,23 @@ data class Vector3(
     }
 
     fun distance(other: Vector3): Double {
-        return sqrt((this.x - other.x).toDouble().pow(2) +
+        return sqrt(
+            (this.x - other.x).toDouble().pow(2) +
                     (this.y - other.y).toDouble().pow(2) +
-                    (this.z - other.z).toDouble().pow(2))
+                    (this.z - other.z).toDouble().pow(2)
+        )
     }
 
     val isZero: Boolean get() = x == 0 && y == 0 && z == 0
 
+    fun distanceSquared(other: Vector3): Int {
+        val dx = this.x - other.x
+        val dy = this.y - other.y
+        val dz = this.z - other.z
+
+        return dx * dx + dy * dy + dz * dz
+    }
+
     fun toLocation(world: World): Location = Location(this.x, this.y, this.z, world)
     fun toVector3d() = Vector3d(x.toDouble(), y.toDouble(), z.toDouble())
     fun toVector3f() = Vector3f(x.toFloat(), y.toFloat(), z.toFloat())
@@ -125,7 +135,7 @@ data class Vector3(
         buffer.writeShort(this.z)
     }
 
-    companion object: NetworkReadable<Vector3> {
+    companion object : NetworkReadable<Vector3> {
 
         override fun read(buffer: ByteBuf): Vector3 {
             return Vector3(
diff --git a/src/main/kotlin/io/github/dockyardmc/pathfinding/IsSolidPathFilter.kt b/src/main/kotlin/io/github/dockyardmc/pathfinding/IsSolidPathFilter.kt
new file mode 100644
index 000000000..4c8d2d3e9
--- /dev/null
+++ b/src/main/kotlin/io/github/dockyardmc/pathfinding/IsSolidPathFilter.kt
@@ -0,0 +1,14 @@
+package io.github.dockyardmc.pathfinding
+
+import de.metaphoriker.pathetic.api.pathing.filter.PathFilter
+import de.metaphoriker.pathetic.api.pathing.filter.PathValidationContext
+import io.github.dockyardmc.pathfinding.PatheticPlatformDockyard.toLocation
+
+class IsSolidPathFilter: PathFilter {
+
+    override fun filter(context: PathValidationContext): Boolean {
+        val location = context.position.toLocation()
+        val block = location.block
+        return PathfindingHelper.isTraversable(block, location)
+    }
+}
\ No newline at end of file
diff --git a/src/main/kotlin/io/github/dockyardmc/pathfinding/Navigator.kt b/src/main/kotlin/io/github/dockyardmc/pathfinding/Navigator.kt
index a1949f4fd..637a9a0f2 100644
--- a/src/main/kotlin/io/github/dockyardmc/pathfinding/Navigator.kt
+++ b/src/main/kotlin/io/github/dockyardmc/pathfinding/Navigator.kt
@@ -8,14 +8,14 @@ import io.github.dockyardmc.entity.Entity
 import io.github.dockyardmc.events.EntityNavigatorPickOffsetEvent
 import io.github.dockyardmc.events.Events
 import io.github.dockyardmc.location.Location
+import io.github.dockyardmc.maths.locationLerp
 import io.github.dockyardmc.pathfinding.PatheticPlatformDockyard.toLocation
 import io.github.dockyardmc.pathfinding.PatheticPlatformDockyard.toPathPosition
-import io.github.dockyardmc.scheduler.runnables.ticks
 import io.github.dockyardmc.scheduler.SchedulerTask
+import io.github.dockyardmc.scheduler.runnables.ticks
 import io.github.dockyardmc.utils.Disposable
 import io.github.dockyardmc.utils.UsedAfterDisposedException
 import io.github.dockyardmc.utils.getEntityEventContext
-import io.github.dockyardmc.maths.locationLerp
 
 class Navigator(val entity: Entity, var speedTicksPerBlock: Int, val pathfinder: Pathfinder, val filters: List<PathFilter>) : Disposable {
 
@@ -51,13 +51,12 @@ class Navigator(val entity: Entity, var speedTicksPerBlock: Int, val pathfinder:
             pathfindResultDispatcher.dispatch(result)
 
             if (result.hasFailed()) {
-                path.clear()
                 cancelNavigating()
                 return@thenAccept
             }
 
             val newPath = result.path.map { pathPosition ->
-                 val event = EntityNavigatorPickOffsetEvent(entity, this, pathPosition.toLocation(), getEntityEventContext(entity))
+                val event = EntityNavigatorPickOffsetEvent(entity, this, pathPosition.toLocation(), getEntityEventContext(entity))
                 Events.dispatch(event)
 
                 event.location
@@ -73,25 +72,34 @@ class Navigator(val entity: Entity, var speedTicksPerBlock: Int, val pathfinder:
             path.clear()
             path.addAll(newPathQueue)
             newPathQueue.clear()
-            currentNavigationNodeIndex = if (path.size >= 5) 2 else 1
+            currentNavigationNodeIndex = 1
         }
     }
 
     private fun startNavigating() {
         if (state == State.DISPOSED) throw UsedAfterDisposedException(this)
         state = State.NAVIGATING
-        cancelNavigating()
+        currentTask?.cancel()
         updatePathWhileNavigating()
 
         currentTask = entity.world.scheduler.runRepeating(speedTicksPerBlock.ticks) { task ->
+
             if (state == State.IDLE) {
                 cancelNavigating()
                 return@runRepeating
             }
 
-            val currentStepPosition = entity.location
-            val nextStepPosition = path.getOrNull(currentNavigationNodeIndex)
-            val dispatcherData = PathfindingStep(currentStepPosition, nextStepPosition)
+            val entityPosition = entity.location
+            var nextStepPosition = path.getOrNull(currentNavigationNodeIndex)
+
+            //TODO this is a very ugly hack please future maya removed this thank you
+            // - past maya
+            if (entityPosition.getBlockLocation().apply { y = 0.0 } == nextStepPosition?.getBlockLocation()?.apply { y = 0.0 }) {
+                currentNavigationNodeIndex++
+                nextStepPosition = path.getOrNull(currentNavigationNodeIndex)
+            }
+
+            val dispatcherData = PathfindingStep(entityPosition, nextStepPosition)
             navigationNodeStepDispatcher.dispatch(dispatcherData)
 
             if (nextStepPosition == null) {
@@ -101,11 +109,12 @@ class Navigator(val entity: Entity, var speedTicksPerBlock: Int, val pathfinder:
             }
 
             var j = 0
+
             currentInterpolationTask = entity.world.scheduler.repeat(speedTicksPerBlock, 1.ticks) { _ ->
-                if(entity.isDead) return@repeat
+                if (entity.isDead) return@repeat
                 j++
                 val progress = j / speedTicksPerBlock.toDouble()
-                val interpolated = locationLerp(currentStepPosition, normalizePathLocation(nextStepPosition), progress.toFloat())
+                val interpolated = locationLerp(entityPosition, normalizePathLocation(nextStepPosition), progress.toFloat())
                 val direction = interpolated.toVector3d() - (entity.location).toVector3d()
                 val location = interpolated.setDirection(direction)
                 entity.teleport(location)
@@ -148,6 +157,7 @@ class Navigator(val entity: Entity, var speedTicksPerBlock: Int, val pathfinder:
         navigationNodeStepDispatcher.dispose()
         path.clear()
         newPathQueue.clear()
+        isCurrentlyPathfinding = false
     }
 }
 
diff --git a/src/main/kotlin/io/github/dockyardmc/utils/Freezable.kt b/src/main/kotlin/io/github/dockyardmc/utils/Freezable.kt
new file mode 100644
index 000000000..95f269ac1
--- /dev/null
+++ b/src/main/kotlin/io/github/dockyardmc/utils/Freezable.kt
@@ -0,0 +1,13 @@
+package io.github.dockyardmc.utils
+
+abstract class Freezable {
+    var frozen: Boolean = false
+
+    open fun freeze() {
+        frozen = true
+    }
+
+    open fun unfreeze() {
+        frozen = false
+    }
+}
\ No newline at end of file