/net/minecraft/world/entity/monster

Some blocks

LayeredCauldronBlock.java.patch has strange diff-- the comment seems to be a red herring.

net/minecraft/network/protocol/login/

paper-server/patches/sources/net/minecraft/network/protocol/login/ClientboundLoginDisconnectPacket.java.patch

@@ -0,0 +1,30 @@
+--- a/net/minecraft/network/protocol/login/ClientboundLoginDisconnectPacket.java
++++ b/net/minecraft/network/protocol/login/ClientboundLoginDisconnectPacket.java
+@@ -14,8 +_,25 @@
+ 
+ public record ClientboundLoginDisconnectPacket(Component reason) implements Packet<ClientLoginPacketListener> {
+     private static final RegistryOps<JsonElement> OPS = RegistryAccess.EMPTY.createSerializationContext(JsonOps.INSTANCE);
+-    public static final StreamCodec<ByteBuf, ClientboundLoginDisconnectPacket> STREAM_CODEC = StreamCodec.composite(
+-        ByteBufCodecs.lenientJson(262144).apply(ByteBufCodecs.fromCodec(OPS, ComponentSerialization.CODEC)),
++    // Paper start  - localized codec
++    // In the login phase, buffer.adventure$locale field is most likely null, but plugins may use internals to set it via the channel attribute
++    public static final StreamCodec<net.minecraft.network.FriendlyByteBuf, ClientboundLoginDisconnectPacket> STREAM_CODEC = StreamCodec.composite(
++        new net.minecraft.network.codec.StreamCodec<>() {
++
++            private static final net.minecraft.network.codec.StreamCodec<io.netty.buffer.ByteBuf, com.google.gson.JsonElement> LENIENT_JSON = net.minecraft.network.codec.ByteBufCodecs.lenientJson(net.minecraft.network.FriendlyByteBuf.MAX_COMPONENT_STRING_LENGTH);
++            @Override
++            public net.minecraft.network.chat.Component decode(final net.minecraft.network.FriendlyByteBuf buffer) {
++                java.util.Locale bufLocale = buffer.adventure$locale;
++                return LENIENT_JSON.apply(ByteBufCodecs.fromCodec(OPS, net.minecraft.network.chat.ComponentSerialization.localizedCodec(bufLocale == null ? java.util.Locale.US : bufLocale))).decode(buffer);
++            }
++
++            @Override
++            public void encode(final net.minecraft.network.FriendlyByteBuf buffer, final net.minecraft.network.chat.Component value) {
++                java.util.Locale bufLocale = buffer.adventure$locale;
++                LENIENT_JSON.apply(ByteBufCodecs.fromCodec(OPS, net.minecraft.network.chat.ComponentSerialization.localizedCodec(bufLocale == null ? java.util.Locale.US : bufLocale))).encode(buffer, value);
++            }
++        },
++        // Paper end - localized codec
+         ClientboundLoginDisconnectPacket::reason,
+         ClientboundLoginDisconnectPacket::new
+     );

paper-server/patches/sources/net/minecraft/world/entity/monster/Phantom.java.patch

@@ -0,0 +1,55 @@
+--- a/net/minecraft/world/entity/monster/Phantom.java
++++ b/net/minecraft/world/entity/monster/Phantom.java
+@@ -49,6 +_,11 @@
+     @Nullable
+     public BlockPos anchorPoint;
+     Phantom.AttackPhase attackPhase = Phantom.AttackPhase.CIRCLE;
++    // Paper start
++    @Nullable
++    public java.util.UUID spawningEntity;
++    public boolean shouldBurnInDay = true;
++    // Paper end
+ 
+     public Phantom(EntityType<? extends Phantom> entityType, Level level) {
+         super(entityType, level);
+@@ -143,7 +_,7 @@
+ 
+     @Override
+     public void aiStep() {
+-        if (this.isAlive() && this.isSunBurnTick()) {
++        if (this.isAlive() && this.shouldBurnInDay && this.isSunBurnTick()) { // Paper - shouldBurnInDay API
+             this.igniteForSeconds(8.0F);
+         }
+ 
+@@ -178,6 +_,10 @@
+         super.readAdditionalSaveData(input);
+         this.anchorPoint = input.read("anchor_pos", BlockPos.CODEC).orElse(null);
+         this.setPhantomSize(input.getIntOr("size", 0));
++        // Paper start
++        this.spawningEntity = input.read("Paper.SpawningEntity", net.minecraft.core.UUIDUtil.CODEC).orElse(null);
++        this.shouldBurnInDay = input.getBooleanOr("Paper.ShouldBurnInDay", true);
++        // Paper end
+     }
+ 
+     @Override
+@@ -185,6 +_,10 @@
+         super.addAdditionalSaveData(output);
+         output.storeNullable("anchor_pos", BlockPos.CODEC, this.anchorPoint);
+         output.putInt("size", this.getPhantomSize());
++        // Paper start
++        output.storeNullable("Paper.SpawningEntity", net.minecraft.core.UUIDUtil.CODEC, this.spawningEntity);
++        output.putBoolean("Paper.ShouldBurnInDay", this.shouldBurnInDay);
++        // Paper end
+     }
+ 
+     @Override
+@@ -258,7 +_,8 @@
+ 
+                     for (Player player : nearbyPlayers) {
+                         if (Phantom.this.canAttack(serverLevel, player, TargetingConditions.DEFAULT)) {
+-                            Phantom.this.setTarget(player);
++                            if (!level().paperConfig().entities.behavior.phantomsOnlyAttackInsomniacs || EntitySelector.IS_INSOMNIAC.test(player)) // Paper - Add phantom creative and insomniac controls
++                            Phantom.this.setTarget(player, org.bukkit.event.entity.EntityTargetEvent.TargetReason.CLOSEST_PLAYER); // CraftBukkit - reason
+                             return true;
+                         }
+                     }

paper-server/patches/sources/net/minecraft/world/entity/monster/ZombieVillager.java.patch

@@ -0,0 +1,63 @@
+--- a/net/minecraft/world/entity/monster/ZombieVillager.java
++++ b/net/minecraft/world/entity/monster/ZombieVillager.java
+@@ -159,12 +_,20 @@
+     }
+ 
+     public void startConverting(@Nullable UUID conversionStarter, int villagerConversionTime) {
++        // Paper start - missing entity behaviour api - converting without entity event
++        this.startConverting(conversionStarter, villagerConversionTime, true);
++    }
++
++    public void startConverting(@Nullable UUID conversionStarter, int villagerConversionTime, boolean broadcastEntityEvent) {
++        // Paper end - missing entity behaviour api - converting without entity event
+         this.conversionStarter = conversionStarter;
+         this.villagerConversionTime = villagerConversionTime;
+         this.getEntityData().set(DATA_CONVERTING_ID, true);
+-        this.removeEffect(MobEffects.WEAKNESS);
+-        this.addEffect(new MobEffectInstance(MobEffects.STRENGTH, villagerConversionTime, Math.min(this.level().getDifficulty().getId() - 1, 0)));
+-        this.level().broadcastEntityEvent(this, (byte)16);
++        // CraftBukkit start
++        this.removeEffect(MobEffects.WEAKNESS, org.bukkit.event.entity.EntityPotionEffectEvent.Cause.CONVERSION);
++        this.addEffect(new MobEffectInstance(MobEffects.STRENGTH, villagerConversionTime, Math.min(this.level().getDifficulty().getId() - 1, 0)), org.bukkit.event.entity.EntityPotionEffectEvent.Cause.CONVERSION);
++        // CraftBukkit end
++        if (broadcastEntityEvent) this.level().broadcastEntityEvent(this, (byte)16); // Paper - missing entity behaviour api - converting without entity event
+     }
+ 
+     @Override
+@@ -189,7 +_,7 @@
+     }
+ 
+     private void finishConversion(ServerLevel level) {
+-        this.convertTo(
++        Villager converted = this.convertTo( // CraftBukkit
+             EntityType.VILLAGER,
+             ConversionParams.single(this, false, false),
+             mob -> {
+@@ -213,19 +_,24 @@
+                 mob.finalizeSpawn(level, level.getCurrentDifficultyAt(mob.blockPosition()), EntitySpawnReason.CONVERSION, null);
+                 mob.refreshBrain(level);
+                 if (this.conversionStarter != null) {
+-                    Player playerByUuid = level.getPlayerByUUID(this.conversionStarter);
++                    Player playerByUuid = level.getGlobalPlayerByUUID(this.conversionStarter); // Paper - check global player list where appropriate
+                     if (playerByUuid instanceof ServerPlayer) {
+                         CriteriaTriggers.CURED_ZOMBIE_VILLAGER.trigger((ServerPlayer)playerByUuid, this, mob);
+                         level.onReputationEvent(ReputationEventType.ZOMBIE_VILLAGER_CURED, playerByUuid, mob);
+                     }
+                 }
+ 
+-                mob.addEffect(new MobEffectInstance(MobEffects.NAUSEA, 200, 0));
++                mob.addEffect(new MobEffectInstance(MobEffects.NAUSEA, 200, 0), org.bukkit.event.entity.EntityPotionEffectEvent.Cause.CONVERSION); // CraftBukkit
+                 if (!this.isSilent()) {
+                     level.levelEvent(null, 1027, this.blockPosition(), 0);
+                 }
+-            }
++                // CraftBukkit start
++            }, org.bukkit.event.entity.EntityTransformEvent.TransformReason.CURED, org.bukkit.event.entity.CreatureSpawnEvent.SpawnReason.CURED // CraftBukkit
+         );
++        if (converted == null) {
++            ((org.bukkit.entity.ZombieVillager) this.getBukkitEntity()).setConversionTime(-1); // SPIGOT-5208: End conversion to stop event spam
++        }
++        // CraftBukkit end
+     }
+ 
+     @VisibleForTesting

paper-server/patches/sources/net/minecraft/world/level/block/LavaCauldronBlock.java.patch

@@ -0,0 +1,10 @@
+--- a/net/minecraft/world/level/block/LavaCauldronBlock.java
++++ b/net/minecraft/world/level/block/LavaCauldronBlock.java
+@@ -44,6 +_,7 @@
+ 
+     @Override
+     protected void entityInside(BlockState state, Level level, BlockPos pos, Entity entity, InsideBlockEffectApplier effectApplier) {
++        if (!new io.papermc.paper.event.entity.EntityInsideBlockEvent(entity.getBukkitEntity(), org.bukkit.craftbukkit.block.CraftBlock.at(level, pos)).callEvent()) { return; } // Paper - Add EntityInsideBlockEvent
+         effectApplier.apply(InsideBlockEffectType.LAVA_IGNITE);
+         effectApplier.runAfter(InsideBlockEffectType.LAVA_IGNITE, Entity::lavaHurt);
+     }

paper-server/patches/sources/net/minecraft/world/level/block/LayeredCauldronBlock.java.patch

@@ -0,0 +1,95 @@
+--- a/net/minecraft/world/level/block/LayeredCauldronBlock.java
++++ b/net/minecraft/world/level/block/LayeredCauldronBlock.java
+@@ -79,39 +_,67 @@
+ 
+     @Override
+     protected void entityInside(BlockState state, Level level, BlockPos pos, Entity entity, InsideBlockEffectApplier effectApplier) {
++        if (!new io.papermc.paper.event.entity.EntityInsideBlockEvent(entity.getBukkitEntity(), org.bukkit.craftbukkit.block.CraftBlock.at(level, pos)).callEvent()) { return; } // Paper - Add EntityInsideBlockEvent
+         if (level instanceof ServerLevel serverLevel) {
+             BlockPos blockPos = pos.immutable();
+             effectApplier.runBefore(InsideBlockEffectType.EXTINGUISH, entity1 -> {
+-                if (entity1.isOnFire() && entity1.mayInteract(serverLevel, blockPos)) {
+-                    this.handleEntityOnFireInside(state, level, blockPos);
++                if (entity1.isOnFire() && (entity instanceof net.minecraft.world.entity.player.Player || serverLevel.getGameRules().getBoolean(net.minecraft.world.level.GameRules.RULE_MOBGRIEFING)) && entity1.mayInteract(serverLevel, blockPos)) { // Paper - Fixes MC-248588
++                    this.handleEntityOnFireInside(state, level, blockPos, entity); // Paper - Track entity
+                 }
+             });
+         }
+ 
+-        effectApplier.apply(InsideBlockEffectType.EXTINGUISH);
++        effectApplier.apply(InsideBlockEffectType.EXTINGUISH); // TODO: THE EVENT ???????????????????????????????????
+     }
+ 
+-    private void handleEntityOnFireInside(BlockState state, Level level, BlockPos pos) {
++    // CraftBukkit start
++    private boolean handleEntityOnFireInside(BlockState state, Level level, BlockPos pos, @javax.annotation.Nullable Entity entity) {
+         if (this.precipitationType == Biome.Precipitation.SNOW) {
+-            lowerFillLevel(Blocks.WATER_CAULDRON.defaultBlockState().setValue(LEVEL, state.getValue(LEVEL)), level, pos);
++            return lowerFillLevel(Blocks.WATER_CAULDRON.defaultBlockState().setValue(LEVEL, state.getValue(LEVEL)), level, pos, entity, org.bukkit.event.block.CauldronLevelChangeEvent.ChangeReason.EXTINGUISH); // CraftBukkit
+         } else {
+-            lowerFillLevel(state, level, pos);
++            return lowerFillLevel(state, level, pos, entity, org.bukkit.event.block.CauldronLevelChangeEvent.ChangeReason.EXTINGUISH); // CraftBukkit
+         }
+     }
+ 
+     public static void lowerFillLevel(BlockState state, Level level, BlockPos pos) {
++    // Paper start
++        lowerFillLevel(state, level, pos, null, org.bukkit.event.block.CauldronLevelChangeEvent.ChangeReason.UNKNOWN);
++    }
++    public static boolean lowerFillLevel(BlockState state, Level level, BlockPos pos, @javax.annotation.Nullable Entity entity, org.bukkit.event.block.CauldronLevelChangeEvent.ChangeReason reason) {
++    // Paper end
+         int i = state.getValue(LEVEL) - 1;
+         BlockState blockState = i == 0 ? Blocks.CAULDRON.defaultBlockState() : state.setValue(LEVEL, i);
+-        level.setBlockAndUpdate(pos, blockState);
+-        level.gameEvent(GameEvent.BLOCK_CHANGE, pos, GameEvent.Context.of(blockState));
+-    }
++        return changeLevel(level, pos, blockState, entity, reason); // Paper
++    }
++    // CraftBukkit start
++    // Paper start - Call CauldronLevelChangeEvent
++    public static boolean changeLevel(Level level, BlockPos pos, BlockState newBlock, @javax.annotation.Nullable Entity entity, org.bukkit.event.block.CauldronLevelChangeEvent.ChangeReason reason) { // Paper - entity is nullable
++        return changeLevel(level, pos, newBlock, entity, reason, true);
++    }
++
++    public static boolean changeLevel(Level level, BlockPos pos, BlockState newBlock, @javax.annotation.Nullable Entity entity, org.bukkit.event.block.CauldronLevelChangeEvent.ChangeReason reason, boolean sendGameEvent) { // Paper - entity is nullable
++        // Paper end - Call CauldronLevelChangeEvent
++        org.bukkit.craftbukkit.block.CraftBlockState newState = org.bukkit.craftbukkit.block.CraftBlockStates.getBlockState(level, pos);
++        newState.setData(newBlock);
++
++        org.bukkit.event.block.CauldronLevelChangeEvent event = new org.bukkit.event.block.CauldronLevelChangeEvent(
++                org.bukkit.craftbukkit.block.CraftBlock.at(level, pos),
++                (entity == null) ? null : entity.getBukkitEntity(), reason, newState
++        );
++        if (!event.callEvent()) {
++            return false;
++        }
++        newState.place(3);
++        if (sendGameEvent) level.gameEvent(GameEvent.BLOCK_CHANGE, pos, GameEvent.Context.of(newBlock)); // Paper - Call CauldronLevelChangeEvent
++        return true;
++    }
++    // CraftBukkit end
+ 
+     @Override
+     public void handlePrecipitation(BlockState state, Level level, BlockPos pos, Biome.Precipitation precipitation) {
+         if (CauldronBlock.shouldHandlePrecipitation(level, precipitation) && state.getValue(LEVEL) != 3 && precipitation == this.precipitationType) {
+             BlockState blockState = state.cycle(LEVEL);
+-            level.setBlockAndUpdate(pos, blockState);
+-            level.gameEvent(GameEvent.BLOCK_CHANGE, pos, GameEvent.Context.of(blockState));
++            changeLevel(level, pos, blockState, null, org.bukkit.event.block.CauldronLevelChangeEvent.ChangeReason.NATURAL_FILL); // CraftBukkit
+         }
+     }
+ 
+@@ -129,8 +_,11 @@
+     protected void receiveStalactiteDrip(BlockState state, Level level, BlockPos pos, Fluid fluid) {
+         if (!this.isFull(state)) {
+             BlockState blockState = state.setValue(LEVEL, state.getValue(LEVEL) + 1);
+-            level.setBlockAndUpdate(pos, blockState);
+-            level.gameEvent(GameEvent.BLOCK_CHANGE, pos, GameEvent.Context.of(blockState));
++            // CraftBukkit start
++            if (!changeLevel(level, pos, blockState, null, org.bukkit.event.block.CauldronLevelChangeEvent.ChangeReason.NATURAL_FILL)) {
++                return;
++            }
++            // CraftBukkit end
+             level.levelEvent(1047, pos, 0);
+         }
+     }

paper-server/patches/sources/net/minecraft/world/level/block/SculkSpreader.java.patch

@@ -0,0 +1,46 @@
+--- a/net/minecraft/world/level/block/SculkSpreader.java
++++ b/net/minecraft/world/level/block/SculkSpreader.java
+@@ -46,6 +_,7 @@
+     private final int chargeDecayRate;
+     private final int additionalDecayRate;
+     private List<SculkSpreader.ChargeCursor> cursors = new ArrayList<>();
++    public net.minecraft.world.level.Level level; // CraftBukkit
+ 
+     public SculkSpreader(
+         boolean isWorldGeneration, TagKey<Block> replaceableBlocks, int growthSpawnCoat, int noGrowthRadius, int chargeDecayRate, int additionalDecayRate
+@@ -101,7 +_,7 @@
+ 
+     public void load(ValueInput input) {
+         this.cursors.clear();
+-        input.read("cursors", SculkSpreader.ChargeCursor.CODEC.sizeLimitedListOf(32)).orElse(List.of()).forEach(this::addCursor);
++        input.read("cursors", SculkSpreader.ChargeCursor.CODEC.sizeLimitedListOf(32)).orElse(List.of()).forEach((cursor) -> this.addCursor(cursor, false));  // Paper - don't fire event for block entity loading
+     }
+ 
+     public void save(ValueOutput output) {
+@@ -111,13 +_,24 @@
+     public void addCursors(BlockPos pos, int charge) {
+         while (charge > 0) {
+             int min = Math.min(charge, 1000);
+-            this.addCursor(new SculkSpreader.ChargeCursor(pos, min));
++            this.addCursor(new SculkSpreader.ChargeCursor(pos, min), true); // Paper - allow firing event for other causes
+             charge -= min;
+         }
+     }
+ 
+-    private void addCursor(SculkSpreader.ChargeCursor cursor) {
++    private void addCursor(SculkSpreader.ChargeCursor cursor, boolean fireEvent) { // Paper - add boolean to conditionally fire SculkBloomEvent
+         if (this.cursors.size() < 32) {
++            // CraftBukkit start
++            if (!this.isWorldGeneration() && fireEvent) { // CraftBukkit - SPIGOT-7475: Don't call event during world generation // Paper - add boolean to conditionally fire SculkBloomEvent
++                org.bukkit.craftbukkit.block.CraftBlock bukkitBlock = org.bukkit.craftbukkit.block.CraftBlock.at(this.level, cursor.pos);
++                org.bukkit.event.block.SculkBloomEvent event = new org.bukkit.event.block.SculkBloomEvent(bukkitBlock, cursor.getCharge());
++                if (!event.callEvent()) {
++                    return;
++                }
++
++                cursor.charge = event.getCharge();
++            }
++            // CraftBukkit end
+             this.cursors.add(cursor);
+         }
+     }

paper-server/patches/sources/net/minecraft/world/level/block/SignBlock.java.patch

@@ -0,0 +1,54 @@
+--- a/net/minecraft/world/level/block/SignBlock.java
++++ b/net/minecraft/world/level/block/SignBlock.java
+@@ -133,7 +_,7 @@
+                 } else if (!this.otherPlayerIsEditingSign(player, signBlockEntity)
+                     && player.mayBuild()
+                     && this.hasEditableText(player, signBlockEntity, isFacingFrontText)) {
+-                    this.openTextEdit(player, signBlockEntity, isFacingFrontText);
++                    this.openTextEdit(player, signBlockEntity, isFacingFrontText, io.papermc.paper.event.player.PlayerOpenSignEvent.Cause.INTERACT); // Paper - Add PlayerOpenSignEvent
+                     return InteractionResult.SUCCESS_SERVER;
+                 } else {
+                     return InteractionResult.PASS;
+@@ -179,7 +_,34 @@
+         return woodType;
+     }
+ 
++    @Deprecated @io.papermc.paper.annotation.DoNotUse // Paper - Add PlayerOpenSignEvent
+     public void openTextEdit(Player player, SignBlockEntity signEntity, boolean isFrontText) {
++        // Paper start - Add PlayerOpenSignEvent
++        this.openTextEdit(player, signEntity, isFrontText, io.papermc.paper.event.player.PlayerOpenSignEvent.Cause.UNKNOWN);
++    }
++
++    public void openTextEdit(Player player, SignBlockEntity signEntity, boolean isFrontText, io.papermc.paper.event.player.PlayerOpenSignEvent.Cause cause) {
++        org.bukkit.entity.Player bukkitPlayer = (org.bukkit.entity.Player) player.getBukkitEntity();
++        org.bukkit.block.Block bukkitBlock = org.bukkit.craftbukkit.block.CraftBlock.at(signEntity.getLevel(), signEntity.getBlockPos());
++        org.bukkit.craftbukkit.block.CraftSign<?> bukkitSign = (org.bukkit.craftbukkit.block.CraftSign<?>) org.bukkit.craftbukkit.block.CraftBlockStates.getBlockState(bukkitBlock);
++        io.papermc.paper.event.player.PlayerOpenSignEvent event = new io.papermc.paper.event.player.PlayerOpenSignEvent(
++            bukkitPlayer,
++            bukkitSign,
++            isFrontText ? org.bukkit.block.sign.Side.FRONT : org.bukkit.block.sign.Side.BACK,
++            cause);
++        if (!event.callEvent()) return;
++        if (org.bukkit.event.player.PlayerSignOpenEvent.getHandlerList().getRegisteredListeners().length > 0) {
++            final org.bukkit.event.player.PlayerSignOpenEvent.Cause legacyCause = switch (cause) {
++                case PLACE -> org.bukkit.event.player.PlayerSignOpenEvent.Cause.PLACE;
++                case PLUGIN -> org.bukkit.event.player.PlayerSignOpenEvent.Cause.PLUGIN;
++                case INTERACT -> org.bukkit.event.player.PlayerSignOpenEvent.Cause.INTERACT;
++                case UNKNOWN -> org.bukkit.event.player.PlayerSignOpenEvent.Cause.UNKNOWN;
++            };
++        if (!org.bukkit.craftbukkit.event.CraftEventFactory.callPlayerSignOpenEvent(player, signEntity, isFrontText, legacyCause)) {
++        // Paper end - Add PlayerOpenSignEvent
++            return;
++        }
++        } // Paper - Add PlayerOpenSignEvent
+         signEntity.setAllowedPlayerEditor(player.getUUID());
+         player.openTextEdit(signEntity, isFrontText);
+     }
+@@ -192,6 +_,6 @@
+     @Nullable
+     @Override
+     public <T extends BlockEntity> BlockEntityTicker<T> getTicker(Level level, BlockState state, BlockEntityType<T> blockEntityType) {
+-        return createTickerHelper(blockEntityType, BlockEntityType.SIGN, SignBlockEntity::tick);
++        return null; // CraftBukkit - remove unnecessary sign ticking
+     }
+ }