#include "evo/biology/metabolism.hpp" #include "evo/accounting/rates.hpp" #include #include namespace evo::biology { namespace { constexpr std::uint64_t thousand = 1000; // Membrane is the more carbon-rich compartment, so a thicker one changes what a // body is made of and not only how much of it there is. constexpr Composition structure_shares{500, 150, 50, 300}; constexpr Composition membrane_shares{700, 50, 100, 150}; constexpr std::uint32_t total_share(const Composition& shares) noexcept { std::uint32_t sum = 0; for (const auto share : shares) { sum += share; } return sum; } static_assert(total_share(structure_shares) == thousand); static_assert(total_share(membrane_shares) == thousand); bool multiply(std::uint64_t& result, std::uint64_t left, std::uint64_t right) noexcept { if (left != 0 && right > std::numeric_limits::max() / left) { return false; } result = left * right; return true; } bool add(std::uint64_t& result, std::uint64_t left, std::uint64_t right) noexcept { if (right > std::numeric_limits::max() - left) { return false; } result = left + right; return true; } // Declared flooring, matching ADR-0031's derivation. std::uint64_t scaled(std::uint64_t value, std::uint64_t numerator) noexcept { return value / thousand * numerator + value % thousand * numerator / thousand; } // Splits a mass across the ledger's channels. The last channel takes whatever the // first three left, so the parts always sum back to the whole. accounting::Inventory compose(std::uint64_t mass, const Composition& shares) noexcept { accounting::Inventory parts{}; std::uint64_t assigned = 0; for (std::size_t index = 0; index + 1 < shares.size(); ++index) { const auto part = scaled(mass, shares[index]); parts.matter[index].value = part; assigned += part; } parts.matter[shares.size() - 1].value = mass - assigned; return parts; } bool combine(accounting::Inventory& total, const accounting::Inventory& amount) noexcept { if (!add(total.energy.value, total.energy.value, amount.energy.value)) { return false; } for (std::size_t index = 0; index < total.matter.size(); ++index) { if (!add(total.matter[index].value, total.matter[index].value, amount.matter[index].value)) { return false; } } return true; } // Every channel and the energy must fit: a surplus of one element never pays for // a shortfall of another. bool fits(const accounting::Inventory& needed, const accounting::Inventory& available) noexcept { if (needed.energy > available.energy) { return false; } for (std::size_t index = 0; index < needed.matter.size(); ++index) { if (needed.matter[index] > available.matter[index]) { return false; } } return true; } std::uint64_t matter_total(const accounting::Inventory& inventory) noexcept { std::uint64_t sum = 0; for (const auto& mass : inventory.matter) { sum += mass.value; } return sum; } // Scales an inventory's matter while keeping its composition. The last channel // again takes the remainder, so the parts sum to the scaled whole exactly. accounting::Inventory fraction_of(const accounting::Inventory& source, std::uint64_t numerator) noexcept { accounting::Inventory parts{}; const auto whole = scaled(matter_total(source), numerator); std::uint64_t assigned = 0; for (std::size_t index = 0; index + 1 < source.matter.size(); ++index) { const auto part = scaled(source.matter[index].value, numerator); parts.matter[index].value = part; assigned += part; } parts.matter[source.matter.size() - 1].value = whole - assigned; return parts; } } // namespace std::expected metabolic_rules_for(std::uint32_t development_version) { if (development_version == 1) { return MetabolicRules{structure_shares, membrane_shares, 20, 50'000}; } // Version 2: per second; movement at 1000 um/s costs 50 pJ/s per 1000 fg (tunable). // Versions 3, 4 and 5: the same metabolism. if (development_version >= 2 && development_version <= 5) { return MetabolicRules{structure_shares, membrane_shares, 50, 50'000}; } return std::unexpected{DevelopmentError::unsupported_rules}; } std::expected metabolic_budget(const Genome& genome, GrowthState growth, EnvironmentState environment, std::uint32_t max_growth_per_thousand) { const auto phenotype = derive_phenotype(genome, growth, environment); if (!phenotype) { return std::unexpected{phenotype.error()}; } const auto rules = metabolic_rules_for(genome.development_version()); if (!rules) { return std::unexpected{rules.error()}; } const auto shape = rules_for(genome.development_version()); if (!shape) { return std::unexpected{shape.error()}; } MetabolicBudget budget; budget.phenotype = *phenotype; budget.rate_microseconds = development_rate_microseconds(genome.development_version()); budget.assimilation_per_thousand = static_cast(phenotype->conversion_per_thousand); budget.body = compose(phenotype->structural_mass, rules->structure); if (!combine(budget.body, compose(phenotype->membrane_mass, rules->membrane))) { return std::unexpected{DevelopmentError::overflow}; } budget.maintenance.value = phenotype->maintenance; // Moving a larger body costs more, so a thicker membrane is paid for twice. std::uint64_t haulage{}; if (!multiply(haulage, scaled(phenotype->total_mass, rules->movement_per_kilogram), phenotype->movement_speed)) { return std::unexpected{DevelopmentError::overflow}; } budget.movement.value = haulage / thousand; if (!add(budget.demand.value, budget.maintenance.value, budget.movement.value)) { return std::unexpected{DevelopmentError::overflow}; } // Intake funds structure, so it arrives in the proportions structure needs. budget.intake_limit = compose(phenotype->ingestion_rate, rules->structure); budget.intake_limit.energy.value = scaled(phenotype->ingestion_rate, rules->intake_energy_per_kilogram); const auto plan = plan_development(genome, growth, environment); if (!plan) { return std::unexpected{plan.error()}; } // A plan bounds by total mass, which cannot tell whether the elements a step // consumes are actually there: released matter never substitutes for an // element the step needs. Narrow the proposal to the largest step whose own // intake fits channel by channel. budget.construction.after = growth; const auto proposed = plan->after.realized_per_thousand - growth.realized_per_thousand; for (std::uint32_t attempt = std::min(proposed, max_growth_per_thousand); attempt > 0; --attempt) { const GrowthState candidate{growth.realized_per_thousand + attempt, growth.damage_per_thousand}; const auto grown = derive_phenotype(genome, candidate, environment); if (!grown) { return std::unexpected{grown.error()}; } // Compose the grown body and difference it against the current one. // Composing the mass difference instead would discard the rounding this // body already carries, and the budget could not then reproduce the // derived body channel by channel. Each compartment is still composed // separately: the two differ in what they cost. auto reached = compose(grown->structural_mass, rules->structure); if (!combine(reached, compose(grown->membrane_mass, rules->membrane))) { return std::unexpected{DevelopmentError::overflow}; } ConstructionTransition move{}; move.after = candidate; std::uint64_t acquired = 0, freed = 0; for (std::size_t index = 0; index < reached.matter.size(); ++index) { const auto held = budget.body.matter[index].value; const auto wanted = reached.matter[index].value; if (wanted >= held) { move.intake.matter[index].value = wanted - held; acquired += wanted - held; } else { move.release.matter[index].value = held - wanted; freed += held - wanted; } } // Energy is priced on the net mass change, as the plan prices it. move.intake.energy.value = scaled(acquired - freed, shape->construction_per_kilogram); if (!fits(move.intake, environment.available)) { continue; } budget.construction = move; break; } if (genome.carries(Capability::reproduction)) { const auto value = *genome.parameter(Capability::reproduction); // Version 4 (ADR-0137): a bud is always half the body, and reproduction is skill: // it takes up to half off the bud's construction energy (value / 2000). Matter is // never discounted (ADR-0118). Earlier versions invest `value` per thousand. const bool skill = genome.development_version() >= 4; // Versions 4 and 5. const auto fraction = skill ? bud_body_per_thousand_v4 : value; // A parent divides the body it has, so the investment keeps its composition. budget.reproduction_investment = fraction_of(budget.body, fraction); // Offspring tissue is priced at what the parent's own tissue costs. const auto construction = scaled(matter_total(budget.reproduction_investment), shape->construction_per_kilogram); // Discount = construction * skill / 2000, split to stay within 64 bits. const std::uint64_t level = std::min(value, 1000); const auto discount = construction / 2000 * level + construction % 2000 * level / 2000; budget.reproduction_investment.energy.value = skill ? construction - discount : construction; } return budget; } std::optional bud_funding_seconds(const MetabolicBudget& budget, std::uint32_t feeding_per_thousand) noexcept { const auto period = budget.rate_microseconds; if (period == 0 || accounting::microseconds_per_second % period != 0 || feeding_per_thousand == 0 || feeding_per_thousand > thousand || matter_total(budget.reproduction_investment) == 0) return std::nullopt; const auto periods_per_second = accounting::microseconds_per_second / period; // Per-second amounts; ceil(need / rate) seconds for each. const auto seconds = [&](std::uint64_t need, std::uint64_t per_period) -> std::optional { if (need == 0) return std::uint64_t{0}; std::uint64_t per_second{}; if (!multiply(per_second, scaled(per_period, feeding_per_thousand), periods_per_second) || per_second == 0) return std::nullopt; return need / per_second + (need % per_second != 0 ? 1 : 0); }; std::uint64_t longest = 0; for (std::size_t c = 0; c < budget.reproduction_investment.matter.size(); ++c) { const auto t = seconds(budget.reproduction_investment.matter[c].value, budget.intake_limit.matter[c].value); if (!t) return std::nullopt; longest = std::max(longest, *t); } // Energy: the fed share of intake, less the whole demand, all per period. const auto fed = scaled(budget.intake_limit.energy.value, feeding_per_thousand); if (fed <= budget.demand.value) return std::nullopt; std::uint64_t surplus{}; if (!multiply(surplus, fed - budget.demand.value, periods_per_second) || surplus == 0) return std::nullopt; const auto need = budget.reproduction_investment.energy.value; longest = std::max(longest, need / surplus + (need % surplus != 0 ? 1 : 0)); return longest; } } // namespace evo::biology