200 lines
9.2 KiB
C++
200 lines
9.2 KiB
C++
#include "evo/core/random.hpp"
|
|
#include "evo/processes/producer.hpp"
|
|
|
|
#include <algorithm>
|
|
#include <iostream>
|
|
#include <limits>
|
|
#include <source_location>
|
|
#include <stdexcept>
|
|
#include <string>
|
|
|
|
namespace {
|
|
using namespace evo::processes;
|
|
using namespace evo::accounting;
|
|
void check(bool condition, std::source_location location = std::source_location::current()) {
|
|
if (!condition) {
|
|
throw std::runtime_error("producer contract line " + std::to_string(location.line()));
|
|
}
|
|
}
|
|
#define CHECK(expression) check(static_cast<bool>(expression))
|
|
ProducerConfig config() {
|
|
return {
|
|
{{5}, 2}, {3, 2}, 600, {1}, {Femtograms{1}, Femtograms{2}, Femtograms{3}, Femtograms{4}}};
|
|
}
|
|
std::vector<Inventory> balances(const ProducerProcess& process) {
|
|
return {process.balances().begin(), process.balances().end()};
|
|
}
|
|
void audit(const ProducerProcess& process, std::uint64_t energy,
|
|
const std::array<Femtograms, 4>& matter) {
|
|
Inventory sum{};
|
|
for (const auto& balance : process.balances()) {
|
|
CHECK(balance.energy.value <= energy - sum.energy.value);
|
|
sum.energy.value += balance.energy.value;
|
|
for (std::size_t index = 0; index < 4; ++index) {
|
|
CHECK(balance.matter[index].value <= matter[index].value - sum.matter[index].value);
|
|
sum.matter[index].value += balance.matter[index].value;
|
|
}
|
|
}
|
|
CHECK(sum.energy.value == energy && sum.matter == matter);
|
|
}
|
|
void hand_calculated() {
|
|
const std::array matter{Femtograms{10}, Femtograms{20}, Femtograms{30}, Femtograms{40}};
|
|
auto process = ProducerProcess::create(config(), {10}, matter);
|
|
CHECK(process);
|
|
const std::array expected{
|
|
ProducerReport{{2}, {1}, {1}, 1, 0}, ProducerReport{{3}, {2}, {1}, 2, 0},
|
|
ProducerReport{{2}, {1}, {1}, 1, 0}, ProducerReport{{3}, {2}, {1}, 2, 0}};
|
|
for (std::size_t index = 0; index < expected.size(); ++index) {
|
|
const auto result = process->advance(evo::Tick{index + 1});
|
|
CHECK(result && *result == expected[index]);
|
|
audit(*process, 10, matter);
|
|
}
|
|
CHECK(process->balances()[0].energy.value == 0);
|
|
CHECK(process->balances()[2].energy.value == 0);
|
|
CHECK(process->balances()[2].matter[0].value == 6);
|
|
CHECK(process->balances()[3].energy.value == 10);
|
|
const auto stopped = process->advance(evo::Tick{5});
|
|
CHECK(stopped && stopped->captured.value == 0 && stopped->grown_units == 0);
|
|
CHECK(process->balances()[3].energy.value == 10); // Heat cannot power growth.
|
|
}
|
|
void limits_and_rejection() {
|
|
const std::array matter{Femtograms{10}, Femtograms{20}, Femtograms{30}, Femtograms{40}};
|
|
for (int invalid = 0; invalid < 5; ++invalid) {
|
|
auto settings = config();
|
|
if (invalid == 0) {
|
|
settings.capture.ticks = 0;
|
|
}
|
|
if (invalid == 1) {
|
|
settings.growth.ticks = 0;
|
|
}
|
|
if (invalid == 2) {
|
|
settings.efficiency_per_thousand = 1001;
|
|
}
|
|
if (invalid == 3) {
|
|
settings.growth_cost = {};
|
|
}
|
|
if (invalid == 4) {
|
|
settings.recipe = {};
|
|
}
|
|
const auto result = ProducerProcess::create(settings, {10}, matter);
|
|
CHECK(!result && result.error() == ProducerError::invalid_config);
|
|
}
|
|
auto process = ProducerProcess::create(config(), {10}, matter);
|
|
CHECK(process);
|
|
CHECK(process->advance(evo::Tick{1}));
|
|
const auto before = balances(*process);
|
|
const auto progress = process->progress();
|
|
for (const auto target : {0U, 1U, 3U}) {
|
|
const auto result = process->advance(evo::Tick{target});
|
|
CHECK(!result && result.error() == ProducerError::wrong_tick);
|
|
CHECK(process->progress() == progress && balances(*process) == before);
|
|
}
|
|
for (const auto efficiency : {0U, 1000U}) {
|
|
auto settings = config();
|
|
settings.efficiency_per_thousand = static_cast<std::uint16_t>(efficiency);
|
|
settings.capture = {{std::numeric_limits<std::uint64_t>::max()}, 1};
|
|
settings.growth = {0, 1};
|
|
auto full =
|
|
ProducerProcess::create(settings, {std::numeric_limits<std::uint64_t>::max()}, matter);
|
|
CHECK(full);
|
|
const auto result = full->advance(evo::Tick{1});
|
|
CHECK(result && result->retained.value ==
|
|
(efficiency == 0 ? 0 : std::numeric_limits<std::uint64_t>::max()));
|
|
audit(*full, std::numeric_limits<std::uint64_t>::max(), matter);
|
|
}
|
|
auto boundary_config = config();
|
|
constexpr auto maximum = std::numeric_limits<std::uint64_t>::max();
|
|
boundary_config.capture = {{maximum}, 2};
|
|
boundary_config.growth = {0, 1};
|
|
boundary_config.efficiency_per_thousand = 500;
|
|
auto boundary = ProducerProcess::create(boundary_config, {maximum}, matter);
|
|
CHECK(boundary);
|
|
const auto first = boundary->advance(evo::Tick{1});
|
|
CHECK(first && first->captured.value == 9223372036854775807ULL);
|
|
CHECK(first->retained.value == 4611686018427387903ULL);
|
|
const auto second = boundary->advance(evo::Tick{2});
|
|
CHECK(second && second->captured.value == 9223372036854775808ULL);
|
|
CHECK(second->retained.value == 4611686018427387904ULL);
|
|
audit(*boundary, maximum, matter);
|
|
boundary_config.capture = {{maximum}, 1};
|
|
boundary_config.growth = {maximum, 1};
|
|
boundary_config.efficiency_per_thousand = 1000;
|
|
boundary_config.growth_cost = {maximum};
|
|
boundary_config.recipe = {Femtograms{maximum}, Femtograms{}, Femtograms{}, Femtograms{}};
|
|
auto massive = ProducerProcess::create(boundary_config, {maximum}, boundary_config.recipe);
|
|
CHECK(massive);
|
|
const auto grown = massive->advance(evo::Tick{1});
|
|
CHECK(grown && grown->grown_units == 1 && grown->unmet_growth_units == maximum - 1);
|
|
audit(*massive, maximum, boundary_config.recipe);
|
|
auto dark_config = config();
|
|
dark_config.capture.energy = {};
|
|
auto dark = ProducerProcess::create(dark_config, {10}, matter);
|
|
CHECK(dark);
|
|
CHECK(dark->advance(evo::Tick{1})->grown_units == 0);
|
|
CHECK(dark->balances()[0].energy.value == 10);
|
|
for (std::size_t limiting = 0; limiting < 4; ++limiting) {
|
|
auto scarce = matter;
|
|
scarce[limiting] = {};
|
|
auto limited = ProducerProcess::create(config(), {10}, scarce);
|
|
CHECK(limited);
|
|
CHECK(limited->advance(evo::Tick{1})->grown_units == 0);
|
|
audit(*limited, 10, scarce);
|
|
}
|
|
}
|
|
void fractional_reference_and_replay() {
|
|
for (std::uint64_t seed = 0; seed < 32; ++seed) {
|
|
evo::Random random{seed};
|
|
auto settings = config();
|
|
settings.capture = {{random.next() % 17},
|
|
static_cast<std::uint32_t>(1 + random.next() % 13)};
|
|
settings.growth = {random.next() % 9, static_cast<std::uint32_t>(1 + random.next() % 7)};
|
|
settings.efficiency_per_thousand = static_cast<std::uint16_t>(random.next() % 1001);
|
|
settings.growth_cost.value = 1 + random.next() % 5;
|
|
const std::array matter{Femtograms{50}, Femtograms{100}, Femtograms{150}, Femtograms{200}};
|
|
constexpr std::uint64_t initial_energy = 200;
|
|
auto process = ProducerProcess::create(settings, {initial_energy}, matter);
|
|
CHECK(process);
|
|
auto replay = *process;
|
|
std::uint64_t total_capture{}, total_retained{}, total_growth{};
|
|
for (std::uint64_t tick = 1; tick <= 1000; ++tick) {
|
|
// Small-domain independent reference: cumulative products fit u64.
|
|
const auto cumulative_capture =
|
|
tick * settings.capture.energy.value / settings.capture.ticks;
|
|
const auto actual_capture = std::min(cumulative_capture, initial_energy);
|
|
const auto retained = actual_capture * settings.efficiency_per_thousand / 1000;
|
|
const auto growth_quota = tick * settings.growth.units / settings.growth.ticks -
|
|
(tick - 1) * settings.growth.units / settings.growth.ticks;
|
|
const auto grown = std::min({growth_quota,
|
|
(retained - total_growth * settings.growth_cost.value) /
|
|
settings.growth_cost.value,
|
|
50 - total_growth});
|
|
const auto result = process->advance(evo::Tick{tick});
|
|
const auto repeated = replay.advance(evo::Tick{tick});
|
|
CHECK(result && repeated && *result == *repeated);
|
|
CHECK(result->captured.value == actual_capture - total_capture);
|
|
CHECK(result->retained.value == retained - total_retained);
|
|
CHECK(result->grown_units == grown);
|
|
total_capture = actual_capture;
|
|
total_retained = retained;
|
|
total_growth += grown;
|
|
CHECK(process->balances()[2].energy.value ==
|
|
total_retained - total_growth * settings.growth_cost.value);
|
|
CHECK(process->balances()[2].matter[0].value == total_growth);
|
|
CHECK(process->progress() == replay.progress());
|
|
CHECK(balances(*process) == balances(replay));
|
|
audit(*process, initial_energy, matter);
|
|
}
|
|
}
|
|
}
|
|
} // namespace
|
|
|
|
int main() try {
|
|
hand_calculated();
|
|
limits_and_rejection();
|
|
fractional_reference_and_replay();
|
|
std::cout << "PASS producer conservation, fractional reference and replay\n";
|
|
return 0;
|
|
} catch (...) {
|
|
return 1;
|
|
}
|