zhenai
/
Code
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
Code/net/minecraft/gametest/framework/GameTestHelper.java

1009 lines
45 KiB
Java
Raw Normal View History

first commit
2025-07-01 06:20:03 +00:00
package net.minecraft.gametest.framework;
import com.mojang.authlib.GameProfile;
import com.mojang.brigadier.exceptions.CommandSyntaxException;
import com.mojang.datafixers.util.Either;
import io.netty.channel.embedded.EmbeddedChannel;
import java.util.List;
import java.util.Objects;
import java.util.UUID;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.IntPredicate;
import java.util.function.Predicate;
import java.util.function.Supplier;
import java.util.stream.LongStream;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import net.minecraft.core.BlockPos;
import net.minecraft.core.Direction;
import net.minecraft.core.Holder;
import net.minecraft.core.registries.Registries;
import net.minecraft.network.Connection;
import net.minecraft.network.chat.Component;
import net.minecraft.network.protocol.PacketFlow;
import net.minecraft.resources.ResourceKey;
import net.minecraft.server.commands.FillBiomeCommand;
import net.minecraft.server.level.ServerLevel;
import net.minecraft.server.level.ServerPlayer;
import net.minecraft.server.network.CommonListenerCookie;
import net.minecraft.tags.BlockTags;
import net.minecraft.tags.TagKey;
import net.minecraft.world.InteractionHand;
import net.minecraft.world.InteractionResult;
import net.minecraft.world.damagesource.DamageSource;
import net.minecraft.world.effect.MobEffect;
import net.minecraft.world.effect.MobEffectInstance;
import net.minecraft.world.entity.Entity;
import net.minecraft.world.entity.EntitySpawnReason;
import net.minecraft.world.entity.EntityType;
import net.minecraft.world.entity.LivingEntity;
import net.minecraft.world.entity.Mob;
import net.minecraft.world.entity.item.ItemEntity;
import net.minecraft.world.entity.npc.InventoryCarrier;
import net.minecraft.world.entity.player.Player;
import net.minecraft.world.item.Item;
import net.minecraft.world.item.ItemStack;
import net.minecraft.world.item.alchemy.PotionContents;
import net.minecraft.world.item.context.UseOnContext;
import net.minecraft.world.level.GameType;
import net.minecraft.world.level.biome.Biome;
import net.minecraft.world.level.block.Block;
import net.minecraft.world.level.block.Blocks;
import net.minecraft.world.level.block.ButtonBlock;
import net.minecraft.world.level.block.LeverBlock;
import net.minecraft.world.level.block.Mirror;
import net.minecraft.world.level.block.Rotation;
import net.minecraft.world.level.block.entity.BaseContainerBlockEntity;
import net.minecraft.world.level.block.entity.BlockEntity;
import net.minecraft.world.level.block.state.BlockState;
import net.minecraft.world.level.block.state.properties.Property;
import net.minecraft.world.level.levelgen.Heightmap;
import net.minecraft.world.level.levelgen.structure.BoundingBox;
import net.minecraft.world.level.levelgen.structure.templatesystem.StructureTemplate;
import net.minecraft.world.level.pathfinder.Path;
import net.minecraft.world.phys.AABB;
import net.minecraft.world.phys.BlockHitResult;
import net.minecraft.world.phys.Vec3;
public class GameTestHelper {
private final GameTestInfo testInfo;
private boolean finalCheckAdded;
public GameTestHelper(GameTestInfo p_127597_) {
this.testInfo = p_127597_;
}
public GameTestAssertException assertionException(Component p_396338_) {
return new GameTestAssertException(p_396338_, this.testInfo.getTick());
}
public GameTestAssertException assertionException(String p_391256_, Object... p_396991_) {
return this.assertionException(Component.translatableEscape(p_391256_, p_396991_));
}
public GameTestAssertPosException assertionException(BlockPos p_397296_, Component p_395659_) {
return new GameTestAssertPosException(p_395659_, this.absolutePos(p_397296_), p_397296_, this.testInfo.getTick());
}
public GameTestAssertPosException assertionException(BlockPos p_395825_, String p_391999_, Object... p_394029_) {
return this.assertionException(p_395825_, Component.translatableEscape(p_391999_, p_394029_));
}
public ServerLevel getLevel() {
return this.testInfo.getLevel();
}
public BlockState getBlockState(BlockPos p_177233_) {
return this.getLevel().getBlockState(this.absolutePos(p_177233_));
}
public <T extends BlockEntity> T getBlockEntity(BlockPos p_177348_, Class<T> p_395786_) {
BlockEntity blockentity = this.getLevel().getBlockEntity(this.absolutePos(p_177348_));
if (blockentity == null) {
throw this.assertionException(p_177348_, "test.error.missing_block_entity");
} else if (p_395786_.isInstance(blockentity)) {
return p_395786_.cast(blockentity);
} else {
throw this.assertionException(p_177348_, "test.error.wrong_block_entity", blockentity.getType().builtInRegistryHolder().getRegisteredName());
}
}
public void killAllEntities() {
this.killAllEntitiesOfClass(Entity.class);
}
public void killAllEntitiesOfClass(Class<? extends Entity> p_289538_) {
AABB aabb = this.getBounds();
List<? extends Entity> list = this.getLevel().getEntitiesOfClass(p_289538_, aabb.inflate(1.0), p_177131_ -> !(p_177131_ instanceof Player));
list.forEach(p_358470_ -> p_358470_.kill(this.getLevel()));
}
public ItemEntity spawnItem(Item p_329778_, Vec3 p_334689_) {
ServerLevel serverlevel = this.getLevel();
Vec3 vec3 = this.absoluteVec(p_334689_);
ItemEntity itementity = new ItemEntity(serverlevel, vec3.x, vec3.y, vec3.z, new ItemStack(p_329778_, 1));
itementity.setDeltaMovement(0.0, 0.0, 0.0);
serverlevel.addFreshEntity(itementity);
return itementity;
}
public ItemEntity spawnItem(Item p_177190_, float p_177191_, float p_177192_, float p_177193_) {
return this.spawnItem(p_177190_, new Vec3(p_177191_, p_177192_, p_177193_));
}
public ItemEntity spawnItem(Item p_251435_, BlockPos p_250287_) {
return this.spawnItem(p_251435_, p_250287_.getX(), p_250287_.getY(), p_250287_.getZ());
}
public <E extends Entity> E spawn(EntityType<E> p_177177_, BlockPos p_177178_) {
return this.spawn(p_177177_, Vec3.atBottomCenterOf(p_177178_));
}
public <E extends Entity> E spawn(EntityType<E> p_177174_, Vec3 p_177175_) {
ServerLevel serverlevel = this.getLevel();
E e = p_177174_.create(serverlevel, EntitySpawnReason.STRUCTURE);
if (e == null) {
throw this.assertionException(BlockPos.containing(p_177175_), "test.error.spawn_failure", p_177174_.builtInRegistryHolder().getRegisteredName());
} else {
if (e instanceof Mob mob) {
mob.setPersistenceRequired();
}
Vec3 vec3 = this.absoluteVec(p_177175_);
e.snapTo(vec3.x, vec3.y, vec3.z, e.getYRot(), e.getXRot());
serverlevel.addFreshEntity(e);
return e;
}
}
public void hurt(Entity p_369429_, DamageSource p_367525_, float p_361355_) {
p_369429_.hurtServer(this.getLevel(), p_367525_, p_361355_);
}
public void kill(Entity p_364190_) {
p_364190_.kill(this.getLevel());
}
public <E extends Entity> E findOneEntity(EntityType<E> p_333077_) {
return this.findClosestEntity(p_333077_, 0, 0, 0, 2.147483647E9);
}
public <E extends Entity> E findClosestEntity(EntityType<E> p_335109_, int p_329434_, int p_334603_, int p_333149_, double p_331586_) {
List<E> list = this.findEntities(p_335109_, p_329434_, p_334603_, p_333149_, p_331586_);
if (list.isEmpty()) {
throw this.assertionException("test.error.expected_entity_around", p_335109_.getDescription(), p_329434_, p_334603_, p_333149_);
} else if (list.size() > 1) {
throw this.assertionException("test.error.too_many_entities", p_335109_.toShortString(), p_329434_, p_334603_, p_333149_, list.size());
} else {
Vec3 vec3 = this.absoluteVec(new Vec3(p_329434_, p_334603_, p_333149_));
list.sort((p_325933_, p_325934_) -> {
double d0 = p_325933_.position().distanceTo(vec3);
double d1 = p_325934_.position().distanceTo(vec3);
return Double.compare(d0, d1);
});
return list.get(0);
}
}
public <E extends Entity> List<E> findEntities(EntityType<E> p_327745_, int p_330471_, int p_329385_, int p_328777_, double p_336258_) {
return this.findEntities(p_327745_, Vec3.atBottomCenterOf(new BlockPos(p_330471_, p_329385_, p_328777_)), p_336258_);
}
public <E extends Entity> List<E> findEntities(EntityType<E> p_327849_, Vec3 p_331515_, double p_330795_) {
ServerLevel serverlevel = this.getLevel();
Vec3 vec3 = this.absoluteVec(p_331515_);
AABB aabb = this.testInfo.getStructureBounds();
AABB aabb1 = new AABB(vec3.add(-p_330795_, -p_330795_, -p_330795_), vec3.add(p_330795_, p_330795_, p_330795_));
return serverlevel.getEntities(p_327849_, aabb, p_325936_ -> p_325936_.getBoundingBox().intersects(aabb1) && p_325936_.isAlive());
}
public <E extends Entity> E spawn(EntityType<E> p_177169_, int p_177170_, int p_177171_, int p_177172_) {
return this.spawn(p_177169_, new BlockPos(p_177170_, p_177171_, p_177172_));
}
public <E extends Entity> E spawn(EntityType<E> p_177164_, float p_177165_, float p_177166_, float p_177167_) {
return this.spawn(p_177164_, new Vec3(p_177165_, p_177166_, p_177167_));
}
public <E extends Mob> E spawnWithNoFreeWill(EntityType<E> p_177330_, BlockPos p_177331_) {
E e = (E)this.spawn(p_177330_, p_177331_);
e.removeFreeWill();
return e;
}
public <E extends Mob> E spawnWithNoFreeWill(EntityType<E> p_177322_, int p_177323_, int p_177324_, int p_177325_) {
return this.spawnWithNoFreeWill(p_177322_, new BlockPos(p_177323_, p_177324_, p_177325_));
}
public <E extends Mob> E spawnWithNoFreeWill(EntityType<E> p_177327_, Vec3 p_177328_) {
E e = (E)this.spawn(p_177327_, p_177328_);
e.removeFreeWill();
return e;
}
public <E extends Mob> E spawnWithNoFreeWill(EntityType<E> p_177317_, float p_177318_, float p_177319_, float p_177320_) {
return this.spawnWithNoFreeWill(p_177317_, new Vec3(p_177318_, p_177319_, p_177320_));
}
public void moveTo(Mob p_335410_, float p_330841_, float p_334132_, float p_332530_) {
Vec3 vec3 = this.absoluteVec(new Vec3(p_330841_, p_334132_, p_332530_));
p_335410_.snapTo(vec3.x, vec3.y, vec3.z, p_335410_.getYRot(), p_335410_.getXRot());
}
public GameTestSequence walkTo(Mob p_177186_, BlockPos p_177187_, float p_177188_) {
return this.startSequence().thenExecuteAfter(2, () -> {
Path path = p_177186_.getNavigation().createPath(this.absolutePos(p_177187_), 0);
p_177186_.getNavigation().moveTo(path, p_177188_);
});
}
public void pressButton(int p_177104_, int p_177105_, int p_177106_) {
this.pressButton(new BlockPos(p_177104_, p_177105_, p_177106_));
}
public void pressButton(BlockPos p_177386_) {
this.assertBlockTag(BlockTags.BUTTONS, p_177386_);
BlockPos blockpos = this.absolutePos(p_177386_);
BlockState blockstate = this.getLevel().getBlockState(blockpos);
ButtonBlock buttonblock = (ButtonBlock)blockstate.getBlock();
buttonblock.press(blockstate, this.getLevel(), blockpos, null);
}
public void useBlock(BlockPos p_177409_) {
this.useBlock(p_177409_, this.makeMockPlayer(GameType.CREATIVE));
}
public void useBlock(BlockPos p_250131_, Player p_251507_) {
BlockPos blockpos = this.absolutePos(p_250131_);
this.useBlock(p_250131_, p_251507_, new BlockHitResult(Vec3.atCenterOf(blockpos), Direction.NORTH, blockpos, true));
}
public void useBlock(BlockPos p_262023_, Player p_261901_, BlockHitResult p_262040_) {
BlockPos blockpos = this.absolutePos(p_262023_);
BlockState blockstate = this.getLevel().getBlockState(blockpos);
InteractionHand interactionhand = InteractionHand.MAIN_HAND;
InteractionResult interactionresult = blockstate.useItemOn(p_261901_.getItemInHand(interactionhand), this.getLevel(), p_261901_, interactionhand, p_262040_);
if (!interactionresult.consumesAction()) {
if (!(interactionresult instanceof InteractionResult.TryEmptyHandInteraction)
|| !blockstate.useWithoutItem(this.getLevel(), p_261901_, p_262040_).consumesAction()) {
UseOnContext useoncontext = new UseOnContext(p_261901_, interactionhand, p_262040_);
p_261901_.getItemInHand(interactionhand).useOn(useoncontext);
}
}
}
public LivingEntity makeAboutToDrown(LivingEntity p_177184_) {
p_177184_.setAirSupply(0);
p_177184_.setHealth(0.25F);
return p_177184_;
}
public LivingEntity withLowHealth(LivingEntity p_286794_) {
p_286794_.setHealth(0.25F);
return p_286794_;
}
public Player makeMockPlayer(final GameType p_333981_) {
return new Player(this.getLevel(), BlockPos.ZERO, 0.0F, new GameProfile(UUID.randomUUID(), "test-mock-player")) {
@Nonnull
@Override
public GameType gameMode() {
return p_333981_;
}
@Override
public boolean isClientAuthoritative() {
return false;
}
};
}
@Deprecated(
forRemoval = true
)
public ServerPlayer makeMockServerPlayerInLevel() {
CommonListenerCookie commonlistenercookie = CommonListenerCookie.createInitial(new GameProfile(UUID.randomUUID(), "test-mock-player"), false);
ServerPlayer serverplayer = new ServerPlayer(
this.getLevel().getServer(), this.getLevel(), commonlistenercookie.gameProfile(), commonlistenercookie.clientInformation()
) {
@Override
public GameType gameMode() {
return GameType.CREATIVE;
}
};
Connection connection = new Connection(PacketFlow.SERVERBOUND);
new EmbeddedChannel(connection);
this.getLevel().getServer().getPlayerList().placeNewPlayer(connection, serverplayer, commonlistenercookie);
return serverplayer;
}
public void pullLever(int p_177303_, int p_177304_, int p_177305_) {
this.pullLever(new BlockPos(p_177303_, p_177304_, p_177305_));
}
public void pullLever(BlockPos p_177422_) {
this.assertBlockPresent(Blocks.LEVER, p_177422_);
BlockPos blockpos = this.absolutePos(p_177422_);
BlockState blockstate = this.getLevel().getBlockState(blockpos);
LeverBlock leverblock = (LeverBlock)blockstate.getBlock();
leverblock.pull(blockstate, this.getLevel(), blockpos, null);
}
public void pulseRedstone(BlockPos p_177235_, long p_177236_) {
this.setBlock(p_177235_, Blocks.REDSTONE_BLOCK);
this.runAfterDelay(p_177236_, () -> this.setBlock(p_177235_, Blocks.AIR));
}
public void destroyBlock(BlockPos p_177435_) {
this.getLevel().destroyBlock(this.absolutePos(p_177435_), false, null);
}
public void setBlock(int p_177108_, int p_177109_, int p_177110_, Block p_177111_) {
this.setBlock(new BlockPos(p_177108_, p_177109_, p_177110_), p_177111_);
}
public void setBlock(int p_177113_, int p_177114_, int p_177115_, BlockState p_177116_) {
this.setBlock(new BlockPos(p_177113_, p_177114_, p_177115_), p_177116_);
}
public void setBlock(BlockPos p_177246_, Block p_177247_) {
this.setBlock(p_177246_, p_177247_.defaultBlockState());
}
public void setBlock(BlockPos p_177253_, BlockState p_177254_) {
this.getLevel().setBlock(this.absolutePos(p_177253_), p_177254_, 3);
}
public void setNight() {
this.setDayTime(13000);
}
public void setDayTime(int p_177102_) {
this.getLevel().setDayTime(p_177102_);
}
public void assertBlockPresent(Block p_177204_, int p_177205_, int p_177206_, int p_177207_) {
this.assertBlockPresent(p_177204_, new BlockPos(p_177205_, p_177206_, p_177207_));
}
public void assertBlockPresent(Block p_177209_, BlockPos p_177210_) {
BlockState blockstate = this.getBlockState(p_177210_);
this.assertBlock(
p_177210_,
p_177216_ -> blockstate.is(p_177209_),
p_389750_ -> Component.translatable("test.error.expected_block", p_177209_.getName(), p_389750_.getName())
);
}
public void assertBlockNotPresent(Block p_177337_, int p_177338_, int p_177339_, int p_177340_) {
this.assertBlockNotPresent(p_177337_, new BlockPos(p_177338_, p_177339_, p_177340_));
}
public void assertBlockNotPresent(Block p_177342_, BlockPos p_177343_) {
this.assertBlock(
p_177343_,
p_177251_ -> !this.getBlockState(p_177343_).is(p_177342_),
p_389752_ -> Component.translatable("test.error.unexpected_block", p_177342_.getName())
);
}
public void assertBlockTag(TagKey<Block> p_395167_, BlockPos p_394420_) {
this.assertBlockState(
p_394420_,
p_389762_ -> p_389762_.is(p_395167_),
p_389754_ -> Component.translatable("test.error.expected_block_tag", p_395167_.location(), p_389754_.getBlock().getName())
);
}
public void succeedWhenBlockPresent(Block p_177378_, int p_177379_, int p_177380_, int p_177381_) {
this.succeedWhenBlockPresent(p_177378_, new BlockPos(p_177379_, p_177380_, p_177381_));
}
public void succeedWhenBlockPresent(Block p_177383_, BlockPos p_177384_) {
this.succeedWhen(() -> this.assertBlockPresent(p_177383_, p_177384_));
}
public void assertBlock(BlockPos p_177272_, Predicate<Block> p_177273_, Function<Block, Component> p_395351_) {
this.assertBlockState(p_177272_, p_177296_ -> p_177273_.test(p_177296_.getBlock()), p_389756_ -> p_395351_.apply(p_389756_.getBlock()));
}
public <T extends Comparable<T>> void assertBlockProperty(BlockPos p_177256_, Property<T> p_177257_, T p_177258_) {
BlockState blockstate = this.getBlockState(p_177256_);
boolean flag = blockstate.hasProperty(p_177257_);
if (!flag) {
throw this.assertionException(p_177256_, "test.error.block_property_missing", p_177257_.getName(), p_177258_);
} else if (!blockstate.<T>getValue(p_177257_).equals(p_177258_)) {
throw this.assertionException(p_177256_, "test.error.block_property_mismatch", p_177257_.getName(), p_177258_, blockstate.getValue(p_177257_));
}
}
public <T extends Comparable<T>> void assertBlockProperty(BlockPos p_177260_, Property<T> p_177261_, Predicate<T> p_177262_, Component p_393167_) {
this.assertBlockState(p_177260_, p_277264_ -> {
if (!p_277264_.hasProperty(p_177261_)) {
return false;
} else {
T t = p_277264_.getValue(p_177261_);
return p_177262_.test(t);
}
}, p_397227_ -> p_393167_);
}
public void assertBlockState(BlockPos p_396349_, BlockState p_394832_) {
BlockState blockstate = this.getBlockState(p_396349_);
if (!blockstate.equals(p_394832_)) {
throw this.assertionException(p_396349_, "test.error.state_not_equal", p_394832_, blockstate);
}
}
public void assertBlockState(BlockPos p_177358_, Predicate<BlockState> p_177359_, Function<BlockState, Component> p_392520_) {
BlockState blockstate = this.getBlockState(p_177358_);
if (!p_177359_.test(blockstate)) {
throw this.assertionException(p_177358_, p_392520_.apply(blockstate));
}
}
public <T extends BlockEntity> void assertBlockEntityData(BlockPos p_345406_, Class<T> p_391986_, Predicate<T> p_342583_, Supplier<Component> p_343096_) {
T t = this.getBlockEntity(p_345406_, p_391986_);
if (!p_342583_.test(t)) {
throw this.assertionException(p_345406_, p_343096_.get());
}
}
public void assertRedstoneSignal(BlockPos p_289644_, Direction p_289642_, IntPredicate p_289645_, Supplier<Component> p_289684_) {
BlockPos blockpos = this.absolutePos(p_289644_);
ServerLevel serverlevel = this.getLevel();
BlockState blockstate = serverlevel.getBlockState(blockpos);
int i = blockstate.getSignal(serverlevel, blockpos, p_289642_);
if (!p_289645_.test(i)) {
throw this.assertionException(p_289644_, p_289684_.get());
}
}
public void assertEntityPresent(EntityType<?> p_177157_) {
List<? extends Entity> list = this.getLevel().getEntities(p_177157_, this.getBounds(), Entity::isAlive);
if (list.isEmpty()) {
throw this.assertionException("test.error.expected_entity_in_test", p_177157_.getDescription());
}
}
public void assertEntityPresent(EntityType<?> p_177370_, int p_177371_, int p_177372_, int p_177373_) {
this.assertEntityPresent(p_177370_, new BlockPos(p_177371_, p_177372_, p_177373_));
}
public void assertEntityPresent(EntityType<?> p_177375_, BlockPos p_177376_) {
BlockPos blockpos = this.absolutePos(p_177376_);
List<? extends Entity> list = this.getLevel().getEntities(p_177375_, new AABB(blockpos), Entity::isAlive);
if (list.isEmpty()) {
throw this.assertionException(p_177376_, "test.error.expected_entity", p_177375_.getDescription());
}
}
public void assertEntityPresent(EntityType<?> p_252010_, AABB p_367168_) {
AABB aabb = this.absoluteAABB(p_367168_);
List<? extends Entity> list = this.getLevel().getEntities(p_252010_, aabb, Entity::isAlive);
if (list.isEmpty()) {
throw this.assertionException(BlockPos.containing(p_367168_.getCenter()), "test.error.expected_entity", p_252010_.getDescription());
}
}
public void assertEntitiesPresent(EntityType<?> p_313026_, int p_310037_) {
List<? extends Entity> list = this.getLevel().getEntities(p_313026_, this.getBounds(), Entity::isAlive);
if (list.size() != p_310037_) {
throw this.assertionException("test.error.expected_entity_count", p_310037_, p_313026_.getDescription(), list.size());
}
}
public void assertEntitiesPresent(EntityType<?> p_239372_, BlockPos p_239373_, int p_239374_, double p_239375_) {
BlockPos blockpos = this.absolutePos(p_239373_);
List<? extends Entity> list = this.getEntities((EntityType<? extends Entity>)p_239372_, p_239373_, p_239375_);
if (list.size() != p_239374_) {
throw this.assertionException(p_239373_, "test.error.expected_entity_count", p_239374_, p_239372_.getDescription(), list.size());
}
}
public void assertEntityPresent(EntityType<?> p_177180_, BlockPos p_177181_, double p_177182_) {
List<? extends Entity> list = this.getEntities((EntityType<? extends Entity>)p_177180_, p_177181_, p_177182_);
if (list.isEmpty()) {
BlockPos blockpos = this.absolutePos(p_177181_);
throw this.assertionException(p_177181_, "test.error.expected_entity", p_177180_.getDescription());
}
}
public <T extends Entity> List<T> getEntities(EntityType<T> p_238400_, BlockPos p_238401_, double p_238402_) {
BlockPos blockpos = this.absolutePos(p_238401_);
return this.getLevel().getEntities(p_238400_, new AABB(blockpos).inflate(p_238402_), Entity::isAlive);
}
public <T extends Entity> List<T> getEntities(EntityType<T> p_330219_) {
return this.getLevel().getEntities(p_330219_, this.getBounds(), Entity::isAlive);
}
public void assertEntityInstancePresent(Entity p_177133_, int p_177134_, int p_177135_, int p_177136_) {
this.assertEntityInstancePresent(p_177133_, new BlockPos(p_177134_, p_177135_, p_177136_));
}
public void assertEntityInstancePresent(Entity p_177141_, BlockPos p_177142_) {
BlockPos blockpos = this.absolutePos(p_177142_);
List<? extends Entity> list = this.getLevel().getEntities(p_177141_.getType(), new AABB(blockpos), Entity::isAlive);
list.stream()
.filter(p_177139_ -> p_177139_ == p_177141_)
.findFirst()
.orElseThrow(() -> this.assertionException(p_177142_, "test.error.expected_entity", p_177141_.getType().getDescription()));
}
public void assertItemEntityCountIs(Item p_177199_, BlockPos p_177200_, double p_177201_, int p_177202_) {
BlockPos blockpos = this.absolutePos(p_177200_);
List<ItemEntity> list = this.getLevel().getEntities(EntityType.ITEM, new AABB(blockpos).inflate(p_177201_), Entity::isAlive);
int i = 0;
for (ItemEntity itementity : list) {
ItemStack itemstack = itementity.getItem();
if (itemstack.is(p_177199_)) {
i += itemstack.getCount();
}
}
if (i != p_177202_) {
throw this.assertionException(p_177200_, "test.error.expected_items_count", p_177202_, p_177199_.getName(), i);
}
}
public void assertItemEntityPresent(Item p_177195_, BlockPos p_177196_, double p_177197_) {
BlockPos blockpos = this.absolutePos(p_177196_);
for (Entity entity : this.getLevel().getEntities(EntityType.ITEM, new AABB(blockpos).inflate(p_177197_), Entity::isAlive)) {
ItemEntity itementity = (ItemEntity)entity;
if (itementity.getItem().getItem().equals(p_177195_)) {
return;
}
}
throw this.assertionException(p_177196_, "test.error.expected_item", p_177195_.getName());
}
public void assertItemEntityNotPresent(Item p_236779_, BlockPos p_236780_, double p_236781_) {
BlockPos blockpos = this.absolutePos(p_236780_);
for (Entity entity : this.getLevel().getEntities(EntityType.ITEM, new AABB(blockpos).inflate(p_236781_), Entity::isAlive)) {
ItemEntity itementity = (ItemEntity)entity;
if (itementity.getItem().getItem().equals(p_236779_)) {
throw this.assertionException(p_236780_, "test.error.unexpected_item", p_236779_.getName());
}
}
}
public void assertItemEntityPresent(Item p_310630_) {
for (Entity entity : this.getLevel().getEntities(EntityType.ITEM, this.getBounds(), Entity::isAlive)) {
ItemEntity itementity = (ItemEntity)entity;
if (itementity.getItem().getItem().equals(p_310630_)) {
return;
}
}
throw this.assertionException("test.error.expected_item", p_310630_.getName());
}
public void assertItemEntityNotPresent(Item p_312600_) {
for (Entity entity : this.getLevel().getEntities(EntityType.ITEM, this.getBounds(), Entity::isAlive)) {
ItemEntity itementity = (ItemEntity)entity;
if (itementity.getItem().getItem().equals(p_312600_)) {
throw this.assertionException("test.error.unexpected_item", p_312600_.getName());
}
}
}
public void assertEntityNotPresent(EntityType<?> p_177310_) {
List<? extends Entity> list = this.getLevel().getEntities(p_177310_, this.getBounds(), Entity::isAlive);
if (!list.isEmpty()) {
throw this.assertionException(list.getFirst().blockPosition(), "test.error.unexpected_entity", p_177310_.getDescription());
}
}
public void assertEntityNotPresent(EntityType<?> p_177398_, int p_177399_, int p_177400_, int p_177401_) {
this.assertEntityNotPresent(p_177398_, new BlockPos(p_177399_, p_177400_, p_177401_));
}
public void assertEntityNotPresent(EntityType<?> p_177403_, BlockPos p_177404_) {
BlockPos blockpos = this.absolutePos(p_177404_);
List<? extends Entity> list = this.getLevel().getEntities(p_177403_, new AABB(blockpos), Entity::isAlive);
if (!list.isEmpty()) {
throw this.assertionException(p_177404_, "test.error.unexpected_entity", p_177403_.getDescription());
}
}
public void assertEntityNotPresent(EntityType<?> p_328558_, AABB p_361757_) {
AABB aabb = this.absoluteAABB(p_361757_);
List<? extends Entity> list = this.getLevel().getEntities(p_328558_, aabb, Entity::isAlive);
if (!list.isEmpty()) {
throw this.assertionException(list.getFirst().blockPosition(), "test.error.unexpected_entity", p_328558_.getDescription());
}
}
public void assertEntityTouching(EntityType<?> p_177159_, double p_177160_, double p_177161_, double p_177162_) {
Vec3 vec3 = new Vec3(p_177160_, p_177161_, p_177162_);
Vec3 vec31 = this.absoluteVec(vec3);
Predicate<? super Entity> predicate = p_177346_ -> p_177346_.getBoundingBox().intersects(vec31, vec31);
List<? extends Entity> list = this.getLevel().getEntities(p_177159_, this.getBounds(), predicate);
if (list.isEmpty()) {
throw this.assertionException(
"test.error.expected_entity_touching", p_177159_.getDescription(), vec31.x(), vec31.y(), vec31.z(), p_177160_, p_177161_, p_177162_
);
}
}
public void assertEntityNotTouching(EntityType<?> p_177312_, double p_177313_, double p_177314_, double p_177315_) {
Vec3 vec3 = new Vec3(p_177313_, p_177314_, p_177315_);
Vec3 vec31 = this.absoluteVec(vec3);
Predicate<? super Entity> predicate = p_177231_ -> !p_177231_.getBoundingBox().intersects(vec31, vec31);
List<? extends Entity> list = this.getLevel().getEntities(p_177312_, this.getBounds(), predicate);
if (list.isEmpty()) {
throw this.assertionException(
"test.error.expected_entity_not_touching",
p_177312_.getDescription(),
vec31.x(),
vec31.y(),
vec31.z(),
p_177313_,
p_177314_,
p_177315_
);
}
}
public <E extends Entity, T> void assertEntityData(BlockPos p_362770_, EntityType<E> p_363965_, Predicate<E> p_367551_) {
BlockPos blockpos = this.absolutePos(p_362770_);
List<E> list = this.getLevel().getEntities(p_363965_, new AABB(blockpos), Entity::isAlive);
if (list.isEmpty()) {
throw this.assertionException(p_362770_, "test.error.expected_entity", p_363965_.getDescription());
} else {
for (E e : list) {
if (!p_367551_.test(e)) {
throw this.assertionException(e.blockPosition(), "test.error.expected_entity_data_predicate", e.getName());
}
}
}
}
public <E extends Entity, T> void assertEntityData(BlockPos p_177238_, EntityType<E> p_177239_, Function<? super E, T> p_177240_, @Nullable T p_177241_) {
BlockPos blockpos = this.absolutePos(p_177238_);
List<E> list = this.getLevel().getEntities(p_177239_, new AABB(blockpos), Entity::isAlive);
if (list.isEmpty()) {
throw this.assertionException(p_177238_, "test.error.expected_entity", p_177239_.getDescription());
} else {
for (E e : list) {
T t = p_177240_.apply(e);
if (!Objects.equals(t, p_177241_)) {
throw this.assertionException(p_177238_, "test.error.expected_entity_data", p_177241_, t);
}
}
}
}
public <E extends LivingEntity> void assertEntityIsHolding(BlockPos p_263501_, EntityType<E> p_263510_, Item p_263517_) {
BlockPos blockpos = this.absolutePos(p_263501_);
List<E> list = this.getLevel().getEntities(p_263510_, new AABB(blockpos), Entity::isAlive);
if (list.isEmpty()) {
throw this.assertionException(p_263501_, "test.error.expected_entity", p_263510_.getDescription());
} else {
for (E e : list) {
if (e.isHolding(p_263517_)) {
return;
}
}
throw this.assertionException(p_263501_, "test.error.expected_entity_holding", p_263517_.getName());
}
}
public <E extends Entity & InventoryCarrier> void assertEntityInventoryContains(BlockPos p_263495_, EntityType<E> p_263521_, Item p_263502_) {
BlockPos blockpos = this.absolutePos(p_263495_);
List<E> list = this.getLevel().getEntities(p_263521_, new AABB(blockpos), p_263479_ -> p_263479_.isAlive());
if (list.isEmpty()) {
throw this.assertionException(p_263495_, "test.error.expected_entity", p_263521_.getDescription());
} else {
for (E e : list) {
if (e.getInventory().hasAnyMatching(p_263481_ -> p_263481_.is(p_263502_))) {
return;
}
}
throw this.assertionException(p_263495_, "test.error.expected_entity_having", p_263502_.getName());
}
}
public void assertContainerEmpty(BlockPos p_177441_) {
BaseContainerBlockEntity basecontainerblockentity = this.getBlockEntity(p_177441_, BaseContainerBlockEntity.class);
if (!basecontainerblockentity.isEmpty()) {
throw this.assertionException(p_177441_, "test.error.expected_empty_container");
}
}
public void assertContainerContainsSingle(BlockPos p_393278_, Item p_397233_) {
BaseContainerBlockEntity basecontainerblockentity = this.getBlockEntity(p_393278_, BaseContainerBlockEntity.class);
if (basecontainerblockentity.countItem(p_397233_) != 1) {
throw this.assertionException(p_393278_, "test.error.expected_container_contents_single", p_397233_.getName());
}
}
public void assertContainerContains(BlockPos p_177243_, Item p_177244_) {
BaseContainerBlockEntity basecontainerblockentity = this.getBlockEntity(p_177243_, BaseContainerBlockEntity.class);
if (basecontainerblockentity.countItem(p_177244_) == 0) {
throw this.assertionException(p_177243_, "test.error.expected_container_contents", p_177244_.getName());
}
}
public void assertSameBlockStates(BoundingBox p_177225_, BlockPos p_177226_) {
BlockPos.betweenClosedStream(p_177225_)
.forEach(
p_177267_ -> {
BlockPos blockpos = p_177226_.offset(
p_177267_.getX() - p_177225_.minX(),
p_177267_.getY() - p_177225_.minY(),
p_177267_.getZ() - p_177225_.minZ()
);
this.assertSameBlockState(p_177267_, blockpos);
}
);
}
public void assertSameBlockState(BlockPos p_177269_, BlockPos p_177270_) {
BlockState blockstate = this.getBlockState(p_177269_);
BlockState blockstate1 = this.getBlockState(p_177270_);
if (blockstate != blockstate1) {
throw this.assertionException(p_177269_, "test.error.state_not_equal", blockstate1, blockstate);
}
}
public void assertAtTickTimeContainerContains(long p_177124_, BlockPos p_177125_, Item p_177126_) {
this.runAtTickTime(p_177124_, () -> this.assertContainerContainsSingle(p_177125_, p_177126_));
}
public void assertAtTickTimeContainerEmpty(long p_177121_, BlockPos p_177122_) {
this.runAtTickTime(p_177121_, () -> this.assertContainerEmpty(p_177122_));
}
public <E extends Entity, T> void succeedWhenEntityData(BlockPos p_177350_, EntityType<E> p_177351_, Function<E, T> p_177352_, T p_177353_) {
this.succeedWhen(() -> this.assertEntityData(p_177350_, p_177351_, p_177352_, p_177353_));
}
public void assertEntityPosition(Entity p_344935_, AABB p_345349_, Component p_393630_) {
if (!p_345349_.contains(this.relativeVec(p_344935_.position()))) {
throw this.assertionException(p_393630_);
}
}
public <E extends Entity> void assertEntityProperty(E p_177148_, Predicate<E> p_393110_, Component p_397208_) {
if (!p_393110_.test(p_177148_)) {
throw this.assertionException(p_177148_.blockPosition(), "test.error.entity_property", p_177148_.getName(), p_397208_);
}
}
public <E extends Entity, T> void assertEntityProperty(E p_177153_, Function<E, T> p_396986_, T p_393513_, Component p_392760_) {
T t = p_396986_.apply(p_177153_);
if (!t.equals(p_393513_)) {
throw this.assertionException(p_177153_.blockPosition(), "test.error.entity_property_details", p_177153_.getName(), p_392760_, t, p_393513_);
}
}
public void assertLivingEntityHasMobEffect(LivingEntity p_300128_, Holder<MobEffect> p_331754_, int p_298143_) {
MobEffectInstance mobeffectinstance = p_300128_.getEffect(p_331754_);
if (mobeffectinstance == null || mobeffectinstance.getAmplifier() != p_298143_) {
throw this.assertionException("test.error.expected_entity_effect", p_300128_.getName(), PotionContents.getPotionDescription(p_331754_, p_298143_));
}
}
public void succeedWhenEntityPresent(EntityType<?> p_177414_, int p_177415_, int p_177416_, int p_177417_) {
this.succeedWhenEntityPresent(p_177414_, new BlockPos(p_177415_, p_177416_, p_177417_));
}
public void succeedWhenEntityPresent(EntityType<?> p_177419_, BlockPos p_177420_) {
this.succeedWhen(() -> this.assertEntityPresent(p_177419_, p_177420_));
}
public void succeedWhenEntityNotPresent(EntityType<?> p_177427_, int p_177428_, int p_177429_, int p_177430_) {
this.succeedWhenEntityNotPresent(p_177427_, new BlockPos(p_177428_, p_177429_, p_177430_));
}
public void succeedWhenEntityNotPresent(EntityType<?> p_177432_, BlockPos p_177433_) {
this.succeedWhen(() -> this.assertEntityNotPresent(p_177432_, p_177433_));
}
public void succeed() {
this.testInfo.succeed();
}
private void ensureSingleFinalCheck() {
if (this.finalCheckAdded) {
throw new IllegalStateException("This test already has final clause");
} else {
this.finalCheckAdded = true;
}
}
public void succeedIf(Runnable p_177280_) {
this.ensureSingleFinalCheck();
this.testInfo.createSequence().thenWaitUntil(0L, p_177280_).thenSucceed();
}
public void succeedWhen(Runnable p_177362_) {
this.ensureSingleFinalCheck();
this.testInfo.createSequence().thenWaitUntil(p_177362_).thenSucceed();
}
public void succeedOnTickWhen(int p_177118_, Runnable p_177119_) {
this.ensureSingleFinalCheck();
this.testInfo.createSequence().thenWaitUntil(p_177118_, p_177119_).thenSucceed();
}
public void runAtTickTime(long p_177128_, Runnable p_177129_) {
this.testInfo.setRunAtTickTime(p_177128_, p_177129_);
}
public void runAfterDelay(long p_177307_, Runnable p_177308_) {
this.runAtTickTime(this.testInfo.getTick() + p_177307_, p_177308_);
}
public void randomTick(BlockPos p_177447_) {
BlockPos blockpos = this.absolutePos(p_177447_);
ServerLevel serverlevel = this.getLevel();
serverlevel.getBlockState(blockpos).randomTick(serverlevel, blockpos, serverlevel.random);
}
public void tickBlock(BlockPos p_396550_) {
BlockPos blockpos = this.absolutePos(p_396550_);
ServerLevel serverlevel = this.getLevel();
serverlevel.getBlockState(blockpos).tick(serverlevel, blockpos, serverlevel.random);
}
public void tickPrecipitation(BlockPos p_311105_) {
BlockPos blockpos = this.absolutePos(p_311105_);
ServerLevel serverlevel = this.getLevel();
serverlevel.tickPrecipitation(blockpos);
}
public void tickPrecipitation() {
AABB aabb = this.getRelativeBounds();
int i = (int)Math.floor(aabb.maxX);
int j = (int)Math.floor(aabb.maxZ);
int k = (int)Math.floor(aabb.maxY);
for (int l = (int)Math.floor(aabb.minX); l < i; l++) {
for (int i1 = (int)Math.floor(aabb.minZ); i1 < j; i1++) {
this.tickPrecipitation(new BlockPos(l, k, i1));
}
}
}
public int getHeight(Heightmap.Types p_236775_, int p_236776_, int p_236777_) {
BlockPos blockpos = this.absolutePos(new BlockPos(p_236776_, 0, p_236777_));
return this.relativePos(this.getLevel().getHeightmapPos(p_236775_, blockpos)).getY();
}
public void fail(Component p_397357_, BlockPos p_177291_) {
throw this.assertionException(p_177291_, p_397357_);
}
public void fail(Component p_393216_, Entity p_177288_) {
throw this.assertionException(p_177288_.blockPosition(), p_393216_);
}
public void fail(Component p_391587_) {
throw this.assertionException(p_391587_);
}
public void failIf(Runnable p_177393_) {
this.testInfo.createSequence().thenWaitUntil(p_177393_).thenFail(() -> this.assertionException("test.error.fail"));
}
public void failIfEver(Runnable p_177411_) {
LongStream.range(this.testInfo.getTick(), this.testInfo.getTimeoutTicks()).forEach(p_177365_ -> this.testInfo.setRunAtTickTime(p_177365_, p_177411_::run));
}
public GameTestSequence startSequence() {
return this.testInfo.createSequence();
}
public BlockPos absolutePos(BlockPos p_177450_) {
BlockPos blockpos = this.testInfo.getTestOrigin();
BlockPos blockpos1 = blockpos.offset(p_177450_);
return StructureTemplate.transform(blockpos1, Mirror.NONE, this.testInfo.getRotation(), blockpos);
}
public BlockPos relativePos(BlockPos p_177453_) {
BlockPos blockpos = this.testInfo.getTestOrigin();
Rotation rotation = this.testInfo.getRotation().getRotated(Rotation.CLOCKWISE_180);
BlockPos blockpos1 = StructureTemplate.transform(p_177453_, Mirror.NONE, rotation, blockpos);
return blockpos1.subtract(blockpos);
}
public AABB absoluteAABB(AABB p_369302_) {
Vec3 vec3 = this.absoluteVec(p_369302_.getMinPosition());
Vec3 vec31 = this.absoluteVec(p_369302_.getMaxPosition());
return new AABB(vec3, vec31);
}
public AABB relativeAABB(AABB p_369720_) {
Vec3 vec3 = this.relativeVec(p_369720_.getMinPosition());
Vec3 vec31 = this.relativeVec(p_369720_.getMaxPosition());
return new AABB(vec3, vec31);
}
public Vec3 absoluteVec(Vec3 p_177228_) {
Vec3 vec3 = Vec3.atLowerCornerOf(this.testInfo.getTestOrigin());
return StructureTemplate.transform(vec3.add(p_177228_), Mirror.NONE, this.testInfo.getRotation(), this.testInfo.getTestOrigin());
}
public Vec3 relativeVec(Vec3 p_251543_) {
Vec3 vec3 = Vec3.atLowerCornerOf(this.testInfo.getTestOrigin());
return StructureTemplate.transform(p_251543_.subtract(vec3), Mirror.NONE, this.testInfo.getRotation(), this.testInfo.getTestOrigin());
}
public Rotation getTestRotation() {
return this.testInfo.getRotation();
}
public void assertTrue(boolean p_249380_, Component p_393681_) {
if (!p_249380_) {
throw this.assertionException(p_393681_);
}
}
public <N> void assertValueEqual(N p_328559_, N p_332683_, Component p_397042_) {
if (!p_328559_.equals(p_332683_)) {
throw this.assertionException("test.error.value_not_equal", p_397042_, p_328559_, p_332683_);
}
}
public void assertFalse(boolean p_277974_, Component p_392338_) {
this.assertTrue(!p_277974_, p_392338_);
}
public long getTick() {
return this.testInfo.getTick();
}
public AABB getBounds() {
return this.testInfo.getStructureBounds();
}
private AABB getRelativeBounds() {
AABB aabb = this.testInfo.getStructureBounds();
Rotation rotation = this.testInfo.getRotation();
switch (rotation) {
case COUNTERCLOCKWISE_90:
case CLOCKWISE_90:
return new AABB(0.0, 0.0, 0.0, aabb.getZsize(), aabb.getYsize(), aabb.getXsize());
default:
return new AABB(0.0, 0.0, 0.0, aabb.getXsize(), aabb.getYsize(), aabb.getZsize());
}
}
public void forEveryBlockInStructure(Consumer<BlockPos> p_177293_) {
AABB aabb = this.getRelativeBounds().contract(1.0, 1.0, 1.0);
BlockPos.MutableBlockPos.betweenClosedStream(aabb).forEach(p_177293_);
}
public void onEachTick(Runnable p_177424_) {
LongStream.range(this.testInfo.getTick(), this.testInfo.getTimeoutTicks()).forEach(p_177283_ -> this.testInfo.setRunAtTickTime(p_177283_, p_177424_::run));
}
public void placeAt(Player p_261595_, ItemStack p_262007_, BlockPos p_261973_, Direction p_262008_) {
BlockPos blockpos = this.absolutePos(p_261973_.relative(p_262008_));
BlockHitResult blockhitresult = new BlockHitResult(Vec3.atCenterOf(blockpos), p_262008_, blockpos, false);
UseOnContext useoncontext = new UseOnContext(p_261595_, InteractionHand.MAIN_HAND, blockhitresult);
p_262007_.useOn(useoncontext);
}
public void setBiome(ResourceKey<Biome> p_312755_) {
AABB aabb = this.getBounds();
BlockPos blockpos = BlockPos.containing(aabb.minX, aabb.minY, aabb.minZ);
BlockPos blockpos1 = BlockPos.containing(aabb.maxX, aabb.maxY, aabb.maxZ);
Either<Integer, CommandSyntaxException> either = FillBiomeCommand.fill(
this.getLevel(), blockpos, blockpos1, this.getLevel().registryAccess().lookupOrThrow(Registries.BIOME).getOrThrow(p_312755_)
);
if (either.right().isPresent()) {
throw this.assertionException("test.error.set_biome");
}
}
}