diff --git a/patches/minecraft/net/minecraft/world/entity/player/Player.java.patch b/patches/minecraft/net/minecraft/world/entity/player/Player.java.patch index a4b2ca6fbb..02d0488d9a 100644 --- a/patches/minecraft/net/minecraft/world/entity/player/Player.java.patch +++ b/patches/minecraft/net/minecraft/world/entity/player/Player.java.patch @@ -135,15 +135,23 @@ if (!this.level().isClientSide) { this.awardStat(Stats.ITEM_USED.get(this.useItem.getItem())); } -@@ -864,6 +_,8 @@ +@@ -862,10 +_,15 @@ + if (p_36383_ >= 3.0F) { + int i = 1 + Mth.floor(p_36383_); InteractionHand interactionhand = this.getUsedItemHand(); ++ // FORGE: cache this.useItem -- if this.stopUsingItem() is called, it will be set to ItemStack.EMPTY ++ ItemStack currentItem = this.useItem; this.useItem.hurtAndBreak(i, this, (p_219739_) -> { p_219739_.broadcastBreakEvent(interactionhand); + net.minecraftforge.event.ForgeEventFactory.onPlayerDestroyItem(this, this.useItem, interactionhand); -+ stopUsingItem(); // Forge: fix MC-168573 ++ if (this.useItem == currentItem) stopUsingItem(); // Forge: fix MC-168573 }); - if (this.useItem.isEmpty()) { +- if (this.useItem.isEmpty()) { ++ // FORGE: use cached item since this.useItem could be ItemStack.EMPTY ++ if (currentItem.isEmpty()) { if (interactionhand == InteractionHand.MAIN_HAND) { + this.setItemSlot(EquipmentSlot.MAINHAND, ItemStack.EMPTY); + } else { @@ -882,10 +_,13 @@ protected void actuallyHurt(DamageSource p_36312_, float p_36313_) { diff --git a/src/main/java/net/minecraftforge/common/extensions/IForgeGameTestHelper.java b/src/main/java/net/minecraftforge/common/extensions/IForgeGameTestHelper.java index e2133f9996..ff64577391 100644 --- a/src/main/java/net/minecraftforge/common/extensions/IForgeGameTestHelper.java +++ b/src/main/java/net/minecraftforge/common/extensions/IForgeGameTestHelper.java @@ -5,11 +5,15 @@ package net.minecraftforge.common.extensions; +import java.util.Arrays; import java.util.Objects; import java.util.UUID; import java.util.function.Consumer; import java.util.function.Supplier; +import net.minecraft.core.HolderLookup; +import net.minecraft.core.Registry; +import net.minecraft.resources.ResourceKey; import net.minecraft.world.entity.player.Player; import net.minecraft.world.level.GameType; import org.jetbrains.annotations.Nullable; @@ -62,7 +66,25 @@ public interface IForgeGameTestHelper { throw new GameTestAssertException(message.get()); } - /** Backported from 1.20.6 */ + default void assertValueEqual(N expected, N actual, String name, String message) { + this.assertValueEqual(expected, actual, name, () -> message); + } + + default void assertValueEqual(N expected, N actual, String name, Supplier message) { + if (!Objects.equals(expected, actual)) + throw new GameTestAssertException("%s -- Expected %s to be %s, but was %s".formatted(message.get(), name, expected, actual)); + } + + default void assertValueEqual(N[] expected, N[] actual, String name, String message) { + this.assertValueEqual(expected, actual, name, () -> message); + } + + default void assertValueEqual(N[] expected, N[] actual, String name, Supplier message) { + if (!Objects.deepEquals(expected, actual)) + throw new GameTestAssertException("%s -- Expected %s to be %s, but was %s".formatted(message.get(), name, Arrays.toString(expected), Arrays.toString(actual))); + } + + // Backported from 1.20.6 default void assertValueEqual(N expected, N actual, String name) { if (!Objects.equals(expected, actual)) { throw new GameTestAssertException("Expected " + name + " to be " + expected + ", but was " + actual); @@ -89,6 +111,10 @@ public interface IForgeGameTestHelper { }; } + default HolderLookup.RegistryLookup registryLookup(ResourceKey> registryKey) { + return this.self().getLevel().registryAccess().lookupOrThrow(registryKey); + } + default ServerPlayer makeMockServerPlayer() { var level = self().getLevel(); var cookie = CommonListenerCookie.createInitial(new GameProfile(UUID.randomUUID(), "test-mock-player")); @@ -185,19 +211,49 @@ public interface IForgeGameTestHelper { } public void assertUnset() { - if (this.value != null) - throw new GameTestAssertException("Expected " + name + " to be null, but was " + this.value); + this.assertUnset((Supplier) null); + } + + public void assertUnset(String message) { + this.assertUnset(message != null ? () -> message : null); + } + + public void assertUnset(Supplier message) { + if (this.value != null) { + String s = message != null ? message.get() + " -- " : ""; + throw new GameTestAssertException(s + "Expected " + name + " to be null, but was " + this.value); + } } public void assertSet() { - if (this.value == null) - throw new GameTestAssertException("Flag " + name + " was never set"); + this.assertSet((Supplier) null); + } + + public void assertSet(String message) { + this.assertSet(message != null ? () -> message : null); + } + + public void assertSet(Supplier message) { + if (this.value == null) { + String s = message != null ? message.get() + " -- " : ""; + throw new GameTestAssertException(s + "Flag " + name + " was never set"); + } } public void assertEquals(T expected) { - assertSet(); - if (expected != null && !expected.equals(this.value)) - throw new GameTestAssertException("Expected " + name + " to be " + expected + ", but was " + this.value); + this.assertEquals(expected, (Supplier) null); + } + + public void assertEquals(T expected, String message) { + this.assertEquals(expected, message != null ? () -> message : null); + } + + public void assertEquals(T expected, Supplier message) { + assertSet(message); + if (expected != null && !expected.equals(this.value)) { + String s = message != null ? message.get() + " -- " : ""; + throw new GameTestAssertException(s + "Expected " + name + " to be " + expected + ", but was " + this.value); + } } } @@ -222,9 +278,29 @@ public interface IForgeGameTestHelper { return this.value == null ? -1 : this.value.longValue(); } + public void assertEquals(int expected) { + super.assertEquals((long) expected); + } + public void assertEquals(long expected) { super.assertEquals(expected); } + + public void assertEquals(int expected, String message) { + super.assertEquals((long) expected, message); + } + + public void assertEquals(long expected, String message) { + super.assertEquals(expected, message); + } + + public void assertEquals(int expected, Supplier message) { + super.assertEquals((long) expected, message); + } + + public void assertEquals(long expected, Supplier message) { + super.assertEquals(expected, message); + } } public static class BoolFlag extends Flag { @@ -243,5 +319,13 @@ public interface IForgeGameTestHelper { public void assertEquals(boolean expected) { super.assertEquals(expected); } + + public void assertEquals(boolean expected, String message) { + super.assertEquals(expected, message); + } + + public void assertEquals(boolean expected, Supplier message) { + super.assertEquals(expected, message); + } } } diff --git a/src/test/java/net/minecraftforge/debug/gameplay/item/PreventItemDamageTest.java b/src/test/java/net/minecraftforge/debug/gameplay/item/PreventItemDamageTest.java new file mode 100644 index 0000000000..307be56a9c --- /dev/null +++ b/src/test/java/net/minecraftforge/debug/gameplay/item/PreventItemDamageTest.java @@ -0,0 +1,146 @@ +/* + * Copyright (c) Forge Development LLC and contributors + * SPDX-License-Identifier: LGPL-2.1-only + */ + +package net.minecraftforge.debug.gameplay.item; + +import net.minecraft.commands.arguments.EntityAnchorArgument; +import net.minecraft.core.BlockPos; +import net.minecraft.core.registries.Registries; +import net.minecraft.gametest.framework.GameTest; +import net.minecraft.gametest.framework.GameTestHelper; +import net.minecraft.server.level.ServerPlayer; +import net.minecraft.world.InteractionHand; +import net.minecraft.world.damagesource.DamageSource; +import net.minecraft.world.damagesource.DamageTypes; +import net.minecraft.world.entity.EntityType; +import net.minecraft.world.entity.LivingEntity; +import net.minecraft.world.item.Item; +import net.minecraft.world.item.ItemStack; +import net.minecraft.world.item.ShieldItem; +import net.minecraft.world.level.GameType; +import net.minecraftforge.event.entity.living.LivingEntityUseItemEvent; +import net.minecraftforge.event.entity.player.PlayerDestroyItemEvent; +import net.minecraftforge.fml.common.Mod; +import net.minecraftforge.gametest.GameTestHolder; +import net.minecraftforge.registries.DeferredRegister; +import net.minecraftforge.registries.ForgeRegistries; +import net.minecraftforge.registries.RegistryObject; +import net.minecraftforge.test.BaseTestMod; + +import java.util.function.Consumer; + +@Mod(PreventItemDamageTest.MOD_ID) +@GameTestHolder("forge." + PreventItemDamageTest.MOD_ID) +public class PreventItemDamageTest extends BaseTestMod { + static final String MOD_ID = "prevent_item_damage"; + + private static final DeferredRegister ITEMS = DeferredRegister.create(ForgeRegistries.ITEMS, MOD_ID); + private static final RegistryObject FAKE_SHIELD = ITEMS.register("fake_shield", FakeShieldItem::new); + + public PreventItemDamageTest() { + this.testItem(() -> FAKE_SHIELD.get().getDefaultInstance()); + } + + @GameTest(template = "forge:empty3x3x3") + public static void player_fake_shield_took_modified_damage(GameTestHelper helper) { + helper.makeFloor(); + + // setup player + var player = helper.makeMockPlayer(GameType.SURVIVAL); + + // setup shield + var shield = FAKE_SHIELD.get().getDefaultInstance(); + + // setup events + var firedLivingEntityUseItem = helper.boolFlag("fired LivingEntityUseItemEvent"); + var firedPlayerDestroyItem = helper.boolFlag("fired PlayerDestroyItemEvent"); + helper.addEventListener(event -> { + if (event.getEntity() != player) return; + + if (event.getItem() != shield) + helper.fail("Player is using an item, but it's not the fake shield! Check the game test impl."); + + // Artificially pass 5 seconds from start of the shield + // This is because the first 5 ticks, the player is still vulnerable + firedLivingEntityUseItem.set(true); + event.setDuration(event.getDuration() - 100); + }); + helper.addEventListener(event -> { + if (event.getEntity() != player) return; + + if (event.getOriginal() != shield) + helper.fail("Player destroyed an item, but it's not the fake shield! Check the game test impl."); + + firedPlayerDestroyItem.set(true); + }); + + // start using shield + player.setItemInHand(InteractionHand.MAIN_HAND, shield); + player.startUsingItem(InteractionHand.MAIN_HAND); + int initialDamage = shield.getDamageValue(); + + // setup enemy + var enemy = helper.spawnWithNoFreeWill(EntityType.HUSK, new BlockPos(2, 0, 2)); + player.lookAt(EntityAnchorArgument.Anchor.EYES, enemy.position()); + + // hit the player + var attack = helper.registryLookup(Registries.DAMAGE_TYPE).getOrThrow(DamageTypes.MOB_ATTACK); + var damage = new DamageSource(attack, enemy) { + @Override + public boolean scalesWithDifficulty() { + return false; + } + }; + player.hurt(damage, 5.0F); + + // ok, run the tests + firedLivingEntityUseItem.assertEquals(true); + firedPlayerDestroyItem.assertEquals(true); + helper.assertValueEqual(initialDamage + 1, shield.getDamageValue(), "shield damage value", "Fake shield did not take precisely 1 damage! Check IForgeItem#damageItem."); + helper.assertValueEqual(player.getItemInHand(InteractionHand.MAIN_HAND), shield, "player shield", "Fake shield was removed from player's hand! Check Player#hurtCurrentlyUsedShield."); + helper.succeed(); + } + + @GameTest(template = "forge:empty3x3x3") + public static void fake_shield_damage_item_impl(GameTestHelper helper) { + helper.makeFloor(); + + // setup player + var player = helper.makeMockServerPlayer(); + + // setup shield + var shield = FAKE_SHIELD.get().getDefaultInstance(); + int initialDamage = shield.getDamageValue(); + + // test hurt and break + var damaged = helper.flag("damaged shield"); + shield.hurtAndBreak(1, player, damaged::set); + damaged.assertEquals(player, "Fake shield was not damaged! Check IForgeItem#damageItem."); + helper.assertValueEqual(initialDamage + 1, shield.getDamageValue(), "shield damage value", "Fake shield did not take precisely 1 damage! Check IForgeItem#damageItem."); + + // HURT WITHOUT BREAK WAS ADDED IN 1.21.3 + /* + // test hurt without breaking + initialDamage = shield.getDamageValue(); + shield.hurtWithoutBreaking(1, player); + helper.assertValueEqual(initialDamage, shield.getDamageValue(), "shield damage value", "Fake shield took damage even though hurtWithoutBreak test should set damage taken to 0! Check FakeShieldItem or IForgeItem#damageItem."); + */ + + // finished + helper.succeed(); + } + + private static final class FakeShieldItem extends ShieldItem { + public FakeShieldItem() { + super(new Item.Properties().durability(10)); + } + + @Override + public int damageItem(ItemStack stack, int amount, T entity, Consumer onBroken) { + onBroken.accept(entity); + return 1; + } + } +} diff --git a/src/test/java/net/minecraftforge/debug/gameplay/item/ShieldDisablingTest.java b/src/test/java/net/minecraftforge/debug/gameplay/item/ShieldDisablingTest.java index 3efde936b9..5be4ba62a6 100644 --- a/src/test/java/net/minecraftforge/debug/gameplay/item/ShieldDisablingTest.java +++ b/src/test/java/net/minecraftforge/debug/gameplay/item/ShieldDisablingTest.java @@ -1,11 +1,19 @@ +/* + * Copyright (c) Forge Development LLC and contributors + * SPDX-License-Identifier: LGPL-2.1-only + */ + package net.minecraftforge.debug.gameplay.item; import net.minecraft.Util; import net.minecraft.commands.arguments.EntityAnchorArgument; import net.minecraft.core.BlockPos; +import net.minecraft.core.registries.Registries; import net.minecraft.gametest.framework.GameTest; import net.minecraft.gametest.framework.GameTestHelper; import net.minecraft.world.InteractionHand; +import net.minecraft.world.damagesource.DamageSource; +import net.minecraft.world.damagesource.DamageTypes; import net.minecraft.world.entity.EntityType; import net.minecraft.world.entity.LivingEntity; import net.minecraft.world.item.ItemStack; @@ -62,7 +70,14 @@ public final class ShieldDisablingTest extends BaseTestMod { player.lookAt(EntityAnchorArgument.Anchor.EYES, enemy.position()); // hit the player - player.hurt(enemy.damageSources().mobAttack(enemy), 5.0F); + var attack = helper.registryLookup(Registries.DAMAGE_TYPE).getOrThrow(DamageTypes.MOB_ATTACK); + var damage = new DamageSource(attack, enemy) { + @Override + public boolean scalesWithDifficulty() { + return false; + } + }; + player.hurt(damage, 5.0F); // shield on cooldown? helper.assertTrue(player.getCooldowns().isOnCooldown(shield.getItem()), "shield should be on cooldown");