From 3cea5de769b3a844e68eeee26450c47de1d4f2d8 Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Tue, 6 Oct 2026 13:48:50 +0200 Subject: [PATCH] Connect feature-region scheduling to resident chunk tick queues --- .../scoped-parity.json | 204 ++++++++++++++++++ .../examples/feature_region_fixture.rs | 46 +++- .../src/worldgen/feature_region.rs | 125 ++++++++++- crates/horizon-world/src/worldgen/terrain.rs | 17 ++ docs/rust-parity.md | 17 ++ .../parity/VanillaFeatureRegionOracle.java | 31 ++- tools/test_feature_region_parity.py | 14 +- 7 files changed, 448 insertions(+), 6 deletions(-) create mode 100644 benchmarks/rust-feature-region-ticks-2026-10-06/scoped-parity.json diff --git a/benchmarks/rust-feature-region-ticks-2026-10-06/scoped-parity.json b/benchmarks/rust-feature-region-ticks-2026-10-06/scoped-parity.json new file mode 100644 index 000000000..87ab83c24 --- /dev/null +++ b/benchmarks/rust-feature-region-ticks-2026-10-06/scoped-parity.json @@ -0,0 +1,204 @@ +{ + "schema": 1, + "minecraft": "26.3", + "manifest_sha1": "4fe1aa1ef8da1cb95c5bad1fb98890ca56dd8ca3", + "platform": "Linux-7.0.0-31-generic-x86_64-with-glibc2.43", + "java": "openjdk 25.0.4.1 2026-08-18", + "rustc": "rustc 1.99.0 (b940084d7 2026-09-28)", + "block_states": 35723, + "block_tag_files": 300, + "fixtures": 192, + "worldgen_random_modes": [ + false, + true + ], + "resident_chunks_per_fixture": 9, + "requested_placements": 2688, + "direct_tick_requests": 14784, + "sources_sha256": { + "mods/horizon/src/test/java/dev/horizonlab/parity/VanillaFeatureRegionOracle.java": "f1d53f2378d4db192ae2d3a0a21027da121dbc16567fe83dbd3e2219d76c81f6", + "mods/horizon/src/test/java/dev/horizonlab/parity/VanillaHeightmapOracle.java": "145c943637ed177cc4ef8a85f2484da8afd164868e84a8463882feec1653a860", + "mods/horizon/src/test/java/dev/horizonlab/parity/VanillaPlacementOracle.java": "12b1c46cc397755ef6827da777faef3e71c008cafa48403669c03ca2bdc3c7cb", + "tools/test_feature_region_parity.py": "d4188a05763c7540a3d997e22c9ef7b87c2c5bc571dc4867a36758124cc59eb7", + "tools/test_rust_parity.py": "29d3db08005873528894b45ca10dcd6278753650473b3eb574e53e06ede40ec6", + "tools/test_worldgen_parity.py": "b40972ab2ad222aa6d77537cc36b434a217baa1f1b56bbaad945d6e12fe776af", + "tools/lab.py": "d00bf107fa01b6c579734a082c3ca4ade3018f0d6851d46844acf17574f66e64", + "Cargo.toml": "dc370d5fdde37238c3e4820046f11c3201020406a4edfa1308257c13edbdcda4", + "Cargo.lock": "7307d0c887364db36d327685ecf0671b75305e31e5ba5fbdcdbb15eaf156d20e", + "crates/horizon-core/Cargo.toml": "e21b502c949da93cf67826592459b687a8cbf737ef92fee514e3ed2cc7cd27ad", + "crates/horizon-world/Cargo.toml": "977338bf3e654193685b015d383493b9f59ff6f5d6210bec212cef8ac4a50bed", + "crates/horizon-core/src/bin/density_parity.rs": "e5b1dd33b7d01306c73cf072629b4fb186e9ab87b672a00108999d1a72263fd0", + "crates/horizon-core/src/bin/float_log_parity.rs": "4a655fcf8822ee7668c4bd126bc84d0b118864a6fc7f5a6aeee667d8bf2590b1", + "crates/horizon-core/src/bin/geometry_parity.rs": "27f6c09fe5018ac3de8e70e0f0bbf78f9abb14f5e4783bcaf46e8ca87b9c6f8a", + "crates/horizon-core/src/bin/noise_parity.rs": "c135bfc708d853e7061e81487d2cfe10de64b2f65677d3b4837cbfe0b8341010", + "crates/horizon-core/src/bin/parity.rs": "f35d928c66f958de39fac5e7e836a657eed95f83599e84899f7ea7a5802ba481", + "crates/horizon-core/src/bin/tick_parity.rs": "a54c164fe4814034d369947a887f5273966f5a878ba849204b80d1c729526a8f", + "crates/horizon-core/src/biome/seed_hash.rs": "5afbb4921c750826b395a08bf06f382fc7f01b5759a93de02a2749c523e2a317", + "crates/horizon-core/src/biome.rs": "908efa8cd4aa0a7adf1cb5e1a222e3dfb640eed5e9172e0fe7f0d1287afae7e8", + "crates/horizon-core/src/carving/ellipsoid.rs": "09232a7588610e8a9176fd9c62d40afb1fb89f2ecab6d555536a1d847b142d86", + "crates/horizon-core/src/carving.rs": "0aa3093caa0437868a8c0ed52a6c6e1993bd51c03583c670a2837e749eae5426", + "crates/horizon-core/src/density/arithmetic.rs": "372faec96c923e2cf4aa6c66c1ac398e676853274557823850dbc8933dd15ab1", + "crates/horizon-core/src/density/beardifier.rs": "bb1052e27dae4a01954ca78d7d5babafef85f3b2c704ccaf1920cb85a098cb50", + "crates/horizon-core/src/density/cache.rs": "38d0b6c9dd04ffef979fdad3f29cfebf98d331c8c9d430be5f39aa34f6c30975", + "crates/horizon-core/src/density/end_islands.rs": "168b9384237bd2e41d0ae5a74e944da4dc74e493bdec31fb73184c9a49e3de55", + "crates/horizon-core/src/density/graph/compiler.rs": "ac67deeb16f16d0859aa20e5a165811a29aca0b910037ee6bf5098211f3a6ede", + "crates/horizon-core/src/density/graph/mod.rs": "b776e7da934cb03051a3053d56d461c71e9978e084922fe4194147aa580c07bf", + "crates/horizon-core/src/density/graph/seeded.rs": "6bcdcaa3dffcfa9df673bbbea35120057a16ba3d2b506c52709c36cf8976b74a", + "crates/horizon-core/src/density/graph/tests.rs": "6bfb8cbff462587dd147b0775ea01d370abbd97544b9bd596c792df1b5f7e634", + "crates/horizon-core/src/density/interpolation.rs": "8c890f52b6467f38a94c654986a6a484b8e0b296ab98c398e60a6ce465b5b010", + "crates/horizon-core/src/density/interval.rs": "b42629163baa6b599a233afe8596d1c370cd81d015cc6fc36a9663aa47b98424", + "crates/horizon-core/src/density/mod.rs": "ca0d77d3282e3746ddcbc92bee97dbf640b9a56214e6ac1537f51f9a5b63d6e7", + "crates/horizon-core/src/density/power.rs": "d5b7270a128d4264268cd772109ad16d71a8ec3ff2d3b63b84cb985296d54a91", + "crates/horizon-core/src/density/rounding.rs": "71840c5206ff8d218ac29bf6f66915d5212764ba270c675711a866ba5b55a7a6", + "crates/horizon-core/src/density/selection.rs": "0dd26af2e85004ec5e053039ad11c384c17c56ace9ab45eb3f5cb3503c0b0330", + "crates/horizon-core/src/density/slice.rs": "5d77605573c0deda47778f1f78f7fa3fbf1944d8f5efbcc65cf589181cadf80b", + "crates/horizon-core/src/density/spline.rs": "6bb2e40f940fc6544d6fb09cb0b8cac722be03bc663dbdfb0f61faae207400bc", + "crates/horizon-core/src/density/surface.rs": "159e0e69cda74f870e80ea64fe523c4397e64af4ccb861bb9fd07b2c3cb91b00", + "crates/horizon-core/src/density/terrain_noise.rs": "8d0059d25eb5d248cb97a4c5a2e670d61528928ea151495c004f25adb723fe3e", + "crates/horizon-core/src/density/tests.rs": "7817796ee40d0ae241bfbebec6bca190e0a8e7d5a1caa8ddf858c3eaa58b8858", + "crates/horizon-core/src/density/world_fields.rs": "c1ce305cb8046b384d90c564cafb24af7365d580389637910f3d8b0cc18eb583", + "crates/horizon-core/src/geometry/mod.rs": "dc92f73885dd0a7760743bf74f1ab8afa839d61cef2dfef890f8a23b67b4742e", + "crates/horizon-core/src/geometry/movement.rs": "930e34abef6f6eeec1ee7a6c920b5ba01bfe37b90678884490f4be53241f6b96", + "crates/horizon-core/src/geometry/shape/create.rs": "189812b91d5e0e3ad963afcd1a6e2831b31b8188df91a904ef27061e644806ad", + "crates/horizon-core/src/geometry/shape/face.rs": "f243bce81384040a95ce7984b02b5699206c596c537b2713097e86005b4d3a5c", + "crates/horizon-core/src/geometry/shape/join.rs": "f1b51887b7bf9482557e3ffa99e136f2e5db07ceeb05fdb116adf45e87129075", + "crates/horizon-core/src/geometry/shape.rs": "e8d88a763de1525f77a30b99591641e8a8b80946263acbde035a9bcc356df960", + "crates/horizon-core/src/geometry/sweep.rs": "abd6009c61555161ef2f18b431b2aa384b126c0871cae8b96a62358498a56a1d", + "crates/horizon-core/src/geometry/traversal.rs": "77a3da570a0b85582b669cf4d841cba4b06327006dda26d4a26df4e8ce05bae4", + "crates/horizon-core/src/geometry/trig.rs": "05cef9341a298a474221a0556a11ddf47650393ea7a97b4b2022a4da6628fe37", + "crates/horizon-core/src/lib.rs": "47350edab5791f5074a54563ba98108818c5c6b1c5818a591388eab2ac9f5490", + "crates/horizon-core/src/noise/mod.rs": "1dab5a713abf702402e69ace1bf9e476bba544b0ede5a61c3c3afc60af0a03f3", + "crates/horizon-core/src/noise/normal.rs": "e9e7a46472a54a02c98c46da819842090567153b32fe0c84249009ef19af7aad", + "crates/horizon-core/src/noise/perlin.rs": "e73815447432eab7542f67366cb3f1b368d164e33f6c9cdbd045ac8e4db0932a", + "crates/horizon-core/src/noise/simplex.rs": "6c0dbc15b2b7510195dd28fceca01dcaac1847ccc4a84d299c351589c642fe7a", + "crates/horizon-core/src/noise/stack.rs": "7f6ef0e7d920139ef1a6ad3ec5640f92765715f86dcc5ec29f1a149984f45fa3", + "crates/horizon-core/src/noise/volume.rs": "3f05d2b1780acfdfee60037677d309937a5033b45ef428fc2d540942d4b56b43", + "crates/horizon-core/src/position/iter.rs": "32d2d8e74821cc4e49e3354202d35d3120e4415bfdda9375a73f2137ef651129", + "crates/horizon-core/src/position.rs": "e10101088e6902386b9b6d27773d44312f1ff72bebb19e57967a54945dde9dcd", + "crates/horizon-core/src/random/hash.rs": "0f88a127a1ba2705d3d6c0ebd009324d6ba86ffa2d27edf2d2a84765e690e4a3", + "crates/horizon-core/src/random/positional.rs": "35494745e5d4cf89e282c3ae0ee245e9f2640ddbbc03bc0055df742006a9c862", + "crates/horizon-core/src/random/worldgen.rs": "9f07ff33bcc038d34e27aa5465753bb21df18f2975e43cae201f709bc186945a", + "crates/horizon-core/src/random.rs": "ddb95d3a83e28ad605ff1f49f5df270cc543ca5ef1130e37d989dc74c8d861e6", + "crates/horizon-core/src/storage.rs": "f6c32201c64aefde06e57a2c767be46918df613548a322801546b133799cc33d", + "crates/horizon-core/src/ticks/generation.rs": "be1237e790693f633a61714ddae68c6506a777588a8a3ab5efbe53a35774dbd2", + "crates/horizon-core/src/ticks/heap.rs": "bf28afab8af77c3d243aa96cd8a1fb8d934140a4dbd07dbfdbf4e7908bb4b845", + "crates/horizon-core/src/ticks/index.rs": "1f1a6a568c2a30eafecb020ca4d5f5fc414860de85b8b381fc419a2e3e65c24a", + "crates/horizon-core/src/ticks/mod.rs": "01634630668172516b8b79d0907bad47f6e2c543a6d499c2fa4b201823b375cb", + "crates/horizon-world/src/bin/worldgen_parity.rs": "3143ceb9b56eecfd7667e5feb5f9f0cd13cfb8754b38d4ea338dbba97f2819da", + "crates/horizon-world/src/block_collision.rs": "cec2af81d212d5eed7a2196e4cf0be2daf4cecf53248f78cc68f2190e4d83f9a", + "crates/horizon-world/src/block_placement.rs": "524f4892d50bab77b7d89d19f7b048ffe746996f2ed7f376db2c6ab00ed75c24", + "crates/horizon-world/src/block_properties.rs": "b0bd8a983336c48e488a20caa77dd5c39b1a74bbd14ebc03b3b64556a1c864fc", + "crates/horizon-world/src/block_support.rs": "ade4fbd47284b450dabdd682dc86138b2ac05a0fd379525d7110648908245476", + "crates/horizon-world/src/block_survival.rs": "28ce64375e09819a4f13da9cfbe37c08b5ad0daf01b289c1c360b4567e50e811", + "crates/horizon-world/src/chunk.rs": "8843e6f48dbbc4245ce4e95564dfba3a4d7a051ba0b1577fb038c07adb0ff0f9", + "crates/horizon-world/src/collision.rs": "05313e0c1f3089524fe029f9aac3e439cd47f1c9584c8c7e154c9adcfa88c335", + "crates/horizon-world/src/compression.rs": "4db73e6ca9a0d552d415ce60e7e88b89c9cf2b7d060a669ff8328f518316e101", + "crates/horizon-world/src/dynamic_support.rs": "e799b31e5120cfdb04e0b342f2097d610ed98ef8c4be031620ee00368d82df59", + "crates/horizon-world/src/entity_obstruction.rs": "a4b28a19bf83b23611c59d94535c488db37e4aee24b22c973c545910894a809f", + "crates/horizon-world/src/fluid.rs": "a0a1f34ba94d8b59dc975becee8952960764d67ae08cf2d6a8bcd40a614b15c4", + "crates/horizon-world/src/heightmap.rs": "a5edef082b5af40d814421ea17e129b3b06d70abee6434ed263e4bba58571698", + "crates/horizon-world/src/lib.rs": "a8cd85f6223668c1446ff103276d80937b9707d9a7dc619a176b1b1ceed36a4a", + "crates/horizon-world/src/main.rs": "fce57418b8c22a6a0a9044baa89ed3d9c243bc2e8413fea3ff0f32985daba021", + "crates/horizon-world/src/nbt.rs": "60262c3de8c8f68bc2da0370ccb17393d32b85f5f5022c6358599a7d32119ea6", + "crates/horizon-world/src/piston_shape.rs": "399c2337103b8e7e0eb5667227c5aa14f9549d6a467b7be7da3d0717f0263500", + "crates/horizon-world/src/region.rs": "72b642e87fed37ed17f54d4c30f96c3b64d26c14bc0589c31ef40ff1616188fc", + "crates/horizon-world/src/registry/json.rs": "1eae82604d2b3377fd35aaa3a914a67e5af28f93923815a49e895b4d437433cd", + "crates/horizon-world/src/registry.rs": "f2e58b2b4d944ac8fc6226bd3352cefc3d2052d8473e02ccf7dc402b176df435", + "crates/horizon-world/src/tick_data.rs": "f8d04a69ea263f4168bce33f92e5b4ee2fe07d7caf50a1621c6b3ef6eb2479f3", + "crates/horizon-world/src/worldgen/anchor.rs": "d156b8a0b147a274cdd143409b441f4f43edecde6e8ee14ef9cf0309f743143a", + "crates/horizon-world/src/worldgen/aquifer/config.rs": "fcd2cc3a520c1527c88f095a3b5d38487e7ebb1ccecc5f757f93d04a069add4f", + "crates/horizon-world/src/worldgen/aquifer/noise_based.rs": "74daaa389b5c3dfdc99214dfff256a9e172f83548d2326cbc941d9637cc53fb7", + "crates/horizon-world/src/worldgen/aquifer.rs": "cb4b66d87de3f9f79ae6ffe4badd6f0f44886cd42ad9de2771b8b56c4f1e28c7", + "crates/horizon-world/src/worldgen/bamboo.rs": "d9b47113c99be34256e58308bc6f40072ff25c579d6bf995182aa862c0006102", + "crates/horizon-world/src/worldgen/biome.rs": "3fe316b875aa32683759c337dc71f624910faf0812a2d6d83b8098d6d0bac7a0", + "crates/horizon-world/src/worldgen/biome_chunk.rs": "d6389c8d1adf900eb8f0e6c8833feafe43dc92d74e5c7ffa6f3950975529d624", + "crates/horizon-world/src/worldgen/biome_predicate.rs": "bfc581bc40077cc74ffda43e990a55fe997adc04c7130f98e039c3305ca79aac", + "crates/horizon-world/src/worldgen/biome_source/codec.rs": "2b9e4f5d679eb444cb73174f511e3b9f32e9eb138248ab12cffc6cfd76adf3a8", + "crates/horizon-world/src/worldgen/biome_source/runtime.rs": "f0b02c1521178e4d0377c6ca62694604b6a773f1f234f070ff0cde4685911d45", + "crates/horizon-world/src/worldgen/biome_source.rs": "e181e1736f3e0b75f7091a24c88de3fd116e01b98424d02382aea7a503d1eb54", + "crates/horizon-world/src/worldgen/biome_temperature.rs": "cde4bbab5e260c4065b113376c423b8511ade93c5aa5fd976e245ee8a58b5ad1", + "crates/horizon-world/src/worldgen/biome_weather.rs": "96b1f9494559ed31d06257b83d604d00cc069ccc8c7b68094117e034b4a71bd7", + "crates/horizon-world/src/worldgen/block_blob.rs": "c608c57b3d77279646ecb89e50677dd8e452b0422ffd357ba755536c5589eb89", + "crates/horizon-world/src/worldgen/block_column.rs": "f72c21a9066ee0aa68c2fb79fba436d05afb14c6ef5a2cb012f1ed35fc17cd22", + "crates/horizon-world/src/worldgen/block_feature.rs": "5ce5c6eaa5f8a2557a620e533788217b1eb430654801dcf6135d6c92d7a012ac", + "crates/horizon-world/src/worldgen/block_pile.rs": "623e369b77e0526ed2756485a6c0bb09683cd28ad8876dea907360ca6665b39d", + "crates/horizon-world/src/worldgen/block_predicate.rs": "074c692367e3f2191a1bb28d87b23402430a843c246bd30a4ea838ee3500280e", + "crates/horizon-world/src/worldgen/blue_ice.rs": "eedd77bdaff808330b864166d303378096daa5c7d235e925770b171c05109247", + "crates/horizon-world/src/worldgen/bulk_section.rs": "eecf61532d7793f853884c5a18a7f436a59835c7b13d3ec9075804511553c9ba", + "crates/horizon-world/src/worldgen/carver/canyon.rs": "509c4d5a9d689849e98e894ab14a9fbf82d10707d38e9cc688ded3c4778df3e2", + "crates/horizon-world/src/worldgen/carver/generation.rs": "a4498d0d1457536de3922a08e9c40ccce8d2ef9cc263801c15a412327513c098", + "crates/horizon-world/src/worldgen/carver.rs": "46b251e28225fe1250de38f49dec5dacda4e2c4ba1e556e21e6d1e14e2651fc3", + "crates/horizon-world/src/worldgen/carving.rs": "4e77d4e5c4a0ca55ca3563b9bdf6f379342e0bdf9d019d60f7bc57ce4afb5fbd", + "crates/horizon-world/src/worldgen/climate/codec.rs": "d567adeb5d837816fca69102db51d790f71aec1b51c09298230d24612e400a14", + "crates/horizon-world/src/worldgen/climate/index.rs": "c5ce61679a5f0e0f2f0af2a373424effa124d0cce8250609eff38b7034650756", + "crates/horizon-world/src/worldgen/climate.rs": "1b9ad44407f40aee4c1cd5357a5c9c443c1b105728f01cf5c644072f99f8357e", + "crates/horizon-world/src/worldgen/decoration.rs": "75a79b20b21e133816e729f16e758be6165d0db18a64bfbd5fd3618325a2adf3", + "crates/horizon-world/src/worldgen/delta.rs": "c2bf49ddf3231d28c109e68871429bc13d76a7bebe14eb33e84aa856bdd66145", + "crates/horizon-world/src/worldgen/density.rs": "65a98c156a290a6b374ef670d28cd5dfbe0aa93171824d1bbd96422536273f84", + "crates/horizon-world/src/worldgen/disk.rs": "6f8f9e059755af44c9bfa1b91eba54a7d13fad811dce31717c5502d7f6df33d7", + "crates/horizon-world/src/worldgen/end_podium.rs": "8f6d0d6d60ff0fde63de5781e867239db321f82cf12639f0537d410a3731ee1d", + "crates/horizon-world/src/worldgen/feature.rs": "40500af71ee6628dfb27518262d99f08d0383ae6c7b9397452feef0c213eadd9", + "crates/horizon-world/src/worldgen/feature_catalog.rs": "efc7b17b227e71622ef34108be9abd010f5675b68ea0409fcab82581d9aab88a", + "crates/horizon-world/src/worldgen/feature_graph.rs": "98bc93dff1373e3b6f4dcf8c4c2b05b56814acd4f66302834aa5877fe90ec7b9", + "crates/horizon-world/src/worldgen/feature_region.rs": "39c29f24c3f08081533cb2ec4f5ef5a4cd891b112055234fe1ed8dafc2ea4cf7", + "crates/horizon-world/src/worldgen/feature_sort.rs": "3488a093dfe1321aaa29d8a30cfb115d8e666a81bf195514e87b170de626835c", + "crates/horizon-world/src/worldgen/fluid_predicate.rs": "e682d13a21f90605215b79f5d254bf2e524d35e89eab2e3b46384709af80b847", + "crates/horizon-world/src/worldgen/height_provider.rs": "368d4dc119854742a045c4a717679c921456da681fc5f71aa9b37102d6f33b47", + "crates/horizon-world/src/worldgen/material_condition/codec.rs": "09b909bc384472f76d163c8069ec6b507c7d5c6a028a36d5e0e3df20deff7b3b", + "crates/horizon-world/src/worldgen/material_condition/density.rs": "df9d0761e978e5010663ae8b44f2d6c1ecb4907331e333bdb6a2b487c1e107de", + "crates/horizon-world/src/worldgen/material_condition/library.rs": "a55534c5da97575a819af5a7dc0dbec9069993fa8b2619c6c9d5576946e683fa", + "crates/horizon-world/src/worldgen/material_condition/noise.rs": "ffb59cc6be2275d7a5621bf7d768527e74a8326ed7ad78618746711540921675", + "crates/horizon-world/src/worldgen/material_condition/rule.rs": "fed643352efbcb1f68f29b6241896617db889fc7c577a6247564e01922fec1fe", + "crates/horizon-world/src/worldgen/material_condition.rs": "d638dcb8cbcb5da20b3cb29602b0ae6a86c4fdf9d8c0fb725de8ec5fc108717e", + "crates/horizon-world/src/worldgen/material_extensions.rs": "ab806eb679d5116e1aebb64fca70e1499ae71f83c9507a8cb4c3201c2b1bf037", + "crates/horizon-world/src/worldgen/material_stage.rs": "698cbc786eff13c246e2bc2ea062401918cd4265899fbc3d53abc87e45a8e7a1", + "crates/horizon-world/src/worldgen/material_surface.rs": "5d37b90099df3d6da0845dab164e71469fb287019c2ee74bc6714f3b9d6d6d5b", + "crates/horizon-world/src/worldgen/ore_feature.rs": "83b89fd3be691c5412c0215b6abefdcaa44119a05aa41217e061970eb7e12ebd", + "crates/horizon-world/src/worldgen/placement/chain.rs": "9218399b4d3757f7bbc550d7729a7201f32a1c83a7030865e0c12aab8a80d116", + "crates/horizon-world/src/worldgen/placement/context.rs": "b7a59a712d2e376e8f32ec1e1fd901df452c8019e06910c39d469816be63a14f", + "crates/horizon-world/src/worldgen/placement/layer.rs": "a0f5ca776f33f9d4f72b8fdcd163426152e5e43cb4a7572fc1d4fc57bf965de1", + "crates/horizon-world/src/worldgen/placement.rs": "b0397e5818fae84358546193a95f84bcb0b5bffafce909e6fcb3386179ee8023", + "crates/horizon-world/src/worldgen/replace_blobs.rs": "bf3377d86d2570cd15288ba69dde64a2cf67c5bcbb9a31d0c23421964af74afa", + "crates/horizon-world/src/worldgen/router.rs": "2cee7cf15a0d2ada12be6b39d83e78177fd3033922e4f4cce87a64073cec2847", + "crates/horizon-world/src/worldgen/rule_test.rs": "d1662ec492489ebaa4b87e20f9a8c809dcf3a223a151211bd65ec241a63692fc", + "crates/horizon-world/src/worldgen/settings.rs": "a8fe87752e1982ef11cb67f8d80d8e3428b2c27db178044cb425ba803e689e59", + "crates/horizon-world/src/worldgen/simple_block.rs": "9ba1a88d5db4925f8c37366557887f776c805f9a6444781615b5dbaff52e92a4", + "crates/horizon-world/src/worldgen/snow_freeze.rs": "9040be3d5c7f8f0fd812d2df45e154bf8a9eeef038530b83fa4159d246eac35f", + "crates/horizon-world/src/worldgen/spike.rs": "eacf0d9d3d2bc3d4bcf62bc87555f90031138236a5bfef0eb5270204f7c2a4fc", + "crates/horizon-world/src/worldgen/spring.rs": "830849e9b89fcdf09e9b06fbefdcdebe3c8c3f82804f60b8bd5de04ba303cb62", + "crates/horizon-world/src/worldgen/state_provider/catalog.rs": "c8687e15a4887a9200c8d365857d801efaa8f90e669eee3e600a1db4905119eb", + "crates/horizon-world/src/worldgen/state_provider/noise.rs": "7ee369c2a032e5620cb9bdf9ee7adad1f70870fb0a27efb7b7c514d92f83491f", + "crates/horizon-world/src/worldgen/state_provider/properties.rs": "9909139aaca1dc4f743957257fadaa9d423d21fa401fa9abc050505f79365139", + "crates/horizon-world/src/worldgen/state_provider.rs": "be29ada818826a90afe01ab60916360fdfc4cbde5af15c9359cd56b1f1f7b156", + "crates/horizon-world/src/worldgen/tags.rs": "d35ded93fe6e95ea045cadcf4925e656dc34ef832b742179b9ad0cc49f902f31", + "crates/horizon-world/src/worldgen/terrain.rs": "b8fb9fb80a66a851d916f07f15df1a40b6cc95b49e71aaec4d4b4107f13d9f9f", + "crates/horizon-world/src/worldgen/underwater_magma.rs": "7317e40af5ee5a9780f90ce358fa5d3e7f5b3d513b731df6ff97754d9c2a0154", + "crates/horizon-world/src/worldgen/value_provider.rs": "3358b563db8cb0bc8a9cfbbe2b8b3e70941cd2d37a0b519fbb6545f8d0dcbb69", + "crates/horizon-world/src/worldgen/vines.rs": "ee9b79b65012bd86a838241d2ef708680f7fe8eafc8aa656dae9cf2abf3c6418", + "crates/horizon-world/src/worldgen/weighted.rs": "839840aae25302933bbd97a81a2336330e2d03a0ad1684e1e16ac769ed408e6b", + "crates/horizon-world/src/worldgen.rs": "072d31a3b814eda9cc9bdc1da06a7dab43c38f133824bfd00f55ebb8452d8b88", + "crates/horizon-world/examples/feature_region_fixture.rs": "5650465d2c4274b68b09521725a237b8ecf54e853c9fb76c09364d81ced233d7" + }, + "fixtures_sha256": { + ".local/rust-feature-region-parity/inputs.txt": "b9291d2acd0a9734a6c6facf40602a6464e03643b485e5e3024fffdad32edc3a", + ".local/rust-feature-region-parity/tags.json": "36975358262568f32bf84778d63d9989a36e7394ed4796d70a34809a8f4a64f0", + ".local/rust-feature-region-parity/facts-client.json": "1d24883ee807b0b71473f0bbf8ed548ddaf712148caeb3fcc7aa13ab973a97b0", + ".local/rust-feature-region-parity/facts-server.json": "1d24883ee807b0b71473f0bbf8ed548ddaf712148caeb3fcc7aa13ab973a97b0" + }, + "rust_output_sha256": "7063716bad44d41187315daa2ce66abc7af187efe8c1b28eb13fbf58e3c5f1f4", + "references": [ + { + "side": "client", + "jar_sha256": "4508d006323f24fa02876310c192d739af56516eb259000ac50f0909a68c9a2d", + "output_sha256": "7063716bad44d41187315daa2ce66abc7af187efe8c1b28eb13fbf58e3c5f1f4", + "matched_output_lines": 28985883 + }, + { + "side": "server", + "jar_sha256": "a362163eec5d1612d520772bc16e5b39c09e3b234fdc045f56bf544284ee8ae6", + "output_sha256": "7063716bad44d41187315daa2ce66abc7af187efe8c1b28eb13fbf58e3c5f1f4", + "matched_output_lines": 28985883 + } + ], + "scope": "Native FeaturePlacer and three basic block-writing features, a composed sequence of four configured fill layers, single-block replacements, scattered ore and water springs share a world proxy backed by nine actual ProtoChunks. Configured water, horizontal logs, air, out-of-height fills and ore/replacement rules test graph-to-region binding. Initial two-layer stone/dirt terrain, both pre-light heightmap groups, count/square/heightmap/layered modifier chains, repeated placements, direct and WorldgenRandom-wrapped random streams, missing-neighbor errors, rejected writes and injected partial failures are compared. Final complete raw sections, heightmap presence and packed words are compared alongside ordered feature writes, update flags, explicit height queries and subsequent random draws. Rust uses resident registry-backed chunks, lazy heightmap priming and a caller-supplied write callback; imported air/fluid facts and bundled block tags bind independently across authenticated JARs. The proxy supplies storage mutation and actual native default scheduleTick/createTick methods routed through WorldGenTickAccess into each ProtoChunk. Separate block/fluid queues, first-request deduplication, nondefault-state block identity, shared tick-order advancement on duplicates and missing-chunk errors, out-of-height requests and wrapped clock values are compared, including saved queue order and priorities. Actual WorldGenRegion construction, write-zone policy, POIs, block entities, postprocessing execution, lighting, block/fluid tick execution, complete feature registries and complete world generation remain outside this comparison." +} diff --git a/crates/horizon-world/examples/feature_region_fixture.rs b/crates/horizon-world/examples/feature_region_fixture.rs index 2b3918be3..953b280fb 100644 --- a/crates/horizon-world/examples/feature_region_fixture.rs +++ b/crates/horizon-world/examples/feature_region_fixture.rs @@ -12,6 +12,7 @@ use horizon_world::worldgen::{ use horizon_core::position::ChunkPos; use horizon_world::{ DATA_VERSION, + fluid::FluidKind, heightmap::{HeightmapState, HeightmapType}, nbt::Tag, registry::{BlockRegistry, BlockStateId}, @@ -140,7 +141,11 @@ fn run( chunks.push(chunk); } } - let mut region = TerrainRegion::new(chunks, WorldGenerationContext::new(-64, 64, 0))?; + let mut region = TerrainRegion::new(chunks, WorldGenerationContext::new(-64, 64, 0))? + .with_tick_clock( + f["game_time"].as_i64().unwrap(), + f["tick_order"].as_i64().unwrap(), + ); let blocks = FeatureBlocks::from_registry(registry)?; // These configured fixture states use compact names and an enum property; // no integer-property parsing is requested by this region corpus. @@ -213,9 +218,48 @@ fn run( } writeln!(out, "repeat {repeat}")?; } + for command in f["tick_commands"].as_array().unwrap() { + let kind = command[0].as_str().unwrap(); + let id = n(&command[1]) as u32; + let p = std::array::from_fn(|i| n(&command[2][i])); + let delay = n(&command[3]); + writeln!(out, "tickrequest {kind} {id}")?; + let result = if kind == "block" { + region.schedule_block_tick(p, BlockStateId(id), delay) + } else { + region.schedule_fluid_tick(p, FluidKind::ALL[id as usize], delay) + }; + writeln!( + out, + "tickresult {}", + if result.is_ok() { "ok" } else { "error" } + )?; + writeln!(out, "tickorder {}", region.tick_clock().1)?; + } for chunk in region.chunks() { let p = chunk.position(); writeln!(out, "chunk {} {}", p.x, p.z)?; + writeln!(out, "blockticks {}", chunk.block_ticks().count())?; + for tick in chunk.block_ticks().pack(region.tick_clock().0) { + writeln!( + out, + "bt {} {} {} {} {} {}", + tick.kind.0, tick.pos.x, tick.pos.y, tick.pos.z, tick.delay, tick.priority as i8 + )?; + } + writeln!(out, "fluidticks {}", chunk.fluid_ticks().count())?; + for tick in chunk.fluid_ticks().pack(region.tick_clock().0) { + writeln!( + out, + "ft {} {} {} {} {} {}", + FluidKind::ALL[tick.kind.0 as usize].name(), + tick.pos.x, + tick.pos.y, + tick.pos.z, + tick.delay, + tick.priority as i8 + )?; + } for kind in HeightmapType::ALL { if let Some(map) = chunk.heightmap(kind) { writeln!(out, "map {}", kind.name())?; diff --git a/crates/horizon-world/src/worldgen/feature_region.rs b/crates/horizon-world/src/worldgen/feature_region.rs index 783537df1..d5e967fa2 100644 --- a/crates/horizon-world/src/worldgen/feature_region.rs +++ b/crates/horizon-world/src/worldgen/feature_region.rs @@ -9,15 +9,24 @@ use super::{ terrain::{PreLightChunkStage, TerrainBlockStates, TerrainChunk, TerrainError}, }; use crate::{ + fluid::FluidKind, heightmap::{HeightmapState, HeightmapType}, registry::BlockStateId, + tick_data::TickKind, +}; +use horizon_core::{ + position::BlockPos, + ticks::{ + ProtoChunkTicks, ScheduledTick, TickPriority, TickTypeId, WorldGenTickAccess, + WorldGenTickContainers, + }, }; -use horizon_core::position::BlockPos; use std::collections::BTreeMap; #[derive(Debug)] pub enum RegionError { InvalidChunks, + InvalidTickState(BlockStateId), MissingChunk([i32; 2]), Terrain(TerrainError), Biome(BiomeRegionError), @@ -45,6 +54,8 @@ pub struct TerrainRegion<'r, B: TerrainBlockStates> { height: i32, generation: WorldGenerationContext, sea_level: i32, + game_time: i64, + next_tick_order: i64, } impl<'r, B: TerrainBlockStates> TerrainRegion<'r, B> { pub fn new( @@ -71,6 +82,8 @@ impl<'r, B: TerrainBlockStates> TerrainRegion<'r, B> { Ok(Self { chunks: stored, sea_level: generator.sea_level, + game_time: 0, + next_tick_order: 0, min_y, height, generation: WorldGenerationContext::with_generator( @@ -82,6 +95,52 @@ impl<'r, B: TerrainBlockStates> TerrainRegion<'r, B> { ), }) } + /// Supply the owning world's current time and region-local next tick order. + pub fn with_tick_clock(mut self, game_time: i64, next_tick_order: i64) -> Self { + self.game_time = game_time; + self.next_tick_order = next_tick_order; + self + } + pub fn tick_clock(&self) -> (i64, i64) { + (self.game_time, self.next_tick_order) + } + pub fn set_game_time(&mut self, game_time: i64) { + self.game_time = game_time; + } + pub fn schedule_tick( + &mut self, + kind: TickKind, + tick: ScheduledTick, + ) -> Result { + WorldGenTickAccess::new(RegionTickContainers { region: self, kind }).schedule(tick) + } + pub fn has_scheduled_tick( + &mut self, + kind: TickKind, + position: BlockPos, + tick_type: TickTypeId, + ) -> Result { + WorldGenTickAccess::new(RegionTickContainers { region: self, kind }) + .has_scheduled(position, tick_type) + } + fn request_tick( + &mut self, + kind: TickKind, + position: [i32; 3], + tick_type: TickTypeId, + delay: i32, + ) -> Result<(), RegionError> { + let tick = ScheduledTick { + kind: tick_type, + pos: BlockPos::new(position[0], position[1], position[2]), + trigger_tick: self.game_time.wrapping_add(i64::from(delay)), + priority: TickPriority::Normal, + sub_tick_order: self.next_tick_order, + }; + self.next_tick_order = self.next_tick_order.wrapping_add(1); + self.schedule_tick(kind, tick)?; + Ok(()) + } /// Override world sea level without changing generator placement anchors. pub fn with_world_sea_level(mut self, sea_level: i32) -> Self { self.sea_level = sea_level; @@ -142,7 +201,54 @@ impl<'r, B: TerrainBlockStates> TerrainRegion<'r, B> { .set_block_worldgen(x, y, z, state)?) } } +struct RegionTickContainers<'a, 'r, B: TerrainBlockStates> { + region: &'a mut TerrainRegion<'r, B>, + kind: TickKind, +} +impl WorldGenTickContainers for RegionTickContainers<'_, '_, B> { + type Container = ProtoChunkTicks; + type Error = RegionError; + fn container_at(&mut self, p: BlockPos) -> Result<&mut ProtoChunkTicks, RegionError> { + let chunk = self.region.chunk_mut(p.x >> 4, p.z >> 4)?; + Ok(match self.kind { + TickKind::Block => chunk.block_ticks_mut(), + TickKind::Fluid => chunk.fluid_ticks_mut(), + }) + } +} impl PlacementContext for TerrainRegion<'_, B> { + fn schedule_block_tick( + &mut self, + position: [i32; 3], + block: BlockStateId, + delay: i32, + ) -> Result<(), PlacementQueryError> { + let registry = self + .chunks + .first_key_value() + .expect("nonempty region") + .1 + .registry(); + let state = registry + .state(block) + .ok_or(RegionError::InvalidTickState(block))?; + // Default state IDs provide one identity per block, separate from fluids. + let block = registry + .default_state(&state.name) + .ok_or(RegionError::InvalidTickState(block))?; + self.request_tick(TickKind::Block, position, TickTypeId(block.0), delay) + .map_err(Into::into) + } + fn schedule_fluid_tick( + &mut self, + position: [i32; 3], + fluid: FluidKind, + delay: i32, + ) -> Result<(), PlacementQueryError> { + self.request_tick(TickKind::Fluid, position, TickTypeId(fluid as u32), delay) + .map_err(Into::into) + } + fn sea_level(&mut self) -> Result { Ok(self.sea_level) } @@ -208,6 +314,23 @@ impl<'a, 'r, B: TerrainBlockStates, F> TerrainFeatureAccess<'a, 'r, B, F> { } } impl PlacementContext for TerrainFeatureAccess<'_, '_, B, F> { + fn schedule_block_tick( + &mut self, + position: [i32; 3], + block: BlockStateId, + delay: i32, + ) -> Result<(), PlacementQueryError> { + self.region.schedule_block_tick(position, block, delay) + } + fn schedule_fluid_tick( + &mut self, + position: [i32; 3], + fluid: FluidKind, + delay: i32, + ) -> Result<(), PlacementQueryError> { + self.region.schedule_fluid_tick(position, fluid, delay) + } + fn sea_level(&mut self) -> Result { self.region.sea_level() } diff --git a/crates/horizon-world/src/worldgen/terrain.rs b/crates/horizon-world/src/worldgen/terrain.rs index 9daf04cb7..3c716cf6d 100644 --- a/crates/horizon-world/src/worldgen/terrain.rs +++ b/crates/horizon-world/src/worldgen/terrain.rs @@ -13,6 +13,7 @@ use horizon_core::{ noise::DensityVolume, position::ChunkPos, random::PositionalRandom, + ticks::ProtoChunkTicks, }; use std::io; @@ -106,6 +107,8 @@ pub struct TerrainChunk<'r, B: TerrainBlockStates> { blocks: TerrainBlocks<'r, B>, heightmaps: [Option; 6], postprocessing: Vec>, + block_ticks: ProtoChunkTicks, + fluid_ticks: ProtoChunkTicks, } /// The persisted generation statuses before lighting initialization. This models /// their block-write heightmap selection, not scheduling or persisted metadata. @@ -235,6 +238,8 @@ impl<'r, B: TerrainBlockStates> TerrainChunk<'r, B> { }, heightmaps: std::array::from_fn(|_| None), postprocessing: vec![Vec::new(); section_count], + block_ticks: ProtoChunkTicks::default(), + fluid_ticks: ProtoChunkTicks::default(), }) } pub(crate) fn registry(&self) -> &BlockRegistry { @@ -312,6 +317,18 @@ impl<'r, B: TerrainBlockStates> TerrainChunk<'r, B> { pub fn heightmap(&self, kind: HeightmapType) -> Option<&Heightmap> { self.heightmaps[kind as usize].as_ref() } + pub fn block_ticks(&self) -> &ProtoChunkTicks { + &self.block_ticks + } + pub fn block_ticks_mut(&mut self) -> &mut ProtoChunkTicks { + &mut self.block_ticks + } + pub fn fluid_ticks(&self) -> &ProtoChunkTicks { + &self.fluid_ticks + } + pub fn fluid_ticks_mut(&mut self) -> &mut ProtoChunkTicks { + &mut self.fluid_ticks + } pub fn postprocessing(&self) -> &[Vec] { &self.postprocessing } diff --git a/docs/rust-parity.md b/docs/rust-parity.md index 806104da9..1d18e695d 100644 --- a/docs/rust-parity.md +++ b/docs/rust-parity.md @@ -677,3 +677,20 @@ priority boundaries and integer/time extremes. Workspace tests, all-target Clipp and all 149 Python tests pass. Rust exposes packed entries as an immutable borrowed slice; mutating Java's returned list is outside this API. Feature-world scheduling integration and block/fluid tick execution remain pending. + +## Resident generation tick queues + +Resident terrain chunks now own separate block and fluid proto-tick queues. +Feature-world scheduling normalizes block states to block identity, routes to the +chunk containing the original position and advances the region's tick order even +for duplicate requests or missing chunks. Time and order use Java wrapping rules. + +The [resident queue comparison](../benchmarks/rust-feature-region-ticks-2026-10-06/scoped-parity.json) +matches **28,985,883 lines per reference JAR** across **192 fixtures**, with nine +resident chunks each, **2,688 requested feature placements** and **14,784 direct +tick requests**. Both references agree on final sections, heightmaps and saved +ticks. Coverage includes spring scheduling, duplicate block identities, separate +fluid identities, missing chunks, out-of-height positions and time/order overflow. +Workspace tests and all-target Clippy pass. This connects generation-stage queues; +block/fluid tick execution, complete chunk persistence and full world-generation +effects remain pending. diff --git a/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaFeatureRegionOracle.java b/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaFeatureRegionOracle.java index a7831c06b..39535438f 100644 --- a/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaFeatureRegionOracle.java +++ b/mods/horizon/src/test/java/dev/horizonlab/parity/VanillaFeatureRegionOracle.java @@ -7,6 +7,10 @@ import java.nio.charset.StandardCharsets; import java.nio.file.*; import java.util.*; import net.minecraft.core.*; +import net.minecraft.core.registries.*; +import net.minecraft.resources.*; +import net.minecraft.world.ticks.*; +import net.minecraft.world.level.material.*; import net.minecraft.util.RandomSource; import net.minecraft.world.level.*; import net.minecraft.world.level.biome.*; @@ -23,6 +27,7 @@ public final class VanillaFeatureRegionOracle { private static ProtoChunk chunk(Map chunks,int x,int z) { var chunk=chunks.get(new ChunkPos(x>>4,z>>4));if(chunk==null)throw new IllegalArgumentException("missing region chunk");return chunk; } + @SuppressWarnings("unchecked") public static void main(String[] args) throws Exception { if(args[0].equals("export")){VanillaHeightmapOracle.main(args);return;} net.minecraft.SharedConstants.tryDetectVersion();net.minecraft.server.Bootstrap.bootStrap(); @@ -34,11 +39,17 @@ public final class VanillaFeatureRegionOracle { var contextMethod=VanillaPlacementOracle.class.getDeclaredMethod("context",JsonObject.class);contextMethod.setAccessible(true); var bounds=new JsonObject();bounds.add("context",JsonParser.parseString("[-64,64,0]")); var generator=((PlacementContext)contextMethod.invoke(null,bounds)).generator(); + var ops=RegistryOps.create(JsonOps.INSTANCE,new RegistryOps.RegistryInfoLookup(){public Optional> lookup(ResourceKey> key){ + if(key.equals(Registries.BLOCK))return (Optional>)(Optional)Optional.of(BuiltInRegistries.BLOCK); + if(key.equals(Registries.FLUID))return (Optional>)(Optional)Optional.of(BuiltInRegistries.FLUID); + return Optional.empty(); + }}); + var fluids=new Fluid[]{Fluids.EMPTY,Fluids.FLOWING_WATER,Fluids.WATER,Fluids.FLOWING_LAVA,Fluids.LAVA}; try(var out=new PrintWriter(Files.newBufferedWriter(dir.resolve(args[0]+".txt"),StandardCharsets.UTF_8))) { for(var line:Files.readAllLines(dir.resolve("inputs.txt"))) { var f=JsonParser.parseString(line).getAsJsonObject();long seed=f.get("seed").getAsLong(); var features=new ArrayList(); - for(var value:f.getAsJsonArray("features"))features.add(Feature.DIRECT_CODEC.parse(JsonOps.INSTANCE,value).getOrThrow()); + for(var value:f.getAsJsonArray("features"))features.add(Feature.DIRECT_CODEC.parse(ops,value).getOrThrow()); RandomSource random=f.get("legacy").getAsBoolean()?new LegacyRandomSource(seed):new XoroshiroRandomSource(seed); if(f.get("worldgen").getAsBoolean())random=new WorldgenRandom(random); var chunks=new TreeMap(Comparator.comparingInt(p->p.x()).thenComparingInt(p->p.z())); @@ -51,8 +62,16 @@ public final class VanillaFeatureRegionOracle { } chunks.put(cp,chunk); } + var blockTicks=new WorldGenTickAccess(p->chunk(chunks,p.getX(),p.getZ()).getBlockTicks()); + var fluidTicks=new WorldGenTickAccess(p->chunk(chunks,p.getX(),p.getZ()).getFluidTicks()); + long[] tickOrder={f.get("tick_order").getAsLong()}; int[] calls={0};int fail=f.get("fail").getAsInt(),reject=f.get("reject").getAsInt(); var world=(WorldGenLevel)Proxy.newProxyInstance(WorldGenLevel.class.getClassLoader(),new Class[]{WorldGenLevel.class},(proxy,method,values)->switch(method.getName()) { + case "getBlockTicks"->blockTicks; + case "getFluidTicks"->fluidTicks; + case "getGameTime"->f.get("game_time").getAsLong(); + case "nextSubTickCount"->tickOrder[0]++; + case "scheduleTick","createTick","isEmptyBlock"->InvocationHandler.invokeDefault(proxy,method,values); case "getMinY"->-64; case "getSeaLevel"->0; case "getHeight"->{ @@ -82,8 +101,18 @@ public final class VanillaFeatureRegionOracle { } out.println("repeat "+repeat); } + for(var raw:f.getAsJsonArray("tick_commands")){ + var command=raw.getAsJsonArray();String kind=command.get(0).getAsString();int id=command.get(1).getAsInt();var xyz=command.get(2).getAsJsonArray();var p=new BlockPos(xyz.get(0).getAsInt(),xyz.get(1).getAsInt(),xyz.get(2).getAsInt());int delay=command.get(3).getAsInt(); + out.println("tickrequest "+kind+" "+id); + try{if(kind.equals("block"))world.scheduleTick(p,Block.stateById(id).getBlock(),delay);else world.scheduleTick(p,fluids[id],delay);out.println("tickresult ok");}catch(RuntimeException error){out.println("tickresult error");} + out.println("tickorder "+tickOrder[0]); + } for(var entry:chunks.entrySet()) { var cp=entry.getKey();var chunk=entry.getValue();out.println("chunk "+cp.x()+" "+cp.z()); + out.println("blockticks "+chunk.getBlockTicks().count()); + for(var tick:((SerializableTickContainer)chunk.getBlockTicks()).pack(f.get("game_time").getAsLong()))out.println("bt "+Block.getId(tick.type().defaultBlockState())+" "+tick.pos().getX()+" "+tick.pos().getY()+" "+tick.pos().getZ()+" "+tick.delay()+" "+tick.priority().getValue()); + out.println("fluidticks "+chunk.getFluidTicks().count()); + for(var tick:((SerializableTickContainer)chunk.getFluidTicks()).pack(f.get("game_time").getAsLong()))out.println("ft "+BuiltInRegistries.FLUID.getKey(tick.type())+" "+tick.pos().getX()+" "+tick.pos().getY()+" "+tick.pos().getZ()+" "+tick.delay()+" "+tick.priority().getValue()); for(var kind:Heightmap.Types.values()) { if(chunk.hasPrimedHeightmap(kind)){out.println("map "+kind.name());for(long word:chunk.getOrCreateHeightmapUnprimed(kind).getRawData())out.println(Long.toUnsignedString(word,16));} else out.println("missing "+kind.name()); diff --git a/tools/test_feature_region_parity.py b/tools/test_feature_region_parity.py index c65ba734a..45f53cdd3 100644 --- a/tools/test_feature_region_parity.py +++ b/tools/test_feature_region_parity.py @@ -22,6 +22,14 @@ def corpus(facts): layers=[{'feature':{'type':'fill_layer','height':height,'state':state},'placement':[]} for height,state in [(32,'water'),(16,{'id':'oak_log','properties':{'axis':'x'}}),(8,'air'),(4064,'stone')]] targets=[{'target':{'predicate_type':'block_match','block':'stone'},'state':'iron_ore'},{'target':{'predicate_type':'block_match','block':'oak_log'},'state':'copper_ore'}] features=leaves+[{'type':'sequence','features':layers},{'type':'replace_single_block','targets':targets},{'type':'scattered_ore','targets':targets,'size':16,'discard_chance_on_air_exposure':0.5}] + features.append({'type':'spring_feature','state':{'id':'water','properties':{'falling':'false'}},'requires_block_below':False,'rock_count':5,'hole_count':5,'valid_blocks':['air','stone','dirt']}) + get=lambda name:facts['defaults']['minecraft:'+name] + log_x=next(i for i,state in enumerate(facts['states']) if state[4]['id']=='minecraft:oak_log' and state[4].get('properties',{}).get('axis')=='x') + ticks=[] + for p in [[0,-40,0],[-1,-64,-1],[16,100,16],[32,0,0],[-17,0,0],[2147483647,-2147483648,0]]: + for kind,value in [('block',get('water')),('fluid',2),('block',log_x),('block',get('oak_log'))]: + for delay in [-2147483648,0,2147483647]:ticks.append([kind,value,p,delay]) + for kind in range(5):ticks.append(['fluid',kind,[0,-40,0],-1]) chains=[ [{'type':'count','count':2},{'type':'in_square'},{'type':'heightmap','heightmap':'MOTION_BLOCKING'}], [{'type':'count_on_every_layer','count':1},{'type':'offset','x':0,'y':1,'z':0}], @@ -34,7 +42,7 @@ def corpus(facts): for reject in [0,3]: for placement in chains: for worldgen in [False,True]: - yield {'worldgen':worldgen,'legacy':legacy,'seed':seed,'stage':stage,'fail':fail,'reject':reject,'placement':placement,'features':features} + yield {'worldgen':worldgen,'legacy':legacy,'seed':seed,'stage':stage,'fail':fail,'reject':reject,'placement':placement,'features':features,'tick_commands':ticks,'game_time':9223372036854775807 if worldgen else -9223372036854775808,'tick_order':9223372036854775803 if legacy else -9223372036854775808} def main(): @@ -83,9 +91,9 @@ def main(): base.ensure_sources_unchanged(sources,tested_sources);base.ensure_sources_unchanged(fixture_paths,tested_fixtures) report={"schema":1,"minecraft":lock["minecraft"]["version"],"manifest_sha1":lock["minecraft"]["manifest_sha1"],"platform":platform.platform(), "java":subprocess.check_output(["java","--version"],text=True).splitlines()[0],"rustc":subprocess.check_output(["rustc","--version"],text=True).strip(), - "block_states":len(facts["states"]),"block_tag_files":len(tags),"fixtures":len(fixtures),"worldgen_random_modes":[False,True],"resident_chunks_per_fixture":9,"requested_placements":sum(len(f["features"])*2 for f in fixtures), + "block_states":len(facts["states"]),"block_tag_files":len(tags),"fixtures":len(fixtures),"worldgen_random_modes":[False,True],"resident_chunks_per_fixture":9,"requested_placements":sum(len(f["features"])*2 for f in fixtures),"direct_tick_requests":sum(len(f["tick_commands"]) for f in fixtures), "sources_sha256":tested_sources,"fixtures_sha256":tested_fixtures,"rust_output_sha256":lab.digest(build/"rust.txt","sha256"),"references":references, - "scope":"Native FeaturePlacer and three basic block-writing features, a composed sequence of four configured fill layers, single-block replacements and scattered ore share a world proxy backed by nine actual ProtoChunks. Configured water, horizontal logs, air, out-of-height fills and ore/replacement rules test graph-to-region binding. Initial two-layer stone/dirt terrain, both pre-light heightmap groups, count/square/heightmap/layered modifier chains, repeated placements, direct and WorldgenRandom-wrapped random streams, missing-neighbor errors, rejected writes and injected partial failures are compared. Final complete raw sections, heightmap presence and packed words are compared alongside ordered feature writes, update flags, explicit height queries and subsequent random draws. Rust uses resident registry-backed chunks, lazy heightmap priming and a caller-supplied write callback; imported air/fluid facts and bundled block tags bind independently across authenticated JARs. The proxy supplies storage mutation only. Actual WorldGenRegion construction, write-zone policy, POIs, block entities, postprocessing effects, lighting, complete feature registries and complete world generation remain outside this comparison."} + "scope":"Native FeaturePlacer and three basic block-writing features, a composed sequence of four configured fill layers, single-block replacements, scattered ore and water springs share a world proxy backed by nine actual ProtoChunks. Configured water, horizontal logs, air, out-of-height fills and ore/replacement rules test graph-to-region binding. Initial two-layer stone/dirt terrain, both pre-light heightmap groups, count/square/heightmap/layered modifier chains, repeated placements, direct and WorldgenRandom-wrapped random streams, missing-neighbor errors, rejected writes and injected partial failures are compared. Final complete raw sections, heightmap presence and packed words are compared alongside ordered feature writes, update flags, explicit height queries and subsequent random draws. Rust uses resident registry-backed chunks, lazy heightmap priming and a caller-supplied write callback; imported air/fluid facts and bundled block tags bind independently across authenticated JARs. The proxy supplies storage mutation and actual native default scheduleTick/createTick methods routed through WorldGenTickAccess into each ProtoChunk. Separate block/fluid queues, first-request deduplication, nondefault-state block identity, shared tick-order advancement on duplicates and missing-chunk errors, out-of-height requests and wrapped clock values are compared, including saved queue order and priorities. Actual WorldGenRegion construction, write-zone policy, POIs, block entities, postprocessing execution, lighting, block/fluid tick execution, complete feature registries and complete world generation remain outside this comparison."} lab.write_json(report_path,report);print(f"Scoped feature-region parity passed: {report_path}")