Deliver cellular tick diagnostics to owners
Foundation / checks (deploy) (push) Successful in 5s
Foundation / checks (checks) (push) Failing after 39s
Foundation / checks (ecs) (push) Successful in 1m55s
Foundation / checks (postgres) (push) Failing after 52s
Foundation / checks (tsan) (push) Failing after 33s
Foundation / checks (network) (push) Failing after 3m1s
Foundation / checks (client) (push) Failing after 4m30s
Foundation / postgres-tools (push) Skipped
Foundation / server-image (push) Skipped
Foundation / image (push) Skipped
Foundation / checks (deploy) (push) Successful in 5s
Foundation / checks (checks) (push) Failing after 39s
Foundation / checks (ecs) (push) Successful in 1m55s
Foundation / checks (postgres) (push) Failing after 52s
Foundation / checks (tsan) (push) Failing after 33s
Foundation / checks (network) (push) Failing after 3m1s
Foundation / checks (client) (push) Failing after 4m30s
Foundation / postgres-tools (push) Skipped
Foundation / server-image (push) Skipped
Foundation / image (push) Skipped
This commit is contained in:
@@ -125,7 +125,7 @@ void launcher(const PanelView& v, FormBuffers& form, PanelActions& a) {
|
||||
ImGui::InputText("Dev CA file", form.authority.data(), form.authority.size());
|
||||
ImGui::InputText("Grant bundle file", form.grants.data(), form.grants.size());
|
||||
bool cellular_trial = v.cellular_trial;
|
||||
if (ImGui::Checkbox("Cellular trial (v8)", &cellular_trial))
|
||||
if (ImGui::Checkbox("Cellular trial (v9)", &cellular_trial))
|
||||
a.cellular_trial = cellular_trial;
|
||||
const bool start = phase == LaunchPhase::choosing && ImGui::Button("Connect", {px(160), 0});
|
||||
ImGui::EndDisabled();
|
||||
@@ -411,6 +411,52 @@ void session(const PanelView& v, PanelActions& a) {
|
||||
ImGui::Text("Life %llu, tick %llu",
|
||||
static_cast<unsigned long long>(v.cellular_perception->life_identity),
|
||||
static_cast<unsigned long long>(v.cellular_perception->tick));
|
||||
if (const auto& diagnostics = v.cellular_perception->diagnostics) {
|
||||
const auto& matter = diagnostics->reserve_matter_fg;
|
||||
ImGui::TextWrapped("Reserve %llu pJ | C %llu N %llu P %llu O %llu fg",
|
||||
static_cast<unsigned long long>(diagnostics->reserve_energy_pj),
|
||||
static_cast<unsigned long long>(matter[0]),
|
||||
static_cast<unsigned long long>(matter[1]),
|
||||
static_cast<unsigned long long>(matter[2]),
|
||||
static_cast<unsigned long long>(matter[3]));
|
||||
const auto movement_name = [&] {
|
||||
switch (diagnostics->movement) {
|
||||
case network::CellularMovementResult::not_reported:
|
||||
return "unavailable";
|
||||
case network::CellularMovementResult::no_movement:
|
||||
return "no movement";
|
||||
case network::CellularMovementResult::moved:
|
||||
return "moved";
|
||||
case network::CellularMovementResult::blocked:
|
||||
return "blocked";
|
||||
case network::CellularMovementResult::insufficient_energy:
|
||||
return "insufficient reserve";
|
||||
}
|
||||
return "unknown";
|
||||
};
|
||||
const auto intake_name = [&] {
|
||||
switch (diagnostics->intake) {
|
||||
case network::CellularIntakeResult::not_reported:
|
||||
return "unavailable";
|
||||
case network::CellularIntakeResult::not_requested:
|
||||
return "not feeding";
|
||||
case network::CellularIntakeResult::acquired:
|
||||
return "acquired";
|
||||
case network::CellularIntakeResult::missing_patch:
|
||||
return "patch missing";
|
||||
case network::CellularIntakeResult::out_of_contact:
|
||||
return "out of contact";
|
||||
}
|
||||
return "unknown";
|
||||
};
|
||||
ImGui::TextWrapped(
|
||||
"Last tick: maintenance %llu pJ, movement %llu pJ; %s; feeding %s",
|
||||
static_cast<unsigned long long>(diagnostics->maintenance_cost_pj),
|
||||
static_cast<unsigned long long>(diagnostics->movement_cost_pj), movement_name(),
|
||||
intake_name());
|
||||
if (!diagnostics->has_tick_effects)
|
||||
ImGui::TextDisabled("Tick effects unavailable after recovery.");
|
||||
}
|
||||
ImGui::TextDisabled("Steer with movement keys. Feeding continues until stopped.");
|
||||
if (v.cellular_feed_target && ImGui::SmallButton("Stop feeding"))
|
||||
a.stop_feeding = true;
|
||||
@@ -423,11 +469,11 @@ void session(const PanelView& v, PanelActions& a) {
|
||||
ImGui::PushID(static_cast<int>(i));
|
||||
ImGui::Text("Patch (%u, %u) um", patch.x_um, patch.y_um);
|
||||
ImGui::TextWrapped("Energy %llu pJ | C %llu N %llu P %llu O %llu fg",
|
||||
static_cast<unsigned long long>(patch.energy_pj),
|
||||
static_cast<unsigned long long>(patch.matter_fg[0]),
|
||||
static_cast<unsigned long long>(patch.matter_fg[1]),
|
||||
static_cast<unsigned long long>(patch.matter_fg[2]),
|
||||
static_cast<unsigned long long>(patch.matter_fg[3]));
|
||||
static_cast<unsigned long long>(patch.energy_pj),
|
||||
static_cast<unsigned long long>(patch.matter_fg[0]),
|
||||
static_cast<unsigned long long>(patch.matter_fg[1]),
|
||||
static_cast<unsigned long long>(patch.matter_fg[2]),
|
||||
static_cast<unsigned long long>(patch.matter_fg[3]));
|
||||
const bool active = v.cellular_feed_target &&
|
||||
v.cellular_feed_target->first == patch.x_um &&
|
||||
v.cellular_feed_target->second == patch.y_um;
|
||||
|
||||
@@ -2,7 +2,7 @@
|
||||
// M10.5c remote dev session for the engineering client (ADR-0093, over ADR-0091/0092
|
||||
// sessions). Without EVO_CLIENT_NETWORK (a build without EVO_BUILD_QUIC) remote mode is
|
||||
// unavailable. The client only presents copies of replicated snapshots and sends bounded
|
||||
// bounded intentions; the explicit cellular trial uses reliable v8 actions and its
|
||||
// bounded intentions; the explicit cellular trial uses reliable v9 actions and its
|
||||
// owner-filtered perception view. Grant bytes stay inside the session: each is handed to one
|
||||
// connection and wiped here; never printed, shown or persisted.
|
||||
//
|
||||
@@ -413,7 +413,7 @@ class RemoteSession {
|
||||
return false;
|
||||
client::RegionSessionClientConfig config;
|
||||
if (cellular_trial_)
|
||||
config.protocol_version = network::session_protocol_v8;
|
||||
config.protocol_version = network::session_protocol_v9;
|
||||
const auto route = routes_.find(target_region_);
|
||||
config.transport = route != routes_.end() ? route->second : transport_;
|
||||
if (ticket_) { // A handoff: the ticket replaces a grant, once.
|
||||
|
||||
@@ -25,8 +25,8 @@
|
||||
|
||||
namespace evo::server_app {
|
||||
// Profile-4 network boundary. Biology and persistence remain owned by the cellular host;
|
||||
// this bridge handles admission, v7/v8 action receipts, public cell replication and
|
||||
// owner-filtered v8 perception.
|
||||
// this bridge handles admission, v7-v9 action receipts, public cell replication and
|
||||
// owner-filtered v8/v9 perception.
|
||||
class CellularBridge {
|
||||
public:
|
||||
static std::optional<CellularBridge> open(const M10Options& options,
|
||||
@@ -177,6 +177,48 @@ class CellularBridge {
|
||||
network::CellularPerception view;
|
||||
view.tick = tick;
|
||||
view.life_identity = life.identity.life;
|
||||
network::CellularLifeDiagnostics diagnostics;
|
||||
diagnostics.reserve_energy_pj = life.reserve.energy.value;
|
||||
for (std::size_t i = 0; i < diagnostics.reserve_matter_fg.size(); ++i)
|
||||
diagnostics.reserve_matter_fg[i] = life.reserve.matter[i].value;
|
||||
const auto feedback =
|
||||
std::ranges::lower_bound(state.last_tick_feedback(), life.identity.life, {},
|
||||
&server::CellularLifeTickFeedback::life_id);
|
||||
if (feedback != state.last_tick_feedback().end() &&
|
||||
feedback->life_id == life.identity.life && feedback->tick == tick) {
|
||||
diagnostics.has_tick_effects = true;
|
||||
diagnostics.maintenance_cost_pj = feedback->maintenance_cost.value;
|
||||
diagnostics.movement_cost_pj = feedback->movement_cost.value;
|
||||
switch (feedback->movement) {
|
||||
case biology::CellularMovementStatus::not_requested:
|
||||
diagnostics.movement = network::CellularMovementResult::no_movement;
|
||||
break;
|
||||
case biology::CellularMovementStatus::moved:
|
||||
diagnostics.movement = network::CellularMovementResult::moved;
|
||||
break;
|
||||
case biology::CellularMovementStatus::blocked:
|
||||
diagnostics.movement = network::CellularMovementResult::blocked;
|
||||
break;
|
||||
case biology::CellularMovementStatus::insufficient_reserve:
|
||||
diagnostics.movement = network::CellularMovementResult::insufficient_energy;
|
||||
break;
|
||||
}
|
||||
switch (feedback->intake) {
|
||||
case biology::CellularIntakeStatus::not_requested:
|
||||
diagnostics.intake = network::CellularIntakeResult::not_requested;
|
||||
break;
|
||||
case biology::CellularIntakeStatus::acquired:
|
||||
diagnostics.intake = network::CellularIntakeResult::acquired;
|
||||
break;
|
||||
case biology::CellularIntakeStatus::missing:
|
||||
diagnostics.intake = network::CellularIntakeResult::missing_patch;
|
||||
break;
|
||||
case biology::CellularIntakeStatus::out_of_contact:
|
||||
diagnostics.intake = network::CellularIntakeResult::out_of_contact;
|
||||
break;
|
||||
}
|
||||
}
|
||||
view.diagnostics = diagnostics;
|
||||
view.patches.reserve(perceived->size());
|
||||
for (const auto& patch : *perceived) {
|
||||
network::CellularPerceivedPatch visible;
|
||||
|
||||
@@ -377,7 +377,7 @@ scoped change before starting the next segment.
|
||||
after CI confirms the v8 server/client build.
|
||||
- Readiness update (2026-10-11): the maintainer reports that the Git checks
|
||||
passed, `evo-region` is running, and the client connects. This is operator
|
||||
confirmation of checks and connectivity; it does not establish that the v8
|
||||
confirmation of checks and connectivity; it does not establish that the
|
||||
cellular path was selected or that life creation, movement, feeding and the
|
||||
on-screen perception work in a hands-on session. Those outcomes and the
|
||||
exploratory notes remain the 11.3e exit evidence. The 11.4 mutation expansion
|
||||
@@ -391,12 +391,21 @@ scoped change before starting the next segment.
|
||||
- 11.3e-6a: ADR-0117 defines owner-only protocol v9 diagnostics for current
|
||||
reserve and the latest committed tick's maintenance, movement and intake result.
|
||||
The v9 codec keeps v8 bytes frozen and rejects malformed status combinations;
|
||||
standalone MSVC `NDEBUG` protocol tests pass. Server report projection and the
|
||||
client display remain the next parts of this subsection, with CI still pending.
|
||||
standalone MSVC `NDEBUG` protocol tests pass.
|
||||
- 11.3e-6b: tick results now expose transient authoritative life feedback from
|
||||
the committed cellular candidate. The profile bridge includes it only in the
|
||||
authenticated owner's v9 perception; v8 owner sessions continue to receive
|
||||
their frozen v8 payload. Recovery clears this non-persistent presentation
|
||||
feedback. Focused biology, lifecycle and QUIC tests cover these paths; CI is
|
||||
still pending.
|
||||
- 11.3e-6c: the cellular trial selects v9 and shows reserve inventories,
|
||||
maintenance and movement energy costs, movement outcome and feeding outcome.
|
||||
Recovery is identified when tick effects are unavailable. The playtest remains
|
||||
exploratory; the probe checklist needs a human run before 11.3 closes.
|
||||
|
||||
## Exit boundary
|
||||
|
||||
11.3 closes only when all five segments have evidence and the player-facing
|
||||
11.3 closes only when the documented segments have evidence and the player-facing
|
||||
single-region probe works against the authoritative server. 11.2 owner routing
|
||||
must also be closed before M11 claims persistent control across regions. Mutation,
|
||||
funded budding, complete permadeath, logout/resume and repeated-life playtesting
|
||||
|
||||
@@ -6629,3 +6629,20 @@ libraries predate v8, first missing the new client methods and then failing
|
||||
during old server-session setup. The full remote-session test, fresh client
|
||||
link, and CI run remain pending; no cellular runtime or playtest success is
|
||||
claimed.
|
||||
|
||||
## 2026-10-11 — M11.3e-6b/c v9 diagnostics delivery (CI pending)
|
||||
|
||||
The committed cellular tick now exposes transient per-life feedback, the
|
||||
cellular server bridge sends it only to the authenticated life owner over v9,
|
||||
and the client displays reserve inventory, the last tick's maintenance and
|
||||
movement costs, movement outcome and feeding outcome. v8 owner sessions still
|
||||
receive the byte-compatible v8 perception; restart clears transient tick
|
||||
effects. The QUIC test covers v9 owner filtering and v8 compatibility.
|
||||
|
||||
MSVC 19.44 compiled the changed biology, lifecycle, client-session and
|
||||
server-session translation units, the cellular step/lifecycle tests, the QUIC
|
||||
session test, the client panel and remote-session test with `/W4 /WX /DNDEBUG`.
|
||||
Visual Studio LLVM `clang-format --dry-run --Werror` and `git diff --check`
|
||||
passed. The configured CMake/Ninja build remained at `Re-checking globbed
|
||||
directories...` for 60 seconds and was stopped; the QUIC test executable,
|
||||
cellular runtime test executables, CI run and live-region probe have not run.
|
||||
|
||||
@@ -2,7 +2,7 @@
|
||||
|
||||
This is the first hands-on check of the cellular stage. It is a one-player,
|
||||
single-region engineering trial, not a balance sign-off or a claim that M11 is
|
||||
complete. Run it after CI is green for the v8 server and client changes.
|
||||
complete. Run it after CI is green for the v9 server and client changes.
|
||||
|
||||
## Start
|
||||
|
||||
@@ -20,7 +20,7 @@ development CA:
|
||||
|
||||
Replace the endpoint and certificate name with the values for the running dev
|
||||
region. The launcher can do the same: fill in endpoint, server name, CA and
|
||||
grant bundle, check **Cellular trial (v8)**, then connect. Do not select the
|
||||
grant bundle, check **Cellular trial (v9)**, then connect. Do not select the
|
||||
load-test grant bundle for an interactive session.
|
||||
|
||||
On first successful login, the client submits a stable first-life request. The
|
||||
|
||||
@@ -20,6 +20,12 @@ enum class CellularStepError : std::uint8_t {
|
||||
motion
|
||||
};
|
||||
enum class CellularIntakeStatus : std::uint8_t { not_requested, acquired, missing, out_of_contact };
|
||||
enum class CellularMovementStatus : std::uint8_t {
|
||||
not_requested,
|
||||
moved,
|
||||
blocked,
|
||||
insufficient_reserve
|
||||
};
|
||||
|
||||
// Complete detached candidate for one 50 ms life tick. Maintenance is charged
|
||||
// first; unaffordable motion leaves the cell stationary, then one targeted patch
|
||||
@@ -30,6 +36,7 @@ struct CellularStepCandidate {
|
||||
accounting::Inventory reserve_after;
|
||||
accounting::Inventory heat_after;
|
||||
accounting::Picojoules maintenance_cost{}, movement_cost{};
|
||||
CellularMovementStatus movement_status{CellularMovementStatus::not_requested};
|
||||
CellularIntakeStatus intake_status{CellularIntakeStatus::not_requested};
|
||||
std::optional<CellularPatchUptakeProposal> intake;
|
||||
auto operator<=>(const CellularStepCandidate&) const = default;
|
||||
|
||||
@@ -41,6 +41,14 @@ struct CellularLifeIntent {
|
||||
biology::CellularStepIntent intent{};
|
||||
auto operator<=>(const CellularLifeIntent&) const = default;
|
||||
};
|
||||
struct CellularLifeTickFeedback {
|
||||
std::uint64_t life_id{}, tick{};
|
||||
accounting::Inventory reserve;
|
||||
accounting::Picojoules maintenance_cost{}, movement_cost{};
|
||||
biology::CellularMovementStatus movement{biology::CellularMovementStatus::not_requested};
|
||||
biology::CellularIntakeStatus intake{biology::CellularIntakeStatus::not_requested};
|
||||
auto operator<=>(const CellularLifeTickFeedback&) const = default;
|
||||
};
|
||||
struct CellularLivesConfig {
|
||||
biology::CellularArea area{};
|
||||
std::uint64_t tick{};
|
||||
@@ -95,11 +103,12 @@ class CellularLives {
|
||||
[[nodiscard]] accounting::Inventory heat() const noexcept;
|
||||
[[nodiscard]] accounting::Inventory opening_total() const noexcept;
|
||||
[[nodiscard]] accounting::Inventory current_total() const noexcept;
|
||||
// Latest successful in-memory step report; omitted from snapshots and empty after restore.
|
||||
[[nodiscard]] std::span<const CellularLifeTickFeedback> last_tick_feedback() const noexcept;
|
||||
[[nodiscard]] std::vector<std::uint8_t> snapshot() const;
|
||||
// Exact stock view for one live cell, filtered by its authoritative footprint and the
|
||||
// M11.3 perception radius. Patch provenance and out-of-range stock are never returned.
|
||||
[[nodiscard]] std::expected<std::vector<biology::CellularPatchPerception>,
|
||||
CellularLivesError>
|
||||
[[nodiscard]] std::expected<std::vector<biology::CellularPatchPerception>, CellularLivesError>
|
||||
perceive(std::uint64_t life_id) const;
|
||||
|
||||
// Returns a detached post-birth candidate for an allocator-reserved request.
|
||||
@@ -123,5 +132,6 @@ class CellularLives {
|
||||
struct State;
|
||||
explicit CellularLives(std::unique_ptr<State> state);
|
||||
std::unique_ptr<State> state_;
|
||||
std::vector<CellularLifeTickFeedback> last_tick_feedback_;
|
||||
};
|
||||
} // namespace evo::server
|
||||
|
||||
@@ -100,7 +100,7 @@ struct RegionSessionsConfig {
|
||||
// M10.8d recovery: this often, open outgoing transfers prepared more than ticket_lifetime
|
||||
// + 10 s ago (by the store's clock, e.g. by a process that died) are aborted.
|
||||
std::chrono::milliseconds overdue_poll{5000};
|
||||
// v5/v8 are accepted only when both primitive-life handlers are supplied. Callbacks
|
||||
// v5/v8/v9 are accepted only when both primitive-life handlers are supplied. Callbacks
|
||||
// receive the authenticated account and durable control generation for this session.
|
||||
// A cellular host may enable v5 together with the v7 cellular action path; each
|
||||
// connection remains fixed to its negotiated protocol.
|
||||
@@ -112,7 +112,7 @@ struct RegionSessionsConfig {
|
||||
query_primitive_life;
|
||||
// M11.3 v6 cellular intentions. Opt-in until a cellular state owner consumes them.
|
||||
bool accept_cellular_intentions{};
|
||||
// M11.3 v7 durable cellular actions and v8 owner-filtered perception. Requires durable
|
||||
// M11.3 v7 durable cellular actions and v8/v9 owner-filtered perception. Requires durable
|
||||
// control and action ledgers; the caller forwards carried inputs to profile 4.
|
||||
bool accept_cellular_actions{};
|
||||
};
|
||||
|
||||
@@ -39,6 +39,8 @@ propose_cellular_step(std::uint64_t begin_tick, CellularArea area, CellularPosit
|
||||
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)
|
||||
@@ -49,12 +51,28 @@ propose_cellular_step(std::uint64_t begin_tick, CellularArea area, CellularPosit
|
||||
heat = movement->heat_after;
|
||||
}
|
||||
|
||||
CellularStepCandidate candidate{
|
||||
begin_tick, begin_tick + 1, position, reserve,
|
||||
heat, {*maintenance}, {}, CellularIntakeStatus::not_requested,
|
||||
{}};
|
||||
if (movement)
|
||||
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;
|
||||
|
||||
|
||||
@@ -159,7 +159,8 @@ RegionSessionClient::connect(RegionSessionClientConfig config, Clock::time_point
|
||||
config.protocol_version != network::session_protocol_v5 &&
|
||||
config.protocol_version != network::session_protocol_v6 &&
|
||||
config.protocol_version != network::session_protocol_v7 &&
|
||||
config.protocol_version != network::session_protocol_v8)
|
||||
config.protocol_version != network::session_protocol_v8 &&
|
||||
config.protocol_version != network::session_protocol_v9)
|
||||
return std::unexpected(network::quic::EndpointError::configuration);
|
||||
auto endpoint = network::quic::Endpoint::connect(config.transport);
|
||||
if (!endpoint)
|
||||
@@ -265,7 +266,8 @@ bool RegionSessionClient::send_cellular_action(
|
||||
std::optional<std::pair<std::uint32_t, std::uint32_t>> intake_target) {
|
||||
auto& m = *impl_;
|
||||
return (m.protocol_version == network::session_protocol_v7 ||
|
||||
m.protocol_version == network::session_protocol_v8) &&
|
||||
m.protocol_version == network::session_protocol_v8 ||
|
||||
m.protocol_version == network::session_protocol_v9) &&
|
||||
m.state == RegionSessionState::established && m.welcome && action_id != 0 && tick != 0 &&
|
||||
m.send(network::CellularAction{m.welcome->session, m.welcome->epoch, action_id, tick,
|
||||
move_x, move_y, intake_target.has_value(),
|
||||
@@ -277,14 +279,16 @@ bool RegionSessionClient::query_action(std::uint64_t action_id) {
|
||||
auto& m = *impl_;
|
||||
return (m.protocol_version == network::session_protocol_version ||
|
||||
m.protocol_version == network::session_protocol_v7 ||
|
||||
m.protocol_version == network::session_protocol_v8) &&
|
||||
m.protocol_version == network::session_protocol_v8 ||
|
||||
m.protocol_version == network::session_protocol_v9) &&
|
||||
m.state == RegionSessionState::established && m.send(network::ActionQuery{action_id});
|
||||
}
|
||||
|
||||
bool RegionSessionClient::request_primitive_life(std::uint64_t request_id) {
|
||||
auto& m = *impl_;
|
||||
return (m.protocol_version == network::session_protocol_v5 ||
|
||||
m.protocol_version == network::session_protocol_v8) &&
|
||||
m.protocol_version == network::session_protocol_v8 ||
|
||||
m.protocol_version == network::session_protocol_v9) &&
|
||||
m.state == RegionSessionState::established && m.welcome && request_id != 0 &&
|
||||
m.send(network::PrimitiveLifeRequest{m.welcome->session, m.welcome->epoch, request_id});
|
||||
}
|
||||
@@ -292,7 +296,8 @@ bool RegionSessionClient::request_primitive_life(std::uint64_t request_id) {
|
||||
bool RegionSessionClient::query_primitive_life(std::uint64_t request_id) {
|
||||
auto& m = *impl_;
|
||||
return (m.protocol_version == network::session_protocol_v5 ||
|
||||
m.protocol_version == network::session_protocol_v8) &&
|
||||
m.protocol_version == network::session_protocol_v8 ||
|
||||
m.protocol_version == network::session_protocol_v9) &&
|
||||
m.state == RegionSessionState::established && request_id != 0 &&
|
||||
m.send(network::PrimitiveLifeQuery{request_id});
|
||||
}
|
||||
@@ -329,7 +334,8 @@ bool RegionSessionClient::set_interest(const network::SessionInterest& interest)
|
||||
auto& m = *impl_;
|
||||
return (m.protocol_version == network::session_protocol_version ||
|
||||
m.protocol_version == network::session_protocol_v7 ||
|
||||
m.protocol_version == network::session_protocol_v8) &&
|
||||
m.protocol_version == network::session_protocol_v8 ||
|
||||
m.protocol_version == network::session_protocol_v9) &&
|
||||
m.state == RegionSessionState::established && m.send(interest);
|
||||
}
|
||||
|
||||
|
||||
@@ -101,8 +101,7 @@ bool add_inventory(accounting::Inventory& total, const accounting::Inventory& va
|
||||
return true;
|
||||
}
|
||||
|
||||
bool subtract_inventory(accounting::Inventory& total,
|
||||
const accounting::Inventory& value) noexcept {
|
||||
bool subtract_inventory(accounting::Inventory& total, const accounting::Inventory& value) noexcept {
|
||||
if (value.energy.value > total.energy.value)
|
||||
return false;
|
||||
for (std::size_t channel = 0; channel < total.matter.size(); ++channel)
|
||||
@@ -147,34 +146,31 @@ sum_state(accounting::Inventory nursery, accounting::Inventory heat,
|
||||
std::expected<accounting::Inventory, CellularLivesError>
|
||||
validate_state(std::uint64_t world, std::uint64_t region, std::uint64_t frame,
|
||||
const CellularLivesConfig& config, const NurseryConfig& nursery_config,
|
||||
const biology::CellularHabitat& habitat,
|
||||
std::span<const CellularOwnedLife> lives,
|
||||
std::span<const CellularOwnedCorpse> corpses,
|
||||
const biology::LineageArchive& archive, accounting::Inventory nursery,
|
||||
accounting::Inventory heat, accounting::Inventory opening_total) {
|
||||
const biology::CellularHabitat& habitat, std::span<const CellularOwnedLife> lives,
|
||||
std::span<const CellularOwnedCorpse> corpses, const biology::LineageArchive& archive,
|
||||
accounting::Inventory nursery, accounting::Inventory heat,
|
||||
accounting::Inventory opening_total) {
|
||||
const auto& map = habitat.config();
|
||||
if (world == 0 || region == 0 || frame == 0 || nursery_config.world != world ||
|
||||
nursery_config.region != region || nursery_config.frame != frame ||
|
||||
nursery_config.source == 0 || nursery_config.funding != nursery ||
|
||||
map.world != world || map.region != region || map.frame != frame ||
|
||||
config.area.width_um == 0 || config.area.height_um == 0 ||
|
||||
map.width_um != config.area.width_um || map.height_um != config.area.height_um ||
|
||||
config.ambient_temperature_millikelvin == 0 ||
|
||||
nursery_config.source == 0 || nursery_config.funding != nursery || map.world != world ||
|
||||
map.region != region || map.frame != frame || config.area.width_um == 0 ||
|
||||
config.area.height_um == 0 || map.width_um != config.area.width_um ||
|
||||
map.height_um != config.area.height_um || config.ambient_temperature_millikelvin == 0 ||
|
||||
nursery_config.sites.empty() || nursery_config.sites.size() > max_primitive_lives ||
|
||||
!std::ranges::is_sorted(nursery_config.sites) ||
|
||||
lives.size() > biology::max_cellular_tick_lives ||
|
||||
corpses.size() > biology::max_archived_organisms ||
|
||||
archive.recorded() != lives.size() + corpses.size())
|
||||
return std::unexpected{CellularLivesError::invalid_config};
|
||||
if (std::ranges::any_of(heat.matter,
|
||||
[](const auto& value) { return value.value != 0; }))
|
||||
if (std::ranges::any_of(heat.matter, [](const auto& value) { return value.value != 0; }))
|
||||
return std::unexpected{CellularLivesError::conservation};
|
||||
|
||||
const auto founder = biology::primitive_founder(1, 1);
|
||||
if (!founder)
|
||||
return std::unexpected{CellularLivesError::biology};
|
||||
const auto founder_budget =
|
||||
biology::metabolic_budget(*founder, {1000, 0}, {config.ambient_temperature_millikelvin, {}});
|
||||
const auto founder_budget = biology::metabolic_budget(
|
||||
*founder, {1000, 0}, {config.ambient_temperature_millikelvin, {}});
|
||||
if (!founder_budget)
|
||||
return std::unexpected{CellularLivesError::biology};
|
||||
const auto spawn_extent = founder_budget->phenotype.extent;
|
||||
@@ -202,10 +198,9 @@ validate_state(std::uint64_t world, std::uint64_t region, std::uint64_t frame,
|
||||
for (std::size_t i = 0; i < lives.size(); ++i) {
|
||||
const auto& life = lives[i];
|
||||
if (life.account == LifeAccount{} || life.identity.life == 0 ||
|
||||
life.identity.organism == 0 || life.identity.genome == 0 ||
|
||||
life.identity.event == 0 || life.identity.born.value == 0 ||
|
||||
life.identity.born.value > config.tick || life.source == 0 ||
|
||||
(i != 0 && lives[i - 1].identity.life >= life.identity.life))
|
||||
life.identity.organism == 0 || life.identity.genome == 0 || life.identity.event == 0 ||
|
||||
life.identity.born.value == 0 || life.identity.born.value > config.tick ||
|
||||
life.source == 0 || (i != 0 && lives[i - 1].identity.life >= life.identity.life))
|
||||
return std::unexpected{CellularLivesError::invalid_life};
|
||||
for (std::size_t j = 0; j < i; ++j)
|
||||
if (lives[j].account == life.account ||
|
||||
@@ -217,8 +212,7 @@ validate_state(std::uint64_t world, std::uint64_t region, std::uint64_t frame,
|
||||
return std::unexpected{CellularLivesError::archive};
|
||||
const auto budget = budget_for(archive, life, config.ambient_temperature_millikelvin);
|
||||
if (!budget || budget->body != life.body || life.body.energy.value != 0 ||
|
||||
budget->phenotype.extent == 0 ||
|
||||
budget->phenotype.extent > config.area.width_um ||
|
||||
budget->phenotype.extent == 0 || budget->phenotype.extent > config.area.width_um ||
|
||||
budget->phenotype.extent > config.area.height_um ||
|
||||
life.position.x_um > config.area.width_um - budget->phenotype.extent ||
|
||||
life.position.y_um > config.area.height_um - budget->phenotype.extent)
|
||||
@@ -242,8 +236,8 @@ validate_state(std::uint64_t world, std::uint64_t region, std::uint64_t frame,
|
||||
const auto genome = archive.find(record->genome);
|
||||
if (!genome)
|
||||
return std::unexpected{CellularLivesError::archive};
|
||||
const auto budget = biology::metabolic_budget(
|
||||
*genome, corpse.growth, {config.ambient_temperature_millikelvin, {}});
|
||||
const auto budget = biology::metabolic_budget(*genome, corpse.growth,
|
||||
{config.ambient_temperature_millikelvin, {}});
|
||||
if (!budget || budget->phenotype.extent != corpse.extent_um ||
|
||||
corpse.extent_um > config.area.width_um || corpse.extent_um > config.area.height_um ||
|
||||
corpse.position.x_um > config.area.width_um - corpse.extent_um ||
|
||||
@@ -282,16 +276,14 @@ struct CellularLives::State {
|
||||
|
||||
State(std::uint64_t world_id, std::uint64_t region_id, std::uint64_t frame_id,
|
||||
CellularLivesConfig cfg, NurseryConfig nursery_definition,
|
||||
std::unique_ptr<biology::CellularHabitat> map,
|
||||
std::vector<CellularOwnedLife> living, std::vector<CellularOwnedCorpse> dead,
|
||||
const biology::LineageArchive& history, accounting::Inventory source,
|
||||
accounting::Inventory accumulated_heat, accounting::Inventory initial,
|
||||
accounting::Inventory current)
|
||||
std::unique_ptr<biology::CellularHabitat> map, std::vector<CellularOwnedLife> living,
|
||||
std::vector<CellularOwnedCorpse> dead, const biology::LineageArchive& history,
|
||||
accounting::Inventory source, accounting::Inventory accumulated_heat,
|
||||
accounting::Inventory initial, accounting::Inventory current)
|
||||
: world{world_id}, region{region_id}, frame{frame_id}, config{cfg},
|
||||
nursery_config{std::move(nursery_definition)},
|
||||
habitat{std::move(map)}, lives{std::move(living)}, corpses{std::move(dead)},
|
||||
archive{history}, nursery{source}, heat{accumulated_heat}, opening_total{initial},
|
||||
current_total{current} {}
|
||||
nursery_config{std::move(nursery_definition)}, habitat{std::move(map)},
|
||||
lives{std::move(living)}, corpses{std::move(dead)}, archive{history}, nursery{source},
|
||||
heat{accumulated_heat}, opening_total{initial}, current_total{current} {}
|
||||
};
|
||||
|
||||
CellularLives::CellularLives(std::unique_ptr<State> state) : state_{std::move(state)} {}
|
||||
@@ -319,8 +311,8 @@ CellularLives::create(const PrimitiveLives& opening,
|
||||
for (const auto& primitive : opening.lives()) {
|
||||
if (primitive.identity.born.value == 0 || primitive.identity.born.value > config.tick ||
|
||||
primitive.identity.life == 0 || primitive.identity.organism == 0 ||
|
||||
primitive.identity.genome == 0 || primitive.source == 0 ||
|
||||
primitive.site.x_um < 0 || primitive.site.y_um < 0)
|
||||
primitive.identity.genome == 0 || primitive.source == 0 || primitive.site.x_um < 0 ||
|
||||
primitive.site.y_um < 0)
|
||||
return std::unexpected{CellularLivesError::invalid_life};
|
||||
if (primitive.body.value == 0 || primitive.reserve.value == 0)
|
||||
return std::unexpected{CellularLivesError::invalid_life};
|
||||
@@ -342,8 +334,8 @@ CellularLives::create(const PrimitiveLives& opening,
|
||||
const auto& life = lives[i];
|
||||
if (i != 0 && lives[i - 1].identity.life == life.identity.life)
|
||||
return std::unexpected{CellularLivesError::duplicate_life};
|
||||
const auto budget = budget_for(opening.archive(), life,
|
||||
config.ambient_temperature_millikelvin);
|
||||
const auto budget =
|
||||
budget_for(opening.archive(), life, config.ambient_temperature_millikelvin);
|
||||
if (!budget || budget->phenotype.extent == 0 ||
|
||||
budget->phenotype.extent > config.area.width_um ||
|
||||
budget->phenotype.extent > config.area.height_um || life.body.energy.value != 0 ||
|
||||
@@ -367,36 +359,58 @@ CellularLives::create(const PrimitiveLives& opening,
|
||||
const auto world = nursery_config.world;
|
||||
const auto region = nursery_config.region;
|
||||
const auto frame = nursery_config.frame;
|
||||
auto state = std::make_unique<State>(
|
||||
world, region, frame, config,
|
||||
std::move(nursery_config),
|
||||
std::move(habitat), std::move(lives), std::vector<CellularOwnedCorpse>{},
|
||||
opening.archive(), nursery, heat, opening_total, *current);
|
||||
auto state = std::make_unique<State>(world, region, frame, config, std::move(nursery_config),
|
||||
std::move(habitat), std::move(lives),
|
||||
std::vector<CellularOwnedCorpse>{}, opening.archive(),
|
||||
nursery, heat, opening_total, *current);
|
||||
return std::unique_ptr<CellularLives>{new CellularLives{std::move(state)}};
|
||||
}
|
||||
|
||||
std::uint64_t CellularLives::world() const noexcept { return state_->world; }
|
||||
std::uint64_t CellularLives::region() const noexcept { return state_->region; }
|
||||
std::uint64_t CellularLives::frame() const noexcept { return state_->frame; }
|
||||
std::uint64_t CellularLives::tick() const noexcept { return state_->config.tick; }
|
||||
std::uint64_t CellularLives::world() const noexcept {
|
||||
return state_->world;
|
||||
}
|
||||
std::uint64_t CellularLives::region() const noexcept {
|
||||
return state_->region;
|
||||
}
|
||||
std::uint64_t CellularLives::frame() const noexcept {
|
||||
return state_->frame;
|
||||
}
|
||||
std::uint64_t CellularLives::tick() const noexcept {
|
||||
return state_->config.tick;
|
||||
}
|
||||
std::uint32_t CellularLives::ambient_temperature_millikelvin() const noexcept {
|
||||
return state_->config.ambient_temperature_millikelvin;
|
||||
}
|
||||
biology::CellularArea CellularLives::area() const noexcept { return state_->config.area; }
|
||||
std::span<const CellularOwnedLife> CellularLives::lives() const noexcept { return state_->lives; }
|
||||
biology::CellularArea CellularLives::area() const noexcept {
|
||||
return state_->config.area;
|
||||
}
|
||||
std::span<const CellularOwnedLife> CellularLives::lives() const noexcept {
|
||||
return state_->lives;
|
||||
}
|
||||
std::span<const CellularOwnedCorpse> CellularLives::corpses() const noexcept {
|
||||
return state_->corpses;
|
||||
}
|
||||
const biology::CellularHabitat& CellularLives::habitat() const noexcept { return *state_->habitat; }
|
||||
const biology::LineageArchive& CellularLives::archive() const noexcept { return state_->archive; }
|
||||
accounting::Inventory CellularLives::nursery() const noexcept { return state_->nursery; }
|
||||
accounting::Inventory CellularLives::heat() const noexcept { return state_->heat; }
|
||||
const biology::CellularHabitat& CellularLives::habitat() const noexcept {
|
||||
return *state_->habitat;
|
||||
}
|
||||
const biology::LineageArchive& CellularLives::archive() const noexcept {
|
||||
return state_->archive;
|
||||
}
|
||||
accounting::Inventory CellularLives::nursery() const noexcept {
|
||||
return state_->nursery;
|
||||
}
|
||||
accounting::Inventory CellularLives::heat() const noexcept {
|
||||
return state_->heat;
|
||||
}
|
||||
accounting::Inventory CellularLives::opening_total() const noexcept {
|
||||
return state_->opening_total;
|
||||
}
|
||||
accounting::Inventory CellularLives::current_total() const noexcept {
|
||||
return state_->current_total;
|
||||
}
|
||||
std::span<const CellularLifeTickFeedback> CellularLives::last_tick_feedback() const noexcept {
|
||||
return last_tick_feedback_;
|
||||
}
|
||||
|
||||
std::vector<std::uint8_t> CellularLives::snapshot() const {
|
||||
const auto habitat = state_->habitat->snapshot();
|
||||
@@ -408,7 +422,8 @@ std::vector<std::uint8_t> CellularLives::snapshot() const {
|
||||
cellular_life_bytes * life_count +
|
||||
cellular_corpse_bytes * corpse_count + habitat.size() +
|
||||
archive.size() + 8;
|
||||
if (total_bytes > max_cellular_lives_bytes || habitat.size() > biology::max_cellular_habitat_bytes ||
|
||||
if (total_bytes > max_cellular_lives_bytes ||
|
||||
habitat.size() > biology::max_cellular_habitat_bytes ||
|
||||
archive.size() > biology::max_archive_bytes || site_count > max_primitive_lives ||
|
||||
life_count > biology::max_cellular_tick_lives ||
|
||||
corpse_count > biology::max_archived_organisms)
|
||||
@@ -476,13 +491,12 @@ std::vector<std::uint8_t> CellularLives::snapshot() const {
|
||||
|
||||
std::expected<std::vector<biology::CellularPatchPerception>, CellularLivesError>
|
||||
CellularLives::perceive(std::uint64_t life_id) const {
|
||||
const auto life = std::ranges::find(state_->lives, life_id, [](const auto& owned) {
|
||||
return owned.identity.life;
|
||||
});
|
||||
const auto life = std::ranges::find(state_->lives, life_id,
|
||||
[](const auto& owned) { return owned.identity.life; });
|
||||
if (life == state_->lives.end())
|
||||
return std::unexpected{CellularLivesError::invalid_life};
|
||||
const auto budget = budget_for(state_->archive, *life,
|
||||
state_->config.ambient_temperature_millikelvin);
|
||||
const auto budget =
|
||||
budget_for(state_->archive, *life, state_->config.ambient_temperature_millikelvin);
|
||||
if (!budget)
|
||||
return std::unexpected{budget.error()};
|
||||
auto view = state_->habitat->perceive(life->position, budget->phenotype.extent);
|
||||
@@ -507,15 +521,19 @@ CellularLives::birth_candidate(LifeRequest request, LifeAllocation allocation) c
|
||||
return life.account == request.account;
|
||||
}))
|
||||
return std::unexpected{CellularLivesError::life_exists};
|
||||
if (std::ranges::any_of(state_->lives, [&](const CellularOwnedLife& life) {
|
||||
return life.identity.life == allocation.life ||
|
||||
life.identity.organism == allocation.organism ||
|
||||
life.identity.genome == allocation.genome ||
|
||||
life.identity.event == allocation.event;
|
||||
}) ||
|
||||
std::ranges::any_of(state_->corpses, [&](const CellularOwnedCorpse& corpse) {
|
||||
return corpse.life_id == allocation.life || corpse.organism == allocation.organism;
|
||||
}) || state_->archive.find(allocation.genome) || state_->archive.organism(allocation.organism))
|
||||
if (std::ranges::any_of(state_->lives,
|
||||
[&](const CellularOwnedLife& life) {
|
||||
return life.identity.life == allocation.life ||
|
||||
life.identity.organism == allocation.organism ||
|
||||
life.identity.genome == allocation.genome ||
|
||||
life.identity.event == allocation.event;
|
||||
}) ||
|
||||
std::ranges::any_of(state_->corpses,
|
||||
[&](const CellularOwnedCorpse& corpse) {
|
||||
return corpse.life_id == allocation.life ||
|
||||
corpse.organism == allocation.organism;
|
||||
}) ||
|
||||
state_->archive.find(allocation.genome) || state_->archive.organism(allocation.organism))
|
||||
return std::unexpected{CellularLivesError::duplicate_life};
|
||||
|
||||
const auto endowed = biology::primitive_endowment();
|
||||
@@ -523,8 +541,7 @@ CellularLives::birth_candidate(LifeRequest request, LifeAllocation allocation) c
|
||||
if (!endowed || !genome)
|
||||
return std::unexpected{CellularLivesError::biology};
|
||||
const auto budget = biology::metabolic_budget(
|
||||
*genome, endowed->growth,
|
||||
{state_->config.ambient_temperature_millikelvin, {}});
|
||||
*genome, endowed->growth, {state_->config.ambient_temperature_millikelvin, {}});
|
||||
if (!budget || budget->body != endowed->body)
|
||||
return std::unexpected{CellularLivesError::biology};
|
||||
|
||||
@@ -533,11 +550,11 @@ CellularLives::birth_candidate(LifeRequest request, LifeAllocation allocation) c
|
||||
if (site.x_um < 0 || site.y_um < 0)
|
||||
return std::unexpected{CellularLivesError::invalid_config};
|
||||
const biology::CellularPosition candidate{static_cast<std::uint64_t>(site.x_um),
|
||||
static_cast<std::uint64_t>(site.y_um)};
|
||||
static_cast<std::uint64_t>(site.y_um)};
|
||||
bool occupied = false;
|
||||
for (const auto& living : state_->lives) {
|
||||
const auto living_budget = budget_for(
|
||||
state_->archive, living, state_->config.ambient_temperature_millikelvin);
|
||||
const auto living_budget =
|
||||
budget_for(state_->archive, living, state_->config.ambient_temperature_millikelvin);
|
||||
if (!living_budget)
|
||||
return std::unexpected{living_budget.error()};
|
||||
const auto separated = [](std::uint64_t left, std::uint64_t right,
|
||||
@@ -568,8 +585,7 @@ CellularLives::birth_candidate(LifeRequest request, LifeAllocation allocation) c
|
||||
return std::unexpected{CellularLivesError::insufficient_funding};
|
||||
nursery.energy.value -= endowed->construction.value;
|
||||
auto heat = state_->heat;
|
||||
if (endowed->construction.value >
|
||||
std::numeric_limits<std::uint64_t>::max() - heat.energy.value)
|
||||
if (endowed->construction.value > std::numeric_limits<std::uint64_t>::max() - heat.energy.value)
|
||||
return std::unexpected{CellularLivesError::overflow};
|
||||
heat.energy.value += endowed->construction.value;
|
||||
|
||||
@@ -580,27 +596,25 @@ CellularLives::birth_candidate(LifeRequest request, LifeAllocation allocation) c
|
||||
auto lives = state_->lives;
|
||||
lives.push_back({request.account, allocation, state_->nursery_config.source, endowed->growth,
|
||||
*position, endowed->body, endowed->reserve});
|
||||
std::ranges::sort(lives, {}, [](const CellularOwnedLife& life) {
|
||||
return life.identity.life;
|
||||
});
|
||||
std::ranges::sort(lives, {}, [](const CellularOwnedLife& life) { return life.identity.life; });
|
||||
|
||||
auto nursery_config = state_->nursery_config;
|
||||
nursery_config.funding = nursery;
|
||||
auto habitat = biology::CellularHabitat::restore(state_->habitat->snapshot(), state_->world,
|
||||
state_->region, state_->frame);
|
||||
state_->region, state_->frame);
|
||||
if (!habitat)
|
||||
return std::unexpected{CellularLivesError::habitat};
|
||||
const auto current = validate_state(state_->world, state_->region, state_->frame,
|
||||
state_->config, nursery_config, **habitat, lives,
|
||||
state_->corpses, archive, nursery, heat,
|
||||
state_->opening_total);
|
||||
const auto current = validate_state(
|
||||
state_->world, state_->region, state_->frame, state_->config, nursery_config, **habitat,
|
||||
lives, state_->corpses, archive, nursery, heat, state_->opening_total);
|
||||
if (!current)
|
||||
return std::unexpected{current.error()};
|
||||
|
||||
auto candidate = std::unique_ptr<CellularLives>{new CellularLives{std::make_unique<State>(
|
||||
state_->world, state_->region, state_->frame, state_->config,
|
||||
std::move(nursery_config), std::move(*habitat), std::move(lives), state_->corpses,
|
||||
archive, nursery, heat, state_->opening_total, *current)}};
|
||||
state_->world, state_->region, state_->frame, state_->config, std::move(nursery_config),
|
||||
std::move(*habitat), std::move(lives), state_->corpses, archive, nursery, heat,
|
||||
state_->opening_total, *current)}};
|
||||
candidate->last_tick_feedback_ = last_tick_feedback_;
|
||||
return candidate;
|
||||
}
|
||||
|
||||
@@ -696,8 +710,8 @@ CellularLives::restore(std::span<const std::uint8_t> bytes, std::uint64_t world,
|
||||
const auto habitat_payload = in.raw(static_cast<std::size_t>(habitat_size));
|
||||
const auto archive_payload = in.raw(static_cast<std::size_t>(archive_size));
|
||||
|
||||
auto habitat = biology::CellularHabitat::restore(habitat_payload, saved_world, saved_region,
|
||||
saved_frame);
|
||||
auto habitat =
|
||||
biology::CellularHabitat::restore(habitat_payload, saved_world, saved_region, saved_frame);
|
||||
if (!habitat) {
|
||||
if (habitat.error() == biology::CellularHabitatError::version)
|
||||
return std::unexpected{CellularLivesError::version};
|
||||
@@ -715,9 +729,9 @@ CellularLives::restore(std::span<const std::uint8_t> bytes, std::uint64_t world,
|
||||
return std::unexpected{CellularLivesError::noncanonical};
|
||||
return std::unexpected{CellularLivesError::archive};
|
||||
}
|
||||
const auto current = validate_state(saved_world, saved_region, saved_frame, config,
|
||||
nursery_config, **habitat, lives, corpses, *archive,
|
||||
nursery, heat, opening_total);
|
||||
const auto current =
|
||||
validate_state(saved_world, saved_region, saved_frame, config, nursery_config, **habitat,
|
||||
lives, corpses, *archive, nursery, heat, opening_total);
|
||||
if (!current)
|
||||
return std::unexpected{current.error()};
|
||||
|
||||
@@ -747,8 +761,8 @@ CellularLives::advance_tick(std::span<const CellularLifeIntent> intents) {
|
||||
inputs.reserve(state_->lives.size());
|
||||
for (std::size_t i = 0; i < state_->lives.size(); ++i) {
|
||||
const auto& life = state_->lives[i];
|
||||
const auto budget = budget_for(state_->archive, life,
|
||||
state_->config.ambient_temperature_millikelvin);
|
||||
const auto budget =
|
||||
budget_for(state_->archive, life, state_->config.ambient_temperature_millikelvin);
|
||||
if (!budget)
|
||||
return std::unexpected{budget.error()};
|
||||
inputs.push_back({life.identity.life,
|
||||
@@ -786,18 +800,13 @@ CellularLives::advance_tick(std::span<const CellularLifeIntent> intents) {
|
||||
if (found == next_lives.end() || found->identity.life != dead.life_id ||
|
||||
!next_archive.record_death(found->identity.organism, {proposal->end_tick}))
|
||||
return std::unexpected{CellularLivesError::archive};
|
||||
const auto corpse_budget = budget_for(
|
||||
next_archive, *found, state_->config.ambient_temperature_millikelvin);
|
||||
const auto corpse_budget =
|
||||
budget_for(next_archive, *found, state_->config.ambient_temperature_millikelvin);
|
||||
if (!corpse_budget)
|
||||
return std::unexpected{corpse_budget.error()};
|
||||
next_corpses.push_back({found->identity.life,
|
||||
found->identity.organism,
|
||||
found->source,
|
||||
proposal->end_tick,
|
||||
dead.position,
|
||||
found->growth,
|
||||
corpse_budget->phenotype.extent,
|
||||
dead.inventory});
|
||||
next_corpses.push_back({found->identity.life, found->identity.organism, found->source,
|
||||
proposal->end_tick, dead.position, found->growth,
|
||||
corpse_budget->phenotype.extent, dead.inventory});
|
||||
next_lives.erase(found);
|
||||
}
|
||||
std::ranges::sort(next_corpses, {}, &CellularOwnedCorpse::organism);
|
||||
@@ -806,10 +815,9 @@ CellularLives::advance_tick(std::span<const CellularLifeIntent> intents) {
|
||||
return std::unexpected{CellularLivesError::overflow};
|
||||
next_heat.energy.value += proposal->heat_released.value;
|
||||
for (const auto& update : proposal->patches) {
|
||||
const auto found = std::ranges::lower_bound(
|
||||
habitat_config.patches, update.address, {}, [](const auto& patch) {
|
||||
return patch.address;
|
||||
});
|
||||
const auto found =
|
||||
std::ranges::lower_bound(habitat_config.patches, update.address, {},
|
||||
[](const auto& patch) { return patch.address; });
|
||||
if (found == habitat_config.patches.end() || found->address != update.address)
|
||||
return std::unexpected{CellularLivesError::habitat};
|
||||
found->stock = update.stock;
|
||||
@@ -817,23 +825,36 @@ CellularLives::advance_tick(std::span<const CellularLifeIntent> intents) {
|
||||
auto next_habitat = biology::CellularHabitat::create(std::move(habitat_config));
|
||||
if (!next_habitat)
|
||||
return std::unexpected{CellularLivesError::habitat};
|
||||
const auto total = validate_state(
|
||||
state_->world, state_->region, state_->frame,
|
||||
CellularLivesConfig{state_->config.area, proposal->end_tick,
|
||||
state_->config.ambient_temperature_millikelvin},
|
||||
state_->nursery_config, **next_habitat, next_lives, next_corpses, next_archive,
|
||||
state_->nursery, next_heat, state_->opening_total);
|
||||
const auto total =
|
||||
validate_state(state_->world, state_->region, state_->frame,
|
||||
CellularLivesConfig{state_->config.area, proposal->end_tick,
|
||||
state_->config.ambient_temperature_millikelvin},
|
||||
state_->nursery_config, **next_habitat, next_lives, next_corpses,
|
||||
next_archive, state_->nursery, next_heat, state_->opening_total);
|
||||
if (!total)
|
||||
return std::unexpected{total.error()};
|
||||
|
||||
auto next = std::make_unique<State>(
|
||||
state_->world, state_->region, state_->frame,
|
||||
CellularLivesConfig{state_->config.area, proposal->end_tick,
|
||||
state_->config.ambient_temperature_millikelvin},
|
||||
state_->nursery_config,
|
||||
std::move(*next_habitat), std::move(next_lives), std::move(next_corpses), next_archive,
|
||||
state_->nursery, next_heat, state_->opening_total, *total);
|
||||
auto next =
|
||||
std::make_unique<State>(state_->world, state_->region, state_->frame,
|
||||
CellularLivesConfig{state_->config.area, proposal->end_tick,
|
||||
state_->config.ambient_temperature_millikelvin},
|
||||
state_->nursery_config, std::move(*next_habitat),
|
||||
std::move(next_lives), std::move(next_corpses), next_archive,
|
||||
state_->nursery, next_heat, state_->opening_total, *total);
|
||||
std::vector<CellularLifeTickFeedback> feedback;
|
||||
feedback.reserve(proposal->lives.size());
|
||||
for (const auto& result : proposal->lives) {
|
||||
const auto input =
|
||||
std::ranges::lower_bound(ordered, result.life_id, {},
|
||||
[](const CellularLifeIntent& value) { return value.life_id; });
|
||||
feedback.push_back({result.life_id, proposal->end_tick, result.candidate.reserve_after,
|
||||
result.candidate.maintenance_cost, result.candidate.movement_cost,
|
||||
result.candidate.movement_status, result.candidate.intake_status});
|
||||
if (input == ordered.end() || input->life_id != result.life_id)
|
||||
return std::unexpected{CellularLivesError::invalid_intents};
|
||||
}
|
||||
state_.swap(next);
|
||||
last_tick_feedback_ = std::move(feedback);
|
||||
return std::move(*proposal);
|
||||
}
|
||||
} // namespace evo::server
|
||||
|
||||
@@ -422,7 +422,8 @@ struct RegionSessions::Impl {
|
||||
c.protocol_version == network::session_protocol_v6) ||
|
||||
(config.accept_cellular_actions &&
|
||||
(c.protocol_version == network::session_protocol_v7 ||
|
||||
c.protocol_version == network::session_protocol_v8)))))
|
||||
c.protocol_version == network::session_protocol_v8 ||
|
||||
c.protocol_version == network::session_protocol_v9)))))
|
||||
return close(c, SessionCloseReason::protocol, now);
|
||||
if (const auto* ack = std::get_if<network::SnapshotAck>(&*decoded))
|
||||
return replication.acknowledge(c.session, *ack);
|
||||
@@ -589,9 +590,10 @@ struct RegionSessions::Impl {
|
||||
(wire_version == network::session_protocol_v5 && !primitive_v5) ||
|
||||
(wire_version == network::session_protocol_v6 && !cellular_v6) ||
|
||||
((wire_version == network::session_protocol_v7 ||
|
||||
wire_version == network::session_protocol_v8) &&
|
||||
wire_version == network::session_protocol_v8 ||
|
||||
wire_version == network::session_protocol_v9) &&
|
||||
!cellular_actions) ||
|
||||
wire_version > network::session_protocol_v8)
|
||||
wire_version > network::session_protocol_v9)
|
||||
return close(c, SessionCloseReason::unsupported_version, now);
|
||||
} else if (wire_version != c.protocol_version) {
|
||||
return close(c, SessionCloseReason::unsupported_version, now);
|
||||
@@ -615,7 +617,8 @@ struct RegionSessions::Impl {
|
||||
}
|
||||
if (const auto* m = std::get_if<network::CellularAction>(&*decoded)) {
|
||||
if (c.protocol_version != network::session_protocol_v7 &&
|
||||
c.protocol_version != network::session_protocol_v8)
|
||||
c.protocol_version != network::session_protocol_v8 &&
|
||||
c.protocol_version != network::session_protocol_v9)
|
||||
return close(c, SessionCloseReason::protocol, now);
|
||||
if (const auto receipt = intents.admit(c.session, *m, admission()))
|
||||
answer(c, *receipt);
|
||||
@@ -881,10 +884,15 @@ bool RegionSessions::send_cellular_perception(const network::AccountId& account,
|
||||
auto& m = *impl_;
|
||||
for (const auto& c : m.connections) {
|
||||
if (c.state != Impl::State::established ||
|
||||
c.protocol_version != network::session_protocol_v8 || c.account_id != account)
|
||||
(c.protocol_version != network::session_protocol_v8 &&
|
||||
c.protocol_version != network::session_protocol_v9) ||
|
||||
c.account_id != account)
|
||||
continue;
|
||||
auto delivered = perception;
|
||||
if (c.protocol_version == network::session_protocol_v8)
|
||||
delivered.diagnostics.reset();
|
||||
return m.endpoint
|
||||
->send_message(c.id, network::encode_session(perception, c.protocol_version))
|
||||
->send_message(c.id, network::encode_session(delivered, c.protocol_version))
|
||||
.has_value();
|
||||
}
|
||||
return false;
|
||||
@@ -897,7 +905,8 @@ void RegionSessions::clear_cellular_perceptions(std::uint64_t tick) {
|
||||
const network::CellularPerception cleared{tick, 0, {}};
|
||||
for (const auto& c : m.connections)
|
||||
if (c.state == Impl::State::established &&
|
||||
c.protocol_version == network::session_protocol_v8)
|
||||
(c.protocol_version == network::session_protocol_v8 ||
|
||||
c.protocol_version == network::session_protocol_v9))
|
||||
m.send(c, cleared);
|
||||
}
|
||||
|
||||
|
||||
@@ -1,12 +1,12 @@
|
||||
#include "evo/server/lifecycle/cellular_lives.hpp"
|
||||
#include "evo/server/lifecycle/cellular_batch.hpp"
|
||||
#include "evo/server/lifecycle/cellular_lives.hpp"
|
||||
|
||||
#include <algorithm>
|
||||
#include <array>
|
||||
#include <cstdint>
|
||||
#include <cstdio>
|
||||
#include <span>
|
||||
#include <source_location>
|
||||
#include <span>
|
||||
#include <stdexcept>
|
||||
#include <string>
|
||||
#include <vector>
|
||||
@@ -46,12 +46,13 @@ void refresh_checksum(std::vector<std::uint8_t>& bytes) {
|
||||
}
|
||||
|
||||
std::unique_ptr<CellularLives> empty_cellular_owner(Inventory funding,
|
||||
std::vector<SpawnSite> sites) {
|
||||
std::vector<SpawnSite> sites) {
|
||||
auto primitive = PrimitiveLives::create({91, 1, 1, 17, funding, std::move(sites)});
|
||||
CHECK(primitive);
|
||||
auto habitat = evo::biology::CellularHabitat::create({91, 1, 1, 1'000, 1'000, {}});
|
||||
CHECK(habitat);
|
||||
auto owner = CellularLives::create(**primitive, std::move(*habitat), {{1'000, 1'000}, 0, 293'150});
|
||||
auto owner =
|
||||
CellularLives::create(**primitive, std::move(*habitat), {{1'000, 1'000}, 0, 293'150});
|
||||
CHECK(owner);
|
||||
CHECK((*owner)->ambient_temperature_millikelvin() == 293'150);
|
||||
return std::move(*owner);
|
||||
@@ -75,8 +76,8 @@ void reserved_birth_is_funded_and_detached() {
|
||||
const auto endowment = evo::biology::primitive_endowment();
|
||||
CHECK(endowment);
|
||||
CHECK((*born)->nursery().energy.value == opening->nursery().energy.value -
|
||||
endowment->reserve.energy.value -
|
||||
endowment->construction.value);
|
||||
endowment->reserve.energy.value -
|
||||
endowment->construction.value);
|
||||
CHECK((*born)->heat().energy.value == endowment->construction.value &&
|
||||
(*born)->current_total() == (*born)->opening_total() &&
|
||||
(*born)->archive().recorded() == 1);
|
||||
@@ -92,13 +93,12 @@ void reserved_birth_is_funded_and_detached() {
|
||||
CHECK(opening->birth_candidate(request, {502, 502, 502, 502, {2}}).error() ==
|
||||
CellularLivesError::invalid_tick);
|
||||
const std::array next_tick{CellularLifeIntent{allocation.life, {}}};
|
||||
CHECK((*born)->advance_tick(next_tick) && (*born)->tick() == 2 &&
|
||||
(*born)->lives().size() == 1);
|
||||
CHECK((*born)->advance_tick(next_tick) && (*born)->tick() == 2 && (*born)->lives().size() == 1);
|
||||
|
||||
auto trace_base = empty_cellular_owner(founder_price(1), {{0, 0}});
|
||||
CellularBatch birth_batch;
|
||||
birth_batch.header = {trace_base->world(), trace_base->region(), trace_base->frame(), {}, {},
|
||||
trace_base->tick(), trace_base->tick() + 1};
|
||||
birth_batch.header = {trace_base->world(), trace_base->region(), trace_base->frame(), {}, {},
|
||||
trace_base->tick(), trace_base->tick() + 1};
|
||||
birth_batch.header.predecessor.fill(3);
|
||||
birth_batch.header.predecessor_digest.fill(4);
|
||||
CellularTickIntents birth_tick;
|
||||
@@ -134,18 +134,16 @@ void reserved_birth_is_funded_and_detached() {
|
||||
CellularLivesError::insufficient_funding);
|
||||
CHECK(unfunded->snapshot() == unfunded_snapshot && unfunded->lives().empty());
|
||||
|
||||
auto occupied_primitive =
|
||||
PrimitiveLives::create({92, 1, 1, 17, founder_price(2), {{0, 0}}});
|
||||
auto occupied_primitive = PrimitiveLives::create({92, 1, 1, 17, founder_price(2), {{0, 0}}});
|
||||
CHECK(occupied_primitive);
|
||||
LifeRequest existing{};
|
||||
existing.account.back() = 11;
|
||||
existing.action = 1;
|
||||
CHECK((*occupied_primitive)->spawn(existing, {701, 701, 701, 701, {1}}));
|
||||
auto occupied_habitat =
|
||||
evo::biology::CellularHabitat::create({92, 1, 1, 1'000, 1'000, {}});
|
||||
auto occupied_habitat = evo::biology::CellularHabitat::create({92, 1, 1, 1'000, 1'000, {}});
|
||||
CHECK(occupied_habitat);
|
||||
auto occupied = CellularLives::create(**occupied_primitive, std::move(*occupied_habitat),
|
||||
{{1'000, 1'000}, 1, 293'150});
|
||||
{{1'000, 1'000}, 1, 293'150});
|
||||
CHECK(occupied);
|
||||
LifeRequest arriving{};
|
||||
arriving.account.back() = 12;
|
||||
@@ -168,8 +166,8 @@ void owner_advances_and_closes_death_atomically() {
|
||||
90, 1, 7, 3'000, 2'000, {{{0, 0}, 29, {{10}, {{{10}, {10}, {10}, {10}}}}}}};
|
||||
auto habitat = evo::biology::CellularHabitat::create(std::move(habitat_config));
|
||||
CHECK(habitat);
|
||||
auto created = CellularLives::create(
|
||||
**primitive, std::move(*habitat), {{3'000, 2'000}, 1, 293'150});
|
||||
auto created =
|
||||
CellularLives::create(**primitive, std::move(*habitat), {{3'000, 2'000}, 1, 293'150});
|
||||
CHECK(created);
|
||||
auto& owner = **created;
|
||||
CHECK(owner.world() == 90 && owner.region() == 1 && owner.frame() == 7);
|
||||
@@ -187,9 +185,8 @@ void owner_advances_and_closes_death_atomically() {
|
||||
visible_patches->front().address == (evo::biology::CellularPatchAddress{0, 0}) &&
|
||||
visible_patches->front().available == owner.habitat().patches()[0].stock);
|
||||
CHECK(owner.perceive(0).error() == CellularLivesError::invalid_life);
|
||||
const std::array invalid_motion{
|
||||
CellularLifeIntent{first_life_id, {}},
|
||||
CellularLifeIntent{second_life_id, {{1'001, 0}, std::nullopt}}};
|
||||
const std::array invalid_motion{CellularLifeIntent{first_life_id, {}},
|
||||
CellularLifeIntent{second_life_id, {{1'001, 0}, std::nullopt}}};
|
||||
const auto partial = owner.advance_tick(invalid_motion);
|
||||
CHECK(!partial && partial.error() == CellularLivesError::region_step && owner.tick() == 1 &&
|
||||
owner.lives().size() == 2);
|
||||
@@ -200,6 +197,15 @@ void owner_advances_and_closes_death_atomically() {
|
||||
CHECK(fed && owner.tick() == 2 && owner.lives().size() == 2);
|
||||
CHECK(fed->lives.size() == 2 &&
|
||||
fed->lives[0].candidate.intake_status == evo::biology::CellularIntakeStatus::acquired);
|
||||
CHECK(owner.last_tick_feedback().size() == 2 &&
|
||||
owner.last_tick_feedback()[0].tick == owner.tick() &&
|
||||
owner.last_tick_feedback()[0].life_id == owner.lives()[0].identity.life &&
|
||||
owner.last_tick_feedback()[0].reserve == fed->lives[0].candidate.reserve_after &&
|
||||
owner.last_tick_feedback()[0].maintenance_cost ==
|
||||
fed->lives[0].candidate.maintenance_cost &&
|
||||
owner.last_tick_feedback()[0].movement ==
|
||||
evo::biology::CellularMovementStatus::not_requested &&
|
||||
owner.last_tick_feedback()[0].intake == evo::biology::CellularIntakeStatus::acquired);
|
||||
CHECK(owner.habitat().patches()[0].stock == (Inventory{{0}, {}}));
|
||||
CHECK(owner.current_total() == owner.opening_total());
|
||||
|
||||
@@ -207,6 +213,7 @@ void owner_advances_and_closes_death_atomically() {
|
||||
CHECK(saved.size() <= max_cellular_lives_bytes);
|
||||
auto recovered = CellularLives::restore(saved, 90, 1, 7, owner.tick());
|
||||
CHECK(recovered && (*recovered)->snapshot() == saved);
|
||||
CHECK((*recovered)->last_tick_feedback().empty()); // Transient presentation is not restored.
|
||||
CHECK(!CellularLives::restore(saved, 91, 1, 7, owner.tick()));
|
||||
CHECK(!CellularLives::restore(saved, 90, 1, 7, owner.tick() + 1));
|
||||
auto damaged = saved;
|
||||
@@ -216,8 +223,7 @@ void owner_advances_and_closes_death_atomically() {
|
||||
auto unsupported = saved;
|
||||
unsupported[8] = static_cast<std::uint8_t>(cellular_lives_format + 1);
|
||||
refresh_checksum(unsupported);
|
||||
const auto unsupported_result =
|
||||
CellularLives::restore(unsupported, 90, 1, 7, owner.tick());
|
||||
const auto unsupported_result = CellularLives::restore(unsupported, 90, 1, 7, owner.tick());
|
||||
CHECK(!unsupported_result && unsupported_result.error() == CellularLivesError::version);
|
||||
auto outside = saved;
|
||||
std::fill(outside.begin() + 300, outside.begin() + 308, uint8_t{0xff});
|
||||
@@ -225,8 +231,8 @@ void owner_advances_and_closes_death_atomically() {
|
||||
CHECK(!CellularLives::restore(outside, 90, 1, 7, owner.tick()));
|
||||
|
||||
CellularBatch replay_batch;
|
||||
replay_batch.header = {owner.world(), owner.region(), owner.frame(), {}, {}, owner.tick(),
|
||||
owner.tick() + 2};
|
||||
replay_batch.header = {owner.world(), owner.region(), owner.frame(), {}, {},
|
||||
owner.tick(), owner.tick() + 2};
|
||||
replay_batch.header.predecessor.fill(0x31);
|
||||
replay_batch.header.predecessor_digest.fill(0x41);
|
||||
for (int i = 0; i < 2; ++i) {
|
||||
@@ -246,8 +252,8 @@ void owner_advances_and_closes_death_atomically() {
|
||||
const std::array actions{action};
|
||||
const auto action_bytes = encode_cellular_action_block(actions, owner.tick(), owner.tick() + 2);
|
||||
CHECK(action_bytes && action_bytes->size() == cellular_action_record_bytes);
|
||||
const auto decoded_actions = decode_cellular_action_block(
|
||||
*action_bytes, owner.tick(), owner.tick() + 2);
|
||||
const auto decoded_actions =
|
||||
decode_cellular_action_block(*action_bytes, owner.tick(), owner.tick() + 2);
|
||||
CHECK(decoded_actions && *decoded_actions == std::vector<CellularActionRecord>{action});
|
||||
CHECK(match_cellular_actions_to_trace(owner, *decoded_batch, *decoded_actions));
|
||||
auto changed_action = action;
|
||||
@@ -257,6 +263,8 @@ void owner_advances_and_closes_death_atomically() {
|
||||
CellularActionBlockError::mismatch);
|
||||
const auto replayed_batch = replay_cellular_batch(owner, *decoded_batch);
|
||||
CHECK(replayed_batch && (*replayed_batch)->tick() == owner.tick() + 2);
|
||||
CHECK((*replayed_batch)->last_tick_feedback().size() == owner.lives().size() &&
|
||||
(*replayed_batch)->last_tick_feedback()[0].tick == (*replayed_batch)->tick());
|
||||
CHECK((*replayed_batch)->current_total() == owner.opening_total());
|
||||
auto short_batch = *batch_bytes;
|
||||
short_batch.pop_back();
|
||||
|
||||
@@ -45,6 +45,7 @@ void maintenance_motion_and_intake_conserve_one_tick() {
|
||||
CHECK(step->begin_tick == 12 && step->end_tick == 13);
|
||||
CHECK(step->position == CellularPosition{10, 0});
|
||||
CHECK(step->maintenance_cost.value == 5 && step->movement_cost.value == 50);
|
||||
CHECK(step->movement_status == CellularMovementStatus::moved);
|
||||
CHECK(step->heat_after.energy.value == 55);
|
||||
CHECK(step->reserve_after == Inventory{{195}, {{{5}, {2}, {1}, {0}}}});
|
||||
if (step->intake_status != CellularIntakeStatus::acquired || !step->intake)
|
||||
@@ -73,6 +74,7 @@ void maintenance_precedes_motion_and_intake() {
|
||||
CHECK(step);
|
||||
CHECK(step->position == CellularPosition{0, 0});
|
||||
CHECK(step->movement_cost.value == 0);
|
||||
CHECK(step->movement_status == CellularMovementStatus::insufficient_reserve);
|
||||
CHECK(step->maintenance_cost.value == 5 && step->heat_after.energy.value == 5);
|
||||
CHECK(step->intake_status == CellularIntakeStatus::acquired);
|
||||
CHECK(step->reserve_after.energy.value == 99); // Intake cannot fund this tick's move.
|
||||
|
||||
+30
-5
@@ -611,7 +611,7 @@ void cellular_v5_spawn_and_v7_action_share_region_sessions(const Files& f) {
|
||||
} actions;
|
||||
FakeLedger control;
|
||||
Harness h{
|
||||
f, 4, 64, &control, [&](server::RegionSessionsConfig& c) {
|
||||
f, 5, 64, &control, [&](server::RegionSessionsConfig& c) {
|
||||
c.actions = &actions;
|
||||
c.accept_cellular_actions = true;
|
||||
c.create_primitive_life = [](const AccountId&, std::uint64_t, std::uint64_t request) {
|
||||
@@ -624,13 +624,16 @@ void cellular_v5_spawn_and_v7_action_share_region_sessions(const Files& f) {
|
||||
auto spawn_client = h.connect(h.issuer.grant(account(0xB5), 1), session_protocol_v5);
|
||||
auto action_client = h.connect(h.issuer.grant(account(0xB7), 1), session_protocol_v7);
|
||||
const auto owner_account = account(0xB8);
|
||||
auto perception_owner = h.connect(h.issuer.grant(owner_account, 1), session_protocol_v8);
|
||||
auto other_owner = h.connect(h.issuer.grant(account(0xB9), 1), session_protocol_v8);
|
||||
auto perception_owner = h.connect(h.issuer.grant(owner_account, 1), session_protocol_v9);
|
||||
auto other_owner = h.connect(h.issuer.grant(account(0xB9), 1), session_protocol_v9);
|
||||
const auto legacy_account = account(0xBA);
|
||||
auto legacy_owner = h.connect(h.issuer.grant(legacy_account, 1), session_protocol_v8);
|
||||
CHECK(h.settled(*spawn_client) && spawn_client->state() == RegionSessionState::established);
|
||||
CHECK(h.settled(*action_client) && action_client->state() == RegionSessionState::established);
|
||||
CHECK(h.settled(*perception_owner) &&
|
||||
perception_owner->state() == RegionSessionState::established);
|
||||
CHECK(h.settled(*other_owner) && other_owner->state() == RegionSessionState::established);
|
||||
CHECK(h.settled(*legacy_owner) && legacy_owner->state() == RegionSessionState::established);
|
||||
|
||||
CHECK(spawn_client->request_primitive_life(44));
|
||||
std::vector<PrimitiveLifeOutcome> birth_outcomes;
|
||||
@@ -665,19 +668,41 @@ void cellular_v5_spawn_and_v7_action_share_region_sessions(const Files& f) {
|
||||
action_client->view()->organisms.front().id == 901);
|
||||
CHECK(action_client->set_interest({1, 0, 0, 2}));
|
||||
|
||||
const CellularPerception perception{101, 901, {{1'000, 2'000, 3, {4, 5, 6, 7}}}};
|
||||
CellularPerception perception{101, 901, {{1'000, 2'000, 3, {4, 5, 6, 7}}}};
|
||||
CellularLifeDiagnostics diagnostics;
|
||||
diagnostics.reserve_energy_pj = 88;
|
||||
diagnostics.reserve_matter_fg = {9, 10, 11, 12};
|
||||
diagnostics.maintenance_cost_pj = 3;
|
||||
diagnostics.movement_cost_pj = 2;
|
||||
diagnostics.movement = CellularMovementResult::moved;
|
||||
diagnostics.intake = CellularIntakeResult::acquired;
|
||||
diagnostics.has_tick_effects = true;
|
||||
perception.diagnostics = diagnostics;
|
||||
CHECK(h.server->send_cellular_perception(owner_account, perception));
|
||||
CHECK(h.until([&] {
|
||||
return perception_owner->cellular_perception() &&
|
||||
perception_owner->cellular_perception()->tick == perception.tick;
|
||||
}));
|
||||
CHECK(*perception_owner->cellular_perception() == perception);
|
||||
CHECK(!other_owner->cellular_perception() && !action_client->cellular_perception());
|
||||
CHECK(!other_owner->cellular_perception() && !legacy_owner->cellular_perception() &&
|
||||
!action_client->cellular_perception());
|
||||
CHECK(h.server->send_cellular_perception(legacy_account, perception));
|
||||
CHECK(h.until([&] {
|
||||
return legacy_owner->cellular_perception() &&
|
||||
legacy_owner->cellular_perception()->tick == perception.tick;
|
||||
}));
|
||||
auto legacy_perception = perception;
|
||||
legacy_perception.diagnostics.reset();
|
||||
CHECK(*legacy_owner->cellular_perception() == legacy_perception);
|
||||
h.server->clear_cellular_perceptions(102);
|
||||
CHECK(h.until([&] {
|
||||
return perception_owner->cellular_perception() &&
|
||||
perception_owner->cellular_perception()->tick == 102;
|
||||
}));
|
||||
CHECK(h.until([&] {
|
||||
return legacy_owner->cellular_perception() &&
|
||||
legacy_owner->cellular_perception()->tick == 102;
|
||||
}));
|
||||
CHECK(perception_owner->cellular_perception()->life_identity == 0 &&
|
||||
perception_owner->cellular_perception()->patches.empty());
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user