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
132
133
134
135
136
137
138
139
140
141
142
|
#include "Religion.hpp"
#include <cassert>
using namespace OpenVic;
using namespace OpenVic::NodeTools;
ReligionGroup::ReligionGroup(const std::string_view new_identifier) : HasIdentifier { new_identifier } {}
Religion::Religion(const std::string_view new_identifier, colour_t new_colour,
ReligionGroup const& new_group, icon_t new_icon, bool new_pagan)
: HasIdentifierAndColour { new_identifier, new_colour, true },
group { new_group },
icon { new_icon },
pagan { new_pagan } {
assert(icon > 0);
}
ReligionGroup const& Religion::get_group() const {
return group;
}
Religion::icon_t Religion::get_icon() const {
return icon;
}
bool Religion::get_pagan() const {
return pagan;
}
ReligionManager::ReligionManager()
: religion_groups { "religion groups" },
religions { "religions" } {}
bool ReligionManager::add_religion_group(const std::string_view identifier) {
if (identifier.empty()) {
Logger::error("Invalid religion group identifier - empty!");
return false;
}
return religion_groups.add_item({ identifier });
}
void ReligionManager::lock_religion_groups() {
religion_groups.lock();
}
ReligionGroup const* ReligionManager::get_religion_group_by_identifier(const std::string_view identifier) const {
return religion_groups.get_item_by_identifier(identifier);
}
size_t ReligionManager::get_religion_group_count() const {
return religion_groups.size();
}
std::vector<ReligionGroup> const& ReligionManager::get_religion_groups() const {
return religion_groups.get_items();
}
bool ReligionManager::add_religion(const std::string_view identifier, colour_t colour, ReligionGroup const* group, Religion::icon_t icon, bool pagan) {
if (!religion_groups.is_locked()) {
Logger::error("Cannot register religions until religion groups are locked!");
return false;
}
if (identifier.empty()) {
Logger::error("Invalid religion identifier - empty!");
return false;
}
if (group == nullptr) {
Logger::error("Null religion group for ", identifier);
return false;
}
if (colour > MAX_COLOUR_RGB) {
Logger::error("Invalid religion colour for ", identifier, ": ", colour_to_hex_string(colour));
return false;
}
if (icon <= 0) {
Logger::error("Invalid religion icon for ", identifier, ": ", icon);
return false;
}
return religions.add_item({ identifier, colour, *group, icon, pagan });
}
void ReligionManager::lock_religions() {
religions.lock();
}
Religion const* ReligionManager::get_religion_by_identifier(const std::string_view identifier) const {
return religions.get_item_by_identifier(identifier);
}
size_t ReligionManager::get_religion_count() const {
return religions.size();
}
std::vector<Religion> const& ReligionManager::get_religions() const {
return religions.get_items();
}
bool ReligionManager::load_religion_file(ast::NodeCPtr root) {
size_t total_expected_religions = 0;
bool ret = expect_dictionary_reserve_length(
religion_groups,
[this, &total_expected_religions](std::string_view key, ast::NodeCPtr value) -> bool {
bool ret = expect_list_and_length(
[&total_expected_religions](size_t size) -> size_t {
total_expected_religions += size;
return 0;
},
success_callback
)(value);
ret &= add_religion_group(key);
return ret;
}
)(root);
lock_religion_groups();
religions.reserve(religions.size() + total_expected_religions);
ret &= expect_dictionary(
[this](std::string_view religion_group_key, ast::NodeCPtr religion_group_value) -> bool {
ReligionGroup const* religion_group = get_religion_group_by_identifier(religion_group_key);
return expect_dictionary(
[this, religion_group](std::string_view key, ast::NodeCPtr value) -> bool {
colour_t colour = NULL_COLOUR;
Religion::icon_t icon = 0;
bool pagan = false;
bool ret = expect_dictionary_keys(
"icon", ONE_EXACTLY, expect_uint(assign_variable_callback_uint("religion icon", icon)),
"color", ONE_EXACTLY, expect_colour(assign_variable_callback(colour)),
"pagan", ZERO_OR_ONE, expect_bool(assign_variable_callback(pagan))
)(value);
ret &= add_religion(key, colour, religion_group, icon, pagan);
return ret;
}
)(religion_group_value);
}
)(root);
lock_religions();
return ret;
}
|
zaaarf