- more placement customisation settings

- account for max pending breaks in break manager
- split pending interactions to breaks and placements

Author: beanbag44

common/src/main/kotlin/com/lambda/config/groups/BreakSettings.kt

@@ -32,13 +32,14 @@ class BreakSettings(
     override val doubleBreak by c.setting("Double Break", false, "Allows breaking two blocks at once") { vis() }
     override val breakDelay by c.setting("Break Delay", 5, 0..5, 1, "The delay between breaking blocks", " ticks") { vis() }
     override val swing by c.setting("Swing Mode", SwingMode.Constant, "The times at which to swing the players hand") { vis() }
-    override val swingType by c.setting("Swing Type", SwingType.Vanilla, "The style of swing") { vis() }
-    override val sounds by c.setting("Sounds", true, "Plays the breaking sounds") { vis() }
+    override val swingType by c.setting("Break Swing Type", BuildConfig.SwingType.Vanilla, "The style of swing") { vis() }
+    override val sounds by c.setting("Break Sounds", true, "Plays the breaking sounds") { vis() }
     override val particles by c.setting("Particles", true, "Renders the breaking particles") { vis() }
     override val breakingTexture by c.setting("Breaking Overlay", true, "Overlays the breaking texture at its different stages") { vis() }
     override val rotateForBreak by c.setting("Rotate For Break", true, "Rotate towards block while breaking") { vis() }
     override val ignoredBlocks by c.setting("Ignored Blocks", allSigns, "Blocks that wont be broken") { vis() }
     override val breakConfirmation by c.setting("Break Confirmation", BreakConfirmationMode.BreakThenAwait, "The style of confirmation used when breaking") { vis() }
+    override val maxPendingBreaks by c.setting("Max Pending Breaks", 2, 0..5, 1, "The maximum amount of pending breaks") { vis() }
     override val breaksPerTick by c.setting("Instant Breaks Per Tick", 5, 1..30, 1, "Maximum instant block breaks per tick") { vis() }
     override val breakWeakBlocks by c.setting("Break Weak Blocks", false, "Break blocks that dont have structural integrity (e.g: grass)") { vis() }
     override val forceSilkTouch by c.setting("Force Silk Touch", false, "Force silk touch when breaking blocks") { vis() }

common/src/main/kotlin/com/lambda/config/groups/BuildConfig.kt

@@ -30,4 +30,10 @@ interface BuildConfig {
 
     // Placing
     val placeSettings: PlaceSettings
+
+    enum class SwingType {
+        Vanilla,
+        Server,
+        Client
+    }
 }

common/src/main/kotlin/com/lambda/config/groups/PlaceSettings.kt

@@ -28,5 +28,9 @@ class PlaceSettings(
 ) : PlaceConfig(priority) {
     override val rotateForPlace by c.setting("Rotate For Place", true, "Rotate towards block while placing") { vis() }
     override val placeConfirmation by c.setting("Place Confirmation", PlaceConfirmation.PlaceThenAwait, "Wait for block placement confirmation") { vis() }
+    override val maxPendingPlacements by c.setting("Max Pending Placements", 2, 0..5, 1, "The maximum amount of pending placements") { vis() }
     override val placementsPerTick by c.setting("Instant Places Per Tick", 1, 1..30, 1, "Maximum instant block places per tick") { vis() }
+    override val swing by c.setting("Swing", true, "Swings the players hand when placing") { vis() }
+    override val swingType by c.setting("Place Swing Type", BuildConfig.SwingType.Vanilla, "The style of swing") { vis() }
+    override val sounds by c.setting("Place Sounds", true, "Plays the placing sounds") { vis() }
 }

common/src/main/kotlin/com/lambda/interaction/request/breaking/BreakConfig.kt

@@ -17,6 +17,7 @@
 
 package com.lambda.interaction.request.breaking
 
+import com.lambda.config.groups.BuildConfig
 import com.lambda.interaction.request.Priority
 import com.lambda.interaction.request.RequestConfig
 import net.minecraft.block.Block
@@ -29,12 +30,13 @@ abstract class BreakConfig(
     abstract val doubleBreak: Boolean
     abstract val breakDelay: Int
     abstract val swing: SwingMode
-    abstract val swingType: SwingType
+    abstract val swingType: BuildConfig.SwingType
     abstract val sounds: Boolean
     abstract val particles: Boolean
     abstract val breakingTexture: Boolean
     abstract val rotateForBreak: Boolean
     abstract val breakConfirmation: BreakConfirmationMode
+    abstract val maxPendingBreaks: Int
     abstract val breaksPerTick: Int
     abstract val breakWeakBlocks: Boolean
     abstract val forceSilkTouch: Boolean
@@ -58,12 +60,6 @@ abstract class BreakConfig(
         End
     }
 
-    enum class SwingType {
-        Vanilla,
-        Server,
-        Client
-    }
-
     enum class BreakConfirmationMode {
         None,
         BreakThenAwait,

common/src/main/kotlin/com/lambda/interaction/request/breaking/BreakManager.kt

@@ -41,7 +41,7 @@ import com.lambda.util.Communication.info
 import com.lambda.util.Communication.warn
 import com.lambda.util.collections.LimitedDecayQueue
 import com.lambda.util.item.ItemUtils.block
-import com.lambda.util.player.swingHandClient
+import com.lambda.util.player.swingHand
 import net.minecraft.block.BlockState
 import net.minecraft.block.OperatorBlock
 import net.minecraft.client.sound.PositionedSoundInstance
@@ -50,7 +50,6 @@ import net.minecraft.client.world.ClientWorld
 import net.minecraft.entity.ItemEntity
 import net.minecraft.entity.player.PlayerEntity
 import net.minecraft.item.ItemStack
-import net.minecraft.network.packet.c2s.play.HandSwingC2SPacket
 import net.minecraft.network.packet.c2s.play.PlayerActionC2SPacket
 import net.minecraft.sound.SoundCategory
 import net.minecraft.util.math.BlockPos
@@ -87,8 +86,11 @@ object BreakManager : RequestHandler<BreakRequest>() {
             if (updateRequest { true }) {
                 currentRequest?.let request@ { request ->
                     var instaBreaks = 0
+                    val config = breakingInfos.firstOrNull()?.breakConfig ?: request.buildConfig.breakSettings
+                    val takeCount = config.maxPendingBreaks - (breakingInfos.count { it != null } + pendingInteractions.size)
                     request.contexts
                         .sortedBy { it.instantBreak }
+                        .take(takeCount)
                         .forEach { requestCtx ->
                             if (!canAccept(requestCtx)) return@forEach
                             val breakType = with(request) {
@@ -242,7 +244,7 @@ object BreakManager : RequestHandler<BreakRequest>() {
                 info.nullify()
                 return false
             }
-            if (info.breakConfig.swing != BreakConfig.SwingMode.End) swingHand(info)
+            if (info.breakConfig.swing != BreakConfig.SwingMode.End) swingHand(info.breakConfig.swingType)
             return true
         }
 
@@ -293,10 +295,10 @@ object BreakManager : RequestHandler<BreakRequest>() {
                 onBlockBreak(info)
                 PlayerActionC2SPacket(PlayerActionC2SPacket.Action.STOP_DESTROY_BLOCK, ctx.expectedPos, hitResult.side, sequence)
             }
-            if (info.breakConfig.swing != BreakConfig.SwingMode.Start) swingHand(info)
+            if (info.breakConfig.swing != BreakConfig.SwingMode.Start) swingHand(info.breakConfig.swingType)
             setBreakCooldown(info.breakConfig.breakDelay)
         } else {
-            if (info.breakConfig.swing == BreakConfig.SwingMode.Constant) swingHand(info)
+            if (info.breakConfig.swing == BreakConfig.SwingMode.Constant) swingHand(info.breakConfig.swingType)
         }
 
         return true
@@ -409,14 +411,6 @@ object BreakManager : RequestHandler<BreakRequest>() {
         )
     }
 
-    private fun SafeContext.swingHand(info: BreakInfo) {
-        when (info.breakConfig.swingType) {
-            BreakConfig.SwingType.Vanilla -> player.swingHand(player.activeHand)
-            BreakConfig.SwingType.Server -> connection.sendPacket(HandSwingC2SPacket(player.activeHand))
-            BreakConfig.SwingType.Client -> swingHandClient(player.activeHand)
-        }
-    }
-
     private fun isOnBreakCooldown() = blockBreakingCooldown > 0
     private fun setBreakCooldown(cooldown: Int) {
         blockBreakingCooldown = cooldown

common/src/main/kotlin/com/lambda/interaction/request/placing/PlaceConfig.kt

@@ -17,6 +17,7 @@
 
 package com.lambda.interaction.request.placing
 
+import com.lambda.config.groups.BuildConfig
 import com.lambda.interaction.request.Priority
 import com.lambda.interaction.request.RequestConfig
 
@@ -25,7 +26,11 @@ abstract class PlaceConfig(
 ) : RequestConfig<PlaceRequest>(priority) {
     abstract val rotateForPlace: Boolean
     abstract val placeConfirmation: PlaceConfirmation
+    abstract val maxPendingPlacements: Int
     abstract val placementsPerTick: Int
+    abstract val swing: Boolean
+    abstract val swingType: BuildConfig.SwingType
+    abstract val sounds: Boolean
 
     override fun requestInternal(request: PlaceRequest) {
         PlaceManager.registerRequest(this, request)

common/src/main/kotlin/com/lambda/interaction/request/placing/PlaceManager.kt

@@ -31,13 +31,30 @@ import com.lambda.module.modules.client.TaskFlowModule
 import com.lambda.util.Communication.info
 import com.lambda.util.Communication.warn
 import com.lambda.util.collections.LimitedDecayQueue
+import com.lambda.util.player.swingHand
+import net.minecraft.block.BlockState
+import net.minecraft.block.pattern.CachedBlockPosition
+import net.minecraft.item.BlockItem
+import net.minecraft.item.ItemPlacementContext
+import net.minecraft.item.ItemStack
+import net.minecraft.item.ItemUsageContext
+import net.minecraft.network.packet.c2s.play.PlayerInteractBlockC2SPacket
+import net.minecraft.registry.RegistryKeys
+import net.minecraft.sound.SoundCategory
+import net.minecraft.stat.Stats
+import net.minecraft.util.ActionResult
 import net.minecraft.util.Hand
+import net.minecraft.util.hit.BlockHitResult
+import net.minecraft.world.GameMode
+import net.minecraft.world.event.GameEvent
+import org.apache.commons.lang3.mutable.MutableObject
 
 object PlaceManager : RequestHandler<PlaceRequest>() {
     private val pendingInteractions = LimitedDecayQueue<PlaceContext>(
         TaskFlowModule.build.maxPendingInteractions, TaskFlowModule.build.interactionTimeout * 50L
     ) { info("${it::class.simpleName} at ${it.expectedPos.toShortString()} timed out") }
 
+    //ToDo: Add server response check for pending interactions
     init {
         listen<TickEvent.Pre>(Int.MIN_VALUE) {
             preEvent()
@@ -47,7 +64,11 @@ object PlaceManager : RequestHandler<PlaceRequest>() {
                 return@listen
             }
 
-            currentRequest?.let { request ->
+            currentRequest?.let request@ { request ->
+                if (pendingInteractions.size >= request.buildConfig.placeSettings.maxPendingPlacements) {
+                    return@request
+                }
+
                 if (request.placeContext.sneak && !player.isSneaking
                     || (request.buildConfig.placeSettings.rotateForPlace && !request.placeContext.rotation.done)
                     || (!request.hotbarConfig.request(HotbarRequest(request.placeContext.hotbarIndex)).done)
@@ -76,24 +97,136 @@ object PlaceManager : RequestHandler<PlaceRequest>() {
     }
 
     private fun SafeContext.placeBlock(request: PlaceRequest, hand: Hand) {
-        val actionResult = interaction.interactBlock(
-            player, hand, request.placeContext.result
-        )
+        val stackInHand = player.getStackInHand(hand)
+        val stackCountPre = stackInHand.count
+        val actionResult = interactBlock(request.buildConfig.placeSettings, hand, request.placeContext.result)
 
         if (actionResult.isAccepted) {
-            if (actionResult.shouldSwingHand() && request.interactionConfig.swingHand) {
-                player.swingHand(hand)
-            }
+            if (request.buildConfig.placeSettings.placeConfirmation != PlaceConfig.PlaceConfirmation.None)
+                pendingInteractions.add(request.placeContext)
 
-            if (!player.getStackInHand(hand).isEmpty && interaction.hasCreativeInventory()) {
+            if (actionResult.shouldSwingHand() && request.buildConfig.placeSettings.swing)
+                swingHand(request.buildConfig.placeSettings.swingType)
+
+            if (!stackInHand.isEmpty && (stackInHand.count != stackCountPre || interaction.hasCreativeInventory()))
                 mc.gameRenderer.firstPersonRenderer.resetEquipProgress(hand)
-            }
         } else {
-            warn("Internal interaction failed with $actionResult")
+            warn("Placement interaction failed with $actionResult")
         }
         request.onPlace()
     }
 
+    private fun SafeContext.interactBlock(placeConfig: PlaceConfig, hand: Hand, hitResult: BlockHitResult): ActionResult {
+        interaction.syncSelectedSlot()
+        if (!world.worldBorder.contains(hitResult.blockPos)) {
+            return ActionResult.FAIL
+        } else {
+            val mutableObject = MutableObject<ActionResult>()
+            interaction.sendSequencedPacket(world) { sequence: Int ->
+                mutableObject.value = interactBlockInternal(placeConfig, hand, hitResult)
+                PlayerInteractBlockC2SPacket(hand, hitResult, sequence)
+            }
+            return mutableObject.value
+        }
+    }
+
+    private fun SafeContext.interactBlockInternal(
+        placeConfig: PlaceConfig,
+        hand: Hand,
+        hitResult: BlockHitResult
+    ): ActionResult {
+        val itemStack = player.getStackInHand(hand)
+        if (interaction.currentGameMode == GameMode.SPECTATOR) return ActionResult.SUCCESS
+
+        val handNotEmpty = !player.getStackInHand(hand).isEmpty
+        val cantInteract = player.shouldCancelInteraction() && handNotEmpty
+        if (!cantInteract) return ActionResult.PASS
+
+        if (!itemStack.isEmpty && !player.itemCooldownManager.isCoolingDown(itemStack.item)) {
+            val itemUsageContext = ItemUsageContext(player, hand, hitResult)
+            val itemUseResult: ActionResult
+            if (interaction.currentGameMode.isCreative) {
+                val i = itemStack.count
+                itemUseResult = useOnBlock(placeConfig, itemStack, itemUsageContext)
+                itemStack.count = i
+            } else
+                itemUseResult = useOnBlock(placeConfig, itemStack, itemUsageContext)
+
+            return itemUseResult
+        }
+        return ActionResult.PASS
+    }
+
+    private fun SafeContext.useOnBlock(
+        placeConfig: PlaceConfig,
+        itemStack: ItemStack,
+        context: ItemUsageContext
+    ): ActionResult {
+        val blockPos = context.blockPos
+        val cachedBlockPosition = CachedBlockPosition(context.world, blockPos, false)
+        if (!player.abilities.allowModifyWorld
+            && !itemStack.canPlaceOn(context.world.registryManager.get(RegistryKeys.BLOCK), cachedBlockPosition)
+            ) {
+            return ActionResult.PASS
+        }
+        val item: BlockItem = (itemStack.item as? BlockItem) ?: return ActionResult.PASS
+        val actionResult = useOnBlock(placeConfig, item, context)
+        if (actionResult.shouldIncrementStat()) player.incrementStat(Stats.USED.getOrCreateStat(item))
+
+        return actionResult
+    }
+
+    private fun SafeContext.useOnBlock(
+        placeConfig: PlaceConfig,
+        item: BlockItem,
+        context: ItemUsageContext
+    ) = place(placeConfig, item, ItemPlacementContext(context))
+
+    private fun SafeContext.place(
+        placeConfig: PlaceConfig,
+        item: BlockItem,
+        context: ItemPlacementContext
+    ): ActionResult {
+        if (!item.block.isEnabled(world.enabledFeatures)) return ActionResult.FAIL
+        if (!context.canPlace()) return ActionResult.FAIL
+
+        val itemPlacementContext: ItemPlacementContext = item.getPlacementContext(context) ?: return ActionResult.FAIL
+        val blockState: BlockState = item.getPlacementState(itemPlacementContext) ?: return ActionResult.FAIL
+
+        if (placeConfig.placeConfirmation == PlaceConfig.PlaceConfirmation.AwaitThenPlace)
+            return ActionResult.success(world.isClient)
+
+        //ToDo: Add restriction checks, like world height, to avoid needlessly awaiting a server response which will never return
+        // if the user has the AwaitThenPlace confirmation setting enabled, as none of the state-setting methods which check these rules
+        // are called
+        if (!item.place(itemPlacementContext, blockState)) return ActionResult.FAIL
+
+        val blockPos = itemPlacementContext.blockPos
+        val itemStack = itemPlacementContext.stack
+        var hitState = world.getBlockState(blockPos)
+        if (hitState.isOf(blockState.block)) {
+            hitState = item.placeFromNbt(blockPos, world, itemStack, hitState)
+            item.postPlacement(blockPos, world, player, itemStack, hitState)
+            hitState.block.onPlaced(world, blockPos, hitState, player, itemStack)
+        }
+
+        if (placeConfig.sounds) {
+            val blockSoundGroup = hitState.soundGroup
+            world.playSound(
+                player,
+                blockPos,
+                item.getPlaceSound(hitState),
+                SoundCategory.BLOCKS,
+                (blockSoundGroup.getVolume() + 1.0f) / 2.0f,
+                blockSoundGroup.getPitch() * 0.8f
+            )
+        }
+        world.emitGameEvent(GameEvent.BLOCK_PLACE, blockPos, GameEvent.Emitter.of(player, hitState))
+        if (!player.abilities.creativeMode) itemStack.decrement(1)
+
+        return ActionResult.success(world.isClient)
+    }
+
     override fun preEvent() = UpdateManagerEvent.Place.Pre().post()
     override fun postEvent() = UpdateManagerEvent.Place.Post().post()
 }

common/src/main/kotlin/com/lambda/util/player/PlayerUtils.kt

@@ -1,11 +1,13 @@
 package com.lambda.util.player
 
+import com.lambda.config.groups.BuildConfig
 import com.lambda.context.SafeContext
 import com.mojang.authlib.GameProfile
 import net.minecraft.client.network.ClientPlayerEntity
 import net.minecraft.client.network.OtherClientPlayerEntity
 import net.minecraft.client.network.PlayerListEntry
 import net.minecraft.entity.player.PlayerEntity
+import net.minecraft.network.packet.c2s.play.HandSwingC2SPacket
 import net.minecraft.util.Hand
 
 fun SafeContext.copyPlayer(entity: ClientPlayerEntity) =
@@ -41,6 +43,13 @@ fun SafeContext.spawnFakePlayer(
     return entity
 }
 
+fun SafeContext.swingHand(swingType: BuildConfig.SwingType) =
+    when (swingType) {
+        BuildConfig.SwingType.Vanilla -> player.swingHand(player.activeHand)
+        BuildConfig.SwingType.Server -> connection.sendPacket(HandSwingC2SPacket(player.activeHand))
+        BuildConfig.SwingType.Client -> swingHandClient(player.activeHand)
+    }
+
 fun SafeContext.swingHandClient(hand: Hand) {
     if (!player.handSwinging || player.handSwingTicks >= player.handSwingDuration / 2 || player.handSwingTicks < 0) {
         player.handSwingTicks = -1

common/src/main/resources/lambda.accesswidener

@@ -16,6 +16,10 @@ accessible field net/minecraft/client/world/ClientChunkManager$ClientChunkMap ch
 accessible field net/minecraft/client/network/ClientPlayerInteractionManager currentBreakingProgress F
 accessible field net/minecraft/client/network/ClientPlayerInteractionManager blockBreakingCooldown I
 accessible field net/minecraft/client/network/ClientPlayerInteractionManager currentBreakingPos Lnet/minecraft/util/math/BlockPos;
+accessible method net/minecraft/item/BlockItem place (Lnet/minecraft/item/ItemPlacementContext;Lnet/minecraft/block/BlockState;)Z
+accessible method net/minecraft/item/BlockItem placeFromNbt (Lnet/minecraft/util/math/BlockPos;Lnet/minecraft/world/World;Lnet/minecraft/item/ItemStack;Lnet/minecraft/block/BlockState;)Lnet/minecraft/block/BlockState;
+accessible method net/minecraft/item/BlockItem postPlacement (Lnet/minecraft/util/math/BlockPos;Lnet/minecraft/world/World;Lnet/minecraft/entity/player/PlayerEntity;Lnet/minecraft/item/ItemStack;Lnet/minecraft/block/BlockState;)Z
+accessible method net/minecraft/item/BlockItem getPlaceSound (Lnet/minecraft/block/BlockState;)Lnet/minecraft/sound/SoundEvent;
 
 # Entity
 accessible field net/minecraft/entity/projectile/FireworkRocketEntity shooter Lnet/minecraft/entity/LivingEntity;