Dynamic zone fixes (#767)

* Fix region reloading for dynamic regions, hopefully solves #326

* Fix dynamic region copying objects incorrectly + add more tests

Author: GregHib

engine/src/main/kotlin/world/gregs/voidps/engine/entity/character/mode/move/Movement.kt

@@ -20,7 +20,6 @@ import world.gregs.voidps.engine.entity.character.player.temporaryMoveType
 import world.gregs.voidps.engine.get
 import world.gregs.voidps.engine.map.Overlap
 import world.gregs.voidps.engine.map.collision.Collisions
-import world.gregs.voidps.engine.map.region.RegionRetry
 import world.gregs.voidps.network.login.protocol.visual.update.player.MoveType
 import world.gregs.voidps.type.Delta
 import world.gregs.voidps.type.Direction
@@ -54,10 +53,6 @@ open class Movement(
 
     override fun tick() {
         if (character is Player && character.viewport?.loaded == false) {
-            if (character.viewport != null && character.inc("fail_load_count") > 10) {
-                character.emit(RegionRetry)
-                character.clear("fail_load_count")
-            }
             return
         }
         if (hasDelay() && !canMove() && !character.steps.destination.noCollision) {

engine/src/main/kotlin/world/gregs/voidps/engine/map/collision/CollisionDecoder.kt

@@ -67,6 +67,7 @@ class CollisionDecoder(private val collisions: Collisions) {
                     }
                     val rotX = rotateX(localX, localY, zoneRotation)
                     val rotY = rotateY(localX, localY, zoneRotation)
+
                     if (isTile(settings, localX, localY, level, ROOF_TILE)) {
                         collisions.setUnsafe(targetX + rotX, targetY + rotY, height, CollisionFlag.ROOF)
                     }

engine/src/main/kotlin/world/gregs/voidps/engine/map/obj/MapObjectsRotatedDecoder.kt

@@ -23,7 +23,7 @@ class MapObjectsRotatedDecoder(
         val objectData = cache.data(Index.MAPS, "l${from.region.x}_${from.region.y}", xtea = keys) ?: return
         val x = from.tile.x.rem(64)
         val y = from.tile.y.rem(64)
-        zone = Rectangle(x, y, x + 8, y + 8)
+        zone = Rectangle(x, y, x + 7, y + 7)
         zoneRotation = rotation
         super.decode(objectData, settings, to.tile.x, to.tile.y)
     }
@@ -39,55 +39,53 @@ class MapObjectsRotatedDecoder(
         objects.set(objectId, regionTileX + rotX, regionTileY + rotY, level, shape, objRotation, def)
     }
 
-    companion object {
-        private fun rotateX(
-            objX: Int,
-            objY: Int,
-            sizeX: Int,
-            sizeY: Int,
-            objRotation: Int,
-            zoneRotation: Int,
-        ): Int {
-            var x = sizeX
-            var y = sizeY
-            val rotation = zoneRotation and 0x3
-            if (objRotation and 0x1 == 1) {
-                val temp = x
-                x = y
-                y = temp
-            }
-            if (rotation == 0) {
-                return objX
-            }
-            if (rotation == 1) {
-                return objY
-            }
-            return if (rotation == 2) 7 - objX - x + 1 else 7 - objY - y + 1
+    internal fun rotateX(
+        objX: Int,
+        objY: Int,
+        sizeX: Int,
+        sizeY: Int,
+        objRotation: Int,
+        zoneRotation: Int,
+    ): Int {
+        var x = sizeX
+        var y = sizeY
+        val rotation = zoneRotation and 0x3
+        if (objRotation and 0x1 == 1) {
+            val temp = x
+            x = y
+            y = temp
         }
+        if (rotation == 0) {
+            return objX
+        }
+        if (rotation == 1) {
+            return objY
+        }
+        return if (rotation == 2) 7 - objX - x + 1 else 7 - objY - y + 1
+    }
 
-        private fun rotateY(
-            objX: Int,
-            objY: Int,
-            sizeX: Int,
-            sizeY: Int,
-            objRotation: Int,
-            zoneRotation: Int,
-        ): Int {
-            val rotation = zoneRotation and 0x3
-            var x = sizeY
-            var y = sizeX
-            if (objRotation and 0x1 == 1) {
-                val temp = y
-                y = x
-                x = temp
-            }
-            if (rotation == 0) {
-                return objY
-            }
-            if (rotation == 1) {
-                return 7 - objX - y + 1
-            }
-            return if (rotation == 2) 7 - objY - x + 1 else objX
+    internal fun rotateY(
+        objX: Int,
+        objY: Int,
+        sizeX: Int,
+        sizeY: Int,
+        objRotation: Int,
+        zoneRotation: Int,
+    ): Int {
+        val rotation = zoneRotation and 0x3
+        var x = sizeY
+        var y = sizeX
+        if (objRotation and 0x1 == 1) {
+            val temp = y
+            y = x
+            x = temp
+        }
+        if (rotation == 0) {
+            return objY
+        }
+        if (rotation == 1) {
+            return 7 - objX - y + 1
         }
+        return if (rotation == 2) 7 - objY - x + 1 else objX
     }
 }

engine/src/main/kotlin/world/gregs/voidps/engine/map/region/RegionRetry.kt

@@ -16,21 +16,37 @@ class DynamicZones(
     private val objects: GameObjects,
     private val collisions: Collisions,
     private val extract: MapDefinitions,
-) {
+) : Runnable {
     private val zones: MutableMap<Int, Int> = Int2IntArrayMap()
+    // All dynamic regions
     private val regions = IntOpenHashSet()
 
-    fun isDynamic(region: Region) = regions.contains(region.id)
+    // Dynamic regions that have recently been modified (not cleared)
+    private val refresh = IntOpenHashSet()
 
-    fun getDynamicZone(zone: Zone) = zones[zone.id]
+    // All recent region changes (including clearing)
+    private val updated = IntOpenHashSet()
+
+    fun dynamic(region: Region) = regions.contains(region.id)
+
+    fun dynamicUpdate(region: Region) = refresh.contains(region.id)
+
+    fun dynamicZone(zone: Zone) = zones[zone.id]
 
     /**
      * @param from The zone to be copied
      * @param to The zone things will be copied to
      */
     fun copy(from: Zone, to: Zone = from, rotation: Int = 0) {
         zones[to.id] = from.rotatedId(rotation)
-        update(from, to, rotation, true)
+        objects.reset(to)
+        collisions.clear(to)
+        extract.loadZone(from, to, rotation)
+        for (region in to.toCuboid(radius = 3).toRegions()) {
+            regions.add(region.id)
+            refresh.add(region.id)
+        }
+        updated.add(to.region.id)
     }
 
     /**
@@ -49,35 +65,46 @@ class DynamicZones(
      */
     fun clear(zone: Zone) {
         zones.remove(zone.id)
-        update(zone, zone, 0, false)
+        objects.reset(zone)
+        collisions.clear(zone)
+        extract.loadZone(zone, zone, 0)
+        for (region in zone.toCuboid(radius = 3).toRegions()) {
+            if (region.toRectangle().toZones().none { zones.containsKey(it.id) }) {
+                regions.remove(region.id)
+            }
+        }
+        updated.add(zone.region.id)
     }
 
     /**
      * Clear the dynamic [region] and replace it with the original
      */
     fun clear(region: Region) {
         for (zone in region.toCuboid().toZones()) {
-            objects.clear(zone)
-            collisions.clear(zone)
-            extract.loadZone(zone, zone, 0)
-            zones.remove(zone.id)
+            if (zones.containsKey(zone.id)) {
+                objects.clear(zone)
+                collisions.clear(zone)
+                extract.loadZone(zone, zone, 0)
+                zones.remove(zone.id)
+            }
+        }
+        if (regions.remove(region.id)) {
+            updated.add(region.id)
         }
-        regions.remove(region.id)
-        World.emit(ClearRegion(region))
     }
 
-    private fun update(from: Zone, to: Zone, rotation: Int, set: Boolean) {
-        objects.reset(to)
-        collisions.clear(to)
-        extract.loadZone(from, to, rotation)
-        for (region in to.toCuboid(radius = 3).toRegions()) {
-            if (set) {
-                regions.add(region.id)
-            } else if (region.toRectangle().toZones().none { zones.containsKey(it.id) }) {
-                regions.remove(region.id)
-            }
+    /**
+     * Send updated regions to clients
+     */
+    override fun run() {
+        if (updated.isEmpty()) {
+            return
+        }
+        for (region in updated.iterator()) {
+            World.emit(RegionReload(Region(region)))
         }
-        World.emit(ReloadZone(to))
+        updated.clear()
+        refresh.clear()
     }
 
     companion object {

engine/src/main/kotlin/world/gregs/voidps/engine/map/zone/DynamicZones.kt

@@ -3,6 +3,9 @@ package world.gregs.voidps.engine.map.zone
 import world.gregs.voidps.engine.event.Event
 import world.gregs.voidps.engine.event.EventDispatcher
 
+/**
+ * Send region load to a player
+ */
 object RegionLoad : Event {
     override val size = 1
 

engine/src/main/kotlin/world/gregs/voidps/engine/map/zone/RegionLoad.kt

@@ -4,8 +4,11 @@ import world.gregs.voidps.engine.event.Event
 import world.gregs.voidps.engine.event.EventDispatcher
 import world.gregs.voidps.type.Region
 
-data class ClearRegion(val region: Region) : Event {
+/**
+ * A region has been changed and needs updating for all players
+ */
+data class RegionReload(val region: Region) : Event {
     override val size = 1
 
-    override fun parameter(dispatcher: EventDispatcher, index: Int) = if (index == 0) "clear_region" else null
+    override fun parameter(dispatcher: EventDispatcher, index: Int) = if (index == 0) "region_reload" else null
 }