242 lines
12 KiB
C++
242 lines
12 KiB
C++
#include "evo/world/environment.hpp"
|
|
#include <algorithm>
|
|
#include <array>
|
|
#include <cstdio>
|
|
#include <limits>
|
|
#include <source_location>
|
|
#include <stdexcept>
|
|
#include <string>
|
|
#include <vector>
|
|
|
|
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<bool>(__VA_ARGS__))
|
|
template <typename T, typename E> bool refused(const std::expected<T, E>& r, E e) {
|
|
return !r && r.error() == e;
|
|
}
|
|
struct Fixture {
|
|
std::unique_ptr<FieldStore> fields;
|
|
std::unique_ptr<ChunkStore> terrain;
|
|
std::vector<VoxelAddress> footprint;
|
|
};
|
|
Fixture fixture() {
|
|
Fixture f;
|
|
std::vector<FieldSite> 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<std::uint64_t, 6> 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<std::int64_t, 6> 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<EnvironmentMass>(*s.fields[2]) == EnvironmentMass{{0}, {0, 1}});
|
|
CHECK(std::get<evo::accounting::Picojoules>(*s.fields[7]).value == 72);
|
|
CHECK(s.chunk_revision == f.terrain->view(s.chunk)->revision());
|
|
}
|
|
CHECK(std::get<EnvironmentMass>(*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<std::int64_t>::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<VoxelAddress> 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<FieldSite> sites;
|
|
std::vector<VoxelAddress> 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<FieldOpening, field_count> openings;
|
|
for (std::size_t k = 0; k < field_count; ++k)
|
|
openings[k] = {static_cast<Field>(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<EnvironmentMass>(*s.fields[k]) == EnvironmentMass{{4}, {4, 1}});
|
|
else
|
|
CHECK(std::get<evo::accounting::Picojoules>(*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;
|
|
}
|