src/openvic-simulation/map/State.cpp


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

#include "State.hpp"

#include "openvic-simulation/map/Map.hpp"

using namespace OpenVic;

State::State(
   Country const* owner, Province const* capital, Region::provinces_t&& provinces, Province::colony_status_t colony_status
) : owner { owner }, capital { capital }, provinces { std::move(provinces) }, colony_status { colony_status } {}

StateSet::StateSet(Region const* new_region) {
   if (region->get_meta()) {
      Logger::error("Cannot use meta region as state template!");
   }
   region = new_region;

   std::vector<Region::provinces_t> temp_provinces;
   bool in_state = false;

   for (Province* province : region->get_provinces()) {
      // add to existing state if shared owner & status...
      for (Region::provinces_t& provinces : temp_provinces) {
         if (provinces[0] == province) {
            provinces.push_back(province);
            in_state = true;
            break;
         }
      }
      if (in_state) {
         in_state = false;
      } else {
         // ...otherwise start a new state
         temp_provinces.push_back({ province });
      }
   }

   for (Region::provinces_t& provinces : temp_provinces) {
      states.push_back({
         /* TODO: capital province logic */
         provinces[0]->get_owner(), provinces[0], std::move(provinces), provinces[0]->get_colony_status()
      });
   }

   // Go back and assign each new state to its provinces.
   for (State const& state : states) {
      for (Province* province : state.get_provinces()) {
         province->set_state(&state);
      }
   }
}

bool StateSet::add_state(State&& state) {
   const auto existing = std::find(states.begin(), states.end(), state);
   if (existing != states.end()) {
      Logger::error("Attempted to add existing state!");
      return false;
   }
   states.push_back(std::move(state));
   return true;
}

bool StateSet::remove_state(State const* state) {
   const auto existing = std::find(states.begin(), states.end(), *state);
   if (existing == states.end()) {
      Logger::error("Attempted to remove non-existant state!");
      return false;
   }
   states.erase(existing);
   return true;
}

StateSet::states_t& StateSet::get_states() {
   return states;
}

void StateManager::generate_states(Map const& map) {
   regions.clear();
   regions.reserve(map.get_region_count());
   for(Region const& region : map.get_regions()) {
      regions.push_back(StateSet(&region));
   }
   Logger::info("Generated states.");
}