4#include "dcon_generated.hpp"
20 state.world.nation_get_real_demand(n, commodity_type) += amount;
21 state.world.commodity_get_demand_by_category(commodity_type, (
int)reason) += amount;
22 assert(std::isfinite(state.world.nation_get_real_demand(n, commodity_type)));
27 state.world.nation_get_intermediate_demand(n, commodity_type) += amount;
29 float price = state.world.commodity_get_current_price(commodity_type);
30 float sat = state.world.nation_get_demand_satisfaction(n, commodity_type);
32 state.world.nation_get_gdp(n) -= amount * price * sat;
37 state.world.nation_get_construction_demand(n, commodity_type) += amount;
41 state.world.nation_get_domestic_market_pool(n, commodity_type) += amount;
42 state.world.nation_get_gdp(n) += amount * state.world.commodity_get_current_price(commodity_type);
49 if(!state.world.nation_get_is_player_controlled(n) || !state.world.nation_get_is_debt_spending(n))
55 auto last_br = state.world.nation_get_bankrupt_until(n);
56 if(last_br && state.current_date < last_br)
67 auto debt = state.world.nation_get_stockpiles(n,
money);
71 return -debt * std::max(0.01f, (state.world.nation_get_modifier_values(n, sys::national_mod_offsets::loan_interest) + 1.0f) * state.defines.loan_base_interest) / 30.0f;
77 auto mod = (state.world.nation_get_modifier_values(n, sys::national_mod_offsets::max_loan_modifier) + 1.0f);
78 auto total_tax_base = state.world.nation_get_total_rich_income(n) + state.world.nation_get_total_middle_income(n) + state.world.nation_get_total_poor_income(n);
79 return std::max(0.0f, total_tax_base * mod);
90 auto date = state.current_date.to_ymd(state.start_date);
94 auto date = state.current_date.to_ymd(state.start_date);
99 return state.world.nation_get_life_needs_costs(n, state.culture_definitions.primary_factory_worker)
100 + 0.1f * state.world.nation_get_everyday_needs_costs(n, state.culture_definitions.primary_factory_worker);
104 float raw = state.world.nation_get_gdp(n);
106 return raw / ideal_pound;
115 return state.world.commodity_get_total_production(c);
129 auto sdef = state.world.state_instance_get_definition(si);
130 auto owner = state.world.state_instance_get_nation_from_state_ownership(si);
131 auto crng = state.world.state_instance_get_state_building_construction(si);
132 if(crng.begin() != crng.end())
135 for(
auto p : state.world.state_definition_get_abstract_state_membership(sdef)) {
136 if(p.get_province().get_nation_from_province_ownership() == owner) {
137 auto rng = p.get_province().get_factory_location();
138 if(
rng.begin() !=
rng.end())
148 state.world.nation_resize_artisan_distribution(state.world.commodity_size());
149 state.world.nation_resize_artisan_actual_production(state.world.commodity_size());
151 auto const csize = state.world.commodity_size();
153 for(
auto n : state.world.in_nation) {
154 for(
uint32_t i = 1; i < csize; ++i) {
155 dcon::commodity_id cid{ dcon::commodity_id::value_base_t(i) };
156 auto kf = state.world.commodity_get_key_factory(cid);
158 if(state.world.commodity_get_artisan_output_amount(cid) > 0.0f && (state.world.commodity_get_is_available_from_start(cid) || (kf && state.world.nation_get_active_building(n, kf)))) {
160 n.set_artisan_distribution(cid, 0.f);
168 state.world.for_each_commodity([&](dcon::commodity_id c) {
169 auto kf = state.world.commodity_get_key_factory(c);
170 if(state.world.commodity_get_is_life_need(c) && (state.world.commodity_get_is_available_from_start(c) || (kf && state.world.nation_get_active_building(n, kf)))) {
171 auto& w = state.world.nation_get_life_needs_weights(n, c);
177 state.world.for_each_commodity([&](dcon::commodity_id c) {
178 auto kf = state.world.commodity_get_key_factory(c);
179 if(state.world.commodity_get_is_everyday_need(c) && (state.world.commodity_get_is_available_from_start(c) || (kf && state.world.nation_get_active_building(n, kf)))) {
180 auto& w = state.world.nation_get_everyday_needs_weights(n, c);
186 state.world.for_each_commodity([&](dcon::commodity_id c) {
187 auto kf = state.world.commodity_get_key_factory(c);
188 if(state.world.commodity_get_is_luxury_need(c) && (state.world.commodity_get_is_available_from_start(c) || (kf && state.world.nation_get_active_building(n, kf)))) {
189 auto& w = state.world.nation_get_luxury_needs_weights(n, c);
197 return 1.0f /
math::sqrt(std::max(state.world.commodity_get_current_price(c), 0.001f));
202 float total_weights = 0.0f;
205 state.world.for_each_commodity([&](dcon::commodity_id c) {
206 auto kf = state.world.commodity_get_key_factory(c);
207 if(state.world.commodity_get_is_life_need(c) && (state.world.commodity_get_is_available_from_start(c) || (kf && state.world.nation_get_active_building(n, kf)))) {
208 auto weight = need_weight(state, n, c);
209 total_weights += weight;
214 state.world.for_each_commodity([&](dcon::commodity_id c) {
215 auto kf = state.world.commodity_get_key_factory(c);
216 if(state.world.commodity_get_is_life_need(c) && (state.world.commodity_get_is_available_from_start(c) || (kf && state.world.nation_get_active_building(n, kf)))) {
217 auto weight = need_weight(state, n, c);
218 auto ideal_weighting = weight / total_weights * count;
219 auto& w = state.world.nation_get_life_needs_weights(n, c);
220 w = ideal_weighting * state.defines.alice_need_drift_speed + w * (1.0f - state.defines.alice_need_drift_speed);
222 assert(std::isfinite(w));
223 assert(w <= count + 0.01f);
229 float total_weights = 0.0f;
232 state.world.for_each_commodity([&](dcon::commodity_id c) {
233 auto kf = state.world.commodity_get_key_factory(c);
234 if(state.world.commodity_get_is_everyday_need(c) && (state.world.commodity_get_is_available_from_start(c) || (kf && state.world.nation_get_active_building(n, kf)))) {
235 auto weight = need_weight(state, n, c);
236 total_weights += weight;
241 state.world.for_each_commodity([&](dcon::commodity_id c) {
242 auto kf = state.world.commodity_get_key_factory(c);
243 if(state.world.commodity_get_is_everyday_need(c) && (state.world.commodity_get_is_available_from_start(c) || (kf && state.world.nation_get_active_building(n, kf)))) {
244 auto weight = need_weight(state, n, c);
245 auto ideal_weighting = weight / total_weights * count;
246 auto& w = state.world.nation_get_everyday_needs_weights(n, c);
247 w = ideal_weighting * state.defines.alice_need_drift_speed + w * (1.0f - state.defines.alice_need_drift_speed);
249 assert(std::isfinite(w));
250 assert(w <= count + 0.01f);
256 float total_weights = 0.0f;
259 state.world.for_each_commodity([&](dcon::commodity_id c) {
260 auto kf = state.world.commodity_get_key_factory(c);
261 if(state.world.commodity_get_is_luxury_need(c) && (state.world.commodity_get_is_available_from_start(c) || (kf && state.world.nation_get_active_building(n, kf)))) {
262 auto weight = need_weight(state, n, c);
263 total_weights += weight;
268 state.world.for_each_commodity([&](dcon::commodity_id c) {
269 auto kf = state.world.commodity_get_key_factory(c);
270 if(state.world.commodity_get_is_luxury_need(c) && (state.world.commodity_get_is_available_from_start(c) || (kf && state.world.nation_get_active_building(n, kf)))) {
271 auto weight = need_weight(state, n, c);
272 auto ideal_weighting = weight / total_weights * count;
273 auto& w = state.world.nation_get_luxury_needs_weights(n, c);
274 w = ideal_weighting * state.defines.alice_need_drift_speed + w * (1.0f - state.defines.alice_need_drift_speed);
276 assert(std::isfinite(w));
277 assert(w <= count + 0.01f);
286 std::vector<float>& buffer_commodities,
287 std::vector<float>& buffer_ingredients,
288 std::vector<float>& buffer_weights
290 state.world.for_each_commodity([&](dcon::commodity_id c) {
291 float amount = buffer_commodities[c.index()];
293 if(state.world.commodity_get_rgo_amount(c) > 0.f) {
294 buffer_ingredients[c.index()] += amount;
297 std::vector<float> weights;
298 float total_weight = 0.f;
299 float non_zero_count = 0.f;
301 state.world.for_each_factory_type([&](dcon::factory_type_id t) {
302 auto o = state.world.factory_type_get_output(t);
304 auto& inputs = state.world.factory_type_get_inputs(t);
306 float weight_current = 0;
308 for(uint32_t i = 0; i < economy::commodity_set::set_size; ++i) {
309 if(inputs.commodity_type[i]) {
310 float weight_input = buffer_weights[inputs.commodity_type[i].index()];
311 total_weight += weight_input;
312 weight_current += weight_input;
318 if(weight_current > 0.f)
321 weights.push_back(weight_current);
325 if(total_weight == 0) {
326 for(
size_t i = 0; i < weights.size(); i++) {
331 float average_weight = total_weight / non_zero_count;
332 for(
size_t i = 0; i < weights.size(); i++) {
333 if(weights[i] == 0.f) {
334 weights[i] = average_weight;
335 total_weight += average_weight;
343 state.world.for_each_factory_type([&](dcon::factory_type_id t) {
344 auto o = state.world.factory_type_get_output(t);
346 auto& inputs = state.world.factory_type_get_inputs(t);
347 float output_power = state.world.factory_type_get_output_amount(t);
349 float weight_current = weights[index] / total_weight;
353 if(inputs.commodity_type[i]) {
355 buffer_ingredients[inputs.commodity_type[i].index()] += inputs.commodity_amounts[i] * amount / output_power * weight_current;
357 float weight_input = buffer_weights[inputs.commodity_type[i].index()];
358 total_weight += weight_input;
359 weight_current += weight_input;
385 auto sdef = state.world.state_instance_get_definition(si);
386 auto owner = state.world.state_instance_get_nation_from_state_ownership(si);
387 for(
auto p : state.world.state_definition_get_abstract_state_membership(sdef)) {
388 if(p.get_province().get_nation_from_province_ownership() == owner) {
389 for(
auto b : p.get_province().get_factory_location()) {
390 if(b.get_factory().get_building_type() == fac)
399 return state.world.nation_get_is_bankrupt(debt_holder) &&
400 state.world.unilateral_relationship_get_owns_debt_of(
401 state.world.get_unilateral_relationship_by_unilateral_pair(debtor, debt_holder)) > 0.1f;
405 auto rng = state.world.nation_get_state_building_construction(n);
406 return rng.begin() !=
rng.end();
410 for(
auto prov_owner : nation_fat.get_province_ownership()) {
411 auto prov = prov_owner.get_province();
412 for(
auto factloc : prov.get_factory_location()) {
413 auto scale = factloc.get_factory().get_production_scale();
423 auto const& inputs = state.world.commodity_get_artisan_inputs(c);
424 float input_total = 0.0f;
425 for(
uint32_t i = 0; i < commodity_set::set_size; ++i) {
426 if(inputs.commodity_type[i]) {
427 input_total += inputs.commodity_amounts[i] * state.world.commodity_get_current_price(inputs.commodity_type[i]);
433 float output_total = state.world.commodity_get_artisan_output_amount(c) * state.world.commodity_get_current_price(c);
435 float input_multiplier = std::max(0.1f, state.defines.alice_inputs_base_factor_artisans + state.world.nation_get_modifier_values(n, sys::national_mod_offsets::artisan_input));
436 float output_multiplier = std::max(0.1f, state.defines.alice_output_base_factor_artisans + state.world.nation_get_modifier_values(n, sys::national_mod_offsets::artisan_output));
438 return output_total * output_multiplier - input_multiplier * input_total;
442 auto const& inputs = state.world.commodity_get_artisan_inputs(c);
443 float input_total = 0.0f;
444 for(
uint32_t i = 0; i < commodity_set::set_size; ++i) {
445 if(inputs.commodity_type[i]) {
446 least = std::min(least, state.world.nation_get_demand_satisfaction(n, inputs.commodity_type[i]));
455 auto kf = state.world.commodity_get_key_factory(cid);
457 state.world.commodity_get_artisan_output_amount(cid) > 0.0f
459 state.world.commodity_get_is_available_from_start(cid)
461 kf && state.world.nation_get_active_building(n, kf)
467inline constexpr float ln_2 = 0.30103f;
476 f = 1 + f + f * f / 2 + f * f * f / 6;
490 float multiplier = 0.000001f * state.world.nation_get_everyday_needs_costs(n, state.culture_definitions.artisans);
491 return 1.f / (multiplier + 1.f);
497 auto const csize = state.world.commodity_size();
500 float max_score = std::numeric_limits<float>::lowest();
502 for(
uint32_t i = 1; i < csize; ++i) {
503 dcon::commodity_id cid{ dcon::commodity_id::value_base_t(i) };
504 float score = state.world.nation_get_artisan_distribution(n, cid);
505 if(score > max_score) {
509 if(baseline > max_score) {
510 max_score = baseline;
517 auto const csize = state.world.commodity_size();
523 for(
uint32_t i = 1; i < csize; ++i) {
524 dcon::commodity_id cid{ dcon::commodity_id::value_base_t(i) };
525 float score = state.world.nation_get_artisan_distribution(n, cid);
537 dcon::commodity_id c,
542 float score = state.world.nation_get_artisan_distribution(n, c);
547 auto const csize = state.world.commodity_size();
557 auto const csize = state.world.commodity_size();
558 float distribution_drift_speed = 0.0001f;
560 std::vector<float> current_distribution;
561 std::vector<float> profits;
562 profits.resize(csize + 1);
566 for(
uint32_t i = 1; i < csize; ++i) {
567 dcon::commodity_id cid{ dcon::commodity_id::value_base_t(i) };
573 profits[cid.index()] = profit;
575 profits[cid.index()] = -256.f / mult / distribution_drift_speed * 10.f;
583 for(
uint32_t i = 1; i < csize; ++i) {
584 dcon::commodity_id cid{ dcon::commodity_id::value_base_t(i) };
585 auto& w = state.world.nation_get_artisan_distribution(n, cid);
587 auto output = state.world.commodity_get_artisan_output_amount(cid);
588 auto next_score = w * 0.8f + distribution_drift_speed * profits[cid.index()] * (1 - last_distribution) /
output;
596 state.world.for_each_commodity([&](dcon::commodity_id c) {
597 auto fc = fatten(state.world, c);
598 fc.set_current_price(fc.get_cost());
599 fc.set_total_consumption(0.0f);
600 fc.set_total_production(0.0f);
601 fc.set_total_real_demand(0.0f);
603 for(
int i = 0; i < 8; i++) {
604 fc.set_demand_by_category(i, 0.f);
608 fc.set_price_record(i, fc.get_cost());
613 auto savings_buffer = state.world.pop_type_make_vectorizable_float_buffer();
614 state.world.for_each_pop_type([&](dcon::pop_type_id t) {
615 auto ft = fatten(state.world, t);
616 state.world.for_each_commodity([&](dcon::commodity_id c) {
617 savings_buffer.get(t) += state.world.commodity_get_is_available_from_start(c)
618 ? state.world.commodity_get_cost(c) * ft.get_life_needs(c) + 0.5f * state.world.commodity_get_cost(c) * ft.get_everyday_needs(c)
621 auto strata = (ft.get_strata() * 2) + 1;
622 savings_buffer.get(t) *= strata;
625 state.world.for_each_pop([&](dcon::pop_id p) {
626 auto fp = fatten(state.world, p);
627 fp.set_life_needs_satisfaction(1.0f);
628 fp.set_everyday_needs_satisfaction(0.1f);
629 fp.set_luxury_needs_satisfaction(0.0f);
630 fp.set_savings(savings_buffer.get(fp.get_poptype()) * fp.get_size() / state.defines.alice_needs_scaling_factor);
633 state.world.for_each_factory([&](dcon::factory_id f) {
634 auto ff = fatten(state.world, f);
635 ff.set_production_scale(1.0f);
639 auto csize = state.world.commodity_size();
640 std::vector<std::vector<float>> per_climate_distribution_buffer(state.world.modifier_size() + 1, std::vector<float>(csize + 1, 0.f));
641 std::vector<std::vector<float>> per_terrain_distribution_buffer(state.world.modifier_size() + 1, std::vector<float>(csize + 1, 0.f));
642 std::vector<std::vector<float>> per_continent_distribution_buffer(state.world.modifier_size() + 1, std::vector<float>(csize + 1, 0.f));
646 auto fp = fatten(state.world, p);
647 dcon::commodity_id main_trade_good = state.world.province_get_rgo(p);
648 if(state.world.commodity_get_money_rgo(main_trade_good)) {
651 dcon::modifier_id climate = fp.get_climate();
652 dcon::modifier_id terrain = fp.get_terrain();
653 dcon::modifier_id continent = fp.get_continent();
654 per_climate_distribution_buffer[climate.value][main_trade_good.value] += 1.f;
655 per_terrain_distribution_buffer[terrain.value][main_trade_good.value] += 1.f;
656 per_continent_distribution_buffer[continent.value][main_trade_good.value] += 1.f;
661 float climate_sum = 0.f;
662 float terrain_sum = 0.f;
663 float continent_sum = 0.f;
664 for(
uint32_t j = 0; j < csize; j++) {
665 climate_sum += per_climate_distribution_buffer[i][j];
666 terrain_sum += per_terrain_distribution_buffer[i][j];
667 continent_sum += per_continent_distribution_buffer[i][j];
669 for(
uint32_t j = 0; j < csize; j++) {
670 per_climate_distribution_buffer[i][j] *= climate_sum == 0.f ? 1.f : 1.f / climate_sum;
671 per_terrain_distribution_buffer[i][j] *= terrain_sum == 0.f ? 1.f : 1.f / terrain_sum;
672 per_continent_distribution_buffer[i][j] *= continent_sum == 0.f ? 1.f : 1.f / continent_sum;
677 if(state.world.province_get_rgo_was_set_during_scenario_creation(p)) {
681 auto fp = fatten(state.world, p);
682 dcon::modifier_id climate = fp.get_climate();
683 dcon::modifier_id terrain = fp.get_terrain();
684 dcon::modifier_id continent = fp.get_continent();
686 dcon::commodity_id main_trade_good = state.world.province_get_rgo(p);
687 bool is_mine = state.world.commodity_get_is_mine(main_trade_good);
690 auto max_rgo_size = std::ceil(2000.f / state.defines.alice_rgo_per_size_employment
693 state.world.for_each_commodity([&](dcon::commodity_id c) {
694 fp.set_rgo_employment_per_good(c, 0.f);
695 fp.set_rgo_target_employment_per_good(c, 0.f);
699 float pop_amount = 0.0f;
700 for(
auto pt : state.world.in_pop_type) {
701 if(pt == state.culture_definitions.slaves) {
702 pop_amount += state.world.province_get_demographics(p, demographics::to_key(state, state.culture_definitions.slaves));
703 }
else if(pt.get_is_paid_rgo_worker()) {
704 pop_amount += state.world.province_get_demographics(p, demographics::to_key(state, pt));
708 auto size_at_the_start_of_the_game = std::ceil(pop_amount / state.defines.alice_rgo_per_size_employment);
709 auto real_size = std::min(size_at_the_start_of_the_game * 1.5f, max_rgo_size);
711 assert(std::isfinite(real_size));
712 fp.set_rgo_size(real_size);
714 static std::vector<float> true_distribution;
715 true_distribution.resize(state.world.commodity_size());
718 state.world.for_each_commodity([&](dcon::commodity_id c) {
719 float climate_d = per_climate_distribution_buffer[climate.value][c.value];
720 float terrain_d = per_terrain_distribution_buffer[terrain.value][c.value];
721 float continent_d = per_continent_distribution_buffer[continent.value][c.value];
722 float current = (climate_d + terrain_d) * (climate_d + terrain_d) * continent_d;
723 true_distribution[c.index()] = current;
729 state.world.for_each_commodity([&](dcon::commodity_id c) {
730 float climate_d = per_climate_distribution_buffer[climate.value][c.value];
731 float terrain_d = per_terrain_distribution_buffer[terrain.value][c.value];
732 float current = (climate_d + terrain_d) * (climate_d + terrain_d);
733 true_distribution[c.index()] = current;
740 state.world.for_each_commodity([&](dcon::commodity_id c) {
741 if(state.world.commodity_get_money_rgo(c)) {
744 if(!state.world.commodity_get_is_available_from_start(c)) {
748 true_distribution[c.index()] = current;
753 state.world.for_each_commodity([&](dcon::commodity_id c) {
754 assert(std::isfinite(total));
757 true_distribution[c.index()] = 0.f;
759 true_distribution[c.index()] /= total;
764 state.world.for_each_commodity([&](dcon::commodity_id c) {
765 auto fc = fatten(state.world, c);
766 assert(std::isfinite(true_distribution[c.index()]));
767 state.world.province_get_rgo_max_size_per_good(fp, c) += real_size * true_distribution[c.index()];
771 state.world.for_each_nation([&](dcon::nation_id n) {
772 initialize_needs_weights(state, n);
774 auto fn = fatten(state.world, n);
775 fn.set_administrative_spending(int8_t(80));
776 fn.set_military_spending(int8_t(60));
777 fn.set_education_spending(int8_t(100));
778 fn.set_social_spending(int8_t(100));
779 fn.set_land_spending(int8_t(100));
780 fn.set_naval_spending(int8_t(100));
781 fn.set_construction_spending(int8_t(100));
782 fn.set_overseas_spending(int8_t(100));
784 fn.set_poor_tax(int8_t(75));
785 fn.set_middle_tax(int8_t(75));
786 fn.set_rich_tax(int8_t(75));
788 fn.set_spending_level(1.0f);
790 state.world.for_each_commodity([&](dcon::commodity_id c) {
791 state.world.nation_set_demand_satisfaction(n, c, 1.0f);
792 state.world.nation_set_direct_demand_satisfaction(n, c, 0.0f);
805 state.world.for_each_nation([&](dcon::nation_id n) {
819 if(state.world.nation_get_is_civilized(sphere_member)) {
820 float base = state.world.nation_get_rank(sphere_member) <= state.defines.colonial_rank
821 ? state.defines.second_rank_base_share_factor
822 : state.defines.civ_base_share_factor;
823 auto const ul = state.world.get_unilateral_relationship_by_unilateral_pair(sphere_member, sphere_leader);
824 float sl_investment = state.world.unilateral_relationship_get_foreign_investment(ul);
826 float investment_fraction = total_investment > 0.0001f ? sl_investment / total_investment : 0.0f;
827 return base + (1.0f - base) * investment_fraction;
829 return state.defines.unciv_base_share_factor;
834 for(
auto gp : state.world.nation_get_gp_relationship_as_great_power(n)) {
839 auto t = gp.get_influence_target();
841 state.world.for_each_commodity([&](dcon::commodity_id c) {
842 state.world.nation_get_domestic_market_pool(n, c) += share * state.world.nation_get_domestic_market_pool(t, c);
849 if(
auto sl = state.world.nation_get_in_sphere_of(n); sl) {
855 state.world.for_each_commodity(
856 [&](dcon::commodity_id c) { state.world.nation_get_domestic_market_pool(n, c) *= (1.0f - share); });
862 return tariff_efficiency * float(state.world.nation_get_tariffs(n)) / 100.0f;
866 auto central_ports = state.world.nation_get_central_ports(n);
867 if(central_ports > 0) {
869 + float(state.world.nation_get_central_blockaded(n)) / float(central_ports)
877 state.world.for_each_factory([&](dcon::factory_id f) {
878 auto fac_type = fatten(state.world, state.world.factory_get_building_type(f));
880 auto prov = state.world.factory_get_province_from_factory_location(f);
881 auto pstate = state.world.province_get_state_membership(prov);
882 auto powner = state.world.province_get_nation_from_province_ownership(prov);
884 if(powner && pstate) {
885 if(
auto mod_a = fac_type.get_bonus_1_trigger();
887 sum -= fac_type.get_bonus_1_amount();
889 if(
auto mod_b = fac_type.get_bonus_2_trigger();
891 sum -= fac_type.get_bonus_2_amount();
893 if(
auto mod_c = fac_type.get_bonus_3_trigger();
895 sum -= fac_type.get_bonus_3_amount();
899 state.world.factory_set_triggered_modifiers(f, sum);
904 auto rgo_ownership = state.world.province_get_landowners_share(p) + state.world.province_get_capitalists_share(p);
905 return state.world.province_get_rgo_size(p) * (1.f - rgo_ownership) * 2.0f;
909 bool is_mine = state.world.commodity_get_is_mine(c);
912 auto rgo = state.world.province_get_rgo(p);
915 base = state.defines.alice_base_rgo_employment_bonus / state.defines.alice_rgo_per_size_employment;
920 auto rgo_ownership = state.world.province_get_landowners_share(p) + state.world.province_get_capitalists_share(p);
921 auto sz = state.world.province_get_rgo_max_size_per_good(p, c) * rgo_ownership + base;
922 auto pmod = state.world.province_get_modifier_values(p, is_mine ? sys::provincial_mod_offsets::mine_rgo_size : sys::provincial_mod_offsets::farm_rgo_size);
923 auto nmod = state.world.nation_get_modifier_values(n, is_mine ? sys::national_mod_offsets::mine_rgo_size : sys::national_mod_offsets::farm_rgo_size);
924 auto specific_pmod = state.world.nation_get_rgo_size(n, c);
925 auto bonus = pmod + nmod + specific_pmod + 1.0f;
927 return std::max(sz * bonus, 0.00f);
932 state.world.for_each_commodity([&](dcon::commodity_id c) {
939 return state.defines.alice_rgo_per_size_employment *
subsistence_size(state, p) * 1.1f;
944 state.world.for_each_commodity([&](dcon::commodity_id c) {
945 total += state.world.province_get_rgo_employment_per_good(p, c);
951 return state.defines.alice_rgo_per_size_employment *
rgo_effective_size(state, n, p, c);
956 state.world.for_each_commodity([&](dcon::commodity_id c) {
963 state.world.execute_parallel_over_province([&](
auto ids) {
964 auto max_subsistence = ve::apply([&](dcon::province_id p) {
968 auto employment = state.world.province_get_subsistence_employment(ids);
969 auto saturation = employment / (4.f + max_subsistence);
970 auto saturation_score = 1.f / (saturation + 1.f);
972 auto quality = (
ve::to_float(state.world.province_get_life_rating(ids)) - 10.f) / 10.f;
973 quality = ve::max(quality, 0.f) + 0.01f;
975 score = (score * saturation_score);
976 state.world.province_set_subsistence_score(ids, score);
981 return state.world.province_get_subsistence_score(p)
982 * state.world.province_get_subsistence_employment(p)
987 state.world.execute_parallel_over_province([&](
auto ids) {
988 auto local_states = state.world.province_get_state_membership(ids);
989 auto weight_aristocracy =
990 state.world.state_instance_get_demographics(local_states,
demographics::to_key(state, state.culture_definitions.aristocrat)) * 200.f
991 + state.world.state_instance_get_demographics(local_states,
demographics::to_key(state, state.culture_definitions.slaves));
992 auto weight_capitalists =
993 state.world.state_instance_get_demographics(local_states,
demographics::to_key(state, state.culture_definitions.capitalists)) * 200.f;
994 auto weight_population =
995 state.world.state_instance_get_demographics(local_states,
demographics::to_key(state, state.culture_definitions.farmers))
996 + state.world.state_instance_get_demographics(local_states,
demographics::to_key(state, state.culture_definitions.laborers));
997 auto total = weight_aristocracy + weight_capitalists + weight_population + 1.0f;
998 state.world.province_set_landowners_share(ids, weight_aristocracy / total);
999 state.world.province_set_capitalists_share(ids, weight_capitalists / total);
1003int32_t factory_priority(
sys::state const& state, dcon::factory_id f) {
1004 return (state.world.factory_get_priority_low(f) ? 1 : 0) + (state.world.factory_get_priority_high(f) ? 2 : 0);
1007 state.world.factory_set_priority_high(f, priority >= 2);
1008 state.world.factory_set_priority_low(f, (priority & 1) != 0);
1011 return state.world.factory_get_unprofitable(f) ==
false || state.world.factory_get_subsidized(f);
1016 auto owner = state.world.province_get_nation_from_province_ownership(p);
1017 auto current_employment = 0.f;
1018 state.world.for_each_commodity([&](dcon::commodity_id c) {
1019 current_employment += state.world.province_get_rgo_employment_per_good(p, c);
1021 current_employment += state.world.province_get_subsistence_employment(p);
1023 bool is_mine = state.world.commodity_get_is_mine(state.world.province_get_rgo(p));
1024 float worker_pool = 0.0f;
1025 for(
auto wt : state.culture_definitions.rgo_workers) {
1026 worker_pool += state.world.province_get_demographics(p, demographics::to_key(state, wt));
1028 float slave_pool = state.world.province_get_demographics(p,
demographics::to_key(state, state.culture_definitions.slaves));
1029 float labor_pool = worker_pool + slave_pool;
1033 assert(labor_pool <= total_population);
1038 static std::vector<dcon::commodity_id> ordered_rgo_goods;
1039 ordered_rgo_goods.clear();
1041 state.world.for_each_commodity([&](dcon::commodity_id c) {
1043 ordered_rgo_goods.push_back(c);
1045 state.world.province_set_rgo_employment_per_good(p, c, 0.f);
1049 std::sort(ordered_rgo_goods.begin(), ordered_rgo_goods.end(), [&](dcon::commodity_id a, dcon::commodity_id b) {
1050 float profit_a = rgo_expected_worker_norm_profit(state, p, owner, a);
1051 float profit_b = rgo_expected_worker_norm_profit(state, p, owner, b);
1052 return (profit_a > profit_b);
1056 float speed = 0.20f;
1058 float total_workforce = labor_pool;
1059 float max_employment_total = 0.f;
1060 float total_employed = 0.f;
1062 for(
uint32_t i = 0; i < ordered_rgo_goods.size(); ++i) {
1063 auto c = ordered_rgo_goods[i];
1065 max_employment_total += max_employment;
1066 float target_workforce = std::min(state.world.province_get_rgo_target_employment_per_good(p, c), total_workforce);
1068 float current_workforce = state.world.province_get_rgo_employment_per_good(p, c);
1069 float new_employment = std::min(current_workforce * (1 - speed) + target_workforce * speed, total_workforce);
1070 total_workforce -= new_employment;
1072 new_employment = std::clamp(new_employment, 0.f, max_employment);
1073 total_employed += new_employment;
1075 state.world.province_set_rgo_employment_per_good(p, c, new_employment);
1079 total_workforce -= subsistence;
1080 total_employed += subsistence;
1082 state.world.province_set_subsistence_employment(p, subsistence);
1084 assert(total_employed <= total_population + 1.f);
1086 float employment_ratio = 0.f;
1087 if(max_employment_total > 1.f) {
1088 employment_ratio = total_employed / (max_employment_total + 1.f);
1090 employment_ratio = 1.f;
1092 state.world.province_set_rgo_employment(p, employment_ratio);
1094 auto slave_fraction = (slave_pool > current_employment) ? current_employment / slave_pool : 1.0f;
1095 auto free_fraction = std::max(0.0f, (worker_pool > current_employment - slave_pool) ? (current_employment - slave_pool) / std::max(worker_pool, 0.01f) : 1.0f);
1097 for(
auto pop : state.world.province_get_pop_location(p)) {
1098 auto pt =
pop.get_pop().get_poptype();
1099 if(pt == state.culture_definitions.slaves) {
1100 pop.get_pop().set_employment(
pop.get_pop().get_size() * slave_fraction);
1101 }
else if(pt.get_is_paid_rgo_worker()) {
1102 pop.get_pop().set_employment(
pop.get_pop().get_size() * free_fraction);
1109 return state.defines.alice_factory_per_level_employment * state.world.factory_get_level(f);
1113 auto primary_employment = state.world.factory_get_primary_employment(f);
1114 return factory_max_employment(state, f) * (state.economy_definitions.craftsmen_fraction * primary_employment);
1117 auto secondary_employment = state.world.factory_get_secondary_employment(f);
1118 return factory_max_employment(state, f) * ((1 - state.economy_definitions.craftsmen_fraction) * secondary_employment);
1122 auto primary_employment = state.world.factory_get_primary_employment(f);
1123 auto secondary_employment = state.world.factory_get_secondary_employment(f);
1124 return factory_max_employment(state, f) * (state.economy_definitions.craftsmen_fraction * primary_employment + (1 -state.economy_definitions.craftsmen_fraction) * secondary_employment);
1128 state.world.for_each_state_instance([&](dcon::state_instance_id si) {
1129 float primary_pool = state.world.state_instance_get_demographics(si,
1131 float secondary_pool = state.world.state_instance_get_demographics(si,
1134 static std::vector<dcon::factory_id> ordered_factories;
1135 ordered_factories.clear();
1138 for(auto fac : state.world.province_get_factory_location(p)) {
1139 ordered_factories.push_back(fac.get_factory());
1143 std::sort(ordered_factories.begin(), ordered_factories.end(), [&](dcon::factory_id a, dcon::factory_id b) {
1144 if(factory_is_profitable(state, a) != factory_is_profitable(state, b)) {
1145 return factory_is_profitable(state, a);
1147 if(factory_priority(state, a) != factory_priority(state, b)) {
1148 return factory_priority(state, a) > factory_priority(state, b);
1150 return a.index() < b.index();
1153 float employment_shift_speed = 0.001f;
1155 float primary_pool_copy = primary_pool;
1156 float secondary_pool_copy = secondary_pool;
1157 for(
uint32_t index = 0; index < ordered_factories.size();) {
1160 float total_workforce = 0.0f;
1161 for(; next_index < ordered_factories.size(); ++next_index) {
1163 factory_is_profitable(state, ordered_factories[index])
1165 factory_is_profitable(state, ordered_factories[next_index])
1167 factory_priority(state, ordered_factories[index])
1169 factory_priority(state, ordered_factories[next_index])
1174 state.world.factory_get_production_scale(ordered_factories[next_index]);
1178 float type_share =
state.economy_definitions.craftsmen_fraction * total_workforce;
1179 float scale = primary_pool_copy >= type_share ? 1.0f : primary_pool_copy / type_share;
1180 primary_pool_copy = std::max(0.0f, primary_pool_copy - type_share);
1183 for(
uint32_t i = index; i < next_index; ++i) {
1184 float old_employment =
state.world.factory_get_primary_employment(ordered_factories[i]);
1185 float new_employment =
1186 old_employment * (1.f - employment_shift_speed)
1187 + scale *
state.world.factory_get_production_scale(ordered_factories[i]) * employment_shift_speed;
1189 state.world.factory_set_primary_employment(
1190 ordered_factories[i],
1196 float type_share = (1.0f -
state.economy_definitions.craftsmen_fraction) * total_workforce;
1197 float scale = secondary_pool_copy >= type_share ? 1.0f : secondary_pool_copy / type_share;
1198 secondary_pool_copy = std::max(0.0f, secondary_pool_copy - type_share);
1200 for(
uint32_t i = index; i < next_index; ++i) {
1202 float old_employment =
state.world.factory_get_secondary_employment(ordered_factories[i]);
1203 float new_employment =
1204 old_employment * (1.f - employment_shift_speed)
1205 + scale *
state.world.factory_get_production_scale(ordered_factories[i]) * employment_shift_speed;
1207 state.world.factory_set_secondary_employment(
1208 ordered_factories[i],
1217 float prim_employment = 1.0f - (primary_pool > 0 ? primary_pool_copy / primary_pool : 0.0f);
1218 float sec_employment = 1.0f - (secondary_pool > 0 ? secondary_pool_copy / secondary_pool : 0.0f);
1221 for(
auto pop :
state.world.province_get_pop_location(p)) {
1222 if(pop.get_pop().get_poptype() == state.culture_definitions.primary_factory_worker) {
1223 pop.get_pop().set_employment(pop.get_pop().get_size() * prim_employment);
1224 }
else if(
pop.get_pop().get_poptype() ==
state.culture_definitions.secondary_factory_worker) {
1225 pop.get_pop().set_employment(pop.get_pop().get_size() * sec_employment);
1259 float mobilization_impact) {
1260 auto fac = fatten(state.world, f);
1261 auto fac_type = fac.get_building_type();
1270 float throughput_multiplier = (state.world.nation_get_factory_goods_throughput(n, fac_type.get_output()) + 1.0f);
1271 float output_multiplier = state.world.nation_get_factory_goods_output(n, fac_type.get_output())
1273 + fac.get_secondary_employment()
1274 * (1.0f - state.economy_definitions.craftsmen_fraction)
1278 float max_production_scale = fac.get_primary_employment()
1280 * std::max(0.0f, mobilization_impact);
1282 return throughput_multiplier * output_multiplier * max_production_scale;
1286 bool is_mine = state.world.commodity_get_is_mine(c);
1288 float main_rgo = 1.f;
1289 auto rgo = state.world.province_get_rgo(p);
1291 main_rgo = state.defines.alice_base_rgo_efficiency_bonus;
1294 float base_amount = state.world.commodity_get_rgo_amount(c);
1297 + state.world.province_get_modifier_values(p, sys::provincial_mod_offsets::local_rgo_throughput)
1298 + state.world.nation_get_modifier_values(n, sys::national_mod_offsets::rgo_throughput)
1299 + state.world.province_get_modifier_values(p,
1301 sys::provincial_mod_offsets::mine_rgo_eff
1303 sys::provincial_mod_offsets::farm_rgo_eff)
1304 + state.world.nation_get_modifier_values(n,
1306 sys::national_mod_offsets::mine_rgo_eff
1308 sys::national_mod_offsets::farm_rgo_eff);
1310 float saturation = state.world.province_get_rgo_employment_per_good(p, c)
1313 float result = base_amount
1315 * (1.f + 1.0f * (1.f - saturation))
1317 * state.defines.alice_rgo_boost
1318 * std::max(0.5f, (1.0f + state.world.province_get_modifier_values(p, sys::provincial_mod_offsets::local_rgo_output) +
1319 state.world.nation_get_modifier_values(n, sys::national_mod_offsets::rgo_output) +
1320 state.world.nation_get_rgo_goods_output(n, c)));
1322 assert(std::isfinite(result));
1336 assert(val >= 0.0f && std::isfinite(val));
1343 dcon::factory_type_fat_id fac_type
1345 float min_input_available = 1.0f;
1346 auto& inputs = fac_type.get_inputs();
1347 for(
uint32_t i = 0; i < commodity_set::set_size; ++i) {
1348 if(inputs.commodity_type[i]) {
1349 min_input_available =
1351 min_input_available,
1352 state.world.nation_get_demand_satisfaction(n, inputs.commodity_type[i])
1358 return min_input_available;
1362 float input_total = 0.0f;
1363 auto& inputs = fac_type.get_inputs();
1364 for(
uint32_t i = 0; i < commodity_set::set_size; ++i) {
1365 if(inputs.commodity_type[i]) {
1366 input_total += inputs.commodity_amounts[i] * state.world.nation_get_effective_prices(n, inputs.commodity_type[i]);
1375 float min_e_input_available = 1.0f;
1376 auto& e_inputs = fac_type.get_efficiency_inputs();
1377 for(
uint32_t i = 0; i < small_commodity_set::set_size; ++i) {
1378 if(e_inputs.commodity_type[i]) {
1379 min_e_input_available =
1381 min_e_input_available,
1382 state.world.nation_get_demand_satisfaction(n, e_inputs.commodity_type[i])
1389 return min_e_input_available;
1393 float e_input_total = 0.0f;
1394 auto& e_inputs = fac_type.get_efficiency_inputs();
1395 for(
uint32_t i = 0; i < small_commodity_set::set_size; ++i) {
1396 if(e_inputs.commodity_type[i]) {
1397 e_input_total += e_inputs.commodity_amounts[i] * state.world.nation_get_effective_prices(n, e_inputs.commodity_type[i]);
1403 return e_input_total;
1409 state.defines.alice_inputs_base_factor
1410 + state.world.nation_get_modifier_values(n, sys::national_mod_offsets::factory_input)
1414 auto output = state.world.factory_type_get_output(fac_type);
1415 return state.world.nation_get_factory_goods_output(n,
output)
1416 + state.world.nation_get_modifier_values(n, sys::national_mod_offsets::factory_output)
1422 float small_size_effect = 1.f;
1423 float small_bound = state.defines.alice_factory_per_level_employment * 5.f;
1424 if(total_workers < small_bound) {
1425 small_size_effect = 0.5f + total_workers / small_bound * 0.5f;
1428 float total_state_pop = std::max(0.01f, state.world.state_instance_get_demographics(s,
demographics::total));
1429 float capitalists = state.world.state_instance_get_demographics(s,
demographics::to_key(state, state.culture_definitions.capitalists));
1430 float owner_fraction = total_state_pop > 0
1433 capitalists / total_state_pop)
1436 return small_size_effect *
1437 fac.get_triggered_modifiers() *
1440 (state.defines.alice_inputs_base_factor
1441 + state.world.province_get_modifier_values(p, sys::provincial_mod_offsets::local_factory_input)
1442 + state.world.nation_get_modifier_values(n, sys::national_mod_offsets::factory_input)
1443 + owner_fraction * -2.5f)
1448 return state.world.nation_get_factory_goods_throughput(n, fac_type.get_output())
1449 + state.world.province_get_modifier_values(p, sys::provincial_mod_offsets::local_factory_throughput)
1450 + state.world.nation_get_modifier_values(n, sys::national_mod_offsets::factory_throughput)
1455 auto fac_type = fac.get_building_type();
1457 return state.world.nation_get_factory_goods_output(n, fac_type.get_output())
1458 + state.world.province_get_modifier_values(p, sys::provincial_mod_offsets::local_factory_output)
1459 + state.world.nation_get_modifier_values(n, sys::national_mod_offsets::factory_output)
1460 + fac.get_secondary_employment()
1461 * (1.0f - state.economy_definitions.craftsmen_fraction)
1467 return fac.get_primary_employment()
1472 return fac.get_primary_employment()
1474 * (occupied ? 0.1f : 1.0f)
1475 * std::max(0.0f, mobilization_impact);
1480 float several_workers_scale = 10.f / total_workers;
1486 float relative_production_amount
1488 state.world.factory_type_get_output_amount(fac.get_building_type())
1490 state.world.commodity_get_total_production(fac.get_building_type().get_output())
1491 + state.world.commodity_get_total_real_demand(fac.get_building_type().get_output())
1495 float relative_modifier = (1 / (relative_production_amount + 0.01f)) / 1000.f;
1497 float effective_production_scale = 0.0f;
1498 if(state.world.factory_get_subsidized(fac)) {
1499 auto new_production_scale = std::min(1.0f, fac.get_production_scale() + several_workers_scale * fac.get_level() * 10.f);
1500 fac.set_production_scale(new_production_scale);
1501 return std::min(new_production_scale * fac.get_level(), max_production_scale);
1504 float over_profit_ratio = (raw_profit) / (desired_raw_profit + 0.0001f) - 1.f;
1505 float under_profit_ratio = (desired_raw_profit) / (raw_profit + 0.0001f) - 1.f;
1507 float speed_modifier = (over_profit_ratio - under_profit_ratio);
1508 float speed =
production_scale_delta * speed_modifier + several_workers_scale * ((raw_profit - desired_raw_profit > 0.f) ? 1.f : -1.f);
1510 speed = std::clamp(speed, -relative_modifier, relative_modifier);
1512 auto new_production_scale = std::clamp(fac.get_production_scale() + speed, 0.f, 1.f);
1513 fac.set_production_scale(new_production_scale);
1514 return std::min(new_production_scale * fac.get_level(), max_production_scale);
1518 return spendings * (1.2f + fac.get_secondary_employment() * fac.get_level() / 150.f );
1522 auto fac = fatten(state.world, f);
1523 auto fac_type = fac.get_building_type();
1526 assert(fac_type.get_output());
1532 float several_workers_scale = 10.f / total_workers;
1536 mobilization_impact,
1540 float current_workers = total_workers * max_production_scale;
1552 auto const mfactor = state.world.nation_get_modifier_values(n, sys::national_mod_offsets::factory_maintenance) + 1.0f;
1557 float total_production = fac_type.get_output_amount()
1558 * (0.75f + 0.25f * min_e_input_available)
1559 * throughput_multiplier
1561 * min_input_available;
1566 * state.world.commodity_get_current_price(fac_type.get_output());
1571 * (state.defines.alice_factory_per_level_employment / state.defines.alice_needs_scaling_factor)
1574 * throughput_multiplier
1576 * min_input_available
1578 input_multiplier * mfactor
1580 * min_e_input_available
1581 * min_input_available;
1584 float max_pure_profit = profit - spendings;
1585 state.world.factory_set_unprofitable(f, !(max_pure_profit > 0.0f));
1590 max_production_scale,
1595 auto& inputs = fac_type.get_inputs();
1596 auto& e_inputs = fac_type.get_efficiency_inputs();
1605 * throughput_multiplier
1606 * effective_production_scale
1607 * (0.1f + min_input_available * 0.9f);
1609 for(
uint32_t i = 0; i < commodity_set::set_size; ++i) {
1610 if(inputs.commodity_type[i]) {
1613 inputs.commodity_type[i],
1615 * inputs.commodity_amounts[i]
1616 , economy_reason::factory
1626 for(
uint32_t i = 0; i < small_commodity_set::set_size; ++i) {
1627 if(e_inputs.commodity_type[i]) {
1631 e_inputs.commodity_type[i],
1634 * e_inputs.commodity_amounts[i]
1635 * (0.1f + min_e_input_available * 0.9f)
1636 , economy_reason::factory
1643 float actual_production = total_production * effective_production_scale;
1644 float pure_profit = max_pure_profit * effective_production_scale;
1646 state.world.factory_set_actual_production(f, actual_production);
1647 state.world.factory_set_full_profit(f, pure_profit);
1652 auto production = state.world.factory_get_actual_production(f);
1653 if(production > 0) {
1654 auto fac = fatten(state.world, f);
1655 auto fac_type = fac.get_building_type();
1679 auto amount = production;
1680 auto money_made = state.world.factory_get_full_profit(f);
1682 state.world.factory_set_actual_production(f, amount);
1685 if(!fac.get_subsidized()) {
1686 state.world.factory_set_full_profit(f, money_made);
1691 * fac.get_primary_employment()
1692 * (state.defines.alice_factory_per_level_employment / state.defines.alice_needs_scaling_factor);
1693 if(money_made < min_wages) {
1694 auto diff = min_wages - money_made;
1696 state.world.factory_set_full_profit(f, min_wages);
1697 state.world.nation_get_stockpiles(n,
money) -= diff;
1698 state.world.nation_get_subsidies_spending(n) += diff;
1700 state.world.factory_set_full_profit(f, std::max(money_made, 0.0f));
1701 fac.set_subsidized(
false);
1704 state.world.factory_set_full_profit(f, money_made);
1712 auto relevant_paid_population = 0.f;
1713 for(
auto wt : state.culture_definitions.rgo_workers) {
1714 relevant_paid_population += state.world.province_get_demographics(p,
demographics::to_key(state, wt));
1719 .paid_workers = relevant_paid_population,
1721 .total = relevant_paid_population + slaves
1731 float perfect_aristos_amount = total_relevant_population / 10000.f;
1732 float perfect_aristos_amount_adjusted = perfect_aristos_amount / state.defines.alice_needs_scaling_factor;
1733 float aristos_desired_cut = perfect_aristos_amount_adjusted * (
1734 state.world.nation_get_everyday_needs_costs(n, state.culture_definitions.aristocrat)
1735 + state.world.nation_get_life_needs_costs(n, state.culture_definitions.aristocrat)
1737 float aristo_burden_per_worker = aristos_desired_cut / (total_relevant_population + 1);
1740 if (subsistence == 0) subsistence = state.world.province_get_subsistence_score(p);
1742 subsistence -= subsistence_life;
1744 subsistence -= subsistence_everyday;
1747 bool is_mine = state.world.commodity_get_is_mine(state.world.province_get_rgo(p));
1749 dcon::pop_type_id pop_type = is_mine ? state.culture_definitions.laborers : state.culture_definitions.farmers;
1751 auto ln_costs = state.world.nation_get_life_needs_costs(n, pop_type);
1752 auto en_costs = state.world.nation_get_everyday_needs_costs(n, pop_type);
1753 auto lx_costs = state.world.nation_get_luxury_needs_costs(n, pop_type);
1755 float subsistence_based_min_wage =
1756 subsistence_life * ln_costs
1757 + subsistence_everyday * en_costs
1758 + subsistence_luxury * ln_costs;
1760 float min_wage_burden_per_worker = (min_wage + subsistence_based_min_wage) / state.defines.alice_needs_scaling_factor;
1762 float desired_profit_by_worker = aristo_burden_per_worker + min_wage_burden_per_worker / (1.f -
rgo_owners_cut);
1767 float employment_ratio = current_employment / (total_relevant_population + 1.f);
1768 desired_profit_by_worker = desired_profit_by_worker * employment_ratio;
1770 assert(std::isfinite(desired_profit_by_worker));
1772 return desired_profit_by_worker;
1779 auto current_price = state.world.commodity_get_current_price(c);
1780 auto consumed_ratio = std::min(1.f, (state.world.commodity_get_total_consumption(c) + 0.0001f) / (state.world.commodity_get_total_production(c) + 0.0001f));
1781 if(state.world.commodity_get_money_rgo(c)) {
1782 consumed_ratio = 1.f;
1789 / state.defines.alice_rgo_per_size_employment;
1793 return 1.f - (1.f - x) * (1.f - x);
1798 dcon::province_id p,
1800 float mobilization_impact,
1801 float expected_min_wage,
1807 state.world.for_each_commodity([&](dcon::commodity_id c) {
1809 if(max_production < 0.001f) {
1814 auto current_employment = state.world.province_get_rgo_employment_per_good(p, c);
1817 float market_size = state.world.commodity_get_total_production(c) + state.world.commodity_get_total_real_demand(c);
1819 float positive_speed = (expected_profit + 0.00000001f) / (desired_profit + 0.00000001f) - 1.f;
1820 float negative_speed = (desired_profit + 0.00000001f) / (expected_profit + 0.00000001f) - 1.f;
1822 float change = (positive_speed - negative_speed) /
rgo_effective_size(state, n, p, c);
1824 float discrete_step = (((expected_profit - desired_profit) > 0.f) ? 1.f : -1.f) * 20.f;
1826 change = change / max_production * pops_max / 100.f + discrete_step;
1829 assert(std::isfinite(current_employment + change));
1830 auto new_employment = std::clamp(current_employment + change, 0.0f, pops_max);
1831 state.world.province_set_rgo_target_employment_per_good(p, c, new_employment);
1834 float employment_ratio = current_employment / pops_max;
1835 assert(max_production * employment_ratio >= 0);
1836 state.world.province_set_rgo_actual_production_per_good(p, c, max_production * employment_ratio);
1841 state.world.province_set_rgo_full_profit(p, 0.f);
1842 state.world.for_each_commodity([&](dcon::commodity_id c) {
1843 auto amount = state.world.province_get_rgo_actual_production_per_good(p, c);
1847 float profit = amount * state.world.commodity_get_current_price(c);
1851 state.world.province_set_rgo_profit_per_good(p, c, profit);
1852 state.world.province_get_rgo_full_profit(p) += profit;
1854 if(state.world.commodity_get_money_rgo(c)) {
1855 assert(std::isfinite(amount * state.defines.gold_to_cash_rate) && amount * state.defines.gold_to_cash_rate >= 0.0f);
1856 state.world.nation_get_stockpiles(n,
money) += amount * state.defines.gold_to_cash_rate;
1863 auto const csize = state.world.commodity_size();
1864 auto num_artisans = state.world.nation_get_demographics(n,
demographics::to_key(state, state.culture_definitions.artisans));
1865 float total_profit = 0.0f;
1872 for(
uint32_t i = 1; i < csize; ++i) {
1873 dcon::commodity_id cid{ dcon::commodity_id::value_base_t(i) };
1874 state.world.nation_set_artisan_actual_production(n, cid, 0.0f);
1876 float input_total = 0.0f;
1877 auto const& inputs = state.world.commodity_get_artisan_inputs(cid);
1878 float min_available = 1.0f;
1879 for(
uint32_t j = 0; j < commodity_set::set_size; ++j) {
1880 if(inputs.commodity_type[j]) {
1881 input_total += inputs.commodity_amounts[j] * state.world.nation_get_effective_prices(n, inputs.commodity_type[j]);
1882 min_available = std::min(min_available, state.world.nation_get_demand_satisfaction(n, inputs.commodity_type[j]));
1888 float output_total = state.world.commodity_get_artisan_output_amount(cid) * state.world.commodity_get_current_price(cid);
1890 float input_multiplier = std::max(0.1f, state.defines.alice_inputs_base_factor_artisans
1891 + state.world.nation_get_modifier_values(n, sys::national_mod_offsets::artisan_input));
1892 float throughput_multiplier = std::max(0.1f, 1.0f
1893 + state.world.nation_get_modifier_values(n, sys::national_mod_offsets::artisan_throughput));
1894 float output_multiplier = std::max(0.1f, state.defines.alice_output_base_factor_artisans
1895 + state.world.nation_get_modifier_values(n, sys::national_mod_offsets::artisan_output));
1898 float max_production_scale = num_artisans * distribution / 10'000.0f * std::max(0.0f, mobilization_impact);
1900 auto profitability_factor = (output_total * output_multiplier * throughput_multiplier * min_available - input_multiplier * input_total * throughput_multiplier * min_available) / (0.5f * expected_min_wage * (10'000.0f / state.defines.alice_needs_scaling_factor));
1902 bool profitable = (output_total * output_multiplier - input_multiplier * input_total) >= 0.0f;
1908 for(
uint32_t j = 0; j < commodity_set::set_size; ++j) {
1909 if(inputs.commodity_type[j]) {
1913 inputs.commodity_type[j],
1914 input_multiplier * throughput_multiplier * max_production_scale * inputs.commodity_amounts[j] * (0.1f + 0.9f * min_available),
1915 economy_reason::artisan
1921 state.world.nation_set_artisan_actual_production(n, cid, state.world.commodity_get_artisan_output_amount(cid) * throughput_multiplier * output_multiplier * max_production_scale * min_available);
1922 total_profit += std::max(0.0f, (output_total * output_multiplier - input_multiplier * input_total) * throughput_multiplier * max_production_scale * min_available);
1927 state.world.nation_set_artisan_profit(n, total_profit);
1931 auto const csize = state.world.commodity_size();
1932 auto num_artisans = state.world.nation_get_demographics(n,
demographics::to_key(state, state.culture_definitions.artisans));
1933 float total_profit = 0.0f;
1935 for(
uint32_t i = 1; i < csize; ++i) {
1936 dcon::commodity_id cid{ dcon::commodity_id::value_base_t(i) };
1940 auto production = state.world.nation_get_artisan_actual_production(n, cid);
1941 if(production > 0.f) {
1942 auto const& inputs = state.world.commodity_get_artisan_inputs(cid);
1944 float min_input = 1.0f;
1945 for(
uint32_t j = 0; j < commodity_set::set_size; ++j) {
1946 if(inputs.commodity_type[j]) {
1947 min_input = std::min(min_input, state.world.nation_get_demand_satisfaction(n, inputs.commodity_type[j]));
1953 auto amount = min_input * production;
1954 state.world.nation_set_artisan_actual_production(n, cid, amount);
1962 uint32_t total_commodities = state.world.commodity_size();
1963 for(
uint32_t i = 1; i < total_commodities; ++i) {
1964 dcon::commodity_id cid{dcon::commodity_id::value_base_t(i)};
1965 state.world.execute_serial_over_nation([&](
auto ids) { state.world.nation_set_army_demand(ids, cid, 0.0f); });
1968 state.world.for_each_regiment([&](dcon::regiment_id r) {
1969 auto reg = fatten(state.world, r);
1970 auto type = state.world.regiment_get_type(r);
1971 auto owner = reg.get_army_from_army_membership().get_controller_from_army_control();
1973 auto o_sc_mod = std::max(0.01f, state.world.nation_get_modifier_values(owner, sys::national_mod_offsets::supply_consumption) + 1.0f);
1974 auto& supply_cost = state.military_definitions.unit_base_definitions[type].supply_cost;
1975 for(
uint32_t i = 0; i < commodity_set::set_size; ++i) {
1976 if(supply_cost.commodity_type[i]) {
1977 state.world.nation_get_army_demand(owner, supply_cost.commodity_type[i]) +=
1978 supply_cost.commodity_amounts[i] * state.world.nation_get_unit_stats(owner, type).supply_consumption *
1989 uint32_t total_commodities = state.world.commodity_size();
1990 for(
uint32_t i = 1; i < total_commodities; ++i) {
1991 dcon::commodity_id cid{dcon::commodity_id::value_base_t(i)};
1992 state.world.execute_serial_over_nation([&](
auto ids) { state.world.nation_set_navy_demand(ids, cid, 0.0f); });
1995 state.world.for_each_ship([&](dcon::ship_id r) {
1996 auto shp = fatten(state.world, r);
1997 auto type = state.world.ship_get_type(r);
1998 auto owner = shp.get_navy_from_navy_membership().get_controller_from_navy_control();
2000 auto o_sc_mod = std::max(0.01f, state.world.nation_get_modifier_values(owner, sys::national_mod_offsets::supply_consumption) + 1.0f);
2001 auto& supply_cost = state.military_definitions.unit_base_definitions[type].supply_cost;
2002 for(
uint32_t i = 0; i < commodity_set::set_size; ++i) {
2003 if(supply_cost.commodity_type[i]) {
2004 state.world.nation_get_navy_demand(owner, supply_cost.commodity_type[i]) +=
2005 supply_cost.commodity_amounts[i] * state.world.nation_get_unit_stats(owner, type).supply_consumption *
2028 float t =
math::sqrt((
static_cast<float>(state.current_date.value) * 0.01f + 2.f));
2045 float t =
math::sqrt((
static_cast<float>(state.current_date.value) * 0.01f + 2.f));
2050 uint32_t total_commodities = state.world.commodity_size();
2051 for(
uint32_t i = 1; i < total_commodities; ++i) {
2052 dcon::commodity_id cid{dcon::commodity_id::value_base_t(i)};
2053 state.world.execute_serial_over_nation([&](
auto ids) { state.world.nation_set_construction_demand(ids, cid, 0.0f); });
2056 for(
auto lc : state.world.in_province_land_construction) {
2057 auto province = state.world.pop_get_province_from_pop_location(state.world.province_land_construction_get_pop(lc));
2058 auto owner = state.world.province_get_nation_from_province_ownership(
province);
2060 float admin_eff = state.world.nation_get_administrative_efficiency(owner);
2061 float admin_cost_factor = 2.0f - admin_eff;
2063 if(owner && state.world.province_get_nation_from_province_control(
province) == owner) {
2066 state.military_definitions.unit_base_definitions[state.world.province_land_construction_get_type(lc)].build_cost;
2067 auto& current_purchased = state.world.province_land_construction_get_purchased_goods(lc);
2069 float(state.military_definitions.unit_base_definitions[state.world.province_land_construction_get_type(lc)].build_time);
2071 for(
uint32_t i = 0; i < commodity_set::set_size; ++i) {
2072 if(base_cost.commodity_type[i]) {
2073 if(current_purchased.commodity_amounts[i] < base_cost.commodity_amounts[i] * admin_cost_factor)
2074 register_construction_demand(state, owner, base_cost.commodity_type[i], base_cost.commodity_amounts[i] * admin_cost_factor / construction_time);
2083 auto owner = state.world.province_get_nation_from_province_ownership(p);
2084 if(!owner || state.world.province_get_nation_from_province_control(p) != owner)
2087 auto rng = state.world.province_get_province_naval_construction(p);
2088 if(rng.begin() != rng.end()) {
2089 auto c = *(rng.begin());
2091 float admin_eff = state.world.nation_get_administrative_efficiency(owner);
2092 float admin_cost_factor = 2.0f - admin_eff;
2094 auto& base_cost = state.military_definitions.unit_base_definitions[c.get_type()].build_cost;
2095 auto& current_purchased = c.get_purchased_goods();
2096 float construction_time = global_non_factory_construction_time_modifier(state) *
2097 float(state.military_definitions.unit_base_definitions[c.get_type()].build_time);
2099 for(uint32_t i = 0; i < commodity_set::set_size; ++i) {
2100 if(base_cost.commodity_type[i]) {
2101 if(current_purchased.commodity_amounts[i] < base_cost.commodity_amounts[i] * admin_cost_factor)
2102 register_construction_demand(state, owner, base_cost.commodity_type[i], base_cost.commodity_amounts[i] * admin_cost_factor / construction_time);
2111 for(
auto c : state.world.in_province_building_construction) {
2112 auto owner = c.get_nation().id;
2113 if(owner && c.get_province().get_nation_from_province_ownership() == c.get_province().get_nation_from_province_control() && !c.get_is_pop_project()) {
2115 auto& base_cost = state.economy_definitions.building_definitions[int32_t(t)].cost;
2116 auto& current_purchased = c.get_purchased_goods();
2117 float construction_time = global_non_factory_construction_time_modifier(state) *
2118 float(state.economy_definitions.building_definitions[int32_t(t)].time);
2120 float admin_eff = state.world.nation_get_administrative_efficiency(owner);
2121 float admin_cost_factor = 2.0f - admin_eff;
2123 for(
uint32_t i = 0; i < commodity_set::set_size; ++i) {
2124 if(base_cost.commodity_type[i]) {
2125 if(current_purchased.commodity_amounts[i] < base_cost.commodity_amounts[i] * admin_cost_factor)
2126 register_construction_demand(state, owner, base_cost.commodity_type[i], base_cost.commodity_amounts[i] * admin_cost_factor / construction_time);
2134 for(
auto c :
state.world.in_state_building_construction) {
2135 auto owner = c.get_nation().id;
2136 if(owner && !c.get_is_pop_project()) {
2137 auto& base_cost = c.get_type().get_construction_costs();
2138 auto& current_purchased = c.get_purchased_goods();
2140 float(c.get_type().get_construction_time()) * (c.get_is_upgrade() ? 0.5f : 1.0f);
2141 float factory_mod =
state.world.nation_get_modifier_values(owner, sys::national_mod_offsets::factory_cost) + 1.0f;
2143 float admin_eff =
state.world.nation_get_administrative_efficiency(owner);
2144 float admin_cost_factor = 2.0f - admin_eff;
2146 for(
uint32_t i = 0; i < commodity_set::set_size; ++i) {
2147 if(base_cost.commodity_type[i]) {
2148 if(current_purchased.commodity_amounts[i] < base_cost.commodity_amounts[i] * factory_mod * admin_cost_factor)
2149 register_construction_demand(state, owner, base_cost.commodity_type[i], base_cost.commodity_amounts[i] * factory_mod * admin_cost_factor / construction_time);
2159 uint32_t total_commodities = state.world.commodity_size();
2160 for(
uint32_t i = 1; i < total_commodities; ++i) {
2161 dcon::commodity_id cid{dcon::commodity_id::value_base_t(i)};
2162 state.world.execute_serial_over_nation([&](
auto ids) { state.world.nation_set_private_construction_demand(ids, cid, 0.0f); });
2165 for(
auto c : state.world.in_province_building_construction) {
2166 auto owner = c.get_nation().id;
2168 if(owner && owner == c.get_province().get_nation_from_province_control() && c.get_is_pop_project()) {
2170 auto& base_cost = state.economy_definitions.building_definitions[int32_t(t)].cost;
2171 auto& current_purchased = c.get_purchased_goods();
2173 float(state.economy_definitions.building_definitions[int32_t(t)].time);
2174 for(
uint32_t i = 0; i < commodity_set::set_size; ++i) {
2175 if(base_cost.commodity_type[i]) {
2176 if(current_purchased.commodity_amounts[i] < base_cost.commodity_amounts[i])
2177 state.world.nation_get_private_construction_demand(owner, base_cost.commodity_type[i]) +=
2178 base_cost.commodity_amounts[i] / construction_time;
2186 for(
auto c : state.world.in_state_building_construction) {
2187 auto owner = c.get_nation().id;
2188 if(owner && c.get_is_pop_project()) {
2189 auto& base_cost = c.get_type().get_construction_costs();
2190 auto& current_purchased = c.get_purchased_goods();
2192 float(c.get_type().get_construction_time()) * (c.get_is_upgrade() ? 0.1f : 1.0f);
2193 float factory_mod = (state.world.nation_get_modifier_values(owner, sys::national_mod_offsets::factory_cost) + 1.0f) * std::max(0.1f, state.world.nation_get_modifier_values(owner, sys::national_mod_offsets::factory_owner_cost));
2195 for(
uint32_t i = 0; i < commodity_set::set_size; ++i) {
2196 if(base_cost.commodity_type[i]) {
2197 if(current_purchased.commodity_amounts[i] < base_cost.commodity_amounts[i] * factory_mod)
2198 state.world.nation_get_private_construction_demand(owner, base_cost.commodity_type[i]) +=
2199 base_cost.commodity_amounts[i] * factory_mod / construction_time;
2210 float military_total = 0.f;
2211 uint32_t total_commodities = state.world.commodity_size();
2212 float l_spending = float(state.world.nation_get_land_spending(n)) / 100.0f;
2213 float n_spending = float(state.world.nation_get_naval_spending(n)) / 100.0f;
2214 float c_spending = float(state.world.nation_get_construction_spending(n)) / 100.0f;
2215 float o_spending = float(state.world.nation_get_overseas_spending(n)) / 100.f;
2217 for(
uint32_t i = 1; i < total_commodities; ++i) {
2218 dcon::commodity_id cid{dcon::commodity_id::value_base_t(i)};
2219 auto v = state.world.nation_get_army_demand(n, cid) * l_spending * state.world.nation_get_effective_prices(n, cid);
2220 assert(std::isfinite(v) && v >= 0.0f);
2222 military_total += v;
2224 for(
uint32_t i = 1; i < total_commodities; ++i) {
2225 dcon::commodity_id cid{dcon::commodity_id::value_base_t(i)};
2226 auto v = state.world.nation_get_navy_demand(n, cid) * n_spending * state.world.nation_get_effective_prices(n, cid);
2227 assert(std::isfinite(v) && v >= 0.0f);
2229 military_total += v;
2231 assert(std::isfinite(total) && total >= 0.0f);
2232 state.world.nation_set_maximum_military_costs(n, military_total);
2234 for(
uint32_t i = 1; i < total_commodities; ++i) {
2235 dcon::commodity_id cid{dcon::commodity_id::value_base_t(i)};
2236 total += state.world.nation_get_construction_demand(n, cid) * c_spending * state.world.nation_get_effective_prices(n, cid);
2238 for(
uint32_t i = 1; i < total_commodities; ++i) {
2239 dcon::commodity_id cid{dcon::commodity_id::value_base_t(i)};
2240 auto difference = state.world.nation_get_stockpile_targets(n, cid) - state.world.nation_get_stockpiles(n, cid);
2241 if(difference > 0 && state.world.nation_get_drawing_on_stockpiles(n, cid) ==
false) {
2242 total += difference * state.world.nation_get_effective_prices(n, cid);
2245 assert(std::isfinite(total) && total >= 0.0f);
2247 auto overseas_factor = state.defines.province_overseas_penalty * float(state.world.nation_get_owned_province_count(n) - state.world.nation_get_central_province_count(n));
2248 if(overseas_factor > 0) {
2249 for(
uint32_t i = 1; i < total_commodities; ++i) {
2250 dcon::commodity_id cid{dcon::commodity_id::value_base_t(i)};
2251 auto kf = state.world.commodity_get_key_factory(cid);
2252 if(state.world.commodity_get_overseas_penalty(cid) && (state.world.commodity_get_is_available_from_start(cid) || (kf && state.world.nation_get_active_building(n, kf)))) {
2253 total += overseas_factor * state.world.nation_get_effective_prices(n, cid) * o_spending;
2258 assert(std::isfinite(total) && total >= 0.0f);
2261 auto const a_spending = float(state.world.nation_get_administrative_spending(n)) / 100.0f * float(state.world.nation_get_administrative_spending(n)) / 100.0f;
2262 auto const s_spending = state.world.nation_get_administrative_efficiency(n) * float(state.world.nation_get_social_spending(n)) / 100.0f;
2263 auto const e_spending = float(state.world.nation_get_education_spending(n)) * float(state.world.nation_get_education_spending(n)) / 100.0f / 100.0f;
2264 auto const m_spending = float(state.world.nation_get_military_spending(n)) * float(state.world.nation_get_military_spending(n)) / 100.0f / 100.f;
2265 auto const p_level = state.world.nation_get_modifier_values(n, sys::national_mod_offsets::pension_level);
2266 auto const unemp_level = state.world.nation_get_modifier_values(n, sys::national_mod_offsets::unemployment_benefit);
2267 auto const di_spending = float(state.world.nation_get_domestic_investment_spending(n)) * float(state.world.nation_get_domestic_investment_spending(n)) / 100.0f / 100.0f;
2269 total += state.defines.alice_domestic_investment_multiplier * di_spending *
2270 (state.world.nation_get_demographics(n,
demographics::to_key(state, state.culture_definitions.capitalists))
2271 * state.world.nation_get_luxury_needs_costs(n, state.culture_definitions.capitalists)
2272 + state.world.nation_get_demographics(n,
demographics::to_key(state, state.culture_definitions.aristocrat))
2273 * state.world.nation_get_luxury_needs_costs(n, state.culture_definitions.aristocrat))
2274 / state.defines.alice_needs_scaling_factor;
2276 state.world.for_each_pop_type([&](dcon::pop_type_id pt) {
2277 auto adj_pop_of_type = state.world.nation_get_demographics(n,
demographics::to_key(state, pt)) / state.defines.alice_needs_scaling_factor;
2279 if(adj_pop_of_type <= 0)
2284 total += a_spending * adj_pop_of_type * state.world.nation_get_life_needs_costs(n, pt);
2286 total += e_spending * adj_pop_of_type * state.world.nation_get_life_needs_costs(n, pt);
2288 total += m_spending * adj_pop_of_type * state.world.nation_get_life_needs_costs(n, pt);
2290 total += s_spending * adj_pop_of_type * p_level * state.world.nation_get_life_needs_costs(n, pt);
2291 if(state.world.pop_type_get_has_unemployment(pt)) {
2293 total += s_spending * (adj_pop_of_type - emp) * unemp_level * state.world.nation_get_life_needs_costs(n, pt);
2299 total += a_spending * adj_pop_of_type * state.world.nation_get_everyday_needs_costs(n, pt);
2301 total += e_spending * adj_pop_of_type * state.world.nation_get_everyday_needs_costs(n, pt);
2303 total += m_spending * adj_pop_of_type * state.world.nation_get_everyday_needs_costs(n, pt);
2308 total += a_spending * adj_pop_of_type * state.world.nation_get_luxury_needs_costs(n, pt);
2310 total += e_spending * adj_pop_of_type * state.world.nation_get_luxury_needs_costs(n, pt);
2312 total += m_spending * adj_pop_of_type * state.world.nation_get_luxury_needs_costs(n, pt);
2315 assert(std::isfinite(total) && total >= 0.0f);
2318 assert(std::isfinite(total) && total >= 0.0f);
2325 uint32_t total_commodities = state.world.commodity_size();
2327 for(
uint32_t i = 1; i < total_commodities; ++i) {
2328 dcon::commodity_id cid{ dcon::commodity_id::value_base_t(i) };
2329 auto difference = state.world.nation_get_stockpile_targets(n, cid) - state.world.nation_get_stockpiles(n, cid);
2330 if(difference > 0 && state.world.nation_get_drawing_on_stockpiles(n, cid) ==
false) {
2331 total += difference * state.world.commodity_get_current_price(cid) * state.world.nation_get_demand_satisfaction(n, cid);
2341 auto overseas_factor = state.defines.province_overseas_penalty * float(state.world.nation_get_owned_province_count(n) - state.world.nation_get_central_province_count(n));
2342 uint32_t total_commodities = state.world.commodity_size();
2344 if(overseas_factor > 0) {
2345 for(
uint32_t i = 1; i < total_commodities; ++i) {
2346 dcon::commodity_id cid{ dcon::commodity_id::value_base_t(i) };
2348 auto kf = state.world.commodity_get_key_factory(cid);
2349 if(state.world.commodity_get_overseas_penalty(cid) && (state.world.commodity_get_is_available_from_start(cid) || (kf && state.world.nation_get_active_building(n, kf)))) {
2350 total += overseas_factor * state.world.commodity_get_current_price(cid) * state.world.nation_get_demand_satisfaction(n, cid);
2360 uint32_t total_commodities = state.world.commodity_size();
2361 for(
uint32_t i = 1; i < total_commodities; ++i) {
2362 dcon::commodity_id cid{dcon::commodity_id::value_base_t(i)};
2363 total += state.world.nation_get_private_construction_demand(n, cid) * state.world.nation_get_effective_prices(n, cid);
2369 uint32_t total_commodities = state.world.commodity_size();
2370 float l_spending = float(state.world.nation_get_land_spending(n)) / 100.0f;
2371 float n_spending = float(state.world.nation_get_naval_spending(n)) / 100.0f;
2372 float c_spending = float(state.world.nation_get_construction_spending(n)) / 100.0f;
2373 float o_spending = float(state.world.nation_get_overseas_spending(n)) / 100.0f;
2375 for(
uint32_t i = 1; i < total_commodities; ++i) {
2376 dcon::commodity_id cid{dcon::commodity_id::value_base_t(i)};
2377 register_demand(state, n, cid, state.world.nation_get_army_demand(n, cid) * l_spending * spending_scale, economy_reason::nation);
2379 for(
uint32_t i = 1; i < total_commodities; ++i) {
2380 dcon::commodity_id cid{dcon::commodity_id::value_base_t(i)};
2381 register_demand(state, n, cid, state.world.nation_get_navy_demand(n, cid) * n_spending * spending_scale, economy_reason::nation);
2383 for(
uint32_t i = 1; i < total_commodities; ++i) {
2384 dcon::commodity_id cid{dcon::commodity_id::value_base_t(i)};
2385 register_demand(state, n, cid, state.world.nation_get_construction_demand(n, cid) * c_spending * spending_scale, economy_reason::construction);
2387 for(
uint32_t i = 1; i < total_commodities; ++i) {
2388 dcon::commodity_id cid{ dcon::commodity_id::value_base_t(i) };
2389 register_demand(state, n, cid, state.world.nation_get_private_construction_demand(n, cid) * private_investment_scale, economy_reason::construction);
2391 for(
uint32_t i = 1; i < total_commodities; ++i) {
2392 dcon::commodity_id cid{dcon::commodity_id::value_base_t(i)};
2393 auto difference = state.world.nation_get_stockpile_targets(n, cid) - state.world.nation_get_stockpiles(n, cid);
2394 if(difference > 0 && state.world.nation_get_drawing_on_stockpiles(n, cid) ==
false) {
2395 register_demand(state, n, cid, difference * spending_scale, economy_reason::stockpile);
2398 auto overseas_factor = state.defines.province_overseas_penalty * float(state.world.nation_get_owned_province_count(n) - state.world.nation_get_central_province_count(n));
2399 if(overseas_factor > 0.f) {
2400 for(
uint32_t i = 1; i < total_commodities; ++i) {
2401 dcon::commodity_id cid{dcon::commodity_id::value_base_t(i)};
2402 auto kf = state.world.commodity_get_key_factory(cid);
2403 if(state.world.commodity_get_overseas_penalty(cid) && (state.world.commodity_get_is_available_from_start(cid) || (kf && state.world.nation_get_active_building(n, kf)))) {
2404 register_demand(state, n, cid, overseas_factor * spending_scale * o_spending, economy_reason::overseas_penalty);
2411 uint32_t total_commodities = state.world.commodity_size();
2413 static auto ln_demand_vector = state.world.pop_type_make_vectorizable_float_buffer();
2414 state.world.execute_serial_over_pop_type([&](
auto ids) { ln_demand_vector.set(ids, ve::fp_vector{}); });
2415 static auto en_demand_vector = state.world.pop_type_make_vectorizable_float_buffer();
2416 state.world.execute_serial_over_pop_type([&](
auto ids) { en_demand_vector.set(ids, ve::fp_vector{}); });
2417 static auto lx_demand_vector = state.world.pop_type_make_vectorizable_float_buffer();
2418 state.world.execute_serial_over_pop_type([&](
auto ids) { lx_demand_vector.set(ids, ve::fp_vector{}); });
2421 auto nation_rules = state.world.nation_get_combined_issue_rules(n);
2423 for(
auto p : state.world.nation_get_province_ownership(n)) {
2427 subsistence -= subsistence_life;
2429 subsistence -= subsistence_everyday;
2436 for(
auto pl : state.world.province_get_pop_location(p.get_province())) {
2437 auto t = pl.get_pop().get_poptype();
2439 auto total_budget = pl.get_pop().get_savings();
2440 auto total_pop = pl.get_pop().get_size();
2444 float ln_to_satisfy = std::max(1.f - subsistence_life, 0.f);
2445 float en_to_satisfy = std::max(1.f - subsistence_everyday, 0.f);
2446 float xn_to_satisfy = std::max(1.f - subsistence_luxury, 0.f);
2448 float ln_cost = ln_to_satisfy * state.world.nation_get_life_needs_costs(n, t) * total_pop / state.defines.alice_needs_scaling_factor;
2449 float en_cost = en_to_satisfy * state.world.nation_get_everyday_needs_costs(n, t) * total_pop / state.defines.alice_needs_scaling_factor;
2450 float xn_cost = xn_to_satisfy * state.world.nation_get_luxury_needs_costs(n, t) * total_pop / state.defines.alice_needs_scaling_factor;
2452 float life_needs_fraction = (total_budget >= ln_cost ? ln_to_satisfy : total_budget / ln_cost);
2453 total_budget -= ln_cost;
2456 total_budget = std::max(total_budget, 0.f);
2459 if(!nation_allows_investment || (t != state.culture_definitions.aristocrat && t != state.culture_definitions.capitalists)) {
2461 }
else if(t == state.culture_definitions.capitalists) {
2462 state.world.nation_get_private_investment(n) += total_budget * state.defines.alice_invest_capitalist;
2463 total_budget -= total_budget * state.defines.alice_invest_capitalist;
2465 state.world.nation_get_private_investment(n) += total_budget * state.defines.alice_invest_aristocrat;
2466 total_budget -= total_budget * state.defines.alice_invest_aristocrat;
2469 float everyday_needs_fraction = (total_budget >= en_cost ? en_to_satisfy : std::max(0.0f, total_budget / en_cost));
2470 total_budget -= en_cost;
2472 float luxury_needs_fraction = (total_budget >= xn_cost ? xn_to_satisfy : std::max(0.0f, total_budget / xn_cost));
2473 total_budget -= xn_cost;
2478 float total_cost = ln_cost + en_cost + xn_cost;
2480 if((total_budget > 0.f)) {
2481 float life_needs_budget = total_budget * state.defines.alice_needs_lf_spend;
2482 float everyday_needs_budget = total_budget * state.defines.alice_needs_ev_spend;
2483 float luxury_needs_budget = total_budget * state.defines.alice_needs_lx_spend;
2485 float induced_life_needs_demand = life_needs_budget / std::max(0.001f, ln_cost);
2486 float induced_everyday_needs_demand = everyday_needs_budget / std::max(0.001f, en_cost);
2487 float induced_luxury_needs_demand = luxury_needs_budget / std::max(0.001f, xn_cost);
2489 life_needs_fraction += induced_life_needs_demand;
2490 everyday_needs_fraction += induced_everyday_needs_demand;
2491 luxury_needs_fraction += induced_luxury_needs_demand;
2494 assert(std::isfinite(life_needs_fraction));
2495 assert(std::isfinite(everyday_needs_fraction));
2496 assert(std::isfinite(luxury_needs_fraction));
2498 float old_life = pl.get_pop().get_life_needs_satisfaction();
2499 float old_everyday = pl.get_pop().get_everyday_needs_satisfaction();
2500 float old_luxury = pl.get_pop().get_luxury_needs_satisfaction();
2502 float old_life_to_use_in_demand_calculation = old_life;
2503 float old_everyday_to_use_in_demand_calculation = old_everyday;
2504 float old_luxury_to_use_in_demand_calculation = old_luxury;
2506 float final_life_needs_fraction = life_needs_fraction + subsistence_life;
2507 float final_everyday_needs_fraction = everyday_needs_fraction + subsistence_everyday;
2508 float final_luxury_needs_fraction = luxury_needs_fraction + subsistence_luxury;
2512 old_life_to_use_in_demand_calculation = std::clamp(old_life - subsistence_life, 0.f, 1.f);
2513 old_everyday_to_use_in_demand_calculation = std::clamp(old_everyday - subsistence_everyday, 0.f, 1.f);
2514 old_luxury_to_use_in_demand_calculation = std::clamp(old_luxury - subsistence_luxury, 0.f, 1.f);
2516 auto result_life = std::clamp(old_life_to_use_in_demand_calculation * 0.9f + life_needs_fraction * 0.1f, 0.f, 1.f);
2517 auto result_everyday = std::clamp(old_everyday_to_use_in_demand_calculation * 0.9f + everyday_needs_fraction * 0.1f, 0.f, 1.f);
2518 auto result_luxury = std::clamp(old_luxury_to_use_in_demand_calculation * 0.9f + luxury_needs_fraction * 0.1f, 0.f, 1.f);
2520 state.world.pop_set_life_needs_satisfaction(pl.get_pop(), std::clamp(old_life * 0.99f + final_life_needs_fraction * 0.01f, 0.f, 1.f));
2521 state.world.pop_set_everyday_needs_satisfaction(pl.get_pop(), std::clamp(old_everyday * 0.99f + final_everyday_needs_fraction * 0.01f, 0.f, 1.f));
2522 state.world.pop_set_luxury_needs_satisfaction(pl.get_pop(), std::clamp(old_luxury * 0.99f + final_luxury_needs_fraction * 0.01f, 0.f, 1.f));
2524 ln_demand_vector.get(t) += result_life * total_pop / state.defines.alice_needs_scaling_factor;
2525 en_demand_vector.get(t) += result_everyday * total_pop / state.defines.alice_needs_scaling_factor;
2526 lx_demand_vector.get(t) += result_luxury * total_pop / state.defines.alice_needs_scaling_factor;
2528 assert(std::isfinite(ln_demand_vector.get(t)));
2529 assert(std::isfinite(en_demand_vector.get(t)));
2530 assert(std::isfinite(lx_demand_vector.get(t)));
2534 float ln_mul[] = {state.world.nation_get_modifier_values(n, sys::national_mod_offsets::poor_life_needs) + 1.0f,
2535 state.world.nation_get_modifier_values(n, sys::national_mod_offsets::middle_life_needs) + 1.0f,
2536 state.world.nation_get_modifier_values(n, sys::national_mod_offsets::rich_life_needs) + 1.0f};
2537 float en_mul[] = {state.world.nation_get_modifier_values(n, sys::national_mod_offsets::poor_everyday_needs) + 1.0f,
2538 state.world.nation_get_modifier_values(n, sys::national_mod_offsets::middle_everyday_needs) + 1.0f,
2539 state.world.nation_get_modifier_values(n, sys::national_mod_offsets::rich_everyday_needs) + 1.0f};
2541 state.world.nation_get_modifier_values(n, sys::national_mod_offsets::poor_luxury_needs) + 1.0f,
2542 state.world.nation_get_modifier_values(n, sys::national_mod_offsets::middle_luxury_needs) + 1.0f,
2543 state.world.nation_get_modifier_values(n, sys::national_mod_offsets::rich_luxury_needs) + 1.0f,
2546 for(
uint32_t i = 1; i < total_commodities; ++i) {
2547 dcon::commodity_id cid{ dcon::commodity_id::value_base_t(i) };
2548 auto kf = state.world.commodity_get_key_factory(cid);
2549 if(state.world.commodity_get_is_available_from_start(cid) || (kf && state.world.nation_get_active_building(n, kf))) {
2550 for(
const auto t : state.world.in_pop_type) {
2551 auto strata = state.world.pop_type_get_strata(t);
2552 float life_weight = state.world.nation_get_life_needs_weights(n, cid);
2553 float everyday_weight = state.world.nation_get_everyday_needs_weights(n, cid);
2554 float luxury_weight = state.world.nation_get_luxury_needs_weights(n, cid);
2556 float base_life = state.world.pop_type_get_life_needs(t, cid);
2557 float base_everyday = state.world.pop_type_get_everyday_needs(t, cid);
2558 float base_luxury = state.world.pop_type_get_luxury_needs(t, cid);
2560 float dist_life = ln_demand_vector.get(t);
2561 float dist_everyday = en_demand_vector.get(t);
2562 float dist_luxury = lx_demand_vector.get(t);
2564 float demand_life = base_life * dist_life * base_demand * ln_mul[strata] * life_weight * state.defines.alice_lf_needs_scale;
2565 float demand_everyday = base_everyday * dist_everyday * base_demand * invention_factor * en_mul[strata] * everyday_weight * state.defines.alice_ev_needs_scale;
2566 float demand_luxury = base_luxury * dist_luxury * base_demand * invention_factor * lx_mul[strata] * luxury_weight * state.defines.alice_lx_needs_scale;
2587 uint32_t total_commodities = state.world.commodity_size();
2589 float ln_mul[] = { state.world.nation_get_modifier_values(n, sys::national_mod_offsets::poor_life_needs) + 1.0f,
2590 state.world.nation_get_modifier_values(n, sys::national_mod_offsets::middle_life_needs) + 1.0f,
2591 state.world.nation_get_modifier_values(n, sys::national_mod_offsets::rich_life_needs) + 1.0f };
2592 float en_mul[] = { state.world.nation_get_modifier_values(n, sys::national_mod_offsets::poor_everyday_needs) + 1.0f,
2593 state.world.nation_get_modifier_values(n, sys::national_mod_offsets::middle_everyday_needs) + 1.0f,
2594 state.world.nation_get_modifier_values(n, sys::national_mod_offsets::rich_everyday_needs) + 1.0f };
2595 float lx_mul[] = { state.world.nation_get_modifier_values(n, sys::national_mod_offsets::poor_luxury_needs) + 1.0f,
2596 state.world.nation_get_modifier_values(n, sys::national_mod_offsets::middle_luxury_needs) + 1.0f,
2597 state.world.nation_get_modifier_values(n, sys::national_mod_offsets::rich_luxury_needs) + 1.0f };
2599 for(
uint32_t i = 1; i < total_commodities; ++i) {
2600 dcon::commodity_id c{dcon::commodity_id::value_base_t(i)};
2601 auto kf = state.world.commodity_get_key_factory(c);
2602 if(state.world.commodity_get_is_available_from_start(c) || (kf && state.world.nation_get_active_building(n, kf))) {
2603 float effective_price = state.world.nation_get_effective_prices(n, c);
2604 auto ln_weight = state.world.nation_get_life_needs_weights(n, c);
2605 auto en_weight = state.world.nation_get_everyday_needs_weights(n, c);
2606 auto lx_weight = state.world.nation_get_luxury_needs_weights(n, c);
2608 state.world.for_each_pop_type([&](dcon::pop_type_id ids) {
2609 auto ln_base = state.world.pop_type_get_life_needs(ids, c);
2610 auto ln = ln_base * effective_price * base_demand * ln_mul[state.world.pop_type_get_strata(ids)] * ln_weight * state.defines.alice_lf_needs_scale;
2611 state.world.nation_set_life_needs_costs(n, ids, ln + state.world.nation_get_life_needs_costs(n, ids));
2612 auto en_base = state.world.pop_type_get_everyday_needs(ids, c);
2613 auto en = en_base * effective_price * base_demand * invention_factor * en_mul[state.world.pop_type_get_strata(ids)] * en_weight * state.defines.alice_ev_needs_scale;
2614 state.world.nation_set_everyday_needs_costs(n, ids, en + state.world.nation_get_everyday_needs_costs(n, ids));
2615 auto lx_base = state.world.pop_type_get_luxury_needs(ids, c);
2616 auto lx = lx_base * effective_price * base_demand * invention_factor * lx_mul[state.world.pop_type_get_strata(ids)] * lx_weight * state.defines.alice_lx_needs_scale;
2617 state.world.nation_set_luxury_needs_costs(n, ids, lx + state.world.nation_get_luxury_needs_costs(n, ids));
2618 assert(std::isfinite(state.world.nation_get_life_needs_costs(n, ids)) && state.world.nation_get_life_needs_costs(n, ids) >= 0.f);
2619 assert(std::isfinite(state.world.nation_get_everyday_needs_costs(n, ids)) && state.world.nation_get_everyday_needs_costs(n, ids) >= 0.f);
2620 assert(std::isfinite(state.world.nation_get_luxury_needs_costs(n, ids)) && state.world.nation_get_luxury_needs_costs(n, ids) >= 0.f);
2627 uint32_t total_commodities = state.world.commodity_size();
2629 float c_spending = state.world.nation_get_spending_level(n) * float(state.world.nation_get_construction_spending(n)) / 100.0f;
2630 float p_spending = state.world.nation_get_private_investment_effective_fraction(n);
2632 float refund_amount = 0.0f;
2634 for(
uint32_t i = 1; i < total_commodities; ++i) {
2635 dcon::commodity_id c{dcon::commodity_id::value_base_t(i)};
2636 auto d_sat = state.world.nation_get_demand_satisfaction(n, c);
2637 auto& nat_demand = state.world.nation_get_construction_demand(n, c);
2638 refund_amount += nat_demand * c_spending * (1.0f - d_sat) * state.world.commodity_get_current_price(c);
2639 nat_demand *= c_spending * d_sat;
2640 state.world.nation_get_private_construction_demand(n, c) *= p_spending * d_sat;
2643 assert(refund_amount >= 0.0f);
2644 state.world.nation_get_stockpiles(n,
economy::money) += refund_amount;
2646 float admin_eff = state.world.nation_get_administrative_efficiency(n);
2647 float admin_cost_factor = 2.0f - admin_eff;
2649 for(
auto p : state.world.nation_get_province_ownership(n)) {
2650 if(p.get_province().get_nation_from_province_control() != n)
2653 for(
auto pops : p.get_province().get_pop_location()) {
2654 auto rng = pops.get_pop().get_province_land_construction();
2655 if(
rng.begin() !=
rng.end()) {
2656 auto c = *(
rng.begin());
2657 auto& base_cost = state.military_definitions.unit_base_definitions[c.get_type()].build_cost;
2658 auto& current_purchased = c.get_purchased_goods();
2661 for(
uint32_t i = 0; i < commodity_set::set_size; ++i) {
2662 if(base_cost.commodity_type[i]) {
2663 if(current_purchased.commodity_amounts[i] < base_cost.commodity_amounts[i] * admin_cost_factor) {
2664 auto amount = base_cost.commodity_amounts[i] / construction_time;
2665 auto& source = state.world.nation_get_construction_demand(n, base_cost.commodity_type[i]);
2666 auto delta = std::max(0.0f, std::min(source, base_cost.commodity_amounts[i] / construction_time));
2667 current_purchased.commodity_amounts[i] += delta;
2678 auto rng = p.get_province().get_province_naval_construction();
2679 if(
rng.begin() !=
rng.end()) {
2680 auto c = *(
rng.begin());
2681 auto& base_cost = state.military_definitions.unit_base_definitions[c.get_type()].build_cost;
2682 auto& current_purchased = c.get_purchased_goods();
2685 for(
uint32_t i = 0; i < commodity_set::set_size; ++i) {
2686 if(base_cost.commodity_type[i]) {
2687 if(current_purchased.commodity_amounts[i] < base_cost.commodity_amounts[i] * admin_cost_factor) {
2688 auto amount = base_cost.commodity_amounts[i] / construction_time;
2689 auto& source = state.world.nation_get_construction_demand(n, base_cost.commodity_type[i]);
2690 auto delta = std::max(0.0f, std::min(source, base_cost.commodity_amounts[i] / construction_time));
2692 current_purchased.commodity_amounts[i] += delta;
2703 for(
auto c : state.world.nation_get_province_building_construction(n)) {
2704 if(c.get_province().get_nation_from_province_ownership() == c.get_province().get_nation_from_province_control()) {
2709 if(!c.get_is_pop_project()) {
2710 auto& base_cost = state.economy_definitions.building_definitions[int32_t(t)].cost;
2711 auto& current_purchased = c.get_purchased_goods();
2714 for(
uint32_t i = 0; i < commodity_set::set_size; ++i) {
2715 if(base_cost.commodity_type[i]) {
2716 if(current_purchased.commodity_amounts[i] < base_cost.commodity_amounts[i] * admin_cost_factor) {
2717 auto amount = base_cost.commodity_amounts[i] / construction_time;
2718 auto& source = state.world.nation_get_construction_demand(n, base_cost.commodity_type[i]);
2719 auto delta = std::max(0.0f, std::min(source, base_cost.commodity_amounts[i] / construction_time));
2721 current_purchased.commodity_amounts[i] += delta;
2728 }
else if(c.get_is_pop_project()) {
2729 auto& base_cost = state.economy_definitions.building_definitions[int32_t(t)].cost;
2730 auto& current_purchased = c.get_purchased_goods();
2733 for(
uint32_t i = 0; i < commodity_set::set_size; ++i) {
2734 if(base_cost.commodity_type[i]) {
2735 if(current_purchased.commodity_amounts[i] < base_cost.commodity_amounts[i]) {
2736 auto amount = base_cost.commodity_amounts[i] / construction_time;
2737 auto& source = state.world.nation_get_private_construction_demand(n, base_cost.commodity_type[i]);
2738 auto delta = std::max(0.0f, std::min(source, base_cost.commodity_amounts[i] / construction_time));
2740 current_purchased.commodity_amounts[i] += delta;
2751 for(
auto c : state.world.nation_get_state_building_construction(n)) {
2752 if(!c.get_is_pop_project()) {
2753 auto& base_cost = c.get_type().get_construction_costs();
2754 auto& current_purchased = c.get_purchased_goods();
2756 float factory_mod = state.world.nation_get_modifier_values(n, sys::national_mod_offsets::factory_cost) + 1.0f;
2758 for(
uint32_t i = 0; i < commodity_set::set_size; ++i) {
2759 if(base_cost.commodity_type[i]) {
2760 if(current_purchased.commodity_amounts[i] < base_cost.commodity_amounts[i] * factory_mod * admin_cost_factor) {
2761 auto amount = base_cost.commodity_amounts[i] / construction_time;
2762 auto& source = state.world.nation_get_construction_demand(n, base_cost.commodity_type[i]);
2763 auto delta = std::max(0.0f, std::min(source, base_cost.commodity_amounts[i] * factory_mod / construction_time));
2765 current_purchased.commodity_amounts[i] += delta;
2773 auto& base_cost = c.get_type().get_construction_costs();
2774 auto& current_purchased = c.get_purchased_goods();
2776 float factory_mod = (state.world.nation_get_modifier_values(n, sys::national_mod_offsets::factory_cost) + 1.0f) *
2777 std::max(0.1f, state.world.nation_get_modifier_values(n, sys::national_mod_offsets::factory_owner_cost));
2779 for(
uint32_t i = 0; i < commodity_set::set_size; ++i) {
2780 if(base_cost.commodity_type[i]) {
2781 if(current_purchased.commodity_amounts[i] < base_cost.commodity_amounts[i] * factory_mod) {
2782 auto amount = base_cost.commodity_amounts[i] / construction_time;
2783 auto& source = state.world.nation_get_private_construction_demand(n, base_cost.commodity_type[i]);
2784 auto delta = std::max(0.0f, std::min(source, base_cost.commodity_amounts[i] * factory_mod / construction_time));
2786 current_purchased.commodity_amounts[i] += delta;
2798 return state.world.nation_get_modifier_values(n, sys::national_mod_offsets::minimum_wage);
2803 float life = state.world.nation_get_life_needs_costs(n, state.culture_definitions.farmers);
2804 float everyday = state.world.nation_get_everyday_needs_costs(n, state.culture_definitions.farmers);
2806 return min_wage_factor * (life + everyday) * 1.1f;
2810 float life = state.world.nation_get_life_needs_costs(n, state.culture_definitions.laborers);
2811 float everyday = state.world.nation_get_everyday_needs_costs(n, state.culture_definitions.laborers);
2813 return min_wage_factor * (life + everyday) * 1.1f;
2818 float total = state.world.nation_get_demographics(n,
demographics::to_key(state, state.culture_definitions.primary_factory_worker));
2820 float unemployement_crisis_measures = 1.f;
2822 unemployement_crisis_measures = employed / total;
2825 float life = state.world.nation_get_life_needs_costs(n, state.culture_definitions.primary_factory_worker);
2826 float everyday = state.world.nation_get_everyday_needs_costs(n, state.culture_definitions.primary_factory_worker);
2828 return min_wage_factor * (life + everyday) * 1.1f * unemployement_crisis_measures * unemployement_crisis_measures * unemployement_crisis_measures;
2833 auto sl = state.world.nation_get_in_sphere_of(n);
2834 if(global_price_multiplier >= 1.0f) {
2835 state.world.for_each_commodity([&](dcon::commodity_id c) {
2836 auto domestic_supply =
2837 state.world.nation_get_domestic_market_pool(n, c) + (sl ? state.world.nation_get_domestic_market_pool(sl, c) : 0.0f) +
2838 (state.world.nation_get_drawing_on_stockpiles(n, c) ? state.world.nation_get_stockpiles(n, c) : 0.0f);
2839 auto global_supply = state.world.commodity_get_global_market_pool(c);
2840 auto last_demand = state.world.nation_get_real_demand(n, c);
2841 auto base_price = state.world.commodity_get_current_price(c);
2842 if(last_demand <= domestic_supply) {
2843 state.world.nation_set_effective_prices(n, c, base_price);
2844 }
else if(last_demand <= domestic_supply + global_supply) {
2845 auto domestic_satisfiable_fraction = domestic_supply / last_demand;
2846 state.world.nation_set_effective_prices(n, c, base_price * domestic_satisfiable_fraction +
2847 base_price * (1.0f - domestic_satisfiable_fraction) * global_price_multiplier);
2848 }
else if(domestic_supply + global_supply > 0) {
2849 auto domestic_satisfiable_fraction = domestic_supply / (domestic_supply + global_supply);
2850 state.world.nation_set_effective_prices(n, c, base_price * domestic_satisfiable_fraction +
2851 base_price * (1.0f - domestic_satisfiable_fraction) * global_price_multiplier);
2853 state.world.nation_set_effective_prices(n, c, base_price * global_price_multiplier);
2855 assert(std::isfinite(state.world.nation_get_effective_prices(n, c)));
2858 state.world.for_each_commodity([&](dcon::commodity_id c) {
2859 auto domestic_supply =
2860 state.world.nation_get_domestic_market_pool(n, c) + (sl ? state.world.nation_get_domestic_market_pool(sl, c) : 0.0f) +
2861 (state.world.nation_get_drawing_on_stockpiles(n, c) ? state.world.nation_get_stockpiles(n, c) : 0.0f);
2862 auto global_supply = state.world.commodity_get_global_market_pool(c);
2863 auto last_demand = state.world.nation_get_real_demand(n, c);
2864 auto base_price = state.world.commodity_get_current_price(c);
2865 if(last_demand <= global_supply) {
2866 state.world.nation_set_effective_prices(n, c, base_price);
2867 }
else if(last_demand <= domestic_supply + global_supply) {
2868 auto global_satisfiable_fraction = global_supply / last_demand;
2869 state.world.nation_set_effective_prices(n, c, base_price * global_satisfiable_fraction * global_price_multiplier +
2870 base_price * (1.0f - global_satisfiable_fraction));
2871 }
else if(domestic_supply + global_supply > 0) {
2872 auto global_satisfiable_fraction = global_supply / (domestic_supply + global_supply);
2873 state.world.nation_set_effective_prices(n, c, base_price * global_satisfiable_fraction * global_price_multiplier +
2874 base_price * (1.0f - global_satisfiable_fraction));
2876 state.world.nation_set_effective_prices(n, c, base_price);
2878 assert(std::isfinite(state.world.nation_get_effective_prices(n, c)));
2890 float total_min_to_pworkers =
2891 min_wage * state.world.state_instance_get_demographics(s,
2893 float total_min_to_sworkers =
2894 min_wage * state.world.state_instance_get_demographics(s,
2897 float num_pworkers = state.world.state_instance_get_demographics(s,
2899 float num_sworkers = state.world.state_instance_get_demographics(s,
2901 float num_owners = state.world.state_instance_get_demographics(s,
2904 auto per_pworker_profit = 0.0f;
2905 auto per_sworker_profit = 0.0f;
2906 auto per_owner_profit = 0.0f;
2908 if(total_min_to_pworkers + total_min_to_sworkers <= total_profit && num_owners > 0) {
2909 auto surplus = total_profit - (total_min_to_pworkers + total_min_to_sworkers);
2910 per_pworker_profit = num_pworkers > 0 ? (total_min_to_pworkers + surplus * 0.1f) / num_pworkers : 0.0f;
2911 per_sworker_profit = num_sworkers > 0 ? (total_min_to_sworkers + surplus * 0.2f) / num_sworkers : 0.0f;
2912 per_owner_profit = (surplus * 0.7f) / num_owners;
2913 }
else if(total_min_to_pworkers + total_min_to_sworkers <= total_profit && num_sworkers > 0) {
2914 auto surplus = total_profit - (total_min_to_pworkers + total_min_to_sworkers);
2915 per_pworker_profit = num_pworkers > 0 ? (total_min_to_pworkers + surplus * 0.5f) / num_pworkers : 0.0f;
2916 per_sworker_profit = num_sworkers > 0 ? (total_min_to_sworkers + surplus * 0.5f) / num_sworkers : 0.0f;
2917 }
else if(total_min_to_pworkers + total_min_to_sworkers <= total_profit) {
2918 per_pworker_profit = num_pworkers > 0 ? total_profit / num_pworkers : 0.0f;
2919 }
else if(num_pworkers + num_sworkers > 0) {
2920 per_pworker_profit = total_profit / (num_pworkers + num_sworkers);
2921 per_sworker_profit = total_profit / (num_pworkers + num_sworkers);
2926 .per_primary_worker = per_pworker_profit,
2927 .per_secondary_worker = per_sworker_profit,
2928 .per_owner = per_owner_profit
2935 state.world.nation_get_total_rich_income(n)
2936 + state.world.nation_get_total_middle_income(n)
2937 + state.world.nation_get_total_poor_income(n) * 0.00001f;
2943 float income_to_build_units = base_income * 0.1f;
2946 auto infantry = state.military_definitions.infantry;
2947 auto artillery = state.military_definitions.artillery;
2949 auto& infantry_def = state.military_definitions.unit_base_definitions[infantry];
2950 auto& artillery_def = state.military_definitions.unit_base_definitions[artillery];
2952 float daily_cost = 0.f;
2954 for(
uint32_t i = 0; i < commodity_set::set_size; ++i) {
2955 if(infantry_def.build_cost.commodity_type[i]) {
2956 auto price = state.world.commodity_get_current_price(infantry_def.build_cost.commodity_type[i]);
2957 daily_cost += infantry_def.build_cost.commodity_amounts[i] / infantry_def.build_time * price;
2962 for(
uint32_t i = 0; i < commodity_set::set_size; ++i) {
2963 if(infantry_def.build_cost.commodity_type[i]) {
2964 auto price = state.world.commodity_get_current_price(artillery_def.build_cost.commodity_type[i]);
2965 daily_cost += artillery_def.build_cost.commodity_amounts[i] / artillery_def.build_time * price;
2971 auto pairs_to_build = income_to_build_units / (daily_cost + 1.f);
2973 for(
uint32_t i = 0; i < commodity_set::set_size; ++i) {
2974 if(infantry_def.build_cost.commodity_type[i]) {
2975 auto daily_amount = infantry_def.build_cost.commodity_amounts[i] / infantry_def.build_time;
2976 register_demand(state, n, infantry_def.build_cost.commodity_type[i], daily_amount * pairs_to_build, economy_reason::construction);
2981 for(
uint32_t i = 0; i < commodity_set::set_size; ++i) {
2982 if(artillery_def.build_cost.commodity_type[i]) {
2983 auto daily_amount = artillery_def.build_cost.commodity_amounts[i] / artillery_def.build_time;
2984 register_demand(state, n, artillery_def.build_cost.commodity_type[i], daily_amount * pairs_to_build, economy_reason::construction);
2994 float income_to_build_factories = base_income * 0.1f;
2998 std::vector<float> per_commodity;
2999 per_commodity.resize(state.world.commodity_size() + 2);
3001 float sum_of_build_times = 0.f;
3002 float cost_factory_set = 0.f;
3005 state.world.for_each_factory_type([&](dcon::factory_type_id factory_type) {
3006 if(!state.world.factory_type_get_is_available_from_start(factory_type)) {
3010 auto build_time = state.world.factory_type_get_construction_time(factory_type);
3011 auto& build_cost = state.world.factory_type_get_construction_costs(factory_type);
3013 for(
uint32_t i = 0; i < commodity_set::set_size; ++i) {
3014 if(build_cost.commodity_type[i]) {
3015 auto price = state.world.commodity_get_current_price(build_cost.commodity_type[i]);
3016 cost_factory_set += price * build_cost.commodity_amounts[i] / build_time;
3026 auto num_of_factory_sets = income_to_build_factories / (cost_factory_set + 1.f);
3029 state.world.for_each_factory_type([&](dcon::factory_type_id factory_type) {
3030 if(!state.world.factory_type_get_is_available_from_start(factory_type)) {
3034 auto build_time =
state.world.factory_type_get_construction_time(factory_type);
3035 auto& build_cost =
state.world.factory_type_get_construction_costs(factory_type);
3037 for(
uint32_t i = 0; i < commodity_set::set_size; ++i) {
3038 if(build_cost.commodity_type[i]) {
3039 auto amount = build_cost.commodity_amounts[i];
3043 build_cost.commodity_type[i], amount / build_time * num_of_factory_sets,
3044 economy_reason::construction
3058 concurrency::parallel_for(0, 10, [&](int32_t index) {
3076 state.world.for_each_pop_type([&](dcon::pop_type_id t) {
3077 state.world.execute_serial_over_nation([&](
auto nids) {
3078 state.world.nation_set_everyday_needs_costs(nids, t, ve::fp_vector{});
3083 state.world.for_each_pop_type([&](dcon::pop_type_id t) {
3084 state.world.execute_serial_over_nation([&](
auto nids) {
3085 state.world.nation_set_luxury_needs_costs(nids, t, ve::fp_vector{});
3090 state.world.for_each_pop_type([&](dcon::pop_type_id t) {
3091 state.world.execute_serial_over_nation([&](
auto nids) {
3092 state.world.nation_set_life_needs_costs(nids, t, ve::fp_vector{});
3097 state.world.execute_serial_over_nation([&](
auto ids) {
3098 state.world.nation_set_subsidies_spending(ids, 0.0f);
3102 state.world.execute_serial_over_nation([&](
auto ids) {
3103 auto treasury = state.world.nation_get_stockpiles(ids,
economy::money);
3104 state.world.nation_set_last_treasury(ids, treasury);
3112 auto const num_nation = state.world.nation_size();
3113 uint32_t total_commodities = state.world.commodity_size();
3129 state.world.for_each_commodity([&](dcon::commodity_id c) {
3130 state.world.commodity_set_demand_by_category(c, i, 0.f);
3135 for(
auto n : state.nations_by_rank) {
3140 for(
auto n : state.nations_by_rank) {
3146 for(
auto n : state.nations_by_rank) {
3151 state.world.nation_set_gdp(n, 0.f);
3168 auto sl = state.world.nation_get_in_sphere_of(n);
3171 state.defines.base_goods_demand + state.world.nation_get_modifier_values(n, sys::national_mod_offsets::goods_demand);
3173 int32_t num_inventions = 0;
3174 state.world.for_each_invention(
3175 [&](
auto iid) { num_inventions += int32_t(state.world.nation_get_active_inventions(n, iid)); });
3176 float invention_factor = float(num_inventions) * state.defines.invention_impact_on_demand + 1.0f;
3184 float artisan_min_wage = (
3185 1.0f * state.world.nation_get_life_needs_costs(n, state.culture_definitions.artisans)
3186 + 0.5f * state.world.nation_get_everyday_needs_costs(n, state.culture_definitions.artisans));
3191 state.world.for_each_commodity([&](dcon::commodity_id c) {
3192 state.world.nation_set_real_demand(n, c, 0.0f);
3193 state.world.nation_set_intermediate_demand(n, c, 0.f);
3199 auto cap_prov = state.world.nation_get_capital(n);
3200 auto cap_continent = state.world.province_get_continent(cap_prov);
3201 auto cap_region = state.world.province_get_connected_region_id(cap_prov);
3205 for(
auto p : state.world.nation_get_province_ownership(n)) {
3206 for(
auto f : state.world.province_get_factory_location(p.get_province())) {
3214 p.get_province().get_state_membership(),
3215 mobilization_impact,
3217 p.get_province().get_nation_from_province_control() != n
3222 bool is_mine = state.world.commodity_get_is_mine(state.world.province_get_rgo(p.get_province()));
3224 is_mine ? laborer_min_wage : farmer_min_wage, p.get_province().get_nation_from_province_control() != n);
3236 float budget = 0.0f;
3237 float spending_scale = 0.0f;
3238 if(state.world.nation_get_is_player_controlled(n)) {
3244 spending_scale = 1.0f;
3246 budget = std::max(0.0f, state.world.nation_get_stockpiles(n,
economy::money));
3247 spending_scale = (total < 0.001f || total <= budget) ? 1.0f : budget / total;
3250 budget = std::max(0.0f, state.world.nation_get_stockpiles(n,
economy::money));
3251 spending_scale = (total < 0.001f || total <= budget) ? 1.0f : budget / total;
3254 assert(spending_scale >= 0);
3255 assert(std::isfinite(spending_scale));
3256 assert(std::isfinite(budget));
3258 state.world.nation_get_stockpiles(n,
economy::money) -= std::min(budget, total * spending_scale);
3259 state.world.nation_set_spending_level(n, spending_scale);
3262 float pi_budget = state.world.nation_get_private_investment(n);
3263 auto pi_scale = pi_total <= pi_budget ? 1.0f : pi_budget / pi_total;
3264 state.world.nation_set_private_investment_effective_fraction(n, pi_scale);
3265 state.world.nation_set_private_investment(n, std::max(0.0f, pi_budget - pi_total));
3274 for(
uint32_t i = 1; i < total_commodities; ++i) {
3275 dcon::commodity_id c{ dcon::commodity_id::value_base_t(i) };
3277 auto dom_pool = state.world.nation_get_domestic_market_pool(n, c);
3278 auto sl_pool = (sl ? state.world.nation_get_domestic_market_pool(sl, c) : 0.0f);
3279 auto sp_pool = (state.world.nation_get_drawing_on_stockpiles(n, c) ? state.world.nation_get_stockpiles(n, c) : 0.0f);
3280 auto wm_pool = state.world.commodity_get_global_market_pool(c);
3282 auto total_supply = dom_pool + sl_pool + sp_pool + wm_pool;
3284 auto rd = state.world.nation_get_real_demand(n, c);
3285 auto old_sat = state.world.nation_get_demand_satisfaction(n, c);
3286 auto new_sat = rd > 0.0001f ? total_supply / rd : total_supply;
3287 auto adj_sat = old_sat * state.defines.alice_sat_delay_factor + new_sat * (1.0f - state.defines.alice_sat_delay_factor);
3288 state.world.nation_set_demand_satisfaction(n, c, std::min(1.0f, adj_sat));
3289 state.world.nation_set_direct_demand_satisfaction(n, c, std::min(1.0f, new_sat));
3291 if(global_price_multiplier >= 1.0f) {
3292 state.world.nation_set_domestic_market_pool(n, c, std::max(0.0f, dom_pool - rd));
3293 rd = std::max(rd - dom_pool, 0.0f);
3295 state.world.nation_set_domestic_market_pool(sl, c, std::max(0.0f, sl_pool - rd));
3296 rd = std::max(rd - sl_pool, 0.0f);
3298 if(state.world.nation_get_drawing_on_stockpiles(n, c)) {
3299 state.world.nation_set_stockpiles(n, c, std::max(0.0f, sp_pool - rd));
3300 rd = std::max(rd - sp_pool, 0.0f);
3302 state.world.commodity_set_global_market_pool(c, std::max(0.0f, wm_pool - rd));
3304 state.world.nation_set_imports(n, c, std::min(wm_pool, rd));
3306 state.world.nation_set_imports(n, c, std::min(wm_pool, rd));
3308 state.world.commodity_set_global_market_pool(c, std::max(0.0f, wm_pool - rd));
3309 rd = std::max(rd - wm_pool, 0.0f);
3311 state.world.nation_set_domestic_market_pool(n, c, std::max(0.0f, dom_pool - rd));
3312 rd = std::max(rd - dom_pool, 0.0f);
3314 state.world.nation_set_domestic_market_pool(sl, c, std::max(0.0f, sl_pool - rd));
3315 rd = std::max(rd - sl_pool, 0.0f);
3317 if(state.world.nation_get_drawing_on_stockpiles(n, c)) {
3318 state.world.nation_set_stockpiles(n, c, std::max(0.0f, sp_pool - rd));
3327 state.world.for_each_commodity([&](dcon::commodity_id c) {
3330 float world_pool = state.world.commodity_get_global_market_pool(c) * decay;
3332 state.world.execute_serial_over_nation([&](
auto nids) {
3333 sum = sum + state.world.nation_get_domestic_market_pool(nids, c);
3334 state.world.nation_set_domestic_market_pool(nids, c, 0.0f);
3336 state.world.commodity_set_global_market_pool(c, world_pool + sum.reduce());
3343 state.world.execute_parallel_over_pop([&](
auto ids) {
3345 auto owner_spending = state.world.nation_get_spending_level(owners);
3347 auto pop_of_type = state.world.pop_get_size(ids);
3348 auto adj_pop_of_type = pop_of_type / state.defines.alice_needs_scaling_factor;
3350 auto const a_spending = owner_spending *
ve::to_float(state.world.nation_get_administrative_spending(owners)) *
ve::to_float(state.world.nation_get_administrative_spending(owners)) / 100.0f / 100.f;
3351 auto const s_spending = owner_spending * state.world.nation_get_administrative_efficiency(owners) *
3352 ve::to_float(state.world.nation_get_social_spending(owners)) / 100.0f;
3353 auto const e_spending = owner_spending *
ve::to_float(state.world.nation_get_education_spending(owners)) *
ve::to_float(state.world.nation_get_education_spending(owners)) / 100.0f / 100.f;
3354 auto const m_spending = owner_spending *
ve::to_float(state.world.nation_get_military_spending(owners)) *
ve::to_float(state.world.nation_get_military_spending(owners)) / 100.0f / 100.0f;
3355 auto const p_level = state.world.nation_get_modifier_values(owners, sys::national_mod_offsets::pension_level);
3356 auto const unemp_level = state.world.nation_get_modifier_values(owners, sys::national_mod_offsets::unemployment_benefit);
3357 auto const di_level = owner_spending *
ve::to_float(state.world.nation_get_domestic_investment_spending(owners)) *
ve::to_float(state.world.nation_get_domestic_investment_spending(owners)) / 100.0f / 100.f;
3359 auto types = state.world.pop_get_poptype(ids);
3361 auto ln_types = state.world.pop_type_get_life_needs_income_type(types);
3362 auto en_types = state.world.pop_type_get_everyday_needs_income_type(types);
3363 auto lx_types = state.world.pop_type_get_luxury_needs_income_type(types);
3365 auto ln_costs = ve::apply(
3366 [&](dcon::pop_type_id pt, dcon::nation_id n) {
return pt ? state.world.nation_get_life_needs_costs(n, pt) : 0.0f; },
3368 auto en_costs = ve::apply(
3369 [&](dcon::pop_type_id pt, dcon::nation_id n) {
return pt ? state.world.nation_get_everyday_needs_costs(n, pt) : 0.0f; },
3371 auto lx_costs = ve::apply(
3372 [&](dcon::pop_type_id pt, dcon::nation_id n) {
return pt ? state.world.nation_get_luxury_needs_costs(n, pt) : 0.0f; },
3384 auto acc_u =
ve::select(none_of_above, s_spending * adj_pop_of_type * p_level * ln_costs, 0.0f);
3390 acc_u = acc_u +
ve::select(types == state.culture_definitions.capitalists, di_level * adj_pop_of_type * state.defines.alice_domestic_investment_multiplier * lx_costs, 0.0f);
3391 acc_u = acc_u +
ve::select(types == state.culture_definitions.aristocrat, di_level * adj_pop_of_type * state.defines.alice_domestic_investment_multiplier * lx_costs, 0.0f);
3397 auto employment = state.world.pop_get_employment(ids);
3399 acc_u = acc_u +
ve::select(none_of_above && state.world.pop_type_get_has_unemployment(types),
3400 s_spending * (pop_of_type - employment) / state.defines.alice_needs_scaling_factor * unemp_level * ln_costs, 0.0f);
3402 state.world.pop_set_savings(ids, state.inflation * ((acc_e + acc_m) + (acc_u + acc_a)));
3403 ve::apply([](
float v) {
assert(std::isfinite(v) && v >= 0); }, acc_e);
3404 ve::apply([](
float v) {
assert(std::isfinite(v) && v >= 0); }, acc_m);
3405 ve::apply([](
float v) {
assert(std::isfinite(v) && v >= 0); }, acc_u);
3406 ve::apply([](
float v) {
assert(std::isfinite(v) && v >= 0); }, acc_a);
3410 concurrency::parallel_for(
uint32_t(0), state.world.nation_size(), [&](
uint32_t i) {
3411 auto n = dcon::nation_id{ dcon::nation_id::value_base_t(i) };
3413 if(state.world.nation_get_owned_province_count(n) == 0)
3417 ve::vectorizable_buffer<float, dcon::pop_type_id> ln_max = state.world.pop_type_make_vectorizable_float_buffer();
3418 ve::vectorizable_buffer<float, dcon::pop_type_id> en_max = state.world.pop_type_make_vectorizable_float_buffer();
3419 ve::vectorizable_buffer<float, dcon::pop_type_id> lx_max = state.world.pop_type_make_vectorizable_float_buffer();
3420 uint32_t total_commodities = state.world.commodity_size();
3421 state.world.for_each_pop_type([&](dcon::pop_type_id pt) {
3422 float ln_total = 0.0f;
3423 float en_total = 0.0f;
3424 float lx_total = 0.0f;
3425 for(uint32_t i = 1; i < total_commodities; ++i) {
3426 dcon::commodity_id c{ dcon::commodity_id::value_base_t(i) };
3427 auto kf = state.world.commodity_get_key_factory(c);
3428 if(state.world.commodity_get_is_available_from_start(c) || (kf && state.world.nation_get_active_building(n, kf))) {
3429 auto sat = state.world.nation_get_demand_satisfaction(n, c);
3431 auto ln_val = state.world.pop_type_get_life_needs(pt, c) * state.world.nation_get_life_needs_weights(n, c);
3433 ln_max.get(pt) += ln_val * sat;
3435 auto en_val = state.world.pop_type_get_everyday_needs(pt, c) * state.world.nation_get_everyday_needs_weights(n, c);
3437 en_max.get(pt) += en_val * sat;
3439 auto lx_val = state.world.pop_type_get_luxury_needs(pt, c) * state.world.nation_get_luxury_needs_weights(n, c);
3441 lx_max.get(pt) += lx_val * sat;
3446 ln_max.get(pt) /= ln_total;
3448 ln_max.get(pt) = 1.f;
3451 en_max.get(pt) /= en_total;
3453 en_max.get(pt) = 1.f;
3456 lx_max.get(pt) /= lx_total;
3458 lx_max.get(pt) = 1.f;
3464 auto nations_commodity_spending = state.world.nation_get_spending_level(n);
3465 float refund = 0.0f;
3467 float max_sp = 0.0f;
3469 float spending_level = float(state.world.nation_get_naval_spending(n)) / 100.0f;
3470 for(
uint32_t k = 1; k < total_commodities; ++k) {
3471 dcon::commodity_id c{ dcon::commodity_id::value_base_t(k) };
3473 auto sat =
state.world.nation_get_demand_satisfaction(n, c);
3474 auto val =
state.world.nation_get_navy_demand(n, c);
3475 auto delta =
val * (1.0f - sat) * nations_commodity_spending * spending_level *
state.world.commodity_get_current_price(c);
3479 max_sp +=
val * sat;
3483 state.world.nation_set_effective_naval_spending(n, nations_commodity_spending * max_sp * spending_level);
3486 float max_sp = 0.0f;
3488 float spending_level = float(
state.world.nation_get_land_spending(n)) / 100.0f;
3489 for(
uint32_t k = 1; k < total_commodities; ++k) {
3490 dcon::commodity_id c{ dcon::commodity_id::value_base_t(k) };
3492 auto sat =
state.world.nation_get_demand_satisfaction(n, c);
3493 auto val =
state.world.nation_get_army_demand(n, c);
3494 auto delta =
val * (1.0f - sat) * nations_commodity_spending * spending_level *
state.world.commodity_get_current_price(c);
3498 max_sp +=
val * sat;
3502 state.world.nation_set_effective_land_spending(n, nations_commodity_spending * max_sp * spending_level);
3505 float max_sp = 0.0f;
3507 float spending_level = float(
state.world.nation_get_construction_spending(n)) / 100.0f;
3508 for(
uint32_t k = 1; k < total_commodities; ++k) {
3509 dcon::commodity_id c{ dcon::commodity_id::value_base_t(k) };
3511 auto sat =
state.world.nation_get_demand_satisfaction(n, c);
3512 auto val =
state.world.nation_get_construction_demand(n, c);
3514 max_sp +=
val * sat;
3518 state.world.nation_set_effective_construction_spending(n, nations_commodity_spending * max_sp * spending_level);
3524 for(
uint32_t k = 1; k < total_commodities; ++k) {
3525 dcon::commodity_id c{ dcon::commodity_id::value_base_t(k) };
3526 auto difference =
state.world.nation_get_stockpile_targets(n, c) -
state.world.nation_get_stockpiles(n, c);
3527 if(difference > 0.f &&
state.world.nation_get_drawing_on_stockpiles(n, c) ==
false) {
3528 auto sat =
state.world.nation_get_direct_demand_satisfaction(n, c);
3529 state.world.nation_get_stockpiles(n, c) += difference * nations_commodity_spending * sat;
3533 * nations_commodity_spending
3534 *
state.world.commodity_get_current_price(c);
3545 auto overseas_factor =
state.defines.province_overseas_penalty * float(
state.world.nation_get_owned_province_count(n) -
state.world.nation_get_central_province_count(n));
3546 auto overseas_budget = float(
state.world.nation_get_overseas_spending(n)) / 100.f;
3547 auto overseas_budget_satisfaction = 1.f;
3549 if(overseas_factor > 0) {
3550 for(
uint32_t k = 1; k < total_commodities; ++k) {
3551 dcon::commodity_id c{ dcon::commodity_id::value_base_t(k) };
3552 auto kf =
state.world.commodity_get_key_factory(c);
3553 if(
state.world.commodity_get_overseas_penalty(c) &&
3554 (
state.world.commodity_get_is_available_from_start(c) || (kf &&
state.world.nation_get_active_building(n, kf)))) {
3555 auto sat =
state.world.nation_get_demand_satisfaction(n, c);
3556 overseas_budget_satisfaction = std::min(sat, overseas_budget_satisfaction);
3557 auto price =
state.world.commodity_get_current_price(c);
3558 auto delta = overseas_factor * (1.0f - sat) * nations_commodity_spending * price;
3564 state.world.nation_set_overseas_penalty(n, overseas_budget * overseas_budget_satisfaction);
3566 state.world.nation_set_overseas_penalty(n, 1.0f);
3570 assert(std::isfinite(refund) && refund >= 0.0f);
3571 state.world.nation_get_stockpiles(n, money) += refund;
3581 for(
auto p :
state.world.nation_get_province_ownership(n)) {
3586 for(
auto f :
state.world.province_get_factory_location(p.get_province())) {
3600 float subsistence_life = std::clamp(subsistence, 0.f, subsistence_score_life);
3601 subsistence -= subsistence_life;
3602 float subsistence_everyday = std::clamp(subsistence, 0.f, subsistence_score_everyday);
3603 subsistence -= subsistence_everyday;
3604 float subsistence_luxury = std::clamp(subsistence, 0.f, subsistence_score_luxury);
3610 for(
auto pl : p.get_province().get_pop_location()) {
3611 auto t = pl.get_pop().get_poptype();
3613 auto ln = pl.get_pop().get_life_needs_satisfaction();
3614 auto en = pl.get_pop().get_everyday_needs_satisfaction();
3615 auto lx = pl.get_pop().get_luxury_needs_satisfaction();
3618 ln -= subsistence_life;
3619 en -= subsistence_everyday;
3620 lx -= subsistence_luxury;
3622 ln = std::min(ln, ln_max.get(t));
3623 en = std::min(en, en_max.get(t));
3624 lx = std::min(lx, lx_max.get(t));
3626 ln += subsistence_life;
3627 en += subsistence_everyday;
3628 lx += subsistence_luxury;
3630 pl.get_pop().set_life_needs_satisfaction(ln);
3631 pl.get_pop().set_everyday_needs_satisfaction(en);
3632 pl.get_pop().set_luxury_needs_satisfaction(lx);
3642 auto const artisan_type =
state.culture_definitions.artisans;
3643 float artisan_profit =
state.world.nation_get_artisan_profit(n);
3645 if(num_artisans > 0) {
3646 auto per_profit = artisan_profit / num_artisans;
3648 for(
auto p :
state.world.nation_get_province_ownership(n)) {
3649 for(
auto pl : p.get_province().get_pop_location()) {
3650 if(artisan_type == pl.get_pop().get_poptype()) {
3651 pl.get_pop().set_savings(pl.get_pop().get_savings() +
state.inflation * pl.get_pop().get_size() * per_profit);
3652 assert(std::isfinite(pl.get_pop().get_savings()) && pl.get_pop().get_savings() >= 0);
3663 for(
auto si :
state.world.nation_get_state_ownership(n)) {
3664 float total_profit = 0.f;
3665 float rgo_owner_profit = 0.f;
3667 float num_capitalist =
state.world.state_instance_get_demographics(
3672 float num_aristocrat =
state.world.state_instance_get_demographics(
3677 float num_rgo_owners = num_capitalist + num_aristocrat;
3679 auto capitalists_ratio = num_capitalist / (num_rgo_owners + 1.f);
3680 auto aristocrats_ratio = num_aristocrat / (num_rgo_owners + 1.f);
3683 for(auto f : state.world.province_get_factory_location(p)) {
3684 total_profit += std::max(0.f, f.get_factory().get_full_profit());
3689 bool is_mine = state.world.commodity_get_is_mine(state.world.province_get_rgo(p));
3692 auto const min_wage = (is_mine ? laborer_min_wage : farmer_min_wage) / state.defines.alice_needs_scaling_factor;
3694 float total_min_to_workers = 0.0f;
3695 float num_workers = 0.0f;
3696 for(auto wt : state.culture_definitions.rgo_workers) {
3697 total_min_to_workers += min_wage * state.world.province_get_demographics(p, demographics::to_employment_key(state, wt));
3698 num_workers += state.world.province_get_demographics(p, demographics::to_key(state, wt));
3700 float total_rgo_profit =
state.world.province_get_rgo_full_profit(p);
3701 float total_worker_wage = 0.0f;
3703 if(num_rgo_owners > 0) {
3705 rgo_owner_profit += rgo_owners_cut * total_rgo_profit;
3706 total_rgo_profit = (1.f - rgo_owners_cut) * total_rgo_profit;
3709 if(total_min_to_workers <= total_rgo_profit && num_rgo_owners > 0) {
3710 total_worker_wage = total_min_to_workers + (total_rgo_profit - total_min_to_workers) * 0.2f;
3711 rgo_owner_profit += (total_rgo_profit - total_min_to_workers) * 0.8f;
3713 total_worker_wage = total_rgo_profit;
3716 auto per_worker_profit = num_workers > 0 ? total_worker_wage / num_workers : 0.0f;
3718 for(
auto pl :
state.world.province_get_pop_location(p)) {
3719 if(pl.get_pop().get_poptype().get_is_paid_rgo_worker()) {
3720 pl.get_pop().set_savings(pl.get_pop().get_savings() + state.inflation * pl.get_pop().get_size() * per_worker_profit);
3721 assert(std::isfinite(pl.get_pop().get_savings()) && pl.get_pop().get_savings() >= 0);
3727 auto const per_rgo_owner_profit = num_rgo_owners > 0 ? rgo_owner_profit / num_rgo_owners : 0.0f;
3729 auto const min_wage = factory_min_wage /
state.defines.alice_needs_scaling_factor;
3734 for(auto pl : state.world.province_get_pop_location(p)) {
3735 if(state.culture_definitions.primary_factory_worker == pl.get_pop().get_poptype()) {
3736 pl.get_pop().set_savings(pl.get_pop().get_savings() + state.inflation * pl.get_pop().get_size() * profit.per_primary_worker);
3737 assert(std::isfinite(pl.get_pop().get_savings()) && pl.get_pop().get_savings() >= 0);
3738 } else if(state.culture_definitions.secondary_factory_worker == pl.get_pop().get_poptype()) {
3739 pl.get_pop().set_savings(pl.get_pop().get_savings() + state.inflation * pl.get_pop().get_size() * profit.per_secondary_worker);
3740 assert(std::isfinite(pl.get_pop().get_savings()) && pl.get_pop().get_savings() >= 0);
3741 } else if(state.culture_definitions.capitalists == pl.get_pop().get_poptype()) {
3742 pl.get_pop().set_savings(pl.get_pop().get_savings() + state.inflation * pl.get_pop().get_size() * (profit.per_owner + per_rgo_owner_profit));
3743 assert(std::isfinite(pl.get_pop().get_savings()) && pl.get_pop().get_savings() >= 0);
3744 } else if(state.culture_definitions.aristocrat == pl.get_pop().get_poptype()) {
3745 pl.get_pop().set_savings(pl.get_pop().get_savings() + state.inflation * pl.get_pop().get_size() * per_rgo_owner_profit);
3746 assert(std::isfinite(pl.get_pop().get_savings()) && pl.get_pop().get_savings() >= 0);
3755 if(!initiate_buildings) {
3760 auto edu_money = 0.f;
3761 auto adm_money = 0.f;
3762 auto const edu_adm_spending = 0.05f;
3763 auto const edu_adm_effect = 1.f - edu_adm_spending;
3764 auto const education_ratio = 0.8f;
3765 for(
auto p :
state.world.nation_get_province_ownership(n)) {
3767 if(
state.world.province_get_nation_from_province_ownership(
province) ==
state.world.province_get_nation_from_province_control(
province)) {
3769 float local_teachers = 0.f;
3770 float local_managers = 0.f;
3771 for(
auto pl :
province.get_pop_location()) {
3772 auto pop = pl.get_pop();
3773 auto pt =
pop.get_poptype();
3776 local_managers +=
pop.get_size();
3778 local_teachers +=
pop.get_size();
3781 if(local_teachers + local_managers > 0.f) {
3782 for(
auto pl :
province.get_pop_location()) {
3783 auto const pop_money = pl.get_pop().get_savings();
3784 current += pop_money * edu_adm_spending;
3785 pl.get_pop().set_savings(pop_money * edu_adm_effect);
3788 float local_education_ratio = education_ratio;
3789 if(local_managers == 0.f) {
3790 local_education_ratio = 1.f;
3792 for(
auto pl :
province.get_pop_location()) {
3793 auto pop = pl.get_pop();
3794 auto pt =
pop.get_poptype();
3797 float ratio =
pop.get_size() / local_managers;
3798 pop.set_savings(
pop.get_savings() + current * (1.f - local_education_ratio) * ratio);
3799 adm_money +=
current * (1.f - local_education_ratio) * ratio;
3801 float ratio =
pop.get_size() / local_teachers;
3802 pop.set_savings(
pop.get_savings() +
current * local_education_ratio * ratio);
3803 edu_money +=
current * local_education_ratio * ratio;
3808 state.world.nation_set_private_investment_education(n, edu_money);
3809 state.world.nation_set_private_investment_administration(n, adm_money);
3817 float total_poor_tax_base = 0.0f;
3818 float total_mid_tax_base = 0.0f;
3819 float total_rich_tax_base = 0.0f;
3821 auto const poor_effect = (1.0f - tax_eff * float(
state.world.nation_get_poor_tax(n)) / 100.0f);
3822 auto const middle_effect = (1.0f - tax_eff * float(
state.world.nation_get_middle_tax(n)) / 100.0f);
3823 auto const rich_effect = (1.0f - tax_eff * float(
state.world.nation_get_rich_tax(n)) / 100.0f);
3825 assert(poor_effect >= 0 && middle_effect >= 0 && rich_effect >= 0);
3827 for(
auto p :
state.world.nation_get_province_ownership(n)) {
3829 if(
state.world.province_get_nation_from_province_ownership(
province) ==
state.world.province_get_nation_from_province_control(
province)) {
3830 for(
auto pl :
province.get_pop_location()) {
3831 auto& pop_money = pl.get_pop().get_savings();
3834 total_poor_tax_base += pop_money;
3835 pop_money *= poor_effect;
3837 total_mid_tax_base += pop_money;
3838 pop_money *= middle_effect;
3840 total_rich_tax_base += pop_money;
3841 pop_money *= rich_effect;
3847 state.world.nation_set_total_rich_income(n, total_rich_tax_base);
3848 state.world.nation_set_total_middle_income(n, total_mid_tax_base);
3849 state.world.nation_set_total_poor_income(n, total_poor_tax_base);
3850 auto collected_tax = total_poor_tax_base * tax_eff * float(
state.world.nation_get_poor_tax(n)) / 100.0f +
3851 total_mid_tax_base * tax_eff * float(
state.world.nation_get_middle_tax(n)) / 100.0f +
3852 total_rich_tax_base * tax_eff * float(
state.world.nation_get_rich_tax(n)) / 100.0f;
3853 assert(std::isfinite(collected_tax));
3854 assert(collected_tax >= 0);
3855 state.world.nation_get_stockpiles(n, money) += collected_tax;
3863 float t_total = 0.0f;
3865 for(
uint32_t k = 1; k < total_commodities; ++k) {
3866 dcon::commodity_id cid{ dcon::commodity_id::value_base_t(k) };
3867 t_total +=
state.world.commodity_get_current_price(cid) * tariff_rate *
state.world.nation_get_imports(n, cid);
3869 assert(std::isfinite(t_total));
3871 state.world.nation_get_stockpiles(n, money) += t_total;
3883 state.world.for_each_commodity([&](dcon::commodity_id c) {
3884 if(!
state.world.commodity_get_money_rgo(c))
3887 float luxury_costs_laborer = 0.f;
3888 const float base_demand =
state.defines.base_goods_demand;
3890 for(
uint32_t i = 1; i < total_commodities; ++i) {
3891 dcon::commodity_id _cid{ dcon::commodity_id::value_base_t(i) };
3893 if(
state.world.commodity_get_is_available_from_start(_cid)) {
3894 float price =
state.world.commodity_get_current_price(_cid);
3895 auto t =
state.culture_definitions.laborers;
3897 float base_life =
state.world.pop_type_get_life_needs(t, _cid);
3898 float base_everyday = 0.5f *
state.world.pop_type_get_everyday_needs(t, _cid);
3899 float base_luxury = 0.1f *
state.world.pop_type_get_luxury_needs(t, _cid);
3901 luxury_costs_laborer += base_life * base_demand *
state.defines.alice_lf_needs_scale *
price;
3902 luxury_costs_laborer += base_everyday * base_demand *
state.defines.alice_ev_needs_scale *
price;
3903 luxury_costs_laborer += base_luxury * base_demand *
state.defines.alice_lx_needs_scale *
price;
3907 state.world.commodity_set_current_price(c, std::clamp(luxury_costs_laborer * 0.3f, 0.001f, 100000.0f));
3910 concurrency::parallel_for(
uint32_t(0), total_commodities, [&](
uint32_t k) {
3911 dcon::commodity_id cid{dcon::commodity_id::value_base_t(k)};
3914 if(
state.world.commodity_get_money_rgo(cid)) {
3918 float total_r_demand = 0.0f;
3919 float total_consumption = 0.0f;
3920 float total_production = 0.0f;
3922 state.world.for_each_nation([&](dcon::nation_id n) {
3923 total_r_demand +=
state.world.nation_get_real_demand(n, cid);
3924 total_consumption +=
state.world.nation_get_real_demand(n, cid) *
state.world.nation_get_demand_satisfaction(n, cid);
3925 total_production +=
state.world.nation_get_domestic_market_pool(n, cid);
3928 state.world.commodity_set_total_consumption(cid, total_consumption);
3929 state.world.commodity_set_total_real_demand(cid, total_r_demand);
3931 auto prior_production =
state.world.commodity_get_total_production(cid);
3932 state.world.commodity_set_total_production(cid, total_production);
3934 float supply = prior_production +
state.world.commodity_get_global_market_pool(cid) / 12.f;
3935 float demand = total_r_demand;
3937 auto base_price =
state.world.commodity_get_cost(cid);
3938 auto current_price =
state.world.commodity_get_current_price(cid);
3940 float market_balance = demand -
supply;
3941 float max_slope =
math::sqrt(abs(market_balance)) + 20.f;
3943 float oversupply_factor = std::clamp(((supply + 0.001f) / (demand + 0.001f) - 1.f), 0.f, max_slope);
3944 float overdemand_factor = std::clamp(((demand + 0.001f) / (supply + 0.001f) - 1.f), 0.f, max_slope);
3946 float speed_modifer = (overdemand_factor - oversupply_factor);
3948 float price_speed = 0.05f * speed_modifer;
3950 if(current_price < 1.f) {
3951 price_speed *= current_price;
3956 current_price += price_speed;
3958 state.world.commodity_set_current_price(cid, std::clamp(current_price, 0.001f, 100000.0f));
3961 if(
state.cheat_data.ecodump) {
3962 float accumulator[8] = { 0, 0, 0, 0, 0, 0, 0, 0 };
3963 state.world.for_each_commodity([&](dcon::commodity_id c) {
3964 state.cheat_data.prices_dump_buffer += std::to_string(
state.world.commodity_get_current_price(c)) +
",";
3965 state.cheat_data.supply_dump_buffer += std::to_string(
state.world.commodity_get_total_production(c)) +
",";
3966 state.cheat_data.demand_dump_buffer += std::to_string(
state.world.commodity_get_total_real_demand(c)) +
",";
3967 for(
int i = 0; i < 8; i++) {
3968 accumulator[i] +=
state.world.commodity_get_demand_by_category(c, i);
3971 for(
int i = 0; i < 8; i++) {
3972 state.cheat_data.demand_by_category_dump_buffer += std::to_string(accumulator[i]) +
",";
3974 state.cheat_data.demand_by_category_dump_buffer +=
"\n";
3976 state.cheat_data.prices_dump_buffer +=
"\n";
3977 state.cheat_data.supply_dump_buffer +=
"\n";
3978 state.cheat_data.demand_dump_buffer +=
"\n";
4008 for(
auto n :
state.world.in_nation) {
4009 for(
auto uni :
n.get_unilateral_relationship_as_source()) {
4010 if(uni.get_war_subsidies()) {
4011 auto target_m_costs = uni.get_target().get_maximum_military_costs() *
state.defines.warsubsidies_percent;
4012 if(target_m_costs <=
n.get_stockpiles(money)) {
4013 n.get_stockpiles(money) -= target_m_costs;
4014 uni.get_target().get_stockpiles(money) += target_m_costs;
4016 uni.set_war_subsidies(
false);
4022 "msg_wsub_end_title",
4023 n.id, uni.get_target().id, dcon::nation_id{},
4028 if(uni.get_reparations() &&
state.current_date <
n.get_reparations_until()) {
4030 auto total_tax_base =
n.get_total_rich_income() +
n.get_total_middle_income() +
n.get_total_poor_income();
4032 auto payout = total_tax_base * tax_eff *
state.defines.reparations_tax_hit;
4033 auto capped_payout = std::min(
n.get_stockpiles(money), payout);
4034 assert(capped_payout >= 0.0f);
4036 n.get_stockpiles(money) -= capped_payout;
4037 uni.get_target().get_stockpiles(money) += capped_payout;
4045 for(
auto n :
state.world.in_nation) {
4046 auto m =
n.get_stockpiles(money);
4058 float primary_commodity_basket = 0.0f;
4059 state.world.for_each_commodity([&](dcon::commodity_id c) {
4060 state.world.for_each_pop_type([&](dcon::pop_type_id pt) {
4061 primary_commodity_basket += 2.0f *
state.world.commodity_get_cost(c) *
state.world.pop_type_get_life_needs(pt, c);
4062 primary_commodity_basket += 2.0f *
state.world.commodity_get_cost(c) *
state.world.pop_type_get_everyday_needs(pt, c);
4065 primary_commodity_basket /= float(
state.world.pop_type_size());
4068 float total_pop_money = 0.0f;
4070 state.world.for_each_nation([&](dcon::nation_id n) {
4072 total_pop_money +=
state.world.nation_get_total_rich_income(n) +
state.world.nation_get_total_middle_income(n) +
4073 state.world.nation_get_total_poor_income(n);
4076 float target_money =
total_pop * primary_commodity_basket /
state.defines.alice_needs_scaling_factor;
4082 if(total_pop_money > 0.001f) {
4083 state.inflation = (
state.inflation * 0.9f) + (0.1f * target_money / total_pop_money);
4089 if(initiate_buildings) {
4092 for(
auto n :
state.world.in_nation) {
4093 auto nation_rules =
n.get_combined_issue_rules();
4096 float total_cost = 0.f;
4098 for(
uint32_t i = 1; i < total_commodities; ++i) {
4099 dcon::commodity_id c{ dcon::commodity_id::value_base_t(i) };
4100 total_cost +=
state.world.nation_get_private_construction_demand(n, c) *
state.world.commodity_get_current_price(c);
4103 float total_cost_added = 0.f;
4105 if(
n.get_private_investment() > total_cost
4106 &&
n.get_is_civilized()
4109 static std::vector<dcon::factory_type_id> desired_types;
4110 desired_types.clear();
4112 static std::vector<dcon::state_instance_id> states_in_order;
4113 states_in_order.clear();
4114 for(
auto si :
n.get_state_ownership()) {
4115 if(si.get_state().get_capital().get_is_colonial() ==
false) {
4116 states_in_order.push_back(si.get_state().id);
4119 std::sort(states_in_order.begin(), states_in_order.end(), [&](dcon::state_instance_id a, dcon::state_instance_id b) {
4120 auto a_pop = state.world.state_instance_get_demographics(a, demographics::total);
4121 auto b_pop = state.world.state_instance_get_demographics(b, demographics::total);
4123 return a_pop > b_pop;
4124 return a.index() < b.index();
4134 for(
auto s : states_in_order) {
4135 auto pw_num =
state.world.state_instance_get_demographics(s,
4137 auto pw_employed =
state.world.state_instance_get_demographics(s,
4140 if(pw_employed >= pw_num && pw_num > 0.0f)
4143 int32_t num_factories = 0;
4145 dcon::factory_id selected_factory;
4148 auto d =
state.world.state_instance_get_definition(s);
4149 for(
auto p :
state.world.state_definition_get_abstract_state_membership(d)) {
4150 if(p.get_province().get_nation_from_province_ownership() == n) {
4151 for(
auto f : p.get_province().get_factory_location()) {
4156 && f.get_factory().get_production_scale() >= 0.9f
4157 && f.get_factory().get_primary_employment() >= 0.9f
4158 && f.get_factory().get_level() <
uint8_t(255)) {
4160 auto type = f.get_factory().get_building_type();
4161 auto ug_in_progress =
false;
4162 for(
auto c :
state.world.state_instance_get_state_building_construction(s)) {
4163 if(c.get_type() == type) {
4164 ug_in_progress =
true;
4169 if(ug_in_progress) {
4173 if(
auto new_p = f.get_factory().get_full_profit() / f.get_factory().get_level(); new_p > profit) {
4175 selected_factory = f.get_factory();
4181 if(selected_factory && profit > 0.f) {
4182 auto new_up =
fatten(
state.world,
state.world.force_create_state_building_construction(s, n));
4183 new_up.set_is_pop_project(
true);
4184 new_up.set_is_upgrade(
true);
4185 new_up.set_type(
state.world.factory_get_building_type(selected_factory));
4190 auto existing_constructions =
state.world.state_instance_get_state_building_construction(s);
4191 if(existing_constructions.begin() != existing_constructions.end())
4194 if(
n.get_private_investment() * 0.1f < total_cost + total_cost_added) {
4200 if(!desired_types.empty()) {
4201 auto selected = desired_types[
rng::get_random(state,
uint32_t((
n.id.index() << 6) ^ s.index())) % desired_types.size()];
4206 bool already_in_progress = [&]() {
4207 for(
auto p :
state.world.state_instance_get_state_building_construction(s)) {
4208 if(p.get_type() == selected)
4214 if(already_in_progress)
4218 bool present_in_location =
false;
4220 for(
auto fac :
state.world.province_get_factory_location(p)) {
4221 auto type = fac.get_factory().get_building_type();
4222 if(selected == type) {
4223 present_in_location = true;
4229 if(present_in_location)
4232 auto new_up =
fatten(
state.world,
state.world.force_create_state_building_construction(s, n));
4233 new_up.set_is_pop_project(
true);
4234 new_up.set_is_upgrade(
false);
4235 new_up.set_type(selected);
4237 auto costs = new_up.get_type().get_construction_costs();
4239 for(
uint32_t i = 0; i < commodity_set::set_size; ++i) {
4240 if(costs.commodity_type[i]) {
4241 total_cost_added +=
state.world.nation_get_effective_prices(n, costs.commodity_type[i]) * costs.commodity_amounts[i];
4253 static std::vector<std::pair<dcon::province_id, int32_t>> provinces_in_order;
4254 provinces_in_order.clear();
4255 for(
auto si :
n.get_state_ownership()) {
4256 if(si.get_state().get_capital().get_is_colonial() ==
false) {
4257 auto s = si.get_state().id;
4258 auto d =
state.world.state_instance_get_definition(s);
4259 int32_t num_factories = 0;
4260 for(
auto p :
state.world.state_definition_get_abstract_state_membership(d)) {
4262 p.get_province().get_nation_from_province_ownership() == n) {
4263 for(
auto f : p.get_province().get_factory_location())
4264 num_factories += int32_t(f.get_factory().get_level());
4265 provinces_in_order.emplace_back(p.get_province().id, num_factories);
4270 for(
auto p :
state.world.state_definition_get_abstract_state_membership(d)) {
4272 p.get_province().get_nation_from_province_ownership() == n)
4273 provinces_in_order.emplace_back(p.get_province().id, num_factories);
4277 if(!provinces_in_order.empty()) {
4278 std::pair<dcon::province_id, int32_t> best_p = provinces_in_order[0];
4279 for(
auto e : provinces_in_order)
4280 if(e.second > best_p.second)
4283 auto new_rr =
fatten(
state.world,
state.world.force_create_province_building_construction(best_p.first, n));
4284 new_rr.set_is_pop_project(
true);
4285 new_rr.set_type(
uint8_t(province_building_type::railroad));
4290 n.set_private_investment(0.0f);
4295 if(
state.cheat_data.ecodump) {
4296 for(
auto n :
state.world.in_nation) {
4298 state.world.nation_get_life_needs_costs(n,
state.culture_definitions.primary_factory_worker)
4299 +
state.world.nation_get_everyday_needs_costs(n,
state.culture_definitions.primary_factory_worker)
4300 +
state.world.nation_get_luxury_needs_costs(n,
state.culture_definitions.primary_factory_worker);
4303 state.cheat_data.national_economy_dump_buffer +=
4306 + std::to_string(
state.world.nation_get_gdp(n)) +
","
4307 + std::to_string(life_costs) +
","
4309 + std::to_string(
state.current_date.value) +
"\n";
4315 state.culture_definitions.rgo_workers.clear();
4316 for(
auto pt : state.world.in_pop_type) {
4317 if(pt.get_is_paid_rgo_worker())
4318 state.culture_definitions.rgo_workers.push_back(pt);
4321 auto const total_commodities = state.world.commodity_size();
4322 for(
uint32_t k = 1; k < total_commodities; ++k) {
4323 dcon::commodity_id cid{ dcon::commodity_id::value_base_t(k) };
4324 for(
auto pt : state.world.in_pop_type) {
4325 if(pt != state.culture_definitions.slaves) {
4326 if(pt.get_life_needs(cid) > 0.0f)
4327 state.world.commodity_set_is_life_need(cid,
true);
4328 if(pt.get_everyday_needs(cid) > 0.0f)
4329 state.world.commodity_set_is_everyday_need(cid,
true);
4330 if(pt.get_luxury_needs(cid) > 0.0f)
4331 state.world.commodity_set_is_luxury_need(cid,
true);
4336 state.world.commodity_resize_demand_by_category(8);
4338 state.world.nation_resize_intermediate_demand(state.world.commodity_size());
4340 state.world.nation_resize_life_needs_costs(state.world.pop_type_size());
4341 state.world.nation_resize_everyday_needs_costs(state.world.pop_type_size());
4342 state.world.nation_resize_luxury_needs_costs(state.world.pop_type_size());
4344 state.world.province_resize_rgo_actual_production_per_good(state.world.commodity_size());
4346 state.world.for_each_commodity([&](dcon::commodity_id c) {
4347 auto fc = fatten(state.world, c);
4348 state.world.commodity_set_key_factory(c, dcon::factory_type_id{});
4349 if(fc.get_total_production() > 0.0001f) {
4350 fc.set_producer_payout_fraction(std::min(fc.get_total_consumption() / fc.get_total_production(), 1.0f));
4352 fc.set_producer_payout_fraction(1.0f);
4355 state.world.for_each_factory_type([&](dcon::factory_type_id t) {
4356 auto o = state.world.factory_type_get_output(t);
4358 state.world.commodity_set_key_factory(o, t);
4363 auto overseas_factor = state.defines.province_overseas_penalty *
4364 float(state.world.nation_get_owned_province_count(n) - state.world.nation_get_central_province_count(n));
4365 auto o_adjust = 0.0f;
4366 if(overseas_factor > 0) {
4367 auto kf = state.world.commodity_get_key_factory(c);
4368 if(state.world.commodity_get_overseas_penalty(c) &&
4369 (state.world.commodity_get_is_available_from_start(c) || (kf && state.world.nation_get_active_building(n, kf)))) {
4370 o_adjust = overseas_factor;
4374 return (state.world.nation_get_army_demand(n, c) + state.world.nation_get_navy_demand(n, c) +
4375 state.world.nation_get_construction_demand(n, c) + o_adjust);
4380 auto& costs = fat.get_construction_costs();
4382 float factory_mod = state.world.nation_get_modifier_values(state.local_player_nation, sys::national_mod_offsets::factory_cost) + 1.0f;
4383 float admin_eff = state.world.nation_get_administrative_efficiency(state.local_player_nation);
4384 float admin_cost_factor = (2.0f - admin_eff) * factory_mod;
4388 auto cid = costs.commodity_type[i];
4390 total += state.world.commodity_get_current_price(cid) * costs.commodity_amounts[i] * admin_cost_factor;
4397float factory_type_output_cost(
sys::state& state, dcon::nation_id n, dcon::factory_type_id factory_type) {
4398 auto fac_type =
dcon::fatten(state.world, factory_type);
4400 float total_production = fac_type.get_output_amount() * output_multiplier;
4402 return total_production * state.world.commodity_get_current_price(fac_type.get_output());
4405float factory_type_input_cost(
sys::state& state, dcon::nation_id n, dcon::factory_type_id factory_type) {
4406 auto fac_type =
dcon::fatten(state.world, factory_type);
4411 auto const maint_multiplier = state.world.nation_get_modifier_values(n, sys::national_mod_offsets::factory_maintenance) + 1.0f;
4414 return input_total * input_multiplier + e_input_total * input_multiplier * maint_multiplier;
4419 for(
auto ownership : state.world.nation_get_province_ownership(n)) {
4420 for(
auto location : state.world.province_get_factory_location(ownership.get_province())) {
4422 auto f = state.world.factory_location_get_factory(location);
4423 auto p = ownership.get_province();
4424 auto s = p.get_state_membership();
4425 auto fac = fatten(state.world, f);
4426 auto fac_type = fac.get_building_type();
4429 float min_input_available = 1.f;
4430 float min_e_input_available = 1.f;
4439 float total_production = fac_type.get_output_amount()
4440 * (0.75f + 0.25f * min_e_input_available)
4441 * throughput_multiplier
4443 * min_input_available;
4445 float effective_production_scale = fac.get_production_scale();
4447 auto& inputs = fac_type.get_inputs();
4448 auto& e_inputs = fac_type.get_efficiency_inputs();
4457 * throughput_multiplier
4458 * effective_production_scale
4459 * (0.1f + min_input_available * 0.9f);
4461 for(
uint32_t i = 0; i < commodity_set::set_size; ++i) {
4462 if(inputs.commodity_type[i]) {
4463 if(inputs.commodity_type[i] == c) {
4465 +input_scale * inputs.commodity_amounts[i];
4476 auto const mfactor = state.world.nation_get_modifier_values(n, sys::national_mod_offsets::factory_maintenance) + 1.0f;
4477 for(
uint32_t i = 0; i < small_commodity_set::set_size; ++i) {
4478 if(e_inputs.commodity_type[i]) {
4479 if(e_inputs.commodity_type[i] == c) {
4483 * e_inputs.commodity_amounts[i]
4484 * (0.1f + min_e_input_available * 0.9f);
4498 auto kf = state.world.commodity_get_key_factory(c);
4499 if(state.world.commodity_get_is_available_from_start(c) || (kf && state.world.nation_get_active_building(n, kf))) {
4500 state.world.for_each_pop_type([&](dcon::pop_type_id pt) {
4501 amount += (state.world.pop_type_get_life_needs(pt, c) + state.world.pop_type_get_everyday_needs(pt, c) +
4502 state.world.pop_type_get_luxury_needs(pt, c)) *
4503 state.world.nation_get_demographics(n,
demographics::to_key(state, pt)) / state.defines.alice_needs_scaling_factor;
4510 float t_total = 0.0f;
4512 auto const total_commodities = state.world.commodity_size();
4513 for(
uint32_t k = 1; k < total_commodities; ++k) {
4514 dcon::commodity_id cid{ dcon::commodity_id::value_base_t(k) };
4515 t_total += state.world.commodity_get_current_price(cid) * state.world.nation_get_imports(n, cid);
4522 auto saved = state.world.pop_get_savings(p);
4528 auto strata =
culture::pop_strata(state.world.pop_type_get_strata(state.world.pop_get_poptype(p)));
4532 return saved / std::max(0.0001f, (1.0f - tax_eff *
float(state.world.nation_get_poor_tax(owner)) / 100.0f));
4534 return saved / std::max(0.0001f, (1.0f - tax_eff *
float(state.world.nation_get_middle_tax(owner)) / 100.0f));
4536 return saved / std::max(0.0001f, (1.0f - tax_eff *
float(state.world.nation_get_rich_tax(owner)) / 100.0f));
4542 for(
auto poid : state.world.nation_get_province_ownership_as_nation(n)) {
4543 auto prov = poid.get_province();
4545 state.world.for_each_commodity([&](dcon::commodity_id c) {
4546 if(state.world.commodity_get_money_rgo(c)) {
4547 amount += province::rgo_production_quantity(state, prov.id, c);
4551 return amount * state.defines.gold_to_cash_rate;
4560 auto const p_level = state.world.nation_get_modifier_values(n, sys::national_mod_offsets::pension_level);
4561 auto const unemp_level = state.world.nation_get_modifier_values(n, sys::national_mod_offsets::unemployment_benefit);
4563 state.world.for_each_pop_type([&](dcon::pop_type_id pt) {
4564 auto adj_pop_of_type =
4565 state.world.nation_get_demographics(n,
demographics::to_key(state, pt)) / state.defines.alice_needs_scaling_factor;
4567 if(adj_pop_of_type <= 0)
4574 total += adj_pop_of_type * p_level * state.world.nation_get_life_needs_costs(n, pt);
4575 if(state.world.pop_type_get_has_unemployment(pt)) {
4576 auto emp = state.world.nation_get_demographics(n, demographics::to_employment_key(state, pt)) / state.defines.alice_needs_scaling_factor;
4577 total += (adj_pop_of_type - emp) * unemp_level * state.world.nation_get_life_needs_costs(n, pt);
4586 state.world.for_each_pop_type([&](dcon::pop_type_id pt) {
4587 auto adj_pop_of_type =
4588 state.world.nation_get_demographics(n,
demographics::to_key(state, pt)) / state.defines.alice_needs_scaling_factor;
4590 if(adj_pop_of_type <= 0)
4595 total += adj_pop_of_type * state.world.nation_get_life_needs_costs(n, pt);
4600 total += adj_pop_of_type * state.world.nation_get_everyday_needs_costs(n, pt);
4605 total += adj_pop_of_type * state.world.nation_get_luxury_needs_costs(n, pt);
4624 return state.world.nation_get_subsidies_spending(n);
4630 for(
auto uni : state.world.nation_get_unilateral_relationship_as_target(n)) {
4631 if(uni.get_war_subsidies()) {
4632 total += uni.get_target().get_maximum_military_costs() * state.defines.warsubsidies_percent;
4637float estimate_reparations_income(
sys::state& state, dcon::nation_id n) {
4639 for(
auto uni : state.world.nation_get_unilateral_relationship_as_target(n)) {
4640 if(uni.get_reparations() && state.current_date < uni.get_source().get_reparations_until()) {
4641 auto source = uni.get_source();
4643 auto total_tax_base = state.world.nation_get_total_rich_income(source) +
4644 state.world.nation_get_total_middle_income(source) +
4645 state.world.nation_get_total_poor_income(source);
4646 auto payout = total_tax_base * tax_eff * state.defines.reparations_tax_hit;
4656 for(
auto uni : state.world.nation_get_unilateral_relationship_as_source(n)) {
4657 if(uni.get_war_subsidies()) {
4658 total += uni.get_target().get_maximum_military_costs() * state.defines.warsubsidies_percent;
4667 if(state.current_date < state.world.nation_get_reparations_until(n)) {
4668 for(
auto uni : state.world.nation_get_unilateral_relationship_as_source(n)) {
4669 if(uni.get_reparations()) {
4671 auto total_tax_base = state.world.nation_get_total_rich_income(n) +
4672 state.world.nation_get_total_middle_income(n) +
4673 state.world.nation_get_total_poor_income(n);
4674 auto payout = total_tax_base * tax_eff * state.defines.reparations_tax_hit;
4685 return w_sub + w_reps;
4689 auto adj_pop_of_type_capis = (state.world.nation_get_demographics(n,
demographics::to_key(state, state.culture_definitions.capitalists))) / state.defines.alice_needs_scaling_factor;
4690 auto adj_pop_of_type_arist = (state.world.nation_get_demographics(n,
demographics::to_key(state, state.culture_definitions.aristocrat))) / state.defines.alice_needs_scaling_factor;
4692 state.world.nation_get_life_needs_costs(n, state.culture_definitions.aristocrat)
4693 + state.world.nation_get_everyday_needs_costs(n, state.culture_definitions.aristocrat)
4694 + state.world.nation_get_luxury_needs_costs(n, state.culture_definitions.aristocrat);
4696 state.world.nation_get_life_needs_costs(n, state.culture_definitions.capitalists)
4697 + state.world.nation_get_everyday_needs_costs(n, state.culture_definitions.capitalists)
4698 + state.world.nation_get_luxury_needs_costs(n, state.culture_definitions.capitalists);
4699 return state.defines.alice_domestic_investment_multiplier * (adj_pop_of_type_capis * capis_costs + adj_pop_of_type_arist * arist_costs);
4704 uint32_t total_commodities = state.world.commodity_size();
4705 for(
uint32_t i = 1; i < total_commodities; ++i) {
4706 dcon::commodity_id cid{dcon::commodity_id::value_base_t(i)};
4707 total += state.world.nation_get_army_demand(n, cid) * state.world.nation_get_effective_prices(n, cid) * state.world.nation_get_demand_satisfaction(n, cid);
4714 uint32_t total_commodities = state.world.commodity_size();
4715 for(
uint32_t i = 1; i < total_commodities; ++i) {
4716 dcon::commodity_id cid{dcon::commodity_id::value_base_t(i)};
4717 total += state.world.nation_get_navy_demand(n, cid) * state.world.nation_get_effective_prices(n, cid) * state.world.nation_get_demand_satisfaction(n, cid);
4724 float admin_eff = state.world.nation_get_administrative_efficiency(n);
4725 float admin_cost_factor = 2.0f - admin_eff;
4727 for(
auto lc : state.world.nation_get_province_land_construction(n)) {
4728 auto province = state.world.pop_get_province_from_pop_location(state.world.province_land_construction_get_pop(lc));
4729 if(state.world.province_get_nation_from_province_control(
province) == n) {
4731 auto& base_cost = state.military_definitions.unit_base_definitions[state.world.province_land_construction_get_type(lc)].build_cost;
4732 auto& current_purchased = state.world.province_land_construction_get_purchased_goods(lc);
4735 for(
uint32_t i = 0; i < commodity_set::set_size; ++i) {
4736 if(base_cost.commodity_type[i]) {
4737 if(current_purchased.commodity_amounts[i] < base_cost.commodity_amounts[i] * admin_cost_factor)
4738 total += state.world.nation_get_effective_prices(n, base_cost.commodity_type[i]) * state.world.nation_get_demand_satisfaction(n, base_cost.commodity_type[i]) * base_cost.commodity_amounts[i] / construction_time;
4746 for(
auto po : state.world.nation_get_province_ownership(n)) {
4747 auto p = po.get_province();
4748 if(state.world.province_get_nation_from_province_control(p) != n)
4751 auto rng = state.world.province_get_province_naval_construction(p);
4752 if(
rng.begin() !=
rng.end()) {
4753 auto c = *(
rng.begin());
4754 auto& base_cost = state.military_definitions.unit_base_definitions[c.get_type()].build_cost;
4755 auto& current_purchased = c.get_purchased_goods();
4758 for(
uint32_t i = 0; i < commodity_set::set_size; ++i) {
4759 if(base_cost.commodity_type[i]) {
4760 if(current_purchased.commodity_amounts[i] < base_cost.commodity_amounts[i] * admin_cost_factor)
4761 total += state.world.nation_get_effective_prices(n, base_cost.commodity_type[i]) * state.world.nation_get_demand_satisfaction(n, base_cost.commodity_type[i]) * base_cost.commodity_amounts[i] / construction_time;
4769 for(
auto c : state.world.nation_get_province_building_construction(n)) {
4770 if(n == c.get_province().get_nation_from_province_control() && !c.get_is_pop_project()) {
4772 auto& base_cost = state.economy_definitions.building_definitions[int32_t(t)].cost;
4773 auto& current_purchased = c.get_purchased_goods();
4776 for(
uint32_t i = 0; i < commodity_set::set_size; ++i) {
4777 if(base_cost.commodity_type[i]) {
4778 if(current_purchased.commodity_amounts[i] < base_cost.commodity_amounts[i] * admin_cost_factor)
4779 total += state.world.nation_get_effective_prices(n, base_cost.commodity_type[i]) * state.world.nation_get_demand_satisfaction(n, base_cost.commodity_type[i]) * base_cost.commodity_amounts[i] / construction_time;
4787 float factory_mod = state.world.nation_get_modifier_values(n, sys::national_mod_offsets::factory_cost) + 1.0f;
4789 for(
auto c : state.world.nation_get_state_building_construction(n)) {
4790 if(!c.get_is_pop_project()) {
4791 auto& base_cost = c.get_type().get_construction_costs();
4792 auto& current_purchased = c.get_purchased_goods();
4795 for(
uint32_t i = 0; i < commodity_set::set_size; ++i) {
4796 if(base_cost.commodity_type[i]) {
4797 if(current_purchased.commodity_amounts[i] < base_cost.commodity_amounts[i] * factory_mod * admin_cost_factor)
4798 total += state.world.nation_get_effective_prices(n, base_cost.commodity_type[i]) * state.world.nation_get_demand_satisfaction(n, base_cost.commodity_type[i]) * base_cost.commodity_amounts[i] * factory_mod / construction_time;
4811 return state.world.nation_get_maximum_military_costs(n) * state.defines.warsubsidies_percent;
4815 for(
auto pb_con : state.world.province_get_province_building_construction(p)) {
4816 if(pb_con.get_type() ==
uint8_t(t)) {
4817 float admin_eff = state.world.nation_get_administrative_efficiency(state.world.province_get_nation_from_province_ownership(p));
4818 float admin_cost_factor = pb_con.get_is_pop_project() ? 1.0f : 2.0f - admin_eff;
4821 float purchased = 0.0f;
4822 for(
uint32_t i = 0; i < commodity_set::set_size; ++i) {
4823 total += state.economy_definitions.building_definitions[int32_t(t)].cost.commodity_amounts[i] * admin_cost_factor;
4824 purchased += pb_con.get_purchased_goods().commodity_amounts[i];
4833 auto in_prov = state.world.factory_get_province_from_factory_location(f);
4834 auto in_state = state.world.province_get_state_membership(in_prov);
4835 auto fac_type = state.world.factory_get_building_type(f);
4837 for(
auto st_con : state.world.state_instance_get_state_building_construction(in_state)) {
4838 if(st_con.get_type() == fac_type) {
4839 float admin_eff = state.world.nation_get_administrative_efficiency(st_con.get_nation());
4840 float factory_mod = state.world.nation_get_modifier_values(st_con.get_nation(), sys::national_mod_offsets::factory_cost) + 1.0f;
4841 float pop_factory_mod = std::max(0.1f, state.world.nation_get_modifier_values(st_con.get_nation(), sys::national_mod_offsets::factory_owner_cost));
4842 float admin_cost_factor = (st_con.get_is_pop_project() ? pop_factory_mod : (2.0f - admin_eff)) * factory_mod;
4846 float purchased = 0.0f;
4847 auto& goods = state.world.factory_type_get_construction_costs(fac_type);
4849 for(
uint32_t i = 0; i < commodity_set::set_size; ++i) {
4850 total += goods.commodity_amounts[i] * admin_cost_factor;
4851 purchased += st_con.get_purchased_goods().commodity_amounts[i];
4862 auto d = state.world.state_instance_get_definition(s);
4863 for(
auto p : state.world.state_definition_get_abstract_state_membership(d)) {
4864 if(p.get_province().get_state_membership() == s) {
4865 for(
auto f : p.get_province().get_factory_location()) {
4866 if(f.get_factory().get_building_type() == ft)
4875 auto d = state.world.state_instance_get_definition(s);
4877 for(
auto p : state.world.state_definition_get_abstract_state_membership(d)) {
4878 if(p.get_province().get_state_membership() == s) {
4879 for(
auto f : p.get_province().get_factory_location()) {
4880 if(f.get_factory().get_building_type() == ft)
4885 for(
auto sc : state.world.state_instance_get_state_building_construction(s)) {
4886 if(sc.get_type() == ft)
4894 int32_t num_factories = 0;
4895 auto d = state.world.state_instance_get_definition(sid);
4896 for(
auto p : state.world.state_definition_get_abstract_state_membership(d))
4897 if(p.get_province().get_nation_from_province_ownership() == n)
4898 num_factories += int32_t(state.world.province_get_factory_location(p.get_province()).end() - state.world.province_get_factory_location(p.get_province()).begin());
4899 for(
auto p : state.world.state_instance_get_state_building_construction(sid))
4900 if(p.get_is_upgrade() ==
false)
4904 assert(num_factories <= int32_t(state.defines.factories_per_state));
4905 return num_factories;
4910 float admin_eff = state.world.nation_get_administrative_efficiency(state.world.province_land_construction_get_nation(c));
4911 float admin_cost_factor = 2.0f - admin_eff;
4913 auto& goods = state.military_definitions.unit_base_definitions[state.world.province_land_construction_get_type(c)].build_cost;
4914 auto& cgoods = state.world.province_land_construction_get_purchased_goods(c);
4917 float purchased = 0.0f;
4919 for(
uint32_t i = 0; i < commodity_set::set_size; ++i) {
4920 total += goods.commodity_amounts[i] * admin_cost_factor;
4921 purchased += cgoods.commodity_amounts[i];
4924 return total > 0.0f ? purchased / total : 0.0f;
4928 float admin_eff = state.world.nation_get_administrative_efficiency(state.world.province_naval_construction_get_nation(c));
4929 float admin_cost_factor = 2.0f - admin_eff;
4931 auto& goods = state.military_definitions.unit_base_definitions[state.world.province_naval_construction_get_type(c)].build_cost;
4932 auto& cgoods = state.world.province_naval_construction_get_purchased_goods(c);
4935 float purchased = 0.0f;
4937 for(
uint32_t i = 0; i < commodity_set::set_size; ++i) {
4938 total += goods.commodity_amounts[i] * admin_cost_factor;
4939 purchased += cgoods.commodity_amounts[i];
4942 return total > 0.0f ? purchased / total : 0.0f;
4948 auto d = state.world.state_instance_get_definition(s);
4949 auto o = state.world.state_instance_get_nation_from_state_ownership(s);
4950 for(
auto p : state.world.state_definition_get_abstract_state_membership(d)) {
4951 if(p.get_province().get_nation_from_province_ownership() == o) {
4952 for(
auto f : p.get_province().get_factory_location()) {
4953 if(f.get_factory().get_building_type() == t) {
4954 auto factory_level = f.get_factory().get_level();
4955 auto new_factory_level = std::min(
float(std::numeric_limits<uint8_t>::max()),
float(factory_level) + 1.f +
math::sqrt(f.get_factory().get_level()) / 2.f);
4956 f.get_factory().get_level() =
uint8_t(new_factory_level);
4963 auto state_cap = state.world.state_instance_get_capital(s);
4964 auto new_fac = fatten(state.world, state.world.create_factory());
4965 new_fac.set_building_type(t);
4966 new_fac.set_level(
uint8_t(1));
4967 new_fac.set_production_scale(1.0f);
4969 state.world.try_create_factory_location(new_fac, state_cap);
4974 for(
uint32_t i = state.world.province_land_construction_size(); i-- > 0;) {
4975 auto c = fatten(state.world, dcon::province_land_construction_id{dcon::province_land_construction_id::value_base_t(i)});
4977 float admin_eff = state.world.nation_get_administrative_efficiency(state.world.province_land_construction_get_nation(c));
4978 float admin_cost_factor = 2.0f - admin_eff;
4980 auto& base_cost = state.military_definitions.unit_base_definitions[c.get_type()].build_cost;
4981 auto& current_purchased = c.get_purchased_goods();
4982 float construction_time = float(state.military_definitions.unit_base_definitions[c.get_type()].build_time);
4984 bool all_finished =
true;
4985 if(!(c.get_nation().get_is_player_controlled() && state.cheat_data.instant_army)) {
4986 for(
uint32_t j = 0; j < commodity_set::set_size && all_finished; ++j) {
4987 if(base_cost.commodity_type[j]) {
4988 if(current_purchased.commodity_amounts[j] < base_cost.commodity_amounts[j] * admin_cost_factor) {
4989 all_finished =
false;
4998 auto pop_location = c.get_pop().get_province_from_pop_location();
5001 auto a = fatten(state.world, state.world.create_army());
5003 a.set_controller_from_army_control(c.get_nation());
5004 state.world.try_create_army_membership(new_reg, a);
5005 state.world.try_create_regiment_source(new_reg, c.get_pop());
5009 if(c.get_nation() == state.local_player_nation) {
5014 state.local_player_nation, dcon::nation_id{}, dcon::nation_id{},
5019 state.world.delete_province_land_construction(c);
5024 auto rng = state.world.province_get_province_naval_construction(p);
5025 if(
rng.begin() !=
rng.end()) {
5026 auto c = *(rng.begin());
5028 float admin_eff = state.world.nation_get_administrative_efficiency(state.world.province_naval_construction_get_nation(c));
5029 float admin_cost_factor = 2.0f - admin_eff;
5031 auto& base_cost = state.military_definitions.unit_base_definitions[c.get_type()].build_cost;
5032 auto& current_purchased = c.get_purchased_goods();
5033 float construction_time = float(state.military_definitions.unit_base_definitions[c.get_type()].build_time);
5035 bool all_finished = true;
5036 if(!(c.get_nation().get_is_player_controlled() && state.cheat_data.instant_navy)) {
5037 for(uint32_t i = 0; i < commodity_set::set_size && all_finished; ++i) {
5038 if(base_cost.commodity_type[i]) {
5039 if(current_purchased.commodity_amounts[i] < base_cost.commodity_amounts[i] * admin_cost_factor) {
5040 all_finished = false;
5049 auto new_ship = military::create_new_ship(state, c.get_nation(), c.get_type());
5050 auto a = fatten(state.world, state.world.create_navy());
5051 a.set_controller_from_navy_control(c.get_nation());
5052 a.set_location_from_navy_location(p);
5053 state.world.try_create_navy_membership(new_ship, a);
5054 military::move_navy_to_merge(state, c.get_nation(), a, c.get_province(), c.get_template_province());
5056 if(c.get_nation() == state.local_player_nation) {
5057 notification::post(state, notification::message{ [](sys::state& state, text::layout_base& contents) {
5058 text::add_line(state, contents,
"amsg_navy_built");
5061 state.local_player_nation, dcon::nation_id{}, dcon::nation_id{},
5062 sys::message_base_type::navy_built
5066 state.world.delete_province_naval_construction(c);
5071 for(
uint32_t i =
state.world.province_building_construction_size(); i-- > 0;) {
5072 dcon::province_building_construction_id c{dcon::province_building_construction_id::value_base_t(i)};
5073 auto for_province =
state.world.province_building_construction_get_province(c);
5075 float admin_eff =
state.world.nation_get_administrative_efficiency(
state.world.province_building_construction_get_nation(c));
5076 float admin_cost_factor =
state.world.province_building_construction_get_is_pop_project(c) ? 1.0f : 2.0f - admin_eff;
5079 auto& base_cost =
state.economy_definitions.building_definitions[int32_t(t)].cost;
5080 auto& current_purchased =
state.world.province_building_construction_get_purchased_goods(c);
5081 bool all_finished =
true;
5083 for(
uint32_t j = 0; j < commodity_set::set_size && all_finished; ++j) {
5084 if(base_cost.commodity_type[j]) {
5085 if(current_purchased.commodity_amounts[j] < base_cost.commodity_amounts[j] * admin_cost_factor) {
5086 all_finished =
false;
5094 if(
state.world.province_get_building_level(for_province,
uint8_t(t)) <
state.world.nation_get_max_building_level(
state.world.province_get_nation_from_province_ownership(for_province),
uint8_t(t))) {
5095 state.world.province_get_building_level(for_province,
uint8_t(t)) += 1;
5097 if(t == province_building_type::railroad) {
5099 state.railroad_built.store(
true, std::memory_order::release);
5102 if(
state.world.province_building_construction_get_nation(c) ==
state.local_player_nation) {
5104 case province_building_type::naval_base:
5108 "amsg_naval_base_complete",
5109 state.local_player_nation, dcon::nation_id{}, dcon::nation_id{},
5113 case province_building_type::fort:
5117 "amsg_fort_complete",
5118 state.local_player_nation, dcon::nation_id{}, dcon::nation_id{},
5122 case province_building_type::railroad:
5127 state.local_player_nation, dcon::nation_id{}, dcon::nation_id{},
5136 state.world.delete_province_building_construction(c);
5140 for(
uint32_t i =
state.world.state_building_construction_size(); i-- > 0;) {
5141 dcon::state_building_construction_id c{dcon::state_building_construction_id::value_base_t(i)};
5142 auto n =
state.world.state_building_construction_get_nation(c);
5143 auto type =
state.world.state_building_construction_get_type(c);
5144 auto& base_cost =
state.world.factory_type_get_construction_costs(type);
5145 auto& current_purchased =
state.world.state_building_construction_get_purchased_goods(c);
5147 if(!
state.world.state_building_construction_get_is_pop_project(c)) {
5148 float admin_eff =
state.world.nation_get_administrative_efficiency(n);
5149 float admin_cost_factor = 2.0f - admin_eff;
5151 float factory_mod =
state.world.nation_get_modifier_values(n, sys::national_mod_offsets::factory_cost) + 1.0f;
5153 bool all_finished =
true;
5154 if(!(n ==
state.local_player_nation &&
state.cheat_data.instant_industry)) {
5155 for(
uint32_t j = 0; j < commodity_set::set_size && all_finished; ++j) {
5156 if(base_cost.commodity_type[j]) {
5157 if(current_purchased.commodity_amounts[j] < base_cost.commodity_amounts[j] * factory_mod * admin_cost_factor) {
5158 all_finished =
false;
5167 state.world.state_building_construction_get_is_upgrade(c));
5168 state.world.delete_state_building_construction(c);
5171 float factory_mod = (
state.world.nation_get_modifier_values(n, sys::national_mod_offsets::factory_cost) + 1.0f) *
5172 std::max(0.1f,
state.world.nation_get_modifier_values(n, sys::national_mod_offsets::factory_owner_cost));
5174 bool all_finished =
true;
5175 if(!(n ==
state.local_player_nation &&
state.cheat_data.instant_industry)) {
5176 for(
uint32_t j = 0; j < commodity_set::set_size && all_finished; ++j) {
5177 if(base_cost.commodity_type[j]) {
5178 if(current_purchased.commodity_amounts[j] < base_cost.commodity_amounts[j] * factory_mod) {
5179 all_finished =
false;
5188 state.world.state_building_construction_get_is_upgrade(c));
5190 if(
state.world.state_building_construction_get_nation(c) ==
state.local_player_nation) {
5194 "amsg_factory_complete",
5195 state.local_player_nation, dcon::nation_id{}, dcon::nation_id{},
5200 state.world.delete_state_building_construction(c);
5213 state.world.nation_get_total_poor_income(n) * state.world.nation_get_poor_tax(n) / 100.f
5214 + state.world.nation_get_total_middle_income(n) * state.world.nation_get_middle_tax(n) / 100.f
5215 + state.world.nation_get_total_rich_income(n) * state.world.nation_get_rich_tax(n) / 100.f
5220 auto n = state.world.state_instance_get_nation_from_state_ownership(s);
5222 if(state.world.factory_type_get_is_coastal(t)) {
5227 auto existing_constructions = state.world.state_instance_get_state_building_construction(s);
5228 int32_t num_factories = 0;
5229 for(
auto prj : existing_constructions) {
5230 if(!prj.get_is_upgrade())
5232 if(prj.get_type() == t)
5237 auto d = state.world.state_instance_get_definition(s);
5238 for(
auto p : state.world.state_definition_get_abstract_state_membership(d)) {
5239 if(p.get_province().get_nation_from_province_ownership() == n) {
5240 for(
auto f : p.get_province().get_factory_location()) {
5242 if(f.get_factory().get_building_type() == t)
5248 if(num_factories < int32_t(state.defines.factories_per_state)) {
5255 auto min_tariff = int32_t(100.0f * state.world.nation_get_modifier_values(n, sys::national_mod_offsets::min_tariff));
5256 auto max_tariff = int32_t(100.0f * state.world.nation_get_modifier_values(n, sys::national_mod_offsets::max_tariff));
5257 max_tariff = std::max(min_tariff, max_tariff);
5259 auto& tariff = state.world.nation_get_tariffs(n);
5260 tariff = int8_t(std::clamp(std::clamp(int32_t(tariff), min_tariff, max_tariff), -100, 100));
5263 auto min_tax = int32_t(100.0f * state.world.nation_get_modifier_values(n, sys::national_mod_offsets::min_tax));
5264 auto max_tax = int32_t(100.0f * state.world.nation_get_modifier_values(n, sys::national_mod_offsets::max_tax));
5267 max_tax = std::max(min_tax, max_tax);
5269 auto& ptax = state.world.nation_get_poor_tax(n);
5270 ptax = int8_t(std::clamp(std::clamp(int32_t(ptax), min_tax, max_tax), 0, 100));
5271 auto& mtax = state.world.nation_get_middle_tax(n);
5272 mtax = int8_t(std::clamp(std::clamp(int32_t(mtax), min_tax, max_tax), 0, 100));
5273 auto& rtax = state.world.nation_get_rich_tax(n);
5274 rtax = int8_t(std::clamp(std::clamp(int32_t(rtax), min_tax, max_tax), 0, 100));
5278 int32_t(100.0f * state.world.nation_get_modifier_values(n, sys::national_mod_offsets::min_military_spending));
5280 int32_t(100.0f * state.world.nation_get_modifier_values(n, sys::national_mod_offsets::max_military_spending));
5283 max_spend = std::max(min_spend, max_spend);
5285 auto& v = state.world.nation_get_military_spending(n);
5286 v = int8_t(std::clamp(std::clamp(int32_t(v), min_spend, max_spend), 0, 100));
5289 auto min_spend = int32_t(100.0f * state.world.nation_get_modifier_values(n, sys::national_mod_offsets::min_social_spending));
5290 auto max_spend = int32_t(100.0f * state.world.nation_get_modifier_values(n, sys::national_mod_offsets::max_social_spending));
5293 max_spend = std::max(min_spend, max_spend);
5295 auto& v = state.world.nation_get_social_spending(n);
5296 v = int8_t(std::clamp(std::clamp(int32_t(v), min_spend, max_spend), 0, 100));
5300 int32_t(100.0f * state.world.nation_get_modifier_values(n, sys::national_mod_offsets::min_military_spending));
5302 int32_t(100.0f * state.world.nation_get_modifier_values(n, sys::national_mod_offsets::max_military_spending));
5305 max_spend = std::max(min_spend, max_spend);
5307 auto& v = state.world.nation_get_military_spending(n);
5308 v = int8_t(std::clamp(std::clamp(int32_t(v), min_spend, max_spend), 0, 100));
5311 auto min_spend = int32_t(100.0f * state.world.nation_get_modifier_values(n, sys::national_mod_offsets::min_domestic_investment));
5312 auto max_spend = int32_t(100.0f * state.world.nation_get_modifier_values(n, sys::national_mod_offsets::max_domestic_investment));
5315 max_spend = std::max(min_spend, max_spend);
5317 auto& v = state.world.nation_get_domestic_investment_spending(n);
5318 v = int8_t(std::clamp(std::clamp(int32_t(v), min_spend, max_spend), 0, 100));
5323 for(
auto si : state.world.in_state_instance) {
5324 auto owner = si.get_nation_from_state_ownership();
5325 auto rules = owner.get_combined_issue_rules();
5330 dcon::factory_id deletion_choice;
5331 int32_t factory_count = 0;
5334 for(
auto f : state.world.province_get_factory_location(p)) {
5336 auto scale = f.get_factory().get_production_scale();
5337 float ten_workers = 10.f / factory_max_employment(state, f.get_factory());
5338 bool unprofitable = f.get_factory().get_unprofitable();
5339 if(((scale < ten_workers) && unprofitable) && (!deletion_choice || state.world.factory_get_level(deletion_choice) > f.get_factory().get_level())) {
5340 deletion_choice = f.get_factory();
5347 if(deletion_choice && (4 + factory_count) >= int32_t(state.defines.factories_per_state)) {
5348 auto production_type = state.world.factory_get_building_type(deletion_choice);
5349 state.world.delete_factory(deletion_choice);
5351 for(
auto proj : si.get_state_building_construction()) {
5352 if(proj.get_type() == production_type) {
5353 state.world.delete_state_building_construction(proj);
5362 return state.economy_definitions.selector_modifier;
5366 return state.economy_definitions.immigrator_modifier;
5370 auto& debt = state.world.nation_get_stockpiles(n,
economy::money);
5375 auto existing_br = state.world.nation_get_bankrupt_until(n);
5376 if(existing_br && state.current_date < existing_br) {
5377 for(
auto gn : state.great_nations) {
5378 if(gn.nation && gn.nation != n) {
5382 }
else if(debt >= -state.defines.small_debt_limit) {
5383 for(
auto gn : state.great_nations) {
5384 if(gn.nation && gn.nation != n) {
5389 for(
auto gn : state.great_nations) {
5390 if(gn.nation && gn.nation != n) {
5396 sys::add_modifier_to_nation(state, n, state.national_definitions.in_bankrupcy, state.current_date + int32_t(state.defines.bankrupcy_duration * 365));
5397 sys::add_modifier_to_nation(state, n, state.national_definitions.bad_debter, state.current_date + int32_t(state.defines.bankruptcy_external_loan_years * 365));
5400 state.world.nation_set_is_debt_spending(n,
false);
5401 state.world.nation_set_bankrupt_until(n, state.current_date + int32_t(state.defines.bankrupcy_duration * 365));
5407 "msg_bankruptcy_title",
5408 n, dcon::nation_id{}, dcon::nation_id{},
5415 if(commodity.get_rgo_amount() > 0 && (commodity.get_artisan_output_amount() > 0 || commodity.get_key_factory()))
5416 return commodity_production_type::both;
5417 else if(commodity.get_key_factory())
5418 return commodity_production_type::derivative;
5420 return commodity_production_type::primary;
#define assert(condition)
void update_budget(sys::state &state)
void get_desired_factory_types(sys::state &state, dcon::nation_id nid, std::vector< dcon::factory_type_id > &desired_types)
pop_satisfaction_wrapper_fat fatten(data_container const &c, pop_satisfaction_wrapper_id id) noexcept
constexpr dcon::demographics_key total(0)
dcon::demographics_key to_key(sys::state const &state, dcon::pop_type_id v)
dcon::demographics_key to_employment_key(sys::state const &state, dcon::pop_type_id v)
float estimate_reparations_income(sys::state &state, dcon::nation_id n)
bool state_contains_factory(sys::state &state, dcon::state_instance_id s, dcon::factory_type_id ft)
float factory_full_production_quantity(sys::state const &state, dcon::factory_id f, dcon::nation_id n, float mobilization_impact)
void initialize(sys::state &state)
bool valid_artisan_good(sys::state &state, dcon::nation_id n, dcon::commodity_id cid)
float global_market_commodity_daily_increase(sys::state &state, dcon::commodity_id c)
dcon::modifier_id get_province_immigrator_modifier(sys::state &state)
constexpr float subsistence_score_life
float total_artisan_exp_score(sys::state &state, dcon::nation_id n, float multiplier, float max_score)
void register_demand(sys::state &state, dcon::nation_id n, dcon::commodity_id commodity_type, float amount, economy_reason reason)
float full_private_investment_cost(sys::state &state, dcon::nation_id n)
float estimate_subsidy_spending(sys::state &state, dcon::nation_id n)
constexpr float diff_factory
void populate_effective_prices(sys::state &state, dcon::nation_id n)
void update_national_consumption(sys::state &state, dcon::nation_id n, float spending_scale, float private_investment_scale)
constexpr float slope_factory
void for_each_new_factory(sys::state &state, dcon::state_instance_id s, F &&func)
float government_consumption(sys::state &state, dcon::nation_id n, dcon::commodity_id c)
float estimate_social_spending(sys::state &state, dcon::nation_id n)
construction_status province_building_construction(sys::state &state, dcon::province_id p, province_building_type t)
float rgo_total_effective_size(sys::state &state, dcon::nation_id n, dcon::province_id p)
float nation_total_imports(sys::state &state, dcon::nation_id n)
bool state_contains_constructed_factory(sys::state &state, dcon::state_instance_id s, dcon::factory_type_id ft)
float estimate_tariff_income(sys::state &state, dcon::nation_id n)
float factory_desired_raw_profit(dcon::factory_fat_id fac, float spendings)
bool has_building(sys::state const &state, dcon::state_instance_id si, dcon::factory_type_id fac)
float factory_max_employment(sys::state const &state, dcon::factory_id f)
void advance_construction(sys::state &state, dcon::nation_id n)
void update_factory_employment(sys::state &state)
bool is_bankrupt_debtor_to(sys::state &state, dcon::nation_id debt_holder, dcon::nation_id debtor)
int32_t state_factory_count(sys::state &state, dcon::state_instance_id sid, dcon::nation_id n)
float sphere_leader_share_factor(sys::state &state, dcon::nation_id sphere_leader, dcon::nation_id sphere_member)
constexpr float diff_non_factory
float estimate_diplomatic_balance(sys::state &state, dcon::nation_id n)
void prune_factories(sys::state &state)
constexpr float day_inf_build_time_modifier_non_factory
void update_factory_triggered_modifiers(sys::state &state)
void convert_commodities_into_ingredients(sys::state &state, std::vector< float > &buffer_commodities, std::vector< float > &buffer_ingredients, std::vector< float > &buffer_weights)
constexpr uint32_t gdp_history_length
float estimate_pop_payouts_by_income_type(sys::state &state, dcon::nation_id n, culture::income_type in)
void populate_construction_consumption(sys::state &state)
float estimate_domestic_investment(sys::state &state, dcon::nation_id n)
int32_t previous_price_record_index(sys::state &state)
void populate_private_construction_consumption(sys::state &state)
constexpr float day_inf_build_time_modifier_factory
rgo_workers_breakdown rgo_relevant_population(sys::state &state, dcon::province_id p, dcon::nation_id n)
float rgo_desired_worker_norm_profit(sys::state &state, dcon::province_id p, dcon::nation_id n, float min_wage, float total_relevant_population)
float factory_min_input_available(sys::state &state, dcon::nation_id n, dcon::factory_type_fat_id fac_type)
float estimate_overseas_penalty_spending(sys::state &state, dcon::nation_id n)
float nation_factory_consumption(sys::state &state, dcon::nation_id n, dcon::commodity_id c)
float nation_factory_input_multiplier(sys::state &state, dcon::nation_id n)
constexpr float shift_factory
float base_artisan_profit(sys::state &state, dcon::nation_id n, dcon::commodity_id c)
commodity_production_type get_commodity_production_type(sys::state &state, dcon::commodity_id c)
bool has_factory(sys::state const &state, dcon::state_instance_id si)
float max_loan(sys::state &state, dcon::nation_id n)
float estimate_construction_spending(sys::state &state, dcon::nation_id n)
float max_artisan_score(sys::state &state, dcon::nation_id n, float multiplier)
float effective_tariff_rate(sys::state &state, dcon::nation_id n)
float estimate_war_subsidies_income(sys::state &state, dcon::nation_id n)
construction_status factory_upgrade(sys::state &state, dcon::factory_id f)
float gdp_adjusted(sys::state &state, dcon::nation_id n)
void presimulate(sys::state &state)
void register_domestic_supply(sys::state &state, dcon::nation_id n, dcon::commodity_id commodity_type, float amount, economy_reason reason)
void update_rgo_employment(sys::state &state)
profit_distribution distribute_factory_profit(sys::state const &state, dcon::state_instance_const_fat_id s, float min_wage, float total_profit)
float full_spending_cost(sys::state &state, dcon::nation_id n)
float estimate_land_spending(sys::state &state, dcon::nation_id n)
constexpr float day_1_build_time_modifier_factory
void update_national_artisan_consumption(sys::state &state, dcon::nation_id n, float expected_min_wage, float mobilization_impact)
float rgo_total_employment(sys::state &state, dcon::nation_id n, dcon::province_id p)
commodity_production_type
float estimate_daily_income(sys::state &state, dcon::nation_id n)
void update_single_factory_production(sys::state &state, dcon::factory_id f, dcon::nation_id n, float expected_min_wage)
constexpr uint32_t price_history_length
float rgo_total_max_employment(sys::state &state, dcon::nation_id n, dcon::province_id p)
void adjust_artisan_balance(sys::state &state, dcon::nation_id n)
constexpr float artisan_baseline_score
void regenerate_unsaved_values(sys::state &state)
float artisan_scale_limit(sys::state &state, dcon::nation_id n, dcon::commodity_id c)
constexpr dcon::commodity_id money(0)
void update_land_ownership(sys::state &state)
float rgo_efficiency(sys::state &state, dcon::nation_id n, dcon::province_id p, dcon::commodity_id c)
bool can_take_loans(sys::state &state, dcon::nation_id n)
dcon::modifier_id get_province_selector_modifier(sys::state &state)
float unit_construction_progress(sys::state &state, dcon::province_land_construction_id c)
constexpr float factory_closed_threshold
int32_t most_recent_price_record_index(sys::state &state)
float factory_throughput_multiplier(sys::state &state, dcon::factory_type_fat_id fac_type, dcon::nation_id n, dcon::province_id p, dcon::state_instance_id s)
void try_add_factory_to_state(sys::state &state, dcon::state_instance_id s, dcon::factory_type_id t)
float pseudo_exp_for_negative(float f)
bool nation_is_constructing_factories(sys::state &state, dcon::nation_id n)
float pop_income(sys::state &state, dcon::pop_id p)
float rgo_effective_size(sys::state const &state, dcon::nation_id n, dcon::province_id p, dcon::commodity_id c)
float factory_max_production_scale_non_modified(sys::state &state, dcon::factory_fat_id fac)
void update_province_rgo_consumption(sys::state &state, dcon::province_id p, dcon::nation_id n, float mobilization_impact, float expected_min_wage, bool occupied)
float subsistence_size(sys::state const &state, dcon::province_id p)
constexpr float subsistence_score_luxury
float pop_factory_min_wage(sys::state &state, dcon::nation_id n, float min_wage_factor)
float estimate_war_subsidies_spending(sys::state &state, dcon::nation_id n)
float factory_max_production_scale(sys::state &state, dcon::factory_fat_id fac, float mobilization_impact, bool occupied)
float commodity_daily_production_amount(sys::state &state, dcon::commodity_id c)
float global_non_factory_construction_time_modifier(sys::state &state)
float global_market_price_multiplier(sys::state &state, dcon::nation_id n)
float estimate_war_subsidies(sys::state &state, dcon::nation_id n)
float rgo_expected_worker_norm_profit(sys::state &state, dcon::province_id p, dcon::nation_id n, dcon::commodity_id c)
constexpr float subsistence_factor
constexpr float production_scale_delta
bool factory_is_profitable(sys::state const &state, dcon::factory_id f)
float convex_function(float x)
float estimate_reparations_spending(sys::state &state, dcon::nation_id n)
int32_t most_recent_gdp_record_index(sys::state &state)
float nation_factory_output_multiplier(sys::state &state, dcon::factory_type_id fac_type, dcon::nation_id n)
float estimate_naval_spending(sys::state &state, dcon::nation_id n)
float subsistence_max_pseudoemployment(sys::state &state, dcon::nation_id n, dcon::province_id p)
float get_artisan_distribution_fast(sys::state &state, dcon::nation_id n, dcon::commodity_id c, float max_score, float total_score, float multiplier)
void for_each_upgraded_factory(sys::state &state, dcon::state_instance_id s, F &&func)
void initialize_needs_weights(sys::state &state, dcon::nation_id n)
void go_bankrupt(sys::state &state, dcon::nation_id n)
void give_sphere_leader_production(sys::state &state, dcon::nation_id n)
void bound_budget_settings(sys::state &state, dcon::nation_id n)
constexpr float slope_non_factory
float adjusted_subsistence_score(sys::state &state, dcon::province_id p)
float get_artisans_multiplier(sys::state &state, dcon::nation_id n)
float factory_secondary_employment(sys::state const &state, dcon::factory_id f)
constexpr float shift_non_factory
float rgo_max_employment(sys::state &state, dcon::nation_id n, dcon::province_id p, dcon::commodity_id c)
float pop_min_wage_factor(sys::state &state, dcon::nation_id n)
void resolve_constructions(sys::state &state)
void update_province_rgo_production(sys::state &state, dcon::province_id p, dcon::nation_id n)
float need_weight(sys::state &state, dcon::nation_id n, dcon::commodity_id c)
void update_local_subsistence_factor(sys::state &state)
float estimate_tax_income_by_strata(sys::state &state, dcon::nation_id n, culture::pop_strata ps)
float pop_farmer_min_wage(sys::state &state, dcon::nation_id n, float min_wage_factor)
float factory_total_employment(sys::state const &state, dcon::factory_id f)
float estimate_stockpile_filling_spending(sys::state &state, dcon::nation_id n)
void update_pop_consumption(sys::state &state, dcon::nation_id n, float base_demand, float invention_factor)
constexpr float rgo_owners_cut
float stockpile_commodity_daily_increase(sys::state &state, dcon::commodity_id c, dcon::nation_id n)
float pop_laborer_min_wage(sys::state &state, dcon::nation_id n, float min_wage_factor)
void populate_needs_costs(sys::state &state, dcon::nation_id n, float base_demand, float invention_factor)
float factory_input_multiplier(sys::state &state, dcon::factory_fat_id fac, dcon::nation_id n, dcon::province_id p, dcon::state_instance_id s)
void rebalance_needs_weights(sys::state &state, dcon::nation_id n)
void populate_army_consumption(sys::state &state)
void absorb_sphere_member_production(sys::state &state, dcon::nation_id n)
void add_factory_level_to_state(sys::state &state, dcon::state_instance_id s, dcon::factory_type_id t, bool is_upgrade)
void emulate_construction_demand(sys::state &state, dcon::nation_id n)
float factory_input_total_cost(sys::state &state, dcon::nation_id n, dcon::factory_type_fat_id fac_type)
constexpr float day_1_derivative_factory
float rgo_full_production_quantity(sys::state &state, dcon::nation_id n, dcon::province_id p, dcon::commodity_id c)
float global_factory_construction_time_modifier(sys::state &state)
void populate_navy_consumption(sys::state &state)
float interest_payment(sys::state &state, dcon::nation_id n)
float factory_e_input_total_cost(sys::state &state, dcon::nation_id n, dcon::factory_type_fat_id fac_type)
void initialize_artisan_distribution(sys::state &state)
void daily_update(sys::state &state, bool initiate_buildings)
void set_factory_priority(sys::state &state, dcon::factory_id f, int32_t priority)
float factory_primary_employment(sys::state const &state, dcon::factory_id f)
void register_construction_demand(sys::state &state, dcon::nation_id n, dcon::commodity_id commodity_type, float amount)
float update_factory_scale(sys::state &state, dcon::factory_fat_id fac, float max_production_scale, float raw_profit, float desired_raw_profit)
bool nation_has_closed_factories(sys::state &state, dcon::nation_id n)
float ideal_pound_conversion_rate(sys::state &state, dcon::nation_id n)
float get_artisan_distribution_slow(sys::state &state, dcon::nation_id n, dcon::commodity_id c)
float factory_output_multiplier(sys::state &state, dcon::factory_fat_id fac, dcon::nation_id n, dcon::province_id p)
float nation_pop_consumption(sys::state &state, dcon::nation_id n, dcon::commodity_id c)
float factory_min_e_input_available(sys::state &state, dcon::nation_id n, dcon::factory_type_fat_id fac_type)
float factory_type_build_cost(sys::state &state, dcon::nation_id n, dcon::factory_type_id factory_type)
int32_t previous_gdp_record_index(sys::state &state)
void register_intermediate_demand(sys::state &state, dcon::nation_id n, dcon::commodity_id commodity_type, float amount, economy_reason reason)
constexpr float subsistence_score_everyday
constexpr float day_1_derivative_non_factory
float estimate_gold_income(sys::state &state, dcon::nation_id n)
void update_single_factory_consumption(sys::state &state, dcon::factory_id f, dcon::nation_id n, dcon::province_id p, dcon::state_instance_id s, float mobilization_impact, float expected_min_wage, bool occupied)
void update_national_artisan_production(sys::state &state, dcon::nation_id n)
constexpr float day_1_build_time_modifier_non_factory
void fire_fixed_event(sys::state &state, std::vector< nations::fixed_event > const &v, int32_t primary_slot, slot_type pt, dcon::nation_id this_slot, int32_t from_slot, slot_type ft)
constexpr uint32_t pop_expand_factory
constexpr uint32_t destroy_factory
constexpr uint32_t pop_build_factory
float sqrt(float x) noexcept
void army_arrives_in_province(sys::state &state, dcon::army_id a, dcon::province_id p, crossing_type crossing, dcon::land_battle_id from)
float mobilization_impact(sys::state const &state, dcon::nation_id n)
void move_land_to_merge(sys::state &state, dcon::nation_id by, dcon::army_id a, dcon::province_id start, dcon::province_id dest)
dcon::regiment_id create_new_regiment(sys::state &state, dcon::nation_id n, dcon::unit_type_id t)
constexpr uint8_t level_in_sphere
constexpr uint8_t level_mask
std::string int_to_tag(uint32_t v)
float get_foreign_investment(sys::state &state, dcon::nation_id n)
float tariff_efficiency(sys::state &state, dcon::nation_id n)
dcon::nation_id owner_of_pop(sys::state const &state, dcon::pop_id pop_ids)
float tax_efficiency(sys::state &state, dcon::nation_id n)
void post(sys::state &state, message &&m)
void for_each_province_in_state_instance(sys::state &state, dcon::state_instance_id s, F const &func)
bool state_is_coastal(sys::state &state, dcon::state_instance_id s)
void for_each_land_province(sys::state &state, F const &func)
constexpr uint16_t to_map_id(dcon::province_id id)
bool generic_can_build_railroads(sys::state &state, dcon::province_id id, dcon::nation_id n)
uint64_t get_random(sys::state const &state, uint32_t value_in)
MOD_PROV_LIST constexpr uint32_t count
void add_modifier_to_nation(sys::state &state, dcon::nation_id target_nation, dcon::modifier_id mod_id, sys::date expiration)
void add_line(sys::state &state, layout_base &dest, dcon::text_key txt, int32_t indent)
std::string produce_simple_string(sys::state const &state, dcon::text_key id)
dcon::text_key get_name(sys::state &state, dcon::nation_id id)
int32_t to_generic(dcon::province_id v)
bool evaluate(sys::state &state, dcon::trigger_key key, int32_t primary, int32_t this_slot, int32_t from_slot)
T select(bool v, T a, T b)
float to_float(int32_t a)
static constexpr uint32_t set_size
float per_secondary_worker