Foundation / checks (deploy) (push) Successful in 5s
Foundation / checks (ecs) (push) Successful in 1m59s
Foundation / checks (checks) (push) Failing after 2m10s
Foundation / checks (postgres) (push) Failing after 10m34s
Foundation / checks (network) (push) Failing after 12m19s
Foundation / checks (tsan) (push) Failing after 2m14s
Foundation / checks (client) (push) Successful in 15m7s
Foundation / postgres-tools (push) Skipped
Foundation / server-image (push) Skipped
Foundation / image (push) Skipped
298 lines
12 KiB
C++
298 lines
12 KiB
C++
#include "evo/server/lifecycle/primitive_lives.hpp"
|
|
|
|
#include <algorithm>
|
|
#include <bit>
|
|
#include <cstdlib>
|
|
#include <limits>
|
|
#include <utility>
|
|
|
|
namespace evo::server {
|
|
struct PrimitiveLives::State {
|
|
NurseryConfig config;
|
|
accounting::Ledger ledger;
|
|
biology::LineageArchive archive;
|
|
std::vector<PrimitiveLife> lives;
|
|
};
|
|
|
|
PrimitiveLives::PrimitiveLives(std::unique_ptr<State> state) : state_{std::move(state)} {}
|
|
PrimitiveLives::~PrimitiveLives() = default;
|
|
|
|
std::expected<std::unique_ptr<PrimitiveLives>, LifeError>
|
|
PrimitiveLives::create(NurseryConfig config) {
|
|
if (config.world == 0 || config.region == 0 || config.frame == 0 || config.source == 0 ||
|
|
config.sites.empty() || config.sites.size() > max_primitive_lives ||
|
|
!std::ranges::is_sorted(config.sites))
|
|
return std::unexpected{LifeError::invalid};
|
|
const auto founder = biology::primitive_founder(1, 1);
|
|
if (!founder)
|
|
return std::unexpected{LifeError::biology};
|
|
const auto phenotype = biology::derive_phenotype(*founder, {1000, 0}, {});
|
|
if (!phenotype)
|
|
return std::unexpected{LifeError::biology};
|
|
for (std::size_t i = 0; i < config.sites.size(); ++i) {
|
|
const auto site = config.sites[i];
|
|
if (site.x_um < -spawn_coordinate_limit_um || site.x_um > spawn_coordinate_limit_um ||
|
|
site.y_um < -spawn_coordinate_limit_um || site.y_um > spawn_coordinate_limit_um)
|
|
return std::unexpected{LifeError::invalid};
|
|
for (std::size_t j = 0; j < i; ++j) {
|
|
const auto dx = std::abs(std::int64_t{site.x_um} - config.sites[j].x_um);
|
|
const auto dy = std::abs(std::int64_t{site.y_um} - config.sites[j].y_um);
|
|
if (dx < phenotype->extent && dy < phenotype->extent)
|
|
return std::unexpected{LifeError::occupied};
|
|
}
|
|
}
|
|
std::vector<accounting::Inventory> opening(2 + 2 * config.sites.size());
|
|
opening[0] = config.funding; // Source 1, heat 2; body/reserve pairs follow.
|
|
auto ledger = accounting::Ledger::create(opening);
|
|
if (!ledger)
|
|
return std::unexpected{LifeError::overflow};
|
|
auto state = std::make_unique<State>(State{std::move(config), std::move(*ledger), {}, {}});
|
|
return std::unique_ptr<PrimitiveLives>{new PrimitiveLives{std::move(state)}};
|
|
}
|
|
|
|
std::expected<PrimitiveLife, LifeError> PrimitiveLives::spawn(LifeRequest request,
|
|
LifeAllocation allocation) {
|
|
if (request.action == 0 || std::ranges::all_of(request.account, [](auto b) { return b == 0; }))
|
|
return std::unexpected{LifeError::invalid};
|
|
for (const auto& life : state_->lives) {
|
|
if (life.request == request)
|
|
return life;
|
|
if (life.request.account == request.account)
|
|
return std::unexpected{LifeError::existing_life};
|
|
}
|
|
if (allocation.life == 0 || allocation.organism == 0 || allocation.genome == 0 ||
|
|
allocation.event == 0)
|
|
return std::unexpected{LifeError::invalid};
|
|
for (const auto& life : state_->lives) {
|
|
const auto& old = life.identity;
|
|
if (old.life == allocation.life || old.organism == allocation.organism ||
|
|
old.genome == allocation.genome || old.event == allocation.event)
|
|
return std::unexpected{LifeError::identity_conflict};
|
|
}
|
|
const auto slot = state_->lives.size();
|
|
if (slot == state_->config.sites.size())
|
|
return std::unexpected{LifeError::capacity};
|
|
const auto endowed = biology::primitive_endowment();
|
|
const auto genome = biology::primitive_founder(allocation.genome, allocation.event);
|
|
if (!endowed || !genome)
|
|
return std::unexpected{LifeError::biology};
|
|
const auto body = accounting::ReservoirId{static_cast<std::uint32_t>(3 + 2 * slot)};
|
|
const auto reserve = accounting::ReservoirId{body.value + 1};
|
|
const PrimitiveLife life{
|
|
request, allocation, state_->config.source, state_->config.sites[slot], endowed->growth,
|
|
body, reserve};
|
|
// Detached candidate: all fallible work, including allocations and archive
|
|
// admission, precedes the single noexcept pointer swap.
|
|
auto next = std::make_unique<State>(*state_);
|
|
const std::array legs{accounting::Transfer{{1}, body, endowed->body},
|
|
accounting::Transfer{{1}, reserve, endowed->reserve},
|
|
accounting::Transfer{{1}, {2}, {endowed->construction, {}}}};
|
|
const auto paid = next->ledger.transfer(slot + 1, legs);
|
|
if (!paid)
|
|
return std::unexpected{paid.error() == accounting::LedgerError::insufficient_inventory
|
|
? LifeError::insufficient_funding
|
|
: LifeError::overflow};
|
|
if (!next->archive.admit(*genome) ||
|
|
!next->archive.record_birth(allocation.organism, allocation.genome, allocation.born))
|
|
return std::unexpected{LifeError::archive};
|
|
next->lives.push_back(life);
|
|
state_.swap(next);
|
|
return life;
|
|
}
|
|
|
|
const NurseryConfig& PrimitiveLives::config() const noexcept {
|
|
return state_->config;
|
|
}
|
|
std::span<const PrimitiveLife> PrimitiveLives::lives() const noexcept {
|
|
return state_->lives;
|
|
}
|
|
std::span<const accounting::Inventory> PrimitiveLives::balances() const noexcept {
|
|
return state_->ledger.balances();
|
|
}
|
|
accounting::Inventory PrimitiveLives::totals() const noexcept {
|
|
return state_->ledger.conserved_totals();
|
|
}
|
|
const biology::LineageArchive& PrimitiveLives::archive() const noexcept {
|
|
return state_->archive;
|
|
}
|
|
|
|
namespace {
|
|
constexpr std::uint64_t life_magic = 0x314546494C4F5645ULL; // "EVOLIFE1"
|
|
constexpr std::size_t life_header_bytes = 112;
|
|
constexpr std::size_t life_record_bytes = 96;
|
|
std::uint64_t checksum(std::span<const std::uint8_t> bytes) noexcept {
|
|
std::uint64_t value = 14695981039346656037ULL;
|
|
for (const auto byte : bytes)
|
|
value = (value ^ byte) * 1099511628211ULL;
|
|
return value;
|
|
}
|
|
class Writer {
|
|
public:
|
|
explicit Writer(std::vector<std::uint8_t>& bytes) : bytes_{bytes} {}
|
|
void put(std::uint64_t value, unsigned width = 8) {
|
|
for (unsigned i = 0; i < width; ++i, value >>= 8U)
|
|
bytes_[at_++] = static_cast<std::uint8_t>(value & 255U);
|
|
}
|
|
void inventory(accounting::Inventory value) {
|
|
put(value.energy.value);
|
|
for (const auto mass : value.matter)
|
|
put(mass.value);
|
|
}
|
|
void site(SpawnSite value) {
|
|
put(std::bit_cast<std::uint32_t>(value.x_um), 4);
|
|
put(std::bit_cast<std::uint32_t>(value.y_um), 4);
|
|
}
|
|
void raw(std::span<const std::uint8_t> value) {
|
|
for (const auto b : value)
|
|
put(b, 1);
|
|
}
|
|
|
|
private:
|
|
std::vector<std::uint8_t>& bytes_;
|
|
std::size_t at_{};
|
|
};
|
|
// Only constructed after exact sizes/counts have been checked, except for the
|
|
// fixed header, whose minimum length is checked before reading any byte.
|
|
class Reader {
|
|
public:
|
|
explicit Reader(std::span<const std::uint8_t> bytes) : bytes_{bytes} {}
|
|
std::uint64_t get(unsigned width = 8) {
|
|
std::uint64_t value{};
|
|
for (unsigned i = 0; i < width; ++i)
|
|
value |= std::uint64_t{bytes_[at_++]} << (8U * i);
|
|
return value;
|
|
}
|
|
accounting::Inventory inventory() {
|
|
accounting::Inventory out{};
|
|
out.energy.value = get();
|
|
for (auto& mass : out.matter)
|
|
mass.value = get();
|
|
return out;
|
|
}
|
|
SpawnSite site() {
|
|
const auto x = static_cast<std::uint32_t>(get(4));
|
|
const auto y = static_cast<std::uint32_t>(get(4));
|
|
return {std::bit_cast<std::int32_t>(x), std::bit_cast<std::int32_t>(y)};
|
|
}
|
|
std::span<const std::uint8_t> raw(std::size_t size) {
|
|
const auto result = bytes_.subspan(at_, size);
|
|
at_ += size;
|
|
return result;
|
|
}
|
|
|
|
private:
|
|
std::span<const std::uint8_t> bytes_;
|
|
std::size_t at_{};
|
|
};
|
|
} // namespace
|
|
|
|
std::vector<std::uint8_t> PrimitiveLives::snapshot() const {
|
|
const auto& c = state_->config;
|
|
const auto history = state_->archive.encode();
|
|
std::vector<std::uint8_t> bytes(life_header_bytes + 8 * c.sites.size() +
|
|
life_record_bytes * state_->lives.size() +
|
|
40 * balances().size() + history.size() + 8);
|
|
Writer out{bytes};
|
|
out.put(life_magic);
|
|
out.put(primitive_lives_format, 4);
|
|
out.put(biology::founder_life_rules, 4);
|
|
out.put(c.world);
|
|
out.put(c.region);
|
|
out.put(c.frame);
|
|
out.put(c.source);
|
|
out.put(50'000); // Ratified M10 quantum; no biological stepping in format 1.
|
|
out.inventory(c.funding);
|
|
out.put(c.sites.size(), 4);
|
|
out.put(state_->lives.size(), 4);
|
|
out.put(history.size(), 4);
|
|
out.put(0, 4);
|
|
for (const auto site : c.sites)
|
|
out.site(site);
|
|
for (const auto& life : state_->lives) {
|
|
out.raw(life.request.account);
|
|
out.put(life.request.action);
|
|
const auto& id = life.identity;
|
|
out.put(id.life);
|
|
out.put(id.organism);
|
|
out.put(id.genome);
|
|
out.put(id.event);
|
|
out.put(id.born.value);
|
|
out.put(life.source);
|
|
out.site(life.site);
|
|
out.put(life.growth.realized_per_thousand, 4);
|
|
out.put(life.growth.damage_per_thousand, 4);
|
|
out.put(life.body.value, 4);
|
|
out.put(life.reserve.value, 4);
|
|
}
|
|
for (const auto inventory : balances())
|
|
out.inventory(inventory);
|
|
out.raw(history);
|
|
out.put(checksum(std::span{bytes}.first(bytes.size() - 8)));
|
|
return bytes;
|
|
}
|
|
|
|
std::expected<std::unique_ptr<PrimitiveLives>, LifeCodecError>
|
|
PrimitiveLives::restore(std::span<const std::uint8_t> bytes, std::uint64_t world,
|
|
std::uint64_t region, std::uint64_t frame) {
|
|
if (bytes.size() < life_header_bytes + 8 || bytes.size() > max_primitive_lives_bytes)
|
|
return std::unexpected{LifeCodecError::format};
|
|
Reader tail{bytes.last(8)};
|
|
if (checksum(bytes.first(bytes.size() - 8)) != tail.get())
|
|
return std::unexpected{LifeCodecError::checksum};
|
|
Reader in{bytes};
|
|
if (in.get() != life_magic)
|
|
return std::unexpected{LifeCodecError::format};
|
|
if (in.get(4) != primitive_lives_format || in.get(4) != biology::founder_life_rules)
|
|
return std::unexpected{LifeCodecError::version};
|
|
NurseryConfig c;
|
|
c.world = in.get();
|
|
c.region = in.get();
|
|
c.frame = in.get();
|
|
c.source = in.get();
|
|
if (c.world != world || c.region != region || c.frame != frame)
|
|
return std::unexpected{LifeCodecError::closure};
|
|
if (in.get() != 50'000)
|
|
return std::unexpected{LifeCodecError::version};
|
|
c.funding = in.inventory();
|
|
const auto sites = in.get(4), count = in.get(4), archive_bytes = in.get(4);
|
|
if (in.get(4) != 0 || sites == 0 || sites > max_primitive_lives || count > sites ||
|
|
archive_bytes > biology::max_archive_legacy_bytes ||
|
|
bytes.size() != life_header_bytes + 8 * sites + life_record_bytes * count +
|
|
40 * (2 + 2 * sites) + archive_bytes + 8)
|
|
return std::unexpected{LifeCodecError::format};
|
|
for (std::uint64_t i = 0; i < sites; ++i)
|
|
c.sites.push_back(in.site());
|
|
auto restored = create(std::move(c));
|
|
if (!restored)
|
|
return std::unexpected{LifeCodecError::closure};
|
|
for (std::uint64_t i = 0; i < count; ++i) {
|
|
PrimitiveLife saved{};
|
|
std::ranges::copy(in.raw(16), saved.request.account.begin());
|
|
saved.request.action = in.get();
|
|
auto& id = saved.identity;
|
|
id.life = in.get();
|
|
id.organism = in.get();
|
|
id.genome = in.get();
|
|
id.event = in.get();
|
|
id.born.value = in.get();
|
|
saved.source = in.get();
|
|
saved.site = in.site();
|
|
saved.growth.realized_per_thousand = static_cast<std::uint32_t>(in.get(4));
|
|
saved.growth.damage_per_thousand = static_cast<std::uint32_t>(in.get(4));
|
|
saved.body.value = static_cast<std::uint32_t>(in.get(4));
|
|
saved.reserve.value = static_cast<std::uint32_t>(in.get(4));
|
|
const auto actual = (*restored)->spawn(saved.request, saved.identity);
|
|
if (!actual || *actual != saved || (*restored)->lives().size() != i + 1)
|
|
return std::unexpected{LifeCodecError::closure};
|
|
}
|
|
for (const auto actual : (*restored)->balances())
|
|
if (actual != in.inventory())
|
|
return std::unexpected{LifeCodecError::closure};
|
|
const auto archive = in.raw(static_cast<std::size_t>(archive_bytes));
|
|
if (!std::ranges::equal(archive, (*restored)->archive().encode()) ||
|
|
!std::ranges::equal(bytes, (*restored)->snapshot()))
|
|
return std::unexpected{LifeCodecError::closure};
|
|
return std::move(*restored);
|
|
}
|
|
} // namespace evo::server
|