#include "evo/world/generation.hpp" #include #include #include #include #include #include namespace { using namespace evo::world; void check(bool condition, std::source_location at = std::source_location::current()) { if (!condition) { throw std::runtime_error("world generation line " + std::to_string(at.line())); } } #define CHECK(...) check(static_cast(__VA_ARGS__)) template bool refused(const std::expected& r, GenerationError e) { return !r && r.error() == e; } std::uint64_t fingerprint(const std::vector& cells) { std::uint64_t result = 14695981039346656037ULL; for (const auto cell : cells) { for (const auto value : {cell.material().value, cell.fill()}) { for (unsigned shift = 0; shift < 16; shift += 8) { result = (result ^ ((value >> shift) & 255U)) * 1099511628211ULL; } } } return result; } struct Golden { std::uint64_t seed; ChunkAddress address; std::uint64_t hash; }; // Frozen from the independent Python integer oracle, before running C++ generation. constexpr std::array goldens{{ {0ULL, {0, 0, 0}, 14125776257468910697ULL}, {0ULL, {-1, -1, -1}, 7242967182163540465ULL}, {0ULL, {-2, 3, 0}, 4316025128172914782ULL}, {0ULL, {4, -3, -1}, 1854350054262447477ULL}, {123456ULL, {0, 0, 0}, 448061536662205469ULL}, {123456ULL, {-1, -1, -1}, 14519177808023994198ULL}, {123456ULL, {-2, 3, 0}, 7503881715723395046ULL}, {123456ULL, {4, -3, -1}, 10763600219040791926ULL}, {18446744073709551615ULL, {0, 0, 0}, 9340024193566171638ULL}, {18446744073709551615ULL, {-1, -1, -1}, 17378676633817032737ULL}, {18446744073709551615ULL, {-2, 3, 0}, 521055241663119581ULL}, {18446744073709551615ULL, {4, -3, -1}, 6558335077292188849ULL}, }}; void frozen_and_order_independent() { for (std::size_t reverse = goldens.size(); reverse > 0; --reverse) { const auto g = goldens[reverse - 1]; const auto first = generate_base_chunk({g.seed}, g.address); CHECK(first && first->size() == base_chunk_cells && fingerprint(*first) == g.hash); const auto unrelated = generate_base_chunk({g.seed ^ 123U}, {9, -10, 2}); CHECK(unrelated); const auto again = generate_base_chunk({g.seed}, g.address); CHECK(again && *again == *first); } for (const auto g : goldens) { const auto result = generate_base_chunk({g.seed}, g.address); CHECK(result && fingerprint(*result) == g.hash); } } void samples_seams_and_materials() { // Independent rectangular enumeration straddles negative and positive chunk // faces on all axes. A halo sample from either side has one global definition. for (std::int64_t cz = -2; cz <= 1; ++cz) { for (std::int64_t cy = -2; cy <= 1; ++cy) { for (std::int64_t cx = -2; cx <= 1; ++cx) { const auto chunk = generate_base_chunk({73}, {cx, cy, cz}); CHECK(chunk); std::size_t index = 0; for (std::int64_t z = 0; z < 16; ++z) { for (std::int64_t y = 0; y < 16; ++y) { for (std::int64_t x = 0; x < 16; ++x) { const auto point = base_sample({73}, {cx * 16 + x, cy * 16 + y, cz * 16 + z}); CHECK(point && *point == (*chunk)[index++]); CHECK(material_name(1, point->material())); CHECK(point->fill() == (point->material().value == 0 ? 0 : fill_scale)); } } } } } } // Test stratigraphy independently of hash implementation by locating the // first void cell; exactly three regolith cells must lie immediately below. for (std::int64_t x = -32; x <= 32; ++x) { std::int64_t height = -12; while (height <= 8) { const auto at = base_sample({91}, {x, -x, height}); CHECK(at); if (at->material().value == 0) { break; } ++height; } CHECK(height >= -8 && height <= 7); for (std::int64_t z = -16; z <= 16; ++z) { const auto at = base_sample({91}, {x, -x, z}); CHECK(at && at->material().value == (z >= height ? 0 : (z >= height - 3 ? 2 : 1))); } } CHECK(*material_name(1, {0}) == "void"); CHECK(*material_name(1, {1}) == "rock"); CHECK(*material_name(1, {2}) == "regolith"); } void rejection_and_extremes() { using E = GenerationError; constexpr auto lo = std::numeric_limits::min(); constexpr auto hi = std::numeric_limits::max(); for (const auto version : {0U, 2U, std::numeric_limits::max()}) { for (unsigned field = 0; field < 4; ++field) { BaseDescriptor d{}; E error{}; switch (field) { case 0: d.coordinate_version = version; error = E::unsupported_coordinates; break; case 1: d.generator_version = version; error = E::unsupported_generator; break; case 2: d.material_version = version; error = E::unsupported_materials; break; default: d.edge = version; error = E::unsupported_edge; break; } CHECK(refused(base_sample(d, {hi, lo, 0}), error)); CHECK(refused(generate_base_chunk(d, {hi, lo, 0}), error)); } CHECK(refused(material_name(version, {0}), E::unsupported_materials)); } for (const auto edge : {8U, 32U, 64U}) { BaseDescriptor d{}; d.edge = edge; CHECK(refused(generate_base_chunk(d, {}), E::unsupported_edge)); } for (const auto id : {3U, 65535U}) { CHECK(refused(material_name(1, {static_cast(id)}), E::unknown_material)); } for (const auto bad : {lo, hi, -voxel_limit - 1, voxel_limit}) { for (const auto a : {VoxelAddress{bad, 0, 0}, VoxelAddress{0, bad, 0}, VoxelAddress{0, 0, bad}}) { CHECK(refused(base_sample({}, a), E::invalid_voxel)); } } constexpr auto limit = voxel_limit / 16; for (const auto bad : {lo, hi, -limit - 1, limit}) { for (const auto a : {ChunkAddress{bad, 0, 0}, ChunkAddress{0, bad, 0}, ChunkAddress{0, 0, bad}}) { CHECK(refused(generate_base_chunk({}, a), E::invalid_chunk)); } } for (const auto x : {-limit, limit - 1}) { for (const auto y : {-limit, limit - 1}) { for (const auto z : {-limit, limit - 1}) { const auto chunk = generate_base_chunk({}, {x, y, z}); CHECK(chunk && chunk->size() == 4096); CHECK((*chunk)[0] == *base_sample({}, {x * 16, y * 16, z * 16})); CHECK((*chunk)[4095] == *base_sample({}, {x * 16 + 15, y * 16 + 15, z * 16 + 15})); } } } } } // namespace int main() try { frozen_and_order_independent(); samples_seams_and_materials(); rejection_and_extremes(); return 0; } catch (const std::exception& e) { std::fprintf(stderr, "%s\n", e.what()); return 1; } catch (...) { return 1; }