fix: hardcode fix for archive server worldheight

Author: Boy0000

src/main/kotlin/com/mineinabyss/deeperworld/DeeperCommands.kt

@@ -110,7 +110,7 @@ object DeeperCommands {
                                 val loc = player.location
                                 val linkedSection = loc.correspondingSection ?: error("Corresponding Section not found")
 
-                                val linkedBlock = loc.getCorrespondingLocation(section, linkedSection)?.block
+                                val linkedBlock = loc.correspondingLocation(section, linkedSection)?.block
                                     ?: error("Corresponding Location not found")
 
                                 val offset = pos2.y().coerceAtLeast(0)

src/main/kotlin/com/mineinabyss/deeperworld/synchronization/ContainerSyncListener.kt

@@ -4,13 +4,10 @@ import com.github.shynixn.mccoroutine.bukkit.launch
 import com.mineinabyss.deeperworld.deeperWorld
 import com.mineinabyss.deeperworld.world.section.*
 import com.mineinabyss.idofront.messaging.info
-import com.mineinabyss.idofront.plugin.Plugins
 import com.mineinabyss.idofront.time.ticks
 import kotlinx.coroutines.delay
 import nl.rutgerkok.blocklocker.BlockLockerAPIv2
-import nl.rutgerkok.blocklocker.SearchMode
 import org.bukkit.Chunk
-import org.bukkit.block.Block
 import org.bukkit.block.Container
 import org.bukkit.block.DecoratedPot
 import org.bukkit.block.Lidded
@@ -38,7 +35,7 @@ object ContainerSyncListener : Listener {
 
         val section = block.location.section ?: return
         val linkedSection = block.location.correspondingSection ?: return
-        val linkedBlock = block.location.getCorrespondingLocation(section, linkedSection)?.block ?: return
+        val linkedBlock = block.location.correspondingLocation(section, linkedSection)?.block ?: return
 
         blockLocker?.apply {
             updateProtection(linkedBlock)
@@ -53,7 +50,7 @@ object ContainerSyncListener : Listener {
 
         if (container is Lidded) {
             (linkedBlock.state as Lidded).open()
-            if (!section.isOnTopOf(linkedSection)) (container as Lidded).open()
+            if (!section.isOnTopOf(linkedSection)) container.open()
         }
 
         if (section.isOnTopOf(linkedSection)) return
@@ -91,7 +88,7 @@ object ContainerSyncListener : Listener {
         val section = block.location.section ?: return
         val linkedSection = block.location.correspondingSection ?: return
         val linkedBlock =
-            block.location.getCorrespondingLocation(section, linkedSection)?.block?.state as? DecoratedPot ?: return
+            block.location.correspondingLocation(section, linkedSection)?.block?.state as? DecoratedPot ?: return
 
         deeperWorld.plugin.launch {
             delay(1.ticks)

src/main/kotlin/com/mineinabyss/deeperworld/synchronization/Updaters.kt

@@ -28,7 +28,7 @@ internal inline fun Location.sync(
     if (!inSectionOverlap) return //ensure blocks don't get altered when we are outside of the corresponding region
     val section = section ?: return
     val correspondingSection = correspondingSection ?: return
-    val corresponding = getCorrespondingLocation(section, correspondingSection) ?: return
+    val corresponding = correspondingLocation(section, correspondingSection) ?: return
     updater(block, corresponding.block, section, correspondingSection)
 }
 

src/main/kotlin/com/mineinabyss/deeperworld/world/section/Section.kt

@@ -29,17 +29,17 @@ data class Section(
     val name: String? = null,
     val region: Region = Region(0,0,0,1,1,1),
     val world: @Serializable(WorldSerializer::class) World = Bukkit.getWorlds().first(),
-    @SerialName("refTop") private val _refTop: String,
+    @SerialName("refTop") private val refTop: String,
     @YamlComment("refBottom should connect to the refTop of the next section.")
-    @SerialName("refBottom") private val _refBottom: String
+    @SerialName("refBottom") private val refBottom: String
 ) {
     @Serializable(LocationSerializer::class)
     @EncodeDefault(EncodeDefault.Mode.NEVER)
-    val referenceTop = _refTop.toLocation(world)
+    val referenceTop = refTop.toLocation(world)
 
     @Serializable(LocationSerializer::class)
     @EncodeDefault(EncodeDefault.Mode.NEVER)
-    val referenceBottom = _refBottom.toLocation(world)
+    val referenceBottom = refBottom.toLocation(world)
 
     fun String.toLocation(world: World): Location {
         val (x,y,z) = this.getCoordinates().map { it.toDouble() }

src/main/kotlin/com/mineinabyss/deeperworld/world/section/SectionUtils.kt

@@ -22,11 +22,12 @@ val SectionKey.section get() = WorldManager.getSectionFor(this)
 val Location.correspondingSection: Section?
     get() {
         val section = this.section ?: return null
-        val above: Section? = section.aboveKey.section
-        val below: Section? = section.belowKey.section
+        val aboveSection = section.aboveKey.section
+        val belowSection = section.belowKey.section
+
         return when {
-            above != null && sharedBetween(section, above) -> above
-            below != null && sharedBetween(section, below) -> below
+            sharedBetween(section, aboveSection) -> aboveSection
+            sharedBetween(section, belowSection) -> belowSection
             else -> null
         }
     }
@@ -36,7 +37,7 @@ val Location.correspondingSection: Section?
  */
 val Location.correspondingLocation: Location?
     get() {
-        return getCorrespondingLocation(section ?: return null, correspondingSection ?: return null)
+        return correspondingLocation(section ?: return null, correspondingSection ?: return null)
     }
 
 /**
@@ -47,7 +48,7 @@ val Location.correspondingLocation: Location?
  * @param sectionB        the section we are translating the point to
  * @return A new location that corresponds to the original location
  */
-fun Location.getCorrespondingLocation(sectionA: Section, sectionB: Section): Location? {
+fun Location.correspondingLocation(sectionA: Section, sectionB: Section): Location? {
     if (!sectionA.isAdjacentTo(sectionB)) return null
 
     // We decide which two points we are translating between.
@@ -73,13 +74,17 @@ val Location.inSectionTransition: Boolean
     get() {
         // Get overlap of this section and corresponding section
         val shared = section?.overlapWith(correspondingSection ?: return false) ?: return false
-        return blockY >= world.maxHeight - .3 * shared || blockY <= world.minHeight + .3 * shared
+        // Archive Server hardcoding for now
+        val minHeight = if ("2021" in world.name) 0 else world.minHeight
+        return blockY >= world.maxHeight - .3 * shared || blockY <= minHeight + .3 * shared
     }
 
-fun Location.sharedBetween(section: Section, otherSection: Section): Boolean {
-    val overlap = section.overlapWith(otherSection) ?: return false
+fun Location.sharedBetween(section: Section, otherSection: Section?): Boolean {
+    val overlap = section.overlapWith(otherSection ?: return false) ?: return false
+    // Archive Server hardcoding for now
+    val minHeight = if ("2021" in world.name) 0 else world.minHeight
     return when {
-        section.isOnTopOf(otherSection) -> blockY <= world.minHeight + overlap
+        section.isOnTopOf(otherSection) -> blockY <= minHeight + overlap
         otherSection.isOnTopOf(section) -> blockY >= world.maxHeight - overlap
         else -> false
     }
@@ -89,12 +94,11 @@ fun Section.overlapWith(other: Section): Int? {
     if (!isAdjacentTo(other)) return null
     if (min(this.region.max.y, other.region.max.y) <= max(this.region.min.y, other.region.min.y)) return null
     // We decide which two points we are translating between.
-    val (locA, locB) = when (isOnTopOf(other)) {
-        true -> referenceBottom to other.referenceTop
-        false -> referenceTop to other.referenceBottom
+    val (yA, yB) = when {
+        isOnTopOf(other) -> referenceBottom.blockY to other.referenceTop.blockY
+        else -> referenceTop.blockY to other.referenceBottom.blockY
     }
-    val yA = locA.blockY
-    val yB = locB.blockY
+
     return max(this.region.max.y, other.region.max.y) - max(yA, yB) +
             (min(yA, yB) - min(this.region.min.y, other.region.min.y))
 }