#include "evo/world/environment.hpp" #include #include #include #include #include #include #include #include #include namespace { using namespace evo::world; constexpr WorldIdentity identity{7, 9}; constexpr std::size_t budget = 2'000'000; constexpr std::uint32_t mask = (1U << 0) | (1U << 1) | (1U << 2) | (1U << 7); void check(bool ok, std::source_location at = std::source_location::current()) { if (!ok) throw std::runtime_error("environment view line " + std::to_string(at.line())); } #define CHECK(...) check(static_cast(__VA_ARGS__)) const EnvironmentQuantity& required_field(const std::optional& field, std::source_location at = std::source_location::current()) { if (!field.has_value()) throw std::runtime_error("missing environment field at line " + std::to_string(at.line())); return *field; } template bool refused(const std::expected& r, E e) { return !r && r.error() == e; } struct Fixture { std::unique_ptr fields; std::unique_ptr terrain; std::vector footprint; }; Fixture fixture() { Fixture f; std::vector sites; for (const auto x : {-17, -16, -1, 0, 15, 16}) { f.footprint.push_back({x, 0, -16000}); sites.push_back({f.footprint.back(), {{0}, {0}, {0}, {10}, {20}, {3}}, {1}}); } sites[1].substrate = {2}; const std::array water{6, 0, 12, 18, 24, 30}; const std::uint64_t zero = 0, energy = 72; const FieldOpening opening[]{{Field::water, water}, {Field::phosphorus, {&zero, 1}}, {Field::organic_energy, {&energy, 1}}}; const FieldDefaults defaults{{evo::accounting::Femtograms{0}, evo::accounting::Femtograms{100}, evo::accounting::Femtograms{0}}}; auto fields = FieldStore::create(identity, 1, defaults, sites, opening, budget); CHECK(fields); f.fields = std::move(*fields); auto terrain = ChunkStore::create({}, 32, budget, {{VolumeUnits{100}, VolumeUnits{100}}}); CHECK(terrain); f.terrain = std::move(*terrain); return f; } void load(Fixture& f) { for (auto address : f.footprint) CHECK(f.terrain->load(split(address, base_chunk_edge)->chunk)); } void values_and_order() { auto f = fixture(); const auto empty = f.terrain->snapshot(identity); CHECK(refused(query_environment(*f.fields, *f.terrain, 5, f.footprint, mask), EnvironmentError::missing_chunk)); CHECK(f.terrain->snapshot(identity) == empty); // missing queries never load load(f); const auto terrain_before = f.terrain->snapshot(identity); const auto fields_before = f.fields->snapshot(); auto q = query_environment(*f.fields, *f.terrain, 5, f.footprint, mask); CHECK(q && validate_environment(*q, *f.fields, *f.terrain, 5)); CHECK(q->identity() == identity && q->tick() == 5 && q->field_revision() == 0); CHECK(q->requested_mask() == mask && q->terrain_pitch().value == 1000); CHECK(q->samples().size() == 6); const std::array expected_chunks{-2, -1, -1, 0, 0, 1}; for (std::size_t i = 0; i < 6; ++i) { const auto& s = q->samples()[i]; CHECK(s.voxel == f.footprint[i] && s.chunk.x == expected_chunks[i]); CHECK(s.measure == HabitatMeasure{{200}, {600}}); CHECK(s.terrain.material() == MaterialId{1} && s.terrain.fill() == fill_scale); CHECK(!s.fields[1] && !s.fields[3]); // missing requested N; unrequested organic C CHECK(std::get(required_field(s.fields[2])) == EnvironmentMass{{0}, {0, 1}}); CHECK(std::get(required_field(s.fields[7])).value == 72); CHECK(s.chunk_revision == f.terrain->view(s.chunk)->revision()); } CHECK(std::get(required_field(q->samples()[0].fields[0])) == EnvironmentMass{{6}, {1, 100}}); CHECK(q->samples()[0].moisture_status == MoistureStatus::available); CHECK(q->samples()[0].moisture == WaterSaturation{3, 50}); CHECK(q->samples()[1].habitat.substrate == MaterialId{2}); // no silent substrate reconciliation CHECK(q->samples()[1].moisture_status == MoistureStatus::zero_capacity && !q->samples()[1].moisture); auto reversed = f.footprint; std::reverse(reversed.begin(), reversed.end()); auto reverse = query_environment(*f.fields, *f.terrain, 5, reversed, mask); CHECK(reverse); for (std::size_t i = 0; i < 6; ++i) { CHECK(reverse->samples()[i].voxel == q->samples()[i].voxel); CHECK(reverse->samples()[i].fields == q->samples()[i].fields); CHECK(reverse->samples()[i].moisture == q->samples()[i].moisture); } auto no_water = query_environment(*f.fields, *f.terrain, 5, f.footprint, 1U << 2); CHECK(no_water && no_water->samples()[0].moisture_status == MoistureStatus::not_requested); CHECK(f.terrain->snapshot(identity) == terrain_before && f.fields->snapshot() == fields_before); CHECK(refused(f.fields->water_capacity(6), FieldError::site)); } void freshness() { auto f = fixture(); load(f); auto q = query_environment(*f.fields, *f.terrain, 7, f.footprint, mask); CHECK(q); CHECK( refused(validate_environment(*q, *f.fields, *f.terrain, 8), EnvironmentError::stale_tick)); auto clone = FieldStore::restore(f.fields->snapshot(), identity, budget); CHECK(clone); CHECK(refused(validate_environment(*q, **clone, *f.terrain, 7), EnvironmentError::wrong_owner)); auto terrain_clone = ChunkStore::restore(*f.terrain->snapshot(identity), identity, budget); CHECK(terrain_clone); CHECK(refused(validate_environment(*q, *f.fields, **terrain_clone, 7), EnvironmentError::wrong_owner)); CHECK(!f.fields->transfer(1, Field::water, 1, 2, 1)); CHECK(validate_environment(*q, *f.fields, *f.terrain, 7)); auto unrelated = query_environment(*f.fields, *f.terrain, 7, std::span{f.footprint}.last(1), mask); CHECK(unrelated); CHECK(f.fields->transfer(1, Field::water, 0, 2, 6)); CHECK(refused(validate_environment(*q, *f.fields, *f.terrain, 7), EnvironmentError::stale_fields)); CHECK(refused(validate_environment(*unrelated, *f.fields, *f.terrain, 7), EnvironmentError::stale_fields)); q = query_environment(*f.fields, *f.terrain, 7, f.footprint, mask); CHECK(q); const auto other = f.terrain->load({10, 0, -1000}); CHECK(other && f.terrain->mark_dirty(*other)); CHECK(validate_environment(*q, *f.fields, *f.terrain, 7)); const auto first = f.terrain->view({-2, 0, -1000}); CHECK(first && f.terrain->mark_dirty(*first)); CHECK(refused(validate_environment(*q, *f.fields, *f.terrain, 7), EnvironmentError::stale_terrain)); q = query_environment(*f.fields, *f.terrain, 7, f.footprint, mask); CHECK(q); const auto last = f.terrain->view({1, 0, -1000}); CHECK(last && f.terrain->evict(*last)); CHECK(refused(validate_environment(*q, *f.fields, *f.terrain, 7), EnvironmentError::stale_terrain)); CHECK(f.terrain->load({1, 0, -1000})); CHECK(refused(validate_environment(*q, *f.fields, *f.terrain, 7), EnvironmentError::stale_terrain)); q = query_environment(*f.fields, *f.terrain, 7, f.footprint, mask); CHECK(q); const auto revision = f.terrain->view({0, 0, -1000})->revision(); const CellCut cut{{0, 0, -1000}, {0, 0, 0}, revision, 1}; ExcavationRequest edit{1, 1, {&cut, 1}, 0}; edit.digest = *excavation_digest(edit); CHECK(f.terrain->excavate(edit)); CHECK(refused(validate_environment(*q, *f.fields, *f.terrain, 7), EnvironmentError::stale_terrain)); auto updated = query_environment(*f.fields, *f.terrain, 7, f.footprint, mask); CHECK(updated); CHECK(updated->samples()[3].terrain.fill() == fill_scale - 1); CHECK(updated->samples()[3].fields == q->samples()[3].fields); } void invalid_and_absent() { auto f = fixture(); load(f); CHECK(refused(query_environment(*f.fields, *f.terrain, 0, {}, mask), EnvironmentError::invalid_request)); CHECK(refused(query_environment(*f.fields, *f.terrain, 0, f.footprint, 0), EnvironmentError::invalid_request)); CHECK(refused(query_environment(*f.fields, *f.terrain, 0, f.footprint, 1U << 10), EnvironmentError::invalid_request)); const VoxelAddress missing{1, 0, -16000}, invalid{std::numeric_limits::min(), 0, 0}; CHECK(refused(query_environment(*f.fields, *f.terrain, 0, {&missing, 1}, mask), EnvironmentError::missing_site)); CHECK(refused(query_environment(*f.fields, *f.terrain, 0, {&invalid, 1}, mask), EnvironmentError::invalid_voxel)); auto duplicate = f.footprint; duplicate.push_back(duplicate[0]); CHECK(refused(query_environment(*f.fields, *f.terrain, 0, duplicate, mask), EnvironmentError::invalid_request)); std::vector excess(max_environment_footprint + 1); CHECK(refused(query_environment(*f.fields, *f.terrain, 0, excess, mask), EnvironmentError::invalid_request)); auto no_fields = FieldStore::create(identity, 2, {}, f.fields->sites(), {}, budget); CHECK(no_fields); auto absent = query_environment(**no_fields, *f.terrain, 0, f.footprint, all_environment_fields); CHECK(absent); for (const auto& s : absent->samples()) { CHECK(s.moisture_status == MoistureStatus::missing_water && !s.moisture); for (const auto& value : s.fields) CHECK(!value); } } void maximum_footprint() { std::vector sites; std::vector footprint; for (std::int64_t x = -128; x < 128; ++x) { footprint.push_back({x, 0, -16000}); sites.push_back({footprint.back(), {{0}, {0}, {0}, {1}, {1}, {1}}, {1}}); } const std::uint64_t amount = 4; std::array openings; for (std::size_t k = 0; k < field_count; ++k) openings[k] = {static_cast(k), {&amount, 1}}; const FieldDefaults defaults{{evo::accounting::Femtograms{0}, evo::accounting::Femtograms{100}, evo::accounting::Femtograms{0}}}; auto fields = FieldStore::create(identity, 3, defaults, sites, openings, budget); auto terrain = ChunkStore::create({}, 32, budget); CHECK(fields && terrain); for (auto voxel : footprint) CHECK((*terrain)->load(split(voxel, base_chunk_edge)->chunk)); std::reverse(footprint.begin(), footprint.end()); const auto fields_before = (*fields)->snapshot(); const auto terrain_before = (*terrain)->snapshot(identity); auto result = query_environment(**fields, **terrain, 0, footprint, all_environment_fields); CHECK(result && result->samples().size() == max_environment_footprint); CHECK(validate_environment(*result, **fields, **terrain, 0)); for (std::size_t i = 0; i < sites.size(); ++i) { const auto& s = result->samples()[i]; CHECK(s.voxel == sites[i].voxel); for (std::size_t k = 0; k < field_count; ++k) { CHECK(s.fields[k]); if (k < 7) CHECK(std::get(required_field(s.fields[k])) == EnvironmentMass{{4}, {4, 1}}); else CHECK(std::get(required_field(s.fields[k])).value == 4); } CHECK(s.moisture == WaterSaturation{1, 25}); } CHECK((*fields)->snapshot() == fields_before && (*terrain)->snapshot(identity) == terrain_before); } } // namespace int main() try { values_and_order(); freshness(); invalid_and_absent(); maximum_footprint(); return 0; } catch (const std::exception& e) { std::fprintf(stderr, "%s\n", e.what()); return 1; } catch (...) { return 1; }