1 #include "file_io.h"
2
3 #include "building/barracks.h"
4 #include "building/count.h"
5 #include "building/granary.h"
6 #include "building/list.h"
7 #include "building/monument.h"
8 #include "building/storage.h"
9 #include "city/culture.h"
10 #include "city/data.h"
11 #include "core/file.h"
12 #include "core/log.h"
13 #include "city/message.h"
14 #include "city/view.h"
15 #include "core/dir.h"
16 #include "core/random.h"
17 #include "core/zip.h"
18 #include "empire/city.h"
19 #include "empire/empire.h"
20 #include "empire/trade_prices.h"
21 #include "empire/trade_route.h"
22 #include "figure/enemy_army.h"
23 #include "figure/formation.h"
24 #include "figure/name.h"
25 #include "figure/route.h"
26 #include "figure/trader.h"
27 #include "game/time.h"
28 #include "game/tutorial.h"
29 #include "map/aqueduct.h"
30 #include "map/bookmark.h"
31 #include "map/building.h"
32 #include "map/desirability.h"
33 #include "map/elevation.h"
34 #include "map/figure.h"
35 #include "map/image.h"
36 #include "map/property.h"
37 #include "map/random.h"
38 #include "map/routing.h"
39 #include "map/sprite.h"
40 #include "map/terrain.h"
41 #include "map/tiles.h"
42 #include "scenario/criteria.h"
43 #include "scenario/earthquake.h"
44 #include "scenario/emperor_change.h"
45 #include "scenario/gladiator_revolt.h"
46 #include "scenario/invasion.h"
47 #include "scenario/map.h"
48 #include "scenario/scenario.h"
49 #include "sound/city.h"
50
51 #include <stdio.h>
52 #include <stdlib.h>
53 #include <string.h>
54
55 #define COMPRESS_BUFFER_SIZE 3000000
56 #define UNCOMPRESSED 0x80000000
57
58 #define PIECE_SIZE_DYNAMIC 0
59
60 static const int SAVE_GAME_CURRENT_VERSION = 0x86;
61
62 static const int SAVE_GAME_LAST_ORIGINAL_LIMITS_VERSION = 0x66;
63 static const int SAVE_GAME_LAST_SMALLER_IMAGE_ID_VERSION = 0x76;
64 static const int SAVE_GAME_LAST_NO_DELIVERIES_VERSION = 0x77;
65 static const int SAVE_GAME_LAST_STATIC_VERSION = 0x78;
66 static const int SAVE_GAME_LAST_JOINED_IMPORT_EXPORT_VERSION = 0x79;
67 static const int SAVE_GAME_LAST_STATIC_BUILDING_COUNT_VERSION = 0x80;
68 static const int SAVE_GAME_LAST_STATIC_MONUMENT_DELIVERIES_VERSION = 0x81;
69 static const int SAVE_GAME_LAST_STORED_IMAGE_IDS = 0x83;
70 // SAVE_GAME_INCREASE_GRANARY_CAPACITY shall be updated if we decide to change granary capacity again.
71 static const int SAVE_GAME_INCREASE_GRANARY_CAPACITY = 0x85;
72 // static const int SAVE_GAME_ROADBLOCK_DATA_MOVED_FROM_SUBTYPE = 0x86; This define is unneeded for now
73
74
75 static char compress_buffer[COMPRESS_BUFFER_SIZE];
76
77 typedef struct {
78 buffer buf;
79 int compressed;
80 int dynamic;
81 } file_piece;
82
83 typedef struct {
84 buffer *graphic_ids;
85 buffer *edge;
86 buffer *terrain;
87 buffer *bitfields;
88 buffer *random;
89 buffer *elevation;
90 buffer *random_iv;
91 buffer *camera;
92 buffer *scenario;
93 buffer *end_marker;
94 } scenario_state;
95
96 static struct {
97 int num_pieces;
98 file_piece pieces[10];
99 scenario_state state;
100 } scenario_data;
101
102 typedef struct {
103 buffer *scenario_campaign_mission;
104 buffer *file_version;
105 buffer *image_grid;
106 buffer *edge_grid;
107 buffer *building_grid;
108 buffer *terrain_grid;
109 buffer *aqueduct_grid;
110 buffer *figure_grid;
111 buffer *bitfields_grid;
112 buffer *sprite_grid;
113 buffer *random_grid;
114 buffer *desirability_grid;
115 buffer *elevation_grid;
116 buffer *building_damage_grid;
117 buffer *aqueduct_backup_grid;
118 buffer *sprite_backup_grid;
119 buffer *figures;
120 buffer *route_figures;
121 buffer *route_paths;
122 buffer *formations;
123 buffer *formation_totals;
124 buffer *city_data;
125 buffer *city_faction_unknown;
126 buffer *player_name;
127 buffer *city_faction;
128 buffer *buildings;
129 buffer *city_view_orientation;
130 buffer *game_time;
131 buffer *building_extra_highest_id_ever;
132 buffer *random_iv;
133 buffer *city_view_camera;
134 buffer *building_count_culture1;
135 buffer *city_graph_order;
136 buffer *emperor_change_time;
137 buffer *empire;
138 buffer *empire_cities;
139 buffer *building_count_industry;
140 buffer *trade_prices;
141 buffer *figure_names;
142 buffer *culture_coverage;
143 buffer *scenario;
144 buffer *max_game_year;
145 buffer *earthquake;
146 buffer *emperor_change_state;
147 buffer *messages;
148 buffer *message_extra;
149 buffer *population_messages;
150 buffer *message_counts;
151 buffer *message_delays;
152 buffer *building_list_burning_totals;
153 buffer *figure_sequence;
154 buffer *scenario_settings;
155 buffer *invasion_warnings;
156 buffer *scenario_is_custom;
157 buffer *city_sounds;
158 buffer *building_extra_highest_id;
159 buffer *figure_traders;
160 buffer *building_list_burning;
161 buffer *building_list_small;
162 buffer *building_list_large;
163 buffer *tutorial_part1;
164 buffer *building_count_military;
165 buffer *enemy_army_totals;
166 buffer *building_storages;
167 buffer *building_count_culture2;
168 buffer *building_count_support;
169 buffer *tutorial_part2;
170 buffer *gladiator_revolt;
171 buffer *trade_route_limit;
172 buffer *trade_route_traded;
173 buffer *building_barracks_tower_sentry;
174 buffer *building_extra_sequence;
175 buffer *routing_counters;
176 buffer *building_count_culture3;
177 buffer *enemy_armies;
178 buffer *city_entry_exit_xy;
179 buffer *last_invasion_id;
180 buffer *building_extra_corrupt_houses;
181 buffer *scenario_name;
182 buffer *bookmarks;
183 buffer *tutorial_part3;
184 buffer *city_entry_exit_grid_offset;
185 buffer *end_marker;
186 buffer *deliveries;
187 } savegame_state;
188
189 static struct {
190 int num_pieces;
191 file_piece pieces[100];
192 savegame_state state;
193 } savegame_data;
194
init_file_piece(file_piece * piece,int size,int compressed)195 static void init_file_piece(file_piece *piece, int size, int compressed)
196 {
197 piece->compressed = compressed;
198 piece->dynamic = size == PIECE_SIZE_DYNAMIC;
199 if (piece->dynamic) {
200 buffer_init(&piece->buf, 0, 0);
201 } else {
202 void *data = malloc(size);
203 memset(data, 0, size);
204 buffer_init(&piece->buf, data, size);
205 }
206 }
207
create_scenario_piece(int size)208 static buffer *create_scenario_piece(int size)
209 {
210 file_piece *piece = &scenario_data.pieces[scenario_data.num_pieces++];
211 init_file_piece(piece, size, 0);
212 return &piece->buf;
213 }
214
create_savegame_piece(int size,int compressed)215 static buffer *create_savegame_piece(int size, int compressed)
216 {
217 file_piece *piece = &savegame_data.pieces[savegame_data.num_pieces++];
218 init_file_piece(piece, size, compressed);
219 return &piece->buf;
220 }
221
clear_savegame_pieces(void)222 static void clear_savegame_pieces(void)
223 {
224 for (int i = 0; i < savegame_data.num_pieces; i++) {
225 buffer_reset(&savegame_data.pieces[i].buf);
226 free(savegame_data.pieces[i].buf.data);
227 }
228 savegame_data.num_pieces = 0;
229 }
230
init_scenario_data(void)231 static void init_scenario_data(void)
232 {
233 if (scenario_data.num_pieces > 0) {
234 for (int i = 0; i < scenario_data.num_pieces; i++) {
235 buffer_reset(&scenario_data.pieces[i].buf);
236 }
237 return;
238 }
239 scenario_state *state = &scenario_data.state;
240 state->graphic_ids = create_scenario_piece(52488);
241 state->edge = create_scenario_piece(26244);
242 state->terrain = create_scenario_piece(52488);
243 state->bitfields = create_scenario_piece(26244);
244 state->random = create_scenario_piece(26244);
245 state->elevation = create_scenario_piece(26244);
246 state->random_iv = create_scenario_piece(8);
247 state->camera = create_scenario_piece(8);
248 state->scenario = create_scenario_piece(1720);
249 state->end_marker = create_scenario_piece(4);
250 }
251
init_savegame_data(int version)252 static void init_savegame_data(int version)
253 {
254 clear_savegame_pieces();
255
256 int multiplier = 1;
257 int count_multiplier = 1;
258 int burning_totals_size = 8;
259 if (version > SAVE_GAME_LAST_ORIGINAL_LIMITS_VERSION) {
260 multiplier = 5;
261 }
262 if (version > SAVE_GAME_LAST_STATIC_VERSION) {
263 multiplier = PIECE_SIZE_DYNAMIC;
264 burning_totals_size = 4;
265 }
266
267 if (version > SAVE_GAME_LAST_STATIC_BUILDING_COUNT_VERSION) {
268 count_multiplier = PIECE_SIZE_DYNAMIC;
269 }
270
271 int image_grid_size = 52488 * (version > SAVE_GAME_LAST_SMALLER_IMAGE_ID_VERSION ? 2 : 1);
272 int figures_size = 128000 * multiplier;
273 int route_figures_size = 1200 * multiplier;
274 int route_paths_size = 300000 * multiplier;
275 int formations_size = 6400 * multiplier;
276 int buildings_size = 256000 * multiplier;
277 int building_list_burning_size = 1000 * multiplier;
278 int building_list_small_size = 1000 * multiplier;
279 int building_list_large_size = 4000 * multiplier;
280 int building_storages_size = 6400 * multiplier;
281
282 int building_count_culture1 = 132 * count_multiplier;
283 int building_count_culture2 = 32 * count_multiplier;
284 int building_count_culture3 = 40 * count_multiplier;
285 int building_count_military = 16 * count_multiplier;
286 int building_count_industry = 128 * count_multiplier;
287 int building_count_support = 24 * count_multiplier;
288
289
290 savegame_state *state = &savegame_data.state;
291 state->scenario_campaign_mission = create_savegame_piece(4, 0);
292 state->file_version = create_savegame_piece(4, 0);
293 if (version <= SAVE_GAME_LAST_STORED_IMAGE_IDS) {
294 state->image_grid = create_savegame_piece(image_grid_size, 1);
295 }
296 state->edge_grid = create_savegame_piece(26244, 1);
297 state->building_grid = create_savegame_piece(52488, 1);
298 state->terrain_grid = create_savegame_piece(52488, 1);
299 state->aqueduct_grid = create_savegame_piece(26244, 1);
300 state->figure_grid = create_savegame_piece(52488, 1);
301 state->bitfields_grid = create_savegame_piece(26244, 1);
302 state->sprite_grid = create_savegame_piece(26244, 1);
303 state->random_grid = create_savegame_piece(26244, 0);
304 state->desirability_grid = create_savegame_piece(26244, 1);
305 state->elevation_grid = create_savegame_piece(26244, 1);
306 state->building_damage_grid = create_savegame_piece(26244, 1);
307 state->aqueduct_backup_grid = create_savegame_piece(26244, 1);
308 state->sprite_backup_grid = create_savegame_piece(26244, 1);
309 state->figures = create_savegame_piece(figures_size, 1);
310 state->route_figures = create_savegame_piece(route_figures_size, 1);
311 state->route_paths = create_savegame_piece(route_paths_size, 1);
312 state->formations = create_savegame_piece(formations_size, 1);
313 state->formation_totals = create_savegame_piece(12, 0);
314 state->city_data = create_savegame_piece(36136, 1);
315 state->city_faction_unknown = create_savegame_piece(2, 0);
316 state->player_name = create_savegame_piece(64, 0);
317 state->city_faction = create_savegame_piece(4, 0);
318 state->buildings = create_savegame_piece(buildings_size, 1);
319 state->city_view_orientation = create_savegame_piece(4, 0);
320 state->game_time = create_savegame_piece(20, 0);
321 state->building_extra_highest_id_ever = create_savegame_piece(8, 0);
322 state->random_iv = create_savegame_piece(8, 0);
323 state->city_view_camera = create_savegame_piece(8, 0);
324 state->building_count_culture1 = create_savegame_piece(building_count_culture1, 0);
325 state->city_graph_order = create_savegame_piece(8, 0);
326 state->emperor_change_time = create_savegame_piece(8, 0);
327 state->empire = create_savegame_piece(12, 0);
328 state->empire_cities = create_savegame_piece(2706, 1);
329 state->building_count_industry = create_savegame_piece(building_count_industry, 0);
330 state->trade_prices = create_savegame_piece(128, 0);
331 state->figure_names = create_savegame_piece(84, 0);
332 state->culture_coverage = create_savegame_piece(60, 0);
333 state->scenario = create_savegame_piece(1720, 0);
334 state->max_game_year = create_savegame_piece(4, 0);
335 state->earthquake = create_savegame_piece(60, 0);
336 state->emperor_change_state = create_savegame_piece(4, 0);
337 state->messages = create_savegame_piece(16000, 1);
338 state->message_extra = create_savegame_piece(12, 0);
339 state->population_messages = create_savegame_piece(10, 0);
340 state->message_counts = create_savegame_piece(80, 0);
341 state->message_delays = create_savegame_piece(80, 0);
342 state->building_list_burning_totals = create_savegame_piece(burning_totals_size, 0);
343 state->figure_sequence = create_savegame_piece(4, 0);
344 state->scenario_settings = create_savegame_piece(12, 0);
345 state->invasion_warnings = create_savegame_piece(3232, 1);
346 state->scenario_is_custom = create_savegame_piece(4, 0);
347 state->city_sounds = create_savegame_piece(8960, 0);
348 state->building_extra_highest_id = create_savegame_piece(4, 0);
349 state->figure_traders = create_savegame_piece(4804, 0);
350 state->building_list_burning = create_savegame_piece(building_list_burning_size, 1);
351 state->building_list_small = create_savegame_piece(building_list_small_size, 1);
352 state->building_list_large = create_savegame_piece(building_list_large_size, 1);
353 state->tutorial_part1 = create_savegame_piece(32, 0);
354 state->building_count_military = create_savegame_piece(building_count_military, 0);
355 state->enemy_army_totals = create_savegame_piece(20, 0);
356 state->building_storages = create_savegame_piece(building_storages_size, 0);
357 state->building_count_culture2 = create_savegame_piece(building_count_culture2, 0);
358 state->building_count_support = create_savegame_piece(building_count_support, 0);
359 state->tutorial_part2 = create_savegame_piece(4, 0);
360 state->gladiator_revolt = create_savegame_piece(16, 0);
361 state->trade_route_limit = create_savegame_piece(1280, 1);
362 state->trade_route_traded = create_savegame_piece(1280, 1);
363 state->building_barracks_tower_sentry = create_savegame_piece(4, 0);
364 state->building_extra_sequence = create_savegame_piece(4, 0);
365 state->routing_counters = create_savegame_piece(16, 0);
366 state->building_count_culture3 = create_savegame_piece(building_count_culture3, 0);
367 state->enemy_armies = create_savegame_piece(900, 0);
368 state->city_entry_exit_xy = create_savegame_piece(16, 0);
369 state->last_invasion_id = create_savegame_piece(2, 0);
370 state->building_extra_corrupt_houses = create_savegame_piece(8, 0);
371 state->scenario_name = create_savegame_piece(65, 0);
372 state->bookmarks = create_savegame_piece(32, 0);
373 state->tutorial_part3 = create_savegame_piece(4, 0);
374 state->city_entry_exit_grid_offset = create_savegame_piece(8, 0);
375 state->end_marker = create_savegame_piece(284, 0); // 71x 4-bytes emptiness
376 if (version > SAVE_GAME_LAST_STATIC_MONUMENT_DELIVERIES_VERSION) {
377 state->deliveries = create_savegame_piece(PIECE_SIZE_DYNAMIC, 0);
378 } else if (version > SAVE_GAME_LAST_NO_DELIVERIES_VERSION) {
379 state->deliveries = create_savegame_piece(3200, 0);
380 }
381 }
382
scenario_load_from_state(scenario_state * file)383 static void scenario_load_from_state(scenario_state *file)
384 {
385 map_image_load_state_legacy(file->graphic_ids);
386 map_terrain_load_state(file->terrain);
387 map_property_load_state(file->bitfields, file->edge);
388 map_random_load_state(file->random);
389 map_elevation_load_state(file->elevation);
390 city_view_load_scenario_state(file->camera);
391
392 random_load_state(file->random_iv);
393
394 scenario_load_state(file->scenario);
395
396 buffer_skip(file->end_marker, 4);
397 }
398
scenario_save_to_state(scenario_state * file)399 static void scenario_save_to_state(scenario_state *file)
400 {
401 map_image_save_state_legacy(file->graphic_ids);
402 map_terrain_save_state(file->terrain);
403 map_property_save_state(file->bitfields, file->edge);
404 map_random_save_state(file->random);
405 map_elevation_save_state(file->elevation);
406 city_view_save_scenario_state(file->camera);
407
408 random_save_state(file->random_iv);
409
410 scenario_save_state(file->scenario);
411
412 buffer_skip(file->end_marker, 4);
413 }
414
savegame_load_from_state(savegame_state * state,int version)415 static void savegame_load_from_state(savegame_state *state, int version)
416 {
417 scenario_settings_load_state(state->scenario_campaign_mission,
418 state->scenario_settings,
419 state->scenario_is_custom,
420 state->player_name,
421 state->scenario_name);
422
423 map_building_load_state(state->building_grid, state->building_damage_grid);
424 map_terrain_load_state(state->terrain_grid);
425 map_aqueduct_load_state(state->aqueduct_grid, state->aqueduct_backup_grid);
426 map_figure_load_state(state->figure_grid);
427 map_sprite_load_state(state->sprite_grid, state->sprite_backup_grid);
428 map_property_load_state(state->bitfields_grid, state->edge_grid);
429 map_random_load_state(state->random_grid);
430 map_desirability_load_state(state->desirability_grid);
431 map_elevation_load_state(state->elevation_grid);
432 figure_load_state(state->figures, state->figure_sequence, version > SAVE_GAME_LAST_STATIC_VERSION);
433 figure_route_load_state(state->route_figures, state->route_paths);
434 formations_load_state(state->formations, state->formation_totals, version > SAVE_GAME_LAST_STATIC_VERSION);
435
436 city_data_load_state(state->city_data,
437 state->city_faction,
438 state->city_faction_unknown,
439 state->city_graph_order,
440 state->city_entry_exit_xy,
441 state->city_entry_exit_grid_offset,
442 version > SAVE_GAME_LAST_JOINED_IMPORT_EXPORT_VERSION);
443
444 building_load_state(state->buildings,
445 state->building_extra_sequence,
446 state->building_extra_corrupt_houses,
447 version > SAVE_GAME_LAST_STATIC_VERSION,
448 version);
449 building_barracks_load_state(state->building_barracks_tower_sentry);
450 city_view_load_state(state->city_view_orientation, state->city_view_camera);
451 game_time_load_state(state->game_time);
452 random_load_state(state->random_iv);
453 building_count_load_state(state->building_count_industry,
454 state->building_count_culture1,
455 state->building_count_culture2,
456 state->building_count_culture3,
457 state->building_count_military,
458 state->building_count_support,
459 version > SAVE_GAME_LAST_STATIC_BUILDING_COUNT_VERSION);
460 if (version < SAVE_GAME_INCREASE_GRANARY_CAPACITY) {
461 building_granary_update_built_granaries_capacity();
462 }
463
464 scenario_emperor_change_load_state(state->emperor_change_time, state->emperor_change_state);
465 empire_load_state(state->empire);
466 empire_city_load_state(state->empire_cities);
467 trade_prices_load_state(state->trade_prices);
468 figure_name_load_state(state->figure_names);
469 city_culture_load_state(state->culture_coverage);
470
471 scenario_load_state(state->scenario);
472 scenario_criteria_load_state(state->max_game_year);
473 scenario_earthquake_load_state(state->earthquake);
474 city_message_load_state(state->messages, state->message_extra,
475 state->message_counts, state->message_delays,
476 state->population_messages);
477 sound_city_load_state(state->city_sounds);
478 traders_load_state(state->figure_traders);
479
480 building_list_load_state(state->building_list_small, state->building_list_large,
481 state->building_list_burning, state->building_list_burning_totals,
482 version > SAVE_GAME_LAST_STATIC_VERSION);
483
484 tutorial_load_state(state->tutorial_part1, state->tutorial_part2, state->tutorial_part3);
485
486 building_storage_load_state(state->building_storages, version > SAVE_GAME_LAST_STATIC_VERSION);
487 scenario_gladiator_revolt_load_state(state->gladiator_revolt);
488 trade_routes_load_state(state->trade_route_limit, state->trade_route_traded);
489 map_routing_load_state(state->routing_counters);
490 enemy_armies_load_state(state->enemy_armies, state->enemy_army_totals);
491 scenario_invasion_load_state(state->last_invasion_id, state->invasion_warnings);
492 map_bookmark_load_state(state->bookmarks);
493
494 buffer_skip(state->end_marker, 284);
495 if (state) {
496 buffer_skip(state->end_marker, 8);
497 }
498 if (version <= SAVE_GAME_LAST_NO_DELIVERIES_VERSION) {
499 building_monument_initialize_deliveries();
500 } else {
501 building_monument_delivery_load_state(state->deliveries,
502 version > SAVE_GAME_LAST_STATIC_MONUMENT_DELIVERIES_VERSION);
503 }
504 map_image_clear();
505 scenario_map_init();
506 map_image_update_all();
507 }
508
savegame_save_to_state(savegame_state * state)509 static void savegame_save_to_state(savegame_state *state)
510 {
511 buffer_write_i32(state->file_version, SAVE_GAME_CURRENT_VERSION);
512
513 scenario_settings_save_state(state->scenario_campaign_mission,
514 state->scenario_settings,
515 state->scenario_is_custom,
516 state->player_name,
517 state->scenario_name);
518
519 map_building_save_state(state->building_grid, state->building_damage_grid);
520 map_terrain_save_state(state->terrain_grid);
521 map_aqueduct_save_state(state->aqueduct_grid, state->aqueduct_backup_grid);
522 map_figure_save_state(state->figure_grid);
523 map_sprite_save_state(state->sprite_grid, state->sprite_backup_grid);
524 map_property_save_state(state->bitfields_grid, state->edge_grid);
525 map_random_save_state(state->random_grid);
526 map_desirability_save_state(state->desirability_grid);
527 map_elevation_save_state(state->elevation_grid);
528
529 figure_save_state(state->figures, state->figure_sequence);
530 figure_route_save_state(state->route_figures, state->route_paths);
531 formations_save_state(state->formations, state->formation_totals);
532
533 city_data_save_state(state->city_data,
534 state->city_faction,
535 state->city_faction_unknown,
536 state->city_graph_order,
537 state->city_entry_exit_xy,
538 state->city_entry_exit_grid_offset);
539
540 building_save_state(state->buildings,
541 state->building_extra_highest_id,
542 state->building_extra_highest_id_ever,
543 state->building_extra_sequence,
544 state->building_extra_corrupt_houses);
545 building_barracks_save_state(state->building_barracks_tower_sentry);
546 city_view_save_state(state->city_view_orientation, state->city_view_camera);
547 game_time_save_state(state->game_time);
548 random_save_state(state->random_iv);
549 building_count_save_state(state->building_count_industry,
550 state->building_count_culture1,
551 state->building_count_culture2,
552 state->building_count_culture3,
553 state->building_count_military,
554 state->building_count_support);
555
556 scenario_emperor_change_save_state(state->emperor_change_time, state->emperor_change_state);
557 empire_save_state(state->empire);
558 empire_city_save_state(state->empire_cities);
559 trade_prices_save_state(state->trade_prices);
560 figure_name_save_state(state->figure_names);
561 city_culture_save_state(state->culture_coverage);
562
563 scenario_save_state(state->scenario);
564
565 scenario_criteria_save_state(state->max_game_year);
566 scenario_earthquake_save_state(state->earthquake);
567 city_message_save_state(state->messages, state->message_extra,
568 state->message_counts, state->message_delays,
569 state->population_messages);
570 sound_city_save_state(state->city_sounds);
571 traders_save_state(state->figure_traders);
572
573 building_list_save_state(state->building_list_small, state->building_list_large,
574 state->building_list_burning, state->building_list_burning_totals);
575
576 tutorial_save_state(state->tutorial_part1, state->tutorial_part2, state->tutorial_part3);
577
578 building_storage_save_state(state->building_storages);
579 scenario_gladiator_revolt_save_state(state->gladiator_revolt);
580 trade_routes_save_state(state->trade_route_limit, state->trade_route_traded);
581 map_routing_save_state(state->routing_counters);
582 enemy_armies_save_state(state->enemy_armies, state->enemy_army_totals);
583 scenario_invasion_save_state(state->last_invasion_id, state->invasion_warnings);
584 map_bookmark_save_state(state->bookmarks);
585
586 buffer_skip(state->end_marker, 284);
587
588 building_monument_delivery_save_state(state->deliveries);
589 }
590
game_file_io_read_scenario(const char * filename)591 int game_file_io_read_scenario(const char *filename)
592 {
593 log_info("Loading scenario", filename, 0);
594 init_scenario_data();
595 FILE *fp = file_open(dir_get_file(filename, NOT_LOCALIZED), "rb");
596 if (!fp) {
597 return 0;
598 }
599 for (int i = 0; i < scenario_data.num_pieces; i++) {
600 size_t read_size = fread(scenario_data.pieces[i].buf.data, 1, scenario_data.pieces[i].buf.size, fp);
601 if (read_size != scenario_data.pieces[i].buf.size) {
602 log_error("Unable to load scenario", filename, 0);
603 file_close(fp);
604 return 0;
605 }
606 }
607 file_close(fp);
608
609 scenario_load_from_state(&scenario_data.state);
610 return 1;
611 }
612
game_file_io_write_scenario(const char * filename)613 int game_file_io_write_scenario(const char *filename)
614 {
615 log_info("Saving scenario", filename, 0);
616 init_scenario_data();
617 scenario_save_to_state(&scenario_data.state);
618
619 FILE *fp = file_open(filename, "wb");
620 if (!fp) {
621 log_error("Unable to save scenario", 0, 0);
622 return 0;
623 }
624 for (int i = 0; i < scenario_data.num_pieces; i++) {
625 fwrite(scenario_data.pieces[i].buf.data, 1, scenario_data.pieces[i].buf.size, fp);
626 }
627 file_close(fp);
628 return 1;
629 }
630
read_int32(FILE * fp)631 static int read_int32(FILE *fp)
632 {
633 uint8_t data[4];
634 if (fread(&data, 1, 4, fp) != 4) {
635 return 0;
636 }
637 buffer buf;
638 buffer_init(&buf, data, 4);
639 return buffer_read_i32(&buf);
640 }
641
write_int32(FILE * fp,int value)642 static void write_int32(FILE *fp, int value)
643 {
644 uint8_t data[4];
645 buffer buf;
646 buffer_init(&buf, data, 4);
647 buffer_write_i32(&buf, value);
648 fwrite(&data, 1, 4, fp);
649 }
650
read_compressed_chunk(FILE * fp,void * buffer,int bytes_to_read)651 static int read_compressed_chunk(FILE *fp, void *buffer, int bytes_to_read)
652 {
653 if (bytes_to_read > COMPRESS_BUFFER_SIZE) {
654 return 0;
655 }
656 int input_size = read_int32(fp);
657 if ((unsigned int) input_size == UNCOMPRESSED) {
658 if (fread(buffer, 1, bytes_to_read, fp) != bytes_to_read) {
659 return 0;
660 }
661 } else {
662 if (fread(compress_buffer, 1, input_size, fp) != input_size
663 || !zip_decompress(compress_buffer, input_size, buffer, &bytes_to_read)) {
664 return 0;
665 }
666 }
667 return 1;
668 }
669
write_compressed_chunk(FILE * fp,const void * buffer,int bytes_to_write)670 static int write_compressed_chunk(FILE *fp, const void *buffer, int bytes_to_write)
671 {
672 if (bytes_to_write > COMPRESS_BUFFER_SIZE) {
673 return 0;
674 }
675 int output_size = COMPRESS_BUFFER_SIZE;
676 if (zip_compress(buffer, bytes_to_write, compress_buffer, &output_size)) {
677 write_int32(fp, output_size);
678 fwrite(compress_buffer, 1, output_size, fp);
679 } else {
680 // unable to compress: write uncompressed
681 write_int32(fp, UNCOMPRESSED);
682 fwrite(buffer, 1, bytes_to_write, fp);
683 }
684 return 1;
685 }
686
savegame_read_from_file(FILE * fp)687 static int savegame_read_from_file(FILE *fp)
688 {
689 for (int i = 0; i < savegame_data.num_pieces; i++) {
690 file_piece *piece = &savegame_data.pieces[i];
691 int result = 0;
692 if (piece->dynamic) {
693 int size = read_int32(fp);
694 if (!size) {
695 continue;
696 }
697 uint8_t *data = malloc(size);
698 memset(data, 0, size);
699 buffer_init(&piece->buf, data, size);
700 }
701 if (piece->compressed) {
702 result = read_compressed_chunk(fp, piece->buf.data, piece->buf.size);
703 } else {
704 result = fread(piece->buf.data, 1, piece->buf.size, fp) == piece->buf.size;
705 }
706 // The last piece may be smaller than buf.size
707 if (!result && i != (savegame_data.num_pieces - 1)) {
708 log_info("Incorrect buffer size, got", 0, result);
709 log_info("Incorrect buffer size, expected", 0, piece->buf.size);
710 return 0;
711 }
712 }
713 return 1;
714 }
715
savegame_write_to_file(FILE * fp)716 static void savegame_write_to_file(FILE *fp)
717 {
718 for (int i = 0; i < savegame_data.num_pieces; i++) {
719 file_piece *piece = &savegame_data.pieces[i];
720 if (piece->dynamic) {
721 write_int32(fp, piece->buf.size);
722 if (!piece->buf.size) {
723 continue;
724 }
725 }
726 if (piece->compressed) {
727 write_compressed_chunk(fp, piece->buf.data, piece->buf.size);
728 } else {
729 fwrite(piece->buf.data, 1, piece->buf.size, fp);
730 }
731 }
732 }
733
get_savegame_version(FILE * fp)734 static int get_savegame_version(FILE *fp)
735 {
736 buffer buf;
737 uint8_t data[4];
738 buffer_init(&buf, data, 4);
739 if (fseek(fp, 4, SEEK_CUR) ||
740 fread(data, 1, 4, fp) != 4 ||
741 fseek(fp, -8, SEEK_CUR)) {
742 return 0;
743 }
744 return buffer_read_i32(&buf);
745 }
746
game_file_io_read_saved_game(const char * filename,int offset)747 int game_file_io_read_saved_game(const char *filename, int offset)
748 {
749 log_info("Loading saved game", filename, 0);
750 FILE *fp = file_open(dir_get_file(filename, NOT_LOCALIZED), "rb");
751 if (!fp) {
752 log_error("Unable to load game, unable to open file.", 0, 0);
753 return 0;
754 }
755 if (offset) {
756 fseek(fp, offset, SEEK_SET);
757 }
758 int result = 0;
759 int version = get_savegame_version(fp);
760 if (version) {
761 if (version > SAVE_GAME_CURRENT_VERSION) {
762 log_error("Newer save game version than supported. Please update your Augustus. Version:", 0, version);
763 return -1;
764 }
765 log_info("Savegame version", 0, version);
766 init_savegame_data(version);
767 result = savegame_read_from_file(fp);
768 }
769 file_close(fp);
770 if (!result) {
771 log_error("Unable to load game, unable to read savefile.", 0, 0);
772 return 0;
773 }
774 savegame_load_from_state(&savegame_data.state, version);
775 return 1;
776 }
777
game_file_io_write_saved_game(const char * filename)778 int game_file_io_write_saved_game(const char *filename)
779 {
780 init_savegame_data(SAVE_GAME_CURRENT_VERSION);
781
782 log_info("Saving game", filename, 0);
783 savegame_save_to_state(&savegame_data.state);
784
785 FILE *fp = file_open(filename, "wb");
786 if (!fp) {
787 log_error("Unable to save game", 0, 0);
788 return 0;
789 }
790 savegame_write_to_file(fp);
791 file_close(fp);
792 return 1;
793 }
794
game_file_io_delete_saved_game(const char * filename)795 int game_file_io_delete_saved_game(const char *filename)
796 {
797 log_info("Deleting game", filename, 0);
798 int result = file_remove(filename);
799 if (!result) {
800 log_error("Unable to delete game", 0, 0);
801 }
802 return result;
803 }
804