Add phenotype-derived cellular motion proposal
Foundation / checks (deploy) (push) Successful in 5s
Foundation / checks (ecs) (push) Successful in 1m58s
Foundation / checks (postgres) (push) Canceled after 0s
Foundation / checks (tsan) (push) Canceled after 0s
Foundation / postgres-tools (push) Canceled after 0s
Foundation / server-image (push) Canceled after 0s
Foundation / image (push) Canceled after 0s
Foundation / checks (network) (push) Canceled after 6s
Foundation / checks (client) (push) Canceled after 2m14s
Foundation / checks (checks) (push) Canceled after 2m17s

This commit is contained in:
dingo
2026-10-10 21:08:50 -04:00
parent 0b607bae53
commit a97c5f3204
6 changed files with 314 additions and 5 deletions
+9 -1
View File
@@ -66,7 +66,10 @@ target_include_directories(evo_accounting PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/in
target_compile_features(evo_accounting PUBLIC cxx_std_23)
evo_owned_target(evo_accounting)
add_library(evo_biology STATIC src/biology/genome.cpp src/biology/development.cpp src/biology/metabolism.cpp src/biology/mutation.cpp src/biology/lineage.cpp src/biology/founder.cpp)
add_library(evo_biology STATIC
src/biology/genome.cpp src/biology/development.cpp src/biology/metabolism.cpp
src/biology/mutation.cpp src/biology/lineage.cpp src/biology/founder.cpp
src/biology/cellular_motion.cpp)
add_library(evo::biology ALIAS evo_biology)
target_include_directories(evo_biology PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/include")
target_link_libraries(evo_biology PUBLIC evo::accounting)
@@ -421,6 +424,11 @@ if(BUILD_TESTING)
add_test(NAME development-contracts COMMAND evo-development-tests)
set_tests_properties(development-contracts PROPERTIES TIMEOUT 60)
add_executable(evo-metabolism-tests tests/metabolism_tests.cpp)
add_executable(evo-cellular-motion-tests tests/cellular_motion_tests.cpp)
target_link_libraries(evo-cellular-motion-tests PRIVATE evo::biology)
evo_owned_target(evo-cellular-motion-tests)
add_test(NAME cellular-motion-contracts COMMAND evo-cellular-motion-tests)
set_tests_properties(cellular-motion-contracts PROPERTIES TIMEOUT 60)
add_executable(evo-primitive-lives-tests tests/primitive_lives_tests.cpp)
target_link_libraries(evo-primitive-lives-tests PRIVATE evo::lifecycle)
evo_owned_target(evo-primitive-lives-tests)
+6 -4
View File
@@ -21,8 +21,9 @@ patches without client authority over speed or position.
- A cellular trial domain is a finite, axis-aligned 2D rectangle in one
region/frame, expressed in integer micrometres. Its width and height are
positive multiples of ADR-0101's patch pitch; the provisioned extent is
explicit and bounded. There is no wraparound. A body cannot leave the
rectangle; a movement step that reaches an edge is clamped there.
explicit and bounded to 1,000,000 μm per axis in this trial. There is no
wraparound. A body cannot leave the rectangle; a movement step that reaches
an edge is clamped there.
- An organism's position is the lower-left corner of its square footprint,
matching the existing primitive spawn-site overlap convention. Current
phenotype extent determines that square. Spawn/restore rejects positions
@@ -37,8 +38,9 @@ patches without client authority over speed or position.
speed capacity. Invalid or stale intentions do not alter state.
- Movement energy is derived from `MetabolicBudget::movement`, proportional to
actual displacement relative to the full-speed tick distance and rounded up:
`ceil(full_speed_tick_cost * floor_sqrt(dx²+dy²) / per_tick_speed)`. Checked
quotient/remainder arithmetic is required; overflow refuses the whole step.
`ceil(full_speed_tick_cost * ceil_sqrt(dx²+dy²) / per_tick_speed)`. The
distance rounds up so the discrete approximation cannot undercharge motion.
Checked quotient/remainder arithmetic is required; overflow refuses the whole step.
A zero per-tick speed or zero displacement costs zero. The movement resolver
reports a proposed cost; the state owner applies the move only if the reserve
can fund that cost. This resolver does not also spend maintenance, which
+20
View File
@@ -5818,3 +5818,23 @@ The Linux/PostgreSQL process suite now includes an isolated profile-3 lifecycle:
owner-provision genesis, authenticate over v5, publish a founder, gracefully restart,
and query the same immutable identity/commit receipt after recovery. This regression
was added but cannot run locally on this Windows host; its CI evidence remains pending.
## 2026-10-10 — M11.3b-1 phenotype-derived motion proposal (CI pending)
Added the pure cellular motion proposal and square-footprint contact helper under
`evo::biology`. It uses the v2 per-second founder budget and 50 ms tick, clamps the
20 μm-class body inside a bounded trial area, reports movement energy without
spending it, and rejects invalid vectors, positions and rate periods. Focused tests
cover cardinal/diagonal movement, directional rounding, energy cost, boundaries,
unsupported rates and edge contact. No network, persistence, feeding or server
integration is included yet.
Executed locally: MSVC 19.44 warning-as-error Debug compile/link and focused CTest
(1/1 passed); direct MSVC Release/NDEBUG compile/run (passed); clang-format 19.1.5
dry-run; clang-tidy 19.1.5 against the generated compile database; and
`git diff --check`. The CMake configure completed with Visual Studio CMake 3.31.6
and module scanning disabled (the project does not use C++ modules), but the Ninja
build target idled at 0 CPU and was stopped; the test executable was compiled
directly and then run by CTest. Linux GCC, ASan+UBSan and server/PostgreSQL process
qualification remain pending CI. This small resolver does not make 11.3 or a
playtest-ready cellular stage complete.
+54
View File
@@ -0,0 +1,54 @@
#pragma once
#include "evo/biology/metabolism.hpp"
#include <compare>
#include <cstdint>
#include <expected>
namespace evo::biology {
inline constexpr std::uint64_t cellular_motion_tick_microseconds = 50'000;
inline constexpr std::uint64_t cellular_motion_axis_limit_um = 1'000'000;
inline constexpr std::int32_t cellular_intent_component_limit = 1'000;
struct CellularArea {
std::uint64_t width_um{}, height_um{};
auto operator<=>(const CellularArea&) const = default;
};
// Lower-left corner of the cell's square footprint, in micrometres.
struct CellularPosition {
std::uint64_t x_um{}, y_um{};
auto operator<=>(const CellularPosition&) const = default;
};
// Bounded movement direction/magnitude, not a position or speed claim.
struct CellularIntent {
std::int16_t x{}, y{};
auto operator<=>(const CellularIntent&) const = default;
};
struct CellularMotionProposal {
CellularPosition position;
std::uint64_t distance_um{}; // Conservative integer upper bound on actual travel.
accounting::Picojoules movement_cost{};
auto operator<=>(const CellularMotionProposal&) const = default;
};
enum class CellularMotionError : std::uint8_t {
invalid_area,
invalid_extent,
outside_area,
invalid_intent,
unsupported_rate_period,
overflow
};
// Pure M11.3 proposal for one 50 ms tick. Costs are reported, not spent; the
// authoritative state owner must apply the proposal only when its reserve can
// fund the movement_cost. Only per-second development-v2 budgets are accepted.
[[nodiscard]] std::expected<CellularMotionProposal, CellularMotionError>
propose_cellular_motion(CellularArea area, CellularPosition position, std::uint32_t extent_um,
CellularIntent intent, const MetabolicBudget& budget) noexcept;
// Axis-aligned square footprints touching at an edge count as in contact.
[[nodiscard]] bool cellular_footprints_contact(CellularPosition a, std::uint32_t extent_a_um,
CellularPosition b,
std::uint32_t extent_b_um) noexcept;
} // namespace evo::biology
+128
View File
@@ -0,0 +1,128 @@
#include "evo/biology/cellular_motion.hpp"
#include "evo/accounting/rates.hpp"
#include <limits>
namespace evo::biology {
namespace {
constexpr std::uint64_t rate_period_microseconds = 1'000'000;
std::uint64_t integer_sqrt(std::uint64_t value) noexcept {
std::uint64_t result{}, bit = std::uint64_t{1} << 62U;
while (bit > value)
bit >>= 2U;
while (bit != 0) {
if (value >= result + bit) {
value -= result + bit;
result = (result >> 1U) + bit;
} else {
result >>= 1U;
}
bit >>= 2U;
}
return result;
}
std::uint64_t integer_sqrt_ceil(std::uint64_t value) noexcept {
const auto floor = integer_sqrt(value);
return floor * floor == value ? floor : floor + 1;
}
bool valid(CellularIntent intent) noexcept {
if (intent.x < -cellular_intent_component_limit || intent.x > cellular_intent_component_limit ||
intent.y < -cellular_intent_component_limit || intent.y > cellular_intent_component_limit)
return false;
const auto x = static_cast<std::int64_t>(intent.x);
const auto y = static_cast<std::int64_t>(intent.y);
return x * x + y * y <=
std::int64_t{cellular_intent_component_limit} * cellular_intent_component_limit;
}
std::expected<std::uint64_t, CellularMotionError>
movement_cost(std::uint64_t full_cost, std::uint64_t distance,
std::uint64_t full_distance) noexcept {
if (distance == 0 || full_cost == 0)
return std::uint64_t{};
if (full_distance == 0 || distance > full_distance)
return std::unexpected{CellularMotionError::overflow};
const auto whole = full_cost / full_distance;
const auto remainder = full_cost % full_distance;
const auto base = whole * distance; // <= full_cost by construction.
const auto product = remainder * distance; // Both are bounded by uint32 speed per tick.
const auto fractional = product / full_distance + (product % full_distance != 0 ? 1 : 0);
if (fractional > std::numeric_limits<std::uint64_t>::max() - base)
return std::unexpected{CellularMotionError::overflow};
return base + fractional;
}
} // namespace
std::expected<CellularMotionProposal, CellularMotionError>
propose_cellular_motion(CellularArea area, CellularPosition position, std::uint32_t extent_um,
CellularIntent intent, const MetabolicBudget& budget) noexcept {
if (area.width_um == 0 || area.height_um == 0 ||
area.width_um > cellular_motion_axis_limit_um ||
area.height_um > cellular_motion_axis_limit_um)
return std::unexpected{CellularMotionError::invalid_area};
if (extent_um == 0 || extent_um > area.width_um || extent_um > area.height_um)
return std::unexpected{CellularMotionError::invalid_extent};
if (position.x_um > area.width_um - extent_um || position.y_um > area.height_um - extent_um)
return std::unexpected{CellularMotionError::outside_area};
if (!valid(intent))
return std::unexpected{CellularMotionError::invalid_intent};
if (budget.rate_microseconds != rate_period_microseconds)
return std::unexpected{CellularMotionError::unsupported_rate_period};
const auto max_step =
accounting::per_tick(budget.phenotype.movement_speed, cellular_motion_tick_microseconds,
accounting::Rounding::down);
const auto full_cost = accounting::per_tick(
budget.movement.value, cellular_motion_tick_microseconds, accounting::Rounding::up);
if (!max_step || !full_cost)
return std::unexpected{CellularMotionError::overflow};
if (*max_step > static_cast<std::uint64_t>(std::numeric_limits<std::int64_t>::max()) /
cellular_intent_component_limit)
return std::unexpected{CellularMotionError::overflow};
const auto dx = static_cast<std::int64_t>(intent.x) * static_cast<std::int64_t>(*max_step) /
cellular_intent_component_limit;
const auto dy = static_cast<std::int64_t>(intent.y) * static_cast<std::int64_t>(*max_step) /
cellular_intent_component_limit;
const auto max_x = area.width_um - extent_um;
const auto max_y = area.height_um - extent_um;
const auto next_x =
static_cast<std::uint64_t>(dx < 0 ? (static_cast<std::uint64_t>(-dx) > position.x_um
? 0
: static_cast<std::int64_t>(position.x_um) + dx)
: (dx > static_cast<std::int64_t>(max_x - position.x_um)
? max_x
: static_cast<std::int64_t>(position.x_um) + dx));
const auto next_y =
static_cast<std::uint64_t>(dy < 0 ? (static_cast<std::uint64_t>(-dy) > position.y_um
? 0
: static_cast<std::int64_t>(position.y_um) + dy)
: (dy > static_cast<std::int64_t>(max_y - position.y_um)
? max_y
: static_cast<std::int64_t>(position.y_um) + dy));
const auto moved_x = next_x >= position.x_um ? next_x - position.x_um : position.x_um - next_x;
const auto moved_y = next_y >= position.y_um ? next_y - position.y_um : position.y_um - next_y;
const auto distance = integer_sqrt_ceil(moved_x * moved_x + moved_y * moved_y);
const auto cost = movement_cost(*full_cost, distance, *max_step);
if (!cost)
return std::unexpected{cost.error()};
return CellularMotionProposal{{next_x, next_y}, distance, {*cost}};
}
bool cellular_footprints_contact(CellularPosition a, std::uint32_t extent_a_um, CellularPosition b,
std::uint32_t extent_b_um) noexcept {
if (extent_a_um == 0 || extent_b_um == 0)
return false;
const auto axis_touches = [](std::uint64_t a_start, std::uint32_t a_extent,
std::uint64_t b_start, std::uint32_t b_extent) {
return a_start <= b_start ? b_start - a_start <= a_extent : a_start - b_start <= b_extent;
};
return axis_touches(a.x_um, extent_a_um, b.x_um, extent_b_um) &&
axis_touches(a.y_um, extent_a_um, b.y_um, extent_b_um);
}
} // namespace evo::biology
+97
View File
@@ -0,0 +1,97 @@
#include "evo/biology/cellular_motion.hpp"
#include <cstdio>
#include <source_location>
#include <stdexcept>
#include <string>
namespace {
using namespace evo::biology;
void check(bool value, std::source_location at = std::source_location::current()) {
if (!value)
throw std::runtime_error("cellular motion line " + std::to_string(at.line()));
}
#define CHECK(...) check(static_cast<bool>(__VA_ARGS__))
MetabolicBudget budget(std::uint32_t speed_um_per_second = 200,
std::uint64_t movement_pj_per_second = 1'000) {
MetabolicBudget result{};
result.phenotype.movement_speed = speed_um_per_second;
result.movement = {movement_pj_per_second};
result.rate_microseconds = 1'000'000;
return result;
}
void movement_proposals() {
const CellularArea area{400, 300};
const CellularPosition start{100, 100};
const auto east = propose_cellular_motion(area, start, 20, {1000, 0}, budget());
CHECK(east && east->position == CellularPosition{110, 100});
CHECK(east->distance_um == 10 && east->movement_cost.value == 50);
const auto partial = propose_cellular_motion(area, start, 20, {500, 0}, budget());
CHECK(partial && partial->position == CellularPosition{105, 100});
CHECK(partial->distance_um == 5 && partial->movement_cost.value == 25);
const auto diagonal = propose_cellular_motion(area, start, 20, {707, 707}, budget());
CHECK(diagonal && diagonal->position == CellularPosition{107, 107});
CHECK(diagonal->distance_um == 10 && diagonal->movement_cost.value == 50);
const auto west = propose_cellular_motion(area, start, 20, {-1000, 0}, budget());
CHECK(west && west->position == CellularPosition{90, 100});
CHECK(west->movement_cost.value == 50);
const auto stopped = propose_cellular_motion(area, start, 20, {0, 0}, budget());
CHECK(stopped && stopped->position == start && stopped->distance_um == 0 &&
stopped->movement_cost.value == 0);
}
void edges_and_invalid_state() {
const auto east_edge = propose_cellular_motion({400, 300}, {370, 100}, 20, {1000, 0}, budget());
CHECK(east_edge && east_edge->position == CellularPosition{380, 100});
CHECK(east_edge->distance_um == 10 && east_edge->movement_cost.value == 50);
const auto pinned = propose_cellular_motion({400, 300}, {380, 100}, 20, {1000, 0}, budget());
CHECK(pinned && pinned->position == CellularPosition{380, 100});
CHECK(pinned->distance_um == 0 && pinned->movement_cost.value == 0);
const auto south_edge = propose_cellular_motion({400, 300}, {100, 1}, 20, {0, -1000}, budget());
CHECK(south_edge && south_edge->position == CellularPosition{100, 0});
CHECK(south_edge->distance_um == 1 && south_edge->movement_cost.value == 5);
CHECK(!propose_cellular_motion({0, 300}, {0, 0}, 20, {}, budget()));
CHECK(!propose_cellular_motion({cellular_motion_axis_limit_um + 1, 300}, {0, 0}, 20, {},
budget()));
CHECK(!propose_cellular_motion({400, 300}, {0, 0}, 0, {}, budget()));
CHECK(!propose_cellular_motion({400, 300}, {390, 0}, 20, {}, budget()));
CHECK(!propose_cellular_motion({400, 300}, {0, 0}, 401, {}, budget()));
CHECK(!propose_cellular_motion({400, 300}, {100, 100}, 20, {1000, 1000}, budget()));
auto wrong_rate_period = budget();
wrong_rate_period.rate_microseconds = 50'000;
CHECK(!propose_cellular_motion({400, 300}, {100, 100}, 20, {}, wrong_rate_period));
// The per-tick speed rounds down by ADR-0099; no phantom sub-micrometre step.
const auto quantized =
propose_cellular_motion({400, 300}, {100, 100}, 20, {1000, 0}, budget(19));
CHECK(quantized && quantized->position == CellularPosition{100, 100});
CHECK(quantized->movement_cost.value == 0);
}
void contact_geometry() {
CHECK(cellular_footprints_contact({0, 0}, 20, {20, 0}, 20)); // Exact edge touch.
CHECK(cellular_footprints_contact({0, 0}, 20, {19, 19}, 20));
CHECK(!cellular_footprints_contact({0, 0}, 20, {21, 0}, 20));
CHECK(!cellular_footprints_contact({0, 0}, 0, {0, 0}, 20));
CHECK(cellular_footprints_contact({1'000'000, 1'000'000}, 20, {1'000'020, 1'000'020}, 20));
}
} // namespace
int main() {
try {
movement_proposals();
edges_and_invalid_state();
contact_geometry();
std::puts("PASS cellular motion: phenotype speed, energy cost, bounds and contact");
} catch (const std::exception& error) {
std::fprintf(stderr, "%s\n", error.what());
return 1;
}
}