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
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
|
#include "Issue.hpp"
using namespace OpenVic;
using namespace OpenVic::NodeTools;
IssueGroup::IssueGroup(const std::string_view new_identifier) : HasIdentifier { new_identifier } {}
Issue::Issue(const std::string_view identifier, IssueGroup const& group)
: HasIdentifier { identifier }, group { group } {}
IssueGroup const& Issue::get_group() const {
return group;
}
ReformType::ReformType(const std::string_view new_identifier, bool uncivilised)
: HasIdentifier { new_identifier }, uncivilised { uncivilised } {}
ReformGroup::ReformGroup(const std::string_view identifier, ReformType const& type, bool ordered, bool administrative)
: IssueGroup { identifier }, type { type }, ordered { ordered }, administrative { administrative } {}
ReformType const& ReformGroup::get_type() const {
return type;
}
bool ReformGroup::is_ordered() const {
return ordered;
}
bool ReformGroup::is_administrative() const {
return administrative;
}
Reform::Reform(const std::string_view identifier, ReformGroup const& group, size_t ordinal)
: Issue { identifier, group }, ordinal { ordinal }, reform_group { group } {}
ReformGroup const& Reform::get_reform_group() const {
return reform_group;
}
ReformType const& Reform::get_type() const {
return get_reform_group().get_type();
}
size_t Reform::get_ordinal() const {
return ordinal;
}
IssueManager::IssueManager() : issue_groups { "issue groups" }, issues { "issues" },
reform_types { "reform types" }, reform_groups { "reform groups" }, reforms { "reforms" } {}
bool IssueManager::add_issue_group(const std::string_view identifier) {
if (identifier.empty()) {
Logger::error("Invalid issue group identifier - empty!");
return false;
}
return issue_groups.add_item({ identifier });
}
bool IssueManager::add_issue(const std::string_view identifier, IssueGroup const* group) {
if (identifier.empty()) {
Logger::error("Invalid issue identifier - empty!");
return false;
}
if (group == nullptr) {
Logger::error("Null issue group for ", identifier);
return false;
}
return issues.add_item({ identifier, *group });
}
bool IssueManager::add_reform_type(const std::string_view identifier, bool uncivilised) {
if (identifier.empty()) {
Logger::error("Invalid issue type identifier - empty!");
return false;
}
return reform_types.add_item({ identifier, uncivilised });
}
bool IssueManager::add_reform_group(const std::string_view identifier, ReformType const* type, bool ordered, bool administrative) {
if (identifier.empty()) {
Logger::error("Invalid issue group identifier - empty!");
return false;
}
if (type == nullptr) {
Logger::error("Null issue type for ", identifier);
return false;
}
return reform_groups.add_item({ identifier, *type, ordered, administrative });
}
bool IssueManager::add_reform(const std::string_view identifier, ReformGroup const* group, size_t ordinal) {
if (identifier.empty()) {
Logger::error("Invalid issue identifier - empty!");
return false;
}
if (group == nullptr) {
Logger::error("Null issue group for ", identifier);
return false;
}
return reforms.add_item({ identifier, *group, ordinal });
}
bool IssueManager::_load_issue_group(size_t& expected_issues, const std::string_view identifier, ast::NodeCPtr node) {
return expect_length([&expected_issues](size_t size) -> size_t {
expected_issues += size;
return size;
})(node) & add_issue_group(identifier);
}
bool IssueManager::_load_issue(const std::string_view identifier, IssueGroup const* group, ast::NodeCPtr node) {
//TODO: policy modifiers, policy rule changes
return add_issue(identifier, group);
}
bool IssueManager::_load_reform_group(size_t& expected_reforms, const std::string_view identifier, ReformType const* type, ast::NodeCPtr node) {
bool ordered = false, administrative = false;
bool ret = expect_dictionary_keys_and_length(
[&expected_reforms](size_t size) -> size_t {
expected_reforms += size;
return size;
}, ALLOW_OTHER_KEYS,
"next_step_only", ZERO_OR_ONE, decrement_callback(expected_reforms, expect_bool(assign_variable_callback(ordered))),
"administrative", ZERO_OR_ONE, decrement_callback(expected_reforms, expect_bool(assign_variable_callback(administrative)))
)(node);
ret &= add_reform_group(identifier, type, ordered, administrative);
return ret;
}
bool IssueManager::_load_reform(size_t& ordinal, const std::string_view identifier, ReformGroup const* group, ast::NodeCPtr node) {
//TODO: conditions to allow, policy modifiers, policy rule changes
return add_reform(identifier, group, ordinal);
}
/* REQUIREMENTS:
* POL-18, POL-19, POL-21, POL-22, POL-23, POL-24, POL-26, POL-27, POL-28, POL-29, POL-31, POL-32, POL-33,
* POL-35, POL-36, POL-37, POL-38, POL-40, POL-41, POL-43, POL-44, POL-45, POL-46, POL-48, POL-49, POL-50,
* POL-51, POL-52, POL-53, POL-55, POL-56, POL-57, POL-59, POL-60, POL-62, POL-63, POL-64, POL-66, POL-67,
* POL-68, POL-69, POL-71, POL-72, POL-73, POL-74, POL-75, POL-77, POL-78, POL-79, POL-80, POL-81, POL-83,
* POL-84, POL-85, POL-86, POL-87, POL-89, POL-90, POL-91, POL-92, POL-93, POL-95, POL-96, POL-97, POL-98,
* POL-99, POL-101, POL-102, POL-103, POL-104, POL-105, POL-107, POL-108, POL-109, POL-110, POL-111, POL-113,
* POL-113, POL-114, POL-115, POL-116
*/
bool IssueManager::load_issues_file(ast::NodeCPtr root) {
size_t expected_issue_groups = 0;
size_t expected_reform_groups = 0;
bool ret = expect_dictionary_reserve_length(reform_types,
[this, &expected_issue_groups, &expected_reform_groups](std::string_view key, ast::NodeCPtr value) -> bool {
if (key == "party_issues")
return expect_length(add_variable_callback(expected_issue_groups))(value);
else return expect_length(add_variable_callback(expected_reform_groups))(value) & add_reform_type(
key, key == "economic_reforms" || "education_reforms" || "military_reforms");
}
)(root);
lock_reform_types();
issue_groups.reserve(issue_groups.size() + expected_issue_groups);
reform_groups.reserve(reform_groups.size() + expected_reform_groups);
size_t expected_issues = 0;
size_t expected_reforms = 0;
ret &= expect_dictionary_reserve_length(issue_groups,
[this, &expected_issues, &expected_reforms](std::string_view type_key, ast::NodeCPtr type_value) -> bool {
if (type_key == "party_issues") {
return expect_dictionary([this, &expected_issues](std::string_view key, ast::NodeCPtr value) -> bool {
return _load_issue_group(expected_issues, key, value);
})(type_value);
} else {
ReformType const* reform_type = get_reform_type_by_identifier(type_key);
return expect_dictionary(
[this, reform_type, &expected_reforms](std::string_view key, ast::NodeCPtr value) -> bool {
return _load_reform_group(expected_reforms, key, reform_type, value);
}
)(type_value);
}
}
)(root);
lock_issue_groups();
lock_reform_groups();
issues.reserve(issues.size() + expected_issues);
reforms.reserve(reforms.size() + expected_reforms);
ret &= expect_dictionary([this](std::string_view type_key, ast::NodeCPtr type_value) -> bool {
return expect_dictionary([this, type_key](std::string_view group_key, ast::NodeCPtr group_value) -> bool {
if (type_key == "party_issues") {
IssueGroup const* issue_group = get_issue_group_by_identifier(group_key);
return expect_dictionary([this, issue_group](std::string_view key, ast::NodeCPtr value) -> bool {
bool ret = _load_issue(key, issue_group, value);
return ret;
})(group_value);
} else {
ReformGroup const* reform_group = get_reform_group_by_identifier(group_key);
size_t ordinal = 0;
return expect_dictionary([this, reform_group, &ordinal](std::string_view key, ast::NodeCPtr value) -> bool {
if (key == "next_step_only" || key == "administrative") return true;
bool ret = _load_reform(ordinal, key, reform_group, value);
ordinal++;
return ret;
})(group_value);
}
})(type_value);
})(root);
lock_issues();
lock_reforms();
return ret;
}
|
zaaarf