Project Alice
Loading...
Searching...
No Matches
serialization.cpp
Go to the documentation of this file.
1#include "dcon_generated.hpp"
2#include "system_state.hpp"
3#include "serialization.hpp"
4#include <random>
5#include <ctime>
6
7#define ZSTD_STATIC_LINKING_ONLY
8#define XXH_NAMESPACE ZSTD_
9
10#include "blake2.h"
11#include "zstd.h"
12
13namespace sys {
14
15uint8_t const* read_scenario_header(uint8_t const* ptr_in, scenario_header& header_out) {
16 uint32_t length = 0;
17 memcpy(&length, ptr_in, sizeof(uint32_t));
18 memcpy(&header_out, ptr_in + sizeof(uint32_t), std::min(length, uint32_t(sizeof(scenario_header))));
19 return ptr_in + sizeof(uint32_t) + length;
20}
21
22uint8_t const* read_save_header(uint8_t const* ptr_in, save_header& header_out) {
23 uint32_t length = 0;
24 memcpy(&length, ptr_in, sizeof(uint32_t));
25 memcpy(&header_out, ptr_in + sizeof(uint32_t), std::min(length, uint32_t(sizeof(save_header))));
26 return ptr_in + sizeof(uint32_t) + length;
27}
28
29uint8_t* write_scenario_header(uint8_t* ptr_in, scenario_header const& header_in) {
30 uint32_t length = uint32_t(sizeof(scenario_header));
31 memcpy(ptr_in, &length, sizeof(uint32_t));
32 memcpy(ptr_in + sizeof(uint32_t), &header_in, sizeof(scenario_header));
33 return ptr_in + sizeof_scenario_header(header_in);
34}
35uint8_t* write_save_header(uint8_t* ptr_in, save_header const& header_in) {
36 uint32_t length = uint32_t(sizeof(save_header));
37 memcpy(ptr_in, &length, sizeof(uint32_t));
38 memcpy(ptr_in + sizeof(uint32_t), &header_in, sizeof(save_header));
39 return ptr_in + sizeof_save_header(header_in);
40}
41
42size_t sizeof_scenario_header(scenario_header const& header_in) {
43 return sizeof(uint32_t) + sizeof(scenario_header);
44}
45
46size_t sizeof_save_header(save_header const& header_in) {
47 return sizeof(uint32_t) + sizeof(save_header);
48}
49
50void read_mod_path(uint8_t const* ptr_in, uint8_t const* lim, native_string& path_out) {
51 uint32_t length = 0;
52 if(size_t(lim - ptr_in) < sizeof(uint32_t))
53 return;
54
55 memcpy(&length, ptr_in, sizeof(uint32_t));
56 ptr_in += sizeof(uint32_t);
57
58 if(size_t(lim - ptr_in) < sizeof(uint32_t) + length * sizeof(native_char))
59 return;
60
61 path_out = native_string(native_string_view(reinterpret_cast<native_char const*>(ptr_in), length));
62}
63uint8_t const* load_mod_path(uint8_t const* ptr_in, sys::state& state) {
64 uint32_t length = 0;
65 memcpy(&length, ptr_in, sizeof(uint32_t));
66 ptr_in += sizeof(uint32_t);
67
68 simple_fs::restore_state(state.common_fs, native_string_view(reinterpret_cast<native_char const*>(ptr_in), length));
69 return ptr_in + length * sizeof(native_char);
70}
71uint8_t* write_mod_path(uint8_t* ptr_in, native_string const& path_in) {
72 uint32_t length = uint32_t(path_in.length());
73 memcpy(ptr_in, &length, sizeof(uint32_t));
74 ptr_in += sizeof(uint32_t);
75 memcpy(ptr_in, path_in.c_str(), length * sizeof(native_char));
76 ptr_in += length * sizeof(native_char);
77 return ptr_in;
78}
79size_t sizeof_mod_path(native_string const& path_in) {
80 size_t sz = 0;
81 uint32_t length = uint32_t(path_in.length());
82 sz += sizeof(uint32_t);
83 sz += length * sizeof(native_char);
84 return sz;
85}
86
87mod_identifier extract_mod_information(uint8_t const* ptr_in, uint64_t file_size) {
88 scenario_header h;
89
90 auto file_end = ptr_in + file_size;
91
92 if(file_size > sizeof_scenario_header(h)) {
93 ptr_in = read_scenario_header(ptr_in, h);
94 }
95
96 if(h.version != sys::scenario_file_version) {
97 return mod_identifier{ native_string{}, 0, 0 };
98 }
99
100 native_string mod_path;
101 read_mod_path(ptr_in, file_end, mod_path);
102
103 return mod_identifier{ mod_path, h.timestamp, h.count };
104}
105
106uint8_t* write_compressed_section(uint8_t* ptr_out, uint8_t const* ptr_in, uint32_t uncompressed_size) {
107 uint32_t decompressed_length = uncompressed_size;
108
109 uint32_t section_length = uint32_t(ZSTD_compress(ptr_out + sizeof(uint32_t) * 2, ZSTD_compressBound(uncompressed_size), ptr_in,
110 uncompressed_size, 0)); // write compressed data
111
112 memcpy(ptr_out, &section_length, sizeof(uint32_t));
113 memcpy(ptr_out + sizeof(uint32_t), &decompressed_length, sizeof(uint32_t));
114
115 return ptr_out + sizeof(uint32_t) * 2 + section_length;
116}
117
118template<typename T>
119uint8_t const* with_decompressed_section(uint8_t const* ptr_in, T const& function) {
120 uint32_t section_length = 0;
121 uint32_t decompressed_length = 0;
122 memcpy(&section_length, ptr_in, sizeof(uint32_t));
123 memcpy(&decompressed_length, ptr_in + sizeof(uint32_t), sizeof(uint32_t));
124
125 uint8_t* temp_buffer = new uint8_t[decompressed_length];
126 // TODO: allocate memory for decompression and decompress into it
127
128 ZSTD_decompress(temp_buffer, decompressed_length, ptr_in + sizeof(uint32_t) * 2, section_length);
129
130 // function(ptr_in + sizeof(uint32_t) * 2, decompressed_length);
131 function(temp_buffer, decompressed_length);
132
133 delete[] temp_buffer;
134 return ptr_in + sizeof(uint32_t) * 2 + section_length;
135}
136
137uint8_t const* read_scenario_section(uint8_t const* ptr_in, uint8_t const* section_end, sys::state& state) {
138 // hand-written contribution
139 { // map
140 ptr_in = memcpy_deserialize(ptr_in, state.map_state.map_data.size_x);
141 ptr_in = memcpy_deserialize(ptr_in, state.map_state.map_data.size_y);
142 ptr_in = deserialize(ptr_in, state.map_state.map_data.river_vertices);
143 ptr_in = deserialize(ptr_in, state.map_state.map_data.river_starts);
144 ptr_in = deserialize(ptr_in, state.map_state.map_data.river_counts);
145 ptr_in = deserialize(ptr_in, state.map_state.map_data.coastal_vertices);
146 ptr_in = deserialize(ptr_in, state.map_state.map_data.coastal_starts);
147 ptr_in = deserialize(ptr_in, state.map_state.map_data.coastal_counts);
148 ptr_in = deserialize(ptr_in, state.map_state.map_data.border_vertices);
149 ptr_in = deserialize(ptr_in, state.map_state.map_data.borders);
150 ptr_in = deserialize(ptr_in, state.map_state.map_data.terrain_id_map);
151 ptr_in = deserialize(ptr_in, state.map_state.map_data.province_id_map);
152 ptr_in = deserialize(ptr_in, state.map_state.map_data.province_area);
153 ptr_in = deserialize(ptr_in, state.map_state.map_data.diagonal_borders);
154 }
155 {
156 memcpy(&(state.defines), ptr_in, sizeof(parsing::defines));
157 ptr_in += sizeof(parsing::defines);
158 }
159 {
160 memcpy(&(state.economy_definitions), ptr_in, sizeof(economy::global_economy_state));
161 ptr_in += sizeof(economy::global_economy_state);
162 }
163 { // culture definitions
164 ptr_in = deserialize(ptr_in, state.culture_definitions.party_issues);
165 ptr_in = deserialize(ptr_in, state.culture_definitions.political_issues);
166 ptr_in = deserialize(ptr_in, state.culture_definitions.social_issues);
167 ptr_in = deserialize(ptr_in, state.culture_definitions.military_issues);
168 ptr_in = deserialize(ptr_in, state.culture_definitions.economic_issues);
169 ptr_in = deserialize(ptr_in, state.culture_definitions.tech_folders);
170 ptr_in = deserialize(ptr_in, state.culture_definitions.crimes);
171 ptr_in = memcpy_deserialize(ptr_in, state.culture_definitions.artisans);
172 ptr_in = memcpy_deserialize(ptr_in, state.culture_definitions.capitalists);
173 ptr_in = memcpy_deserialize(ptr_in, state.culture_definitions.farmers);
174 ptr_in = memcpy_deserialize(ptr_in, state.culture_definitions.laborers);
175 ptr_in = memcpy_deserialize(ptr_in, state.culture_definitions.clergy);
176 ptr_in = memcpy_deserialize(ptr_in, state.culture_definitions.soldiers);
177 ptr_in = memcpy_deserialize(ptr_in, state.culture_definitions.officers);
178 ptr_in = memcpy_deserialize(ptr_in, state.culture_definitions.slaves);
179 ptr_in = memcpy_deserialize(ptr_in, state.culture_definitions.bureaucrat);
180 ptr_in = memcpy_deserialize(ptr_in, state.culture_definitions.aristocrat);
181 ptr_in = memcpy_deserialize(ptr_in, state.culture_definitions.primary_factory_worker);
182 ptr_in = memcpy_deserialize(ptr_in, state.culture_definitions.secondary_factory_worker);
183 ptr_in = memcpy_deserialize(ptr_in, state.culture_definitions.officer_leadership_points);
184 ptr_in = memcpy_deserialize(ptr_in, state.culture_definitions.bureaucrat_tax_efficiency);
185 ptr_in = memcpy_deserialize(ptr_in, state.culture_definitions.conservative);
186 ptr_in = memcpy_deserialize(ptr_in, state.culture_definitions.jingoism);
187 ptr_in = memcpy_deserialize(ptr_in, state.culture_definitions.promotion_chance);
188 ptr_in = memcpy_deserialize(ptr_in, state.culture_definitions.demotion_chance);
189 ptr_in = memcpy_deserialize(ptr_in, state.culture_definitions.migration_chance);
190 ptr_in = memcpy_deserialize(ptr_in, state.culture_definitions.colonialmigration_chance);
191 ptr_in = memcpy_deserialize(ptr_in, state.culture_definitions.emigration_chance);
192 ptr_in = memcpy_deserialize(ptr_in, state.culture_definitions.assimilation_chance);
193 ptr_in = memcpy_deserialize(ptr_in, state.culture_definitions.conversion_chance);
194 }
195 { // military definitions
196 ptr_in = memcpy_deserialize(ptr_in, state.military_definitions.first_background_trait);
197 ptr_in = deserialize(ptr_in, state.military_definitions.unit_base_definitions);
198 ptr_in = memcpy_deserialize(ptr_in, state.military_definitions.base_army_unit);
199 ptr_in = memcpy_deserialize(ptr_in, state.military_definitions.base_naval_unit);
200 ptr_in = memcpy_deserialize(ptr_in, state.military_definitions.standard_civil_war);
201 ptr_in = memcpy_deserialize(ptr_in, state.military_definitions.standard_great_war);
202 ptr_in = memcpy_deserialize(ptr_in, state.military_definitions.standard_status_quo);
203 ptr_in = memcpy_deserialize(ptr_in, state.military_definitions.liberate);
204 ptr_in = memcpy_deserialize(ptr_in, state.military_definitions.uninstall_communist_gov);
205 ptr_in = memcpy_deserialize(ptr_in, state.military_definitions.crisis_colony);
206 ptr_in = memcpy_deserialize(ptr_in, state.military_definitions.crisis_liberate);
207 ptr_in = memcpy_deserialize(ptr_in, state.military_definitions.irregular);
208 ptr_in = memcpy_deserialize(ptr_in, state.military_definitions.infantry);
209 ptr_in = memcpy_deserialize(ptr_in, state.military_definitions.artillery);
210 }
211 { // national definitions
212 ptr_in = deserialize(ptr_in, state.national_definitions.flag_variable_names);
213 ptr_in = deserialize(ptr_in, state.national_definitions.global_flag_variable_names);
214 ptr_in = deserialize(ptr_in, state.national_definitions.variable_names);
215 ptr_in = deserialize(ptr_in, state.national_definitions.triggered_modifiers);
216 ptr_in = memcpy_deserialize(ptr_in, state.national_definitions.rebel_id);
217 ptr_in = memcpy_deserialize(ptr_in, state.national_definitions.very_easy_player);
218 ptr_in = memcpy_deserialize(ptr_in, state.national_definitions.easy_player);
219 ptr_in = memcpy_deserialize(ptr_in, state.national_definitions.hard_player);
220 ptr_in = memcpy_deserialize(ptr_in, state.national_definitions.very_hard_player);
221 ptr_in = memcpy_deserialize(ptr_in, state.national_definitions.very_easy_ai);
222 ptr_in = memcpy_deserialize(ptr_in, state.national_definitions.easy_ai);
223 ptr_in = memcpy_deserialize(ptr_in, state.national_definitions.hard_ai);
224 ptr_in = memcpy_deserialize(ptr_in, state.national_definitions.very_hard_ai);
225 ptr_in = memcpy_deserialize(ptr_in, state.national_definitions.overseas);
226 ptr_in = memcpy_deserialize(ptr_in, state.national_definitions.coastal);
227 ptr_in = memcpy_deserialize(ptr_in, state.national_definitions.non_coastal);
228 ptr_in = memcpy_deserialize(ptr_in, state.national_definitions.coastal_sea);
229 ptr_in = memcpy_deserialize(ptr_in, state.national_definitions.sea_zone);
230 ptr_in = memcpy_deserialize(ptr_in, state.national_definitions.land_province);
231 ptr_in = memcpy_deserialize(ptr_in, state.national_definitions.blockaded);
232 ptr_in = memcpy_deserialize(ptr_in, state.national_definitions.no_adjacent_controlled);
233 ptr_in = memcpy_deserialize(ptr_in, state.national_definitions.core);
234 ptr_in = memcpy_deserialize(ptr_in, state.national_definitions.has_siege);
235 ptr_in = memcpy_deserialize(ptr_in, state.national_definitions.occupied);
236 ptr_in = memcpy_deserialize(ptr_in, state.national_definitions.nationalism);
237 ptr_in = memcpy_deserialize(ptr_in, state.national_definitions.infrastructure);
238 ptr_in = memcpy_deserialize(ptr_in, state.national_definitions.base_values);
239 ptr_in = memcpy_deserialize(ptr_in, state.national_definitions.war);
240 ptr_in = memcpy_deserialize(ptr_in, state.national_definitions.peace);
241 ptr_in = memcpy_deserialize(ptr_in, state.national_definitions.disarming);
242 ptr_in = memcpy_deserialize(ptr_in, state.national_definitions.war_exhaustion);
243 ptr_in = memcpy_deserialize(ptr_in, state.national_definitions.badboy);
244 ptr_in = memcpy_deserialize(ptr_in, state.national_definitions.debt_default_to);
245 ptr_in = memcpy_deserialize(ptr_in, state.national_definitions.bad_debter);
246 ptr_in = memcpy_deserialize(ptr_in, state.national_definitions.great_power);
247 ptr_in = memcpy_deserialize(ptr_in, state.national_definitions.second_power);
248 ptr_in = memcpy_deserialize(ptr_in, state.national_definitions.civ_nation);
249 ptr_in = memcpy_deserialize(ptr_in, state.national_definitions.unciv_nation);
250 ptr_in = memcpy_deserialize(ptr_in, state.national_definitions.average_literacy);
251 ptr_in = memcpy_deserialize(ptr_in, state.national_definitions.plurality);
252 ptr_in = memcpy_deserialize(ptr_in, state.national_definitions.generalised_debt_default);
253 ptr_in = memcpy_deserialize(ptr_in, state.national_definitions.total_occupation);
254 ptr_in = memcpy_deserialize(ptr_in, state.national_definitions.total_blockaded);
255 ptr_in = memcpy_deserialize(ptr_in, state.national_definitions.in_bankrupcy);
256 ptr_in = memcpy_deserialize(ptr_in, state.national_definitions.num_allocated_national_variables);
257 ptr_in = memcpy_deserialize(ptr_in, state.national_definitions.num_allocated_national_flags);
258 ptr_in = memcpy_deserialize(ptr_in, state.national_definitions.num_allocated_global_flags);
259 ptr_in = memcpy_deserialize(ptr_in, state.national_definitions.flashpoint_focus);
260 ptr_in = memcpy_deserialize(ptr_in, state.national_definitions.flashpoint_amount);
261 ptr_in = deserialize(ptr_in, state.national_definitions.on_yearly_pulse);
262 ptr_in = deserialize(ptr_in, state.national_definitions.on_quarterly_pulse);
263 ptr_in = deserialize(ptr_in, state.national_definitions.on_battle_won);
264 ptr_in = deserialize(ptr_in, state.national_definitions.on_battle_lost);
265 ptr_in = deserialize(ptr_in, state.national_definitions.on_surrender);
266 ptr_in = deserialize(ptr_in, state.national_definitions.on_new_great_nation);
267 ptr_in = deserialize(ptr_in, state.national_definitions.on_lost_great_nation);
268 ptr_in = deserialize(ptr_in, state.national_definitions.on_election_tick);
269 ptr_in = deserialize(ptr_in, state.national_definitions.on_colony_to_state);
270 ptr_in = deserialize(ptr_in, state.national_definitions.on_state_conquest);
271 ptr_in = deserialize(ptr_in, state.national_definitions.on_colony_to_state_free_slaves);
272 ptr_in = deserialize(ptr_in, state.national_definitions.on_debtor_default);
273 ptr_in = deserialize(ptr_in, state.national_definitions.on_debtor_default_small);
274 ptr_in = deserialize(ptr_in, state.national_definitions.on_debtor_default_second);
275 ptr_in = deserialize(ptr_in, state.national_definitions.on_civilize);
276 ptr_in = deserialize(ptr_in, state.national_definitions.on_my_factories_nationalized);
277 ptr_in = deserialize(ptr_in, state.national_definitions.on_crisis_declare_interest);
278 ptr_in = deserialize(ptr_in, state.national_definitions.on_election_started);
279 ptr_in = deserialize(ptr_in, state.national_definitions.on_election_finished);
280 }
281 { // provincial definitions
282 ptr_in = deserialize(ptr_in, state.province_definitions.canals);
283 ptr_in = deserialize(ptr_in, state.province_definitions.canal_provinces);
284 ptr_in = deserialize(ptr_in, state.province_definitions.terrain_to_gfx_map);
285 ptr_in = memcpy_deserialize(ptr_in, state.province_definitions.first_sea_province);
286 ptr_in = memcpy_deserialize(ptr_in, state.province_definitions.europe);
287 ptr_in = memcpy_deserialize(ptr_in, state.province_definitions.asia);
288 ptr_in = memcpy_deserialize(ptr_in, state.province_definitions.africa);
289 ptr_in = memcpy_deserialize(ptr_in, state.province_definitions.north_america);
290 ptr_in = memcpy_deserialize(ptr_in, state.province_definitions.south_america);
291 ptr_in = memcpy_deserialize(ptr_in, state.province_definitions.oceania);
292 }
293 ptr_in = memcpy_deserialize(ptr_in, state.start_date);
294 ptr_in = memcpy_deserialize(ptr_in, state.end_date);
295 ptr_in = deserialize(ptr_in, state.trigger_data);
296 ptr_in = deserialize(ptr_in, state.trigger_data_indices);
297 ptr_in = deserialize(ptr_in, state.effect_data);
298 ptr_in = deserialize(ptr_in, state.effect_data_indices);
299 ptr_in = deserialize(ptr_in, state.value_modifier_segments);
300 ptr_in = deserialize(ptr_in, state.value_modifiers);
301 ptr_in = deserialize(ptr_in, state.key_data);
302 ptr_in = deserialize(ptr_in, state.untrans_key_to_text_sequence);
303
304 { // ui definitions
305 ptr_in = deserialize(ptr_in, state.ui_defs.gfx);
306 ptr_in = deserialize(ptr_in, state.ui_defs.textures);
307 ptr_in = deserialize(ptr_in, state.ui_defs.gui);
308 ptr_in = deserialize(ptr_in, state.font_collection.font_names);
309 ptr_in = deserialize(ptr_in, state.ui_defs.extensions);
310 }
311
312 // data container
313
314 dcon::load_record loaded;
315 std::byte const* start = reinterpret_cast<std::byte const*>(ptr_in);
316 state.world.deserialize(start, reinterpret_cast<std::byte const*>(section_end), loaded);
317
318 return section_end;
319}
320uint8_t* write_scenario_section(uint8_t* ptr_in, sys::state& state) {
321 // hand-written contribution
322 { // map
323 ptr_in = memcpy_serialize(ptr_in, state.map_state.map_data.size_x);
324 ptr_in = memcpy_serialize(ptr_in, state.map_state.map_data.size_y);
325 ptr_in = serialize(ptr_in, state.map_state.map_data.river_vertices);
326 ptr_in = serialize(ptr_in, state.map_state.map_data.river_starts);
327 ptr_in = serialize(ptr_in, state.map_state.map_data.river_counts);
328 ptr_in = serialize(ptr_in, state.map_state.map_data.coastal_vertices);
329 ptr_in = serialize(ptr_in, state.map_state.map_data.coastal_starts);
330 ptr_in = serialize(ptr_in, state.map_state.map_data.coastal_counts);
331 ptr_in = serialize(ptr_in, state.map_state.map_data.border_vertices);
332 ptr_in = serialize(ptr_in, state.map_state.map_data.borders);
333 ptr_in = serialize(ptr_in, state.map_state.map_data.terrain_id_map);
334 ptr_in = serialize(ptr_in, state.map_state.map_data.province_id_map);
335 ptr_in = serialize(ptr_in, state.map_state.map_data.province_area);
336 ptr_in = serialize(ptr_in, state.map_state.map_data.diagonal_borders);
337 }
338 {
339 memcpy(ptr_in, &(state.defines), sizeof(parsing::defines));
340 ptr_in += sizeof(parsing::defines);
341 }
342 {
343 memcpy(ptr_in, &(state.economy_definitions), sizeof(economy::global_economy_state));
344 ptr_in += sizeof(economy::global_economy_state);
345 }
346 { // culture definitions
347 ptr_in = serialize(ptr_in, state.culture_definitions.party_issues);
348 ptr_in = serialize(ptr_in, state.culture_definitions.political_issues);
349 ptr_in = serialize(ptr_in, state.culture_definitions.social_issues);
350 ptr_in = serialize(ptr_in, state.culture_definitions.military_issues);
351 ptr_in = serialize(ptr_in, state.culture_definitions.economic_issues);
352 ptr_in = serialize(ptr_in, state.culture_definitions.tech_folders);
353 ptr_in = serialize(ptr_in, state.culture_definitions.crimes);
354 ptr_in = memcpy_serialize(ptr_in, state.culture_definitions.artisans);
355 ptr_in = memcpy_serialize(ptr_in, state.culture_definitions.capitalists);
356 ptr_in = memcpy_serialize(ptr_in, state.culture_definitions.farmers);
357 ptr_in = memcpy_serialize(ptr_in, state.culture_definitions.laborers);
358 ptr_in = memcpy_serialize(ptr_in, state.culture_definitions.clergy);
359 ptr_in = memcpy_serialize(ptr_in, state.culture_definitions.soldiers);
360 ptr_in = memcpy_serialize(ptr_in, state.culture_definitions.officers);
361 ptr_in = memcpy_serialize(ptr_in, state.culture_definitions.slaves);
362 ptr_in = memcpy_serialize(ptr_in, state.culture_definitions.bureaucrat);
363 ptr_in = memcpy_serialize(ptr_in, state.culture_definitions.aristocrat);
364 ptr_in = memcpy_serialize(ptr_in, state.culture_definitions.primary_factory_worker);
365 ptr_in = memcpy_serialize(ptr_in, state.culture_definitions.secondary_factory_worker);
366 ptr_in = memcpy_serialize(ptr_in, state.culture_definitions.officer_leadership_points);
367 ptr_in = memcpy_serialize(ptr_in, state.culture_definitions.bureaucrat_tax_efficiency);
368 ptr_in = memcpy_serialize(ptr_in, state.culture_definitions.conservative);
369 ptr_in = memcpy_serialize(ptr_in, state.culture_definitions.jingoism);
370 ptr_in = memcpy_serialize(ptr_in, state.culture_definitions.promotion_chance);
371 ptr_in = memcpy_serialize(ptr_in, state.culture_definitions.demotion_chance);
372 ptr_in = memcpy_serialize(ptr_in, state.culture_definitions.migration_chance);
373 ptr_in = memcpy_serialize(ptr_in, state.culture_definitions.colonialmigration_chance);
374 ptr_in = memcpy_serialize(ptr_in, state.culture_definitions.emigration_chance);
375 ptr_in = memcpy_serialize(ptr_in, state.culture_definitions.assimilation_chance);
376 ptr_in = memcpy_serialize(ptr_in, state.culture_definitions.conversion_chance);
377 }
378 { // military definitions
379 ptr_in = memcpy_serialize(ptr_in, state.military_definitions.first_background_trait);
380 ptr_in = serialize(ptr_in, state.military_definitions.unit_base_definitions);
381 ptr_in = memcpy_serialize(ptr_in, state.military_definitions.base_army_unit);
382 ptr_in = memcpy_serialize(ptr_in, state.military_definitions.base_naval_unit);
383 ptr_in = memcpy_serialize(ptr_in, state.military_definitions.standard_civil_war);
384 ptr_in = memcpy_serialize(ptr_in, state.military_definitions.standard_great_war);
385 ptr_in = memcpy_serialize(ptr_in, state.military_definitions.standard_status_quo);
386 ptr_in = memcpy_serialize(ptr_in, state.military_definitions.liberate);
387 ptr_in = memcpy_serialize(ptr_in, state.military_definitions.uninstall_communist_gov);
388 ptr_in = memcpy_serialize(ptr_in, state.military_definitions.crisis_colony);
389 ptr_in = memcpy_serialize(ptr_in, state.military_definitions.crisis_liberate);
390 ptr_in = memcpy_serialize(ptr_in, state.military_definitions.irregular);
391 ptr_in = memcpy_serialize(ptr_in, state.military_definitions.infantry);
392 ptr_in = memcpy_serialize(ptr_in, state.military_definitions.artillery);
393 }
394 { // national definitions
395 ptr_in = serialize(ptr_in, state.national_definitions.flag_variable_names);
396 ptr_in = serialize(ptr_in, state.national_definitions.global_flag_variable_names);
397 ptr_in = serialize(ptr_in, state.national_definitions.variable_names);
398 ptr_in = serialize(ptr_in, state.national_definitions.triggered_modifiers);
399 ptr_in = memcpy_serialize(ptr_in, state.national_definitions.rebel_id);
400 ptr_in = memcpy_serialize(ptr_in, state.national_definitions.very_easy_player);
401 ptr_in = memcpy_serialize(ptr_in, state.national_definitions.easy_player);
402 ptr_in = memcpy_serialize(ptr_in, state.national_definitions.hard_player);
403 ptr_in = memcpy_serialize(ptr_in, state.national_definitions.very_hard_player);
404 ptr_in = memcpy_serialize(ptr_in, state.national_definitions.very_easy_ai);
405 ptr_in = memcpy_serialize(ptr_in, state.national_definitions.easy_ai);
406 ptr_in = memcpy_serialize(ptr_in, state.national_definitions.hard_ai);
407 ptr_in = memcpy_serialize(ptr_in, state.national_definitions.very_hard_ai);
408 ptr_in = memcpy_serialize(ptr_in, state.national_definitions.overseas);
409 ptr_in = memcpy_serialize(ptr_in, state.national_definitions.coastal);
410 ptr_in = memcpy_serialize(ptr_in, state.national_definitions.non_coastal);
411 ptr_in = memcpy_serialize(ptr_in, state.national_definitions.coastal_sea);
412 ptr_in = memcpy_serialize(ptr_in, state.national_definitions.sea_zone);
413 ptr_in = memcpy_serialize(ptr_in, state.national_definitions.land_province);
414 ptr_in = memcpy_serialize(ptr_in, state.national_definitions.blockaded);
415 ptr_in = memcpy_serialize(ptr_in, state.national_definitions.no_adjacent_controlled);
416 ptr_in = memcpy_serialize(ptr_in, state.national_definitions.core);
417 ptr_in = memcpy_serialize(ptr_in, state.national_definitions.has_siege);
418 ptr_in = memcpy_serialize(ptr_in, state.national_definitions.occupied);
419 ptr_in = memcpy_serialize(ptr_in, state.national_definitions.nationalism);
420 ptr_in = memcpy_serialize(ptr_in, state.national_definitions.infrastructure);
421 ptr_in = memcpy_serialize(ptr_in, state.national_definitions.base_values);
422 ptr_in = memcpy_serialize(ptr_in, state.national_definitions.war);
423 ptr_in = memcpy_serialize(ptr_in, state.national_definitions.peace);
424 ptr_in = memcpy_serialize(ptr_in, state.national_definitions.disarming);
425 ptr_in = memcpy_serialize(ptr_in, state.national_definitions.war_exhaustion);
426 ptr_in = memcpy_serialize(ptr_in, state.national_definitions.badboy);
427 ptr_in = memcpy_serialize(ptr_in, state.national_definitions.debt_default_to);
428 ptr_in = memcpy_serialize(ptr_in, state.national_definitions.bad_debter);
429 ptr_in = memcpy_serialize(ptr_in, state.national_definitions.great_power);
430 ptr_in = memcpy_serialize(ptr_in, state.national_definitions.second_power);
431 ptr_in = memcpy_serialize(ptr_in, state.national_definitions.civ_nation);
432 ptr_in = memcpy_serialize(ptr_in, state.national_definitions.unciv_nation);
433 ptr_in = memcpy_serialize(ptr_in, state.national_definitions.average_literacy);
434 ptr_in = memcpy_serialize(ptr_in, state.national_definitions.plurality);
435 ptr_in = memcpy_serialize(ptr_in, state.national_definitions.generalised_debt_default);
436 ptr_in = memcpy_serialize(ptr_in, state.national_definitions.total_occupation);
437 ptr_in = memcpy_serialize(ptr_in, state.national_definitions.total_blockaded);
438 ptr_in = memcpy_serialize(ptr_in, state.national_definitions.in_bankrupcy);
439 ptr_in = memcpy_serialize(ptr_in, state.national_definitions.num_allocated_national_variables);
440 ptr_in = memcpy_serialize(ptr_in, state.national_definitions.num_allocated_national_flags);
441 ptr_in = memcpy_serialize(ptr_in, state.national_definitions.num_allocated_global_flags);
442 ptr_in = memcpy_serialize(ptr_in, state.national_definitions.flashpoint_focus);
443 ptr_in = memcpy_serialize(ptr_in, state.national_definitions.flashpoint_amount);
444 ptr_in = serialize(ptr_in, state.national_definitions.on_yearly_pulse);
445 ptr_in = serialize(ptr_in, state.national_definitions.on_quarterly_pulse);
446 ptr_in = serialize(ptr_in, state.national_definitions.on_battle_won);
447 ptr_in = serialize(ptr_in, state.national_definitions.on_battle_lost);
448 ptr_in = serialize(ptr_in, state.national_definitions.on_surrender);
449 ptr_in = serialize(ptr_in, state.national_definitions.on_new_great_nation);
450 ptr_in = serialize(ptr_in, state.national_definitions.on_lost_great_nation);
451 ptr_in = serialize(ptr_in, state.national_definitions.on_election_tick);
452 ptr_in = serialize(ptr_in, state.national_definitions.on_colony_to_state);
453 ptr_in = serialize(ptr_in, state.national_definitions.on_state_conquest);
454 ptr_in = serialize(ptr_in, state.national_definitions.on_colony_to_state_free_slaves);
455 ptr_in = serialize(ptr_in, state.national_definitions.on_debtor_default);
456 ptr_in = serialize(ptr_in, state.national_definitions.on_debtor_default_small);
457 ptr_in = serialize(ptr_in, state.national_definitions.on_debtor_default_second);
458 ptr_in = serialize(ptr_in, state.national_definitions.on_civilize);
459 ptr_in = serialize(ptr_in, state.national_definitions.on_my_factories_nationalized);
460 ptr_in = serialize(ptr_in, state.national_definitions.on_crisis_declare_interest);
461 ptr_in = serialize(ptr_in, state.national_definitions.on_election_started);
462 ptr_in = serialize(ptr_in, state.national_definitions.on_election_finished);
463 }
464 { // provincial definitions
465 ptr_in = serialize(ptr_in, state.province_definitions.canals);
466 ptr_in = serialize(ptr_in, state.province_definitions.canal_provinces);
467 ptr_in = serialize(ptr_in, state.province_definitions.terrain_to_gfx_map);
468 ptr_in = memcpy_serialize(ptr_in, state.province_definitions.first_sea_province);
469 ptr_in = memcpy_serialize(ptr_in, state.province_definitions.europe);
470 ptr_in = memcpy_serialize(ptr_in, state.province_definitions.asia);
471 ptr_in = memcpy_serialize(ptr_in, state.province_definitions.africa);
472 ptr_in = memcpy_serialize(ptr_in, state.province_definitions.north_america);
473 ptr_in = memcpy_serialize(ptr_in, state.province_definitions.south_america);
474 ptr_in = memcpy_serialize(ptr_in, state.province_definitions.oceania);
475 }
476 ptr_in = memcpy_serialize(ptr_in, state.start_date);
477 ptr_in = memcpy_serialize(ptr_in, state.end_date);
478 ptr_in = serialize(ptr_in, state.trigger_data);
479 ptr_in = serialize(ptr_in, state.trigger_data_indices);
480 ptr_in = serialize(ptr_in, state.effect_data);
481 ptr_in = serialize(ptr_in, state.effect_data_indices);
482 ptr_in = serialize(ptr_in, state.value_modifier_segments);
483 ptr_in = serialize(ptr_in, state.value_modifiers);
484 ptr_in = serialize(ptr_in, state.key_data);
485 ptr_in = serialize(ptr_in, state.untrans_key_to_text_sequence);
486
487 { // ui definitions
488 ptr_in = serialize(ptr_in, state.ui_defs.gfx);
489 ptr_in = serialize(ptr_in, state.ui_defs.textures);
490 ptr_in = serialize(ptr_in, state.ui_defs.gui);
491 ptr_in = serialize(ptr_in, state.font_collection.font_names);
492 ptr_in = serialize(ptr_in, state.ui_defs.extensions);
493 }
494
495 dcon::load_record result = state.world.make_serialize_record_store_scenario();
496 std::byte* start = reinterpret_cast<std::byte*>(ptr_in);
497 state.world.serialize(start, result);
498
499 return reinterpret_cast<uint8_t*>(start);
500}
501scenario_size sizeof_scenario_section(sys::state& state) {
502 size_t sz = 0;
503
504 // hand-written contribution
505 { // map
506 sz += sizeof(state.map_state.map_data.size_x);
507 sz += sizeof(state.map_state.map_data.size_y);
508 sz += serialize_size(state.map_state.map_data.river_vertices);
509 sz += serialize_size(state.map_state.map_data.river_starts);
510 sz += serialize_size(state.map_state.map_data.river_counts);
511 sz += serialize_size(state.map_state.map_data.coastal_vertices);
512 sz += serialize_size(state.map_state.map_data.coastal_starts);
513 sz += serialize_size(state.map_state.map_data.coastal_counts);
514 sz += serialize_size(state.map_state.map_data.border_vertices);
515 sz += serialize_size(state.map_state.map_data.borders);
516 sz += serialize_size(state.map_state.map_data.terrain_id_map);
517 sz += serialize_size(state.map_state.map_data.province_id_map);
518 sz += serialize_size(state.map_state.map_data.province_area);
519 sz += serialize_size(state.map_state.map_data.diagonal_borders);
520 }
521 { sz += sizeof(parsing::defines); }
522 { sz += sizeof(economy::global_economy_state); }
523 { // culture definitions
524 sz += serialize_size(state.culture_definitions.party_issues);
525 sz += serialize_size(state.culture_definitions.political_issues);
526 sz += serialize_size(state.culture_definitions.social_issues);
527 sz += serialize_size(state.culture_definitions.military_issues);
528 sz += serialize_size(state.culture_definitions.economic_issues);
529 sz += serialize_size(state.culture_definitions.tech_folders);
530 sz += serialize_size(state.culture_definitions.crimes);
531 sz += sizeof(state.culture_definitions.artisans);
532 sz += sizeof(state.culture_definitions.capitalists);
533 sz += sizeof(state.culture_definitions.farmers);
534 sz += sizeof(state.culture_definitions.laborers);
535 sz += sizeof(state.culture_definitions.clergy);
536 sz += sizeof(state.culture_definitions.soldiers);
537 sz += sizeof(state.culture_definitions.officers);
538 sz += sizeof(state.culture_definitions.slaves);
539 sz += sizeof(state.culture_definitions.bureaucrat);
540 sz += sizeof(state.culture_definitions.aristocrat);
541 sz += sizeof(state.culture_definitions.primary_factory_worker);
542 sz += sizeof(state.culture_definitions.secondary_factory_worker);
543 sz += sizeof(state.culture_definitions.officer_leadership_points);
544 sz += sizeof(state.culture_definitions.bureaucrat_tax_efficiency);
545 sz += sizeof(state.culture_definitions.conservative);
546 sz += sizeof(state.culture_definitions.jingoism);
547 sz += sizeof(state.culture_definitions.promotion_chance);
548 sz += sizeof(state.culture_definitions.demotion_chance);
549 sz += sizeof(state.culture_definitions.migration_chance);
550 sz += sizeof(state.culture_definitions.colonialmigration_chance);
551 sz += sizeof(state.culture_definitions.emigration_chance);
552 sz += sizeof(state.culture_definitions.assimilation_chance);
553 sz += sizeof(state.culture_definitions.conversion_chance);
554 }
555 { // military definitions
556 sz += sizeof(state.military_definitions.first_background_trait);
557 sz += serialize_size(state.military_definitions.unit_base_definitions);
558 sz += sizeof(state.military_definitions.base_army_unit);
559 sz += sizeof(state.military_definitions.base_naval_unit);
560 sz += sizeof(state.military_definitions.standard_civil_war);
561 sz += sizeof(state.military_definitions.standard_great_war);
562 sz += sizeof(state.military_definitions.standard_status_quo);
563 sz += sizeof(state.military_definitions.liberate);
564 sz += sizeof(state.military_definitions.uninstall_communist_gov);
565 sz += sizeof(state.military_definitions.crisis_colony);
566 sz += sizeof(state.military_definitions.crisis_liberate);
567 sz += sizeof(state.military_definitions.irregular);
568 sz += sizeof(state.military_definitions.infantry);
569 sz += sizeof(state.military_definitions.artillery);
570 }
571 { // national definitions
572 sz += serialize_size(state.national_definitions.flag_variable_names);
573 sz += serialize_size(state.national_definitions.global_flag_variable_names);
574 sz += serialize_size(state.national_definitions.variable_names);
575 sz += serialize_size(state.national_definitions.triggered_modifiers);
576 sz += sizeof(state.national_definitions.rebel_id);
577 sz += sizeof(state.national_definitions.very_easy_player);
578 sz += sizeof(state.national_definitions.easy_player);
579 sz += sizeof(state.national_definitions.hard_player);
580 sz += sizeof(state.national_definitions.very_hard_player);
581 sz += sizeof(state.national_definitions.very_easy_ai);
582 sz += sizeof(state.national_definitions.easy_ai);
583 sz += sizeof(state.national_definitions.hard_ai);
584 sz += sizeof(state.national_definitions.very_hard_ai);
585 sz += sizeof(state.national_definitions.overseas);
586 sz += sizeof(state.national_definitions.coastal);
587 sz += sizeof(state.national_definitions.non_coastal);
588 sz += sizeof(state.national_definitions.coastal_sea);
589 sz += sizeof(state.national_definitions.sea_zone);
590 sz += sizeof(state.national_definitions.land_province);
591 sz += sizeof(state.national_definitions.blockaded);
592 sz += sizeof(state.national_definitions.no_adjacent_controlled);
593 sz += sizeof(state.national_definitions.core);
594 sz += sizeof(state.national_definitions.has_siege);
595 sz += sizeof(state.national_definitions.occupied);
596 sz += sizeof(state.national_definitions.nationalism);
597 sz += sizeof(state.national_definitions.infrastructure);
598 sz += sizeof(state.national_definitions.base_values);
599 sz += sizeof(state.national_definitions.war);
600 sz += sizeof(state.national_definitions.peace);
601 sz += sizeof(state.national_definitions.disarming);
602 sz += sizeof(state.national_definitions.war_exhaustion);
603 sz += sizeof(state.national_definitions.badboy);
604 sz += sizeof(state.national_definitions.debt_default_to);
605 sz += sizeof(state.national_definitions.bad_debter);
606 sz += sizeof(state.national_definitions.great_power);
607 sz += sizeof(state.national_definitions.second_power);
608 sz += sizeof(state.national_definitions.civ_nation);
609 sz += sizeof(state.national_definitions.unciv_nation);
610 sz += sizeof(state.national_definitions.average_literacy);
611 sz += sizeof(state.national_definitions.plurality);
612 sz += sizeof(state.national_definitions.generalised_debt_default);
613 sz += sizeof(state.national_definitions.total_occupation);
614 sz += sizeof(state.national_definitions.total_blockaded);
615 sz += sizeof(state.national_definitions.in_bankrupcy);
616 sz += sizeof(state.national_definitions.num_allocated_national_variables);
617 sz += sizeof(state.national_definitions.num_allocated_national_flags);
618 sz += sizeof(state.national_definitions.num_allocated_global_flags);
619 sz += sizeof(state.national_definitions.flashpoint_focus);
620 sz += sizeof(state.national_definitions.flashpoint_amount);
621 sz += serialize_size(state.national_definitions.on_yearly_pulse);
622 sz += serialize_size(state.national_definitions.on_quarterly_pulse);
623 sz += serialize_size(state.national_definitions.on_battle_won);
624 sz += serialize_size(state.national_definitions.on_battle_lost);
625 sz += serialize_size(state.national_definitions.on_surrender);
626 sz += serialize_size(state.national_definitions.on_new_great_nation);
627 sz += serialize_size(state.national_definitions.on_lost_great_nation);
628 sz += serialize_size(state.national_definitions.on_election_tick);
629 sz += serialize_size(state.national_definitions.on_colony_to_state);
630 sz += serialize_size(state.national_definitions.on_state_conquest);
631 sz += serialize_size(state.national_definitions.on_colony_to_state_free_slaves);
632 sz += serialize_size(state.national_definitions.on_debtor_default);
633 sz += serialize_size(state.national_definitions.on_debtor_default_small);
634 sz += serialize_size(state.national_definitions.on_debtor_default_second);
635 sz += serialize_size(state.national_definitions.on_civilize);
636 sz += serialize_size(state.national_definitions.on_my_factories_nationalized);
637 sz += serialize_size(state.national_definitions.on_crisis_declare_interest);
638 sz += serialize_size(state.national_definitions.on_election_started);
639 sz += serialize_size(state.national_definitions.on_election_finished);
640 }
641 { // provincial definitions
642 sz += serialize_size(state.province_definitions.canals);
643 sz += serialize_size(state.province_definitions.canal_provinces);
644 sz += serialize_size(state.province_definitions.terrain_to_gfx_map);
645 sz += sizeof(state.province_definitions.first_sea_province);
646 sz += sizeof(state.province_definitions.europe);
647 sz += sizeof(state.province_definitions.asia);
648 sz += sizeof(state.province_definitions.africa);
649 sz += sizeof(state.province_definitions.north_america);
650 sz += sizeof(state.province_definitions.south_america);
651 sz += sizeof(state.province_definitions.oceania);
652 }
653 sz += sizeof(state.start_date);
654 sz += sizeof(state.end_date);
655 sz += serialize_size(state.trigger_data);
656 sz += serialize_size(state.trigger_data_indices);
657 sz += serialize_size(state.effect_data);
658 sz += serialize_size(state.effect_data_indices);
659 sz += serialize_size(state.value_modifier_segments);
660 sz += serialize_size(state.value_modifiers);
661 sz += serialize_size(state.key_data);
662 sz += serialize_size(state.untrans_key_to_text_sequence);
663
664 { // ui definitions
665 sz += serialize_size(state.ui_defs.gfx);
666 sz += serialize_size(state.ui_defs.textures);
667 sz += serialize_size(state.ui_defs.gui);
668 sz += serialize_size(state.font_collection.font_names);
669 sz += serialize_size(state.ui_defs.extensions);
670 }
671
672 // data container contribution
673 dcon::load_record loaded = state.world.make_serialize_record_store_scenario();
674 // dcon::load_record loaded;
675 auto szb = state.world.serialize_size(loaded);
676
677 return scenario_size{ sz + szb, sz };
678}
679
680uint8_t const* read_save_section(uint8_t const* ptr_in, uint8_t const* section_end, sys::state& state) {
681 // hand-written contribution
682 ptr_in = deserialize(ptr_in, state.unit_names);
683 ptr_in = deserialize(ptr_in, state.unit_names_indices);
684 ptr_in = memcpy_deserialize(ptr_in, state.local_player_nation);
685 ptr_in = memcpy_deserialize(ptr_in, state.current_date);
686 ptr_in = memcpy_deserialize(ptr_in, state.game_seed);
687 ptr_in = memcpy_deserialize(ptr_in, state.crisis_state);
688 ptr_in = deserialize(ptr_in, state.crisis_participants);
689 ptr_in = memcpy_deserialize(ptr_in, state.current_crisis);
690 ptr_in = memcpy_deserialize(ptr_in, state.crisis_temperature);
691 ptr_in = memcpy_deserialize(ptr_in, state.primary_crisis_attacker);
692 ptr_in = memcpy_deserialize(ptr_in, state.primary_crisis_defender);
693 ptr_in = memcpy_deserialize(ptr_in, state.current_crisis_mode);
694 ptr_in = memcpy_deserialize(ptr_in, state.crisis_last_checked_gp);
695 ptr_in = memcpy_deserialize(ptr_in, state.crisis_war);
696 ptr_in = memcpy_deserialize(ptr_in, state.last_crisis_end_date);
697 ptr_in = memcpy_deserialize(ptr_in, state.crisis_liberation_tag);
698 ptr_in = memcpy_deserialize(ptr_in, state.crisis_colony);
699 ptr_in = memcpy_deserialize(ptr_in, state.inflation);
700 ptr_in = deserialize(ptr_in, state.great_nations);
701 ptr_in = deserialize(ptr_in, state.pending_n_event);
702 ptr_in = deserialize(ptr_in, state.pending_f_n_event);
703 ptr_in = deserialize(ptr_in, state.pending_p_event);
704 ptr_in = deserialize(ptr_in, state.pending_f_p_event);
705 ptr_in = memcpy_deserialize(ptr_in, state.pending_messages);
706 ptr_in = memcpy_deserialize(ptr_in, state.player_data_cache);
707 ptr_in = deserialize(ptr_in, state.future_n_event);
708 ptr_in = deserialize(ptr_in, state.future_p_event);
709
710 { // national definitions
711 ptr_in = deserialize(ptr_in, state.national_definitions.global_flag_variables);
712 }
713
714 { // military definitions
715 ptr_in = memcpy_deserialize(ptr_in, state.military_definitions.great_wars_enabled);
716 ptr_in = memcpy_deserialize(ptr_in, state.military_definitions.world_wars_enabled);
717 }
718
719 // data container contribution
720
721 dcon::load_record loaded;
722
723 if(state.network_mode == sys::network_mode_type::single_player) {
724 std::byte const* start = reinterpret_cast<std::byte const*>(ptr_in);
725 state.world.deserialize(start, reinterpret_cast<std::byte const*>(section_end), loaded);
726 } else {
727 dcon::load_record loadmask = state.world.make_serialize_record_store_save();
728 std::byte const* start = reinterpret_cast<std::byte const*>(ptr_in);
729 state.world.deserialize(start, reinterpret_cast<std::byte const*>(section_end), loaded, loadmask);
730 }
731 return section_end;
732}
733
734uint8_t* write_save_section(uint8_t* ptr_in, sys::state& state) {
735 // hand-written contribution
736 ptr_in = serialize(ptr_in, state.unit_names);
737 ptr_in = serialize(ptr_in, state.unit_names_indices);
738 ptr_in = memcpy_serialize(ptr_in, state.local_player_nation);
739 ptr_in = memcpy_serialize(ptr_in, state.current_date);
740 ptr_in = memcpy_serialize(ptr_in, state.game_seed);
741 ptr_in = memcpy_serialize(ptr_in, state.crisis_state);
742 ptr_in = serialize(ptr_in, state.crisis_participants);
743 ptr_in = memcpy_serialize(ptr_in, state.current_crisis);
744 ptr_in = memcpy_serialize(ptr_in, state.crisis_temperature);
745 ptr_in = memcpy_serialize(ptr_in, state.primary_crisis_attacker);
746 ptr_in = memcpy_serialize(ptr_in, state.primary_crisis_defender);
747 ptr_in = memcpy_serialize(ptr_in, state.current_crisis_mode);
748 ptr_in = memcpy_serialize(ptr_in, state.crisis_last_checked_gp);
749 ptr_in = memcpy_serialize(ptr_in, state.crisis_war);
750 ptr_in = memcpy_serialize(ptr_in, state.last_crisis_end_date);
751 ptr_in = memcpy_serialize(ptr_in, state.crisis_liberation_tag);
752 ptr_in = memcpy_serialize(ptr_in, state.crisis_colony);
753 ptr_in = memcpy_serialize(ptr_in, state.inflation);
754 ptr_in = serialize(ptr_in, state.great_nations);
755 ptr_in = serialize(ptr_in, state.pending_n_event);
756 ptr_in = serialize(ptr_in, state.pending_f_n_event);
757 ptr_in = serialize(ptr_in, state.pending_p_event);
758 ptr_in = serialize(ptr_in, state.pending_f_p_event);
759 ptr_in = memcpy_serialize(ptr_in, state.pending_messages);
760 ptr_in = memcpy_serialize(ptr_in, state.player_data_cache);
761 ptr_in = serialize(ptr_in, state.future_n_event);
762 ptr_in = serialize(ptr_in, state.future_p_event);
763
764 { // national definitions
765 ptr_in = serialize(ptr_in, state.national_definitions.global_flag_variables);
766 }
767 { // military definitions
768 ptr_in = memcpy_serialize(ptr_in, state.military_definitions.great_wars_enabled);
769 ptr_in = memcpy_serialize(ptr_in, state.military_definitions.world_wars_enabled);
770 }
771
772 // data container contribution
773 dcon::load_record loaded = state.world.make_serialize_record_store_full_save();
774 std::byte* start = reinterpret_cast<std::byte*>(ptr_in);
775 state.world.serialize(start, loaded);
776
777 return reinterpret_cast<uint8_t*>(start);
778}
779size_t sizeof_save_section(sys::state& state) {
780 size_t sz = 0;
781
782 // hand-written contribution
783
784 sz += serialize_size(state.unit_names);
785 sz += serialize_size(state.unit_names_indices);
786 sz += sizeof(state.local_player_nation);
787 sz += sizeof(state.current_date);
788 sz += sizeof(state.game_seed);
789 sz += sizeof(state.crisis_state);
790 sz += serialize_size(state.crisis_participants);
791 sz += sizeof(state.current_crisis);
792 sz += sizeof(state.crisis_temperature);
793 sz += sizeof(state.primary_crisis_attacker);
794 sz += sizeof(state.primary_crisis_defender);
795 sz += sizeof(state.current_crisis_mode);
796 sz += sizeof(state.crisis_last_checked_gp);
797 sz += sizeof(state.crisis_war);
798 sz += sizeof(state.last_crisis_end_date);
799 sz += sizeof(state.crisis_liberation_tag);
800 sz += sizeof(state.crisis_colony);
801 sz += sizeof(state.inflation);
802 sz += serialize_size(state.great_nations);
803 sz += serialize_size(state.pending_n_event);
804 sz += serialize_size(state.pending_f_n_event);
805 sz += serialize_size(state.pending_p_event);
806 sz += serialize_size(state.pending_f_p_event);
807 sz += sizeof(state.pending_messages);
808 sz += sizeof(state.player_data_cache);
809 sz += serialize_size(state.future_n_event);
810 sz += serialize_size(state.future_p_event);
811
812 { // national definitions
813 sz += serialize_size(state.national_definitions.global_flag_variables);
814 }
815 { // military definitions
816 sz += sizeof(state.military_definitions.great_wars_enabled);
817 sz += sizeof(state.military_definitions.world_wars_enabled);
818 }
819
820 // data container contribution
821 dcon::load_record loaded = state.world.make_serialize_record_store_full_save();
822 sz += state.world.serialize_size(loaded);
823
824 return sz;
825}
826
827void write_scenario_file(sys::state& state, native_string_view name, uint32_t count) {
828 scenario_header header;
829 header.count = count;
830 header.timestamp = uint64_t(std::time(nullptr));
831
832 auto scenario_space = sizeof_scenario_section(state);
833 size_t save_space = sizeof_save_section(state);
834
835 state.scenario_counter = count;
836 state.scenario_time_stamp = header.timestamp;
837
838
839 // this is an upper bound, since compacting the data may require less space
840 size_t total_size =
841 sizeof_scenario_header(header) + sizeof_mod_path(simple_fs::extract_state(state.common_fs)) + ZSTD_compressBound(scenario_space.total_size) + ZSTD_compressBound(save_space) + sizeof(uint32_t) * 4;
842
843 uint8_t* temp_buffer = new uint8_t[total_size];
844 uint8_t* buffer_position = temp_buffer;
845
846 buffer_position = write_scenario_header(buffer_position, header);
847 buffer_position = write_mod_path(buffer_position, simple_fs::extract_state(state.common_fs));
848
849 uint8_t* temp_scenario_buffer = new uint8_t[scenario_space.total_size];
850 auto last_written = write_scenario_section(temp_scenario_buffer, state);
851 auto last_written_count = last_written - temp_scenario_buffer;
852 assert(size_t(last_written_count) == scenario_space.total_size);
853 // calculate checksum
854 checksum_key* checksum = &reinterpret_cast<scenario_header*>(temp_buffer + sizeof(uint32_t))->checksum;
855 blake2b(checksum, sizeof(*checksum), temp_scenario_buffer + scenario_space.checksum_offset, scenario_space.total_size - scenario_space.checksum_offset, nullptr, 0);
856 state.scenario_checksum = *checksum;
857
858 buffer_position = write_compressed_section(buffer_position, temp_scenario_buffer, uint32_t(scenario_space.total_size));
859 delete[] temp_scenario_buffer;
860
861 uint8_t* temp_save_buffer = new uint8_t[save_space];
862 auto last_save_written = write_save_section(temp_save_buffer, state);
863 auto last_save_written_count = last_save_written - temp_save_buffer;
864 assert(size_t(last_save_written_count) == save_space);
865 buffer_position = write_compressed_section(buffer_position, temp_save_buffer, uint32_t(save_space));
866 delete[] temp_save_buffer;
867
868 auto total_size_used = buffer_position - temp_buffer;
869
870 simple_fs::write_file(simple_fs::get_or_create_scenario_directory(), name, reinterpret_cast<char*>(temp_buffer),
871 uint32_t(total_size_used));
872
873 delete[] temp_buffer;
874}
875bool try_read_scenario_file(sys::state& state, native_string_view name) {
876 auto dir = simple_fs::get_or_create_scenario_directory();
877 auto save_file = open_file(dir, name);
878 if(save_file) {
879 scenario_header header;
880 header.version = 0;
881
882 auto contents = simple_fs::view_contents(*save_file);
883 uint8_t const* buffer_pos = reinterpret_cast<uint8_t const*>(contents.data);
884 auto file_end = buffer_pos + contents.file_size;
885
886 if(contents.file_size > sizeof_scenario_header(header)) {
887 buffer_pos = read_scenario_header(buffer_pos, header);
888 }
889
890 if(header.version != sys::scenario_file_version) {
891 return false;
892 }
893
894 state.scenario_counter = header.count;
895 state.scenario_time_stamp = header.timestamp;
896 state.scenario_checksum = header.checksum;
897 state.loaded_save_file = NATIVE("");
898 state.loaded_scenario_file = name;
899
900 buffer_pos = load_mod_path(buffer_pos, state);
901
902 buffer_pos = with_decompressed_section(buffer_pos,
903 [&](uint8_t const* ptr_in, uint32_t length) { read_scenario_section(ptr_in, ptr_in + length, state); });
904
905 return true;
906 } else {
907 return false;
908 }
909}
910
911bool try_read_scenario_and_save_file(sys::state& state, native_string_view name) {
912 auto dir = simple_fs::get_or_create_scenario_directory();
913 auto save_file = open_file(dir, name);
914 if(save_file) {
915 scenario_header header;
916 header.version = 0;
917
918 auto contents = simple_fs::view_contents(*save_file);
919 uint8_t const* buffer_pos = reinterpret_cast<uint8_t const*>(contents.data);
920 auto file_end = buffer_pos + contents.file_size;
921
922 if(contents.file_size > sizeof_scenario_header(header)) {
923 buffer_pos = read_scenario_header(buffer_pos, header);
924 }
925
926 if(header.version != sys::scenario_file_version) {
927 return false;
928 }
929
930 state.scenario_counter = header.count;
931 state.scenario_time_stamp = header.timestamp;
932 state.scenario_checksum = header.checksum;
933
934 state.loaded_save_file = NATIVE("");
935 state.loaded_scenario_file = name;
936
937 buffer_pos = load_mod_path(buffer_pos, state);
938
939 buffer_pos = with_decompressed_section(buffer_pos,
940 [&](uint8_t const* ptr_in, uint32_t length) { read_scenario_section(ptr_in, ptr_in + length, state); });
941 buffer_pos = with_decompressed_section(buffer_pos,
942 [&](uint8_t const* ptr_in, uint32_t length) { read_save_section(ptr_in, ptr_in + length, state); });
943
944 state.game_seed = uint32_t(std::random_device()());
945
946 state.on_scenario_load();
947
948 return true;
949 } else {
950 return false;
951 }
952}
953
954bool try_read_scenario_as_save_file(sys::state& state, native_string_view name) {
955 auto dir = simple_fs::get_or_create_scenario_directory();
956 auto save_file = open_file(dir, name);
957 if(save_file) {
958 scenario_header header;
959 header.version = 0;
960
961 auto contents = simple_fs::view_contents(*save_file);
962 uint8_t const* buffer_pos = reinterpret_cast<uint8_t const*>(contents.data);
963 auto file_end = buffer_pos + contents.file_size;
964
965 if(contents.file_size > sizeof_scenario_header(header)) {
966 buffer_pos = read_scenario_header(buffer_pos, header);
967 }
968
969 if(header.version != sys::scenario_file_version) {
970 return false;
971 }
972
973 if(!state.scenario_checksum.is_equal(header.checksum))
974 return false;
975
976 state.loaded_save_file = NATIVE("");
977
978 buffer_pos = load_mod_path(buffer_pos, state);
979
980 buffer_pos = with_decompressed_section(buffer_pos,
981 [&](uint8_t const* ptr_in, uint32_t length) {
982 // DO NOTHING -- this skips over reading the scenario section
983 });
984 buffer_pos = with_decompressed_section(buffer_pos,
985 [&](uint8_t const* ptr_in, uint32_t length) {
986 read_save_section(ptr_in, ptr_in + length, state);
987 });
988
989 state.game_seed = uint32_t(std::random_device()());
990
991 return true;
992 } else {
993 return false;
994 }
995}
996
997std::string make_time_string(uint64_t value) {
998 std::string result;
999 for(int32_t i = 64 / 4; i --> 0; ) {
1000 result += char('a' + (0x0F & (value >> (i * 4))));
1001 }
1002 return result;
1003}
1004
1005void write_save_file(sys::state& state, save_type type, std::string const& name) {
1006 save_header header;
1007 header.count = state.scenario_counter;
1008 //header.timestamp = state.scenario_time_stamp;
1009 auto time_stamp = std::time(nullptr);
1010 header.timestamp = int64_t(time_stamp);
1011 header.checksum = state.scenario_checksum;
1012 header.tag = state.world.nation_get_identity_from_identity_holder(state.local_player_nation);
1013 header.cgov = state.world.nation_get_government_type(state.local_player_nation);
1014 header.d = state.current_date;
1015
1016 memcpy(header.save_name, name.c_str(), std::min(name.length(), size_t(31)));
1017 if(name.length() < 31) {
1018 header.save_name[name.length()] = 0;
1019 } else {
1020 header.save_name[31] = 0;
1021 }
1022
1023 size_t save_space = sizeof_save_section(state);
1024
1025 // this is an upper bound, since compacting the data may require less space
1026 size_t total_size = sizeof_save_header(header) + ZSTD_compressBound(save_space) + sizeof(uint32_t) * 2;
1027
1028 uint8_t* temp_buffer = new uint8_t[total_size];
1029 uint8_t* buffer_position = temp_buffer;
1030
1031 buffer_position = write_save_header(buffer_position, header);
1032
1033 uint8_t* temp_save_buffer = new uint8_t[save_space];
1034 write_save_section(temp_save_buffer, state);
1035
1036 buffer_position = write_compressed_section(buffer_position, temp_save_buffer, uint32_t(save_space));
1037 delete[] temp_save_buffer;
1038
1039 auto total_size_used = buffer_position - temp_buffer;
1040
1041 auto sdir = simple_fs::get_or_create_save_game_directory();
1042
1043 if(type == sys::save_type::autosave) {
1044 simple_fs::write_file(sdir, native_string(NATIVE("autosave_")) + simple_fs::utf8_to_native(std::to_string(state.autosave_counter)) + native_string(NATIVE(".bin")), reinterpret_cast<char*>(temp_buffer), uint32_t(total_size_used));
1045 state.autosave_counter = (state.autosave_counter + 1) % sys::max_autosaves;
1046 } else if(type == sys::save_type::bookmark) {
1047 auto ymd_date = state.current_date.to_ymd(state.start_date);
1048 auto base_str = "bookmark_" + make_time_string(uint64_t(std::time(nullptr))) + "-" + std::to_string(ymd_date.year) + "-" + std::to_string(ymd_date.month) + "-" + std::to_string(ymd_date.day) + ".bin";
1049 simple_fs::write_file(sdir, simple_fs::utf8_to_native(base_str), reinterpret_cast<char*>(temp_buffer), uint32_t(total_size_used));
1050 } else {
1051 auto ymd_date = state.current_date.to_ymd(state.start_date);
1052 auto base_str = make_time_string(uint64_t(std::time(nullptr))) + "-" + nations::int_to_tag(state.world.national_identity_get_identifying_int(header.tag)) + "-" + std::to_string(ymd_date.year) + "-" + std::to_string(ymd_date.month) + "-" + std::to_string(ymd_date.day) + ".bin";
1053 simple_fs::write_file(sdir, simple_fs::utf8_to_native(base_str), reinterpret_cast<char*>(temp_buffer), uint32_t(total_size_used));
1054 }
1055 delete[] temp_buffer;
1056
1057 state.save_list_updated.store(true, std::memory_order::release); // update for ui
1058
1059
1060 if(state.cheat_data.ecodump) {
1061 auto data_dumps_directory = simple_fs::get_or_create_data_dumps_directory();
1062
1063 simple_fs::write_file(
1064 data_dumps_directory,
1065 NATIVE("economy_dump.txt"),
1066 state.cheat_data.national_economy_dump_buffer.c_str(),
1067 uint32_t(state.cheat_data.national_economy_dump_buffer.size())
1068 );
1069 simple_fs::write_file(
1070 data_dumps_directory,
1071 NATIVE("prices_dump.txt"),
1072 state.cheat_data.prices_dump_buffer.c_str(),
1073 uint32_t(state.cheat_data.prices_dump_buffer.size())
1074 );
1075 simple_fs::write_file(
1076 data_dumps_directory,
1077 NATIVE("demand_dump.txt"),
1078 state.cheat_data.demand_dump_buffer.c_str(),
1079 uint32_t(state.cheat_data.demand_dump_buffer.size())
1080 );
1081 simple_fs::write_file(
1082 data_dumps_directory,
1083 NATIVE("supply_dump.txt"),
1084 state.cheat_data.supply_dump_buffer.c_str(),
1085 uint32_t(state.cheat_data.supply_dump_buffer.size())
1086 );
1087 simple_fs::write_file(
1088 data_dumps_directory,
1089 NATIVE("demand_by_category_dump.txt"),
1090 state.cheat_data.demand_by_category_dump_buffer.c_str(),
1091 uint32_t(state.cheat_data.demand_by_category_dump_buffer.size())
1092 );
1093 }
1094}
1095bool try_read_save_file(sys::state& state, native_string_view name) {
1096 auto dir = simple_fs::get_or_create_save_game_directory();
1097 auto save_file = open_file(dir, name);
1098 if(save_file) {
1099 save_header header;
1100 header.version = 0;
1101
1102 auto contents = simple_fs::view_contents(*save_file);
1103 uint8_t const* buffer_pos = reinterpret_cast<uint8_t const*>(contents.data);
1104 auto file_end = buffer_pos + contents.file_size;
1105
1106 if(contents.file_size > sizeof_save_header(header)) {
1107 buffer_pos = read_save_header(buffer_pos, header);
1108 }
1109
1110 if(header.version != sys::save_file_version) {
1111 return false;
1112 }
1113
1114 //if(state.scenario_counter != header.count)
1115 // return false;
1116 //if(state.scenario_time_stamp != header.timestamp)
1117 // return false;
1118 if(!state.scenario_checksum.is_equal(header.checksum))
1119 return false;
1120
1121 state.loaded_save_file = name;
1122
1123 buffer_pos = with_decompressed_section(buffer_pos,
1124 [&](uint8_t const* ptr_in, uint32_t length) { read_save_section(ptr_in, ptr_in + length, state); });
1125
1126 return true;
1127 } else {
1128 return false;
1129 }
1130}
1131
1132} // namespace sys
blake2b
int blake2b(void *out, size_t outlen, const void *in, size_t inlen, const void *key, size_t keylen)
Definition: blake2.c:259
map::display_data::river_vertices
std::vector< textured_line_with_width_vertex > river_vertices
Definition: map.hpp:116
map::display_data::river_counts
std::vector< GLsizei > river_counts
Definition: map.hpp:118
map::display_data::coastal_counts
std::vector< GLsizei > coastal_counts
Definition: map.hpp:124
map::display_data::coastal_starts
std::vector< GLint > coastal_starts
Definition: map.hpp:123
map::display_data::borders
std::vector< border > borders
Definition: map.hpp:114
map::display_data::river_starts
std::vector< GLint > river_starts
Definition: map.hpp:117
map::display_data::province_id_map
std::vector< uint16_t > province_id_map
Definition: map.hpp:162
map::display_data::diagonal_borders
std::vector< uint8_t > diagonal_borders
Definition: map.hpp:159
map::display_data::border_vertices
std::vector< textured_line_vertex_b > border_vertices
Definition: map.hpp:115
map::display_data::coastal_vertices
std::vector< textured_line_vertex_b > coastal_vertices
Definition: map.hpp:122
map::display_data::terrain_id_map
std::vector< uint8_t > terrain_id_map
Definition: map.hpp:156
map::display_data::size_y
uint32_t size_y
Definition: map.hpp:169
map::display_data::size_x
uint32_t size_x
Definition: map.hpp:168
map::display_data::province_area
std::vector< uint32_t > province_area
Definition: map.hpp:158
map::map_state::map_data
display_data map_data
Definition: map_state.hpp:60
sys::date::to_ymd
year_month_day to_ymd(absolute_time_point base) const noexcept
Definition: date_interface.cpp:35
text::font_manager::font_names
ankerl::unordered_dense::map< uint16_t, dcon::text_key > font_names
Definition: fonts.hpp:178
ui::definitions::gui
tagged_vector< element_data, dcon::gui_def_id > gui
Definition: gui_graphics.hpp:340
ui::definitions::extensions
std::vector< window_extension > extensions
Definition: gui_graphics.hpp:341
ui::definitions::gfx
tagged_vector< gfx_object, dcon::gfx_object_id > gfx
Definition: gui_graphics.hpp:338
ui::definitions::textures
tagged_vector< dcon::text_key, dcon::texture_id > textures
Definition: gui_graphics.hpp:339
assert
#define assert(condition)
Definition: debug.h:74
nations::int_to_tag
std::string int_to_tag(uint32_t v)
Definition: nations.hpp:10
simple_fs::utf8_to_native
native_string utf8_to_native(std::string_view data_in)
Definition: simple_fs_nix.cpp:522
simple_fs::extract_state
native_string extract_state(file_system const &fs)
Definition: simple_fs_nix.cpp:155
simple_fs::restore_state
void restore_state(file_system &fs, native_string_view data)
Definition: simple_fs_nix.cpp:167
simple_fs::write_file
void write_file(directory const &dir, native_string_view file_name, char const *file_data, uint32_t file_size)
Definition: simple_fs_nix.cpp:419
simple_fs::get_or_create_save_game_directory
directory get_or_create_save_game_directory()
Definition: simple_fs_nix.cpp:468
simple_fs::get_or_create_data_dumps_directory
directory get_or_create_data_dumps_directory()
Definition: simple_fs_nix.cpp:496
simple_fs::view_contents
file_contents view_contents(file const &f)
Definition: simple_fs_nix.cpp:441
simple_fs::get_or_create_scenario_directory
directory get_or_create_scenario_directory()
Definition: simple_fs_nix.cpp:503
sys
Definition: constants.hpp:4
sys::write_mod_path
uint8_t * write_mod_path(uint8_t *ptr_in, native_string const &path_in)
Definition: serialization.cpp:71
sys::write_scenario_section
uint8_t * write_scenario_section(uint8_t *ptr_in, sys::state &state)
Definition: serialization.cpp:320
sys::try_read_scenario_as_save_file
bool try_read_scenario_as_save_file(sys::state &state, native_string_view name)
Definition: serialization.cpp:954
sys::sizeof_save_section
size_t sizeof_save_section(sys::state &state)
Definition: serialization.cpp:779
sys::read_save_header
uint8_t const * read_save_header(uint8_t const *ptr_in, save_header &header_out)
Definition: serialization.cpp:22
sys::extract_mod_information
mod_identifier extract_mod_information(uint8_t const *ptr_in, uint64_t file_size)
Definition: serialization.cpp:87
sys::scenario_file_version
constexpr uint32_t scenario_file_version
Definition: serialization.hpp:155
sys::sizeof_mod_path
size_t sizeof_mod_path(native_string const &path_in)
Definition: serialization.cpp:79
sys::memcpy_deserialize
uint8_t const * memcpy_deserialize(uint8_t const *ptr_in, T &obj)
Definition: serialization.hpp:39
sys::save_type
save_type
Definition: constants.hpp:565
sys::autosave
@ autosave
Definition: constants.hpp:567
sys::bookmark
@ bookmark
Definition: constants.hpp:568
sys::write_scenario_header
uint8_t * write_scenario_header(uint8_t *ptr_in, scenario_header const &header_in)
Definition: serialization.cpp:29
sys::write_scenario_file
void write_scenario_file(sys::state &state, native_string_view name, uint32_t count)
Definition: serialization.cpp:827
sys::with_decompressed_section
uint8_t const * with_decompressed_section(uint8_t const *ptr_in, T const &function)
Definition: serialization.cpp:119
sys::deserialize
uint8_t const * deserialize(uint8_t const *ptr_in, std::vector< T > &vec)
Definition: serialization.hpp:24
sys::write_save_section
uint8_t * write_save_section(uint8_t *ptr_in, sys::state &state)
Definition: serialization.cpp:734
sys::sizeof_scenario_section
scenario_size sizeof_scenario_section(sys::state &state)
Definition: serialization.cpp:501
sys::read_scenario_header
uint8_t const * read_scenario_header(uint8_t const *ptr_in, scenario_header &header_out)
Definition: serialization.cpp:15
sys::read_mod_path
void read_mod_path(uint8_t const *ptr_in, uint8_t const *lim, native_string &path_out)
Definition: serialization.cpp:50
sys::write_save_header
uint8_t * write_save_header(uint8_t *ptr_in, save_header const &header_in)
Definition: serialization.cpp:35
sys::make_time_string
std::string make_time_string(uint64_t value)
Definition: serialization.cpp:997
sys::memcpy_serialize
uint8_t * memcpy_serialize(uint8_t *ptr_in, T const &obj)
Definition: serialization.hpp:33
sys::try_read_scenario_file
bool try_read_scenario_file(sys::state &state, native_string_view name)
Definition: serialization.cpp:875
sys::serialize_size
size_t serialize_size(std::vector< T > const &vec)
Definition: serialization.hpp:11
sys::max_autosaves
constexpr int32_t max_autosaves
Definition: constants.hpp:176
sys::serialize
uint8_t * serialize(uint8_t *ptr_in, std::vector< T > const &vec)
Definition: serialization.hpp:16
sys::read_save_section
uint8_t const * read_save_section(uint8_t const *ptr_in, uint8_t const *section_end, sys::state &state)
Definition: serialization.cpp:680
sys::sizeof_save_header
size_t sizeof_save_header(save_header const &header_in)
Definition: serialization.cpp:46
sys::write_compressed_section
uint8_t * write_compressed_section(uint8_t *ptr_out, uint8_t const *ptr_in, uint32_t uncompressed_size)
Definition: serialization.cpp:106
sys::try_read_save_file
bool try_read_save_file(sys::state &state, native_string_view name)
Definition: serialization.cpp:1095
sys::write_save_file
void write_save_file(sys::state &state, save_type type, std::string const &name)
Definition: serialization.cpp:1005
sys::load_mod_path
uint8_t const * load_mod_path(uint8_t const *ptr_in, sys::state &state)
Definition: serialization.cpp:63
sys::sizeof_scenario_header
size_t sizeof_scenario_header(scenario_header const &header_in)
Definition: serialization.cpp:42
sys::save_file_version
constexpr uint32_t save_file_version
Definition: serialization.hpp:154
sys::read_scenario_section
uint8_t const * read_scenario_section(uint8_t const *ptr_in, uint8_t const *section_end, sys::state &state)
Definition: serialization.cpp:137
sys::try_read_scenario_and_save_file
bool try_read_scenario_and_save_file(sys::state &state, native_string_view name)
Definition: serialization.cpp:911
native_char
char native_char
Definition: native_types_nix.hpp:7
NATIVE
#define NATIVE(X)
Definition: native_types_nix.hpp:13
native_string_view
std::string_view native_string_view
Definition: native_types_nix.hpp:6
native_string
std::string native_string
Definition: native_types_nix.hpp:5
uint32_t
uint uint32_t
Definition: openclfeatures.h:85
uint64_t
ulong uint64_t
Definition: openclfeatures.h:84
uint8_t
uchar uint8_t
Definition: openclfeatures.h:86
culture::global_cultural_state::political_issues
std::vector< dcon::issue_id > political_issues
Definition: culture.hpp:126
culture::global_cultural_state::conversion_chance
dcon::value_modifier_key conversion_chance
Definition: culture.hpp:166
culture::global_cultural_state::military_issues
std::vector< dcon::reform_id > military_issues
Definition: culture.hpp:128
culture::global_cultural_state::farmers
dcon::pop_type_id farmers
Definition: culture.hpp:139
culture::global_cultural_state::migration_chance
dcon::value_modifier_key migration_chance
Definition: culture.hpp:162
culture::global_cultural_state::clergy
dcon::pop_type_id clergy
Definition: culture.hpp:141
culture::global_cultural_state::colonialmigration_chance
dcon::value_modifier_key colonialmigration_chance
Definition: culture.hpp:163
culture::global_cultural_state::crimes
tagged_vector< crime_info, dcon::crime_id > crimes
Definition: culture.hpp:134
culture::global_cultural_state::demotion_chance
dcon::value_modifier_key demotion_chance
Definition: culture.hpp:161
culture::global_cultural_state::economic_issues
std::vector< dcon::reform_id > economic_issues
Definition: culture.hpp:129
culture::global_cultural_state::secondary_factory_worker
dcon::pop_type_id secondary_factory_worker
Definition: culture.hpp:149
culture::global_cultural_state::officer_leadership_points
int32_t officer_leadership_points
Definition: culture.hpp:151
culture::global_cultural_state::bureaucrat
dcon::pop_type_id bureaucrat
Definition: culture.hpp:145
culture::global_cultural_state::artisans
dcon::pop_type_id artisans
Definition: culture.hpp:137
culture::global_cultural_state::tech_folders
std::vector< folder_info > tech_folders
Definition: culture.hpp:131
culture::global_cultural_state::party_issues
std::vector< dcon::issue_id > party_issues
Definition: culture.hpp:125
culture::global_cultural_state::social_issues
std::vector< dcon::issue_id > social_issues
Definition: culture.hpp:127
culture::global_cultural_state::bureaucrat_tax_efficiency
float bureaucrat_tax_efficiency
Definition: culture.hpp:152
culture::global_cultural_state::soldiers
dcon::pop_type_id soldiers
Definition: culture.hpp:142
culture::global_cultural_state::primary_factory_worker
dcon::pop_type_id primary_factory_worker
Definition: culture.hpp:148
culture::global_cultural_state::assimilation_chance
dcon::value_modifier_key assimilation_chance
Definition: culture.hpp:165
culture::global_cultural_state::officers
dcon::pop_type_id officers
Definition: culture.hpp:143
culture::global_cultural_state::aristocrat
dcon::pop_type_id aristocrat
Definition: culture.hpp:146
culture::global_cultural_state::jingoism
dcon::issue_option_id jingoism
Definition: culture.hpp:157
culture::global_cultural_state::capitalists
dcon::pop_type_id capitalists
Definition: culture.hpp:138
culture::global_cultural_state::conservative
dcon::ideology_id conservative
Definition: culture.hpp:155
culture::global_cultural_state::promotion_chance
dcon::value_modifier_key promotion_chance
Definition: culture.hpp:160
culture::global_cultural_state::laborers
dcon::pop_type_id laborers
Definition: culture.hpp:140
culture::global_cultural_state::slaves
dcon::pop_type_id slaves
Definition: culture.hpp:144
culture::global_cultural_state::emigration_chance
dcon::value_modifier_key emigration_chance
Definition: culture.hpp:164
economy::global_economy_state
Definition: economy.hpp:98
military::global_military_state::standard_civil_war
dcon::cb_type_id standard_civil_war
Definition: military.hpp:150
military::global_military_state::uninstall_communist_gov
dcon::cb_type_id uninstall_communist_gov
Definition: military.hpp:156
military::global_military_state::base_army_unit
dcon::unit_type_id base_army_unit
Definition: military.hpp:147
military::global_military_state::irregular
dcon::unit_type_id irregular
Definition: military.hpp:161
military::global_military_state::unit_base_definitions
tagged_vector< unit_definition, dcon::unit_type_id > unit_base_definitions
Definition: military.hpp:140
military::global_military_state::infantry
dcon::unit_type_id infantry
Definition: military.hpp:162
military::global_military_state::great_wars_enabled
bool great_wars_enabled
Definition: military.hpp:144
military::global_military_state::standard_status_quo
dcon::cb_type_id standard_status_quo
Definition: military.hpp:153
military::global_military_state::crisis_liberate
dcon::cb_type_id crisis_liberate
Definition: military.hpp:159
military::global_military_state::crisis_colony
dcon::cb_type_id crisis_colony
Definition: military.hpp:158
military::global_military_state::liberate
dcon::cb_type_id liberate
Definition: military.hpp:155
military::global_military_state::standard_great_war
dcon::cb_type_id standard_great_war
Definition: military.hpp:151
military::global_military_state::base_naval_unit
dcon::unit_type_id base_naval_unit
Definition: military.hpp:148
military::global_military_state::world_wars_enabled
bool world_wars_enabled
Definition: military.hpp:145
military::global_military_state::artillery
dcon::unit_type_id artillery
Definition: military.hpp:163
military::global_military_state::first_background_trait
dcon::leader_trait_id first_background_trait
Definition: military.hpp:142
nations::global_national_state::on_surrender
std::vector< fixed_event > on_surrender
Definition: nations.hpp:139
nations::global_national_state::on_colony_to_state
std::vector< fixed_event > on_colony_to_state
Definition: nations.hpp:143
nations::global_national_state::on_lost_great_nation
std::vector< fixed_event > on_lost_great_nation
Definition: nations.hpp:141
nations::global_national_state::overseas
dcon::modifier_id overseas
Definition: nations.hpp:87
nations::global_national_state::on_yearly_pulse
std::vector< fixed_event > on_yearly_pulse
Definition: nations.hpp:135
nations::global_national_state::total_occupation
dcon::modifier_id total_occupation
Definition: nations.hpp:117
nations::global_national_state::total_blockaded
dcon::modifier_id total_blockaded
Definition: nations.hpp:118
nations::global_national_state::on_civilize
std::vector< fixed_event > on_civilize
Definition: nations.hpp:149
nations::global_national_state::on_debtor_default_small
std::vector< fixed_event > on_debtor_default_small
Definition: nations.hpp:147
nations::global_national_state::on_state_conquest
std::vector< fixed_event > on_state_conquest
Definition: nations.hpp:144
nations::global_national_state::on_election_started
std::vector< fixed_event > on_election_started
Definition: nations.hpp:152
nations::global_national_state::land_province
dcon::modifier_id land_province
Definition: nations.hpp:92
nations::global_national_state::easy_ai
dcon::modifier_id easy_ai
Definition: nations.hpp:82
nations::global_national_state::variable_names
tagged_vector< dcon::text_key, dcon::national_variable_id > variable_names
Definition: nations.hpp:73
nations::global_national_state::very_hard_ai
dcon::modifier_id very_hard_ai
Definition: nations.hpp:84
nations::global_national_state::base_values
dcon::modifier_id base_values
Definition: nations.hpp:102
nations::global_national_state::generalised_debt_default
dcon::modifier_id generalised_debt_default
Definition: nations.hpp:116
nations::global_national_state::flashpoint_amount
float flashpoint_amount
Definition: nations.hpp:133
nations::global_national_state::coastal_sea
dcon::modifier_id coastal_sea
Definition: nations.hpp:90
nations::global_national_state::rebel_id
dcon::national_identity_id rebel_id
Definition: nations.hpp:75
nations::global_national_state::very_hard_player
dcon::modifier_id very_hard_player
Definition: nations.hpp:80
nations::global_national_state::hard_ai
dcon::modifier_id hard_ai
Definition: nations.hpp:83
nations::global_national_state::on_election_finished
std::vector< fixed_event > on_election_finished
Definition: nations.hpp:153
nations::global_national_state::nationalism
dcon::modifier_id nationalism
Definition: nations.hpp:98
nations::global_national_state::on_battle_won
std::vector< fixed_province_event > on_battle_won
Definition: nations.hpp:137
nations::global_national_state::debt_default_to
dcon::modifier_id debt_default_to
Definition: nations.hpp:108
nations::global_national_state::badboy
dcon::modifier_id badboy
Definition: nations.hpp:107
nations::global_national_state::coastal
dcon::modifier_id coastal
Definition: nations.hpp:88
nations::global_national_state::global_flag_variable_names
tagged_vector< dcon::text_key, dcon::global_flag_id > global_flag_variable_names
Definition: nations.hpp:72
nations::global_national_state::on_colony_to_state_free_slaves
std::vector< fixed_event > on_colony_to_state_free_slaves
Definition: nations.hpp:145
nations::global_national_state::hard_player
dcon::modifier_id hard_player
Definition: nations.hpp:79
nations::global_national_state::very_easy_ai
dcon::modifier_id very_easy_ai
Definition: nations.hpp:81
nations::global_national_state::unciv_nation
dcon::modifier_id unciv_nation
Definition: nations.hpp:113
nations::global_national_state::on_quarterly_pulse
std::vector< fixed_event > on_quarterly_pulse
Definition: nations.hpp:136
nations::global_national_state::non_coastal
dcon::modifier_id non_coastal
Definition: nations.hpp:89
nations::global_national_state::in_bankrupcy
dcon::modifier_id in_bankrupcy
Definition: nations.hpp:119
nations::global_national_state::disarming
dcon::modifier_id disarming
Definition: nations.hpp:105
nations::global_national_state::easy_player
dcon::modifier_id easy_player
Definition: nations.hpp:78
nations::global_national_state::num_allocated_global_flags
int32_t num_allocated_global_flags
Definition: nations.hpp:123
nations::global_national_state::bad_debter
dcon::modifier_id bad_debter
Definition: nations.hpp:109
nations::global_national_state::flag_variable_names
tagged_vector< dcon::text_key, dcon::national_flag_id > flag_variable_names
Definition: nations.hpp:71
nations::global_national_state::civ_nation
dcon::modifier_id civ_nation
Definition: nations.hpp:112
nations::global_national_state::flashpoint_focus
dcon::national_focus_id flashpoint_focus
Definition: nations.hpp:125
nations::global_national_state::plurality
dcon::modifier_id plurality
Definition: nations.hpp:115
nations::global_national_state::no_adjacent_controlled
dcon::modifier_id no_adjacent_controlled
Definition: nations.hpp:94
nations::global_national_state::on_debtor_default
std::vector< fixed_event > on_debtor_default
Definition: nations.hpp:146
nations::global_national_state::on_crisis_declare_interest
std::vector< fixed_event > on_crisis_declare_interest
Definition: nations.hpp:151
nations::global_national_state::sea_zone
dcon::modifier_id sea_zone
Definition: nations.hpp:91
nations::global_national_state::blockaded
dcon::modifier_id blockaded
Definition: nations.hpp:93
nations::global_national_state::num_allocated_national_variables
int32_t num_allocated_national_variables
Definition: nations.hpp:121
nations::global_national_state::num_allocated_national_flags
int32_t num_allocated_national_flags
Definition: nations.hpp:122
nations::global_national_state::peace
dcon::modifier_id peace
Definition: nations.hpp:104
nations::global_national_state::triggered_modifiers
std::vector< triggered_modifier > triggered_modifiers
Definition: nations.hpp:67
nations::global_national_state::on_my_factories_nationalized
std::vector< fixed_event > on_my_factories_nationalized
Definition: nations.hpp:150
nations::global_national_state::great_power
dcon::modifier_id great_power
Definition: nations.hpp:110
nations::global_national_state::on_election_tick
std::vector< fixed_election_event > on_election_tick
Definition: nations.hpp:142
nations::global_national_state::war_exhaustion
dcon::modifier_id war_exhaustion
Definition: nations.hpp:106
nations::global_national_state::war
dcon::modifier_id war
Definition: nations.hpp:103
nations::global_national_state::infrastructure
dcon::modifier_id infrastructure
Definition: nations.hpp:99
nations::global_national_state::average_literacy
dcon::modifier_id average_literacy
Definition: nations.hpp:114
nations::global_national_state::second_power
dcon::modifier_id second_power
Definition: nations.hpp:111
nations::global_national_state::occupied
dcon::modifier_id occupied
Definition: nations.hpp:97
nations::global_national_state::very_easy_player
dcon::modifier_id very_easy_player
Definition: nations.hpp:77
nations::global_national_state::has_siege
dcon::modifier_id has_siege
Definition: nations.hpp:96
nations::global_national_state::core
dcon::modifier_id core
Definition: nations.hpp:95
nations::global_national_state::on_new_great_nation
std::vector< fixed_event > on_new_great_nation
Definition: nations.hpp:140
nations::global_national_state::on_debtor_default_second
std::vector< fixed_event > on_debtor_default_second
Definition: nations.hpp:148
nations::global_national_state::on_battle_lost
std::vector< fixed_province_event > on_battle_lost
Definition: nations.hpp:138
nations::global_national_state::global_flag_variables
std::vector< dcon::bitfield_type > global_flag_variables
Definition: nations.hpp:68
province::global_provincial_state::south_america
dcon::modifier_id south_america
Definition: province.hpp:31
province::global_provincial_state::terrain_to_gfx_map
ankerl::unordered_dense::map< dcon::modifier_id, dcon::gfx_object_id, sys::modifier_hash > terrain_to_gfx_map
Definition: province.hpp:23
province::global_provincial_state::canals
std::vector< dcon::province_adjacency_id > canals
Definition: province.hpp:21
province::global_provincial_state::first_sea_province
dcon::province_id first_sea_province
Definition: province.hpp:26
province::global_provincial_state::europe
dcon::modifier_id europe
Definition: province.hpp:27
province::global_provincial_state::asia
dcon::modifier_id asia
Definition: province.hpp:28
province::global_provincial_state::north_america
dcon::modifier_id north_america
Definition: province.hpp:30
province::global_provincial_state::oceania
dcon::modifier_id oceania
Definition: province.hpp:32
province::global_provincial_state::canal_provinces
std::vector< dcon::province_id > canal_provinces
Definition: province.hpp:22
province::global_provincial_state::africa
dcon::modifier_id africa
Definition: province.hpp:29
sys::cheat_data_s::ecodump
bool ecodump
Definition: system_state.hpp:410
sys::cheat_data_s::national_economy_dump_buffer
std::string national_economy_dump_buffer
Definition: system_state.hpp:412
sys::cheat_data_s::prices_dump_buffer
std::string prices_dump_buffer
Definition: system_state.hpp:413
sys::cheat_data_s::supply_dump_buffer
std::string supply_dump_buffer
Definition: system_state.hpp:415
sys::cheat_data_s::demand_by_category_dump_buffer
std::string demand_by_category_dump_buffer
Definition: system_state.hpp:416
sys::cheat_data_s::demand_dump_buffer
std::string demand_dump_buffer
Definition: system_state.hpp:414
sys::checksum_key
Definition: container_types.hpp:277
sys::checksum_key::is_equal
bool is_equal(const checksum_key &a) noexcept
Definition: container_types.hpp:281
sys::mod_identifier
Definition: serialization.hpp:175
sys::save_header
Definition: serialization.hpp:164
sys::save_header::count
uint32_t count
Definition: serialization.hpp:166
sys::save_header::tag
dcon::national_identity_id tag
Definition: serialization.hpp:169
sys::save_header::d
sys::date d
Definition: serialization.hpp:171
sys::save_header::timestamp
uint64_t timestamp
Definition: serialization.hpp:167
sys::save_header::cgov
dcon::government_type_id cgov
Definition: serialization.hpp:170
sys::save_header::save_name
char save_name[32]
Definition: serialization.hpp:172
sys::save_header::checksum
checksum_key checksum
Definition: serialization.hpp:168
sys::save_header::version
uint32_t version
Definition: serialization.hpp:165
sys::scenario_header
Definition: serialization.hpp:157
sys::scenario_header::version
uint32_t version
Definition: serialization.hpp:158
sys::scenario_header::count
uint32_t count
Definition: serialization.hpp:159
sys::scenario_header::checksum
checksum_key checksum
Definition: serialization.hpp:161
sys::scenario_header::timestamp
uint64_t timestamp
Definition: serialization.hpp:160
sys::scenario_size
Definition: serialization.hpp:202
sys::state::scenario_time_stamp
uint64_t scenario_time_stamp
Definition: system_state.hpp:509
sys::state::font_collection
text::font_manager font_collection
Definition: system_state.hpp:609
sys::state::crisis_liberation_tag
dcon::national_identity_id crisis_liberation_tag
Definition: system_state.hpp:535
sys::state::culture_definitions
culture::global_cultural_state culture_definitions
Definition: system_state.hpp:480
sys::state::network_mode
network_mode_type network_mode
Definition: system_state.hpp:579
sys::state::key_data
std::vector< char > key_data
Definition: system_state.hpp:495
sys::state::future_p_event
std::vector< event::pending_human_p_event > future_p_event
Definition: system_state.hpp:554
sys::state::save_list_updated
std::atomic< bool > save_list_updated
Definition: system_state.hpp:614
sys::state::pending_p_event
std::vector< event::pending_human_p_event > pending_p_event
Definition: system_state.hpp:550
sys::state::value_modifier_segments
std::vector< value_modifier_segment > value_modifier_segments
Definition: system_state.hpp:492
sys::state::untrans_key_to_text_sequence
ankerl::unordered_dense::set< dcon::text_key, text::vector_backed_ci_hash, text::vector_backed_ci_eq > untrans_key_to_text_sequence
Definition: system_state.hpp:497
sys::state::world
dcon::data_container world
Definition: system_state.hpp:473
sys::state::crisis_participants
std::vector< crisis_member_def > crisis_participants
Definition: system_state.hpp:526
sys::state::pending_f_p_event
std::vector< event::pending_human_f_p_event > pending_f_p_event
Definition: system_state.hpp:551
sys::state::effect_data
std::vector< uint16_t > effect_data
Definition: system_state.hpp:490
sys::state::crisis_colony
dcon::state_definition_id crisis_colony
Definition: system_state.hpp:536
sys::state::local_player_nation
dcon::nation_id local_player_nation
Definition: system_state.hpp:580
sys::state::defines
parsing::defines defines
Definition: system_state.hpp:477
sys::state::unit_names
std::vector< char > unit_names
Definition: system_state.hpp:557
sys::state::trigger_data_indices
std::vector< int32_t > trigger_data_indices
Definition: system_state.hpp:489
sys::state::crisis_last_checked_gp
uint32_t crisis_last_checked_gp
Definition: system_state.hpp:532
sys::state::value_modifiers
tagged_vector< value_modifier_description, dcon::value_modifier_key > value_modifiers
Definition: system_state.hpp:493
sys::state::economy_definitions
economy::global_economy_state economy_definitions
Definition: system_state.hpp:479
sys::state::common_fs
simple_fs::file_system common_fs
Definition: system_state.hpp:605
sys::state::start_date
absolute_time_point start_date
Definition: system_state.hpp:485
sys::state::end_date
absolute_time_point end_date
Definition: system_state.hpp:486
sys::state::game_seed
uint32_t game_seed
Definition: system_state.hpp:583
sys::state::military_definitions
military::global_military_state military_definitions
Definition: system_state.hpp:481
sys::state::current_date
sys::date current_date
Definition: system_state.hpp:581
sys::state::scenario_checksum
sys::checksum_key scenario_checksum
Definition: system_state.hpp:512
sys::state::unit_names_indices
std::vector< int32_t > unit_names_indices
Definition: system_state.hpp:556
sys::state::loaded_save_file
native_string loaded_save_file
Definition: system_state.hpp:515
sys::state::player_data_cache
player_data player_data_cache
Definition: system_state.hpp:585
sys::state::primary_crisis_defender
dcon::nation_id primary_crisis_defender
Definition: system_state.hpp:530
sys::state::pending_messages
std::array< diplomatic_message::message, 128 > pending_messages
Definition: system_state.hpp:542
sys::state::future_n_event
std::vector< event::pending_human_n_event > future_n_event
Definition: system_state.hpp:553
sys::state::cheat_data
cheat_data_s cheat_data
Definition: system_state.hpp:657
sys::state::scenario_counter
uint32_t scenario_counter
Definition: system_state.hpp:510
sys::state::great_nations
std::vector< great_nation > great_nations
Definition: system_state.hpp:507
sys::state::crisis_war
dcon::war_id crisis_war
Definition: system_state.hpp:533
sys::state::current_crisis
crisis_type current_crisis
Definition: system_state.hpp:527
sys::state::loaded_scenario_file
native_string loaded_scenario_file
Definition: system_state.hpp:514
sys::state::map_state
map::map_state map_state
Definition: system_state.hpp:647
sys::state::province_definitions
province::global_provincial_state province_definitions
Definition: system_state.hpp:483
sys::state::autosave_counter
int32_t autosave_counter
Definition: system_state.hpp:511
sys::state::last_crisis_end_date
sys::date last_crisis_end_date
Definition: system_state.hpp:534
sys::state::pending_f_n_event
std::vector< event::pending_human_f_n_event > pending_f_n_event
Definition: system_state.hpp:549
sys::state::on_scenario_load
void on_scenario_load()
Definition: system_state.cpp:3277
sys::state::crisis_state
dcon::state_instance_id crisis_state
Definition: system_state.hpp:525
sys::state::primary_crisis_attacker
dcon::nation_id primary_crisis_attacker
Definition: system_state.hpp:529
sys::state::effect_data_indices
std::vector< int32_t > effect_data_indices
Definition: system_state.hpp:491
sys::state::ui_defs
ui::definitions ui_defs
Definition: system_state.hpp:563
sys::state::pending_n_event
std::vector< event::pending_human_n_event > pending_n_event
Definition: system_state.hpp:548
sys::state::trigger_data
std::vector< uint16_t > trigger_data
Definition: system_state.hpp:488
sys::state::crisis_temperature
float crisis_temperature
Definition: system_state.hpp:528
sys::state::current_crisis_mode
crisis_mode current_crisis_mode
Definition: system_state.hpp:531
sys::state::national_definitions
nations::global_national_state national_definitions
Definition: system_state.hpp:482
system_state.hpp
ZSTD_compressBound
size_t ZSTD_compressBound(size_t srcSize)
Definition: zstd_compress.c:69
ZSTD_compress
size_t ZSTD_compress(void *dst, size_t dstCapacity, const void *src, size_t srcSize, int compressionLevel)
Definition: zstd_compress.c:5372
ZSTD_decompress
size_t ZSTD_decompress(void *dst, size_t dstCapacity, const void *src, size_t srcSize)
Definition: zstd_decompress.c:1197