[ChunkDataThrottle] Migrate to nms registry, vanilla blockstate occlude cache

Author: Rothes

bukkit/src/main/kotlin/io/github/rothes/esu/bukkit/module/NetworkThrottleModule.kt

@@ -5,6 +5,7 @@ import io.github.rothes.esu.bukkit.util.version.adapter.nms.MCRegistryValueSeria
 import io.github.rothes.esu.bukkit.util.version.versioned
 import io.github.rothes.esu.core.configuration.ConfigLoader
 import io.github.rothes.esu.core.configuration.ConfigurationPart
+import io.github.rothes.esu.core.configuration.LoadedConfiguration
 import io.github.rothes.esu.core.module.configuration.BaseModuleConfiguration
 import io.github.rothes.esu.lib.configurate.yaml.YamlConfigurationLoader
 import java.util.*
@@ -36,14 +37,26 @@ object NetworkThrottleModule: BukkitModule<BaseModuleConfiguration, NetworkThrot
         if (MCRegistryValueSerializers.isSupported) {
             builder.defaultOptions { options ->
                 options.serializers { builder ->
-                    builder.register(
-                        MCRegistryValueSerializers.instance.entityType
-                    )
+                    builder.register(MCRegistryValueSerializers.instance.block)
+                        .register(MCRegistryValueSerializers.instance.entityType)
                 }
             }
         }
     }
 
+    override fun preprocessConfig(loadedConfiguration: LoadedConfiguration) {
+        // v0.12.4
+        val node = loadedConfiguration.node
+        val from = node.node("chunk-data-throttle")
+        val to = node.node("chunk-data-throttle", "chunk-handler")
+        for ((key, value) in from.childrenMap()) {
+            if (key != "enabled" && key != "chunk-handler") {
+                to.node(value.key()).from(value)
+                from.removeChild(key)
+            }
+        }
+    }
+
 
     data class ModuleData(
         val originalViewDistance: MutableMap<UUID, Int> = linkedMapOf(),

bukkit/src/main/kotlin/io/github/rothes/esu/bukkit/module/networkthrottle/ChunkDataThrottle.kt

@@ -1,6 +1,5 @@
 package io.github.rothes.esu.bukkit.module.networkthrottle
 
-import io.github.retrooper.packetevents.util.SpigotConversionUtil
 import io.github.rothes.esu.bukkit.module.networkthrottle.chunkdatathrottle.ChunkDataThrottleHandler
 import io.github.rothes.esu.bukkit.plugin
 import io.github.rothes.esu.bukkit.util.ServerCompatibility
@@ -9,23 +8,20 @@ import io.github.rothes.esu.bukkit.util.version.versioned
 import io.github.rothes.esu.core.command.annotation.ShortPerm
 import io.github.rothes.esu.core.configuration.data.MessageData.Companion.message
 import io.github.rothes.esu.core.configuration.meta.Comment
-import io.github.rothes.esu.core.configuration.meta.RenamedFrom
-import io.github.rothes.esu.core.configuration.serializer.MapSerializer.DefaultedLinkedHashMap
 import io.github.rothes.esu.core.module.CommonFeature
 import io.github.rothes.esu.core.module.Feature
 import io.github.rothes.esu.core.module.configuration.BaseFeatureConfiguration
 import io.github.rothes.esu.core.module.configuration.EmptyConfiguration
 import io.github.rothes.esu.core.user.User
-import io.github.rothes.esu.lib.configurate.objectmapping.meta.PostProcess
-import org.bukkit.Material
 import org.incendo.cloud.annotations.Command
 
 object ChunkDataThrottle: CommonFeature<ChunkDataThrottle.FeatureConfig, EmptyConfiguration>() {
 
-    val versioned by lazy { ChunkDataThrottleHandler::class.java.versioned() }
-    val counter
-        get() = versioned.counter
-    private var wasEnabled = false
+    val handler by lazy { ChunkDataThrottleHandler::class.java.versioned() }
+
+    init {
+        if (ServerCompatibility.serverVersion >= "1.18") registerFeature(handler)
+    }
 
     override fun checkUnavailable(): Feature.AvailableCheck? {
         return super.checkUnavailable() ?: checkPacketEvents() ?: let {
@@ -37,161 +33,23 @@ object ChunkDataThrottle: CommonFeature<ChunkDataThrottle.FeatureConfig, EmptyCo
         }
     }
 
-    override fun onReload() {
-        super.onReload()
-        if (enabled)
-            versioned.onReload()
-    }
-
     override fun onEnable() {
-        wasEnabled = true
-        versioned.onEnable()
-
         registerCommands(object {
             @Command("esu networkThrottle chunkDataThrottle stats")
             @ShortPerm("chunkDataThrottle")
             fun chunkDataThrottleView(sender: User) {
-                val (minimalChunks, resentChunks, resentBlocks) = counter
+                val (minimalChunks, resentChunks, resentBlocks) = handler.counter
                 sender.message("minimalChunks: $minimalChunks ; resentChunks: $resentChunks ; resentBlocks: $resentBlocks")
             }
         })
     }
 
-    override fun onTerminate() {
-        super.onTerminate()
-        if (wasEnabled) versioned.onTerminate()
-    }
-
     @Comment("""
             Helps to reduce chunk upload bandwidth. Plugin will compress invisible blocks in chunk data packet.
             If necessary, we send a full chunk data again.
             This can save about 50% bandwidth usage in overworld and 30% in nether averagely.
             Make sure you have enabled network-compression on proxy or this server.
             """)
-    data class FeatureConfig(
-        @Comment("""
-                Plugin will resent complete original chunk data if resent block amount exceeds this value.
-                Set it to -1 will never resent chunk but keep updating nearby blocks, 
-                 0 to always resent original chunks.
-                Set this to a large value can prevent constantly sending block update packets.
-                Original chunk is not with anti-xray functionality. It is recommended to leave this value -1 .
-                """,
-            overrideOld = [
-                """
-                    Plugin will resent whole chunk data if resent block amount exceeds this value.
-                    Set it to -1 will never resent chunk but keep updating nearby blocks, 
-                     0 to always resent chunks.
-                    """
-            ])
-        val thresholdToResentWholeChunk: Int = -1,
-        @Comment("""
-                We updates the nearby blocks when a player digs a block immediately.
-                If this is enabled, we will check if the block is in the interaction range
-                 of the player with a rough calculation.
-                """)
-        val updateOnLegalInteractOnly: Boolean = true,
-        @Comment("How many distance of blocks to update from the center when necessary.")
-        val updateDistance: Int = 2,
-        @Comment("""
-                The bedrock level(minimal height) is never visible unless you are in void.
-                We would skip the check, and if you don't like it you can enable it.
-                """)
-        val minimalHeightInvisibleCheck: Boolean = false,
-        @Comment("""
-                Same with minimal-height but it's for nether roof. For out-of-the-box, it's true by default.
-                It's highly recommend to set it to FALSE if you don't allow players to get above there.
-                """,
-            overrideOld = ["Same with minimal-height but it's for nether roof."]
-        )
-        val netherRoofInvisibleCheck: Boolean = true,
-        @Comment("""
-                If a non-occluding block is surrounded by occluding blocks, the center block is invisible.
-                But should we consider all surrounded blocks invisible to this block face?
-                Unless the player joins the game with their eye in the non-occluding block,
-                 they will never naturally see those surrounded blocks.
-                This step takes extra ~0.02ms, so it's not enabled by default.
-                Enable this could help with saving bandwidth in nether, as there's many single-block lava.
-            """)
-        val detectInvisibleSingleBlock: Boolean = false,
-        @Comment("""
-                Detect lava pool, and consider lava blocks which being covered invisible.
-                This step takes extra ~0.03ms, so it's not enabled by default.
-                It also makes the plugin detect nearby blocks everytime player moves.
-                Enable this could help with saving bandwidth, especially in nether.
-            """)
-        val detectLavaPool: Boolean = false,
-        @RenamedFrom("single-valued-section-block-list")
-        @Comment("""
-                    This feature doesn't support running along with any other anti-xray plugins.
-                    You must use the anti-xray here we provide.
-                    
-                    We will send non-visible blocks to one of the random block in this list.
-                    If you don't like to anti-xray, you can set the list to 'bedrock'.
-                """,
-            overrideOld = ["Plugin will convert chunks with all non-visible blocks to single-valued palette format,\nThis could save a lot of bandwidth. And since we are conflicting with anti-xray things,\nyou can use this for some kind of substitution.\nWe choose a random block from the list and make it of a 16*16*16 chunk section."]
-        )
-        val antiXrayRandomBlockList: DefaultedLinkedHashMap<String, MutableList<Material>> = DefaultedLinkedHashMap<String, MutableList<Material>>(
-            mutableListOf(Material.BEDROCK)
-        ).apply {
-            put("world", buildList {
-                val cavesUpdate = ServerCompatibility.serverVersion >= "1.17"
-                add(Material.COAL_ORE)
-                if (cavesUpdate) add(Material.COPPER_ORE)
-                addAll(listOf(Material.IRON_ORE, Material.GOLD_ORE,
-                    Material.EMERALD_ORE, Material.DIAMOND_ORE, Material.REDSTONE_ORE, Material.LAPIS_ORE))
-
-                if (cavesUpdate) addAll(listOf(Material.DEEPSLATE_COAL_ORE, Material.DEEPSLATE_COPPER_ORE,
-                    Material.DEEPSLATE_IRON_ORE, Material.DEEPSLATE_GOLD_ORE, Material.DEEPSLATE_EMERALD_ORE,
-                    Material.DEEPSLATE_DIAMOND_ORE, Material.DEEPSLATE_REDSTONE_ORE, Material.DEEPSLATE_LAPIS_ORE))
-            }.toMutableList())
-            put("world_nether", buildList {
-                add(Material.NETHER_QUARTZ_ORE)
-                if (ServerCompatibility.serverVersion >= "1.16") {
-                    add(Material.NETHER_GOLD_ORE)
-                    add(Material.ANCIENT_DEBRIS)
-                }
-            }.toMutableList())
-            put("world_the_end", mutableListOf(Material.END_STONE))
-        },
-        @Comment("""
-                If enabled, we add a extra block type to chunk section palettes for the random block.
-                This will greatly enhance anti-xray capabilities while giving only few bytes of additional bandwidth.
-            """)
-        val enhancedAntiXray: Boolean = true,
-        @Comment("""
-                Put any blocks you don't want to hide, so they are ignored while processing.
-                For example, you can add any ores to it, so there's no anti-xray effect.
-                WARNING: This significantly reduces compression badly. Please make sure you really have to do this.
-            """)
-        val nonInvisibleBlocksOverrides: Set<Material> = setOf(),
-    ): BaseFeatureConfiguration(true) {
-
-        val antiXrayRandomBlockIds by lazy {
-            with(antiXrayRandomBlockList) {
-                DefaultedLinkedHashMap<String, IntArray>((default ?: listOf(Material.BEDROCK)).map { it.globalId }.toIntArray()).also {
-                    it.putAll(entries.map { it.key to it.value.map { it.globalId }.toIntArray() })
-                }
-            }
-        }
-
-        private val Material.globalId
-            get() = if (!this.isBlock) error("Material $this is not a block type!") else SpigotConversionUtil.fromBukkitBlockData(createBlockData()).globalId
-
-        @PostProcess
-        private fun postProcess() {
-            fun checkEmptyBlockList(key: String, list: MutableList<Material>) {
-                if (list.isEmpty()) {
-                    list.add(Material.BEDROCK)
-                    plugin.warn("[ChunkDataThrottle] Anti-xray random block list of '$key' is empty! We have added bedrock to it.")
-                }
-            }
-            antiXrayRandomBlockList.default?.let {
-                checkEmptyBlockList("default", it)
-            }
-            antiXrayRandomBlockList.entries.toList().forEach {
-                checkEmptyBlockList(it.key, it.value)
-            }
-        }
-    }
+    class FeatureConfig(): BaseFeatureConfiguration(true)
 
 }

bukkit/src/main/kotlin/io/github/rothes/esu/bukkit/module/networkthrottle/chunkdatathrottle/ChunkDataThrottleHandler.kt

@@ -1,12 +1,12 @@
 package io.github.rothes.esu.bukkit.module.networkthrottle.chunkdatathrottle
 
-interface ChunkDataThrottleHandler {
+import io.github.rothes.esu.core.module.CommonFeature
 
-    val counter: Counter
+abstract class ChunkDataThrottleHandler<C, L>: CommonFeature<C, L>() {
 
-    fun onEnable()
-    fun onReload()
-    fun onTerminate()
+    override val name: String = "ChunkHandler"
+
+    val counter: Counter = Counter()
 
     data class Counter(
         var minimalChunks: Long = 0,

bukkit/src/main/resources/lang/modules/NetworkThrottle/config.yml/zh_cn.yml

@@ -3,48 +3,49 @@
 # 平均可以节省约 50% 的主世界带宽使用量和 30% 的下界带宽使用量。
 # 确保您已在群组服务器或本服务器上启用网络压缩(network-compression)。
 chunk-data-throttle:
-  # 如果重新发送的方块数量超过此值，将直接重新发送整个区块的完整原始数据。
-  # 设置为 -1 表示永远不会重新发送整个区块，而是持续更新相邻方块；
-  # 设置为 0 表示始终重新发送完整的原始区块。
-  # 设置为较大的值可以避免持续发送方块更新数据包，但尚未确定是否有益。
-  # 此外，原始区块不会包含假矿功能。建议保留为 -1 。
-  threshold-to-resent-whole-chunk:
-  # 当玩家开始挖掘一个方块时，我们会立即更新相邻的方块。
-  # 如果启用此选项，我们将通过粗略计算来检查该方块是否在玩家的合法交互范围内。
-  update-on-legal-interact-only:
-  # 每次更新方块时，更新多少距离内的相邻方块。
-  update-distance:
-  # 除非身处虚空，否则基岩层（世界最小高度）永远不可见。
-  # 默认我们会跳过这项检查，如果你不喜欢，可以启用。
-  minimal-height-invisible-check:
-  # 与 minimal-height 相似，适用于下界的基岩顶层. 为了开箱即用，默认为 true。
-  # 如果您不允许玩家上基岩层，强烈建议将此选项设为 FALSE。
-  nether-roof-invisible-check:
-  # 如果一个透明方块被非透明方块包围，则明显中心方块不可见。
-  # 此外，是否应该认为所有相邻的方块对于该方块面是不可见的？
-  # 除非玩家加入游戏时视线在这个中心方块内，否则永远不会看到相邻方块。
-  # 此步骤额外耗时约 0.02 毫秒，因此默认情况下不启用。
-  # 启用此选项有助于节省下界的带宽，因为下界中有很多单方块的熔岩。
-  detect-invisible-single-block:
-  # 检测熔岩池，将被覆盖的熔岩方块视为不可见。
-  # 此步骤额外耗时约 0.03 毫秒，因此默认情况下不启用。
-  # 这还会要求插件在玩家每次移动时检测附近的方块。
-  # 启用此功能有助于节省带宽，尤其是在下界。
-  detect-lava-pool:
-  # 此功能不支持与其他任何假矿插件同时运行。
-  # 您必须使用我们提供的假矿功能。
-  #
-  # 我们会将不可见的方块替换为此列表中的随机一个方块。
-  # 如果您不想启用假矿，可将列表设置为 'bedrock' 。
-  anti-xray-random-block-list:
-  # 若启用，在不增加子区块“调色板”位数时，可添加一个随机方块类型。
-  # 可大幅增强假矿效果，同时仅占用额外少量字节的带宽。
-  enhanced-anti-xray:
-  # 在此列表中添加的任何方块在处理时会被忽略。
-  # 可以添加任何不想被隐藏的方块。
-  # 例如，你可以添加任何矿石，这样就不会产生反矿透效果。
-  # *警告*：添加任何方块都可能严重降低带宽压缩率，请三思。
-  non-invisible-blocks-overrides:
+  chunk-handler:
+    # 如果重新发送的方块数量超过此值，将直接重新发送整个区块的完整原始数据。
+    # 设置为 -1 表示永远不会重新发送整个区块，而是持续更新相邻方块；
+    # 设置为 0 表示始终重新发送完整的原始区块。
+    # 设置为较大的值可以避免持续发送方块更新数据包，但尚未确定是否有益。
+    # 此外，原始区块不会包含假矿功能。建议保留为 -1 。
+    threshold-to-resent-whole-chunk:
+    # 当玩家开始挖掘一个方块时，我们会立即更新相邻的方块。
+    # 如果启用此选项，我们将通过粗略计算来检查该方块是否在玩家的合法交互范围内。
+    update-on-legal-interact-only:
+    # 每次更新方块时，更新多少距离内的相邻方块。
+    update-distance:
+    # 除非身处虚空，否则基岩层（世界最小高度）永远不可见。
+    # 默认我们会跳过这项检查，如果你不喜欢，可以启用。
+    minimal-height-invisible-check:
+    # 与 minimal-height 相似，适用于下界的基岩顶层. 为了开箱即用，默认为 true。
+    # 如果您不允许玩家上基岩层，强烈建议将此选项设为 FALSE。
+    nether-roof-invisible-check:
+    # 如果一个透明方块被非透明方块包围，则明显中心方块不可见。
+    # 此外，是否应该认为所有相邻的方块对于该方块面是不可见的？
+    # 除非玩家加入游戏时视线在这个中心方块内，否则永远不会看到相邻方块。
+    # 此步骤额外耗时约 0.02 毫秒，因此默认情况下不启用。
+    # 启用此选项有助于节省下界的带宽，因为下界中有很多单方块的熔岩。
+    detect-invisible-single-block:
+    # 检测熔岩池，将被覆盖的熔岩方块视为不可见。
+    # 此步骤额外耗时约 0.03 毫秒，因此默认情况下不启用。
+    # 这还会要求插件在玩家每次移动时检测附近的方块。
+    # 启用此功能有助于节省带宽，尤其是在下界。
+    detect-lava-pool:
+    # 此功能不支持与其他任何假矿插件同时运行。
+    # 您必须使用我们提供的假矿功能。
+    #
+    # 我们会将不可见的方块替换为此列表中的随机一个方块。
+    # 如果您不想启用假矿，可将列表设置为 'bedrock' 。
+    anti-xray-random-block-list:
+    # 若启用，在不增加子区块“调色板”位数时，可添加一个随机方块类型。
+    # 可大幅增强假矿效果，同时仅占用额外少量字节的带宽。
+    enhanced-anti-xray:
+    # 在此列表中添加的任何方块在处理时会被忽略。
+    # 可以添加任何不想被隐藏的方块。
+    # 例如，你可以添加任何矿石，这样就不会产生反矿透效果。
+    # *警告*：添加任何方块都可能严重降低带宽压缩率，请三思。
+    non-invisible-blocks-overrides:
 
 # 启用动态区块发送速率。需要在 ESU 的 velocity 插件端也开启此功能。
 dynamic-chunk-send-rate:

bukkit/version/base/src/main/kotlin/io/github/rothes/esu/bukkit/util/version/adapter/nms/BlockOccludeTester.kt

@@ -0,0 +1,9 @@
+package io.github.rothes.esu.bukkit.util.version.adapter.nms
+
+import net.minecraft.world.level.block.state.BlockState
+
+interface BlockOccludeTester {
+
+    fun isFullOcclude(blockState: BlockState): Boolean
+
+}

bukkit/version/v1_17_1/src/main/kotlin/io/github/rothes/esu/bukkit/util/version/adapter/nms/v1_17_1/BlockOccludeTesterImpl.kt

@@ -0,0 +1,21 @@
+package io.github.rothes.esu.bukkit.util.version.adapter.nms.v1_17_1
+
+import io.github.rothes.esu.bukkit.util.version.adapter.nms.BlockOccludeTester
+import io.github.rothes.esu.core.util.UnsafeUtils.usBooleanAccessor
+import io.github.rothes.esu.core.util.UnsafeUtils.usNullableObjAccessor
+import net.minecraft.world.level.block.state.BlockBehaviour
+import net.minecraft.world.level.block.state.BlockState
+
+object BlockOccludeTesterImpl: BlockOccludeTester {
+
+    private val canOcclude = BlockBehaviour.BlockStateBase::class.java.getDeclaredField("canOcclude").usBooleanAccessor
+    private val bsCache = BlockBehaviour.BlockStateBase::class.java.getDeclaredField("cache").usNullableObjAccessor
+
+    override fun isFullOcclude(blockState: BlockState): Boolean {
+        @Suppress("NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS") // No worries
+        return canOcclude[blockState]
+                && bsCache[blockState] != null
+                && blockState.isCollisionShapeFullBlock(null, null)
+    }
+
+}