aboutsummaryrefslogtreecommitdiff
path: root/src/openvic-simulation/map/State.cpp
blob: 1c49ed76dbbce2e578e88a2d44632849a31d9e96 (plain) (blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
#include "State.hpp"

#include "openvic-simulation/country/Country.hpp"
#include "openvic-simulation/map/Map.hpp"
#include "openvic-simulation/map/ProvinceInstance.hpp"
#include "openvic-simulation/map/Region.hpp"

using namespace OpenVic;

State::State(
   StateSet const& new_state_set, Country const* owner, ProvinceInstance* capital, std::vector<ProvinceInstance*>&& provinces,
   ProvinceInstance::colony_status_t colony_status
) : state_set { new_state_set }, owner { owner }, capital { capital }, provinces { std::move(provinces) },
   colony_status { colony_status } {}

void State::update_gamestate() {
   total_population = 0;

   for (ProvinceInstance const* province : provinces) {
      total_population += province->get_total_population();
   }
}

/* Whether two provinces in the same region should be grouped into the same state or not.
 * (Assumes both provinces non-null.) */
static bool provinces_belong_in_same_state(ProvinceInstance const* lhs, ProvinceInstance const* rhs) {
   return lhs->get_owner() == rhs->get_owner() && lhs->get_colony_status() == rhs->get_colony_status();
}

StateSet::StateSet(Region const& new_region) : region { new_region }, states {} {}

size_t StateSet::get_state_count() const {
   return states.size();
}

void StateSet::update_gamestate() {
   for (State& state : states) {
      state.update_gamestate();
   }
}

bool StateManager::add_state_set(Map& map, Region const& region) {
   if (region.get_meta()) {
      Logger::error("Cannot use meta region \"", region.get_identifier(), "\" as state template!");
      return false;
   }

   if (region.empty()) {
      Logger::error("Cannot use empty region \"", region.get_identifier(), "\" as state template!");
      return false;
   }

   std::vector<std::vector<ProvinceInstance*>> temp_provinces;

   for (ProvinceDefinition const* province : region.get_provinces()) {

      ProvinceInstance* province_instance = map.get_province_instance_from_const(province);

      // add to existing state if shared owner & status...
      for (std::vector<ProvinceInstance*>& provinces : temp_provinces) {
         if (provinces_belong_in_same_state(provinces.front(), province_instance)) {
            provinces.push_back(province_instance);
            // jump to the end of the outer loop, skipping the new state code
            goto loop_end;
         }
      }

      // ...otherwise start a new state
      temp_provinces.push_back({ province_instance });

   loop_end:;
      /* Either the province was added to an existing state and the program jumped to here,
       * or it was used to create a new state and the program arrived here normally. */
   }

   state_sets.push_back({ region });

   StateSet& state_set = state_sets.back();

   // Reserve space for the maximum number of states (one per province)
   state_set.states.reserve(region.size());

   for (std::vector<ProvinceInstance*>& provinces : temp_provinces) {
      ProvinceInstance* capital = provinces.front();

      state_set.states.push_back(
         /* TODO: capital province logic */
         { state_set, capital->get_owner(), capital, std::move(provinces), capital->get_colony_status() }
      );

      State const& state = state_set.states.back();

      for (ProvinceInstance* province : state.get_provinces()) {
         province->set_state(&state);
      }
   }

   return true;
}

bool StateManager::generate_states(Map& map) {
   state_sets.clear();
   state_sets.reserve(map.get_region_count());

   bool ret = true;
   size_t state_count = 0;

   for (Region const& region : map.get_regions()) {
      if (!region.get_meta()) {
         if (add_state_set(map, region)) {
            state_count += state_sets.back().get_state_count();
         } else {
            ret = false;
         }
      }
   }

   Logger::info("Generated ", state_count, " states across ", state_sets.size(), " state sets.");

   return ret;
}

void StateManager::reset() {
   state_sets.clear();
}

void StateManager::update_gamestate() {
   for (StateSet& state_set : state_sets) {
      state_set.update_gamestate();
   }
}