std::array<std::uint32_t, std::mt19937::state_size> seed_bits{};

std::random_device real_random{};

std::generate(seed_bits.begin(), seed_bits.end(), std::ref(real_random));

std::seed_seq wrapped_seed_bits(seed_bits.begin(), seed_bits.end());

return std::mt19937(wrapped_seed_bits);

Fill_up_vector()

: rng_{ init_mersenne_twister() } {}

void operator()(Node& node) {

Node_id opad_id = node.opad_list()[0]; // This kind of nodes have exactly one output pad

Dice_pool& dice_pool = node.opad(opad_id);

dice_pool.resize(20);

std::uniform_int_distribution die(1,100);

for (auto& res : dice_pool) {

res = die( rng_ );

}

}

std::mt19937 rng_;

std::vector<Node_id> const& dice_pool_ids = node.ipad_list(); // there can be many input pads

Node_id opad_id = node.opad_list()[0]; // Output pad

Dice_pool& best_results_pool = node.opad(opad_id);

best_results_pool.resize(20);

for (std::size_t i{}, e{20}; i < e; ++i) {

int maximum{ -1 };

for (Node_id dice_pool_id: dice_pool_ids) {

if (node.ipad(dice_pool_id)[i] > maximum) {

maximum = node.ipad(dice_pool_id)[i];

}

}

best_results_pool[i] = maximum;

}

Node_id ipad_id = node.ipad_list()[0]; // The input pad

Dice_pool const& best_results_pool = node.ipad(ipad_id);

bool first{ true };

for (auto const& result : best_results_pool) {

if (first) {

first = false;

} else {

std::cout << ", ";

}

std::cout << result;

}

std::cout << "\n";

Dataflow_generator gg{};

auto output = gg.create_node(write_out);

auto pickup = gg.create_node(pick_up_max);

gg.create_arc(pickup, output);

//try to increase or reduce the number of dice pools

int nr_dice_pools{ 5 };

while (nr_dice_pools-- > 0) {

gg.create_arc(gg.create_node(Fill_up_vector{}), pickup);

}

int times{ 10 };

gg.start_flow([&times]() { return times-- == 0; });