Merge branch '1.21' into 1.21-forge

# Conflicts:
#	gradle.properties

Author: lucaargolo

gradle.properties

@@ -12,7 +12,7 @@ github_api_version=1.314
 
 # Mod Properties
 mod_loader=neoforge
-mod_version=2.3+1.21
+mod_version=2.3.1+1.21
 maven_group=io.github.lucaargolo
 
 # Fabric Properties

src/main/java/io/github/lucaargolo/kibe/mixin/EntityMixin.java

@@ -30,12 +30,13 @@ public abstract class EntityMixin {
     @Inject(at = @At("HEAD"), method = "setSneaking")
     private void setSneaking(boolean sneaking, CallbackInfo info) {
         if(sneaking && !isSpectator()) {
-            BlockPos pos = getBlockPos();
+            BlockPos pos = this.getBlockPos();
             Block block = world.getBlockState(pos.down()).getBlock();
             if (block instanceof Elevator && world.getBlockState(pos).getCollisionShape(world, pos).isEmpty()) {
                 pos = pos.down();
                 while(pos.getY() > world.getBottomY()) {
                     if(world.getBlockState(pos.down()).getBlock().equals(block) && Elevator.Companion.isElevatorValid(world, pos.down())) {
+                        world.playSound(null, this.getBlockPos(), SoundEvents.BLOCK_PISTON_CONTRACT, SoundCategory.BLOCKS, 0.5F, world.random.nextFloat() * 0.15F + 0.6F);
                         requestTeleport(this.pos.x, pos.down().getY()+1.15, this.pos.z);
                         world.playSound(null, pos, SoundEvents.BLOCK_PISTON_CONTRACT, SoundCategory.BLOCKS, 0.5F, world.random.nextFloat() * 0.15F + 0.6F);
                         break;

src/main/java/io/github/lucaargolo/kibe/mixin/LivingEntityMixin.java

@@ -98,6 +98,7 @@ private void jump(CallbackInfo info) {
         if (block instanceof Elevator && getWorld().getBlockState(pos).getCollisionShape(getWorld(), pos).isEmpty()) {
             while(pos.getY() < getWorld().getTopY()) {
                 if(getWorld().getBlockState(pos.up()).getBlock().equals(block) && Elevator.Companion.isElevatorValid(getWorld(), pos.up())) {
+                    getWorld().playSound(null, this.getBlockPos(), SoundEvents.BLOCK_PISTON_EXTEND, SoundCategory.BLOCKS, 0.5F, getWorld().random.nextFloat() * 0.25F + 0.6F);
                     this.teleport(this.getPos().x, pos.up().getY()+1.15, this.getPos().z, false);
                     getWorld().playSound(null, pos, SoundEvents.BLOCK_PISTON_EXTEND, SoundCategory.BLOCKS, 0.5F, getWorld().random.nextFloat() * 0.25F + 0.6F);
                     break;

src/main/kotlin/io/github/lucaargolo/kibe/block/Drawbridge.kt

@@ -1,41 +1,44 @@
 package io.github.lucaargolo.kibe.block
 
 import com.mojang.serialization.MapCodec
-import io.github.lucaargolo.kibe.blockentity.BlockEntityCompendium
 import io.github.lucaargolo.kibe.blockentity.DrawbridgeBlockEntity
 import io.github.lucaargolo.kibe.menu.DrawbridgeScreenHandler
 import io.github.lucaargolo.kibe.utils.menu.BlockScreenHandlerFactory
+import net.fabricmc.fabric.api.entity.FakePlayer
 import net.minecraft.block.*
-import net.minecraft.block.entity.BlockEntity
-import net.minecraft.block.entity.BlockEntityTicker
-import net.minecraft.block.entity.BlockEntityType
+import net.minecraft.enchantment.Enchantments
 import net.minecraft.entity.player.PlayerEntity
 import net.minecraft.inventory.Inventory
-import net.minecraft.item.ItemPlacementContext
-import net.minecraft.item.ItemStack
+import net.minecraft.item.*
+import net.minecraft.registry.RegistryKeys
+import net.minecraft.registry.tag.BlockTags
+import net.minecraft.screen.ScreenHandler
+import net.minecraft.server.world.ServerWorld
+import net.minecraft.sound.SoundCategory
+import net.minecraft.sound.SoundEvents
 import net.minecraft.state.StateManager
 import net.minecraft.state.property.Properties
-import net.minecraft.util.ActionResult
-import net.minecraft.util.BlockMirror
-import net.minecraft.util.BlockRotation
-import net.minecraft.util.ItemScatterer
+import net.minecraft.util.*
 import net.minecraft.util.hit.BlockHitResult
 import net.minecraft.util.math.BlockPos
-import net.minecraft.util.math.MathHelper
+import net.minecraft.util.math.Direction
+import net.minecraft.util.math.Vec3d
+import net.minecraft.util.math.random.Random
 import net.minecraft.world.World
 
 class Drawbridge(settings: Settings): BlockWithEntity(settings) {
 
-    override fun createBlockEntity(blockPos: BlockPos, blockState: BlockState): BlockEntity {
-        return DrawbridgeBlockEntity(blockPos, blockState)
-    }
-
-    override fun <T : BlockEntity?> getTicker(world: World?, state: BlockState?, blockEntityType: BlockEntityType<T>?): BlockEntityTicker<T>? {
-        return validateTicker(blockEntityType, BlockEntityCompendium.DRAWBRIDGE, DrawbridgeBlockEntity::tick)
+    init {
+        defaultState = stateManager.defaultState.with(Properties.FACING, Direction.NORTH).with(Properties.TRIGGERED, false)
     }
 
     override fun appendProperties(stateManager: StateManager.Builder<Block?, BlockState?>) {
         stateManager.add(Properties.FACING)
+        stateManager.add(Properties.TRIGGERED)
+    }
+
+    override fun getPlacementState(ctx: ItemPlacementContext): BlockState? {
+        return defaultState.with(Properties.FACING, ctx.playerLookDirection.opposite)
     }
 
     override fun rotate(state: BlockState, rotation: BlockRotation): BlockState {
@@ -46,21 +49,58 @@ class Drawbridge(settings: Settings): BlockWithEntity(settings) {
         return state.rotate(mirror.getRotation(state[DispenserBlock.FACING]))
     }
 
-    override fun hasComparatorOutput(state: BlockState?) = true
+    override fun neighborUpdate(state: BlockState, world: World, pos: BlockPos, block: Block?, fromPos: BlockPos?, notify: Boolean) {
+        val isReceivingPower = world.isReceivingRedstonePower(pos) || world.isReceivingRedstonePower(pos.up())
+        val triggered = state[DispenserBlock.TRIGGERED]
+        if (isReceivingPower && !triggered) {
+            world.scheduleBlockTick(pos, this, 8)
+            world.setBlockState(pos, state.with(DispenserBlock.TRIGGERED, true), 4)
+        } else if (!isReceivingPower && triggered) {
+            world.scheduleBlockTick(pos, this, 8)
+            world.setBlockState(pos, state.with(DispenserBlock.TRIGGERED, false), 4)
+        }
+    }
 
-    override fun getComparatorOutput(state: BlockState, world: World, pos: BlockPos): Int {
-        var output = 0
-        (world.getBlockEntity(pos) as? DrawbridgeBlockEntity)?.let { entity ->
-            var i = 0
-            var f = 0.0f
-            val itemStack: ItemStack = entity.getStack(0)
-            if (!itemStack.isEmpty) {
-                f += itemStack.count.toFloat() / entity.maxCountPerStack.coerceAtMost(itemStack.maxCount).toFloat()
-                ++i
+    override fun scheduledTick(state: BlockState, world: ServerWorld, pos: BlockPos, random: Random) {
+        val facing = state[Properties.FACING]
+        val triggered = state[DispenserBlock.TRIGGERED]
+        (world.getBlockEntity(pos) as? DrawbridgeBlockEntity)?.let {
+            if(triggered) {
+                val stack = it.getStack(0)
+                val front = world.getBlockState(pos.offset(facing))
+                if(front.isAir || isSameBlock(stack, world, pos.offset(facing), front)) {
+                    val distance = sameBlockDistance(stack, world, pos, facing)
+                    if (!stack.isEmpty && distance < stack.maxCount) {
+                        placeBlock(stack, world, pos.offset(facing, distance + 1), facing)
+                        world.playSound(null, pos, SoundEvents.BLOCK_PISTON_EXTEND, SoundCategory.BLOCKS, 1f, world.random.nextFloat() * 0.25f + 0.6f)
+                        world.scheduleBlockTick(pos, this, 8)
+                    }
+                }
+            }else{
+                val stack = it.getStack(0).let { stack ->
+                    if(stack.isEmpty) {
+                        val blockStack = stackFromBlock(world, pos.offset(facing))
+                        return@let blockStack
+                    } else {
+                        return@let stack
+                    }
+                }
+                val distance = sameBlockDistance(stack, world, pos, facing)
+                if(distance > 0 && !stack.isEmpty && stack.count < stack.maxCount) {
+                    breakBlock(stack, world, pos.offset(facing, distance), it)
+                    world.playSound(null, pos, SoundEvents.BLOCK_PISTON_CONTRACT, SoundCategory.BLOCKS, 1f, world.random.nextFloat() * 0.25f + 0.6f)
+                    world.scheduleBlockTick(pos, this, 8)
+                }
             }
-            output = MathHelper.floor(f * 14.0f) + if (i > 0) 1 else 0
         }
-        return output
+    }
+
+    override fun createBlockEntity(pos: BlockPos, state: BlockState) = DrawbridgeBlockEntity(pos, state)
+
+    override fun hasComparatorOutput(state: BlockState?) = true
+
+    override fun getComparatorOutput(state: BlockState, world: World, pos: BlockPos): Int {
+        return ScreenHandler.calculateComparatorOutput(world.getBlockEntity(pos))
     }
 
     override fun onStateReplaced(state: BlockState, world: World, pos: BlockPos?, newState: BlockState, notify: Boolean) {
@@ -73,21 +113,82 @@ class Drawbridge(settings: Settings): BlockWithEntity(settings) {
         }
     }
 
-    override fun getPlacementState(ctx: ItemPlacementContext): BlockState? {
-        return defaultState.with(Properties.FACING, ctx.playerLookDirection.opposite)
-    }
-
     override fun onUse(state: BlockState?, world: World, pos: BlockPos, player: PlayerEntity, hit: BlockHitResult?): ActionResult {
         player.openHandledScreen(BlockScreenHandlerFactory(this, pos, ::DrawbridgeScreenHandler))
         return ActionResult.SUCCESS
     }
 
     override fun getRenderType(state: BlockState?) = BlockRenderType.MODEL
 
-    override fun getCodec(): MapCodec<Drawbridge> = CODEC
+    override fun getCodec(): MapCodec<Placer> = CODEC
 
     companion object {
-        private val CODEC: MapCodec<Drawbridge> = createCodec(::Drawbridge)
+        private val CODEC: MapCodec<Placer> = createCodec(::Placer)
+
+        private fun placeBlock(stack: ItemStack, world: ServerWorld, pos: BlockPos, facing: Direction) {
+            val fakePlayer = FakePlayer.get(world)
+            fakePlayer.setStackInHand(Hand.MAIN_HAND, stack)
+            val fakeHitPos = Vec3d(pos.x + 0.5, pos.y + 0.0, pos.z + 0.5)
+            (stack.item as? BlockItem)?.useOnBlock(ItemUsageContext(fakePlayer, Hand.MAIN_HAND, BlockHitResult(fakeHitPos, facing.opposite, pos, false)))
+        }
+
+        private fun breakBlock(stack: ItemStack, world: World, pos: BlockPos, blockEntity: DrawbridgeBlockEntity) {
+            world.breakBlock(pos, false)
+            if(stack == blockEntity.getStack(0)) {
+                stack.increment(1)
+            }else{
+                blockEntity.setStack(0, stack.copy())
+            }
+        }
+
+        private fun sameBlockDistance(stack: ItemStack, world: ServerWorld, pos: BlockPos, facing: Direction): Int {
+            var distance = 0
+            while(distance < stack.maxCount && isSameBlock(stack, world, pos.offset(facing, distance+1))) {
+                distance++
+            }
+            return distance
+        }
+
+        private fun isSameBlock(stack: ItemStack, world: ServerWorld, pos: BlockPos): Boolean {
+            return ItemStack.areItemsAndComponentsEqual(stack, stackFromBlock(world, pos))
+        }
+
+        private fun isSameBlock(stack: ItemStack, world: ServerWorld, pos: BlockPos, state: BlockState): Boolean {
+            return ItemStack.areItemsAndComponentsEqual(stack, stackFromBlock(world, pos, state))
+        }
+
+        private fun stackFromBlock(world: ServerWorld, pos: BlockPos): ItemStack {
+            val state = world.getBlockState(pos)
+            return stackFromBlock(world, pos, state)
+        }
+
+        private fun stackFromBlock(world: ServerWorld, pos: BlockPos, state: BlockState): ItemStack {
+            val entity = world.getBlockEntity(pos)
+            val list = getDroppedStacks(state, world, pos, entity, null, silkTouchStack(world, state))
+            if(list.size == 1) {
+                val stack = list.first()
+                if(stack.count == 1 && stack.item is BlockItem) {
+                    return stack
+                }
+            }
+            return ItemStack.EMPTY
+        }
+
+        private fun silkTouchStack(world: World, state: BlockState): ItemStack {
+            val item = Items.STICK
+            state.streamTags().forEach {
+                when(it) {
+                    BlockTags.SHOVEL_MINEABLE -> Items.NETHERITE_SHOVEL
+                    BlockTags.AXE_MINEABLE -> Items.NETHERITE_AXE
+                    BlockTags.PICKAXE_MINEABLE -> Items.NETHERITE_PICKAXE
+                    BlockTags.HOE_MINEABLE -> Items.NETHERITE_HOE
+                }
+            }
+            return item.defaultStack.also {
+                it.addEnchantment(world.registryManager.get(RegistryKeys.ENCHANTMENT).getEntry(Enchantments.SILK_TOUCH).get(), 1)
+            }
+        }
+
     }
 
 }