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
216
217
218
|
#include "Issue.hpp"
using namespace OpenVic;
using namespace OpenVic::NodeTools;
IssueGroup::IssueGroup(std::string_view new_identifier) : HasIdentifier { new_identifier } {}
Issue::Issue(std::string_view new_identifier, ModifierValue&& new_values, IssueGroup const& new_group, RuleSet&& new_rules, bool new_jingoism)
: Modifier { new_identifier, std::move(new_values), 0 }, group { new_group }, rules { std::move(new_rules) },
jingoism { new_jingoism } {}
ReformType::ReformType(std::string_view new_identifier, bool new_uncivilised)
: HasIdentifier { new_identifier }, uncivilised { new_uncivilised } {}
ReformGroup::ReformGroup(std::string_view new_identifier, ReformType const& new_type, bool new_ordered, bool new_administrative)
: IssueGroup { new_identifier }, type { new_type }, ordered { new_ordered }, administrative { new_administrative } {}
Reform::Reform(
std::string_view new_identifier, ModifierValue&& new_values, ReformGroup const& new_group, size_t new_ordinal,
RuleSet&& new_rules, tech_cost_t new_technology_cost
) : Issue { new_identifier, std::move(new_values), new_group, std::move(new_rules), false },
ordinal { new_ordinal }, reform_group { new_group }, technology_cost { new_technology_cost } {}
bool IssueManager::add_issue_group(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(std::string_view identifier, ModifierValue&& values, IssueGroup const* group, RuleSet&& rules, bool jingoism) {
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, std::move(values), *group, std::move(rules), jingoism });
}
bool IssueManager::add_reform_type(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(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(
std::string_view identifier, ModifierValue&& values, ReformGroup const* group, size_t ordinal,
RuleSet&& rules, Reform::tech_cost_t technology_cost
) {
if (identifier.empty()) {
Logger::error("Invalid issue identifier - empty!");
return false;
}
if (group == nullptr) {
Logger::error("Null issue group for ", identifier);
return false;
}
if (group->get_type().is_uncivilised()) {
if (technology_cost <= 0) {
Logger::warning("Non-positive technology cost ", technology_cost, " found in uncivilised reform ", identifier, "!");
}
} else if (technology_cost != 0) {
Logger::warning("Non-zero technology cost ", technology_cost, " found in civilised reform ", identifier, "!");
}
return reforms.add_item({ identifier, std::move(values), *group, ordinal, std::move(rules), technology_cost });
}
bool IssueManager::_load_issue_group(size_t& expected_issues, std::string_view identifier, ast::NodeCPtr node) {
return expect_length(add_variable_callback(expected_issues))(node)
& add_issue_group(identifier);
}
bool IssueManager::_load_issue(
ModifierManager const& modifier_manager, RuleManager const& rule_manager, std::string_view identifier,
IssueGroup const* group, ast::NodeCPtr node
) {
ModifierValue values;
RuleSet rules;
bool jingoism = false;
bool ret = modifier_manager.expect_modifier_value_and_keys(move_variable_callback(values),
"is_jingoism", ZERO_OR_ONE, expect_bool(assign_variable_callback(jingoism)),
"rules", ZERO_OR_ONE, rule_manager.expect_rule_set(move_variable_callback(rules))
)(node);
ret &= add_issue(identifier, std::move(values), group, std::move(rules), jingoism);
return ret;
}
bool IssueManager::_load_reform_group(
size_t& expected_reforms, std::string_view identifier, ReformType const* type, ast::NodeCPtr node
) {
bool ordered = false, administrative = false;
bool ret = expect_dictionary_keys_and_default(
increment_callback(expected_reforms),
"next_step_only", ZERO_OR_ONE, expect_bool(assign_variable_callback(ordered)),
"administrative", ZERO_OR_ONE, expect_bool(assign_variable_callback(administrative))
)(node);
ret &= add_reform_group(identifier, type, ordered, administrative);
return ret;
}
bool IssueManager::_load_reform(
ModifierManager const& modifier_manager, RuleManager const& rule_manager, size_t ordinal, std::string_view identifier,
ReformGroup const* group, ast::NodeCPtr node
) {
// TODO: conditions to allow, policy rule changes
ModifierValue values;
RuleSet rules;
Reform::tech_cost_t technology_cost = 0;
bool ret = modifier_manager.expect_modifier_value_and_keys(move_variable_callback(values),
"technology_cost", ZERO_OR_ONE, expect_uint(assign_variable_callback(technology_cost)),
"allow", ZERO_OR_ONE, success_callback, //TODO: allow block
"rules", ZERO_OR_ONE, rule_manager.expect_rule_set(move_variable_callback(rules)),
"on_execute", ZERO_OR_MORE, success_callback //TODO: trigger/effect blocks
)(node);
ret &= add_reform(identifier, std::move(values), group, ordinal, std::move(rules), technology_cost);
return ret;
}
/* 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(ModifierManager const& modifier_manager, RuleManager const& rule_manager, 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, &modifier_manager, &rule_manager](std::string_view type_key, ast::NodeCPtr type_value) -> bool {
return expect_dictionary([this, &modifier_manager, &rule_manager, 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, &modifier_manager, &rule_manager, issue_group](std::string_view key, ast::NodeCPtr value) -> bool {
return _load_issue(modifier_manager, rule_manager, key, issue_group, value);
})(group_value);
} else {
ReformGroup const* reform_group = get_reform_group_by_identifier(group_key);
size_t ordinal = 0;
return expect_dictionary([this, &modifier_manager, &rule_manager, reform_group, &ordinal](std::string_view key, ast::NodeCPtr value) -> bool {
if (key == "next_step_only" || key == "administrative") {
return true;
}
return _load_reform(modifier_manager, rule_manager, ordinal++, key, reform_group, value);
})(group_value);
}
})(type_value);
})(root);
lock_issues();
lock_reforms();
return ret;
}
|
zaaarf