Foundation / checks (deploy) (push) Successful in 3m32s
Foundation / checks (ecs) (push) Successful in 1m56s
Foundation / checks (client) (push) Successful in 12m56s
Foundation / checks (network) (push) Successful in 13m46s
Foundation / checks (tsan) (push) Successful in 7m59s
Foundation / checks (checks) (push) Successful in 33m36s
Foundation / checks (postgres) (push) Successful in 45m30s
Foundation / postgres-tools (push) Successful in 20s
Foundation / server-image (push) Successful in 25s
Foundation / image (push) Successful in 2m36s
Movement and ingestion are stored per second in schema 2 (ranges x20). Schema 1 records stay valid, are never rewritten, and read as exactly x20 via Genome::per_second; drafts default to schema 1 so existing literals keep their meaning. Development version 1 converts genome rates at its own 50 ms quantum (round down), so phenotypes are unchanged. Mutation keeps the parent's schema and step; the lineage archive header names exactly the highest schema held (all-schema-1 archives keep their bytes); the development-v1 opening names schema 1. No golden changed; two tests that used 2 as an unknown schema now use the next one. Refresh the dev session window. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
183 lines
7.6 KiB
C++
183 lines
7.6 KiB
C++
#pragma once
|
|
|
|
#include <array>
|
|
#include <compare>
|
|
#include <cstddef>
|
|
#include <cstdint>
|
|
#include <expected>
|
|
#include <span>
|
|
#include <vector>
|
|
|
|
namespace evo::biology {
|
|
// Evolvable developmental capabilities, not genes, organs, species or DNA.
|
|
enum class Capability : std::uint8_t {
|
|
energy_conversion,
|
|
membrane,
|
|
movement,
|
|
ingestion,
|
|
reproduction,
|
|
target_size,
|
|
thermal_tolerance
|
|
};
|
|
inline constexpr std::size_t capability_count = 7;
|
|
// The unit is a schema fact per kind and is never encoded, so no record can
|
|
// contradict its own units.
|
|
enum class Unit : std::uint8_t {
|
|
per_thousand,
|
|
micrometres,
|
|
micrometres_per_tick, // Schema 1: per 50 ms tick.
|
|
femtograms,
|
|
femtograms_per_tick, // Schema 1: per 50 ms tick.
|
|
millikelvin,
|
|
micrometres_per_second, // Schema 2 (ADR-0099).
|
|
femtograms_per_second // Schema 2 (ADR-0099).
|
|
};
|
|
struct CapabilitySpec {
|
|
Unit unit;
|
|
std::uint32_t minimum;
|
|
std::uint32_t maximum;
|
|
bool required;
|
|
// Capabilities the schema mandates be present; developmental edges as well.
|
|
std::uint32_t mandates;
|
|
};
|
|
[[nodiscard]] constexpr std::uint32_t capability_bit(Capability kind) noexcept {
|
|
return 1U << static_cast<std::uint8_t>(kind);
|
|
}
|
|
// Chosen schema constants, reviewable as a unit. These are ranges of expressible
|
|
// capability, not balance, stats or a power score. Schema 1 states rates per 50 ms tick.
|
|
inline constexpr std::array<CapabilitySpec, capability_count> capability_schema_v1{
|
|
CapabilitySpec{Unit::per_thousand, 1, 1000, true, 0},
|
|
CapabilitySpec{Unit::micrometres, 1, 10'000, true, 0},
|
|
CapabilitySpec{Unit::micrometres_per_tick, 0, 100'000, false,
|
|
capability_bit(Capability::membrane)},
|
|
CapabilitySpec{Unit::femtograms_per_tick, 0, 1'000'000, false,
|
|
capability_bit(Capability::membrane)},
|
|
CapabilitySpec{Unit::per_thousand, 1, 1000, false,
|
|
capability_bit(Capability::energy_conversion)},
|
|
CapabilitySpec{Unit::femtograms, 1, 1'000'000'000, true, 0},
|
|
CapabilitySpec{Unit::millikelvin, 1, 100'000, false, 0}};
|
|
// Schema 2 (ADR-0099): the same capabilities with rates per second. Each rate range is
|
|
// schema 1's times 20, so every schema 1 value has an exact schema 2 equivalent.
|
|
inline constexpr std::array<CapabilitySpec, capability_count> capability_schema_v2{
|
|
CapabilitySpec{Unit::per_thousand, 1, 1000, true, 0},
|
|
CapabilitySpec{Unit::micrometres, 1, 10'000, true, 0},
|
|
CapabilitySpec{Unit::micrometres_per_second, 0, 2'000'000, false,
|
|
capability_bit(Capability::membrane)},
|
|
CapabilitySpec{Unit::femtograms_per_second, 0, 20'000'000, false,
|
|
capability_bit(Capability::membrane)},
|
|
CapabilitySpec{Unit::per_thousand, 1, 1000, false,
|
|
capability_bit(Capability::energy_conversion)},
|
|
CapabilitySpec{Unit::femtograms, 1, 1'000'000'000, true, 0},
|
|
CapabilitySpec{Unit::millikelvin, 1, 100'000, false, 0}};
|
|
// The current schema's table.
|
|
inline constexpr const auto& capability_schema = capability_schema_v2;
|
|
// Schema 1 rates are per tick of this quantum.
|
|
inline constexpr std::uint64_t schema_v1_tick_microseconds = 50'000;
|
|
|
|
struct CapabilityRecord {
|
|
Capability kind{};
|
|
std::uint32_t parameter{};
|
|
// Declared developmental ordering, over and above what the schema mandates.
|
|
std::uint32_t prerequisites{};
|
|
auto operator<=>(const CapabilityRecord&) const = default;
|
|
};
|
|
// Unvalidated input. Only Genome::create turns one into a record.
|
|
struct GenomeDraft {
|
|
std::uint64_t id{};
|
|
std::uint64_t origin_event{};
|
|
std::uint32_t development_version{};
|
|
std::vector<std::uint64_t> parents;
|
|
std::vector<CapabilityRecord> capabilities;
|
|
// The schema the parameters are written in. Schema 1 is the default so an existing
|
|
// literal keeps its meaning (rates per 50 ms tick); new records name schema 2. Last,
|
|
// so positional initialisers are unaffected.
|
|
std::uint32_t schema_version{1};
|
|
};
|
|
enum class GenomeError : std::uint8_t {
|
|
unsupported_version,
|
|
unknown_capability,
|
|
missing_capability,
|
|
duplicate_capability,
|
|
parameter_out_of_range,
|
|
missing_prerequisite,
|
|
cyclic_development,
|
|
invalid_identity,
|
|
invalid_ancestry,
|
|
digest_mismatch,
|
|
invalid_encoding
|
|
};
|
|
// The current schema. Schema 1 records stay valid and are never rewritten (ADR-0099).
|
|
inline constexpr std::uint32_t genome_schema_version = 2;
|
|
inline constexpr std::uint32_t genome_schema_v1 = 1;
|
|
// The capability table of a supported schema (1 or 2); nullptr otherwise.
|
|
[[nodiscard]] constexpr const std::array<CapabilitySpec, capability_count>*
|
|
capability_schema_for(std::uint32_t schema) noexcept {
|
|
return schema == genome_schema_v1 ? &capability_schema_v1
|
|
: schema == genome_schema_version ? &capability_schema_v2
|
|
: nullptr;
|
|
}
|
|
inline constexpr std::size_t max_parents = 2;
|
|
inline constexpr std::size_t max_genome_bytes = 256;
|
|
|
|
// Immutable once constructed: validation happens exactly once, at the boundary.
|
|
class Genome {
|
|
public:
|
|
[[nodiscard]] static std::expected<Genome, GenomeError> create(const GenomeDraft& draft);
|
|
[[nodiscard]] static std::expected<Genome, GenomeError>
|
|
decode(std::span<const std::uint8_t> bytes);
|
|
// Copy-only on purpose. A moved-from record would keep its identity, origin
|
|
// and digest while losing its capabilities, which is precisely the invalid
|
|
// genome this type exists to make unrepresentable. Declaring the copy
|
|
// operations suppresses the implicit moves, so a move decays to a copy; the
|
|
// record is at most seven capabilities and one parent, so that is cheap.
|
|
Genome(const Genome&) = default;
|
|
Genome& operator=(const Genome&) = default;
|
|
[[nodiscard]] std::vector<std::uint8_t> encode() const;
|
|
[[nodiscard]] std::uint64_t id() const noexcept {
|
|
return id_;
|
|
}
|
|
[[nodiscard]] std::uint64_t origin_event() const noexcept {
|
|
return origin_event_;
|
|
}
|
|
[[nodiscard]] std::uint32_t schema_version() const noexcept {
|
|
return schema_version_;
|
|
}
|
|
[[nodiscard]] std::uint32_t development_version() const noexcept {
|
|
return development_version_;
|
|
}
|
|
// Zero parents identifies a documented founder; v1 permits at most one.
|
|
[[nodiscard]] std::span<const std::uint64_t> parents() const noexcept {
|
|
return parents_;
|
|
}
|
|
// Sorted strictly ascending by kind, so the record is canonical.
|
|
[[nodiscard]] std::span<const CapabilityRecord> capabilities() const noexcept {
|
|
return capabilities_;
|
|
}
|
|
[[nodiscard]] bool carries(Capability kind) const noexcept;
|
|
[[nodiscard]] std::expected<std::uint32_t, GenomeError>
|
|
parameter(Capability kind) const noexcept;
|
|
// A rate capability (movement, ingestion) per second, whatever the schema: a
|
|
// schema 1 per-tick value times 20, exactly. Other capabilities are returned as
|
|
// stored.
|
|
[[nodiscard]] std::expected<std::uint64_t, GenomeError>
|
|
per_second(Capability kind) const noexcept;
|
|
// Covers identity and ancestry, so distinct origins never share a digest.
|
|
// An integrity and deduplication aid, never a content key and never authenticity.
|
|
[[nodiscard]] std::uint64_t content_digest() const noexcept {
|
|
return digest_;
|
|
}
|
|
auto operator<=>(const Genome&) const = default;
|
|
|
|
private:
|
|
Genome() = default;
|
|
[[nodiscard]] std::vector<std::uint8_t> body() const;
|
|
std::uint32_t schema_version_{genome_schema_v1};
|
|
std::uint64_t id_{};
|
|
std::uint64_t origin_event_{};
|
|
std::uint32_t development_version_{};
|
|
std::vector<std::uint64_t> parents_;
|
|
std::vector<CapabilityRecord> capabilities_;
|
|
std::uint64_t digest_{};
|
|
};
|
|
} // namespace evo::biology
|