From e019d361d9fc266b0c2e075df6abfc14728b021b Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Sun, 11 Oct 2026 15:43:57 +0200 Subject: [PATCH] WIP: natural spawn oracle and collision lookup (harness in progress) Co-Authored-By: Claude Opus 5.5 --- crates/horizon-client/src/collisions.rs | 88 +++ .../src/mobs/spawn_selection.rs | 9 +- .../parity/VanillaNaturalSpawnOracle.java | 520 ++++++++++++++++++ 3 files changed, 611 insertions(+), 6 deletions(-) create mode 100644 mods/horizon/src/test/java/dev/horizonlab/parity/VanillaNaturalSpawnOracle.java diff --git a/crates/horizon-client/src/collisions.rs b/crates/horizon-client/src/collisions.rs index a7790c283..47b5d7981 100644 --- a/crates/horizon-client/src/collisions.rs +++ b/crates/horizon-client/src/collisions.rs @@ -183,3 +183,91 @@ impl PowderSnowWorld for SceneCollisions<'_, '_> { Ok(false) } } + +/// Collision queries over any block lookup (test worlds without chunks): +/// every chunk is present, nothing is suffocating, no entities collide. +pub struct LookupCollisions<'w, 'r> { + pub block: &'w dyn Fn(i32, i32, i32) -> horizon_world::registry::BlockStateId, + pub binding: &'w BlockCollisionRegistry<'r>, +} +impl BlockCollisionWorld for LookupCollisions<'_, '_> { + type Error = io::Error; + type Chunk = ChunkPos; + fn collision_chunk(&mut self, p: ChunkPos) -> io::Result> { + Ok(Some(p)) + } + fn collision_block(&mut self, _: ChunkPos, p: BlockPos) -> io::Result { + self.binding.collision_block((self.block)(p.x, p.y, p.z)) + } + fn is_suffocating(&mut self, _: ChunkPos, _: CollisionBlock, _: BlockPos) -> io::Result { + Ok(false) + } + fn context_shape( + &mut self, + block: CollisionBlock, + p: BlockPos, + context: &CollisionContext<'_>, + ) -> io::Result { + self.binding + .collision_shape_with_context(self, block.state, p, context) + .map_err(io::Error::other) + } +} +impl EntityMovementWorld for LookupCollisions<'_, '_> { + type Error = io::Error; + fn entity_collisions(&mut self, _: EntityIdentity, _: Aabb) -> io::Result> { + Ok(Vec::new()) + } + fn movement_border(&mut self, _: EntityIdentity, _: Aabb) -> io::Result> { + Ok(None) + } +} +impl DynamicSupportWorld for LookupCollisions<'_, '_> { + type Error = io::Error; + fn shulker_is_closed(&mut self, _: [i32; 3]) -> io::Result> { + Ok(None) + } + fn moving_piston_shape(&mut self, _: [i32; 3]) -> io::Result> { + Ok(None) + } +} +impl DynamicCollisionWorld for LookupCollisions<'_, '_> { + fn shulker_collision_state( + &mut self, + _: [i32; 3], + ) -> io::Result> { + Ok(None) + } +} +impl LiquidCollisionWorld for LookupCollisions<'_, '_> { + type Error = io::Error; + fn entity_liquid_shape(&mut self, _: EntityIdentity) -> io::Result { + Ok(VoxelShape::empty()) + } + fn fluid(&mut self, p: BlockPos) -> io::Result { + FluidState::from_block( + self.binding + .registry() + .state((self.block)(p.x, p.y, p.z)) + .ok_or_else(|| io::Error::other("fluid state outside registry"))?, + ) + } + fn entity_can_stand(&mut self, _: EntityIdentity, _: FluidState) -> io::Result { + Ok(false) + } +} +impl PowderSnowWorld for LookupCollisions<'_, '_> { + type Error = io::Error; + fn powder_snow_entity(&mut self, _: EntityIdentity) -> io::Result { + Ok(PowderSnowEntity { + fall_distance: 0.0, + falling_block: false, + }) + } + fn powder_snow_walkable_tag(&mut self, _: EntityIdentity) -> io::Result { + Ok(false) + } + fn feet_are_leather_boots(&mut self, _: EntityIdentity) -> io::Result { + Ok(false) + } +} diff --git a/crates/horizon-client/src/mobs/spawn_selection.rs b/crates/horizon-client/src/mobs/spawn_selection.rs index 0e6f777a0..d0ab2b67e 100644 --- a/crates/horizon-client/src/mobs/spawn_selection.rs +++ b/crates/horizon-client/src/mobs/spawn_selection.rs @@ -1174,10 +1174,8 @@ fn valid_position_for_type( /// What chunk generation spawning did (for differential tests). #[derive(Clone, Debug, PartialEq)] pub enum GenEvent { - /// A pack: its type and count. - Pack(String, u32), - /// An attempt at the top non-colliding position of a column. - Try([i32; 3]), + /// An attempt at a column (the heightmap lookup). + Column(i32, i32), Spawn(String, [f64; 3], f32), } /// `NaturalSpawner.spawnMobsForChunkGeneration`: creature packs placed on @@ -1212,7 +1210,6 @@ pub fn spawn_mobs_for_chunk_generation = Vec::new(); let mut x = xo + random.next_int_bound(16).unwrap_or(0); @@ -1228,7 +1225,7 @@ pub fn spawn_mobs_for_chunk_generation c) throws Exception { return allocate.invoke(unsafe, c); } + + static void put(Object target, Class owner, String field, Object value) throws Exception { + Field f = owner.getDeclaredField(field); + putObject.invoke(unsafe, target, (long) objectFieldOffset.invoke(unsafe, f), value); + } + + record Box(int x0, int y0, int z0, int x1, int y1, int z1) { + boolean has(int x, int y, int z) { return x >= x0 && x <= x1 && y >= y0 && y <= y1 && z >= z0 && z <= z1; } + static Box parse(String s) { + String[] p = s.split(","); + return new Box(Integer.parseInt(p[0]), Integer.parseInt(p[1]), Integer.parseInt(p[2]), + Integer.parseInt(p[3]), Integer.parseInt(p[4]), Integer.parseInt(p[5])); + } + } + record Start(Structure structure, StructureStart start) {} + + /** finalizeSpawn's random: the same answer every time. */ + static final class Neutral implements RandomSource { + @Override public RandomSource fork() { return this; } + @Override public net.minecraft.world.level.levelgen.PositionalRandomFactory forkPositional() { throw new UnsupportedOperationException(); } + @Override public void setSeed(long seed) {} + @Override public int nextInt() { return 0; } + @Override public int nextInt(int bound) { return 0; } + @Override public long nextLong() { return 0L; } + @Override public boolean nextBoolean() { return false; } + @Override public float nextFloat() { return 0.75F; } + @Override public double nextDouble() { return 0.75; } + @Override public double nextGaussian() { return 0.0; } + } + + static final class Lvl extends ServerLevel { + Lvl() { super(null, null, null, null, null, null, false, 0L, List.of(), false); } + RegistryAccess registries; + List> blocks = new ArrayList<>(); + List> lights = new ArrayList<>(); + List>> biomes = new ArrayList<>(); + Holder biome; + int sky, block, darken, sea; + boolean thunder; + long seed; + Difficulty difficulty; + DimensionType dimensionType; + ResourceKey dimensionKey; + LevelData.RespawnData respawn; + Set unloaded = new HashSet<>(); + List starts = new ArrayList<>(); + List entities = new ArrayList<>(); + List playerList = new ArrayList<>(); + net.minecraft.world.attribute.EnvironmentAttributeSystem attributes; + BiomeManager biomeManager; + WorldBorder border = new WorldBorder(); + GameRules rules; + ServerChunkCache chunkSource; + StructureManager structures; + RandomSource neutral = new Neutral(); + List log; + boolean logColumns; + int next = 1; + @Override public RegistryAccess registryAccess() { return registries; } + @Override public Difficulty getDifficulty() { return difficulty; } + @Override public long getGameTime() { return 0L; } + @Override public int getNextEntityId() { return next++; } + @Override public net.minecraft.world.flag.FeatureFlagSet enabledFeatures() { return net.minecraft.world.flag.FeatureFlags.REGISTRY.allFlags(); } + @Override public BlockState getBlockState(BlockPos pos) { + for (int i = blocks.size() - 1; i >= 0; i--) + if (blocks.get(i).getKey().has(pos.getX(), pos.getY(), pos.getZ())) return blocks.get(i).getValue(); + return Blocks.AIR.defaultBlockState(); + } + @Override public FluidState getFluidState(BlockPos pos) { return getBlockState(pos).getFluidState(); } + int[] light(BlockPos pos) { + for (int i = lights.size() - 1; i >= 0; i--) + if (lights.get(i).getKey().has(pos.getX(), pos.getY(), pos.getZ())) return lights.get(i).getValue(); + return new int[] {sky, block}; + } + @Override public int getBrightness(LightLayer layer, BlockPos pos) { int[] l = light(pos); return layer == LightLayer.SKY ? l[0] : l[1]; } + @Override public int getRawBrightness(BlockPos pos, int darkening) { int[] l = light(pos); return Math.max(l[1], l[0] - darkening); } + @Override public int getSkyDarken() { return darken; } + @Override public boolean isThundering() { return thunder; } + @Override public int getSeaLevel() { return sea; } + @Override public int getHeight(Heightmap.Types type, int x, int z) { + if (logColumns) log.add("col " + x + " " + z); + for (int y = getMaxY(); y >= getMinY(); y--) + if (type.isOpaque().test(getBlockState(new BlockPos(x, y, z)))) return y + 1; + return getMinY(); + } + @Override public long getSeed() { return seed; } + @Override public DimensionType dimensionType() { return dimensionType; } + @Override public ResourceKey dimension() { return dimensionKey; } + Holder biomeAt(int x, int y, int z) { + for (int i = biomes.size() - 1; i >= 0; i--) + if (biomes.get(i).getKey().has(x, y, z)) return biomes.get(i).getValue(); + return biome; + } + @Override public Holder getBiome(BlockPos pos) { return biomeAt(pos.getX(), pos.getY(), pos.getZ()); } + @Override public BiomeManager getBiomeManager() { return biomeManager; } + @Override public net.minecraft.world.attribute.EnvironmentAttributeSystem environmentAttributes() { return attributes; } + @Override public WorldBorder getWorldBorder() { return border; } + @Override public GameRules getGameRules() { return rules; } + @Override public RandomSource getRandom() { return neutral; } + @Override public ServerChunkCache getChunkSource() { return chunkSource; } + @Override public StructureManager structureManager() { return structures; } + @Override public LevelData.RespawnData getRespawnData() { return respawn; } + @Override public boolean canSpawnEntitiesInChunk(ChunkPos pos) { return !unloaded.contains(pos.pack()); } + @Override public DifficultyInstance getCurrentDifficultyAt(BlockPos pos) { return new DifficultyInstance(difficulty, 0L, 0L, 0.0F); } + @Override public BlockGetter getChunkForCollisions(int chunkX, int chunkZ) { return this; } + @Override public boolean containsAnyLiquid(AABB box) { + BlockPos lo = BlockPos.containing(box.minX, box.minY, box.minZ), hi = BlockPos.containing(box.maxX, box.maxY, box.maxZ); + for (BlockPos p : BlockPos.betweenClosed(lo, hi)) if (!getBlockState(p).getFluidState().isEmpty()) return true; + return false; + } + @SuppressWarnings({"unchecked", "rawtypes"}) + @Override public List players() { return playerList; } + @Override public Iterable getAllEntities() { return entities; } + @Override public List getEntities(Entity except, AABB bb, Predicate selector) { + List out = new ArrayList<>(); + for (Entity e : entities) if (e != except && e.getBoundingBox().intersects(bb) && selector.test(e)) out.add(e); + return out; + } + @Override public List getEntities(EntityTypeTest type, AABB bb, Predicate selector) { + List out = new ArrayList<>(); + for (Entity e : entities) { + T t = type.tryCast(e); + if (t != null && e.getBoundingBox().intersects(bb) && selector.test(t)) out.add(t); + } + return out; + } + @Override public boolean addFreshEntity(Entity entity) { entities.add(entity); return true; } + @Override public void addFreshEntityWithPassengers(Entity entity) { entity.getSelfAndPassengers().forEach(this::addFreshEntity); } + @Override public Player getNearestPlayer(double x, double y, double z, double maxDist, boolean filter) { + if (maxDist == -1.0 && !filter) log.add("try " + (int) Math.floor(x) + " " + (int) Math.floor(z)); + return super.getNearestPlayer(x, y, z, maxDist, filter); + } + } + + static final class Chunk extends LevelChunk { + Chunk() { super((Level) null, (ChunkPos) null); } + Lvl level; + ChunkPos at; + @Override public ChunkPos getPos() { return at; } + @Override public BlockState getBlockState(BlockPos pos) { return level.getBlockState(pos); } + @Override public FluidState getFluidState(BlockPos pos) { return level.getFluidState(pos); } + @Override public int getHeight(Heightmap.Types type, int x, int z) { return level.getHeight(type, x, z); } + } + + static final class Source extends ServerChunkCache { + Source() { super(null, null, null, null, null, null, 0, 0, false, null); } + ChunkGenerator generator; + @Override public ChunkGenerator getGenerator() { return generator; } + } + + /** getPlayersCloseForSpawning: none past the natural spawn chunk tracker's 8 chunks, else non-spectators within 128 blocks of the chunk centre. */ + static final class Map2 extends ChunkMap { + Map2() { super(null, null, null, null, null, null, null, null, null, null, 0, false); } + Lvl level; + @Override public List getPlayersCloseForSpawning(ChunkPos pos) { + boolean tracked = false; + for (ServerPlayer p : level.playerList) { + int px = Mth.floor(p.getX()) >> 4, pz = Mth.floor(p.getZ()) >> 4; + if (Math.max(Math.abs(px - pos.x()), Math.abs(pz - pos.z())) <= 8) tracked = true; + } + if (!tracked) return List.of(); + List out = new ArrayList<>(); + for (ServerPlayer p : level.playerList) { + double xd = pos.x() * 16 + 8 - p.getX(), zd = pos.z() * 16 + 8 - p.getZ(); + if (!p.isSpectator() && xd * xd + zd * zd < 16384.0) out.add(p); + } + return out; + } + } + + static final class Structures extends StructureManager { + Structures() { super(null, null, null); } + Lvl level; + List referenced(int x, int z) { + int cx = x >> 4, cz = z >> 4; + List out = new ArrayList<>(); + for (Start s : level.starts) { + BoundingBox b = s.start().getBoundingBox(); + if (b.intersects(cx * 16, cz * 16, cx * 16 + 15, cz * 16 + 15)) out.add(s); + } + return out; + } + @Override public Map getAllStructuresAt(int x, int y, int z) { + Map out = new LinkedHashMap<>(); + for (Start s : referenced(x, z)) out.computeIfAbsent(s.structure(), k -> new LongOpenHashSet()).add(level.starts.indexOf(s)); + return out; + } + @Override public void fillStartsForStructure(Structure structure, LongSet references, Consumer consumer) { + for (long i : references) { + StructureStart start = level.starts.get((int) i).start(); + if (start.isValid()) consumer.accept(start); + } + } + @Override public List startsForStructure(int sectionX, int sectionZ, Structure structure) { + List out = new ArrayList<>(); + for (Start s : referenced(sectionX << 4, sectionZ << 4)) if (s.structure() == structure) out.add(s.start()); + return out; + } + @Override public RegistryAccess registryAccess() { return level.registries; } + } + + static final class Piece extends StructurePiece { + Piece(BoundingBox box) { super(null, 0, box); } + @Override protected void addAdditionalSaveData(StructurePieceSerializationContext context, CompoundTag tag) {} + @Override public void postProcess(WorldGenLevel level, StructureManager structureManager, ChunkGenerator generator, RandomSource random, + BoundingBox chunkBB, ChunkPos chunkPos, BlockPos referencePos) {} + } + + static final class OraclePlayer extends ServerPlayer { + OraclePlayer() { super(null, null, null, null); } + GameType mode; + @Override public boolean isSpectator() { return mode == GameType.SPECTATOR; } + @Override public boolean isCreative() { return mode == GameType.CREATIVE; } + @Override public GameType gameMode() { return mode; } + } + + static String bits(double v) { return Long.toHexString(Double.doubleToRawLongBits(v)); } + static String bits(float v) { return Integer.toHexString(Float.floatToRawIntBits(v)); } + + public static void main(String[] args) throws Exception { + SharedConstants.tryDetectVersion(); + Bootstrap.bootStrap(); + var unsafeField = Class.forName("sun.misc.Unsafe").getDeclaredField("theUnsafe"); + unsafeField.setAccessible(true); + unsafe = unsafeField.get(null); + allocate = unsafe.getClass().getMethod("allocateInstance", Class.class); + putObject = unsafe.getClass().getMethod("putObject", Object.class, long.class, Object.class); + objectFieldOffset = unsafe.getClass().getMethod("objectFieldOffset", Field.class); + var repo = ServerPacksSource.createVanillaTrustedRepository(); + repo.reload(); + repo.setSelected(List.of("vanilla")); + var resources = new MultiPackResourceManager(PackType.SERVER_DATA, repo.openAllSelected()); + var layers = RegistryLayer.createRegistryAccess(); + var staticTags = TagLoader.loadTagsForExistingRegistries(resources, layers.getLayer(RegistryLayer.STATIC)); + var context = TagLoader.buildUpdatedLookups(layers.getAccessForLoading(RegistryLayer.WORLD), staticTags); + RegistryAccess.Frozen world = RegistryDataLoader.load(resources, context, RegistryDataLoader.WORLD_REGISTRIES, Runnable::run).join(); + staticTags.forEach(Registry.PendingTags::apply); + var access = layers.replaceFrom(RegistryLayer.WORLD, world).compositeAccess(); + var biomes = access.lookupOrThrow(Registries.BIOME); + var dimensions = access.lookupOrThrow(Registries.DIMENSION_TYPE); + var blockLookup = access.lookupOrThrow(Registries.BLOCK); + var structureLookup = access.lookupOrThrow(Registries.STRUCTURE); + + Lvl level = (Lvl) alloc(Lvl.class); + level.registries = access; + level.blocks = new ArrayList<>(); + level.lights = new ArrayList<>(); + level.biomes = new ArrayList<>(); + level.unloaded = new HashSet<>(); + level.starts = new ArrayList<>(); + level.entities = new ArrayList<>(); + level.playerList = new ArrayList<>(); + level.border = new WorldBorder(); + level.neutral = new Neutral(); + level.rules = new GameRules(net.minecraft.world.flag.FeatureFlags.REGISTRY.allFlags()); + level.biomeManager = new BiomeManager((x, y, z, sampler) -> level.biome, 0L) { + @Override public Holder getBiome(BlockPos pos) { return level.biomeAt(pos.getX(), pos.getY(), pos.getZ()); } + @Override public Holder getBiome(int x, int y, int z) { return level.biomeAt(x, y, z); } + }; + put(level, Level.class, "isClientSide", false); + Source source = (Source) alloc(Source.class); + source.generator = (ChunkGenerator) alloc(FlatLevelSource.class); + level.chunkSource = source; + Structures structures = (Structures) alloc(Structures.class); + structures.level = level; + level.structures = structures; + Map2 chunkMap = (Map2) alloc(Map2.class); + chunkMap.level = level; + + Method createState = NaturalSpawner.class.getMethod("createState", int.class, ServerLevel.class, NaturalSpawner.ChunkGetter.class, LocalMobCapCalculator.class); + Method canSpawn = NaturalSpawner.SpawnState.class.getDeclaredMethod("canSpawn", EntityType.class, Level.class, BlockPos.class, net.minecraft.world.level.chunk.ChunkAccess.class); + canSpawn.setAccessible(true); + Method afterSpawn = NaturalSpawner.SpawnState.class.getDeclaredMethod("afterSpawn", Mob.class, net.minecraft.world.level.chunk.ChunkAccess.class); + afterSpawn.setAccessible(true); + Method local = NaturalSpawner.SpawnState.class.getDeclaredMethod("canSpawnForCategoryLocal", MobCategory.class, ChunkPos.class); + local.setAccessible(true); + Method randomPos = NaturalSpawner.class.getDeclaredMethod("getRandomPosWithin", Level.class, LevelChunk.class); + randomPos.setAccessible(true); + Field position = Entity.class.getDeclaredField("position"); + + List lines = Files.readAllLines(Path.of(args[0])); + try (var w = new PrintWriter(Files.newBufferedWriter(Path.of(args[1]), StandardCharsets.UTF_8))) { + for (String raw : lines) { + if (raw.isBlank()) continue; + Map c = new LinkedHashMap<>(); + for (String token : raw.trim().split("\\s+")) { + int eq = token.indexOf('='); + if (eq < 0) c.put("name", token); else c.put(token.substring(0, eq), token.substring(eq + 1)); + } + List log = new ArrayList<>(); + level.log = log; + level.logColumns = false; + try { + level.dimensionKey = ResourceKey.create(Registries.DIMENSION, Identifier.parse(c.getOrDefault("dim", "minecraft:overworld"))); + level.dimensionType = dimensions.getOrThrow(ResourceKey.create(Registries.DIMENSION_TYPE, level.dimensionKey.identifier())).value(); + level.blocks.clear(); + for (int i = 0; c.containsKey("k" + i); i++) { + String[] p = c.get("k" + i).split("/", 2); + level.blocks.add(Map.entry(Box.parse(p[0]), net.minecraft.commands.arguments.blocks.BlockStateParser.parseForBlock(blockLookup, p[1], false).blockState())); + } + level.lights.clear(); + for (int i = 0; c.containsKey("l" + i); i++) { + String[] p = c.get("l" + i).split("/", 2); + String[] v = p[1].split(","); + level.lights.add(Map.entry(Box.parse(p[0]), new int[] {Integer.parseInt(v[0]), Integer.parseInt(v[1])})); + } + level.biome = biomes.getOrThrow(ResourceKey.create(Registries.BIOME, Identifier.parse(c.getOrDefault("biome", "minecraft:plains")))); + level.biomes.clear(); + for (int i = 0; c.containsKey("b" + i); i++) { + String[] p = c.get("b" + i).split("/", 2); + level.biomes.add(Map.entry(Box.parse(p[0]), biomes.getOrThrow(ResourceKey.create(Registries.BIOME, Identifier.parse(p[1]))))); + } + level.sky = Integer.parseInt(c.getOrDefault("sky", "15")); + level.block = Integer.parseInt(c.getOrDefault("light", "0")); + level.darken = Integer.parseInt(c.getOrDefault("darken", "0")); + level.thunder = c.getOrDefault("thunder", "0").equals("1"); + level.sea = Integer.parseInt(c.getOrDefault("sea", "63")); + level.seed = Long.parseLong(c.getOrDefault("wseed", "0")); + level.difficulty = Difficulty.byName(c.getOrDefault("difficulty", "normal")); + level.rules.set(net.minecraft.world.level.gamerules.GameRules.SPAWN_MOBS, !c.getOrDefault("rules", "1").equals("0"), null); + level.attributes = net.minecraft.world.attribute.EnvironmentAttributeSystem.builder().addStaticLayers(level).build(); + level.unloaded.clear(); + if (c.containsKey("unloaded")) for (String u : c.get("unloaded").split(";")) { + String[] p = u.split(","); + level.unloaded.add(ChunkPos.pack(Integer.parseInt(p[0]), Integer.parseInt(p[1]))); + } + level.starts.clear(); + for (int i = 0; c.containsKey("s" + i); i++) { + String[] p = c.get("s" + i).split("/", 2); + Structure structure = structureLookup.getValue(Identifier.parse(p[0])); + List pieces = new ArrayList<>(); + for (String b : p[1].split(";")) { + Box bx = Box.parse(b); + pieces.add(new Piece(new BoundingBox(bx.x0(), bx.y0(), bx.z0(), bx.x1(), bx.y1(), bx.z1()))); + } + level.starts.add(new Start(structure, new StructureStart(structure, new ChunkPos(0, 0), 0, new PiecesContainer(pieces)))); + } + String[] r = c.getOrDefault("respawn", "0,-1000,0/minecraft:overworld").split("/"); + String[] rp = r[0].split(","); + level.respawn = new LevelData.RespawnData(GlobalPos.of(ResourceKey.create(Registries.DIMENSION, Identifier.parse(r[1])), + new BlockPos(Integer.parseInt(rp[0]), Integer.parseInt(rp[1]), Integer.parseInt(rp[2]))), 0.0F, 0.0F); + level.playerList.clear(); + for (int i = 0; c.containsKey("p" + i); i++) { + String[] p = c.get("p" + i).split("/"); + String[] v = p[0].split(","); + OraclePlayer player = (OraclePlayer) alloc(OraclePlayer.class); + player.mode = GameType.byName(p.length > 1 ? p[1] : "survival"); + put(player, Entity.class, "position", new Vec3(Double.parseDouble(v[0]), Double.parseDouble(v[1]), Double.parseDouble(v[2]))); + level.playerList.add(player); + } + level.entities.clear(); + for (int i = 0; c.containsKey("e" + i); i++) { + String[] p = c.get("e" + i).split("/"); + String[] v = p[1].split(","); + Entity e = BuiltInRegistries.ENTITY_TYPE.getValue(Identifier.parse(p[0])).create(level, EntitySpawnReason.LOAD); + e.setPos(Double.parseDouble(v[0]), Double.parseDouble(v[1]), Double.parseDouble(v[2])); + if (p.length > 2 && p[2].equals("p") && e instanceof Mob mob) mob.setPersistenceRequired(); + level.entities.add(e); + } + put(level, Level.class, "random", RandomSource.create(Long.parseLong(c.getOrDefault("seed", "0")))); + String mode = c.getOrDefault("mode", "chunk"); + String[] cp = c.getOrDefault("chunk", "0,0").split(","); + Chunk chunk = (Chunk) alloc(Chunk.class); + chunk.level = level; + chunk.at = new ChunkPos(Integer.parseInt(cp[0]), Integer.parseInt(cp[1])); + if (mode.equals("gen")) { + level.logColumns = true; + int n = level.entities.size(); + RandomSource random = RandomSource.create(Long.parseLong(c.getOrDefault("gseed", "0"))); + BlockPos sourcePos = new BlockPos(chunk.at.getMinBlockX(), level.getMaxY(), chunk.at.getMinBlockZ()); + NaturalSpawner.spawnMobsForChunkGeneration(level, sourcePos, chunk.at, random); + level.logColumns = false; + for (Entity e : level.entities.subList(n, level.entities.size())) + if (e.getVehicle() == null) + log.add("spawn " + BuiltInRegistries.ENTITY_TYPE.getKey(e.getType()) + " " + bits(e.getX()) + " " + bits(e.getY()) + " " + bits(e.getZ()) + " " + bits(e.getYRot())); + log.add("next " + random.nextInt(1000)); + } else { + Map chunks = new HashMap<>(); + NaturalSpawner.ChunkGetter getter = (key, consumer) -> { + if (level.unloaded.contains(key)) return; + Chunk k = chunks.computeIfAbsent(key, kk -> { + try { + Chunk made = (Chunk) alloc(Chunk.class); + made.level = level; + made.at = ChunkPos.unpack(kk); + return made; + } catch (Exception ex) { throw new RuntimeException(ex); } + }); + consumer.accept(k); + }; + var state = (NaturalSpawner.SpawnState) createState.invoke(null, Integer.parseInt(c.getOrDefault("chunkcount", "289")), level, getter, new LocalMobCapCalculator(chunkMap)); + NaturalSpawner.SpawnPredicate extra = (type, lvl, pos, ch) -> { + try { + boolean ok = (boolean) canSpawn.invoke(state, type, lvl, pos, ch); + log.add("test " + BuiltInRegistries.ENTITY_TYPE.getKey(type) + " " + pos.getX() + " " + pos.getY() + " " + pos.getZ() + " " + ok); + return ok; + } catch (Exception ex) { throw new RuntimeException(ex); } + }; + NaturalSpawner.AfterSpawnCallback after = (mob, ch) -> { + log.add("spawn " + BuiltInRegistries.ENTITY_TYPE.getKey(mob.getType()) + " " + bits(mob.getX()) + " " + bits(mob.getY()) + " " + bits(mob.getZ()) + " " + bits(mob.getYRot())); + try { afterSpawn.invoke(state, mob, ch); } catch (Exception ex) { throw new RuntimeException(ex); } + }; + if (mode.equals("pos")) { + MobCategory category = MobCategory.valueOf(c.get("cat").toUpperCase(Locale.ROOT)); + String[] sp = c.get("start").split(","); + BlockPos start = new BlockPos(Integer.parseInt(sp[0]), Integer.parseInt(sp[1]), Integer.parseInt(sp[2])); + NaturalSpawner.spawnCategoryForPosition(category, level, chunk, start, extra, after); + } else { + List categories = NaturalSpawner.getFilteredSpawningCategories(state, c.getOrDefault("enemies", "1").equals("1"), c.getOrDefault("persistent", "1").equals("1")); + StringBuilder names = new StringBuilder(); + for (MobCategory m : categories) names.append(names.isEmpty() ? "" : ",").append(m.getSerializedName()); + log.add("cats " + names); + // spawnForChunk, then spawnCategoryForChunk with its start logged. + for (MobCategory category : categories) { + boolean ok = (boolean) local.invoke(state, category, chunk.at); + log.add("local " + category.getSerializedName() + " " + ok); + if (!ok) continue; + BlockPos start = (BlockPos) randomPos.invoke(null, level, chunk); + log.add("start " + category.getSerializedName() + " " + start.getX() + " " + start.getY() + " " + start.getZ()); + if (start.getY() >= level.getMinY() + 1) NaturalSpawner.spawnCategoryForPosition(category, level, chunk, start, extra, after); + } + } + log.add("next " + level.random.nextInt(1000)); + } + w.println(c.get("name") + " " + String.join(" ; ", log)); + } catch (Throwable t) { + Throwable cause = t instanceof InvocationTargetException ite ? ite.getCause() : t; + StringBuilder line = new StringBuilder(c.get("name") + " error " + cause); + if (System.getenv("ORACLE_TRACE") != null) for (var frame : cause.getStackTrace()) line.append("\n at ").append(frame); + w.println(line); + } + } + } + System.exit(0); + } +}