Foundation / checks (checks) (push) Successful in 5s
Foundation / checks (client) (push) Successful in 4s
Foundation / checks (network) (push) Successful in 5s
Foundation / checks (ecs) (push) Successful in 5s
Foundation / checks (postgres) (push) Successful in 5s
Foundation / checks (tsan) (push) Successful in 4s
Foundation / checks (deploy) (push) Successful in 4m28s
Foundation / postgres-tools (push) Successful in 25s
Foundation / server-image (push) Successful in 4m3s
Foundation / image (push) Successful in 4m28s
Rules 12 lives carry a liquid input (motion state, handling, brake and the local flow sample) and step through propose_liquid_cellular_step: maintenance first, then one kinematic tick funded from what is left, so unfundable thrust coasts with the current. A format-3 habitat requires liquid input on every life and older habitats refuse it. Contact feeding sweeps each liquid cell's whole path so a fast cell cannot pass over food; frozen cells keep their motion; corpse bubbles in a format-3 habitat count one merged bubble and use the larger deposit limit. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
157 lines
7.1 KiB
C++
157 lines
7.1 KiB
C++
#include "evo/biology/cellular_step.hpp"
|
|
|
|
#include "evo/accounting/rates.hpp"
|
|
#include "evo/biology/cellular_motion.hpp"
|
|
|
|
#include <limits>
|
|
|
|
namespace evo::biology {
|
|
namespace {
|
|
constexpr std::uint64_t rate_period_microseconds = 1'000'000;
|
|
|
|
bool credit_heat(accounting::Inventory& heat, std::uint64_t amount) noexcept {
|
|
if (heat.energy.value > std::numeric_limits<std::uint64_t>::max() - amount)
|
|
return false;
|
|
heat.energy.value += amount;
|
|
return true;
|
|
}
|
|
} // namespace
|
|
|
|
std::expected<CellularStepCandidate, CellularStepError>
|
|
propose_cellular_step(std::uint64_t begin_tick, CellularArea area, CellularPosition position,
|
|
std::uint32_t extent_um, CellularStepIntent intent,
|
|
accounting::Inventory reserve, accounting::Inventory heat,
|
|
const MetabolicBudget& budget, const CellularHabitat& habitat) noexcept {
|
|
if (begin_tick == std::numeric_limits<std::uint64_t>::max())
|
|
return std::unexpected{CellularStepError::invalid_tick};
|
|
if (budget.rate_microseconds != rate_period_microseconds)
|
|
return std::unexpected{CellularStepError::unsupported_rate_period};
|
|
if (area.width_um != habitat.config().width_um || area.height_um != habitat.config().height_um)
|
|
return std::unexpected{CellularStepError::motion};
|
|
|
|
const auto maintenance = accounting::per_tick(
|
|
budget.maintenance.value, cellular_motion_tick_microseconds, accounting::Rounding::up);
|
|
if (!maintenance)
|
|
return std::unexpected{CellularStepError::overflow};
|
|
if (reserve.energy.value < *maintenance)
|
|
return std::unexpected{CellularStepError::insufficient_maintenance};
|
|
if (!credit_heat(heat, *maintenance))
|
|
return std::unexpected{CellularStepError::overflow};
|
|
reserve.energy.value -= *maintenance;
|
|
|
|
const auto original_position = position;
|
|
const bool movement_requested = intent.movement.x != 0 || intent.movement.y != 0;
|
|
const auto movement = propose_funded_cellular_motion(area, position, extent_um, intent.movement,
|
|
budget, reserve, heat);
|
|
if (!movement && movement.error() != CellularMotionError::insufficient_reserve)
|
|
return std::unexpected{CellularStepError::motion};
|
|
if (movement) {
|
|
position = movement->position;
|
|
reserve = movement->reserve_after;
|
|
heat = movement->heat_after;
|
|
}
|
|
|
|
CellularStepCandidate candidate{begin_tick,
|
|
begin_tick + 1,
|
|
position,
|
|
reserve,
|
|
heat,
|
|
{*maintenance},
|
|
{},
|
|
CellularMovementStatus::not_requested,
|
|
CellularIntakeStatus::not_requested,
|
|
{}};
|
|
if (!movement_requested) {
|
|
candidate.movement_status = CellularMovementStatus::not_requested;
|
|
} else if (!movement) {
|
|
candidate.movement_status = CellularMovementStatus::insufficient_reserve;
|
|
} else if (movement->position == original_position) {
|
|
candidate.movement_status = CellularMovementStatus::blocked;
|
|
} else {
|
|
candidate.movement_status = CellularMovementStatus::moved;
|
|
}
|
|
if (movement) {
|
|
candidate.movement_cost = movement->movement_cost;
|
|
}
|
|
if (!intent.intake_target)
|
|
return candidate;
|
|
|
|
const auto intake =
|
|
habitat.propose_uptake(*intent.intake_target, position, extent_um, reserve, budget);
|
|
if (!intake) {
|
|
if (intake.error() == CellularHabitatError::missing_patch) {
|
|
candidate.intake_status = CellularIntakeStatus::missing;
|
|
return candidate;
|
|
}
|
|
if (intake.error() == CellularHabitatError::not_in_contact) {
|
|
candidate.intake_status = CellularIntakeStatus::out_of_contact;
|
|
return candidate;
|
|
}
|
|
return std::unexpected{intake.error() == CellularHabitatError::uptake
|
|
? CellularStepError::overflow
|
|
: CellularStepError::motion};
|
|
}
|
|
candidate.reserve_after = intake->transfer.reserve_after;
|
|
candidate.intake_status = CellularIntakeStatus::acquired;
|
|
candidate.intake = *intake;
|
|
return candidate;
|
|
}
|
|
|
|
std::expected<CellularStepCandidate, CellularStepError>
|
|
propose_liquid_cellular_step(std::uint64_t begin_tick, CellularArea area, CellularPosition position,
|
|
std::uint32_t extent_um, CellularIntent movement,
|
|
const CellularLiquidInput& liquid, accounting::Inventory reserve,
|
|
accounting::Inventory heat, const MetabolicBudget& budget) noexcept {
|
|
if (begin_tick == std::numeric_limits<std::uint64_t>::max())
|
|
return std::unexpected{CellularStepError::invalid_tick};
|
|
if (budget.rate_microseconds != rate_period_microseconds)
|
|
return std::unexpected{CellularStepError::unsupported_rate_period};
|
|
const auto maintenance = accounting::per_tick(
|
|
budget.maintenance.value, cellular_motion_tick_microseconds, accounting::Rounding::up);
|
|
if (!maintenance)
|
|
return std::unexpected{CellularStepError::overflow};
|
|
if (reserve.energy.value < *maintenance)
|
|
return std::unexpected{CellularStepError::insufficient_maintenance};
|
|
if (!credit_heat(heat, *maintenance))
|
|
return std::unexpected{CellularStepError::overflow};
|
|
reserve.energy.value -= *maintenance;
|
|
|
|
const auto motion =
|
|
step_cellular_kinematics(area, position, extent_um, liquid.motion, {movement, liquid.brake},
|
|
liquid.handling, liquid.flow, reserve.energy);
|
|
if (!motion)
|
|
return std::unexpected{CellularStepError::motion};
|
|
if (!credit_heat(heat, motion->cost.value))
|
|
return std::unexpected{CellularStepError::overflow};
|
|
reserve.energy.value -= motion->cost.value;
|
|
|
|
CellularStepCandidate candidate{};
|
|
candidate.begin_tick = begin_tick;
|
|
candidate.end_tick = begin_tick + 1;
|
|
candidate.position = motion->position;
|
|
candidate.reserve_after = reserve;
|
|
candidate.heat_after = heat;
|
|
candidate.maintenance_cost = {*maintenance};
|
|
candidate.movement_cost = motion->cost;
|
|
candidate.motion = motion->state;
|
|
candidate.path_um = motion->path_um;
|
|
switch (motion->thrust) {
|
|
case CellularThrustStatus::idle:
|
|
candidate.movement_status = CellularMovementStatus::not_requested;
|
|
break;
|
|
case CellularThrustStatus::unfunded:
|
|
candidate.movement_status = CellularMovementStatus::insufficient_reserve;
|
|
break;
|
|
case CellularThrustStatus::applied:
|
|
// Blocked only when an edge stopped it; a sub-micrometre start is still moving.
|
|
candidate.movement_status = motion->position == position &&
|
|
motion->state.velocity_x_q10 == 0 &&
|
|
motion->state.velocity_y_q10 == 0
|
|
? CellularMovementStatus::blocked
|
|
: CellularMovementStatus::moved;
|
|
break;
|
|
}
|
|
return candidate;
|
|
}
|
|
} // namespace evo::biology
|