Freeciv-3.2
Loading...
Searching...
No Matches
savegame2.c
Go to the documentation of this file.
1/***********************************************************************
2 Freeciv - Copyright (C) 1996 - A Kjeldberg, L Gregersen, P Unold
3 This program is free software; you can redistribute it and/or modify
4 it under the terms of the GNU General Public License as published by
5 the Free Software Foundation; either version 2, or (at your option)
6 any later version.
7
8 This program is distributed in the hope that it will be useful,
9 but WITHOUT ANY WARRANTY; without even the implied warranty of
10 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11 GNU General Public License for more details.
12***********************************************************************/
13
14/*
15 This file includes the definition of a new savegame format introduced with
16 2.3.0. It is defined by the mandatory option '+version2'. The main load
17 function checks if this option is present. If not, the old (pre-2.3.0)
18 loading routines are used.
19 The format version is also saved in the settings section of the savefile, as an
20 integer (savefile.version). The integer is used to determine the version
21 of the savefile.
22
23 Structure of this file:
24
25 - The real work is done by savegame2_load().
26 This function call all submodules (settings, players, etc.)
27
28 - The remaining part of this file is split into several sections:
29 * helper functions
30 * load functions for all submodules (and their subsubmodules)
31
32 - If possible, all functions for load submodules should exit in
33 pairs named sg_load_<submodule>. If one is not
34 needed please add a comment why.
35
36 - The submodules can be further divided as:
37 sg_load_<submodule>_<subsubmodule>
38
39 - If needed (due to static variables in the *.c files) these functions
40 can be located in the corresponding source files (as done for the settings
41 and the event_cache).
42
43 Loading a savegame:
44
45 - The status of the process is saved within the static variable
46 'sg_success'. This variable is set to TRUE within savegame2_load().
47 If you encounter an error use sg_failure_*() to set it to FALSE and
48 return an error message. Furthermore, sg_check_* should be used at the
49 start of each (submodule) function to return if previous functions failed.
50
51 - While the loading process dependencies between different modules exits.
52 They can be handled within the struct loaddata *loading which is used as
53 first argument for all sg_load_*() function. Please indicate the
54 dependencies within the definition of this struct.
55
56*/
57
58#ifdef HAVE_CONFIG_H
59#include <fc_config.h>
60#endif
61
62#include <ctype.h>
63#include <stdarg.h>
64#include <stdio.h>
65#include <stdlib.h>
66#include <string.h>
67
68/* utility */
69#include "bitvector.h"
70#include "fcintl.h"
71#include "idex.h"
72#include "log.h"
73#include "mem.h"
74#include "rand.h"
75#include "registry.h"
76#include "shared.h"
77#include "support.h" /* bool type */
78#include "timing.h"
79
80/* common */
81#include "achievements.h"
82#include "ai.h"
83#include "bitvector.h"
84#include "capability.h"
85#include "citizens.h"
86#include "city.h"
87#include "game.h"
88#include "government.h"
89#include "map.h"
90#include "mapimg.h"
91#include "movement.h"
92#include "multipliers.h"
93#include "packets.h"
94#include "research.h"
95#include "rgbcolor.h"
96#include "specialist.h"
97#include "unit.h"
98#include "unitlist.h"
99#include "version.h"
100
101/* server */
102#include "barbarian.h"
103#include "citizenshand.h"
104#include "citytools.h"
105#include "cityturn.h"
106#include "diplhand.h"
107#include "maphand.h"
108#include "meta.h"
109#include "notify.h"
110#include "plrhand.h"
111#include "report.h"
112#include "ruleset.h"
113#include "sanitycheck.h"
114#include "savecompat.h"
115#include "score.h"
116#include "settings.h"
117#include "spacerace.h"
118#include "srv_main.h"
119#include "stdinhand.h"
120#include "techtools.h"
121#include "unittools.h"
122
123/* server/advisors */
124#include "advdata.h"
125#include "advbuilding.h"
126#include "infracache.h"
127
128/* server/generator */
129#include "mapgen.h"
130#include "mapgen_utils.h"
131
132/* server/scripting */
133#include "script_server.h"
134
135/* ai */
136#include "aitraits.h"
137#include "difficulty.h"
138
139#include "savegame2.h"
140
141extern bool sg_success;
142
143#define ACTIVITY_OLD_ROAD (ACTIVITY_LAST + 1)
144#define ACTIVITY_OLD_RAILROAD (ACTIVITY_LAST + 2)
145#define ACTIVITY_OLD_POLLUTION_SG2 (ACTIVITY_OLD_RAILROAD + 1)
146#define ACTIVITY_OLD_FALLOUT_SG2 (ACTIVITY_OLD_POLLUTION_SG2 + 1)
147#define ACTIVITY_LAST_SAVEGAME2 (ACTIVITY_OLD_FALLOUT_SG2 + 1)
148
149/*
150 * This loops over the entire map to save data. It collects all the data of
151 * a line using GET_XY_CHAR and then executes the macro SECFILE_INSERT_LINE.
152 *
153 * Parameters:
154 * ptile: current tile within the line (used by GET_XY_CHAR)
155 * GET_XY_CHAR: macro returning the map character for each position
156 * secfile: a secfile struct
157 * secpath, ...: path as used for sprintf() with arguments; the last item
158 * will be the y coordinate
159 * Example:
160 * SAVE_MAP_CHAR(ptile, terrain2char(ptile->terrain), file, "map.t%04d");
161 */
162#define SAVE_MAP_CHAR(ptile, GET_XY_CHAR, secfile, secpath, ...) \
163{ \
164 char _line[wld.map.xsize + 1]; \
165 int _nat_x, _nat_y; \
166 \
167 for (_nat_y = 0; _nat_y < wld.map.ysize; _nat_y++) { \
168 for (_nat_x = 0; _nat_x < wld.map.xsize; _nat_x++) { \
169 struct tile *ptile = native_pos_to_tile(&(wld.map), _nat_x, _nat_y); \
170 fc_assert_action(ptile != NULL, continue); \
171 _line[_nat_x] = (GET_XY_CHAR); \
172 sg_failure_ret(fc_isprint(_line[_nat_x] & 0x7f), \
173 "Trying to write invalid map data at position " \
174 "(%d, %d) for path %s: '%c' (%d)", _nat_x, _nat_y, \
175 secpath, _line[_nat_x], _line[_nat_x]); \
176 } \
177 _line[wld.map.xsize] = '\0'; \
178 secfile_insert_str(secfile, _line, secpath, ## __VA_ARGS__, _nat_y); \
179 } \
180}
181
182/*
183 * This loops over the entire map to load data. It inputs a line of data
184 * using the macro SECFILE_LOOKUP_LINE and then loops using the macro
185 * SET_XY_CHAR to load each char into the map at (map_x, map_y). Internal
186 * variables ch, map_x, map_y, nat_x, and nat_y are allocated within the
187 * macro but definable by the caller.
188 *
189 * Parameters:
190 * ch: a variable to hold a char (data for a single position,
191 * used by SET_XY_CHAR)
192 * ptile: current tile within the line (used by SET_XY_CHAR)
193 * SET_XY_CHAR: macro to load the map character at each (map_x, map_y)
194 * secfile: a secfile struct
195 * secpath, ...: path as used for sprintf() with arguments; the last item
196 * will be the y coordinate
197 * Example:
198 * LOAD_MAP_CHAR(ch, ptile,
199 * map_get_player_tile(ptile, plr)->terrain
200 * = char2terrain(ch), file, "player%d.map_t%04d", plrno);
201 *
202 * Note: some (but not all) of the code this is replacing used to skip over
203 * lines that did not exist. This allowed for backward-compatibility.
204 * We could add another parameter that specified whether it was OK to
205 * skip the data, but there's not really much advantage to exiting
206 * early in this case. Instead, we let any map data type to be empty,
207 * and just print an informative warning message about it.
208 */
209#define LOAD_MAP_CHAR(ch, ptile, SET_XY_CHAR, secfile, secpath, ...) \
210{ \
211 int _nat_x, _nat_y; \
212 bool _printed_warning = FALSE; \
213 for (_nat_y = 0; _nat_y < wld.map.ysize; _nat_y++) { \
214 const char *_line = secfile_lookup_str(secfile, secpath, \
215 ## __VA_ARGS__, _nat_y); \
216 if (NULL == _line) { \
217 char buf[64]; \
218 fc_snprintf(buf, sizeof(buf), secpath, ## __VA_ARGS__, _nat_y); \
219 log_verbose("Line not found='%s'", buf); \
220 _printed_warning = TRUE; \
221 continue; \
222 } else if (strlen(_line) != wld.map.xsize) { \
223 char buf[64]; \
224 fc_snprintf(buf, sizeof(buf), secpath, ## __VA_ARGS__, _nat_y); \
225 log_verbose("Line too short (expected %d got " SIZE_T_PRINTF \
226 ")='%s'", wld.map.xsize, strlen(_line), buf); \
227 _printed_warning = TRUE; \
228 continue; \
229 } \
230 for (_nat_x = 0; _nat_x < wld.map.xsize; _nat_x++) { \
231 const char ch = _line[_nat_x]; \
232 struct tile *ptile = native_pos_to_tile(&(wld.map), _nat_x, _nat_y); \
233 (SET_XY_CHAR); \
234 } \
235 } \
236 if (_printed_warning) { \
237 /* TRANS: Minor error message. */ \
238 log_sg(_("Saved game contains incomplete map data. This can" \
239 " happen with old saved games, or it may indicate an" \
240 " invalid saved game file. Proceed at your own risk.")); \
241 } \
242}
243
244/* Iterate on the extras half-bytes */
245#define halfbyte_iterate_extras(e, num_extras_types) \
246{ \
247 int e; \
248 for (e = 0; 4 * e < (num_extras_types); e++) {
249
250#define halfbyte_iterate_extras_end \
251 } \
252}
253
254/* Iterate on the specials half-bytes */
255#define halfbyte_iterate_special(s, num_specials_types) \
256{ \
257 enum tile_special_type s; \
258 for (s = 0; 4 * s < (num_specials_types); s++) {
259
260#define halfbyte_iterate_special_end \
261 } \
262}
263
264/* Iterate on the bases half-bytes */
265#define halfbyte_iterate_bases(b, num_bases_types) \
266{ \
267 int b; \
268 for (b = 0; 4 * b < (num_bases_types); b++) {
269
270#define halfbyte_iterate_bases_end \
271 } \
272}
273
274/* Iterate on the roads half-bytes */
275#define halfbyte_iterate_roads(r, num_roads_types) \
276{ \
277 int r; \
278 for (r = 0; 4 * r < (num_roads_types); r++) {
279
280#define halfbyte_iterate_roads_end \
281 } \
282}
283
284#define TOKEN_SIZE 10
285
286#define ORDER_OLD_BUILD_CITY (-1)
287#define ORDER_OLD_DISBAND (-2)
288#define ORDER_OLD_BUILD_WONDER (-3)
289#define ORDER_OLD_TRADE_ROUTE (-4)
290#define ORDER_OLD_HOMECITY (-5)
291
292static struct loaddata *loaddata_new(struct section_file *file);
293static void loaddata_destroy(struct loaddata *loading);
294
295static enum unit_orders char2order(char order);
296static enum direction8 char2dir(char dir);
297static char activity2char(int activity);
298static int char2activity(char activity);
299static int unquote_block(const char *const quoted_, void *dest,
300 int dest_length);
301static void worklist_load(struct section_file *file, int wlist_max_length,
302 struct worklist *pwl,
303 const char *path, ...);
304static void unit_ordering_apply(void);
305static void sg_extras_set_dbv(struct dbv *extras, char ch,
306 struct extra_type **idx);
307static void sg_extras_set_bv(bv_extras *extras, char ch,
308 struct extra_type **idx);
309static void sg_special_set_dbv(struct tile *ptile, struct dbv *extras, char ch,
310 const enum tile_special_type *idx,
311 bool rivers_overlay);
312static void sg_special_set_bv(struct tile *ptile, bv_extras *extras, char ch,
313 const enum tile_special_type *idx,
314 bool rivers_overlay);
315static void sg_bases_set_dbv(struct dbv *extras, char ch, struct base_type **idx);
316static void sg_bases_set_bv(bv_extras *extras, char ch, struct base_type **idx);
317static void sg_roads_set_dbv(struct dbv *extras, char ch, struct road_type **idx);
318static void sg_roads_set_bv(bv_extras *extras, char ch, struct road_type **idx);
319static struct extra_type *char2resource(char c);
320static struct terrain *char2terrain(char ch);
321static Tech_type_id technology_load(struct section_file *file,
322 const char *path, int plrno);
323
324static void sg_load_ruleset(struct loaddata *loading);
325static void sg_load_savefile(struct loaddata *loading);
326
327static void sg_load_game(struct loaddata *loading);
328
329static void sg_load_ruledata(struct loaddata *loading);
330
331static void sg_load_random(struct loaddata *loading);
332
333static void sg_load_script(struct loaddata *loading);
334
335static void sg_load_scenario(struct loaddata *loading);
336
337static void sg_load_settings(struct loaddata *loading);
338
339static void sg_load_map(struct loaddata *loading);
340static void sg_load_map_tiles(struct loaddata *loading);
341static void sg_load_map_tiles_extras(struct loaddata *loading);
342static void sg_load_map_tiles_bases(struct loaddata *loading);
343static void sg_load_map_tiles_roads(struct loaddata *loading);
344static void sg_load_map_tiles_specials(struct loaddata *loading,
345 bool rivers_overlay);
346static void sg_load_map_tiles_resources(struct loaddata *loading);
347
348static void sg_load_map_startpos(struct loaddata *loading);
349static void sg_load_map_owner(struct loaddata *loading);
350static void sg_load_map_worked(struct loaddata *loading);
351static void sg_load_map_known(struct loaddata *loading);
352
353static void sg_load_players_basic(struct loaddata *loading);
354static void sg_load_players(struct loaddata *loading);
355static void sg_load_player_main(struct loaddata *loading,
356 struct player *plr);
357static void sg_load_player_cities(struct loaddata *loading,
358 struct player *plr);
359static bool sg_load_player_city(struct loaddata *loading, struct player *plr,
360 struct city *pcity, const char *citystr,
361 int wlist_max_length);
362static void sg_load_player_city_citizens(struct loaddata *loading,
363 struct player *plr,
364 struct city *pcity,
365 const char *citystr);
366static void sg_load_player_units(struct loaddata *loading,
367 struct player *plr);
368static bool sg_load_player_unit(struct loaddata *loading,
369 struct player *plr, struct unit *punit,
370 const char *unitstr);
371static void sg_load_player_units_transport(struct loaddata *loading,
372 struct player *plr);
373static void sg_load_player_attributes(struct loaddata *loading,
374 struct player *plr);
375static void sg_load_player_vision(struct loaddata *loading,
376 struct player *plr);
377static bool sg_load_player_vision_city(struct loaddata *loading,
378 struct player *plr,
379 struct vision_site *pdcity,
380 const char *citystr);
381
382static void sg_load_researches(struct loaddata *loading);
383
384static void sg_load_event_cache(struct loaddata *loading);
385
386static void sg_load_treaties(struct loaddata *loading);
387
388static void sg_load_history(struct loaddata *loading);
389
390static void sg_load_mapimg(struct loaddata *loading);
391
392static void sg_load_sanitycheck(struct loaddata *loading);
393
394
395/* =======================================================================
396 * Basic load / save functions.
397 * ======================================================================= */
398
399/************************************************************************/
402void savegame2_load(struct section_file *file)
403{
404 struct loaddata *loading;
405 bool was_send_city_suppressed, was_send_tile_suppressed;
406
407 /* initialise loading */
408 was_send_city_suppressed = send_city_suppression(TRUE);
409 was_send_tile_suppressed = send_tile_suppression(TRUE);
410 loading = loaddata_new(file);
411 sg_success = TRUE;
412
413 /* Load the savegame data. */
414 /* Set up correct ruleset */
415 sg_load_ruleset(loading);
416 /* [compat] */
417 sg_load_compat(loading, SAVEGAME_2);
418 /* [savefile] */
419 sg_load_savefile(loading);
420 /* [game] */
421 sg_load_game(loading);
422 /* [scenario] */
423 sg_load_scenario(loading);
424 /* [random] */
425 sg_load_random(loading);
426 /* [settings] */
427 sg_load_settings(loading);
428 /* [ruledata] */
429 sg_load_ruledata(loading);
430 /* [players] (basic data) */
431 sg_load_players_basic(loading);
432 /* [map]; needs width and height loaded by [settings] */
433 sg_load_map(loading);
434 /* [research] */
435 sg_load_researches(loading);
436 /* [player<i>] */
437 sg_load_players(loading);
438 /* [event_cache] */
439 sg_load_event_cache(loading);
440 /* [treaties] */
441 sg_load_treaties(loading);
442 /* [history] */
443 sg_load_history(loading);
444 /* [mapimg] */
445 sg_load_mapimg(loading);
446 /* [script] -- must come last as may reference game objects */
447 sg_load_script(loading);
448 /* [post_load_compat]; needs the game loaded by [savefile] */
449 sg_load_post_load_compat(loading, SAVEGAME_2);
450
451 /* Sanity checks for the loaded game. */
452 sg_load_sanitycheck(loading);
453
454 /* deinitialise loading */
455 loaddata_destroy(loading);
456 send_tile_suppression(was_send_tile_suppressed);
457 send_city_suppression(was_send_city_suppressed);
458
459 if (!sg_success) {
460 log_error("Failure loading savegame!");
461 /* Try to get the server back to a vaguely sane state */
462 server_game_free();
463 server_game_init(FALSE);
464 load_rulesets(NULL, NULL, FALSE, NULL, TRUE, FALSE, TRUE);
465 }
466}
467
468/************************************************************************/
471static struct loaddata *loaddata_new(struct section_file *file)
472{
473 struct loaddata *loading = calloc(1, sizeof(*loading));
474 loading->file = file;
475 loading->secfile_options = NULL;
476
477 loading->improvement.order = NULL;
478 loading->improvement.size = -1;
479 loading->technology.order = NULL;
480 loading->technology.size = -1;
481 loading->activities.order = NULL;
482 loading->activities.size = -1;
483 loading->trait.order = NULL;
484 loading->trait.size = -1;
485 loading->extra.order = NULL;
486 loading->extra.size = -1;
487 loading->multiplier.order = NULL;
488 loading->multiplier.size = -1;
489 loading->special.order = NULL;
490 loading->special.size = -1;
491 loading->base.order = NULL;
492 loading->base.size = -1;
493 loading->road.order = NULL;
494 loading->road.size = -1;
495 loading->specialist.order = NULL;
496 loading->specialist.size = -1;
497 loading->ds_t.order = NULL;
498 loading->ds_t.size = -1;
499 loading->coptions.order = NULL;
500 loading->coptions.size = -1;
501
502 loading->server_state = S_S_INITIAL;
503 loading->rstate = fc_rand_state();
504 loading->worked_tiles = NULL;
505
506 return loading;
507}
508
509/************************************************************************/
512static void loaddata_destroy(struct loaddata *loading)
513{
514 if (loading->improvement.order != NULL) {
515 free(loading->improvement.order);
516 }
517
518 if (loading->technology.order != NULL) {
519 free(loading->technology.order);
520 }
521
522 if (loading->activities.order != NULL) {
523 free(loading->activities.order);
524 }
525
526 if (loading->trait.order != NULL) {
527 free(loading->trait.order);
528 }
529
530 if (loading->extra.order != NULL) {
531 free(loading->extra.order);
532 }
533
534 if (loading->multiplier.order != NULL) {
535 free(loading->multiplier.order);
536 }
537
538 if (loading->special.order != NULL) {
539 free(loading->special.order);
540 }
541
542 if (loading->base.order != NULL) {
543 free(loading->base.order);
544 }
545
546 if (loading->road.order != NULL) {
547 free(loading->road.order);
548 }
549
550 if (loading->specialist.order != NULL) {
551 free(loading->specialist.order);
552 }
553
554 if (loading->ds_t.order != NULL) {
555 free(loading->ds_t.order);
556 }
557
558 if (loading->coptions.order != NULL) {
559 free(loading->coptions.order);
560 }
561
562 if (loading->worked_tiles != NULL) {
563 free(loading->worked_tiles);
564 }
565
566 free(loading);
567}
568
569
570/************************************************************************/
579
580/************************************************************************/
589
590/* =======================================================================
591 * Helper functions.
592 * ======================================================================= */
593
594/************************************************************************/
597static enum unit_orders char2order(char order)
598{
599 switch (order) {
600 case 'm':
601 case 'M':
602 return ORDER_MOVE;
603 case 'w':
604 case 'W':
605 return ORDER_FULL_MP;
606 case 'b':
607 case 'B':
608 return ORDER_OLD_BUILD_CITY;
609 case 'a':
610 case 'A':
611 return ORDER_ACTIVITY;
612 case 'd':
613 case 'D':
614 return ORDER_OLD_DISBAND;
615 case 'u':
616 case 'U':
617 return ORDER_OLD_BUILD_WONDER;
618 case 't':
619 case 'T':
620 return ORDER_OLD_TRADE_ROUTE;
621 case 'h':
622 case 'H':
623 return ORDER_OLD_HOMECITY;
624 case 'x':
625 case 'X':
626 return ORDER_ACTION_MOVE;
627 }
628
629 /* This can happen if the savegame is invalid. */
630 return ORDER_LAST;
631}
632
633/************************************************************************/
636static enum direction8 char2dir(char dir)
637{
638 /* Numberpad values for the directions. */
639 switch (dir) {
640 case '1':
641 return DIR8_SOUTHWEST;
642 case '2':
643 return DIR8_SOUTH;
644 case '3':
645 return DIR8_SOUTHEAST;
646 case '4':
647 return DIR8_WEST;
648 case '6':
649 return DIR8_EAST;
650 case '7':
651 return DIR8_NORTHWEST;
652 case '8':
653 return DIR8_NORTH;
654 case '9':
655 return DIR8_NORTHEAST;
656 }
657
658 /* This can happen if the savegame is invalid. */
659 return direction8_invalid();
660}
661
662/************************************************************************/
665static char activity2char(int activity)
666{
667 switch (activity) {
668 case ACTIVITY_IDLE:
669 return 'w';
670 case ACTIVITY_CLEAN:
671 return 'C';
672 case ACTIVITY_OLD_POLLUTION_SG2:
673 return 'p';
674 case ACTIVITY_OLD_ROAD:
675 return 'r';
676 case ACTIVITY_MINE:
677 return 'm';
678 case ACTIVITY_IRRIGATE:
679 return 'i';
680 case ACTIVITY_FORTIFIED:
681 return 'f';
682 case ACTIVITY_SENTRY:
683 return 's';
684 case ACTIVITY_OLD_RAILROAD:
685 return 'l';
686 case ACTIVITY_PILLAGE:
687 return 'e';
688 case ACTIVITY_GOTO:
689 return 'g';
690 case ACTIVITY_EXPLORE:
691 return 'x';
692 case ACTIVITY_TRANSFORM:
693 return 'o';
694 case ACTIVITY_FORTIFYING:
695 return 'y';
696 case ACTIVITY_OLD_FALLOUT_SG2:
697 return 'u';
698 case ACTIVITY_BASE:
699 return 'b';
700 case ACTIVITY_GEN_ROAD:
701 return 'R';
702 case ACTIVITY_CONVERT:
703 return 'c';
704 case ACTIVITY_CULTIVATE:
705 case ACTIVITY_PLANT:
706 return '?';
707 case ACTIVITY_LAST:
708 break;
709 }
710
711 fc_assert(FALSE);
712
713 return '?';
714}
715
716/************************************************************************/
719static int char2activity(char activity)
720{
721 int a;
722
723 for (a = 0; a < ACTIVITY_LAST_SAVEGAME2; a++) {
724 char achar = activity2char(a);
725
726 if (activity == achar) {
727 return a;
728 }
729 }
730
731 /* This can happen if the savegame is invalid. */
732 return ACTIVITY_LAST;
733}
734
735/************************************************************************/
740static int unquote_block(const char *const quoted_, void *dest,
741 int dest_length)
742{
743 int i, length, parsed, tmp;
744 char *endptr;
745 const char *quoted = quoted_;
746
747 parsed = sscanf(quoted, "%d", &length);
748
749 if (parsed != 1) {
750 log_error(_("Syntax error in attribute block."));
751 return 0;
752 }
753
754 if (length > dest_length) {
755 return 0;
756 }
757
758 quoted = strchr(quoted, ':');
759
760 if (quoted == NULL) {
761 log_error(_("Syntax error in attribute block."));
762 return 0;
763 }
764
765 quoted++;
766
767 for (i = 0; i < length; i++) {
768 tmp = strtol(quoted, &endptr, 16);
769
770 if ((endptr - quoted) != 2
771 || *endptr != ' '
772 || (tmp & 0xff) != tmp) {
773 log_error(_("Syntax error in attribute block."));
774 return 0;
775 }
776
777 ((unsigned char *) dest)[i] = tmp;
778 quoted += 3;
779 }
780
781 return length;
782}
783
784/************************************************************************/
788static void worklist_load(struct section_file *file, int wlist_max_length,
789 struct worklist *pwl, const char *path, ...)
790{
791 int i;
792 const char *kind;
793 const char *name;
794 char path_str[1024];
795 va_list ap;
796
797 /* The first part of the registry path is taken from the varargs to the
798 * function. */
799 va_start(ap, path);
800 fc_vsnprintf(path_str, sizeof(path_str), path, ap);
801 va_end(ap);
802
803 worklist_init(pwl);
804 pwl->length = secfile_lookup_int_default(file, 0,
805 "%s.wl_length", path_str);
806
807 for (i = 0; i < pwl->length; i++) {
808 kind = secfile_lookup_str(file, "%s.wl_kind%d", path_str, i);
809
810 /* We lookup the production value by name. An invalid entry isn't a
811 * fatal error; we just truncate the worklist. */
812 name = secfile_lookup_str_default(file, "-", "%s.wl_value%d",
813 path_str, i);
814 pwl->entries[i] = universal_by_rule_name(kind, name);
815 if (pwl->entries[i].kind == universals_n_invalid()) {
816 log_sg("%s.wl_value%d: unknown \"%s\" \"%s\".", path_str, i, kind,
817 name);
818 pwl->length = i;
819 break;
820 }
821 }
822
823 /* Padding entries */
824 for (; i < wlist_max_length; i++) {
825 (void) secfile_entry_lookup(file, "%s.wl_kind%d", path_str, i);
826 (void) secfile_entry_lookup(file, "%s.wl_value%d", path_str, i);
827 }
828}
829
830/************************************************************************/
834static void unit_ordering_apply(void)
835{
836 players_iterate(pplayer) {
837 city_list_iterate(pplayer->cities, pcity) {
838 unit_list_sort_ord_city(pcity->units_supported);
839 }
840 city_list_iterate_end;
841 } players_iterate_end;
842
843 whole_map_iterate(&(wld.map), ptile) {
844 unit_list_sort_ord_map(ptile->units);
845 } whole_map_iterate_end;
846}
847
848/************************************************************************/
855static void sg_extras_set_dbv(struct dbv *extras, char ch,
856 struct extra_type **idx)
857{
858 int i, bin;
859 const char *pch = strchr(hex_chars, ch);
860
861 if (!pch || ch == '\0') {
862 log_sg("Unknown hex value: '%c' (%d)", ch, ch);
863 bin = 0;
864 } else {
865 bin = pch - hex_chars;
866 }
867
868 for (i = 0; i < 4; i++) {
869 struct extra_type *pextra = idx[i];
870
871 if (pextra == NULL) {
872 continue;
873 }
874 if ((bin & (1 << i))
875 && (wld.map.server.have_huts || !is_extra_caused_by(pextra, EC_HUT))) {
876 dbv_set(extras, extra_index(pextra));
877 }
878 }
879}
880
881/************************************************************************/
888static void sg_extras_set_bv(bv_extras *extras, char ch,
889 struct extra_type **idx)
890{
891 int i, bin;
892 const char *pch = strchr(hex_chars, ch);
893
894 if (!pch || ch == '\0') {
895 log_sg("Unknown hex value: '%c' (%d)", ch, ch);
896 bin = 0;
897 } else {
898 bin = pch - hex_chars;
899 }
900
901 for (i = 0; i < 4; i++) {
902 struct extra_type *pextra = idx[i];
903
904 if (pextra == NULL) {
905 continue;
906 }
907 if ((bin & (1 << i))
908 && (wld.map.server.have_huts || !is_extra_caused_by(pextra, EC_HUT))) {
909 BV_SET(*extras, extra_index(pextra));
910 }
911 }
912}
913
914/************************************************************************/
921static void sg_special_set_dbv(struct tile *ptile, struct dbv *extras, char ch,
922 const enum tile_special_type *idx,
923 bool rivers_overlay)
924{
925 int i, bin;
926 const char *pch = strchr(hex_chars, ch);
927
928 if (!pch || ch == '\0') {
929 log_sg("Unknown hex value: '%c' (%d)", ch, ch);
930 bin = 0;
931 } else {
932 bin = pch - hex_chars;
933 }
934
935 for (i = 0; i < 4; i++) {
936 enum tile_special_type sp = idx[i];
937
938 if (sp == S_LAST) {
939 continue;
940 }
941 if (rivers_overlay && sp != S_OLD_RIVER) {
942 continue;
943 }
944
945 if (sp == S_HUT && !wld.map.server.have_huts) {
946 /* It would be logical to have this in the saving side -
947 * really not saving the huts in the first place, BUT
948 * 1) They have been saved by older versions, so we
949 * have to deal with such savegames.
950 * 2) This makes scenario author less likely to lose
951 * one's work completely after carefully placing huts
952 * and then saving with 'have_huts' disabled. */
953 continue;
954 }
955
956 if (bin & (1 << i)) {
957 if (sp == S_OLD_ROAD) {
958 struct road_type *proad;
959
960 proad = road_by_compat_special(ROCO_ROAD);
961 if (proad) {
962 BV_SET(*extras, extra_index(road_extra_get(proad)));
963 }
964 } else if (sp == S_OLD_RAILROAD) {
965 struct road_type *proad;
966
967 proad = road_by_compat_special(ROCO_RAILROAD);
968 if (proad) {
969 BV_SET(*extras, extra_index(road_extra_get(proad)));
970 }
971 } else if (sp == S_OLD_RIVER) {
972 struct road_type *proad;
973
974 proad = road_by_compat_special(ROCO_RIVER);
975 if (proad) {
976 BV_SET(*extras, extra_index(road_extra_get(proad)));
977 }
978 } else {
979 struct extra_type *pextra = NULL;
980 enum extra_cause cause = EC_COUNT;
981
982 /* Converting from old hardcoded specials to as sensible extra as we can */
983 switch (sp) {
984 case S_IRRIGATION:
985 case S_FARMLAND:
986 /* If old savegame has both irrigation and farmland, EC_IRRIGATION
987 * gets applied twice, which hopefully has the correct result. */
988 cause = EC_IRRIGATION;
989 break;
990 case S_MINE:
991 cause = EC_MINE;
992 break;
993 case S_POLLUTION:
994 cause = EC_POLLUTION;
995 break;
996 case S_HUT:
997 cause = EC_HUT;
998 break;
999 case S_FALLOUT:
1000 cause = EC_FALLOUT;
1001 break;
1002 default:
1003 pextra = extra_type_by_rule_name(special_rule_name(sp));
1004 break;
1005 }
1006
1007 if (cause != EC_COUNT) {
1008 struct tile *vtile = tile_virtual_new(ptile);
1009 struct terrain *pterr = tile_terrain(vtile);
1010 const struct req_context tile_ctxt = { .tile = vtile };
1011
1012 /* Do not let the extras already set to the real tile mess with setup
1013 * of the player tiles if that's what we're doing. */
1014 dbv_to_bv(vtile->extras.vec, extras);
1015
1016 /* It's ok not to know which player or which unit originally built the extra -
1017 * in the rules used when specials were saved these could not have made any
1018 * difference. */
1019 /* Can't use next_extra_for_tile() as it works for buildable extras only. */
1020
1021 if ((cause != EC_IRRIGATION || pterr->irrigation_time != 0)
1022 && (cause != EC_MINE || pterr->mining_time != 0)
1023 && (cause != EC_BASE || pterr->base_time != 0)
1024 && (cause != EC_ROAD || pterr->road_time != 0)) {
1025 extra_type_by_cause_iterate(cause, candidate) {
1026 if (!tile_has_extra(vtile, candidate)) {
1027 if ((!is_extra_caused_by(candidate, EC_BASE)
1028 || tile_city(vtile) != NULL
1029 || extra_base_get(candidate)->border_sq <= 0)
1030 && are_reqs_active(&tile_ctxt, tile_owner(vtile),
1031 &candidate->reqs,
1032 RPT_POSSIBLE)) {
1033 pextra = candidate;
1034 break;
1035 }
1036 }
1037 } extra_type_by_cause_iterate_end;
1038 }
1039
1040 tile_virtual_destroy(vtile);
1041 }
1042
1043 if (pextra) {
1044 dbv_set(extras, extra_index(pextra));
1045 }
1046 }
1047 }
1048 }
1049}
1050
1051/************************************************************************/
1058static void sg_special_set_bv(struct tile *ptile, bv_extras *extras, char ch,
1059 const enum tile_special_type *idx,
1060 bool rivers_overlay)
1061{
1062 int i, bin;
1063 const char *pch = strchr(hex_chars, ch);
1064
1065 if (!pch || ch == '\0') {
1066 log_sg("Unknown hex value: '%c' (%d)", ch, ch);
1067 bin = 0;
1068 } else {
1069 bin = pch - hex_chars;
1070 }
1071
1072 for (i = 0; i < 4; i++) {
1073 enum tile_special_type sp = idx[i];
1074
1075 if (sp == S_LAST) {
1076 continue;
1077 }
1078 if (rivers_overlay && sp != S_OLD_RIVER) {
1079 continue;
1080 }
1081
1082 if (sp == S_HUT && !wld.map.server.have_huts) {
1083 /* It would be logical to have this in the saving side -
1084 * really not saving the huts in the first place, BUT
1085 * 1) They have been saved by older versions, so we
1086 * have to deal with such savegames.
1087 * 2) This makes scenario author less likely to lose
1088 * one's work completely after carefully placing huts
1089 * and then saving with 'have_huts' disabled. */
1090 continue;
1091 }
1092
1093 if (bin & (1 << i)) {
1094 if (sp == S_OLD_ROAD) {
1095 struct road_type *proad;
1096
1097 proad = road_by_compat_special(ROCO_ROAD);
1098 if (proad) {
1099 BV_SET(*extras, extra_index(road_extra_get(proad)));
1100 }
1101 } else if (sp == S_OLD_RAILROAD) {
1102 struct road_type *proad;
1103
1104 proad = road_by_compat_special(ROCO_RAILROAD);
1105 if (proad) {
1106 BV_SET(*extras, extra_index(road_extra_get(proad)));
1107 }
1108 } else if (sp == S_OLD_RIVER) {
1109 struct road_type *proad;
1110
1111 proad = road_by_compat_special(ROCO_RIVER);
1112 if (proad) {
1113 BV_SET(*extras, extra_index(road_extra_get(proad)));
1114 }
1115 } else {
1116 struct extra_type *pextra = NULL;
1117 enum extra_cause cause = EC_COUNT;
1118
1119 /* Converting from old hardcoded specials to as sensible extra as we can */
1120 switch (sp) {
1121 case S_IRRIGATION:
1122 case S_FARMLAND:
1123 /* If old savegame has both irrigation and farmland, EC_IRRIGATION
1124 * gets applied twice, which hopefully has the correct result. */
1125 cause = EC_IRRIGATION;
1126 break;
1127 case S_MINE:
1128 cause = EC_MINE;
1129 break;
1130 case S_POLLUTION:
1131 cause = EC_POLLUTION;
1132 break;
1133 case S_HUT:
1134 cause = EC_HUT;
1135 break;
1136 case S_FALLOUT:
1137 cause = EC_FALLOUT;
1138 break;
1139 default:
1140 pextra = extra_type_by_rule_name(special_rule_name(sp));
1141 break;
1142 }
1143
1144 if (cause != EC_COUNT) {
1145 struct tile *vtile = tile_virtual_new(ptile);
1146 struct terrain *pterr = tile_terrain(vtile);
1147 const struct req_context tile_ctxt = { .tile = vtile };
1148
1149 /* Do not let the extras already set to the real tile mess with setup
1150 * of the player tiles if that's what we're doing. */
1151 vtile->extras = *extras;
1152
1153 /* It's ok not to know which player or which unit originally built the extra -
1154 * in the rules used when specials were saved these could not have made any
1155 * difference. */
1156 /* Can't use next_extra_for_tile() as it works for buildable extras only. */
1157
1158 if ((cause != EC_IRRIGATION || pterr->irrigation_time != 0)
1159 && (cause != EC_MINE || pterr->mining_time != 0)
1160 && (cause != EC_BASE || pterr->base_time != 0)
1161 && (cause != EC_ROAD || pterr->road_time != 0)) {
1162 extra_type_by_cause_iterate(cause, candidate) {
1163 if (!tile_has_extra(vtile, candidate)) {
1164 if ((!is_extra_caused_by(candidate, EC_BASE)
1165 || tile_city(vtile) != NULL
1166 || extra_base_get(candidate)->border_sq <= 0)
1167 && are_reqs_active(&tile_ctxt, tile_owner(vtile),
1168 &candidate->reqs,
1169 RPT_POSSIBLE)) {
1170 pextra = candidate;
1171 break;
1172 }
1173 }
1174 } extra_type_by_cause_iterate_end;
1175 }
1176
1177 tile_virtual_destroy(vtile);
1178 }
1179
1180 if (pextra) {
1181 BV_SET(*extras, extra_index(pextra));
1182 }
1183 }
1184 }
1185 }
1186}
1187
1188/************************************************************************/
1195static void sg_bases_set_dbv(struct dbv *extras, char ch,
1196 struct base_type **idx)
1197{
1198 int i, bin;
1199 const char *pch = strchr(hex_chars, ch);
1200
1201 if (!pch || ch == '\0') {
1202 log_sg("Unknown hex value: '%c' (%d)", ch, ch);
1203 bin = 0;
1204 } else {
1205 bin = pch - hex_chars;
1206 }
1207
1208 for (i = 0; i < 4; i++) {
1209 struct base_type *pbase = idx[i];
1210
1211 if (pbase == NULL) {
1212 continue;
1213 }
1214 if (bin & (1 << i)) {
1215 dbv_set(extras, extra_index(base_extra_get(pbase)));
1216 }
1217 }
1218}
1219
1220/************************************************************************/
1227static void sg_bases_set_bv(bv_extras *extras, char ch, struct base_type **idx)
1228{
1229 int i, bin;
1230 const char *pch = strchr(hex_chars, ch);
1231
1232 if (!pch || ch == '\0') {
1233 log_sg("Unknown hex value: '%c' (%d)", ch, ch);
1234 bin = 0;
1235 } else {
1236 bin = pch - hex_chars;
1237 }
1238
1239 for (i = 0; i < 4; i++) {
1240 struct base_type *pbase = idx[i];
1241
1242 if (pbase == NULL) {
1243 continue;
1244 }
1245 if (bin & (1 << i)) {
1246 BV_SET(*extras, extra_index(base_extra_get(pbase)));
1247 }
1248 }
1249}
1250
1251/************************************************************************/
1258static void sg_roads_set_dbv(struct dbv *extras, char ch, struct road_type **idx)
1259{
1260 int i, bin;
1261 const char *pch = strchr(hex_chars, ch);
1262
1263 if (!pch || ch == '\0') {
1264 log_sg("Unknown hex value: '%c' (%d)", ch, ch);
1265 bin = 0;
1266 } else {
1267 bin = pch - hex_chars;
1268 }
1269
1270 for (i = 0; i < 4; i++) {
1271 struct road_type *proad = idx[i];
1272
1273 if (proad == NULL) {
1274 continue;
1275 }
1276 if (bin & (1 << i)) {
1277 dbv_set(extras, extra_index(road_extra_get(proad)));
1278 }
1279 }
1280}
1281
1282/************************************************************************/
1289static void sg_roads_set_bv(bv_extras *extras, char ch, struct road_type **idx)
1290{
1291 int i, bin;
1292 const char *pch = strchr(hex_chars, ch);
1293
1294 if (!pch || ch == '\0') {
1295 log_sg("Unknown hex value: '%c' (%d)", ch, ch);
1296 bin = 0;
1297 } else {
1298 bin = pch - hex_chars;
1299 }
1300
1301 for (i = 0; i < 4; i++) {
1302 struct road_type *proad = idx[i];
1303
1304 if (proad == NULL) {
1305 continue;
1306 }
1307 if (bin & (1 << i)) {
1308 BV_SET(*extras, extra_index(road_extra_get(proad)));
1309 }
1310 }
1311}
1312
1313/************************************************************************/
1316static struct extra_type *char2resource(char c)
1317{
1318 /* speed common values */
1319 if (c == RESOURCE_NULL_IDENTIFIER
1320 || c == RESOURCE_NONE_IDENTIFIER) {
1321 return NULL;
1322 }
1323
1324 return resource_by_identifier(c);
1325}
1326
1327/************************************************************************/
1331static struct terrain *char2terrain(char ch)
1332{
1333 /* terrain_by_identifier plus fatal error */
1334 if (ch == TERRAIN_UNKNOWN_IDENTIFIER) {
1335 return T_UNKNOWN;
1336 }
1337 terrain_type_iterate(pterrain) {
1338 if (pterrain->identifier == ch) {
1339 return pterrain;
1340 }
1341 } terrain_type_iterate_end;
1342
1343 log_fatal("Unknown terrain identifier '%c' in savegame.", ch);
1344
1345 exit(EXIT_FAILURE);
1346
1347 RETURN_VALUE_AFTER_EXIT(NULL);
1348}
1349
1350/************************************************************************/
1353static Tech_type_id technology_load(struct section_file *file,
1354 const char *path, int plrno)
1355{
1356 char path_with_name[128];
1357 const char *name;
1358 struct advance *padvance;
1359
1360 fc_snprintf(path_with_name, sizeof(path_with_name),
1361 "%s_name", path);
1362
1363 name = secfile_lookup_str(file, path_with_name, plrno);
1364
1365 if (!name || name[0] == '\0') {
1366 /* Used by researching_saved */
1367 return A_UNKNOWN;
1368 }
1369 if (fc_strcasecmp(name, "A_FUTURE") == 0) {
1370 return A_FUTURE;
1371 }
1372 if (fc_strcasecmp(name, "A_NONE") == 0) {
1373 return A_NONE;
1374 }
1375 if (fc_strcasecmp(name, "A_UNSET") == 0) {
1376 return A_UNSET;
1377 }
1378
1379 padvance = advance_by_rule_name(name);
1380 sg_failure_ret_val(NULL != padvance, A_NONE,
1381 "%s: unknown technology \"%s\".", path_with_name, name);
1382
1383 return advance_number(padvance);
1384}
1385
1386/* =======================================================================
1387 * Load savefile data.
1388 * ======================================================================= */
1389
1390/************************************************************************/
1393static void sg_load_ruleset(struct loaddata *loading)
1394{
1395 const char *ruleset = secfile_lookup_str_default(loading->file,
1396 GAME_DEFAULT_RULESETDIR,
1397 "savefile.rulesetdir");
1398
1399 /* Load ruleset. */
1400 sz_strlcpy(game.server.rulesetdir, ruleset);
1401 if (!strcmp("default", game.server.rulesetdir)) {
1402 int version;
1403
1404 version = secfile_lookup_int_default(loading->file, -1, "savefile.version");
1405 if (version >= 30) {
1406 /* Here 'default' really means current default.
1407 * Saving happens with real ruleset name, so savegames containing this
1408 * are special scenarios. */
1409 sz_strlcpy(game.server.rulesetdir, GAME_DEFAULT_RULESETDIR);
1410 } else {
1411 /* 'default' is the old name of the classic ruleset */
1412 sz_strlcpy(game.server.rulesetdir, "classic");
1413 }
1414 log_verbose("Savegame specified ruleset '%s'. Really loading '%s'.",
1415 ruleset, game.server.rulesetdir);
1416 }
1417 if (!load_rulesets(NULL, NULL, FALSE, NULL, TRUE, FALSE, TRUE)) {
1418 /* Failed to load correct ruleset */
1419 sg_failure_ret(FALSE, _("Failed to load ruleset '%s' needed for savegame."),
1420 ruleset);
1421 }
1422}
1423
1424/************************************************************************/
1427static void sg_load_savefile(struct loaddata *loading)
1428{
1429 int i;
1430 const char *terr_name;
1431 const char *str;
1432
1433 /* Check status and return if not OK (sg_success FALSE). */
1434 sg_check_ret();
1435
1436 /* Load savefile options. */
1437 loading->secfile_options
1438 = secfile_lookup_str(loading->file, "savefile.options");
1439
1440 /* We don't need these entries, but read them anyway to avoid
1441 * warnings about unread secfile entries. */
1442 (void) secfile_entry_by_path(loading->file, "savefile.reason");
1443 (void) secfile_entry_by_path(loading->file, "savefile.revision");
1444
1445 str = secfile_lookup_str(loading->file, "savefile.orig_version");
1446 sz_strlcpy(game.server.orig_game_version, str);
1447
1448 /* In case of savegame2.c saves, missing entry means savegame older than support
1449 * for saving last_updated by turn. So this must default to TRUE. */
1450 game.server.last_updated_year = secfile_lookup_bool_default(loading->file, TRUE,
1451 "savefile.last_updated_as_year");
1452
1453 /* Load improvements. */
1454 loading->improvement.size
1455 = secfile_lookup_int_default(loading->file, 0,
1456 "savefile.improvement_size");
1457 if (loading->improvement.size) {
1458 loading->improvement.order
1459 = secfile_lookup_str_vec(loading->file, &loading->improvement.size,
1460 "savefile.improvement_vector");
1461 sg_failure_ret(loading->improvement.size != 0,
1462 "Failed to load improvement order: %s",
1463 secfile_error());
1464 }
1465
1466 /* Load technologies. */
1467 loading->technology.size
1468 = secfile_lookup_int_default(loading->file, 0,
1469 "savefile.technology_size");
1470 if (loading->technology.size) {
1471 loading->technology.order
1472 = secfile_lookup_str_vec(loading->file, &loading->technology.size,
1473 "savefile.technology_vector");
1474 sg_failure_ret(loading->technology.size != 0,
1475 "Failed to load technology order: %s",
1476 secfile_error());
1477 }
1478
1479 /* Load Activities. */
1480 loading->activities.size
1481 = secfile_lookup_int_default(loading->file, 0,
1482 "savefile.activities_size");
1483 if (loading->activities.size) {
1484 loading->activities.order
1485 = secfile_lookup_str_vec(loading->file, &loading->activities.size,
1486 "savefile.activities_vector");
1487 sg_failure_ret(loading->activities.size != 0,
1488 "Failed to load activity order: %s",
1489 secfile_error());
1490 }
1491
1492 /* Load traits. */
1493 loading->trait.size
1494 = secfile_lookup_int_default(loading->file, 0,
1495 "savefile.trait_size");
1496 if (loading->trait.size) {
1497 loading->trait.order
1498 = secfile_lookup_str_vec(loading->file, &loading->trait.size,
1499 "savefile.trait_vector");
1500 sg_failure_ret(loading->trait.size != 0,
1501 "Failed to load trait order: %s",
1502 secfile_error());
1503 }
1504
1505 /* Load extras. */
1506 loading->extra.size
1507 = secfile_lookup_int_default(loading->file, 0,
1508 "savefile.extras_size");
1509 if (loading->extra.size) {
1510 const char **modname;
1511 size_t nmod;
1512 int j;
1513
1514 modname = secfile_lookup_str_vec(loading->file, &loading->extra.size,
1515 "savefile.extras_vector");
1516 sg_failure_ret(loading->extra.size != 0,
1517 "Failed to load extras order: %s",
1518 secfile_error());
1519 sg_failure_ret(!(game.control.num_extra_types < loading->extra.size),
1520 "Number of extras defined by the ruleset (= %d) are "
1521 "lower than the number in the savefile (= %d).",
1522 game.control.num_extra_types, (int)loading->extra.size);
1523 /* make sure that the size of the array is divisible by 4 */
1524 nmod = 4 * ((loading->extra.size + 3) / 4);
1525 loading->extra.order = fc_calloc(nmod, sizeof(*loading->extra.order));
1526 for (j = 0; j < loading->extra.size; j++) {
1527 loading->extra.order[j] = extra_type_by_rule_name(modname[j]);
1528 }
1529 free(modname);
1530 for (; j < nmod; j++) {
1531 loading->extra.order[j] = NULL;
1532 }
1533 }
1534
1535 /* Load multipliers. */
1536 loading->multiplier.size
1537 = secfile_lookup_int_default(loading->file, 0,
1538 "savefile.multipliers_size");
1539 if (loading->multiplier.size) {
1540 const char **modname;
1541 int j;
1542
1543 modname = secfile_lookup_str_vec(loading->file, &loading->multiplier.size,
1544 "savefile.multipliers_vector");
1545 sg_failure_ret(loading->multiplier.size != 0,
1546 "Failed to load multipliers order: %s",
1547 secfile_error());
1548 /* It's OK for the set of multipliers in the savefile to differ
1549 * from those in the ruleset. */
1550 loading->multiplier.order = fc_calloc(loading->multiplier.size,
1551 sizeof(*loading->multiplier.order));
1552 for (j = 0; j < loading->multiplier.size; j++) {
1553 loading->multiplier.order[j] = multiplier_by_rule_name(modname[j]);
1554 if (!loading->multiplier.order[j]) {
1555 log_verbose("Multiplier \"%s\" in savegame but not in ruleset, "
1556 "discarding", modname[j]);
1557 }
1558 }
1559 free(modname);
1560 }
1561
1562 /* Load specials. */
1563 loading->special.size
1564 = secfile_lookup_int_default(loading->file, 0,
1565 "savefile.specials_size");
1566 if (loading->special.size) {
1567 const char **modname;
1568 size_t nmod;
1569 enum tile_special_type j;
1570
1571 modname = secfile_lookup_str_vec(loading->file, &loading->special.size,
1572 "savefile.specials_vector");
1573 sg_failure_ret(loading->special.size != 0,
1574 "Failed to load specials order: %s",
1575 secfile_error());
1576 /* make sure that the size of the array is divisible by 4 */
1577 /* Allocating extra 4 slots, just a couple of bytes,
1578 * in case of special.size being divisible by 4 already is intentional.
1579 * Added complexity would cost those couple of bytes in code size alone,
1580 * and we actually need at least one slot immediately after last valid
1581 * one. That's where S_LAST is (or was in version that saved the game)
1582 * and in some cases S_LAST gets written to savegame, at least as
1583 * activity target special when activity targets some base or road
1584 * instead. By having current S_LAST in that index allows us to map
1585 * that old S_LAST to current S_LAST, just like any real special within
1586 * special.size gets mapped. */
1587 nmod = loading->special.size + (4 - (loading->special.size % 4));
1588 loading->special.order = fc_calloc(nmod,
1589 sizeof(*loading->special.order));
1590 for (j = 0; j < loading->special.size; j++) {
1591 if (!fc_strcasecmp("Road", modname[j])) {
1592 loading->special.order[j] = S_OLD_ROAD;
1593 } else if (!fc_strcasecmp("Railroad", modname[j])) {
1594 loading->special.order[j] = S_OLD_RAILROAD;
1595 } else if (!fc_strcasecmp("River", modname[j])) {
1596 loading->special.order[j] = S_OLD_RIVER;
1597 } else {
1598 loading->special.order[j] = special_by_rule_name(modname[j]);
1599 }
1600 }
1601 free(modname);
1602 for (; j < nmod; j++) {
1603 loading->special.order[j] = S_LAST;
1604 }
1605 }
1606
1607 /* Load bases. */
1608 loading->base.size
1609 = secfile_lookup_int_default(loading->file, 0,
1610 "savefile.bases_size");
1611 if (loading->base.size) {
1612 const char **modname;
1613 size_t nmod;
1614 int j;
1615
1616 modname = secfile_lookup_str_vec(loading->file, &loading->base.size,
1617 "savefile.bases_vector");
1618 sg_failure_ret(loading->base.size != 0,
1619 "Failed to load bases order: %s",
1620 secfile_error());
1621 /* make sure that the size of the array is divisible by 4 */
1622 nmod = 4 * ((loading->base.size + 3) / 4);
1623 loading->base.order = fc_calloc(nmod, sizeof(*loading->base.order));
1624 for (j = 0; j < loading->base.size; j++) {
1625 struct extra_type *pextra = extra_type_by_rule_name(modname[j]);
1626
1627 sg_failure_ret(pextra != NULL
1628 || game.control.num_base_types >= loading->base.size,
1629 "Unknown base type %s in savefile.",
1630 modname[j]);
1631
1632 if (pextra != NULL) {
1633 loading->base.order[j] = extra_base_get(pextra);
1634 } else {
1635 loading->base.order[j] = NULL;
1636 }
1637 }
1638 free(modname);
1639 for (; j < nmod; j++) {
1640 loading->base.order[j] = NULL;
1641 }
1642 }
1643
1644 /* Load roads. */
1645 loading->road.size
1646 = secfile_lookup_int_default(loading->file, 0,
1647 "savefile.roads_size");
1648 if (loading->road.size) {
1649 const char **modname;
1650 size_t nmod;
1651 int j;
1652
1653 modname = secfile_lookup_str_vec(loading->file, &loading->road.size,
1654 "savefile.roads_vector");
1655 sg_failure_ret(loading->road.size != 0,
1656 "Failed to load roads order: %s",
1657 secfile_error());
1658 sg_failure_ret(!(game.control.num_road_types < loading->road.size),
1659 "Number of roads defined by the ruleset (= %d) are "
1660 "lower than the number in the savefile (= %d).",
1661 game.control.num_road_types, (int)loading->road.size);
1662 /* make sure that the size of the array is divisible by 4 */
1663 nmod = 4 * ((loading->road.size + 3) / 4);
1664 loading->road.order = fc_calloc(nmod, sizeof(*loading->road.order));
1665 for (j = 0; j < loading->road.size; j++) {
1666 struct extra_type *pextra = extra_type_by_rule_name(modname[j]);
1667
1668 if (pextra != NULL) {
1669 loading->road.order[j] = extra_road_get(pextra);
1670 } else {
1671 loading->road.order[j] = NULL;
1672 }
1673 }
1674 free(modname);
1675 for (; j < nmod; j++) {
1676 loading->road.order[j] = NULL;
1677 }
1678 }
1679
1680 /* Load specialists. */
1681 loading->specialist.size
1682 = secfile_lookup_int_default(loading->file, 0,
1683 "savefile.specialists_size");
1684 if (loading->specialist.size) {
1685 const char **modname;
1686 size_t nmod;
1687 int j;
1688
1689 modname = secfile_lookup_str_vec(loading->file, &loading->specialist.size,
1690 "savefile.specialists_vector");
1691 sg_failure_ret(loading->specialist.size != 0,
1692 "Failed to load specialists order: %s",
1693 secfile_error());
1694 sg_failure_ret(!(game.control.num_specialist_types < loading->specialist.size),
1695 "Number of specialists defined by the ruleset (= %d) are "
1696 "lower than the number in the savefile (= %d).",
1697 game.control.num_specialist_types, (int)loading->specialist.size);
1698 /* make sure that the size of the array is divisible by 4 */
1699 /* That's not really needed with specialists at the moment, but done this way
1700 * for consistency with other types, and to be prepared for the time it needs
1701 * to be this way. */
1702 nmod = 4 * ((loading->specialist.size + 3) / 4);
1703 loading->specialist.order = fc_calloc(nmod, sizeof(*loading->specialist.order));
1704 for (j = 0; j < loading->specialist.size; j++) {
1705 loading->specialist.order[j] = specialist_by_rule_name(modname[j]);
1706 }
1707 free(modname);
1708 for (; j < nmod; j++) {
1709 loading->specialist.order[j] = NULL;
1710 }
1711 }
1712
1713 /* Load diplomatic state type order. */
1714 loading->ds_t.size
1715 = secfile_lookup_int_default(loading->file, 0,
1716 "savefile.diplstate_type_size");
1717
1718 sg_failure_ret(loading->ds_t.size > 0,
1719 "Failed to load diplomatic state type order: %s",
1720 secfile_error());
1721
1722 if (loading->ds_t.size) {
1723 const char **modname;
1724 int j;
1725
1726 modname = secfile_lookup_str_vec(loading->file, &loading->ds_t.size,
1727 "savefile.diplstate_type_vector");
1728
1729 loading->ds_t.order = fc_calloc(loading->ds_t.size,
1730 sizeof(*loading->ds_t.order));
1731
1732 for (j = 0; j < loading->ds_t.size; j++) {
1733 loading->ds_t.order[j] = diplstate_type_by_name(modname[j],
1734 fc_strcasecmp);
1735 }
1736
1737 free(modname);
1738 }
1739
1740 /* Load city options order. */
1741 loading->coptions.size
1742 = secfile_lookup_int_default(loading->file, 0,
1743 "savefile.city_options_size");
1744
1745 {
1746 const char *modname_old[] = { "Disband", "Sci_Specialists", "Tax_Specialists" };
1747 const char **modname;
1748 int j;
1749 bool compat;
1750
1751 if (loading->coptions.size > 0) {
1752 modname = secfile_lookup_str_vec(loading->file, &loading->coptions.size,
1753 "savefile.city_options_vector");
1754 compat = FALSE;
1755 } else {
1756 modname = modname_old;
1757 loading->coptions.size = 3;
1758 compat = TRUE;
1759 }
1760
1761 loading->coptions.order = fc_calloc(loading->coptions.size,
1762 sizeof(*loading->coptions.order));
1763
1764 for (j = 0; j < loading->coptions.size; j++) {
1765 loading->coptions.order[j] = city_options_by_name(modname[j],
1766 fc_strcasecmp);
1767 }
1768
1769 if (!compat) {
1770 free(modname);
1771 }
1772 }
1773
1774 /* Terrain identifiers */
1775 terrain_type_iterate(pterr) {
1776 pterr->identifier_load = '\0';
1777 } terrain_type_iterate_end;
1778
1779 i = 0;
1780 while ((terr_name = secfile_lookup_str_default(loading->file, NULL,
1781 "savefile.terrident%d.name", i)) != NULL) {
1782 struct terrain *pterr = terrain_by_rule_name(terr_name);
1783
1784 if (pterr != NULL) {
1785 const char *iptr = secfile_lookup_str_default(loading->file, NULL,
1786 "savefile.terrident%d.identifier", i);
1787
1788 pterr->identifier_load = *iptr;
1789 } else {
1790 log_error("Identifier for unknown terrain type %s.", terr_name);
1791 }
1792 i++;
1793 }
1794
1795 terrain_type_iterate(pterr) {
1796 terrain_type_iterate(pterr2) {
1797 if (pterr != pterr2 && pterr->identifier_load != '\0') {
1798 sg_failure_ret((pterr->identifier_load != pterr2->identifier_load),
1799 "%s and %s share a saved identifier",
1800 terrain_rule_name(pterr), terrain_rule_name(pterr2));
1801 }
1802 } terrain_type_iterate_end;
1803 } terrain_type_iterate_end;
1804}
1805
1806/* =======================================================================
1807 * Load game status.
1808 * ======================================================================= */
1809
1810/************************************************************************/
1813static void sg_load_ruledata(struct loaddata *loading)
1814{
1815 int i;
1816 const char *name;
1817
1818 /* Check status and return if not OK (sg_success FALSE). */
1819 sg_check_ret();
1820
1821 for (i = 0;
1822 (name = secfile_lookup_str_default(loading->file, NULL,
1823 "ruledata.government%d.name", i));
1824 i++) {
1825 struct government *gov = government_by_rule_name(name);
1826
1827 if (gov != NULL) {
1828 gov->changed_to_times = secfile_lookup_int_default(loading->file, 0,
1829 "ruledata.government%d.changes", i);
1830 }
1831 }
1832}
1833
1834/************************************************************************/
1837static void sg_load_game(struct loaddata *loading)
1838{
1839 int game_version;
1840 const char *str;
1841 int i;
1842
1843 /* Check status and return if not OK (sg_success FALSE). */
1844 sg_check_ret();
1845
1846 /* Load version. */
1847 game_version
1848 = secfile_lookup_int_default(loading->file, 0, "game.version");
1849 /* We require at least version 2.2.99 */
1850 sg_failure_ret(20299 <= game_version, "Saved game is too old, at least "
1851 "version 2.2.99 required.");
1852
1853 loading->full_version = game_version;
1854
1855 secfile_entry_ignore(loading->file, "scenario.game_version");
1856
1857 /* Load server state. */
1858 str = secfile_lookup_str_default(loading->file, "S_S_INITIAL",
1859 "game.server_state");
1860 loading->server_state = server_states_by_name(str, strcmp);
1861 if (!server_states_is_valid(loading->server_state)) {
1862 /* Don't take any risk! */
1863 loading->server_state = S_S_INITIAL;
1864 }
1865
1866 str = secfile_lookup_str_default(loading->file,
1867 default_meta_patches_string(),
1868 "game.meta_patches");
1869 set_meta_patches_string(str);
1870
1871 if (0 == strcmp(DEFAULT_META_SERVER_ADDR, srvarg.metaserver_addr)) {
1872 /* Do not overwrite this if the user requested a specific metaserver
1873 * from the command line (option --Metaserver). */
1874 sz_strlcpy(srvarg.metaserver_addr,
1875 secfile_lookup_str_default(loading->file,
1876 DEFAULT_META_SERVER_ADDR,
1877 "game.meta_server"));
1878 }
1879
1880 if ('\0' == srvarg.serverid[0]) {
1881 /* Do not overwrite this if the user requested a specific metaserver
1882 * from the command line (option --serverid). */
1883 sz_strlcpy(srvarg.serverid,
1884 secfile_lookup_str_default(loading->file, "",
1885 "game.serverid"));
1886 }
1887 sz_strlcpy(server.game_identifier,
1888 secfile_lookup_str_default(loading->file, "", "game.id"));
1889 /* We are not checking game_identifier legality just yet.
1890 * That's done when we are sure that rand seed has been initialized,
1891 * so that we can generate new game_identifier, if needed.
1892 * See sq_load_sanitycheck(). */
1893
1894 game.info.phase_mode
1895 = secfile_lookup_int_default(loading->file, GAME_DEFAULT_PHASE_MODE,
1896 "game.phase_mode");
1897 game.server.phase_mode_stored
1898 = secfile_lookup_int_default(loading->file, GAME_DEFAULT_PHASE_MODE,
1899 "game.phase_mode_stored");
1900 game.info.phase
1901 = secfile_lookup_int_default(loading->file, 0,
1902 "game.phase");
1903 game.server.scoreturn
1904 = secfile_lookup_int_default(loading->file,
1905 game.info.turn + GAME_DEFAULT_SCORETURN,
1906 "game.scoreturn");
1907
1908 game.server.timeoutint
1909 = secfile_lookup_int_default(loading->file, GAME_DEFAULT_TIMEOUTINT,
1910 "game.timeoutint");
1911 game.server.timeoutintinc
1912 = secfile_lookup_int_default(loading->file, GAME_DEFAULT_TIMEOUTINTINC,
1913 "game.timeoutintinc");
1914 game.server.timeoutinc
1915 = secfile_lookup_int_default(loading->file, GAME_DEFAULT_TIMEOUTINC,
1916 "game.timeoutinc");
1917 game.server.timeoutincmult
1918 = secfile_lookup_int_default(loading->file, GAME_DEFAULT_TIMEOUTINCMULT,
1919 "game.timeoutincmult");
1920 game.server.timeoutcounter
1921 = secfile_lookup_int_default(loading->file, GAME_DEFAULT_TIMEOUTCOUNTER,
1922 "game.timeoutcounter");
1923
1924 game.info.turn
1925 = secfile_lookup_int_default(loading->file, 0, "game.turn");
1926 sg_failure_ret(secfile_lookup_int(loading->file, &game.info.year,
1927 "game.year"), "%s", secfile_error());
1928 game.info.year_0_hack
1929 = secfile_lookup_bool_default(loading->file, FALSE, "game.year_0_hack");
1930
1931 game.info.globalwarming
1932 = secfile_lookup_int_default(loading->file, 0, "game.globalwarming");
1933 game.info.heating
1934 = secfile_lookup_int_default(loading->file, 0, "game.heating");
1935 game.info.warminglevel
1936 = secfile_lookup_int_default(loading->file, 0, "game.warminglevel");
1937
1938 game.info.nuclearwinter
1939 = secfile_lookup_int_default(loading->file, 0, "game.nuclearwinter");
1940 game.info.cooling
1941 = secfile_lookup_int_default(loading->file, 0, "game.cooling");
1942 game.info.coolinglevel
1943 = secfile_lookup_int_default(loading->file, 0, "game.coolinglevel");
1944
1945 /* Savegame may have stored random_seed for documentation purposes only,
1946 * but we want to keep it for resaving. */
1947 game.server.seed = secfile_lookup_int_default(loading->file, 0, "game.random_seed");
1948
1949 /* Global advances. */
1950 str = secfile_lookup_str_default(loading->file, NULL,
1951 "game.global_advances");
1952 if (str != NULL) {
1953 sg_failure_ret(strlen(str) == loading->technology.size,
1954 "Invalid length of 'game.global_advances' ("
1955 SIZE_T_PRINTF " ~= " SIZE_T_PRINTF ").",
1956 strlen(str), loading->technology.size);
1957 for (i = 0; i < loading->technology.size; i++) {
1958 sg_failure_ret(str[i] == '1' || str[i] == '0',
1959 "Undefined value '%c' within 'game.global_advances'.",
1960 str[i]);
1961 if (str[i] == '1') {
1962 struct advance *padvance =
1963 advance_by_rule_name(loading->technology.order[i]);
1964
1965 if (padvance != NULL) {
1966 game.info.global_advances[advance_number(padvance)] = TRUE;
1967 }
1968 }
1969 }
1970 }
1971
1972 game.info.is_new_game
1973 = !secfile_lookup_bool_default(loading->file, TRUE, "game.save_players");
1974
1975 game.server.turn_change_time
1976 = secfile_lookup_int_default(loading->file, 0, "game.last_turn_change_time") / 100.0;
1977}
1978
1979/* =======================================================================
1980 * Load random status.
1981 * ======================================================================= */
1982
1983/************************************************************************/
1986static void sg_load_random(struct loaddata *loading)
1987{
1988 /* Check status and return if not OK (sg_success FALSE). */
1989 sg_check_ret();
1990
1991 if (secfile_lookup_bool_default(loading->file, FALSE, "random.saved")) {
1992 const char *str;
1993 int i;
1994
1995 /* Since random state was previously saved, save it also when resaving.
1996 * This affects only pre-2.6 scenarios where scenario.save_random
1997 * is not defined.
1998 * - If this is 2.6 or later scenario -> it would have saved random.saved = TRUE
1999 * only if scenario.save_random is already TRUE
2000 *
2001 * Do NOT touch this in case of regular savegame. They always have random.saved
2002 * set, but if one starts to make scenario based on a savegame, we want
2003 * default scenario settings in the beginning (default save_random = FALSE).
2004 */
2005 if (game.scenario.is_scenario) {
2006 game.scenario.save_random = TRUE;
2007 }
2008
2009 sg_failure_ret(secfile_lookup_int(loading->file, &loading->rstate.j,
2010 "random.index_J"), "%s", secfile_error());
2011 sg_failure_ret(secfile_lookup_int(loading->file, &loading->rstate.k,
2012 "random.index_K"), "%s", secfile_error());
2013 sg_failure_ret(secfile_lookup_int(loading->file, &loading->rstate.x,
2014 "random.index_X"), "%s", secfile_error());
2015
2016 for (i = 0; i < 8; i++) {
2017 str = secfile_lookup_str(loading->file, "random.table%d",i);
2018 sg_failure_ret(NULL != str, "%s", secfile_error());
2019 sscanf(str, "%8x %8x %8x %8x %8x %8x %8x", &loading->rstate.v[7*i],
2020 &loading->rstate.v[7*i+1], &loading->rstate.v[7*i+2],
2021 &loading->rstate.v[7*i+3], &loading->rstate.v[7*i+4],
2022 &loading->rstate.v[7*i+5], &loading->rstate.v[7*i+6]);
2023 }
2024 loading->rstate.is_init = TRUE;
2025 fc_rand_set_state(loading->rstate);
2026 } else {
2027 /* No random values - mark the setting. */
2028 (void) secfile_entry_by_path(loading->file, "random.saved");
2029
2030 /* We're loading a game without a seed (which is okay, if it's a scenario).
2031 * We need to generate the game seed now because it will be needed later
2032 * during the load. */
2033 init_game_seed();
2034 loading->rstate = fc_rand_state();
2035 }
2036}
2037
2038/* =======================================================================
2039 * Load lua script data.
2040 * ======================================================================= */
2041
2042/************************************************************************/
2045static void sg_load_script(struct loaddata *loading)
2046{
2047 /* Check status and return if not OK (sg_success FALSE). */
2048 sg_check_ret();
2049
2050 script_server_state_load(loading->file);
2051}
2052
2053/* =======================================================================
2054 * Load scenario data.
2055 * ======================================================================= */
2056
2057/************************************************************************/
2060static void sg_load_scenario(struct loaddata *loading)
2061{
2062 const char *buf;
2063 bool lake_flood_default;
2064
2065 /* Check status and return if not OK (sg_success FALSE). */
2066 sg_check_ret();
2067
2068 if (NULL == secfile_section_lookup(loading->file, "scenario")) {
2069 game.scenario.is_scenario = FALSE;
2070
2071 return;
2072 }
2073
2074 /* Default is that when there's scenario section (which we already checked)
2075 * this is a scenario. Only if it explicitly says that it's not, we consider
2076 * this regular savegame */
2077 game.scenario.is_scenario = secfile_lookup_bool_default(loading->file, TRUE, "scenario.is_scenario");
2078
2079 if (!game.scenario.is_scenario) {
2080 return;
2081 }
2082
2083 buf = secfile_lookup_str_default(loading->file, "", "scenario.name");
2084 if (buf[0] != '\0') {
2085 sz_strlcpy(game.scenario.name, buf);
2086 }
2087
2088 buf = secfile_lookup_str_default(loading->file, "",
2089 "scenario.authors");
2090 if (buf[0] != '\0') {
2091 sz_strlcpy(game.scenario.authors, buf);
2092 } else {
2093 game.scenario.authors[0] = '\0';
2094 }
2095
2096 buf = secfile_lookup_str_default(loading->file, "",
2097 "scenario.description");
2098 if (buf[0] != '\0') {
2099 sz_strlcpy(game.scenario_desc.description, buf);
2100 } else {
2101 game.scenario_desc.description[0] = '\0';
2102 }
2103
2104 game.scenario.save_random
2105 = secfile_lookup_bool_default(loading->file, FALSE, "scenario.save_random");
2106 game.scenario.players
2107 = secfile_lookup_bool_default(loading->file, TRUE, "scenario.players");
2108 game.scenario.startpos_nations
2109 = secfile_lookup_bool_default(loading->file, FALSE,
2110 "scenario.startpos_nations");
2111
2112 game.scenario.prevent_new_cities
2113 = secfile_lookup_bool_default(loading->file, FALSE,
2114 "scenario.prevent_new_cities");
2115 if (loading->version < 20599) {
2116 /* Lake flooding may break some old scenarios where rivers made out of
2117 * lake terrains, so play safe there */
2118 lake_flood_default = FALSE;
2119 } else {
2120 /* If lake flooding is a problem for a newer scenario, it could explicitly
2121 * disable it. */
2122 lake_flood_default = TRUE;
2123 }
2124 game.scenario.lake_flooding
2125 = secfile_lookup_bool_default(loading->file, lake_flood_default,
2126 "scenario.lake_flooding");
2127 game.scenario.handmade
2128 = secfile_lookup_bool_default(loading->file, FALSE,
2129 "scenario.handmade");
2130 game.scenario.allow_ai_type_fallback
2131 = secfile_lookup_bool_default(loading->file, FALSE,
2132 "scenario.allow_ai_type_fallback");
2133 game.scenario.ruleset_locked = TRUE;
2134
2135 sg_failure_ret(loading->server_state == S_S_INITIAL
2136 || (loading->server_state == S_S_RUNNING
2137 && game.scenario.players),
2138 "Invalid scenario definition (server state '%s' and "
2139 "players are %s).",
2140 server_states_name(loading->server_state),
2141 game.scenario.players ? "saved" : "not saved");
2142
2143 /* Remove all defined players. They are recreated with the skill level
2144 * defined by the scenario. */
2145 (void) aifill(0);
2146}
2147
2148/* =======================================================================
2149 * Load game settings.
2150 * ======================================================================= */
2151
2152/************************************************************************/
2155static void sg_load_settings(struct loaddata *loading)
2156{
2157 /* Check status and return if not OK (sg_success FALSE). */
2158 sg_check_ret();
2159
2160 settings_game_load(loading->file, "settings");
2161
2162 /* Save current status of fogofwar. */
2163 game.server.fogofwar_old = game.info.fogofwar;
2164
2165 /* Add all compatibility settings here. */
2166}
2167
2168/* =======================================================================
2169 * Load the main map.
2170 * ======================================================================= */
2171
2172/************************************************************************/
2175static void sg_load_map(struct loaddata *loading)
2176{
2177 /* Check status and return if not OK (sg_success FALSE). */
2178 sg_check_ret();
2179
2180 /* This defaults to TRUE even if map has not been generated. Also,
2181 * old versions have also explicitly saved TRUE even in pre-game.
2182 * We rely on that
2183 * 1) scenario maps have it explicitly right.
2184 * 2) when map is actually generated, it re-initialize this to FALSE. */
2185 wld.map.server.have_huts
2186 = secfile_lookup_bool_default(loading->file, TRUE, "map.have_huts");
2187
2188 /* Savegame may have stored random_seed for documentation purposes only,
2189 * but we want to keep it for resaving. */
2190 wld.map.server.seed
2191 = secfile_lookup_int_default(loading->file, 0, "map.random_seed");
2192
2193 if (S_S_INITIAL == loading->server_state
2194 && MAPGEN_SCENARIO == wld.map.server.generator) {
2195 /* Generator MAPGEN_SCENARIO is used;
2196 * this map was done with the map editor. */
2197
2198 /* Load tiles. */
2199 sg_load_map_tiles(loading);
2200 sg_load_map_startpos(loading);
2201
2202 if (loading->version >= 30) {
2203 /* 2.6.0 or newer */
2204 sg_load_map_tiles_extras(loading);
2205 } else {
2206 sg_load_map_tiles_bases(loading);
2207 if (loading->version >= 20) {
2208 /* 2.5.0 or newer */
2209 sg_load_map_tiles_roads(loading);
2210 }
2211 if (has_capability("specials", loading->secfile_options)) {
2212 /* Load specials. */
2213 sg_load_map_tiles_specials(loading, FALSE);
2214 }
2215 }
2216
2217 /* have_resources TRUE only if set so by sg_load_map_tiles_resources() */
2218 game.scenario.have_resources = FALSE;
2219 if (has_capability("specials", loading->secfile_options)) {
2220 /* Load resources. */
2221 sg_load_map_tiles_resources(loading);
2222 } else if (has_capability("riversoverlay", loading->secfile_options)) {
2223 /* Load only rivers overlay. */
2224 sg_load_map_tiles_specials(loading, TRUE);
2225 }
2226
2227 /* Nothing more needed for a scenario. */
2228 secfile_entry_ignore(loading->file, "game.save_known");
2229
2230 return;
2231 }
2232
2233 if (S_S_INITIAL == loading->server_state) {
2234 /* Nothing more to do if it is not a scenario but in initial state. */
2235 return;
2236 }
2237
2238 sg_load_map_tiles(loading);
2239 sg_load_map_startpos(loading);
2240 if (loading->version >= 30) {
2241 /* 2.6.0 or newer */
2242 sg_load_map_tiles_extras(loading);
2243 } else {
2244 sg_load_map_tiles_bases(loading);
2245 if (loading->version >= 20) {
2246 /* 2.5.0 or newer */
2247 sg_load_map_tiles_roads(loading);
2248 }
2249 sg_load_map_tiles_specials(loading, FALSE);
2250 }
2251 sg_load_map_tiles_resources(loading);
2252 sg_load_map_known(loading);
2253 sg_load_map_owner(loading);
2254 sg_load_map_worked(loading);
2255}
2256
2257/************************************************************************/
2260static void sg_load_map_tiles(struct loaddata *loading)
2261{
2262 /* Check status and return if not OK (sg_success FALSE). */
2263 sg_check_ret();
2264
2265 /* Initialize the map for the current topology. 'map.xsize' and
2266 * 'map.ysize' must be set. */
2267 map_init_topology(&(wld.map));
2268
2269 /* Allocate map. */
2270 main_map_allocate();
2271
2272 /* get the terrain type */
2273 LOAD_MAP_CHAR(ch, ptile, ptile->terrain = char2terrain(ch), loading->file,
2274 "map.t%04d");
2275 assign_continent_numbers();
2276
2277 /* Check for special tile sprites. */
2278 whole_map_iterate(&(wld.map), ptile) {
2279 const char *spec_sprite;
2280 const char *label;
2281 int nat_x, nat_y;
2282
2283 index_to_native_pos(&nat_x, &nat_y, tile_index(ptile));
2284 spec_sprite = secfile_lookup_str(loading->file, "map.spec_sprite_%d_%d",
2285 nat_x, nat_y);
2286 label = secfile_lookup_str_default(loading->file, NULL, "map.label_%d_%d",
2287 nat_x, nat_y);
2288 if (NULL != ptile->spec_sprite) {
2289 ptile->spec_sprite = fc_strdup(spec_sprite);
2290 }
2291 if (label != NULL) {
2292 tile_set_label(ptile, label);
2293 }
2294 } whole_map_iterate_end;
2295}
2296
2297/************************************************************************/
2300static void sg_load_map_tiles_extras(struct loaddata *loading)
2301{
2302 /* Check status and return if not OK (sg_success FALSE). */
2303 sg_check_ret();
2304
2305 /* Load extras. */
2306 halfbyte_iterate_extras(j, loading->extra.size) {
2307 LOAD_MAP_CHAR(ch, ptile, sg_extras_set_bv(&ptile->extras,
2308 ch, loading->extra.order + 4 * j),
2309 loading->file, "map.e%02d_%04d", j);
2310 } halfbyte_iterate_extras_end;
2311}
2312
2313/************************************************************************/
2316static void sg_load_map_tiles_bases(struct loaddata *loading)
2317{
2318 /* Check status and return if not OK (sg_success FALSE). */
2319 sg_check_ret();
2320
2321 /* Load bases. */
2322 halfbyte_iterate_bases(j, loading->base.size) {
2323 LOAD_MAP_CHAR(ch, ptile, sg_bases_set_bv(&ptile->extras, ch,
2324 loading->base.order + 4 * j),
2325 loading->file, "map.b%02d_%04d", j);
2326 } halfbyte_iterate_bases_end;
2327}
2328
2329/************************************************************************/
2332static void sg_load_map_tiles_roads(struct loaddata *loading)
2333{
2334 /* Check status and return if not OK (sg_success FALSE). */
2335 sg_check_ret();
2336
2337 /* Load roads. */
2338 halfbyte_iterate_roads(j, loading->road.size) {
2339 LOAD_MAP_CHAR(ch, ptile, sg_roads_set_bv(&ptile->extras, ch,
2340 loading->road.order + 4 * j),
2341 loading->file, "map.r%02d_%04d", j);
2342 } halfbyte_iterate_roads_end;
2343}
2344
2345/************************************************************************/
2348static void sg_load_map_tiles_specials(struct loaddata *loading,
2349 bool rivers_overlay)
2350{
2351 /* Check status and return if not OK (sg_success FALSE). */
2352 sg_check_ret();
2353
2354 /* If 'rivers_overlay' is set to TRUE, load only the rivers overlay map
2355 * from the savegame file.
2356 *
2357 * A scenario may define the terrain of the map but not list the specials
2358 * on it (thus allowing users to control the placement of specials).
2359 * However rivers are a special case and must be included in the map along
2360 * with the scenario. Thus in those cases this function should be called
2361 * to load the river information separate from any other special data.
2362 *
2363 * This does not need to be called from map_load(), because map_load()
2364 * loads the rivers overlay along with the rest of the specials. Call this
2365 * only if you've already called map_load_tiles(), and want to load only
2366 * the rivers overlay but no other specials. Scenarios that encode things
2367 * this way should have the "riversoverlay" capability. */
2368 halfbyte_iterate_special(j, loading->special.size) {
2369 LOAD_MAP_CHAR(ch, ptile, sg_special_set_bv(ptile, &ptile->extras, ch,
2370 loading->special.order + 4 * j,
2371 rivers_overlay),
2372 loading->file, "map.spe%02d_%04d", j);
2373 } halfbyte_iterate_special_end;
2374}
2375
2376/************************************************************************/
2379static void sg_load_map_tiles_resources(struct loaddata *loading)
2380{
2381 /* Check status and return if not OK (sg_success FALSE). */
2382 sg_check_ret();
2383
2384 LOAD_MAP_CHAR(ch, ptile, tile_set_resource(ptile, char2resource(ch)),
2385 loading->file, "map.res%04d");
2386
2387 /* After the resources are loaded, indicate those currently valid. */
2388 whole_map_iterate(&(wld.map), ptile) {
2389 if (NULL == ptile->resource) {
2390 continue;
2391 }
2392
2393 if (ptile->terrain == NULL || !terrain_has_resource(ptile->terrain, ptile->resource)) {
2394 BV_CLR(ptile->extras, extra_index(ptile->resource));
2395 }
2396 } whole_map_iterate_end;
2397
2398 wld.map.server.have_resources = TRUE;
2399 game.scenario.have_resources = TRUE;
2400}
2401
2402/************************************************************************/
2406static void sg_load_map_startpos(struct loaddata *loading)
2407{
2408 struct nation_type *pnation;
2409 struct startpos *psp;
2410 struct tile *ptile;
2411 const char SEPARATOR = '#';
2412 const char *nation_names;
2413 int nat_x, nat_y;
2414 bool exclude;
2415 int i, startpos_count;
2416
2417 /* Check status and return if not OK (sg_success FALSE). */
2418 sg_check_ret();
2419
2420 startpos_count
2421 = secfile_lookup_int_default(loading->file, 0, "map.startpos_count");
2422
2423 if (0 == startpos_count) {
2424 /* Nothing to do. */
2425 return;
2426 }
2427
2428 for (i = 0; i < startpos_count; i++) {
2429 if (!secfile_lookup_int(loading->file, &nat_x, "map.startpos%d.x", i)
2430 || !secfile_lookup_int(loading->file, &nat_y,
2431 "map.startpos%d.y", i)) {
2432 log_sg("Warning: Undefined coordinates for startpos %d", i);
2433 continue;
2434 }
2435
2436 ptile = native_pos_to_tile(&(wld.map), nat_x, nat_y);
2437 if (NULL == ptile) {
2438 log_error("Start position native coordinates (%d, %d) do not exist "
2439 "in this map. Skipping...", nat_x, nat_y);
2440 continue;
2441 }
2442
2443 exclude = secfile_lookup_bool_default(loading->file, FALSE,
2444 "map.startpos%d.exclude", i);
2445
2446 psp = map_startpos_new(ptile);
2447
2448 nation_names = secfile_lookup_str(loading->file,
2449 "map.startpos%d.nations", i);
2450 if (NULL != nation_names && '\0' != nation_names[0]) {
2451 const size_t size = strlen(nation_names) + 1;
2452 char buf[size], *start, *end;
2453
2454 memcpy(buf, nation_names, size);
2455 for (start = buf - 1; NULL != start; start = end) {
2456 start++;
2457 if ((end = strchr(start, SEPARATOR))) {
2458 *end = '\0';
2459 }
2460
2461 pnation = nation_by_rule_name(start);
2462 if (NO_NATION_SELECTED != pnation) {
2463 if (exclude) {
2464 startpos_disallow(psp, pnation);
2465 } else {
2466 startpos_allow(psp, pnation);
2467 }
2468 } else {
2469 log_verbose("Missing nation \"%s\".", start);
2470 }
2471 }
2472 }
2473 }
2474
2475 if (0 < map_startpos_count()
2476 && loading->server_state == S_S_INITIAL
2477 && map_startpos_count() < game.server.max_players) {
2478 log_verbose("Number of starts (%d) are lower than rules.max_players "
2479 "(%d), lowering rules.max_players.",
2480 map_startpos_count(), game.server.max_players);
2481 game.server.max_players = map_startpos_count();
2482 }
2483
2484 /* Re-initialize nation availability in light of start positions.
2485 * This has to be after loading [scenario] and [map].startpos and
2486 * before we seek nations for players. */
2487 update_nations_with_startpos();
2488}
2489
2490/************************************************************************/
2493static void sg_load_map_owner(struct loaddata *loading)
2494{
2495 int x, y;
2496 struct player *owner = NULL;
2497 struct tile *claimer = NULL;
2498 struct player *eowner = NULL;
2499
2500 /* Check status and return if not OK (sg_success FALSE). */
2501 sg_check_ret();
2502
2503 if (game.info.is_new_game) {
2504 /* No owner/source information for a new game / scenario. */
2505 return;
2506 }
2507
2508 /* Owner and ownership source are stored as plain numbers */
2509 for (y = 0; y < wld.map.ysize; y++) {
2510 const char *buffer1 = secfile_lookup_str(loading->file,
2511 "map.owner%04d", y);
2512 const char *buffer2 = secfile_lookup_str(loading->file,
2513 "map.source%04d", y);
2514 const char *buffer3 = secfile_lookup_str(loading->file,
2515 "map.eowner%04d", y);
2516 const char *ptr1 = buffer1;
2517 const char *ptr2 = buffer2;
2518 const char *ptr3 = buffer3;
2519
2520 sg_failure_ret(buffer1 != NULL, "%s", secfile_error());
2521 sg_failure_ret(buffer2 != NULL, "%s", secfile_error());
2522 if (loading->version >= 30) {
2523 sg_failure_ret(buffer3 != NULL, "%s", secfile_error());
2524 }
2525
2526 for (x = 0; x < wld.map.xsize; x++) {
2527 char token1[TOKEN_SIZE];
2528 char token2[TOKEN_SIZE];
2529 char token3[TOKEN_SIZE];
2530 int number;
2531 struct tile *ptile = native_pos_to_tile(&(wld.map), x, y);
2532
2533 scanin(&ptr1, ",", token1, sizeof(token1));
2534 sg_failure_ret(token1[0] != '\0',
2535 "Map size not correct (map.owner%d).", y);
2536 if (strcmp(token1, "-") == 0) {
2537 owner = NULL;
2538 } else {
2539 sg_failure_ret(str_to_int(token1, &number),
2540 "Got map owner %s in (%d, %d).", token1, x, y);
2541 owner = player_by_number(number);
2542 }
2543
2544 scanin(&ptr2, ",", token2, sizeof(token2));
2545 sg_failure_ret(token2[0] != '\0',
2546 "Map size not correct (map.source%d).", y);
2547 if (strcmp(token2, "-") == 0) {
2548 claimer = NULL;
2549 } else {
2550 sg_failure_ret(str_to_int(token2, &number),
2551 "Got map source %s in (%d, %d).", token2, x, y);
2552 claimer = index_to_tile(&(wld.map), number);
2553 }
2554
2555 if (loading->version >= 30) {
2556 scanin(&ptr3, ",", token3, sizeof(token3));
2557 sg_failure_ret(token3[0] != '\0',
2558 "Map size not correct (map.eowner%d).", y);
2559 if (strcmp(token3, "-") == 0) {
2560 eowner = NULL;
2561 } else {
2562 sg_failure_ret(str_to_int(token3, &number),
2563 "Got base owner %s in (%d, %d).", token3, x, y);
2564 eowner = player_by_number(number);
2565 }
2566 } else {
2567 eowner = owner;
2568 }
2569
2570 map_claim_ownership(ptile, owner, claimer, FALSE);
2571 tile_claim_bases(ptile, eowner);
2572 log_debug("extras_owner(%d, %d) = %s", TILE_XY(ptile), player_name(eowner));
2573 }
2574 }
2575}
2576
2577/************************************************************************/
2580static void sg_load_map_worked(struct loaddata *loading)
2581{
2582 int x, y;
2583
2584 /* Check status and return if not OK (sg_success FALSE). */
2585 sg_check_ret();
2586
2587 sg_failure_ret(loading->worked_tiles == NULL,
2588 "City worked map not loaded!");
2589
2590 loading->worked_tiles = fc_malloc(MAP_INDEX_SIZE *
2591 sizeof(*loading->worked_tiles));
2592
2593 for (y = 0; y < wld.map.ysize; y++) {
2594 const char *buffer = secfile_lookup_str(loading->file, "map.worked%04d",
2595 y);
2596 const char *ptr = buffer;
2597
2598 sg_failure_ret(NULL != buffer,
2599 "Savegame corrupt - map line %d not found.", y);
2600 for (x = 0; x < wld.map.xsize; x++) {
2601 char token[TOKEN_SIZE];
2602 int number;
2603 struct tile *ptile = native_pos_to_tile(&(wld.map), x, y);
2604
2605 scanin(&ptr, ",", token, sizeof(token));
2606 sg_failure_ret('\0' != token[0],
2607 "Savegame corrupt - map size not correct.");
2608 if (strcmp(token, "-") == 0) {
2609 number = -1;
2610 } else {
2611 sg_failure_ret(str_to_int(token, &number) && 0 < number,
2612 "Savegame corrupt - got tile worked by city "
2613 "id=%s in (%d, %d).", token, x, y);
2614 }
2615
2616 loading->worked_tiles[ptile->index] = number;
2617 }
2618 }
2619}
2620
2621/************************************************************************/
2624static void sg_load_map_known(struct loaddata *loading)
2625{
2626 /* Check status and return if not OK (sg_success FALSE). */
2627 sg_check_ret();
2628
2629 players_iterate(pplayer) {
2630 /* Allocate player private map here; it is needed in different modules
2631 * besides this one ((i.e. sg_load_player_*()). */
2632 player_map_init(pplayer);
2633 } players_iterate_end;
2634
2635 if (secfile_lookup_bool_default(loading->file, TRUE,
2636 "game.save_known")) {
2637 int lines = player_slot_max_used_number() / 32 + 1;
2638 int j, p, l, i;
2639 unsigned int *known = fc_calloc(lines * MAP_INDEX_SIZE, sizeof(*known));
2640
2641 for (l = 0; l < lines; l++) {
2642 for (j = 0; j < 8; j++) {
2643 for (i = 0; i < 4; i++) {
2644 /* Only bother trying to load the map for this halfbyte if at least
2645 * one of the corresponding player slots is in use. */
2646 if (player_slot_is_used(player_slot_by_number(l*32 + j*4 + i))) {
2647 LOAD_MAP_CHAR(ch, ptile,
2648 known[l * MAP_INDEX_SIZE + tile_index(ptile)]
2649 |= ascii_hex2bin(ch, j),
2650 loading->file, "map.k%02d_%04d", l * 8 + j);
2651 break;
2652 }
2653 }
2654 }
2655 }
2656
2657 players_iterate(pplayer) {
2658 dbv_clr_all(&pplayer->tile_known);
2659 } players_iterate_end;
2660
2661 /* HACK: we read the known data from hex into 32-bit integers, and
2662 * now we convert it to the known tile data of each player. */
2663 whole_map_iterate(&(wld.map), ptile) {
2664 players_iterate(pplayer) {
2665 p = player_index(pplayer);
2666 l = player_index(pplayer) / 32;
2667
2668 if (known[l * MAP_INDEX_SIZE + tile_index(ptile)] & (1u << (p % 32))) {
2669 map_set_known(ptile, pplayer);
2670 }
2671 } players_iterate_end;
2672 } whole_map_iterate_end;
2673
2674 FC_FREE(known);
2675 }
2676}
2677
2678/* =======================================================================
2679 * Load player data.
2680 *
2681 * This is split into two parts as some data can only be loaded if the
2682 * number of players is known and the corresponding player slots are
2683 * defined.
2684 * ======================================================================= */
2685
2686/************************************************************************/
2689static void sg_load_players_basic(struct loaddata *loading)
2690{
2691 int i, k, nplayers;
2692 const char *str;
2693 bool shuffle_loaded = TRUE;
2694
2695 /* Check status and return if not OK (sg_success FALSE). */
2696 sg_check_ret();
2697
2698 if (S_S_INITIAL == loading->server_state
2699 || game.info.is_new_game) {
2700 /* Nothing more to do. */
2701 return;
2702 }
2703
2704 /* Load destroyed wonders: */
2705 str = secfile_lookup_str(loading->file,
2706 "players.destroyed_wonders");
2707 sg_failure_ret(str != NULL, "%s", secfile_error());
2708 sg_failure_ret(strlen(str) == loading->improvement.size,
2709 "Invalid length for 'players.destroyed_wonders' ("
2710 SIZE_T_PRINTF" ~= " SIZE_T_PRINTF ")",
2711 strlen(str), loading->improvement.size);
2712 for (k = 0; k < loading->improvement.size; k++) {
2713 sg_failure_ret(str[k] == '1' || str[k] == '0',
2714 "Undefined value '%c' within "
2715 "'players.destroyed_wonders'.", str[k]);
2716
2717 if (str[k] == '1') {
2718 struct impr_type *pimprove =
2719 improvement_by_rule_name(loading->improvement.order[k]);
2720
2721 if (pimprove) {
2722 game.info.great_wonder_owners[improvement_index(pimprove)]
2723 = WONDER_DESTROYED;
2724 }
2725 }
2726 }
2727
2728 server.identity_number
2729 = secfile_lookup_int_default(loading->file, server.identity_number,
2730 "players.identity_number_used");
2731
2732 /* First remove all defined players. */
2733 players_iterate(pplayer) {
2734 server_remove_player(pplayer);
2735 } players_iterate_end;
2736
2737 /* Now, load the players from the savefile. */
2738 player_slots_iterate(pslot) {
2739 struct player *pplayer;
2740 struct rgbcolor *prgbcolor = NULL;
2741 int pslot_id = player_slot_index(pslot);
2742
2743 if (NULL == secfile_section_lookup(loading->file, "player%d",
2744 pslot_id)) {
2745 continue;
2746 }
2747
2748 /* Get player AI type. */
2749 str = secfile_lookup_str(loading->file, "player%d.ai_type",
2750 player_slot_index(pslot));
2751 sg_failure_ret(str != NULL, "%s", secfile_error());
2752
2753 /* Get player color */
2754 if (!rgbcolor_load(loading->file, &prgbcolor, "player%d.color",
2755 pslot_id)) {
2756 if (loading->version >= 10 && game_was_started()) {
2757 /* 2.4.0 or later savegame. This is not an error in 2.3 savefiles,
2758 * as they predate the introduction of configurable player colors. */
2759 log_sg("Game has started, yet player %d has no color defined.",
2760 pslot_id);
2761 /* This will be fixed up later */
2762 } else {
2763 log_verbose("No color defined for player %d.", pslot_id);
2764 /* Colors will be assigned on game start, or at end of savefile
2765 * loading if game has already started */
2766 }
2767 }
2768
2769 /* Create player. */
2770 pplayer = server_create_player(player_slot_index(pslot), str,
2771 prgbcolor,
2772 !game.scenario.is_scenario
2773 || game.scenario.allow_ai_type_fallback);
2774 sg_failure_ret(pplayer != NULL, "Invalid AI type: '%s'!", str);
2775
2776 server_player_init(pplayer, FALSE, FALSE);
2777
2778 /* Free the color definition. */
2779 rgbcolor_destroy(prgbcolor);
2780
2781 /* Multipliers (policies) */
2782
2783 /* First initialise player values with ruleset defaults; this will
2784 * cover any in the ruleset not known when the savefile was created. */
2785 multipliers_iterate(pmul) {
2786 pplayer->multipliers[multiplier_index(pmul)].value
2787 = pplayer->multipliers[multiplier_index(pmul)].target = pmul->def;
2788 } multipliers_iterate_end;
2789
2790 /* Now override with any values from the savefile. */
2791 for (k = 0; k < loading->multiplier.size; k++) {
2792 const struct multiplier *pmul = loading->multiplier.order[k];
2793
2794 if (pmul) {
2795 Multiplier_type_id idx = multiplier_index(pmul);
2796 int val =
2797 secfile_lookup_int_default(loading->file, pmul->def,
2798 "player%d.multiplier%d.val",
2799 player_slot_index(pslot), k);
2800 int rval = (((CLIP(pmul->start, val, pmul->stop)
2801 - pmul->start) / pmul->step) * pmul->step) + pmul->start;
2802
2803 if (rval != val) {
2804 log_verbose("Player %d had illegal value for multiplier \"%s\": "
2805 "was %d, clamped to %d", pslot_id,
2806 multiplier_rule_name(pmul), val, rval);
2807 }
2808 pplayer->multipliers[idx].value = rval;
2809
2810 val =
2811 secfile_lookup_int_default(loading->file,
2812 pplayer->multipliers[idx].value,
2813 "player%d.multiplier%d.target",
2814 player_slot_index(pslot), k);
2815 rval = (((CLIP(pmul->start, val, pmul->stop)
2816 - pmul->start) / pmul->step) * pmul->step) + pmul->start;
2817
2818 if (rval != val) {
2819 log_verbose("Player %d had illegal value for multiplier_target "
2820 "\"%s\": was %d, clamped to %d", pslot_id,
2821 multiplier_rule_name(pmul), val, rval);
2822 }
2823 pplayer->multipliers[idx].target = rval;
2824
2825 /* Never present in savegame2 format */
2826 pplayer->multipliers[idx].changed = 0;
2827 } /* else silently discard multiplier not in current ruleset */
2828 }
2829
2830 /* Just in case savecompat starts adding it in the future. */
2831 pplayer->server.border_vision =
2832 secfile_lookup_bool_default(loading->file, FALSE,
2833 "player%d.border_vision",
2834 player_slot_index(pslot));
2835 } player_slots_iterate_end;
2836
2837 /* check number of players */
2838 nplayers = secfile_lookup_int_default(loading->file, 0, "players.nplayers");
2839 sg_failure_ret(player_count() == nplayers, "The value of players.nplayers "
2840 "(%d) from the loaded game does not match the number of "
2841 "players present (%d).", nplayers, player_count());
2842
2843 /* Load team information. */
2844 players_iterate(pplayer) {
2845 int team;
2846 struct team_slot *tslot = NULL;
2847
2848 sg_failure_ret(secfile_lookup_int(loading->file, &team,
2849 "player%d.team_no",
2850 player_number(pplayer))
2851 && (tslot = team_slot_by_number(team)),
2852 "Invalid team definition for player %s (nb %d).",
2853 player_name(pplayer), player_number(pplayer));
2854 /* Should never fail when slot given is not NULL */
2855 team_add_player(pplayer, team_new(tslot));
2856 } players_iterate_end;
2857
2858 /* Loading the shuffle list is quite complex. At the time of saving the
2859 * shuffle data is saved as
2860 * shuffled_player_<number> = player_slot_id
2861 * where number is an increasing number and player_slot_id is a number
2862 * between 0 and the maximum number of player slots. Now we have to create
2863 * a list
2864 * shuffler_players[number] = player_slot_id
2865 * where all player slot IDs are used exactly one time. The code below
2866 * handles this ... */
2867 if (secfile_lookup_int_default(loading->file, -1,
2868 "players.shuffled_player_%d", 0) >= 0) {
2869 int slots = player_slot_count();
2870 int plrcount = player_count();
2871 int shuffled_players[slots];
2872 bool shuffled_player_set[slots];
2873
2874 for (i = 0; i < slots; i++) {
2875 /* Array to save used numbers. */
2876 shuffled_player_set[i] = FALSE;
2877 /* List of all player IDs (needed for set_shuffled_players()). It is
2878 * initialised with the value -1 to indicate that no value is set. */
2879 shuffled_players[i] = -1;
2880 }
2881
2882 /* Load shuffled player list. */
2883 for (i = 0; i < plrcount; i++) {
2884 int shuffle
2885 = secfile_lookup_int_default(loading->file, -1,
2886 "players.shuffled_player_%d", i);
2887
2888 if (shuffle == -1) {
2889 log_sg("Missing player shuffle information (index %d) "
2890 "- reshuffle player list!", i);
2891 shuffle_loaded = FALSE;
2892 break;
2893 } else if (shuffled_player_set[shuffle]) {
2894 log_sg("Player shuffle %d used two times "
2895 "- reshuffle player list!", shuffle);
2896 shuffle_loaded = FALSE;
2897 break;
2898 }
2899 /* Set this ID as used. */
2900 shuffled_player_set[shuffle] = TRUE;
2901
2902 /* Save the player ID in the shuffle list. */
2903 shuffled_players[i] = shuffle;
2904 }
2905
2906 if (shuffle_loaded) {
2907 /* Insert missing numbers. */
2908 int shuffle_index = plrcount;
2909
2910 for (i = 0; i < slots; i++) {
2911 if (!shuffled_player_set[i]) {
2912 shuffled_players[shuffle_index++] = i;
2913 }
2914
2915 /* shuffle_index must not grow higher than size of shuffled_players. */
2916 sg_failure_ret(shuffle_index <= slots,
2917 "Invalid player shuffle data!");
2918 }
2919
2920#ifdef FREECIV_DEBUG
2921 log_debug("[load shuffle] player_count() = %d", player_count());
2922 player_slots_iterate(pslot) {
2923 int plrid = player_slot_index(pslot);
2924
2925 log_debug("[load shuffle] id: %3d => slot: %3d | slot %3d: %s",
2926 plrid, shuffled_players[plrid], plrid,
2927 shuffled_player_set[plrid] ? "is used" : "-");
2928 } player_slots_iterate_end;
2929#endif /* FREECIV_DEBUG */
2930
2931 /* Set shuffle list from savegame. */
2932 set_shuffled_players(shuffled_players);
2933 }
2934 }
2935
2936 if (!shuffle_loaded) {
2937 /* No shuffled players included or error loading them, so shuffle them
2938 * (this may include scenarios). */
2939 shuffle_players();
2940 }
2941}
2942
2943/************************************************************************/
2946static void sg_load_players(struct loaddata *loading)
2947{
2948 /* Check status and return if not OK (sg_success FALSE). */
2949 sg_check_ret();
2950
2951 if (game.info.is_new_game) {
2952 /* Nothing to do. */
2953 return;
2954 }
2955
2956 players_iterate(pplayer) {
2957 sg_load_player_main(loading, pplayer);
2958 sg_load_player_cities(loading, pplayer);
2959 sg_load_player_units(loading, pplayer);
2960 sg_load_player_attributes(loading, pplayer);
2961
2962 /* Check the success of the functions above. */
2963 sg_check_ret();
2964
2965 /* Print out some information */
2966 if (is_ai(pplayer)) {
2967 log_normal(_("%s has been added as %s level AI-controlled player "
2968 "(%s)."), player_name(pplayer),
2969 ai_level_translated_name(pplayer->ai_common.skill_level),
2970 ai_name(pplayer->ai));
2971 } else {
2972 log_normal(_("%s has been added as human player."),
2973 player_name(pplayer));
2974 }
2975 } players_iterate_end;
2976
2977 /* Also load the transport status of the units here. It must be a special
2978 * case as all units must be known (unit on an allied transporter). */
2979 players_iterate(pplayer) {
2980 /* Load unit transport status. */
2981 sg_load_player_units_transport(loading, pplayer);
2982 } players_iterate_end;
2983
2984 /* Savegame may contain nation assignments that are incompatible with the
2985 * current nationset -- for instance, if it predates the introduction of
2986 * nationsets. Ensure they are compatible, one way or another. */
2987 fit_nationset_to_players();
2988
2989 /* Some players may have invalid nations in the ruleset. Once all players
2990 * are loaded, pick one of the remaining nations for them. */
2991 players_iterate(pplayer) {
2992 if (pplayer->nation == NO_NATION_SELECTED) {
2993 player_set_nation(pplayer, pick_a_nation(NULL, FALSE, TRUE,
2994 NOT_A_BARBARIAN));
2995 /* TRANS: Minor error message: <Leader> ... <Poles>. */
2996 log_sg(_("%s had invalid nation; changing to %s."),
2997 player_name(pplayer), nation_plural_for_player(pplayer));
2998
2999 ai_traits_init(pplayer);
3000 }
3001 } players_iterate_end;
3002
3003 /* Sanity check alliances, prevent allied-with-ally-of-enemy. */
3004 players_iterate_alive(plr) {
3005 players_iterate_alive(aplayer) {
3006 if (pplayers_allied(plr, aplayer)) {
3007 enum dipl_reason can_ally = pplayer_can_make_treaty(plr, aplayer,
3008 DS_ALLIANCE);
3009
3010 if (can_ally == DIPL_ALLIANCE_PROBLEM_US
3011 || can_ally == DIPL_ALLIANCE_PROBLEM_THEM) {
3012 log_sg("Illegal alliance structure detected: "
3013 "%s alliance to %s reduced to peace treaty.",
3014 nation_rule_name(nation_of_player(plr)),
3015 nation_rule_name(nation_of_player(aplayer)));
3016 player_diplstate_get(plr, aplayer)->type = DS_PEACE;
3017 player_diplstate_get(aplayer, plr)->type = DS_PEACE;
3018 }
3019 }
3020 } players_iterate_alive_end;
3021 } players_iterate_alive_end;
3022
3023 /* Update cached city illness. This can depend on trade routes,
3024 * so can't be calculated until all players have been loaded. */
3025 if (game.info.illness_on) {
3026 cities_iterate(pcity) {
3027 pcity->server.illness
3028 = city_illness_calc(pcity, NULL, NULL,
3029 &(pcity->illness_trade), NULL);
3030 } cities_iterate_end;
3031 }
3032
3033 /* Update all city information. This must come after all cities are
3034 * loaded (in player_load) but before player (dumb) cities are loaded
3035 * in player_load_vision(). */
3036 players_iterate(plr) {
3037 city_list_iterate(plr->cities, pcity) {
3038 city_refresh(pcity);
3039 sanity_check_city(pcity);
3040 CALL_PLR_AI_FUNC(city_got, plr, plr, pcity);
3041 } city_list_iterate_end;
3042 } players_iterate_end;
3043
3044 /* Since the cities must be placed on the map to put them on the
3045 player map we do this afterwards */
3046 players_iterate(pplayer) {
3047 sg_load_player_vision(loading, pplayer);
3048 /* Check the success of the function above. */
3049 sg_check_ret();
3050 } players_iterate_end;
3051
3052 /* Check shared vision. Shared tiles are never given in savegame2 save */
3053 players_iterate(pplayer) {
3054 BV_CLR_ALL(pplayer->gives_shared_vision);
3055 BV_CLR_ALL(pplayer->gives_shared_tiles);
3056 BV_CLR_ALL(pplayer->server.really_gives_vision);
3057 } players_iterate_end;
3058
3059 /* Set up shared vision... */
3060 players_iterate(pplayer) {
3061 int plr1 = player_index(pplayer);
3062
3063 players_iterate(pplayer2) {
3064 int plr2 = player_index(pplayer2);
3065
3066 if (secfile_lookup_bool_default(loading->file, FALSE,
3067 "player%d.diplstate%d.gives_shared_vision", plr1, plr2)) {
3068 give_shared_vision(pplayer, pplayer2);
3069 }
3070 } players_iterate_end;
3071 } players_iterate_end;
3072
3073 /* ...and check it */
3074 players_iterate(pplayer1) {
3075 players_iterate(pplayer2) {
3076 /* TODO: Is there a good reason player is not marked as
3077 * giving shared vision to themselves -> really_gives_vision()
3078 * returning FALSE when pplayer1 == pplayer2 */
3079 if (pplayer1 != pplayer2
3080 && players_on_same_team(pplayer1, pplayer2)) {
3081 if (!really_gives_vision(pplayer1, pplayer2)) {
3082 sg_regr(3000900,
3083 _("%s did not give shared vision to team member %s."),
3084 player_name(pplayer1), player_name(pplayer2));
3085 give_shared_vision(pplayer1, pplayer2);
3086 }
3087 if (!really_gives_vision(pplayer2, pplayer1)) {
3088 sg_regr(3000900,
3089 _("%s did not give shared vision to team member %s."),
3090 player_name(pplayer2), player_name(pplayer1));
3091 give_shared_vision(pplayer2, pplayer1);
3092 }
3093 }
3094 } players_iterate_end;
3095 } players_iterate_end;
3096
3097 initialize_globals();
3098 unit_ordering_apply();
3099
3100 /* All vision is ready; this calls city_thaw_workers_queue(). */
3101 map_calculate_borders();
3102
3103 /* Make sure everything is consistent. */
3104 players_iterate(pplayer) {
3105 unit_list_iterate(pplayer->units, punit) {
3106 if (!can_unit_continue_current_activity(&(wld.map), punit)) {
3107 struct tile *ptile = unit_tile(punit);
3108
3109 log_sg("%s doing illegal activity in savegame!",
3110 unit_rule_name(punit));
3111 log_sg("Activity: %s, Target: %s, Tile: (%d, %d), Terrain: %s",
3112 unit_activity_name(punit->activity),
3113 punit->activity_target ? extra_rule_name(
3114 punit->activity_target)
3115 : "missing",
3116 TILE_XY(ptile), terrain_rule_name(tile_terrain(ptile)));
3117 punit->activity = ACTIVITY_IDLE;
3118 }
3119 } unit_list_iterate_end;
3120 } players_iterate_end;
3121
3122 cities_iterate(pcity) {
3123 city_refresh(pcity);
3124 city_thaw_workers(pcity); /* may auto_arrange_workers() */
3125 } cities_iterate_end;
3126
3127 /* Player colors are always needed once game has started. Pre-2.4 savegames
3128 * lack them. This cannot be in compatibility conversion layer as we need
3129 * all the player data available to be able to assign best colors. */
3130 if (game_was_started()) {
3131 assign_player_colors();
3132 }
3133}
3134
3135/************************************************************************/
3138static void sg_load_player_main(struct loaddata *loading,
3139 struct player *plr)
3140{
3141 const char **slist;
3142 int i, plrno = player_number(plr);
3143 const char *str;
3144 struct government *gov;
3145 const char *level;
3146 const char *barb_str;
3147 size_t nval;
3148
3149 /* Check status and return if not OK (sg_success FALSE). */
3150 sg_check_ret();
3151
3152 /* Basic player data. */
3153 str = secfile_lookup_str(loading->file, "player%d.name", plrno);
3154 sg_failure_ret(str != NULL, "%s", secfile_error());
3155 server_player_set_name(plr, str);
3156 sz_strlcpy(plr->username,
3157 secfile_lookup_str_default(loading->file, "",
3158 "player%d.username", plrno));
3159 sg_failure_ret(secfile_lookup_bool(loading->file, &plr->unassigned_user,
3160 "player%d.unassigned_user", plrno),
3161 "%s", secfile_error());
3162 sz_strlcpy(plr->server.orig_username,
3163 secfile_lookup_str_default(loading->file, "",
3164 "player%d.orig_username",
3165 plrno));
3166 sz_strlcpy(plr->ranked_username,
3167 secfile_lookup_str_default(loading->file, "",
3168 "player%d.ranked_username",
3169 plrno));
3170 sg_failure_ret(secfile_lookup_bool(loading->file, &plr->unassigned_ranked,
3171 "player%d.unassigned_ranked", plrno),
3172 "%s", secfile_error());
3173 str = secfile_lookup_str_default(loading->file, "",
3174 "player%d.delegation_username",
3175 plrno);
3176 /* Defaults to no delegation. */
3177 if (strlen(str)) {
3178 player_delegation_set(plr, str);
3179 }
3180
3181 /* Player flags */
3182 BV_CLR_ALL(plr->flags);
3183 slist = secfile_lookup_str_vec(loading->file, &nval, "player%d.flags", plrno);
3184 for (i = 0; i < nval; i++) {
3185 const char *sval = slist[i];
3186 enum plr_flag_id fid = plr_flag_id_by_name(sval, fc_strcasecmp);
3187
3188 sg_failure_ret(plr_flag_id_is_valid(fid), "Invalid player flag \"%s\".", sval);
3189
3190 BV_SET(plr->flags, fid);
3191 }
3192 free(slist);
3193
3194 /* Nation */
3195 str = secfile_lookup_str(loading->file, "player%d.nation", plrno);
3196 player_set_nation(plr, nation_by_rule_name(str));
3197 if (plr->nation != NULL) {
3198 ai_traits_init(plr);
3199 }
3200
3201 /* Government */
3202 str = secfile_lookup_str(loading->file, "player%d.government_name",
3203 plrno);
3204 gov = government_by_rule_name(str);
3205 sg_failure_ret(gov != NULL, "Player%d: unsupported government \"%s\".",
3206 plrno, str);
3207 plr->government = gov;
3208
3209 /* Target government */
3210 str = secfile_lookup_str(loading->file,
3211 "player%d.target_government_name", plrno);
3212 if (str != NULL) {
3213 plr->target_government = government_by_rule_name(str);
3214 } else {
3215 plr->target_government = NULL;
3216 }
3217 plr->revolution_finishes
3218 = secfile_lookup_int_default(loading->file, -1,
3219 "player%d.revolution_finishes", plrno);
3220
3221 /* Load diplomatic data (diplstate + embassy + vision).
3222 * Shared vision is loaded in sg_load_players(). */
3223 BV_CLR_ALL(plr->real_embassy);
3224 players_iterate(pplayer) {
3225 char buf[32];
3226 int unconverted;
3227 struct player_diplstate *ds = player_diplstate_get(plr, pplayer);
3228 i = player_index(pplayer);
3229
3230 /* load diplomatic status */
3231 fc_snprintf(buf, sizeof(buf), "player%d.diplstate%d", plrno, i);
3232
3233 unconverted =
3234 secfile_lookup_int_default(loading->file, -1, "%s.type", buf);
3235 if (unconverted >= 0 && unconverted < loading->ds_t.size) {
3236 /* Look up what state the unconverted number represents. */
3237 ds->type = loading->ds_t.order[unconverted];
3238 } else {
3239 log_sg("No valid diplomatic state type between players %d and %d",
3240 plrno, i);
3241
3242 ds->type = DS_WAR;
3243 }
3244
3245 unconverted =
3246 secfile_lookup_int_default(loading->file, -1, "%s.max_state", buf);
3247 if (unconverted >= 0 && unconverted < loading->ds_t.size) {
3248 /* Look up what state the unconverted number represents. */
3249 ds->max_state = loading->ds_t.order[unconverted];
3250 } else {
3251 log_sg("No valid diplomatic max_state between players %d and %d",
3252 plrno, i);
3253
3254 ds->max_state = DS_WAR;
3255 }
3256
3257 /* FIXME: If either party is barbarian, we cannot enforce below check */
3258#if 0
3259 if (ds->type == DS_WAR && ds->first_contact_turn <= 0) {
3260 sg_regr(3020000,
3261 "Player%d: War with player %d who has never been met. "
3262 "Reverted to No Contact state.", plrno, i);
3263 ds->type = DS_NO_CONTACT;
3264 }
3265#endif
3266
3267 if (valid_dst_closest(ds) != ds->max_state) {
3268 sg_regr(3020000,
3269 "Player%d: closest diplstate to player %d less than current. "
3270 "Updated.", plrno, i);
3271 ds->max_state = ds->type;
3272 }
3273
3274 ds->first_contact_turn =
3275 secfile_lookup_int_default(loading->file, 0,
3276 "%s.first_contact_turn", buf);
3277 ds->turns_left =
3278 secfile_lookup_int_default(loading->file, -2, "%s.turns_left", buf);
3279 ds->has_reason_to_cancel =
3280 secfile_lookup_int_default(loading->file, 0,
3281 "%s.has_reason_to_cancel", buf);
3282 ds->contact_turns_left =
3283 secfile_lookup_int_default(loading->file, 0,
3284 "%s.contact_turns_left", buf);
3285
3286 if (secfile_lookup_bool_default(loading->file, FALSE, "%s.embassy",
3287 buf)) {
3288 BV_SET(plr->real_embassy, i);
3289 }
3290 /* 'gives_shared_vision' is loaded in sg_load_players() as all cities
3291 * must be known. */
3292 } players_iterate_end;
3293
3294 /* load ai data */
3295 players_iterate(aplayer) {
3296 char buf[32];
3297
3298 fc_snprintf(buf, sizeof(buf), "player%d.ai%d", plrno,
3299 player_index(aplayer));
3300
3301 plr->ai_common.love[player_index(aplayer)] =
3302 secfile_lookup_int_default(loading->file, 1, "%s.love", buf);
3303 CALL_FUNC_EACH_AI(player_load_relations, plr, aplayer, loading->file, plrno);
3304 } players_iterate_end;
3305
3306 CALL_FUNC_EACH_AI(player_load, plr, loading->file, plrno);
3307
3308 /* Some sane defaults */
3309 plr->ai_common.fuzzy = 0;
3310 plr->ai_common.expand = 100;
3311 plr->ai_common.science_cost = 100;
3312
3313
3314 level = secfile_lookup_str_default(loading->file, NULL,
3315 "player%d.ai.level", plrno);
3316 if (level != NULL) {
3317 if (!fc_strcasecmp("Handicapped", level)) {
3318 /* Up to freeciv-3.1 Restricted AI level was known as Handicapped */
3319 plr->ai_common.skill_level = AI_LEVEL_RESTRICTED;
3320 } else {
3321 plr->ai_common.skill_level = ai_level_by_name(level, fc_strcasecmp);
3322 }
3323 } else {
3324 plr->ai_common.skill_level = ai_level_invalid();
3325 }
3326
3327 if (!ai_level_is_valid(plr->ai_common.skill_level)) {
3328 plr->ai_common.skill_level
3329 = ai_level_convert(secfile_lookup_int_default(loading->file,
3330 game.info.skill_level,
3331 "player%d.ai.skill_level",
3332 plrno));
3333 }
3334
3335 barb_str = secfile_lookup_str_default(loading->file, "None",
3336 "player%d.ai.barb_type", plrno);
3337 plr->ai_common.barbarian_type = barbarian_type_by_name(barb_str, fc_strcasecmp);
3338
3339 if (!barbarian_type_is_valid(plr->ai_common.barbarian_type)) {
3340 log_sg("Player%d: Invalid barbarian type \"%s\". "
3341 "Changed to \"None\".", plrno, barb_str);
3342 plr->ai_common.barbarian_type = NOT_A_BARBARIAN;
3343 }
3344
3345 if (is_barbarian(plr)) {
3346 server.nbarbarians++;
3347 }
3348
3349 if (is_ai(plr)) {
3350 set_ai_level_directer(plr, plr->ai_common.skill_level);
3351 CALL_PLR_AI_FUNC(gained_control, plr, plr);
3352 }
3353
3354 /* Load nation style. */
3355 {
3356 struct nation_style *style;
3357
3358 str = secfile_lookup_str(loading->file, "player%d.style_by_name", plrno);
3359
3360 /* Handle pre-2.6 savegames */
3361 if (str == NULL) {
3362 str = secfile_lookup_str(loading->file, "player%d.city_style_by_name",
3363 plrno);
3364 }
3365
3366 sg_failure_ret(str != NULL, "%s", secfile_error());
3367 style = style_by_rule_name(str);
3368 if (style == NULL) {
3369 style = style_by_number(0);
3370 log_sg("Player%d: unsupported city_style_name \"%s\". "
3371 "Changed to \"%s\".", plrno, str, style_rule_name(style));
3372 }
3373 plr->style = style;
3374 }
3375
3376 sg_failure_ret(secfile_lookup_int(loading->file, &plr->nturns_idle,
3377 "player%d.idle_turns", plrno),
3378 "%s", secfile_error());
3379 plr->is_male = secfile_lookup_bool_default(loading->file, TRUE,
3380 "player%d.is_male", plrno);
3381 sg_failure_ret(secfile_lookup_bool(loading->file, &plr->is_alive,
3382 "player%d.is_alive", plrno),
3383 "%s", secfile_error());
3384 sg_failure_ret(secfile_lookup_int(loading->file, &plr->turns_alive,
3385 "player%d.turns_alive", plrno),
3386 "%s", secfile_error());
3387 sg_failure_ret(secfile_lookup_int(loading->file, &plr->last_war_action,
3388 "player%d.last_war", plrno),
3389 "%s", secfile_error());
3390 plr->phase_done = secfile_lookup_bool_default(loading->file, FALSE,
3391 "player%d.phase_done", plrno);
3392 sg_failure_ret(secfile_lookup_int(loading->file, &plr->economic.gold,
3393 "player%d.gold", plrno),
3394 "%s", secfile_error());
3395 sg_failure_ret(secfile_lookup_int(loading->file, &plr->economic.tax,
3396 "player%d.rates.tax", plrno),
3397 "%s", secfile_error());
3398 sg_failure_ret(secfile_lookup_int(loading->file, &plr->economic.science,
3399 "player%d.rates.science", plrno),
3400 "%s", secfile_error());
3401 sg_failure_ret(secfile_lookup_int(loading->file, &plr->economic.luxury,
3402 "player%d.rates.luxury", plrno),
3403 "%s", secfile_error());
3404 plr->server.bulbs_last_turn =
3405 secfile_lookup_int_default(loading->file, 0,
3406 "player%d.research.bulbs_last_turn", plrno);
3407
3408 /* Traits */
3409 if (plr->nation) {
3410 for (i = 0; i < loading->trait.size; i++) {
3411 enum trait tr = trait_by_name(loading->trait.order[i], fc_strcasecmp);
3412
3413 if (trait_is_valid(tr)) {
3414 int val = secfile_lookup_int_default(loading->file, -1, "player%d.trait%d.val",
3415 plrno, i);
3416
3417 if (val != -1) {
3418 plr->ai_common.traits[tr].val = val;
3419 }
3420
3421 sg_failure_ret(secfile_lookup_int(loading->file, &val,
3422 "player%d.trait%d.mod", plrno, i),
3423 "%s", secfile_error());
3424 plr->ai_common.traits[tr].mod = val;
3425 }
3426 }
3427 }
3428
3429 /* Achievements */
3430 {
3431 int count;
3432
3433 count = secfile_lookup_int_default(loading->file, -1,
3434 "player%d.achievement_count", plrno);
3435
3436 if (count > 0) {
3437 for (i = 0; i < count; i++) {
3438 const char *name;
3439 struct achievement *pach;
3440 bool first;
3441
3442 name = secfile_lookup_str(loading->file,
3443 "player%d.achievement%d.name", plrno, i);
3444 pach = achievement_by_rule_name(name);
3445
3446 sg_failure_ret(pach != NULL,
3447 "Unknown achievement \"%s\".", name);
3448
3449 sg_failure_ret(secfile_lookup_bool(loading->file, &first,
3450 "player%d.achievement%d.first",
3451 plrno, i),
3452 "achievement error: %s", secfile_error());
3453
3454 sg_failure_ret(pach->first == NULL || !first,
3455 "Multiple players listed as first to get achievement \"%s\".",
3456 name);
3457
3458 BV_SET(pach->achievers, player_index(plr));
3459
3460 if (first) {
3461 pach->first = plr;
3462 }
3463 }
3464 }
3465 }
3466
3467 /* Player score. */
3468 plr->score.happy =
3469 secfile_lookup_int_default(loading->file, 0,
3470 "score%d.happy", plrno);
3471 plr->score.content =
3472 secfile_lookup_int_default(loading->file, 0,
3473 "score%d.content", plrno);
3474 plr->score.unhappy =
3475 secfile_lookup_int_default(loading->file, 0,
3476 "score%d.unhappy", plrno);
3477 plr->score.angry =
3478 secfile_lookup_int_default(loading->file, 0,
3479 "score%d.angry", plrno);
3480
3481 /* Make sure that the score about specialists in current ruleset that
3482 * were not present at saving time are set to zero. */
3483 specialist_type_iterate(sp) {
3484 plr->score.specialists[sp] = 0;
3485 } specialist_type_iterate_end;
3486
3487 for (i = 0; i < loading->specialist.size; i++) {
3488 plr->score.specialists[specialist_index(loading->specialist.order[i])]
3489 = secfile_lookup_int_default(loading->file, 0,
3490 "score%d.specialists%d", plrno, i);
3491 }
3492
3493 plr->score.wonders =
3494 secfile_lookup_int_default(loading->file, 0,
3495 "score%d.wonders", plrno);
3496 plr->score.techs =
3497 secfile_lookup_int_default(loading->file, 0,
3498 "score%d.techs", plrno);
3499 plr->score.techout =
3500 secfile_lookup_int_default(loading->file, 0,
3501 "score%d.techout", plrno);
3502 plr->score.landarea =
3503 secfile_lookup_int_default(loading->file, 0,
3504 "score%d.landarea", plrno);
3505 plr->score.settledarea =
3506 secfile_lookup_int_default(loading->file, 0,
3507 "score%d.settledarea", plrno);
3508 plr->score.population =
3509 secfile_lookup_int_default(loading->file, 0,
3510 "score%d.population", plrno);
3511 plr->score.cities =
3512 secfile_lookup_int_default(loading->file, 0,
3513 "score%d.cities", plrno);
3514 plr->score.units =
3515 secfile_lookup_int_default(loading->file, 0,
3516 "score%d.units", plrno);
3517 plr->score.pollution =
3518 secfile_lookup_int_default(loading->file, 0,
3519 "score%d.pollution", plrno);
3520 plr->score.literacy =
3521 secfile_lookup_int_default(loading->file, 0,
3522 "score%d.literacy", plrno);
3523 plr->score.bnp =
3524 secfile_lookup_int_default(loading->file, 0,
3525 "score%d.bnp", plrno);
3526 plr->score.mfg =
3527 secfile_lookup_int_default(loading->file, 0,
3528 "score%d.mfg", plrno);
3529 plr->score.spaceship =
3530 secfile_lookup_int_default(loading->file, 0,
3531 "score%d.spaceship", plrno);
3532 plr->score.units_built =
3533 secfile_lookup_int_default(loading->file, 0,
3534 "score%d.units_built", plrno);
3535 plr->score.units_killed =
3536 secfile_lookup_int_default(loading->file, 0,
3537 "score%d.units_killed", plrno);
3538 plr->score.units_lost =
3539 secfile_lookup_int_default(loading->file, 0,
3540 "score%d.units_lost", plrno);
3541 plr->score.units_used = 0; /* Was never saved to savegame2.c saves */
3542 plr->score.culture =
3543 secfile_lookup_int_default(loading->file, 0,
3544 "score%d.culture", plrno);
3545 plr->score.game =
3546 secfile_lookup_int_default(loading->file, 0,
3547 "score%d.total", plrno);
3548
3549 /* Load space ship data. */
3550 {
3551 struct player_spaceship *ship = &plr->spaceship;
3552 char prefix[32];
3553 const char *st;
3554 int ei;
3555
3556 fc_snprintf(prefix, sizeof(prefix), "player%d.spaceship", plrno);
3557 spaceship_init(ship);
3558 sg_failure_ret(secfile_lookup_int(loading->file,
3559 &ei,
3560 "%s.state", prefix),
3561 "%s", secfile_error());
3562 ship->state = ei;
3563
3564 if (ship->state != SSHIP_NONE) {
3565 sg_failure_ret(secfile_lookup_int(loading->file, &ship->structurals,
3566 "%s.structurals", prefix),
3567 "%s", secfile_error());
3568 sg_failure_ret(secfile_lookup_int(loading->file, &ship->components,
3569 "%s.components", prefix),
3570 "%s", secfile_error());
3571 sg_failure_ret(secfile_lookup_int(loading->file, &ship->modules,
3572 "%s.modules", prefix),
3573 "%s", secfile_error());
3574 sg_failure_ret(secfile_lookup_int(loading->file, &ship->fuel,
3575 "%s.fuel", prefix),
3576 "%s", secfile_error());
3577 sg_failure_ret(secfile_lookup_int(loading->file, &ship->propulsion,
3578 "%s.propulsion", prefix),
3579 "%s", secfile_error());
3580 sg_failure_ret(secfile_lookup_int(loading->file, &ship->habitation,
3581 "%s.habitation", prefix),
3582 "%s", secfile_error());
3583 sg_failure_ret(secfile_lookup_int(loading->file, &ship->life_support,
3584 "%s.life_support", prefix),
3585 "%s", secfile_error());
3586 sg_failure_ret(secfile_lookup_int(loading->file, &ship->solar_panels,
3587 "%s.solar_panels", prefix),
3588 "%s", secfile_error());
3589
3590 st = secfile_lookup_str(loading->file, "%s.structure", prefix);
3591 sg_failure_ret(st != NULL, "%s", secfile_error())
3592 for (i = 0; i < NUM_SS_STRUCTURALS && st[i]; i++) {
3593 sg_failure_ret(st[i] == '1' || st[i] == '0',
3594 "Undefined value '%c' within '%s.structure'.", st[i],
3595 prefix)
3596
3597 if (!(st[i] == '0')) {
3598 BV_SET(ship->structure, i);
3599 }
3600 }
3601 if (ship->state >= SSHIP_LAUNCHED) {
3602 sg_failure_ret(secfile_lookup_int(loading->file, &ship->launch_year,
3603 "%s.launch_year", prefix),
3604 "%s", secfile_error());
3605 }
3606 spaceship_calc_derived(ship);
3607 }
3608 }
3609
3610 /* Load lost wonder data. */
3611 str = secfile_lookup_str(loading->file, "player%d.lost_wonders", plrno);
3612 /* If not present, probably an old savegame; nothing to be done */
3613 if (str != NULL) {
3614 int k;
3615
3616 sg_failure_ret(strlen(str) == loading->improvement.size,
3617 "Invalid length for 'player%d.lost_wonders' ("
3618 SIZE_T_PRINTF " ~= " SIZE_T_PRINTF ")",
3619 plrno, strlen(str), loading->improvement.size);
3620 for (k = 0; k < loading->improvement.size; k++) {
3621 sg_failure_ret(str[k] == '1' || str[k] == '0',
3622 "Undefined value '%c' within "
3623 "'player%d.lost_wonders'.", plrno, str[k]);
3624
3625 if (str[k] == '1') {
3626 struct impr_type *pimprove =
3627 improvement_by_rule_name(loading->improvement.order[k]);
3628
3629 if (pimprove) {
3630 plr->wonders[improvement_index(pimprove)] = WONDER_LOST;
3631 }
3632 }
3633 }
3634 }
3635
3636 plr->history =
3637 secfile_lookup_int_default(loading->file, 0, "player%d.culture", plrno);
3638 plr->server.huts =
3639 secfile_lookup_int_default(loading->file, 0, "player%d.hut_count", plrno);
3640}
3641
3642/************************************************************************/
3645static void sg_load_player_cities(struct loaddata *loading,
3646 struct player *plr)
3647{
3648 int ncities, i, plrno = player_number(plr);
3649 bool tasks_handled;
3650 int wlist_max_length;
3651
3652 /* Check status and return if not OK (sg_success FALSE). */
3653 sg_check_ret();
3654
3655 sg_failure_ret(secfile_lookup_int(loading->file, &ncities,
3656 "player%d.ncities", plrno),
3657 "%s", secfile_error());
3658
3659 if (!plr->is_alive && ncities > 0) {
3660 log_sg("'player%d.ncities' = %d for dead player!", plrno, ncities);
3661 ncities = 0;
3662 }
3663
3664 if (!player_has_flag(plr, PLRF_FIRST_CITY) && ncities > 0) {
3665 /* Probably barbarians in an old savegame; fix up */
3666 BV_SET(plr->flags, PLRF_FIRST_CITY);
3667 }
3668
3669 wlist_max_length = secfile_lookup_int_default(loading->file, 0,
3670 "player%d.wl_max_length",
3671 plrno);
3672
3673 /* Load all cities of the player. */
3674 for (i = 0; i < ncities; i++) {
3675 char buf[32];
3676 struct city *pcity;
3677
3678 fc_snprintf(buf, sizeof(buf), "player%d.c%d", plrno, i);
3679
3680 /* Create a dummy city. */
3681 pcity = create_city_virtual(plr, NULL, buf);
3682 adv_city_alloc(pcity);
3683 if (!sg_load_player_city(loading, plr, pcity, buf, wlist_max_length)) {
3684 adv_city_free(pcity);
3685 destroy_city_virtual(pcity);
3686 sg_failure_ret(FALSE, "Error loading city %d of player %d.", i, plrno);
3687 }
3688
3689 identity_number_reserve(pcity->id);
3690 idex_register_city(&wld, pcity);
3691
3692 /* Load the information about the nationality of citizens. This is done
3693 * here because the city sanity check called by citizens_update() requires
3694 * that the city is registered. */
3695 sg_load_player_city_citizens(loading, plr, pcity, buf);
3696
3697 /* After everything is loaded, but before vision. */
3698 map_claim_ownership(city_tile(pcity), plr, city_tile(pcity), TRUE);
3699
3700 /* adding the city contribution to fog-of-war */
3701 pcity->server.vision = vision_new(plr, city_tile(pcity));
3702 vision_reveal_tiles(pcity->server.vision, game.server.vision_reveal_tiles);
3703 city_refresh_vision(pcity);
3704
3705 city_list_append(plr->cities, pcity);
3706 }
3707
3708 tasks_handled = FALSE;
3709 for (i = 0; !tasks_handled; i++) {
3710 int city_id;
3711 struct city *pcity = NULL;
3712
3713 city_id = secfile_lookup_int_default(loading->file, -1, "player%d.task%d.city",
3714 plrno, i);
3715
3716 if (city_id != -1) {
3717 pcity = player_city_by_number(plr, city_id);
3718 }
3719
3720 if (pcity != NULL) {
3721 const char *str;
3722 int nat_x, nat_y;
3723 struct worker_task *ptask = fc_malloc(sizeof(struct worker_task));
3724
3725 nat_x = secfile_lookup_int_default(loading->file, -1, "player%d.task%d.x", plrno, i);
3726 nat_y = secfile_lookup_int_default(loading->file, -1, "player%d.task%d.y", plrno, i);
3727
3728 ptask->ptile = native_pos_to_tile(&(wld.map), nat_x, nat_y);
3729
3730 str = secfile_lookup_str(loading->file, "player%d.task%d.activity", plrno, i);
3731 ptask->act = unit_activity_by_name(str, fc_strcasecmp);
3732
3733 sg_failure_ret(unit_activity_is_valid(ptask->act),
3734 "Unknown workertask activity %s", str);
3735
3736 str = secfile_lookup_str(loading->file, "player%d.task%d.target", plrno, i);
3737
3738 if (strcmp("-", str)) {
3739 ptask->tgt = extra_type_by_rule_name(str);
3740
3741 sg_failure_ret(ptask->tgt != NULL,
3742 "Unknown workertask target %s", str);
3743 } else {
3744 ptask->tgt = NULL;
3745 }
3746
3747 ptask->want = secfile_lookup_int_default(loading->file, 1,
3748 "player%d.task%d.want", plrno, i);
3749
3750 worker_task_list_append(pcity->task_reqs, ptask);
3751 } else {
3752 tasks_handled = TRUE;
3753 }
3754 }
3755}
3756
3757/************************************************************************/
3760static bool sg_load_player_city(struct loaddata *loading, struct player *plr,
3761 struct city *pcity, const char *citystr,
3762 int wlist_max_length)
3763{
3764 struct player *past;
3765 const char *kind, *name, *str;
3766 int id, i, repair, sp_count = 0, workers = 0, value;
3767 int nat_x, nat_y;
3768 citizens size;
3769 const char *stylename;
3770 const struct civ_map *nmap = &(wld.map);
3771
3772 sg_warn_ret_val(secfile_lookup_int(loading->file, &nat_x, "%s.x", citystr),
3773 FALSE, "%s", secfile_error());
3774 sg_warn_ret_val(secfile_lookup_int(loading->file, &nat_y, "%s.y", citystr),
3775 FALSE, "%s", secfile_error());
3776 pcity->tile = native_pos_to_tile(&(wld.map), nat_x, nat_y);
3777 sg_warn_ret_val(NULL != pcity->tile, FALSE,
3778 "%s has invalid center tile (%d, %d)",
3779 citystr, nat_x, nat_y);
3780 sg_warn_ret_val(NULL == tile_city(pcity->tile), FALSE,
3781 "%s duplicates city (%d, %d)", citystr, nat_x, nat_y);
3782
3783 /* Instead of dying, use 'citystr' string for damaged name. */
3784 city_name_set(pcity, secfile_lookup_str_default(loading->file, citystr,
3785 "%s.name", citystr));
3786
3787 sg_warn_ret_val(secfile_lookup_int(loading->file, &pcity->id, "%s.id",
3788 citystr), FALSE, "%s", secfile_error());
3789
3790 id = secfile_lookup_int_default(loading->file, player_number(plr),
3791 "%s.original", citystr);
3792 past = player_by_number(id);
3793 if (NULL != past) {
3794 pcity->original = past;
3795 }
3796
3797 /* savegame2 saves never had this information. Guess. */
3798 if (pcity->original != plr) {
3799 pcity->acquire_t = CACQ_CONQUEST;
3800 } else {
3801 pcity->acquire_t = CACQ_FOUNDED;
3802 }
3803
3804 sg_warn_ret_val(secfile_lookup_int(loading->file, &value, "%s.size",
3805 citystr), FALSE, "%s", secfile_error());
3806 size = (citizens)value; /* Set the correct type */
3807 sg_warn_ret_val(value == (int)size, FALSE,
3808 "Invalid city size: %d, set to %d", value, size);
3809 city_size_set(pcity, size);
3810
3811 for (i = 0; i < loading->specialist.size; i++) {
3812 sg_warn_ret_val(secfile_lookup_int(loading->file, &value, "%s.nspe%d",
3813 citystr, i),
3814 FALSE, "%s", secfile_error());
3815 pcity->specialists[specialist_index(loading->specialist.order[i])]
3816 = (citizens)value;
3817 sp_count += value;
3818 }
3819
3820 /* savegame2.c saves were ever saved with MAX_TRADE_ROUTES_OLD routes max */
3821 for (i = 0; i < MAX_TRADE_ROUTES_OLD; i++) {
3822 int partner = secfile_lookup_int_default(loading->file, 0,
3823 "%s.traderoute%d", citystr, i);
3824
3825 if (partner != 0) {
3826 struct trade_route *proute = fc_malloc(sizeof(struct trade_route));
3827
3828 proute->partner = partner;
3829 proute->dir = RDIR_BIDIRECTIONAL;
3830 proute->goods = goods_by_number(0); /* First good */
3831
3832 trade_route_list_append(pcity->routes, proute);
3833 }
3834 }
3835
3836 sg_warn_ret_val(secfile_lookup_int(loading->file, &pcity->food_stock,
3837 "%s.food_stock", citystr),
3838 FALSE, "%s", secfile_error());
3839 sg_warn_ret_val(secfile_lookup_int(loading->file, &pcity->shield_stock,
3840 "%s.shield_stock", citystr),
3841 FALSE, "%s", secfile_error());
3842 pcity->history =
3843 secfile_lookup_int_default(loading->file, 0, "%s.history", citystr);
3844
3845 pcity->airlift =
3846 secfile_lookup_int_default(loading->file, 0, "%s.airlift", citystr);
3847 pcity->was_happy =
3848 secfile_lookup_bool_default(loading->file, FALSE, "%s.was_happy",
3849 citystr);
3850 pcity->had_famine = FALSE;
3851
3852 pcity->turn_plague =
3853 secfile_lookup_int_default(loading->file, 0, "%s.turn_plague", citystr);
3854
3855 sg_warn_ret_val(secfile_lookup_int(loading->file, &pcity->anarchy,
3856 "%s.anarchy", citystr),
3857 FALSE, "%s", secfile_error());
3858 pcity->rapture =
3859 secfile_lookup_int_default(loading->file, 0, "%s.rapture", citystr);
3860 pcity->steal =
3861 secfile_lookup_int_default(loading->file, 0, "%s.steal", citystr);
3862
3863 /* Before did_buy for undocumented hack */
3864 pcity->turn_founded =
3865 secfile_lookup_int_default(loading->file, -2, "%s.turn_founded",
3866 citystr);
3867 sg_warn_ret_val(secfile_lookup_int(loading->file, &i, "%s.did_buy",
3868 citystr), FALSE, "%s", secfile_error());
3869 pcity->did_buy = (i != 0);
3870 if (i == -1 && pcity->turn_founded == -2) {
3871 /* Undocumented hack */
3872 pcity->turn_founded = game.info.turn;
3873 }
3874
3875 pcity->did_sell
3876 = secfile_lookup_bool_default(loading->file, FALSE, "%s.did_sell", citystr);
3877
3878 sg_warn_ret_val(secfile_lookup_int(loading->file, &pcity->turn_last_built,
3879 "%s.turn_last_built", citystr),
3880 FALSE, "%s", secfile_error());
3881
3882 kind = secfile_lookup_str(loading->file, "%s.currently_building_kind",
3883 citystr);
3884 name = secfile_lookup_str(loading->file, "%s.currently_building_name",
3885 citystr);
3886 pcity->production = universal_by_rule_name(kind, name);
3887 sg_warn_ret_val(pcity->production.kind != universals_n_invalid(), FALSE,
3888 "%s.currently_building: unknown \"%s\" \"%s\".",
3889 citystr, kind, name);
3890
3891 kind = secfile_lookup_str(loading->file, "%s.changed_from_kind",
3892 citystr);
3893 name = secfile_lookup_str(loading->file, "%s.changed_from_name",
3894 citystr);
3895 pcity->changed_from = universal_by_rule_name(kind, name);
3896 sg_warn_ret_val(pcity->changed_from.kind != universals_n_invalid(), FALSE,
3897 "%s.changed_from: unknown \"%s\" \"%s\".",
3898 citystr, kind, name);
3899
3900 pcity->before_change_shields =
3901 secfile_lookup_int_default(loading->file, pcity->shield_stock,
3902 "%s.before_change_shields", citystr);
3903 pcity->caravan_shields =
3904 secfile_lookup_int_default(loading->file, 0,
3905 "%s.caravan_shields", citystr);
3906 pcity->disbanded_shields =
3907 secfile_lookup_int_default(loading->file, 0,
3908 "%s.disbanded_shields", citystr);
3909 pcity->last_turns_shield_surplus =
3910 secfile_lookup_int_default(loading->file, 0,
3911 "%s.last_turns_shield_surplus",
3912 citystr);
3913
3914 stylename = secfile_lookup_str_default(loading->file, NULL,
3915 "%s.style", citystr);
3916 if (stylename != NULL) {
3917 pcity->style = city_style_by_rule_name(stylename);
3918 } else {
3919 pcity->style = 0;
3920 }
3921 if (pcity->style < 0) {
3922 pcity->style = city_style(pcity);
3923 }
3924
3925 pcity->server.synced = FALSE; /* Must re-sync with clients */
3926
3927 /* Initialise list of city improvements. */
3928 for (i = 0; i < ARRAY_SIZE(pcity->built); i++) {
3929 pcity->built[i].turn = I_NEVER;
3930 }
3931
3932 /* Load city improvements. */
3933 str = secfile_lookup_str(loading->file, "%s.improvements", citystr);
3934 sg_warn_ret_val(str != NULL, FALSE, "%s", secfile_error());
3935 sg_warn_ret_val(strlen(str) == loading->improvement.size, FALSE,
3936 "Invalid length of '%s.improvements' ("
3937 SIZE_T_PRINTF " ~= " SIZE_T_PRINTF ").",
3938 citystr, strlen(str), loading->improvement.size);
3939 for (i = 0; i < loading->improvement.size; i++) {
3940 sg_warn_ret_val(str[i] == '1' || str[i] == '0', FALSE,
3941 "Undefined value '%c' within '%s.improvements'.",
3942 str[i], citystr)
3943
3944 if (str[i] == '1') {
3945 struct impr_type *pimprove =
3946 improvement_by_rule_name(loading->improvement.order[i]);
3947
3948 if (pimprove) {
3949 city_add_improvement(pcity, pimprove);
3950 }
3951 }
3952 }
3953
3954 sg_failure_ret_val(loading->worked_tiles != NULL, FALSE,
3955 "No worked tiles map defined.");
3956
3957 city_freeze_workers(pcity);
3958
3959 /* Load new savegame with variable (squared) city radius and worked
3960 * tiles map */
3961
3962 int radius_sq
3963 = secfile_lookup_int_default(loading->file, -1, "%s.city_radius_sq",
3964 citystr);
3965 city_map_radius_sq_set(pcity, radius_sq);
3966
3967 city_tile_iterate(nmap, CITY_MAP_MAX_RADIUS_SQ, city_tile(pcity), ptile) {
3968 if (loading->worked_tiles[ptile->index] == pcity->id) {
3969 if (sq_map_distance(ptile, pcity->tile) > radius_sq) {
3970 log_sg("[%s] '%s' (%d, %d) has worker outside current radius "
3971 "at (%d, %d); repairing", citystr, city_name_get(pcity),
3972 TILE_XY(pcity->tile), TILE_XY(ptile));
3973 pcity->specialists[DEFAULT_SPECIALIST]++;
3974 sp_count++;
3975 } else {
3976 tile_set_worked(ptile, pcity);
3977 workers++;
3978 }
3979
3980#ifdef FREECIV_DEBUG
3981 /* Set this tile to unused; a check for not reset tiles is
3982 * included in game_load_internal() */
3983 loading->worked_tiles[ptile->index] = -1;
3984#endif /* FREECIV_DEBUG */
3985 }
3986 } city_tile_iterate_end;
3987
3988 if (tile_worked(city_tile(pcity)) != pcity) {
3989 struct city *pwork = tile_worked(city_tile(pcity));
3990
3991 if (NULL != pwork) {
3992 log_sg("[%s] city center of '%s' (%d,%d) [%d] is worked by '%s' "
3993 "(%d,%d) [%d]; repairing", citystr, city_name_get(pcity),
3994 TILE_XY(city_tile(pcity)), city_size_get(pcity), city_name_get(pwork),
3995 TILE_XY(city_tile(pwork)), city_size_get(pwork));
3996
3997 tile_set_worked(city_tile(pcity), NULL); /* remove tile from pwork */
3998 pwork->specialists[DEFAULT_SPECIALIST]++;
3999 auto_arrange_workers(pwork);
4000 } else {
4001 log_sg("[%s] city center of '%s' (%d,%d) [%d] is empty; repairing",
4002 citystr, city_name_get(pcity), TILE_XY(city_tile(pcity)),
4003 city_size_get(pcity));
4004 }
4005
4006 /* repair pcity */
4007 tile_set_worked(city_tile(pcity), pcity);
4008 city_repair_size(pcity, -1);
4009 }
4010
4011 repair = city_size_get(pcity) - sp_count - (workers - FREE_WORKED_TILES);
4012 if (0 != repair) {
4013 log_sg("[%s] size mismatch for '%s' (%d,%d): size [%d] != "
4014 "(workers [%d] - free worked tiles [%d]) + specialists [%d]",
4015 citystr, city_name_get(pcity), TILE_XY(city_tile(pcity)), city_size_get(pcity),
4016 workers, FREE_WORKED_TILES, sp_count);
4017
4018 /* repair pcity */
4019 city_repair_size(pcity, repair);
4020 }
4021
4022 /* worklist_init() done in create_city_virtual() */
4023 worklist_load(loading->file, wlist_max_length, &pcity->worklist, "%s", citystr);
4024
4025 /* Load city options. */
4026 BV_CLR_ALL(pcity->city_options);
4027 for (i = 0; i < loading->coptions.size; i++) {
4028 if (secfile_lookup_bool_default(loading->file, FALSE, "%s.option%d",
4029 citystr, i)) {
4030 BV_SET(pcity->city_options, loading->coptions.order[i]);
4031 }
4032 }
4033 /* Was never stored to savegame2 saves */
4034 pcity->wlcb = WLCB_SMART;
4035
4036 CALL_FUNC_EACH_AI(city_load, loading->file, pcity, citystr);
4037
4038 return TRUE;
4039}
4040
4041/************************************************************************/
4044static void sg_load_player_city_citizens(struct loaddata *loading,
4045 struct player *plr,
4046 struct city *pcity,
4047 const char *citystr)
4048{
4049 if (game.info.citizen_nationality) {
4050 citizens size;
4051
4052 citizens_init(pcity);
4053 player_slots_iterate(pslot) {
4054 int nationality;
4055
4056 nationality = secfile_lookup_int_default(loading->file, -1,
4057 "%s.citizen%d", citystr,
4058 player_slot_index(pslot));
4059 if (nationality > 0 && !player_slot_is_used(pslot)) {
4060 log_sg("Citizens of an invalid nation for %s (player slot %d)!",
4061 city_name_get(pcity), player_slot_index(pslot));
4062 continue;
4063 }
4064
4065 if (nationality != -1 && player_slot_is_used(pslot)) {
4066 sg_warn(nationality >= 0 && nationality <= MAX_CITY_SIZE,
4067 "Invalid value for citizens of player %d in %s: %d.",
4068 player_slot_index(pslot), city_name_get(pcity), nationality);
4069 citizens_nation_set(pcity, pslot, nationality);
4070 }
4071 } player_slots_iterate_end;
4072 /* Sanity check. */
4073 size = citizens_count(pcity);
4074 if (size != city_size_get(pcity)) {
4075 if (size != 0) {
4076 /* size == 0 can be result from the fact that ruleset had no
4077 * nationality enabled at saving time, so no citizens at all
4078 * were saved. But something more serious must be going on if
4079 * citizens have been saved partially - if some of them are there. */
4080 log_sg("City size and number of citizens does not match in %s "
4081 "(%d != %d)! Repairing ...", city_name_get(pcity),
4082 city_size_get(pcity), size);
4083 }
4084 citizens_update(pcity, NULL);
4085 }
4086 }
4087}
4088
4089/************************************************************************/
4092static void sg_load_player_units(struct loaddata *loading,
4093 struct player *plr)
4094{
4095 int nunits, i, plrno = player_number(plr);
4096
4097 /* Check status and return if not OK (sg_success FALSE). */
4098 sg_check_ret();
4099
4100 sg_failure_ret(secfile_lookup_int(loading->file, &nunits,
4101 "player%d.nunits", plrno),
4102 "%s", secfile_error());
4103 if (!plr->is_alive && nunits > 0) {
4104 log_sg("'player%d.nunits' = %d for dead player!", plrno, nunits);
4105 nunits = 0; /* Some old savegames may be buggy. */
4106 }
4107
4108 for (i = 0; i < nunits; i++) {
4109 struct unit *punit;
4110 struct city *pcity;
4111 const char *name;
4112 char buf[32];
4113 struct unit_type *type;
4114 struct tile *ptile;
4115
4116 fc_snprintf(buf, sizeof(buf), "player%d.u%d", plrno, i);
4117
4118 name = secfile_lookup_str(loading->file, "%s.type_by_name", buf);
4119 type = unit_type_by_rule_name(name);
4120 sg_failure_ret(type != NULL, "%s: unknown unit type \"%s\".", buf, name);
4121
4122 /* Create a dummy unit. */
4123 punit = unit_virtual_create(plr, NULL, type, 0);
4124 if (!sg_load_player_unit(loading, plr, punit, buf)) {
4125 unit_virtual_destroy(punit);
4126 sg_failure_ret(FALSE, "Error loading unit %d of player %d.", i, plrno);
4127 }
4128
4129 identity_number_reserve(punit->id);
4130 idex_register_unit(&wld, punit);
4131
4132 if ((pcity = game_city_by_number(punit->homecity))) {
4133 unit_list_prepend(pcity->units_supported, punit);
4134 } else if (punit->homecity > IDENTITY_NUMBER_ZERO) {
4135 log_sg("%s: bad home city %d.", buf, punit->homecity);
4136 punit->homecity = IDENTITY_NUMBER_ZERO;
4137 }
4138
4139 ptile = unit_tile(punit);
4140
4141 /* allocate the unit's contribution to fog of war */
4142 punit->server.vision = vision_new(unit_owner(punit), ptile);
4143 unit_refresh_vision(punit);
4144 /* NOTE: There used to be some map_set_known calls here. These were
4145 * unneeded since unfogging the tile when the unit sees it will
4146 * automatically reveal that tile. */
4147
4148 unit_list_append(plr->units, punit);
4149 unit_list_prepend(unit_tile(punit)->units, punit);
4150
4151 /* Claim ownership of fortress? */
4152 if ((extra_owner(ptile) == NULL
4153 || pplayers_at_war(extra_owner(ptile), plr))
4154 && tile_has_claimable_base(ptile, unit_type_get(punit))) {
4155 tile_claim_bases(ptile, plr);
4156 }
4157 }
4158}
4159
4160/************************************************************************/
4170static int sg_order_to_action(int order, struct unit *act_unit,
4171 struct tile *tgt_tile)
4172{
4173 switch (order) {
4174 case ORDER_OLD_BUILD_CITY:
4175 if (tile_city(tgt_tile)
4176 && city_owner(tile_city(tgt_tile)) == unit_owner(act_unit)) {
4177 /* The player's cities are loaded right before their units. It wasn't
4178 * possible for rulesets to allow joining foreign cities before 3.0.
4179 * This means that a converted build city order only can be a Join
4180 * City order if it targets a domestic city. */
4181 return ACTION_JOIN_CITY;
4182 } else {
4183 /* Assume that the intention was to found a new city. */
4184 return ACTION_FOUND_CITY;
4185 }
4186 case ORDER_OLD_BUILD_WONDER:
4187 /* Maps one to one with each other. */
4188 return ACTION_HELP_WONDER;
4189 case ORDER_OLD_TRADE_ROUTE:
4190 /* Maps one to one with each other. */
4191 return ACTION_TRADE_ROUTE;
4192 case ORDER_OLD_DISBAND:
4193 /* Added to the order system in the same commit as Help Wonder. Assume
4194 * that anyone that intended to order Help Wonder used Help Wonder. */
4195 /* Could in theory be intended as an order to disband in the field. Why
4196 * would the player give a unit an order to go to a non city location
4197 * and disband there? Assume the intention was to recover production
4198 * until a non recovering disband order is found. */
4199 return ACTION_DISBAND_UNIT_RECOVER;
4200 case ORDER_OLD_HOMECITY:
4201 return ACTION_HOME_CITY;
4202 }
4203
4204 /* The order hasn't been replaced by an action. */
4205 return ACTION_NONE;
4206}
4207
4208/************************************************************************/
4211static bool sg_load_player_unit(struct loaddata *loading,
4212 struct player *plr, struct unit *punit,
4213 const char *unitstr)
4214{
4215 int activity;
4216 int nat_x, nat_y;
4217 enum tile_special_type target;
4218 struct extra_type *pextra = NULL;
4219 struct base_type *pbase = NULL;
4220 struct road_type *proad = NULL;
4221 struct tile *ptile;
4222 int extra_id;
4223 int base_id;
4224 int road_id;
4225 int ei;
4226 const char *facing_str;
4227 enum tile_special_type cfspe;
4228 int natnbr;
4229 bool ai_controlled;
4230
4231 sg_warn_ret_val(secfile_lookup_int(loading->file, &punit->id, "%s.id",
4232 unitstr), FALSE, "%s", secfile_error());
4233 sg_warn_ret_val(secfile_lookup_int(loading->file, &nat_x, "%s.x", unitstr),
4234 FALSE, "%s", secfile_error());
4235 sg_warn_ret_val(secfile_lookup_int(loading->file, &nat_y, "%s.y", unitstr),
4236 FALSE, "%s", secfile_error());
4237
4238 ptile = native_pos_to_tile(&(wld.map), nat_x, nat_y);
4239 sg_warn_ret_val(NULL != ptile, FALSE, "%s invalid tile (%d, %d)",
4240 unitstr, nat_x, nat_y);
4241 unit_tile_set(punit, ptile);
4242
4243 facing_str
4244 = secfile_lookup_str_default(loading->file, "x",
4245 "%s.facing", unitstr);
4246 if (facing_str[0] != 'x') {
4247 /* We don't touch punit->facing if savegame does not contain that
4248 * information. Initial orientation set by unit_virtual_create()
4249 * is as good as any. */
4250 enum direction8 facing = char2dir(facing_str[0]);
4251
4252 if (direction8_is_valid(facing)) {
4253 punit->facing = facing;
4254 } else {
4255 log_error("Illegal unit orientation '%s'", facing_str);
4256 }
4257 }
4258
4259 /* If savegame has unit nationality, it doesn't hurt to
4260 * internally set it even if nationality rules are disabled. */
4261 natnbr = secfile_lookup_int_default(loading->file,
4262 player_number(plr),
4263 "%s.nationality", unitstr);
4264
4265 punit->nationality = player_by_number(natnbr);
4266 if (punit->nationality == NULL) {
4267 punit->nationality = plr;
4268 }
4269
4270 sg_warn_ret_val(secfile_lookup_int(loading->file, &punit->homecity,
4271 "%s.homecity", unitstr), FALSE,
4272 "%s", secfile_error());
4273 sg_warn_ret_val(secfile_lookup_int(loading->file, &punit->moves_left,
4274 "%s.moves", unitstr), FALSE,
4275 "%s", secfile_error());
4276 sg_warn_ret_val(secfile_lookup_int(loading->file, &punit->fuel,
4277 "%s.fuel", unitstr), FALSE,
4278 "%s", secfile_error());
4279 sg_warn_ret_val(secfile_lookup_int(loading->file, &ei,
4280 "%s.activity", unitstr), FALSE,
4281 "%s", secfile_error());
4282 activity = unit_activity_by_name(loading->activities.order[ei],
4283 fc_strcasecmp);
4284
4285 punit->birth_turn
4286 = secfile_lookup_int_default(loading->file, game.info.turn,
4287 "%s.born", unitstr);
4288 punit->current_form_turn = game.info.turn;
4289
4290 extra_id = secfile_lookup_int_default(loading->file, -2,
4291 "%s.activity_tgt", unitstr);
4292
4293 if (extra_id != -2) {
4294 if (extra_id >= 0 && extra_id < loading->extra.size) {
4295 pextra = loading->extra.order[extra_id];
4296 set_unit_activity_targeted(punit, activity, pextra);
4297 } else if (activity == ACTIVITY_IRRIGATE) {
4298 struct extra_type *tgt = next_extra_for_tile(unit_tile(punit),
4299 EC_IRRIGATION,
4300 unit_owner(punit),
4301 punit);
4302 if (tgt != NULL) {
4303 set_unit_activity_targeted(punit, ACTIVITY_IRRIGATE, tgt);
4304 } else {
4305 set_unit_activity(punit, ACTIVITY_CULTIVATE);
4306 }
4307 } else if (activity == ACTIVITY_MINE) {
4308 struct extra_type *tgt = next_extra_for_tile(unit_tile(punit),
4309 EC_MINE,
4310 unit_owner(punit),
4311 punit);
4312 if (tgt != NULL) {
4313 set_unit_activity_targeted(punit, ACTIVITY_MINE, tgt);
4314 } else {
4315 set_unit_activity(punit, ACTIVITY_PLANT);
4316 }
4317 } else {
4318 set_unit_activity(punit, activity);
4319 }
4320 } else {
4321 /* extra_id == -2 -> activity_tgt not set */
4322 base_id = secfile_lookup_int_default(loading->file, -1,
4323 "%s.activity_base", unitstr);
4324 if (base_id >= 0 && base_id < loading->base.size) {
4325 pbase = loading->base.order[base_id];
4326 }
4327 road_id = secfile_lookup_int_default(loading->file, -1,
4328 "%s.activity_road", unitstr);
4329 if (road_id >= 0 && road_id < loading->road.size) {
4330 proad = loading->road.order[road_id];
4331 }
4332
4333 {
4334 int tgt_no = secfile_lookup_int_default(loading->file,
4335 loading->special.size /* S_LAST */,
4336 "%s.activity_target", unitstr);
4337 if (tgt_no >= 0 && tgt_no < loading->special.size) {
4338 target = loading->special.order[tgt_no];
4339 } else {
4340 target = S_LAST;
4341 }
4342 }
4343
4344 if (target == S_OLD_ROAD) {
4345 target = S_LAST;
4346 proad = road_by_compat_special(ROCO_ROAD);
4347 } else if (target == S_OLD_RAILROAD) {
4348 target = S_LAST;
4349 proad = road_by_compat_special(ROCO_RAILROAD);
4350 }
4351
4352 if (activity == ACTIVITY_OLD_ROAD) {
4353 activity = ACTIVITY_GEN_ROAD;
4354 proad = road_by_compat_special(ROCO_ROAD);
4355 } else if (activity == ACTIVITY_OLD_RAILROAD) {
4356 activity = ACTIVITY_GEN_ROAD;
4357 proad = road_by_compat_special(ROCO_RAILROAD);
4358 }
4359
4360 /* We need changed_from == ACTIVITY_IDLE by now so that
4361 * set_unit_activity() and friends don't spuriously restore activity
4362 * points -- unit should have been created this way */
4363 fc_assert(punit->changed_from == ACTIVITY_IDLE);
4364
4365 if (activity == ACTIVITY_BASE) {
4366 if (pbase) {
4367 set_unit_activity_base(punit, base_number(pbase));
4368 } else {
4369 log_sg("Cannot find base %d for %s to build",
4370 base_id, unit_rule_name(punit));
4371 set_unit_activity(punit, ACTIVITY_IDLE);
4372 }
4373 } else if (activity == ACTIVITY_GEN_ROAD) {
4374 if (proad) {
4375 set_unit_activity_road(punit, road_number(proad));
4376 } else {
4377 log_sg("Cannot find road %d for %s to build",
4378 road_id, unit_rule_name(punit));
4379 set_unit_activity(punit, ACTIVITY_IDLE);
4380 }
4381 } else if (activity == ACTIVITY_PILLAGE) {
4382 struct extra_type *a_target;
4383
4384 if (target != S_LAST) {
4385 a_target = special_extra_get(target);
4386 } else if (pbase != NULL) {
4387 a_target = base_extra_get(pbase);
4388 } else if (proad != NULL) {
4389 a_target = road_extra_get(proad);
4390 } else {
4391 a_target = NULL;
4392 }
4393 /* An out-of-range base number is seen with old savegames. We take
4394 * it as indicating undirected pillaging. We will assign pillage
4395 * targets before play starts. */
4396 set_unit_activity_targeted(punit, activity, a_target);
4397 } else if (activity == ACTIVITY_IRRIGATE) {
4398 struct extra_type *tgt = next_extra_for_tile(unit_tile(punit),
4399 EC_IRRIGATION,
4400 unit_owner(punit),
4401 punit);
4402 if (tgt != NULL) {
4403 set_unit_activity_targeted(punit, ACTIVITY_IRRIGATE, tgt);
4404 } else {
4405 set_unit_activity_targeted(punit, ACTIVITY_IRRIGATE, NULL);
4406 }
4407 } else if (activity == ACTIVITY_MINE) {
4408 struct extra_type *tgt = next_extra_for_tile(unit_tile(punit),
4409 EC_MINE,
4410 unit_owner(punit),
4411 punit);
4412 if (tgt != NULL) {
4413 set_unit_activity_targeted(punit, ACTIVITY_MINE, tgt);
4414 } else {
4415 set_unit_activity_targeted(punit, ACTIVITY_MINE, NULL);
4416 }
4417 } else if (activity == ACTIVITY_OLD_POLLUTION_SG2
4418 || activity == ACTIVITY_OLD_FALLOUT_SG2) {
4419 struct extra_type *tgt = prev_extra_in_tile(unit_tile(punit),
4420 ERM_CLEAN,
4421 unit_owner(punit),
4422 punit);
4423 if (tgt != NULL) {
4424 set_unit_activity_targeted(punit, ACTIVITY_CLEAN, tgt);
4425 } else {
4426 set_unit_activity_targeted(punit, ACTIVITY_CLEAN, NULL);
4427 }
4428 } else {
4429 set_unit_activity_targeted(punit, activity, NULL);
4430 }
4431 } /* activity_tgt == NULL */
4432
4433 sg_warn_ret_val(secfile_lookup_int(loading->file, &punit->activity_count,
4434 "%s.activity_count", unitstr), FALSE,
4435 "%s", secfile_error());
4436
4437 punit->changed_from =
4438 secfile_lookup_int_default(loading->file, ACTIVITY_IDLE,
4439 "%s.changed_from", unitstr);
4440
4441 extra_id = secfile_lookup_int_default(loading->file, -2,
4442 "%s.changed_from_tgt", unitstr);
4443
4444 if (extra_id != -2) {
4445 if (extra_id >= 0 && extra_id < loading->extra.size) {
4446 punit->changed_from_target = loading->extra.order[extra_id];
4447 } else {
4448 punit->changed_from_target = NULL;
4449 }
4450 } else {
4451 /* extra_id == -2 -> changed_from_tgt not set */
4452
4453 cfspe =
4454 secfile_lookup_int_default(loading->file, S_LAST,
4455 "%s.changed_from_target", unitstr);
4456 base_id =
4457 secfile_lookup_int_default(loading->file, -1,
4458 "%s.changed_from_base", unitstr);
4459 road_id =
4460 secfile_lookup_int_default(loading->file, -1,
4461 "%s.changed_from_road", unitstr);
4462
4463 if (road_id == -1) {
4464 if (cfspe == S_OLD_ROAD) {
4465 proad = road_by_compat_special(ROCO_ROAD);
4466 if (proad) {
4467 road_id = road_number(proad);
4468 }
4469 } else if (cfspe == S_OLD_RAILROAD) {
4470 proad = road_by_compat_special(ROCO_RAILROAD);
4471 if (proad) {
4472 road_id = road_number(proad);
4473 }
4474 }
4475 }
4476
4477 if (base_id >= 0 && base_id < loading->base.size) {
4478 punit->changed_from_target = base_extra_get(loading->base.order[base_id]);
4479 } else if (road_id >= 0 && road_id < loading->road.size) {
4480 punit->changed_from_target = road_extra_get(loading->road.order[road_id]);
4481 } else if (cfspe != S_LAST) {
4482 punit->changed_from_target = special_extra_get(cfspe);
4483 } else {
4484 punit->changed_from_target = NULL;
4485 }
4486
4487 if (punit->changed_from == ACTIVITY_IRRIGATE) {
4488 struct extra_type *tgt = next_extra_for_tile(unit_tile(punit),
4489 EC_IRRIGATION,
4490 unit_owner(punit),
4491 punit);
4492 if (tgt != NULL) {
4493 punit->changed_from_target = tgt;
4494 } else {
4495 punit->changed_from_target = NULL;
4496 }
4497 } else if (punit->changed_from == ACTIVITY_MINE) {
4498 struct extra_type *tgt = next_extra_for_tile(unit_tile(punit),
4499 EC_MINE,
4500 unit_owner(punit),
4501 punit);
4502 if (tgt != NULL) {
4503 punit->changed_from_target = tgt;
4504 } else {
4505 punit->changed_from_target = NULL;
4506 }
4507 } else if (punit->changed_from == ACTIVITY_OLD_POLLUTION_SG2
4508 || punit->changed_from == ACTIVITY_OLD_FALLOUT_SG2) {
4509 struct extra_type *tgt = prev_extra_in_tile(unit_tile(punit),
4510 ERM_CLEAN,
4511 unit_owner(punit),
4512 punit);
4513 if (tgt != NULL) {
4514 punit->changed_from_target = tgt;
4515 } else {
4516 punit->changed_from_target = NULL;
4517 }
4518 }
4519 }
4520
4521 punit->changed_from_count =
4522 secfile_lookup_int_default(loading->file, 0,
4523 "%s.changed_from_count", unitstr);
4524
4525 /* Special case: for a long time, we accidentally incremented
4526 * activity_count while a unit was sentried, so it could increase
4527 * without bound (bug #20641) and be saved in old savefiles.
4528 * We zero it to prevent potential trouble overflowing the range
4529 * in network packets, etc. */
4530 if (activity == ACTIVITY_SENTRY) {
4531 punit->activity_count = 0;
4532 }
4533 if (punit->changed_from == ACTIVITY_SENTRY) {
4534 punit->changed_from_count = 0;
4535 }
4536
4537 punit->veteran
4538 = secfile_lookup_int_default(loading->file, 0, "%s.veteran", unitstr);
4539 {
4540 /* Protect against change in veteran system in ruleset */
4541 const int levels = utype_veteran_levels(unit_type_get(punit));
4542 if (punit->veteran >= levels) {
4543 fc_assert(levels >= 1);
4544 punit->veteran = levels - 1;
4545 }
4546 }
4547 punit->done_moving
4548 = secfile_lookup_bool_default(loading->file, (punit->moves_left == 0),
4549 "%s.done_moving", unitstr);
4550 punit->battlegroup
4551 = secfile_lookup_int_default(loading->file, BATTLEGROUP_NONE,
4552 "%s.battlegroup", unitstr);
4553
4554 if (secfile_lookup_bool_default(loading->file, FALSE,
4555 "%s.go", unitstr)) {
4556 int gnat_x, gnat_y;
4557
4558 sg_warn_ret_val(secfile_lookup_int(loading->file, &gnat_x,
4559 "%s.goto_x", unitstr), FALSE,
4560 "%s", secfile_error());
4561 sg_warn_ret_val(secfile_lookup_int(loading->file, &gnat_y,
4562 "%s.goto_y", unitstr), FALSE,
4563 "%s", secfile_error());
4564
4565 punit->goto_tile = native_pos_to_tile(&(wld.map), gnat_x, gnat_y);
4566 } else {
4567 punit->goto_tile = NULL;
4568
4569 /* These variables are not used but needed for saving the unit table.
4570 * Load them to prevent unused variables errors. */
4571 (void) secfile_entry_lookup(loading->file, "%s.goto_x", unitstr);
4572 (void) secfile_entry_lookup(loading->file, "%s.goto_y", unitstr);
4573 }
4574
4575 /* Load AI data of the unit. */
4576 CALL_FUNC_EACH_AI(unit_load, loading->file, punit, unitstr);
4577
4578 sg_warn_ret_val(secfile_lookup_bool(loading->file,
4579 &ai_controlled,
4580 "%s.ai", unitstr), FALSE,
4581 "%s", secfile_error());
4582 if (ai_controlled) {
4583 /* Autosettler and Autoexplore are separated by
4584 * compat_post_load_030100() when set to SSA_AUTOSETTLER */
4585 punit->ssa_controller = SSA_AUTOSETTLER;
4586 } else {
4587 punit->ssa_controller = SSA_NONE;
4588 }
4589 sg_warn_ret_val(secfile_lookup_int(loading->file, &punit->hp,
4590 "%s.hp", unitstr), FALSE,
4591 "%s", secfile_error());
4592
4593 punit->server.ord_map
4594 = secfile_lookup_int_default(loading->file, 0, "%s.ord_map", unitstr);
4595 punit->server.ord_city
4596 = secfile_lookup_int_default(loading->file, 0, "%s.ord_city", unitstr);
4597 punit->moved
4598 = secfile_lookup_bool_default(loading->file, FALSE, "%s.moved", unitstr);
4599 punit->paradropped
4600 = secfile_lookup_bool_default(loading->file, FALSE,
4601 "%s.paradropped", unitstr);
4602
4603 /* The transport status (punit->transported_by) is loaded in
4604 * sg_player_units_transport(). */
4605
4606 /* Initialize upkeep values: these are hopefully initialized
4607 * elsewhere before use (specifically, in city_support(); but
4608 * fixme: check whether always correctly initialized?).
4609 * Below is mainly for units which don't have homecity --
4610 * otherwise these don't get initialized (and AI calculations
4611 * etc may use junk values). */
4612 output_type_iterate(o) {
4613 punit->upkeep[o] = utype_upkeep_cost(unit_type_get(punit), plr, o);
4614 } output_type_iterate_end;
4615
4616 punit->action_decision_want
4617 = secfile_lookup_enum_default(loading->file,
4618 ACT_DEC_NOTHING, action_decision,
4619 "%s.action_decision_want", unitstr);
4620
4621 if (punit->action_decision_want != ACT_DEC_NOTHING) {
4622 /* Load the tile to act against. */
4623 int adwt_x, adwt_y;
4624
4625 if (secfile_lookup_int(loading->file, &adwt_x,
4626 "%s.action_decision_tile_x", unitstr)
4627 && secfile_lookup_int(loading->file, &adwt_y,
4628 "%s.action_decision_tile_y", unitstr)) {
4629 punit->action_decision_tile = native_pos_to_tile(&(wld.map),
4630 adwt_x, adwt_y);
4631 } else {
4632 punit->action_decision_want = ACT_DEC_NOTHING;
4633 punit->action_decision_tile = NULL;
4634 log_sg("Bad action_decision_tile for unit %d", punit->id);
4635 }
4636 } else {
4637 (void) secfile_entry_lookup(loading->file, "%s.action_decision_tile_x", unitstr);
4638 (void) secfile_entry_lookup(loading->file, "%s.action_decision_tile_y", unitstr);
4639 punit->action_decision_tile = NULL;
4640 }
4641
4642 /* Load the unit orders */
4643 {
4644 int len = secfile_lookup_int_default(loading->file, 0,
4645 "%s.orders_length", unitstr);
4646
4647 if (len > 0) {
4648 const char *orders_unitstr, *dir_unitstr, *act_unitstr;
4649 const char *tgt_unitstr;
4650 const char *base_unitstr = NULL;
4651 const char *road_unitstr = NULL;
4652 int road_idx = road_number(road_by_compat_special(ROCO_ROAD));
4653 int rail_idx = road_number(road_by_compat_special(ROCO_RAILROAD));
4654 int j;
4655
4656 punit->orders.list = fc_malloc(len * sizeof(*(punit->orders.list)));
4657 punit->orders.length = len;
4658 punit->orders.index
4659 = secfile_lookup_int_default(loading->file, 0,
4660 "%s.orders_index", unitstr);
4661 punit->orders.repeat
4662 = secfile_lookup_bool_default(loading->file, FALSE,
4663 "%s.orders_repeat", unitstr);
4664 punit->orders.vigilant
4665 = secfile_lookup_bool_default(loading->file, FALSE,
4666 "%s.orders_vigilant", unitstr);
4667
4668 orders_unitstr
4669 = secfile_lookup_str_default(loading->file, "",
4670 "%s.orders_list", unitstr);
4671 dir_unitstr
4672 = secfile_lookup_str_default(loading->file, "",
4673 "%s.dir_list", unitstr);
4674 act_unitstr
4675 = secfile_lookup_str_default(loading->file, "",
4676 "%s.activity_list", unitstr);
4677 tgt_unitstr
4678 = secfile_lookup_str_default(loading->file, NULL, "%s.tgt_list", unitstr);
4679
4680 if (tgt_unitstr == NULL) {
4681 base_unitstr
4682 = secfile_lookup_str(loading->file, "%s.base_list", unitstr);
4683 road_unitstr
4684 = secfile_lookup_str_default(loading->file, NULL, "%s.road_list", unitstr);
4685 }
4686
4687 punit->has_orders = TRUE;
4688
4689 for (j = 0; j < len; j++) {
4690 struct unit_order *order = &punit->orders.list[j];
4691
4692 if (orders_unitstr[j] == '\0' || dir_unitstr[j] == '\0'
4693 || act_unitstr[j] == '\0') {
4694 log_sg("Invalid unit orders.");
4695 free_unit_orders(punit);
4696 break;
4697 }
4698 order->order = char2order(orders_unitstr[j]);
4699 order->dir = char2dir(dir_unitstr[j]);
4700 order->activity = char2activity(act_unitstr[j]);
4701 /* Target, if needed, is set in compat_post_load_030100() */
4702 order->target = NO_TARGET;
4703 order->sub_target = NO_TARGET;
4704
4705 if (order->order == ORDER_LAST
4706 || (order->order == ORDER_MOVE && !direction8_is_valid(order->dir))
4707 || (order->order == ORDER_ACTION_MOVE
4708 && !direction8_is_valid(order->dir))
4709 || (order->order == ORDER_ACTIVITY
4710 && order->activity == ACTIVITY_LAST)) {
4711 /* An invalid order. Just drop the orders for this unit. */
4712 free(punit->orders.list);
4713 punit->orders.list = NULL;
4714 punit->orders.length = 0;
4715 punit->has_orders = FALSE;
4716 punit->goto_tile = NULL;
4717 break;
4718 }
4719
4720 /* The order may have been replaced by the perform action order */
4721 order->action = sg_order_to_action(order->order, punit,
4722 punit->goto_tile);
4723 if (order->action != ACTION_NONE) {
4724 /* The order was converted by order_to_action */
4725 order->order = ORDER_PERFORM_ACTION;
4726 }
4727
4728 if (tgt_unitstr) {
4729 if (tgt_unitstr[j] != '?') {
4730 extra_id = char2num(tgt_unitstr[j]);
4731
4732 if (extra_id < 0 || extra_id >= loading->extra.size) {
4733 log_sg("Cannot find extra %d for %s to build",
4734 extra_id, unit_rule_name(punit));
4735 order->sub_target = EXTRA_NONE;
4736 } else {
4737 order->sub_target = extra_id;
4738 }
4739 } else {
4740 order->sub_target = EXTRA_NONE;
4741 }
4742 } else {
4743 /* In pre-2.6 savegames, base_list and road_list were only saved
4744 * for those activities (and not e.g. pillaging) */
4745 if (base_unitstr && base_unitstr[j] != '?'
4746 && order->activity == ACTIVITY_BASE) {
4747 base_id = char2num(base_unitstr[j]);
4748
4749 if (base_id < 0 || base_id >= loading->base.size) {
4750 log_sg("Cannot find base %d for %s to build",
4751 base_id, unit_rule_name(punit));
4752 base_id = base_number(get_base_by_gui_type(BASE_GUI_FORTRESS,
4753 NULL, NULL));
4754 }
4755
4756 order->sub_target
4757 = extra_number(base_extra_get(base_by_number(base_id)));
4758 } else if (road_unitstr && road_unitstr[j] != '?'
4759 && order->activity == ACTIVITY_GEN_ROAD) {
4760 road_id = char2num(road_unitstr[j]);
4761
4762 if (road_id < 0 || road_id >= loading->road.size) {
4763 log_sg("Cannot find road %d for %s to build",
4764 road_id, unit_rule_name(punit));
4765 road_id = 0;
4766 }
4767
4768 order->sub_target
4769 = extra_number(road_extra_get(road_by_number(road_id)));
4770 } else {
4771 order->sub_target = EXTRA_NONE;
4772 }
4773
4774 if (order->activity == ACTIVITY_OLD_ROAD) {
4775 order->activity = ACTIVITY_GEN_ROAD;
4776 order->sub_target
4777 = extra_number(road_extra_get(road_by_number(road_idx)));
4778 } else if (order->activity == ACTIVITY_OLD_RAILROAD) {
4779 order->activity = ACTIVITY_GEN_ROAD;
4780 order->sub_target
4781 = extra_number(road_extra_get(road_by_number(rail_idx)));
4782 }
4783 }
4784 }
4785 } else {
4786 punit->goto_tile = NULL;
4787 punit->has_orders = FALSE;
4788 punit->orders.list = NULL;
4789 punit->orders.length = 0;
4790
4791 (void) secfile_entry_lookup(loading->file, "%s.orders_index", unitstr);
4792 (void) secfile_entry_lookup(loading->file, "%s.orders_repeat", unitstr);
4793 (void) secfile_entry_lookup(loading->file, "%s.orders_vigilant", unitstr);
4794 (void) secfile_entry_lookup(loading->file, "%s.orders_list", unitstr);
4795 (void) secfile_entry_lookup(loading->file, "%s.dir_list", unitstr);
4796 (void) secfile_entry_lookup(loading->file, "%s.activity_list", unitstr);
4797 (void) secfile_entry_lookup(loading->file, "%s.tgt_list", unitstr);
4798 }
4799 }
4800
4801 return TRUE;
4802}
4803
4804/************************************************************************/
4808static void sg_load_player_units_transport(struct loaddata *loading,
4809 struct player *plr)
4810{
4811 int nunits, i, plrno = player_number(plr);
4812
4813 /* Check status and return if not OK (sg_success FALSE). */
4814 sg_check_ret();
4815
4816 /* Recheck the number of units for the player. This is a copied from
4817 * sg_load_player_units(). */
4818 sg_failure_ret(secfile_lookup_int(loading->file, &nunits,
4819 "player%d.nunits", plrno),
4820 "%s", secfile_error());
4821 if (!plr->is_alive && nunits > 0) {
4822 log_sg("'player%d.nunits' = %d for dead player!", plrno, nunits);
4823 nunits = 0; /* Some old savegames may be buggy. */
4824 }
4825
4826 for (i = 0; i < nunits; i++) {
4827 int id_unit, id_trans;
4828 struct unit *punit, *ptrans;
4829
4830 id_unit = secfile_lookup_int_default(loading->file, -1,
4831 "player%d.u%d.id",
4832 plrno, i);
4833 punit = player_unit_by_number(plr, id_unit);
4834 fc_assert_action(punit != NULL, continue);
4835
4836 id_trans = secfile_lookup_int_default(loading->file, -1,
4837 "player%d.u%d.transported_by",
4838 plrno, i);
4839 if (id_trans == -1) {
4840 /* Not transported. */
4841 continue;
4842 }
4843
4844 ptrans = game_unit_by_number(id_trans);
4845 fc_assert_action(id_trans == -1 || ptrans != NULL, continue);
4846
4847 if (ptrans) {
4848#ifndef FREECIV_NDEBUG
4849 bool load_success =
4850#endif
4851 unit_transport_load(punit, ptrans, TRUE);
4852
4853 fc_assert_action(load_success, continue);
4854 }
4855 }
4856}
4857
4858/************************************************************************/
4861static void sg_load_player_attributes(struct loaddata *loading,
4862 struct player *plr)
4863{
4864 int plrno = player_number(plr);
4865
4866 /* Check status and return if not OK (sg_success FALSE). */
4867 sg_check_ret();
4868
4869 /* Toss any existing attribute_block (should not exist) */
4870 if (plr->attribute_block.data) {
4871 free(plr->attribute_block.data);
4872 plr->attribute_block.data = NULL;
4873 }
4874
4875 /* This is a big heap of opaque data for the client, check everything! */
4876 plr->attribute_block.length = secfile_lookup_int_default(
4877 loading->file, 0, "player%d.attribute_v2_block_length", plrno);
4878
4879 if (0 > plr->attribute_block.length) {
4880 log_sg("player%d.attribute_v2_block_length=%d too small", plrno,
4881 plr->attribute_block.length);
4882 plr->attribute_block.length = 0;
4883 } else if (MAX_ATTRIBUTE_BLOCK < plr->attribute_block.length) {
4884 log_sg("player%d.attribute_v2_block_length=%d too big (max %d)",
4885 plrno, plr->attribute_block.length, MAX_ATTRIBUTE_BLOCK);
4886 plr->attribute_block.length = 0;
4887 } else if (0 < plr->attribute_block.length) {
4888 int part_nr, parts;
4889 int quoted_length;
4890 char *quoted;
4891#ifndef FREECIV_NDEBUG
4892 size_t actual_length;
4893#endif
4894
4895 sg_failure_ret(
4896 secfile_lookup_int(loading->file, &quoted_length,
4897 "player%d.attribute_v2_block_length_quoted",
4898 plrno), "%s", secfile_error());
4899 sg_failure_ret(
4900 secfile_lookup_int(loading->file, &parts,
4901 "player%d.attribute_v2_block_parts", plrno),
4902 "%s", secfile_error());
4903
4904 quoted = fc_malloc(quoted_length + 1);
4905 quoted[0] = '\0';
4906 plr->attribute_block.data = fc_malloc(plr->attribute_block.length);
4907 for (part_nr = 0; part_nr < parts; part_nr++) {
4908 const char *current =
4909 secfile_lookup_str(loading->file,
4910 "player%d.attribute_v2_block_data.part%d",
4911 plrno, part_nr);
4912 if (!current) {
4913 log_sg("attribute_v2_block_parts=%d actual=%d", parts, part_nr);
4914 break;
4915 }
4916 log_debug("attribute_v2_block_length_quoted=%d"
4917 " have=" SIZE_T_PRINTF " part=" SIZE_T_PRINTF,
4918 quoted_length, strlen(quoted), strlen(current));
4919 fc_assert(strlen(quoted) + strlen(current) <= quoted_length);
4920 strcat(quoted, current);
4921 }
4922 fc_assert_msg(quoted_length == strlen(quoted),
4923 "attribute_v2_block_length_quoted=%d"
4924 " actual=" SIZE_T_PRINTF,
4925 quoted_length, strlen(quoted));
4926
4927#ifndef FREECIV_NDEBUG
4928 actual_length =
4929#endif
4930 unquote_block(quoted,
4931 plr->attribute_block.data,
4932 plr->attribute_block.length);
4933 fc_assert(actual_length == plr->attribute_block.length);
4934 free(quoted);
4935 }
4936}
4937
4938/************************************************************************/
4941static void sg_load_player_vision(struct loaddata *loading,
4942 struct player *plr)
4943{
4944 int plrno = player_number(plr);
4945 int total_ncities =
4946 secfile_lookup_int_default(loading->file, -1,
4947 "player%d.dc_total", plrno);
4948 int i;
4949 bool someone_alive = FALSE;
4950
4951 /* Check status and return if not OK (sg_success FALSE). */
4952 sg_check_ret();
4953
4954 if (game.server.revealmap & REVEAL_MAP_DEAD) {
4955 player_list_iterate(team_members(plr->team), pteam_member) {
4956 if (pteam_member->is_alive) {
4957 someone_alive = TRUE;
4958 break;
4959 }
4960 } player_list_iterate_end;
4961
4962 if (!someone_alive) {
4963 /* Reveal all for completely dead teams. */
4964 map_know_and_see_all(plr);
4965 }
4966 }
4967
4968 if (!plr->is_alive
4969 || -1 == total_ncities
4970 || !game.info.fogofwar
4971 || !secfile_lookup_bool_default(loading->file, TRUE,
4972 "game.save_private_map")) {
4973 /* We have:
4974 * - a dead player;
4975 * - fogged cities are not saved for any reason;
4976 * - a savegame with fog of war turned off;
4977 * - or game.save_private_map is not set to FALSE in the scenario /
4978 * savegame. The players private knowledge is set to be what they could
4979 * see without fog of war. */
4980 whole_map_iterate(&(wld.map), ptile) {
4981 if (map_is_known(ptile, plr)) {
4982 struct city *pcity = tile_city(ptile);
4983
4984 update_player_tile_last_seen(plr, ptile);
4985 update_player_tile_knowledge(plr, ptile);
4986
4987 if (NULL != pcity) {
4988 update_dumb_city(plr, pcity);
4989 }
4990 }
4991 } whole_map_iterate_end;
4992
4993 /* Nothing more to do; */
4994 return;
4995 }
4996
4997 /* Load player map (terrain). */
4998 LOAD_MAP_CHAR(ch, ptile,
4999 map_get_player_tile(ptile, plr)->terrain
5000 = char2terrain(ch), loading->file,
5001 "player%d.map_t%04d", plrno);
5002
5003 /* Load player map (resources). */
5004 LOAD_MAP_CHAR(ch, ptile,
5005 map_get_player_tile(ptile, plr)->resource
5006 = char2resource(ch), loading->file,
5007 "player%d.map_res%04d", plrno);
5008
5009 if (loading->version >= 30) {
5010 /* 2.6.0 or newer */
5011
5012 /* Load player map (extras). */
5013 halfbyte_iterate_extras(j, loading->extra.size) {
5014 LOAD_MAP_CHAR(ch, ptile,
5015 sg_extras_set_dbv(&(map_get_player_tile(ptile, plr)->extras),
5016 ch, loading->extra.order + 4 * j),
5017 loading->file, "player%d.map_e%02d_%04d", plrno, j);
5018 } halfbyte_iterate_extras_end;
5019 } else {
5020 /* Load player map (specials). */
5021 halfbyte_iterate_special(j, loading->special.size) {
5022 LOAD_MAP_CHAR(ch, ptile,
5023 sg_special_set_dbv(ptile,
5024 &(map_get_player_tile(ptile, plr)->extras),
5025 ch, loading->special.order + 4 * j, FALSE),
5026 loading->file, "player%d.map_spe%02d_%04d", plrno, j);
5027 } halfbyte_iterate_special_end;
5028
5029 /* Load player map (bases). */
5030 halfbyte_iterate_bases(j, loading->base.size) {
5031 LOAD_MAP_CHAR(ch, ptile,
5032 sg_bases_set_dbv(&(map_get_player_tile(ptile, plr)->extras),
5033 ch, loading->base.order + 4 * j),
5034 loading->file, "player%d.map_b%02d_%04d", plrno, j);
5035 } halfbyte_iterate_bases_end;
5036
5037 /* Load player map (roads). */
5038 if (loading->version >= 20) {
5039 /* 2.5.0 or newer */
5040 halfbyte_iterate_roads(j, loading->road.size) {
5041 LOAD_MAP_CHAR(ch, ptile,
5042 sg_roads_set_dbv(&(map_get_player_tile(ptile, plr)->extras),
5043 ch, loading->road.order + 4 * j),
5044 loading->file, "player%d.map_r%02d_%04d", plrno, j);
5045 } halfbyte_iterate_roads_end;
5046 }
5047 }
5048
5049 if (game.server.foggedborders) {
5050 /* Load player map (border). */
5051 int x, y;
5052
5053 for (y = 0; y < wld.map.ysize; y++) {
5054 const char *buffer
5055 = secfile_lookup_str(loading->file, "player%d.map_owner%04d",
5056 plrno, y);
5057 const char *buffer2
5058 = secfile_lookup_str(loading->file, "player%d.extras_owner%04d",
5059 plrno, y);
5060 const char *ptr = buffer;
5061 const char *ptr2 = buffer2;
5062
5063 sg_failure_ret(NULL != buffer,
5064 "Savegame corrupt - map line %d not found.", y);
5065 for (x = 0; x < wld.map.xsize; x++) {
5066 char token[TOKEN_SIZE];
5067 char token2[TOKEN_SIZE];
5068 int number;
5069 struct tile *ptile = native_pos_to_tile(&(wld.map), x, y);
5070
5071 scanin(&ptr, ",", token, sizeof(token));
5072 sg_failure_ret('\0' != token[0],
5073 "Savegame corrupt - map size not correct.");
5074 if (strcmp(token, "-") == 0) {
5075 map_get_player_tile(ptile, plr)->owner = NULL;
5076 } else {
5077 sg_failure_ret(str_to_int(token, &number),
5078 "Savegame corrupt - got tile owner=%s in (%d, %d).",
5079 token, x, y);
5080 map_get_player_tile(ptile, plr)->owner = player_by_number(number);
5081 }
5082
5083 if (loading->version >= 30) {
5084 scanin(&ptr2, ",", token2, sizeof(token2));
5085 sg_failure_ret('\0' != token2[0],
5086 "Savegame corrupt - map size not correct.");
5087 if (strcmp(token2, "-") == 0) {
5088 map_get_player_tile(ptile, plr)->extras_owner = NULL;
5089 } else {
5090 sg_failure_ret(str_to_int(token2, &number),
5091 "Savegame corrupt - got extras owner=%s in (%d, %d).",
5092 token, x, y);
5093 map_get_player_tile(ptile, plr)->extras_owner = player_by_number(number);
5094 }
5095 } else {
5096 map_get_player_tile(ptile, plr)->extras_owner
5097 = map_get_player_tile(ptile, plr)->owner;
5098 }
5099 }
5100 }
5101 }
5102
5103 /* Load player map (update time). */
5104 for (i = 0; i < 4; i++) {
5105 /* put 4-bit segments of 16-bit "updated" field */
5106 if (i == 0) {
5107 LOAD_MAP_CHAR(ch, ptile,
5108 map_get_player_tile(ptile, plr)->last_updated
5109 = ascii_hex2bin(ch, i),
5110 loading->file, "player%d.map_u%02d_%04d", plrno, i);
5111 } else {
5112 LOAD_MAP_CHAR(ch, ptile,
5113 map_get_player_tile(ptile, plr)->last_updated
5114 |= ascii_hex2bin(ch, i),
5115 loading->file, "player%d.map_u%02d_%04d", plrno, i);
5116 }
5117 }
5118
5119 /* Load player map known cities. */
5120 for (i = 0; i < total_ncities; i++) {
5121 struct vision_site *pdcity;
5122 char buf[32];
5123 fc_snprintf(buf, sizeof(buf), "player%d.dc%d", plrno, i);
5124
5125 pdcity = vision_site_new(0, NULL, NULL);
5126 if (sg_load_player_vision_city(loading, plr, pdcity, buf)) {
5127 change_playertile_site(map_get_player_tile(pdcity->location, plr),
5128 pdcity);
5129 identity_number_reserve(pdcity->identity);
5130 } else {
5131 /* Error loading the data. */
5132 log_sg("Skipping seen city %d for player %d.", i, plrno);
5133 if (pdcity != NULL) {
5134 vision_site_destroy(pdcity);
5135 }
5136 }
5137 }
5138
5139 /* Repair inconsistent player maps. */
5140 whole_map_iterate(&(wld.map), ptile) {
5141 if (map_is_known_and_seen(ptile, plr, V_MAIN)) {
5142 struct city *pcity = tile_city(ptile);
5143
5144 update_player_tile_knowledge(plr, ptile);
5145 reality_check_city(plr, ptile);
5146
5147 if (NULL != pcity) {
5148 update_dumb_city(plr, pcity);
5149 }
5150 } else if (!game.server.foggedborders && map_is_known(ptile, plr)) {
5151 /* Non fogged borders aren't loaded. See hrm Bug #879084 */
5152 struct player_tile *plrtile = map_get_player_tile(ptile, plr);
5153
5154 plrtile->owner = tile_owner(ptile);
5155 }
5156 } whole_map_iterate_end;
5157}
5158
5159/************************************************************************/
5162static bool sg_load_player_vision_city(struct loaddata *loading,
5163 struct player *plr,
5164 struct vision_site *pdcity,
5165 const char *citystr)
5166{
5167 const char *str;
5168 int i, id, size;
5169 citizens city_size;
5170 int nat_x, nat_y;
5171 const char *stylename;
5172 const char *vname;
5173
5174 sg_warn_ret_val(secfile_lookup_int(loading->file, &nat_x, "%s.x",
5175 citystr),
5176 FALSE, "%s", secfile_error());
5177 sg_warn_ret_val(secfile_lookup_int(loading->file, &nat_y, "%s.y",
5178 citystr),
5179 FALSE, "%s", secfile_error());
5180 pdcity->location = native_pos_to_tile(&(wld.map), nat_x, nat_y);
5181 sg_warn_ret_val(NULL != pdcity->location, FALSE,
5182 "%s invalid tile (%d,%d)", citystr, nat_x, nat_y);
5183
5184 sg_warn_ret_val(secfile_lookup_int(loading->file, &id, "%s.owner",
5185 citystr),
5186 FALSE, "%s", secfile_error());
5187 pdcity->owner = player_by_number(id);
5188 sg_warn_ret_val(NULL != pdcity->owner, FALSE,
5189 "%s has invalid owner (%d); skipping.", citystr, id);
5190
5191 sg_warn_ret_val(secfile_lookup_int(loading->file, &pdcity->identity,
5192 "%s.id", citystr),
5193 FALSE, "%s", secfile_error());
5194 sg_warn_ret_val(IDENTITY_NUMBER_ZERO < pdcity->identity, FALSE,
5195 "%s has invalid id (%d); skipping.", citystr, id);
5196
5197 sg_warn_ret_val(secfile_lookup_int(loading->file, &size,
5198 "%s.size", citystr),
5199 FALSE, "%s", secfile_error());
5200 city_size = (citizens)size; /* set the correct type */
5201 sg_warn_ret_val(size == (int)city_size, FALSE,
5202 "Invalid city size: %d; set to %d.", size, city_size);
5203 vision_site_size_set(pdcity, city_size);
5204
5205 /* Initialise list of improvements */
5206 BV_CLR_ALL(pdcity->improvements);
5207 str = secfile_lookup_str(loading->file, "%s.improvements", citystr);
5208 sg_warn_ret_val(str != NULL, FALSE, "%s", secfile_error());
5209 sg_warn_ret_val(strlen(str) == loading->improvement.size, FALSE,
5210 "Invalid length of '%s.improvements' ("
5211 SIZE_T_PRINTF " ~= " SIZE_T_PRINTF ").",
5212 citystr, strlen(str), loading->improvement.size);
5213 for (i = 0; i < loading->improvement.size; i++) {
5214 sg_warn_ret_val(str[i] == '1' || str[i] == '0', FALSE,
5215 "Undefined value '%c' within '%s.improvements'.",
5216 str[i], citystr)
5217
5218 if (str[i] == '1') {
5219 struct impr_type *pimprove =
5220 improvement_by_rule_name(loading->improvement.order[i]);
5221
5222 if (pimprove) {
5223 BV_SET(pdcity->improvements, improvement_index(pimprove));
5224 }
5225 }
5226 }
5227
5228 vname = secfile_lookup_str_default(loading->file, NULL,
5229 "%s.name", citystr);
5230
5231 if (vname != NULL) {
5232 pdcity->name = fc_strdup(vname);
5233 }
5234
5235 pdcity->occupied = secfile_lookup_bool_default(loading->file, FALSE,
5236 "%s.occupied", citystr);
5237 pdcity->walls = secfile_lookup_bool_default(loading->file, FALSE,
5238 "%s.walls", citystr);
5239 pdcity->happy = secfile_lookup_bool_default(loading->file, FALSE,
5240 "%s.happy", citystr);
5241 pdcity->unhappy = secfile_lookup_bool_default(loading->file, FALSE,
5242 "%s.unhappy", citystr);
5243 stylename = secfile_lookup_str_default(loading->file, NULL,
5244 "%s.style", citystr);
5245 if (stylename != NULL) {
5246 pdcity->style = city_style_by_rule_name(stylename);
5247 } else {
5248 pdcity->style = 0;
5249 }
5250 if (pdcity->style < 0) {
5251 pdcity->style = 0;
5252 }
5253
5254 pdcity->city_image = secfile_lookup_int_default(loading->file, -100,
5255 "%s.city_image", citystr);
5256
5257 pdcity->capital = CAPITAL_NOT;
5258
5259 return TRUE;
5260}
5261
5262/* =======================================================================
5263 * Load the researches.
5264 * ======================================================================= */
5265
5266/************************************************************************/
5269static void sg_load_researches(struct loaddata *loading)
5270{
5271 struct research *presearch;
5272 int count;
5273 int number;
5274 const char *str;
5275 int i, j;
5276 bool got_tech;
5277
5278 /* Check status and return if not OK (sg_success FALSE). */
5279 sg_check_ret();
5280
5281 /* Initialize all researches. */
5282 researches_iterate(pinitres) {
5283 init_tech(pinitres, FALSE);
5284 } researches_iterate_end;
5285
5286 /* May be unsaved (e.g. scenario case). */
5287 count = secfile_lookup_int_default(loading->file, 0, "research.count");
5288 for (i = 0; i < count; i++) {
5289 sg_failure_ret(secfile_lookup_int(loading->file, &number,
5290 "research.r%d.number", i),
5291 "%s", secfile_error());
5292 presearch = research_by_number(number);
5293 sg_failure_ret(presearch != NULL,
5294 "Invalid research number %d in 'research.r%d.number'",
5295 number, i);
5296
5297 presearch->tech_goal = technology_load(loading->file,
5298 "research.r%d.goal", i);
5299 sg_failure_ret(secfile_lookup_int(loading->file,
5300 &presearch->techs_researched,
5301 "research.r%d.techs", i),
5302 "%s", secfile_error());
5303 sg_failure_ret(secfile_lookup_int(loading->file,
5304 &presearch->future_tech,
5305 "research.r%d.futuretech", i),
5306 "%s", secfile_error());
5307 sg_failure_ret(secfile_lookup_int(loading->file,
5308 &presearch->bulbs_researched,
5309 "research.r%d.bulbs", i),
5310 "%s", secfile_error());
5311 sg_failure_ret(secfile_lookup_int(loading->file,
5312 &presearch->bulbs_researching_saved,
5313 "research.r%d.bulbs_before", i),
5314 "%s", secfile_error());
5315 presearch->researching_saved = technology_load(loading->file,
5316 "research.r%d.saved", i);
5317 presearch->researching = technology_load(loading->file,
5318 "research.r%d.now", i);
5319 sg_failure_ret(secfile_lookup_bool(loading->file,
5320 &got_tech,
5321 "research.r%d.got_tech", i),
5322 "%s", secfile_error());
5323 if (got_tech) {
5324 presearch->free_bulbs = presearch->bulbs_researched;
5325 }
5326
5327 str = secfile_lookup_str(loading->file, "research.r%d.done", i);
5328 sg_failure_ret(str != NULL, "%s", secfile_error());
5329 sg_failure_ret(strlen(str) == loading->technology.size,
5330 "Invalid length of 'research.r%d.done' ("
5331 SIZE_T_PRINTF " ~= " SIZE_T_PRINTF ").",
5332 i, strlen(str), loading->technology.size);
5333 for (j = 0; j < loading->technology.size; j++) {
5334 sg_failure_ret(str[j] == '1' || str[j] == '0',
5335 "Undefined value '%c' within 'research.r%d.done'.",
5336 str[j], i);
5337
5338 if (str[j] == '1') {
5339 struct advance *padvance =
5340 advance_by_rule_name(loading->technology.order[j]);
5341
5342 if (padvance) {
5343 research_invention_set(presearch, advance_number(padvance),
5344 TECH_KNOWN);
5345 }
5346 }
5347 }
5348 }
5349
5350 /* In case of tech_leakage, we can update research only after all the
5351 * researches have been loaded */
5352 researches_iterate(pupres) {
5353 research_update(pupres);
5354 } researches_iterate_end;
5355}
5356
5357/* =======================================================================
5358 * Load the event cache. Should be the last thing to do.
5359 * ======================================================================= */
5360
5361/************************************************************************/
5364static void sg_load_event_cache(struct loaddata *loading)
5365{
5366 /* Check status and return if not OK (sg_success FALSE). */
5367 sg_check_ret();
5368
5369 event_cache_load(loading->file, "event_cache");
5370}
5371
5372/* =======================================================================
5373 * Load the open treaties
5374 * ======================================================================= */
5375
5376/************************************************************************/
5379static void sg_load_treaties(struct loaddata *loading)
5380{
5381 int tidx;
5382 const char *plr0;
5383
5384 /* Check status and return if not OK (sg_success FALSE). */
5385 sg_check_ret();
5386
5387 for (tidx = 0; (plr0 = secfile_lookup_str_default(loading->file, NULL,
5388 "treaty%d.plr0", tidx)) != NULL ;
5389 tidx++) {
5390 const char *plr1;
5391 const char *ct;
5392 int cidx;
5393 struct player *p0, *p1;
5394
5395 plr1 = secfile_lookup_str(loading->file, "treaty%d.plr1", tidx);
5396
5397 p0 = player_by_name(plr0);
5398 p1 = player_by_name(plr1);
5399
5400 if (p0 == NULL || p1 == NULL) {
5401 log_error("Treaty between unknown players %s and %s", plr0, plr1);
5402 } else {
5403 struct Treaty *ptreaty = fc_malloc(sizeof(*ptreaty));
5404
5405 init_treaty(ptreaty, p0, p1);
5406 treaty_add(ptreaty);
5407
5408 for (cidx = 0; (ct = secfile_lookup_str_default(loading->file, NULL,
5409 "treaty%d.clause%d.type",
5410 tidx, cidx)) != NULL ;
5411 cidx++ ) {
5412 enum clause_type type = clause_type_by_name(ct, fc_strcasecmp);
5413 const char *plrx;
5414
5415 if (!clause_type_is_valid(type)) {
5416 log_error("Invalid clause type \"%s\"", ct);
5417 } else {
5418 struct player *pgiver = NULL;
5419
5420 plrx = secfile_lookup_str(loading->file, "treaty%d.clause%d.from",
5421 tidx, cidx);
5422
5423 if (!fc_strcasecmp(plrx, plr0)) {
5424 pgiver = p0;
5425 } else if (!fc_strcasecmp(plrx, plr1)) {
5426 pgiver = p1;
5427 } else {
5428 log_error("Clause giver %s is not participant of the treaty"
5429 "between %s and %s", plrx, plr0, plr1);
5430 }
5431
5432 if (pgiver != NULL) {
5433 int value;
5434
5435 value = secfile_lookup_int_default(loading->file, 0,
5436 "treaty%d.clause%d.value",
5437 tidx, cidx);
5438
5439 add_clause(ptreaty, pgiver, type, value, NULL);
5440 }
5441 }
5442 }
5443
5444 /* These must be after clauses have been added so that acceptance
5445 * does not get cleared by what seems like changes to the treaty. */
5446 ptreaty->accept0 = secfile_lookup_bool_default(loading->file, FALSE,
5447 "treaty%d.accept0", tidx);
5448 ptreaty->accept1 = secfile_lookup_bool_default(loading->file, FALSE,
5449 "treaty%d.accept1", tidx);
5450 }
5451 }
5452}
5453
5454/* =======================================================================
5455 * Load the history report
5456 * ======================================================================= */
5457
5458/************************************************************************/
5461static void sg_load_history(struct loaddata *loading)
5462{
5463 struct history_report *hist = history_report_get();
5464 int turn;
5465
5466 /* Check status and return if not OK (sg_success FALSE). */
5467 sg_check_ret();
5468
5469 turn = secfile_lookup_int_default(loading->file, -2, "history.turn");
5470
5471 if (turn != -2) {
5472 hist->turn = turn;
5473 }
5474
5475 if (turn + 1 >= game.info.turn) {
5476 const char *str;
5477
5478 str = secfile_lookup_str(loading->file, "history.title");
5479 sg_failure_ret(str != NULL, "%s", secfile_error());
5480 sz_strlcpy(hist->title, str);
5481 str = secfile_lookup_str(loading->file, "history.body");
5482 sg_failure_ret(str != NULL, "%s", secfile_error());
5483 sz_strlcpy(hist->body, str);
5484 }
5485}
5486
5487/* =======================================================================
5488 * Load the mapimg definitions.
5489 * ======================================================================= */
5490
5491/************************************************************************/
5494static void sg_load_mapimg(struct loaddata *loading)
5495{
5496 int mapdef_count, i;
5497
5498 /* Check status and return if not OK (sg_success FALSE). */
5499 sg_check_ret();
5500
5501 /* Clear all defined map images. */
5502 while (mapimg_count() > 0) {
5503 mapimg_delete(0);
5504 }
5505
5506 mapdef_count = secfile_lookup_int_default(loading->file, 0,
5507 "mapimg.count");
5508 log_verbose("Saved map image definitions: %d.", mapdef_count);
5509
5510 if (0 >= mapdef_count) {
5511 return;
5512 }
5513
5514 for (i = 0; i < mapdef_count; i++) {
5515 const char *p;
5516
5517 p = secfile_lookup_str(loading->file, "mapimg.mapdef%d", i);
5518 if (NULL == p) {
5519 log_verbose("[Mapimg %4d] Missing definition.", i);
5520 continue;
5521 }
5522
5523 if (!mapimg_define(p, FALSE)) {
5524 log_error("Invalid map image definition %4d: %s.", i, p);
5525 }
5526
5527 log_verbose("Mapimg %4d loaded.", i);
5528 }
5529}
5530
5531/* =======================================================================
5532 * Sanity checks for loading a game.
5533 * ======================================================================= */
5534
5535/************************************************************************/
5538static void sg_load_sanitycheck(struct loaddata *loading)
5539{
5540 int players;
5541
5542 /* Check status and return if not OK (sg_success FALSE). */
5543 sg_check_ret();
5544
5545 if (game.info.is_new_game) {
5546 /* Nothing to do for new games (or not started scenarios). */
5547 return;
5548 }
5549
5550 /* Old savegames may have maxplayers lower than current player count,
5551 * fix. */
5552 players = normal_player_count();
5553 if (game.server.max_players < players) {
5554 log_verbose("Max players lower than current players, fixing");
5555 game.server.max_players = players;
5556 }
5557
5558 /* Fix ferrying sanity */
5559 players_iterate(pplayer) {
5560 unit_list_iterate_safe(pplayer->units, punit) {
5561 if (!unit_transport_get(punit)
5562 && !can_unit_exist_at_tile(&(wld.map), punit, unit_tile(punit))) {
5563 log_sg("Removing %s unferried %s in %s at (%d, %d)",
5564 nation_rule_name(nation_of_player(pplayer)),
5565 unit_rule_name(punit),
5566 terrain_rule_name(unit_tile(punit)->terrain),
5567 TILE_XY(unit_tile(punit)));
5568 bounce_unit(punit, TRUE);
5569 }
5570 } unit_list_iterate_safe_end;
5571 } players_iterate_end;
5572
5573 /* Fix stacking issues. We don't rely on the savegame preserving
5574 * alliance invariants (old savegames often did not) so if there are any
5575 * unallied units on the same tile we just bounce them. */
5576 players_iterate(pplayer) {
5577 players_iterate(aplayer) {
5578 resolve_unit_stacks(pplayer, aplayer, TRUE);
5579 } players_iterate_end;
5580 } players_iterate_end;
5581
5582 /* Recalculate the potential buildings for each city. Has caused some
5583 * problems with game random state.
5584 * This also changes the game state if you save the game directly after
5585 * loading it and compare the results. */
5586 players_iterate(pplayer) {
5587 /* Building advisor needs data phase open in order to work */
5588 adv_data_phase_init(pplayer, FALSE);
5589 building_advisor(pplayer);
5590 /* Close data phase again so it can be opened again when game starts. */
5591 adv_data_phase_done(pplayer);
5592 } players_iterate_end;
5593
5594 /* Prevent a buggy or intentionally crafted save game from crashing
5595 * Freeciv. See hrm Bug #887748 */
5596 players_iterate(pplayer) {
5597 city_list_iterate(pplayer->cities, pcity) {
5598 worker_task_list_iterate(pcity->task_reqs, ptask) {
5599 if (!worker_task_is_sane(ptask)) {
5600 log_error("[city id: %d] Bad worker task %d.",
5601 pcity->id, ptask->act);
5602 worker_task_list_remove(pcity->task_reqs, ptask);
5603 free(ptask);
5604 ptask = NULL;
5605 }
5606 } worker_task_list_iterate_end;
5607 } city_list_iterate_end;
5608 } players_iterate_end;
5609
5610 /* Check worked tiles map */
5611#ifdef FREECIV_DEBUG
5612 if (loading->worked_tiles != NULL) {
5613 /* check the entire map for unused worked tiles */
5614 whole_map_iterate(&(wld.map), ptile) {
5615 if (loading->worked_tiles[ptile->index] != -1) {
5616 log_error("[city id: %d] Unused worked tile at (%d, %d).",
5617 loading->worked_tiles[ptile->index], TILE_XY(ptile));
5618 }
5619 } whole_map_iterate_end;
5620 }
5621#endif /* FREECIV_DEBUG */
5622
5623 /* Check researching technologies and goals. */
5624 researches_iterate(presearch) {
5625 int techs;
5626
5627 if (presearch->researching != A_UNSET
5628 && !is_future_tech(presearch->researching)
5629 && (valid_advance_by_number(presearch->researching) == NULL
5630 || (research_invention_state(presearch, presearch->researching)
5631 != TECH_PREREQS_KNOWN))) {
5632 log_sg(_("%s had invalid researching technology."),
5633 research_name_translation(presearch));
5634 presearch->researching = A_UNSET;
5635 }
5636 if (presearch->tech_goal != A_UNSET
5637 && !is_future_tech(presearch->tech_goal)
5638 && (valid_advance_by_number(presearch->tech_goal) == NULL
5639 || !research_invention_reachable(presearch, presearch->tech_goal)
5640 || (research_invention_state(presearch, presearch->tech_goal)
5641 == TECH_KNOWN))) {
5642 log_sg(_("%s had invalid technology goal."),
5643 research_name_translation(presearch));
5644 presearch->tech_goal = A_UNSET;
5645 }
5646
5647 techs = recalculate_techs_researched(presearch);
5648
5649 if (presearch->techs_researched != techs) {
5650 sg_regr(3000300,
5651 _("%s had finished researches count wrong."),
5652 research_name_translation(presearch));
5653 presearch->techs_researched = techs;
5654 }
5655 } researches_iterate_end;
5656
5657 players_iterate(pplayer) {
5658 unit_list_iterate_safe(pplayer->units, punit) {
5659 if (punit->has_orders
5660 && !unit_order_list_is_sane(&(wld.map), punit->orders.length,
5661 punit->orders.list)) {
5662 log_sg("Invalid unit orders for unit %d.", punit->id);
5663 free_unit_orders(punit);
5664 }
5665 } unit_list_iterate_safe_end;
5666 } players_iterate_end;
5667
5668 /* Check max rates (rules may have changed since saving) */
5669 players_iterate(pplayer) {
5670 player_limit_to_max_rates(pplayer);
5671 } players_iterate_end;
5672
5673 if (0 == strlen(server.game_identifier)
5674 || !is_base64url(server.game_identifier)) {
5675 /* This uses fc_rand(), so random state has to be initialized before. */
5676 randomize_base64url_string(server.game_identifier,
5677 sizeof(server.game_identifier));
5678 }
5679
5680 /* Check if some player has more than one of some UTYF_UNIQUE unit type */
5681 players_iterate(pplayer) {
5682 int unique_count[U_LAST];
5683
5684 memset(unique_count, 0, sizeof(unique_count));
5685
5686 unit_list_iterate(pplayer->units, punit) {
5687 unique_count[utype_index(unit_type_get(punit))]++;
5688 } unit_list_iterate_end;
5689
5690 unit_type_iterate(ut) {
5691 if (unique_count[utype_index(ut)] > 1 && utype_has_flag(ut, UTYF_UNIQUE)) {
5692 log_sg(_("%s has multiple units of type %s though it should be possible "
5693 "to have only one."),
5694 player_name(pplayer), utype_name_translation(ut));
5695 }
5696 } unit_type_iterate_end;
5697 } players_iterate_end;
5698
5699 /* Restore game random state, just in case various initialization code
5700 * inexplicably altered the previously existing state. */
5701 if (!game.info.is_new_game) {
5702 fc_rand_set_state(loading->rstate);
5703
5704 if (loading->version < 30) {
5705 /* For older savegames we have to recalculate the score with current data,
5706 * instead of using beginning-of-turn saved scores. */
5707 players_iterate(pplayer) {
5708 calc_civ_score(pplayer);
5709 } players_iterate_end;
5710 }
5711 }
5712
5713 /* At the end do the default sanity checks. */
5714 sanity_check();
5715}
achievement_by_rule_name
struct achievement * achievement_by_rule_name(const char *name)
Definition achievements.c:123
ACTION_NONE
#define ACTION_NONE
Definition actions.h:311
building_advisor
void building_advisor(struct player *pplayer)
Definition advbuilding.c:175
adv_data_phase_init
bool adv_data_phase_init(struct player *pplayer, bool is_new_phase)
Definition advdata.c:263
adv_data_phase_done
void adv_data_phase_done(struct player *pplayer)
Definition advdata.c:565
ai_name
const char * ai_name(const struct ai_type *ai)
Definition ai.c:335
CALL_FUNC_EACH_AI
#define CALL_FUNC_EACH_AI(_func,...)
Definition ai.h:387
CALL_PLR_AI_FUNC
#define CALL_PLR_AI_FUNC(_func, _player,...)
Definition ai.h:377
ai_traits_init
void ai_traits_init(struct player *pplayer)
Definition aitraits.c:33
str
#define str
Definition astring.c:76
base_number
Base_type_id base_number(const struct base_type *pbase)
Definition base.c:92
base_extra_get
struct extra_type * base_extra_get(const struct base_type *pbase)
Definition base.c:101
get_base_by_gui_type
struct base_type * get_base_by_gui_type(enum base_gui_type type, const struct unit *punit, const struct tile *ptile)
Definition base.c:139
base_by_number
struct base_type * base_by_number(const Base_type_id id)
Definition base.c:76
dbv_set
void dbv_set(struct dbv *pdbv, int bit)
Definition bitvector.c:144
dbv_clr_all
void dbv_clr_all(struct dbv *pdbv)
Definition bitvector.c:179
dbv_to_bv
void dbv_to_bv(unsigned char *dest, const struct dbv *src)
Definition bitvector.c:235
BV_CLR_ALL
#define BV_CLR_ALL(bv)
Definition bitvector.h:95
BV_SET
#define BV_SET(bv, bit)
Definition bitvector.h:81
BV_CLR
#define BV_CLR(bv, bit)
Definition bitvector.h:86
has_capability
bool has_capability(const char *cap, const char *capstr)
Definition capability.c:77
citizens_nation_set
void citizens_nation_set(struct city *pcity, const struct player_slot *pslot, citizens count)
Definition citizens.c:145
citizens_count
citizens citizens_count(const struct city *pcity)
Definition citizens.c:162
citizens_init
void citizens_init(struct city *pcity)
Definition citizens.c:32
citizens_update
void citizens_update(struct city *pcity, struct player *plr)
Definition citizenshand.c:202
city_map_radius_sq_set
void city_map_radius_sq_set(struct city *pcity, int radius_sq)
Definition city.c:148
city_name_set
void city_name_set(struct city *pcity, const char *new_name)
Definition city.c:1145
city_name_get
const char * city_name_get(const struct city *pcity)
Definition city.c:1137
create_city_virtual
struct city * create_city_virtual(struct player *pplayer, struct tile *ptile, const char *name)
Definition city.c:3430
city_illness_calc
int city_illness_calc(const struct city *pcity, int *ill_base, int *ill_size, int *ill_trade, int *ill_pollution)
Definition city.c:2870
city_size_set
void city_size_set(struct city *pcity, citizens size)
Definition city.c:1180
city_add_improvement
void city_add_improvement(struct city *pcity, const struct impr_type *pimprove)
Definition city.c:3357
destroy_city_virtual
void destroy_city_virtual(struct city *pcity)
Definition city.c:3516
city_style_by_rule_name
int city_style_by_rule_name(const char *s)
Definition city.c:1738
cities_iterate_end
#define cities_iterate_end
Definition city.h:517
city_list_iterate
#define city_list_iterate(citylist, pcity)
Definition city.h:508
city_tile
#define city_tile(_pcity_)
Definition city.h:564
cities_iterate
#define cities_iterate(pcity)
Definition city.h:512
CITY_MAP_MAX_RADIUS_SQ
#define CITY_MAP_MAX_RADIUS_SQ
Definition city.h:86
city_size_get
static citizens city_size_get(const struct city *pcity)
Definition city.h:569
output_type_iterate
#define output_type_iterate(output)
Definition city.h:845
city_owner
#define city_owner(_pcity_)
Definition city.h:563
FREE_WORKED_TILES
#define FREE_WORKED_TILES
Definition city.h:882
MAX_CITY_SIZE
#define MAX_CITY_SIZE
Definition city.h:106
city_list_iterate_end
#define city_list_iterate_end
Definition city.h:510
I_NEVER
#define I_NEVER
Definition city.h:247
city_tile_iterate
#define city_tile_iterate(_nmap, _radius_sq, _city_tile, _tile)
Definition city.h:230
city_tile_iterate_end
#define city_tile_iterate_end
Definition city.h:238
output_type_iterate_end
#define output_type_iterate_end
Definition city.h:851
update_dumb_city
bool update_dumb_city(struct player *pplayer, struct city *pcity)
Definition citytools.c:2769
send_city_suppression
bool send_city_suppression(bool now)
Definition citytools.c:2166
city_freeze_workers
static void void city_freeze_workers(struct city *pcity)
Definition citytools.c:137
city_thaw_workers
void city_thaw_workers(struct city *pcity)
Definition citytools.c:147
reality_check_city
void reality_check_city(struct player *pplayer, struct tile *ptile)
Definition citytools.c:2840
city_refresh_vision
void city_refresh_vision(struct city *pcity)
Definition citytools.c:3442
auto_arrange_workers
void auto_arrange_workers(struct city *pcity)
Definition cityturn.c:367
city_repair_size
void city_repair_size(struct city *pcity, int change)
Definition cityturn.c:852
city_refresh
bool city_refresh(struct city *pcity)
Definition cityturn.c:159
techs
char * techs
Definition comments.c:31
incite_cost
char * incite_cost
Definition comments.c:75
road
static void road(QVariant data1, QVariant data2)
Definition dialogs.cpp:2919
base
static void base(QVariant data1, QVariant data2)
Definition dialogs.cpp:2940
punit
struct unit struct city struct unit struct tile struct extra_type const struct act_prob *act_probs int actor_unit_id struct unit struct unit * punit
Definition dialogs_g.h:74
set_ai_level_directer
void set_ai_level_directer(struct player *pplayer, enum ai_level level)
Definition difficulty.c:39
valid_dst_closest
enum diplstate_type valid_dst_closest(struct player_diplstate *dst)
Definition diplhand.c:111
ptreaty
struct Treaty * ptreaty
Definition diplodlg_g.h:28
init_treaty
void init_treaty(struct Treaty *ptreaty, struct player *plr0, struct player *plr1)
Definition diptreaty.c:99
add_clause
bool add_clause(struct Treaty *ptreaty, struct player *pfrom, enum clause_type type, int val, struct player *client_player)
Definition diptreaty.c:145
treaty_add
void treaty_add(struct Treaty *ptreaty)
Definition diptreaty.c:361
id
int int id
Definition editgui_g.h:28
next_extra_for_tile
struct extra_type * next_extra_for_tile(const struct tile *ptile, enum extra_cause cause, const struct player *pplayer, const struct unit *punit)
Definition extras.c:765
extra_type_by_rule_name
struct extra_type * extra_type_by_rule_name(const char *name)
Definition extras.c:212
extra_owner
struct player * extra_owner(const struct tile *ptile)
Definition extras.c:1114
extra_number
int extra_number(const struct extra_type *pextra)
Definition extras.c:161
prev_extra_in_tile
struct extra_type * prev_extra_in_tile(const struct tile *ptile, enum extra_rmcause rmcause, const struct player *pplayer, const struct unit *punit)
Definition extras.c:790
extras
static struct extra_type extras[MAX_EXTRA_TYPES]
Definition extras.c:31
extra_rule_name
const char * extra_rule_name(const struct extra_type *pextra)
Definition extras.c:203
is_extra_caused_by
#define is_extra_caused_by(e, c)
Definition extras.h:203
extra_index
#define extra_index(_e_)
Definition extras.h:183
EXTRA_NONE
#define EXTRA_NONE
Definition extras.h:85
extra_base_get
#define extra_base_get(_e_)
Definition extras.h:190
extra_road_get
#define extra_road_get(_e_)
Definition extras.h:191
extra_type_by_cause_iterate_end
#define extra_type_by_cause_iterate_end
Definition extras.h:339
extra_type_by_cause_iterate
#define extra_type_by_cause_iterate(_cause, _extra)
Definition extras.h:333
ruleset
static char * ruleset
Definition fc_manual.c:163
NO_TARGET
#define NO_TARGET
Definition fc_types.h:354
Road_type_id
int Road_type_id
Definition fc_types.h:384
ROCO_RAILROAD
@ ROCO_RAILROAD
Definition fc_types.h:1253
ROCO_RIVER
@ ROCO_RIVER
Definition fc_types.h:1253
ROCO_ROAD
@ ROCO_ROAD
Definition fc_types.h:1253
Tech_type_id
int Tech_type_id
Definition fc_types.h:377
citizens
unsigned char citizens
Definition fc_types.h:388
RPT_POSSIBLE
@ RPT_POSSIBLE
Definition fc_types.h:700
Base_type_id
int Base_type_id
Definition fc_types.h:383
Multiplier_type_id
int Multiplier_type_id
Definition fc_types.h:386
IDENTITY_NUMBER_ZERO
#define IDENTITY_NUMBER_ZERO
Definition fc_types.h:92
_
#define _(String)
Definition fcintl.h:67
game
struct civ_game game
Definition game.c:62
wld
struct world wld
Definition game.c:63
game_unit_by_number
struct unit * game_unit_by_number(int id)
Definition game.c:116
initialize_globals
void initialize_globals(void)
Definition game.c:683
game_city_by_number
struct city * game_city_by_number(int id)
Definition game.c:107
GAME_DEFAULT_TIMEOUTINTINC
#define GAME_DEFAULT_TIMEOUTINTINC
Definition game.h:598
GAME_DEFAULT_SCORETURN
#define GAME_DEFAULT_SCORETURN
Definition game.h:582
GAME_DEFAULT_TIMEOUTINT
#define GAME_DEFAULT_TIMEOUTINT
Definition game.h:597
GAME_DEFAULT_TIMEOUTINCMULT
#define GAME_DEFAULT_TIMEOUTINCMULT
Definition game.h:600
GAME_DEFAULT_TIMEOUTINC
#define GAME_DEFAULT_TIMEOUTINC
Definition game.h:599
GAME_DEFAULT_RULESETDIR
#define GAME_DEFAULT_RULESETDIR
Definition game.h:676
GAME_DEFAULT_TIMEOUTCOUNTER
#define GAME_DEFAULT_TIMEOUTCOUNTER
Definition game.h:602
GAME_DEFAULT_PHASE_MODE
#define GAME_DEFAULT_PHASE_MODE
Definition game.h:617
government_by_rule_name
struct government * government_by_rule_name(const char *name)
Definition government.c:55
owner
struct city * owner
Definition citydlg.c:226
type
GType type
Definition repodlgs.c:1313
idex_register_unit
void idex_register_unit(struct world *iworld, struct unit *punit)
Definition idex.c:82
idex_register_city
void idex_register_city(struct world *iworld, struct city *pcity)
Definition idex.c:67
improvement_index
Impr_type_id improvement_index(const struct impr_type *pimprove)
Definition improvement.c:175
improvement_by_rule_name
struct impr_type * improvement_by_rule_name(const char *name)
Definition improvement.c:367
WONDER_DESTROYED
#define WONDER_DESTROYED
Definition improvement.h:139
WONDER_LOST
#define WONDER_LOST
Definition improvement.h:144
adv_city_free
void adv_city_free(struct city *pcity)
Definition infracache.c:501
adv_city_alloc
void adv_city_alloc(struct city *pcity)
Definition infracache.c:488
name
const char * name
Definition inputfile.c:127
fc_assert_msg
#define fc_assert_msg(condition, message,...)
Definition log.h:181
log_verbose
#define log_verbose(message,...)
Definition log.h:109
fc_assert
#define fc_assert(condition)
Definition log.h:176
log_fatal
#define log_fatal(message,...)
Definition log.h:100
fc_assert_action
#define fc_assert_action(condition, action)
Definition log.h:187
log_debug
#define log_debug(message,...)
Definition log.h:115
log_normal
#define log_normal(message,...)
Definition log.h:107
log_error
#define log_error(message,...)
Definition log.h:103
startpos_disallow
bool startpos_disallow(struct startpos *psp, struct nation_type *pnation)
Definition map.c:1660
nat_x
#define nat_x
nat_y
#define nat_y
sq_map_distance
int sq_map_distance(const struct tile *tile0, const struct tile *tile1)
Definition map.c:641
map_startpos_new
struct startpos * map_startpos_new(struct tile *ptile)
Definition map.c:1866
map_init_topology
void map_init_topology(struct civ_map *nmap)
Definition map.c:303
main_map_allocate
void main_map_allocate(void)
Definition map.c:519
index_to_tile
struct tile * index_to_tile(const struct civ_map *imap, int mindex)
Definition map.c:456
map_startpos_count
int map_startpos_count(void)
Definition map.c:1853
native_pos_to_tile
struct tile * native_pos_to_tile(const struct civ_map *nmap, int nat_x, int nat_y)
Definition map.c:443
startpos_allow
bool startpos_allow(struct startpos *psp, struct nation_type *pnation)
Definition map.c:1643
MAP_INDEX_SIZE
#define MAP_INDEX_SIZE
Definition map.h:137
whole_map_iterate
#define whole_map_iterate(_map, _tile)
Definition map.h:545
index_to_native_pos
#define index_to_native_pos(pnat_x, pnat_y, mindex)
Definition map.h:157
whole_map_iterate_end
#define whole_map_iterate_end
Definition map.h:554
MAPGEN_SCENARIO
@ MAPGEN_SCENARIO
Definition map_types.h:47
assign_continent_numbers
void assign_continent_numbers(void)
Definition mapgen_utils.c:452
mapgen_utils.h
player_map_init
void player_map_init(struct player *pplayer)
Definition maphand.c:1221
update_player_tile_last_seen
void update_player_tile_last_seen(struct player *pplayer, struct tile *ptile)
Definition maphand.c:1467
map_claim_ownership
void map_claim_ownership(struct tile *ptile, struct player *powner, struct tile *psource, bool claim_bases)
Definition maphand.c:2207
map_is_known
bool map_is_known(const struct tile *ptile, const struct player *pplayer)
Definition maphand.c:894
send_tile_suppression
bool send_tile_suppression(bool now)
Definition maphand.c:475
really_gives_vision
bool really_gives_vision(struct player *me, struct player *them)
Definition maphand.c:345
map_know_and_see_all
void map_know_and_see_all(struct player *pplayer)
Definition maphand.c:1196
update_player_tile_knowledge
bool update_player_tile_knowledge(struct player *pplayer, struct tile *ptile)
Definition maphand.c:1398
tile_claim_bases
void tile_claim_bases(struct tile *ptile, struct player *powner)
Definition maphand.c:2220
map_set_known
void map_set_known(struct tile *ptile, struct player *pplayer)
Definition maphand.c:1178
map_is_known_and_seen
bool map_is_known_and_seen(const struct tile *ptile, const struct player *pplayer, enum vision_layer vlayer)
Definition maphand.c:920
change_playertile_site
void change_playertile_site(struct player_tile *ptile, struct vision_site *new_site)
Definition maphand.c:1159
map_calculate_borders
void map_calculate_borders(void)
Definition maphand.c:2373
give_shared_vision
void give_shared_vision(struct player *pfrom, struct player *pto)
Definition maphand.c:1632
map_get_player_tile
struct player_tile * map_get_player_tile(const struct tile *ptile, const struct player *pplayer)
Definition maphand.c:1382
mapimg_define
bool mapimg_define(const char *maparg, bool check)
Definition mapimg.c:769
mapimg_delete
bool mapimg_delete(int id)
Definition mapimg.c:1204
mapimg_count
int mapimg_count(void)
Definition mapimg.c:573
fc_calloc
#define fc_calloc(n, esz)
Definition mem.h:38
FC_FREE
#define FC_FREE(ptr)
Definition mem.h:41
fc_strdup
#define fc_strdup(str)
Definition mem.h:43
fc_malloc
#define fc_malloc(sz)
Definition mem.h:34
set_meta_patches_string
void set_meta_patches_string(const char *string)
Definition meta.c:172
default_meta_patches_string
const char * default_meta_patches_string(void)
Definition meta.c:83
DEFAULT_META_SERVER_ADDR
#define DEFAULT_META_SERVER_ADDR
Definition meta.h:21
can_unit_exist_at_tile
bool can_unit_exist_at_tile(const struct civ_map *nmap, const struct unit *punit, const struct tile *ptile)
Definition movement.c:351
multiplier_rule_name
const char * multiplier_rule_name(const struct multiplier *pmul)
Definition multipliers.c:106
multiplier_by_rule_name
struct multiplier * multiplier_by_rule_name(const char *name)
Definition multipliers.c:115
multiplier_index
Multiplier_type_id multiplier_index(const struct multiplier *pmul)
Definition multipliers.c:80
multipliers_iterate
#define multipliers_iterate(_mul_)
Definition multipliers.h:61
multipliers_iterate_end
#define multipliers_iterate_end
Definition multipliers.h:67
nation_rule_name
const char * nation_rule_name(const struct nation_type *pnation)
Definition nation.c:138
nation_of_player
struct nation_type * nation_of_player(const struct player *pplayer)
Definition nation.c:444
nation_by_rule_name
struct nation_type * nation_by_rule_name(const char *name)
Definition nation.c:121
nation_plural_for_player
const char * nation_plural_for_player(const struct player *pplayer)
Definition nation.c:178
NO_NATION_SELECTED
#define NO_NATION_SELECTED
Definition nation.h:30
event_cache_load
void event_cache_load(struct section_file *file, const char *section)
Definition notify.c:783
parts
int parts
Definition packhand.c:132
lines
char * lines
Definition packhand.c:131
len
int len
Definition packhand.c:127
player_slot_is_used
bool player_slot_is_used(const struct player_slot *pslot)
Definition player.c:448
player_unit_by_number
struct unit * player_unit_by_number(const struct player *pplayer, int unit_id)
Definition player.c:1229
player_by_number
struct player * player_by_number(const int player_id)
Definition player.c:849
players_on_same_team
bool players_on_same_team(const struct player *pplayer1, const struct player *pplayer2)
Definition player.c:1476
player_count
int player_count(void)
Definition player.c:817
player_slot_count
int player_slot_count(void)
Definition player.c:418
player_slot_by_number
struct player_slot * player_slot_by_number(int player_id)
Definition player.c:463
player_number
int player_number(const struct player *pplayer)
Definition player.c:837
pplayer_can_make_treaty
enum dipl_reason pplayer_can_make_treaty(const struct player *p1, const struct player *p2, enum diplstate_type treaty)
Definition player.c:159
player_name
const char * player_name(const struct player *pplayer)
Definition player.c:895
player_slot_max_used_number
int player_slot_max_used_number(void)
Definition player.c:476
pplayers_at_war
bool pplayers_at_war(const struct player *pplayer, const struct player *pplayer2)
Definition player.c:1388
player_slot_index
int player_slot_index(const struct player_slot *pslot)
Definition player.c:426
player_by_name
struct player * player_by_name(const char *name)
Definition player.c:881
player_has_flag
bool player_has_flag(const struct player *pplayer, enum plr_flag_id flag)
Definition player.c:1990
player_city_by_number
struct city * player_city_by_number(const struct player *pplayer, int city_id)
Definition player.c:1203
player_index
int player_index(const struct player *pplayer)
Definition player.c:829
player_set_nation
bool player_set_nation(struct player *pplayer, struct nation_type *pnation)
Definition player.c:861
player_diplstate_get
struct player_diplstate * player_diplstate_get(const struct player *plr1, const struct player *plr2)
Definition player.c:324
pplayers_allied
bool pplayers_allied(const struct player *pplayer, const struct player *pplayer2)
Definition player.c:1405
slots
struct player_slot * slots
Definition player.c:51
players_iterate_end
#define players_iterate_end
Definition player.h:537
dipl_reason
dipl_reason
Definition player.h:190
DIPL_ALLIANCE_PROBLEM_THEM
@ DIPL_ALLIANCE_PROBLEM_THEM
Definition player.h:192
DIPL_ALLIANCE_PROBLEM_US
@ DIPL_ALLIANCE_PROBLEM_US
Definition player.h:192
players_iterate
#define players_iterate(_pplayer)
Definition player.h:532
MAX_ATTRIBUTE_BLOCK
#define MAX_ATTRIBUTE_BLOCK
Definition player.h:221
player_list_iterate
#define player_list_iterate(playerlist, pplayer)
Definition player.h:555
is_barbarian
static bool is_barbarian(const struct player *pplayer)
Definition player.h:489
player_slots_iterate
#define player_slots_iterate(_pslot)
Definition player.h:523
is_ai
#define is_ai(plr)
Definition player.h:230
player_list_iterate_end
#define player_list_iterate_end
Definition player.h:557
players_iterate_alive_end
#define players_iterate_alive_end
Definition player.h:547
player_slots_iterate_end
#define player_slots_iterate_end
Definition player.h:527
players_iterate_alive
#define players_iterate_alive(_pplayer)
Definition player.h:542
server_player_set_name
void server_player_set_name(struct player *pplayer, const char *name)
Definition plrhand.c:2268
server_create_player
struct player * server_create_player(int player_id, const char *ai_tname, struct rgbcolor *prgbcolor, bool allow_ai_type_fallbacking)
Definition plrhand.c:1894
normal_player_count
int normal_player_count(void)
Definition plrhand.c:3205
player_limit_to_max_rates
void player_limit_to_max_rates(struct player *pplayer)
Definition plrhand.c:2057
pick_a_nation
struct nation_type * pick_a_nation(const struct nation_list *choices, bool ignore_conflicts, bool needs_startpos, enum barbarian_type barb_type)
Definition plrhand.c:2453
set_shuffled_players
void set_shuffled_players(int *shuffled_players)
Definition plrhand.c:2403
player_delegation_set
void player_delegation_set(struct player *pplayer, const char *username)
Definition plrhand.c:3251
shuffle_players
void shuffle_players(void)
Definition plrhand.c:2378
server_remove_player
void server_remove_player(struct player *pplayer)
Definition plrhand.c:1943
server_player_init
void server_player_init(struct player *pplayer, bool initmap, bool needs_team)
Definition plrhand.c:1619
assign_player_colors
void assign_player_colors(void)
Definition plrhand.c:1734
fit_nationset_to_players
void fit_nationset_to_players(void)
Definition plrhand.c:2659
fc_rand_state
RANDOM_STATE fc_rand_state(void)
Definition rand.c:208
fc_rand_set_state
void fc_rand_set_state(RANDOM_STATE state)
Definition rand.c:229
secfile_error
const char * secfile_error(void)
Definition section_file.c:36
secfile_lookup_int
bool secfile_lookup_int(const struct section_file *secfile, int *ival, const char *path,...)
Definition registry_ini.c:1975
secfile_lookup_str_vec
const char ** secfile_lookup_str_vec(const struct section_file *secfile, size_t *dim, const char *path,...)
Definition registry_ini.c:2239
secfile_entry_lookup
struct entry * secfile_entry_lookup(const struct section_file *secfile, const char *path,...)
Definition registry_ini.c:1857
secfile_lookup_str
const char * secfile_lookup_str(const struct section_file *secfile, const char *path,...)
Definition registry_ini.c:2175
secfile_lookup_bool_default
bool secfile_lookup_bool_default(const struct section_file *secfile, bool def, const char *path,...)
Definition registry_ini.c:1900
secfile_lookup_int_default
int secfile_lookup_int_default(const struct section_file *secfile, int def, const char *path,...)
Definition registry_ini.c:2000
secfile_entry_by_path
struct entry * secfile_entry_by_path(const struct section_file *secfile, const char *path)
Definition registry_ini.c:1784
secfile_section_lookup
struct section * secfile_section_lookup(const struct section_file *secfile, const char *path,...)
Definition registry_ini.c:2840
secfile_lookup_str_default
const char * secfile_lookup_str_default(const struct section_file *secfile, const char *def, const char *path,...)
Definition registry_ini.c:2205
secfile_lookup_bool
bool secfile_lookup_bool(const struct section_file *secfile, bool *bval, const char *path,...)
Definition registry_ini.c:1875
secfile_lookup_enum_default
#define secfile_lookup_enum_default(secfile, defval, specenum_type, path,...)
Definition registry_ini.h:516
secfile_entry_ignore
#define secfile_entry_ignore(_sfile_, _fmt_,...)
Definition registry_ini.h:414
history_report_get
struct history_report * history_report_get(void)
Definition report.c:1824
are_reqs_active
bool are_reqs_active(const struct req_context *context, const struct player *other_player, const struct requirement_vector *reqs, const enum req_problem_type prob_type)
Definition requirements.c:5523
universal_by_rule_name
struct universal universal_by_rule_name(const char *kind, const char *value)
Definition requirements.c:238
research_invention_reachable
bool research_invention_reachable(const struct research *presearch, const Tech_type_id tech)
Definition research.c:668
research_name_translation
const char * research_name_translation(const struct research *presearch)
Definition research.c:156
research_invention_set
enum tech_state research_invention_set(struct research *presearch, Tech_type_id tech, enum tech_state value)
Definition research.c:637
research_by_number
struct research * research_by_number(int number)
Definition research.c:118
recalculate_techs_researched
int recalculate_techs_researched(const struct research *presearch)
Definition research.c:1345
research_invention_state
enum tech_state research_invention_state(const struct research *presearch, Tech_type_id tech)
Definition research.c:619
research_update
void research_update(struct research *presearch)
Definition research.c:501
researches_iterate
#define researches_iterate(_presearch)
Definition research.h:155
researches_iterate_end
#define researches_iterate_end
Definition research.h:158
rgbcolor_destroy
void rgbcolor_destroy(struct rgbcolor *prgbcolor)
Definition rgbcolor.c:74
rgbcolor_load
bool rgbcolor_load(struct section_file *file, struct rgbcolor **prgbcolor, char *path,...)
Definition rgbcolor.c:90
road_extra_get
struct extra_type * road_extra_get(const struct road_type *proad)
Definition road.c:42
road_number
Road_type_id road_number(const struct road_type *proad)
Definition road.c:32
road_by_number
struct road_type * road_by_number(Road_type_id id)
Definition road.c:58
road_by_compat_special
struct road_type * road_by_compat_special(enum road_compat compat)
Definition road.c:160
load_rulesets
bool load_rulesets(const char *restore, const char *alt, bool compat_mode, rs_conversion_logger logger, bool act, bool buffer_script, bool load_luadata)
Definition ruleset.c:9362
sanity_check
#define sanity_check()
Definition sanitycheck.h:43
sanity_check_city
#define sanity_check_city(x)
Definition sanitycheck.h:41
resource_by_identifier
struct extra_type * resource_by_identifier(const char identifier)
Definition savecompat.c:306
compat
static struct compatibility compat[]
Definition savecompat.c:105
char2num
int char2num(char ch)
Definition savecompat.c:251
sg_load_compat
void sg_load_compat(struct loaddata *loading, enum sgf_version format_class)
Definition savecompat.c:138
ai_level_convert
enum ai_level ai_level_convert(int old_level)
Definition savecompat.c:2406
ascii_hex2bin
int ascii_hex2bin(char ch, int halfbyte)
Definition savecompat.c:227
special_extra_get
struct extra_type * special_extra_get(int spe)
Definition savecompat.c:292
special_by_rule_name
enum tile_special_type special_by_rule_name(const char *name)
Definition savecompat.c:266
sg_load_post_load_compat
void sg_load_post_load_compat(struct loaddata *loading, enum sgf_version format_class)
Definition savecompat.c:183
special_rule_name
const char * special_rule_name(enum tile_special_type type)
Definition savecompat.c:282
sg_check_ret
#define sg_check_ret(...)
Definition savecompat.h:150
sg_warn
#define sg_warn(condition, message,...)
Definition savecompat.h:160
tile_special_type
tile_special_type
Definition savecompat.h:29
S_MINE
@ S_MINE
Definition savecompat.h:31
S_HUT
@ S_HUT
Definition savecompat.h:33
S_FALLOUT
@ S_FALLOUT
Definition savecompat.h:35
S_POLLUTION
@ S_POLLUTION
Definition savecompat.h:32
S_OLD_RIVER
@ S_OLD_RIVER
Definition savecompat.h:44
S_FARMLAND
@ S_FARMLAND
Definition savecompat.h:34
S_OLD_ROAD
@ S_OLD_ROAD
Definition savecompat.h:42
S_LAST
@ S_LAST
Definition savecompat.h:38
S_IRRIGATION
@ S_IRRIGATION
Definition savecompat.h:30
S_OLD_RAILROAD
@ S_OLD_RAILROAD
Definition savecompat.h:43
hex_chars
#define hex_chars
Definition savecompat.h:205
sg_failure_ret_val
#define sg_failure_ret_val(condition, _val, message,...)
Definition savecompat.h:184
sg_failure_ret
#define sg_failure_ret(condition, message,...)
Definition savecompat.h:177
MAX_TRADE_ROUTES_OLD
#define MAX_TRADE_ROUTES_OLD
Definition savecompat.h:222
sg_regr
#define sg_regr(fixversion, message,...)
Definition savecompat.h:193
SAVEGAME_2
@ SAVEGAME_2
Definition savecompat.h:27
log_sg
#define log_sg
Definition savecompat.h:146
sg_warn_ret_val
#define sg_warn_ret_val(condition, _val, message,...)
Definition savecompat.h:171
unit_ordering_apply
static void unit_ordering_apply(void)
Definition savegame2.c:834
sg_load_players_basic
static void sg_load_players_basic(struct loaddata *loading)
Definition savegame2.c:2689
loaddata_new
static struct loaddata * loaddata_new(struct section_file *file)
Definition savegame2.c:471
ACTIVITY_OLD_POLLUTION_SG2
#define ACTIVITY_OLD_POLLUTION_SG2
Definition savegame2.c:145
sg_load_map_known
static void sg_load_map_known(struct loaddata *loading)
Definition savegame2.c:2624
halfbyte_iterate_roads_end
#define halfbyte_iterate_roads_end
Definition savegame2.c:280
char2resource
static struct extra_type * char2resource(char c)
Definition savegame2.c:1316
sg_load_map_owner
static void sg_load_map_owner(struct loaddata *loading)
Definition savegame2.c:2493
sg_success
bool sg_success
Definition savecompat.c:34
halfbyte_iterate_extras_end
#define halfbyte_iterate_extras_end
Definition savegame2.c:250
sg_load_map_tiles_roads
static void sg_load_map_tiles_roads(struct loaddata *loading)
Definition savegame2.c:2332
halfbyte_iterate_extras
#define halfbyte_iterate_extras(e, num_extras_types)
Definition savegame2.c:245
sg_load_map
static void sg_load_map(struct loaddata *loading)
Definition savegame2.c:2175
char2order
static enum unit_orders char2order(char order)
Definition savegame2.c:597
unquote_block
static int unquote_block(const char *const quoted_, void *dest, int dest_length)
Definition savegame2.c:740
sg_bases_set_bv
static void sg_bases_set_bv(bv_extras *extras, char ch, struct base_type **idx)
Definition savegame2.c:1227
LOAD_MAP_CHAR
#define LOAD_MAP_CHAR(ch, ptile, SET_XY_CHAR, secfile, secpath,...)
Definition savegame2.c:209
ACTIVITY_OLD_RAILROAD
#define ACTIVITY_OLD_RAILROAD
Definition savegame2.c:144
sg_load_player_city_citizens
static void sg_load_player_city_citizens(struct loaddata *loading, struct player *plr, struct city *pcity, const char *citystr)
Definition savegame2.c:4044
sg_load_player_cities
static void sg_load_player_cities(struct loaddata *loading, struct player *plr)
Definition savegame2.c:3645
sg_load_map_tiles
static void sg_load_map_tiles(struct loaddata *loading)
Definition savegame2.c:2260
activity2char
static char activity2char(int activity)
Definition savegame2.c:665
sg_load_savefile
static void sg_load_savefile(struct loaddata *loading)
Definition savegame2.c:1427
ACTIVITY_OLD_FALLOUT_SG2
#define ACTIVITY_OLD_FALLOUT_SG2
Definition savegame2.c:146
sg_load_player_unit
static bool sg_load_player_unit(struct loaddata *loading, struct player *plr, struct unit *punit, const char *unitstr)
Definition savegame2.c:4211
set_unit_activity_base
static void set_unit_activity_base(struct unit *punit, Base_type_id base)
Definition savegame2.c:573
sg_load_player_city
static bool sg_load_player_city(struct loaddata *loading, struct player *plr, struct city *pcity, const char *citystr, int wlist_max_length)
Definition savegame2.c:3760
sg_load_settings
static void sg_load_settings(struct loaddata *loading)
Definition savegame2.c:2155
sg_bases_set_dbv
static void sg_bases_set_dbv(struct dbv *extras, char ch, struct base_type **idx)
Definition savegame2.c:1195
sg_load_player_units
static void sg_load_player_units(struct loaddata *loading, struct player *plr)
Definition savegame2.c:4092
halfbyte_iterate_special
#define halfbyte_iterate_special(s, num_specials_types)
Definition savegame2.c:255
savegame2_load
void savegame2_load(struct section_file *file)
Definition savegame2.c:402
sg_load_researches
static void sg_load_researches(struct loaddata *loading)
Definition savegame2.c:5269
halfbyte_iterate_bases_end
#define halfbyte_iterate_bases_end
Definition savegame2.c:270
sg_load_map_worked
static void sg_load_map_worked(struct loaddata *loading)
Definition savegame2.c:2580
sg_load_random
static void sg_load_random(struct loaddata *loading)
Definition savegame2.c:1986
halfbyte_iterate_special_end
#define halfbyte_iterate_special_end
Definition savegame2.c:260
halfbyte_iterate_bases
#define halfbyte_iterate_bases(b, num_bases_types)
Definition savegame2.c:265
sg_load_player_units_transport
static void sg_load_player_units_transport(struct loaddata *loading, struct player *plr)
Definition savegame2.c:4808
sg_load_history
static void sg_load_history(struct loaddata *loading)
Definition savegame2.c:5461
char2activity
static int char2activity(char activity)
Definition savegame2.c:719
ORDER_OLD_BUILD_WONDER
#define ORDER_OLD_BUILD_WONDER
Definition savegame2.c:288
sg_load_map_tiles_specials
static void sg_load_map_tiles_specials(struct loaddata *loading, bool rivers_overlay)
Definition savegame2.c:2348
TOKEN_SIZE
#define TOKEN_SIZE
Definition savegame2.c:284
sg_load_script
static void sg_load_script(struct loaddata *loading)
Definition savegame2.c:2045
sg_load_scenario
static void sg_load_scenario(struct loaddata *loading)
Definition savegame2.c:2060
sg_load_ruleset
static void sg_load_ruleset(struct loaddata *loading)
Definition savegame2.c:1393
sg_load_game
static void sg_load_game(struct loaddata *loading)
Definition savegame2.c:1837
sg_load_player_main
static void sg_load_player_main(struct loaddata *loading, struct player *plr)
Definition savegame2.c:3138
ACTIVITY_OLD_ROAD
#define ACTIVITY_OLD_ROAD
Definition savegame2.c:143
sg_load_treaties
static void sg_load_treaties(struct loaddata *loading)
Definition savegame2.c:5379
sg_extras_set_bv
static void sg_extras_set_bv(bv_extras *extras, char ch, struct extra_type **idx)
Definition savegame2.c:888
set_unit_activity_road
static void set_unit_activity_road(struct unit *punit, Road_type_id road)
Definition savegame2.c:583
technology_load
static Tech_type_id technology_load(struct section_file *file, const char *path, int plrno)
Definition savegame2.c:1353
char2dir
static enum direction8 char2dir(char dir)
Definition savegame2.c:636
sg_load_map_tiles_resources
static void sg_load_map_tiles_resources(struct loaddata *loading)
Definition savegame2.c:2379
ORDER_OLD_BUILD_CITY
#define ORDER_OLD_BUILD_CITY
Definition savegame2.c:286
char2terrain
static struct terrain * char2terrain(char ch)
Definition savegame2.c:1331
ORDER_OLD_DISBAND
#define ORDER_OLD_DISBAND
Definition savegame2.c:287
sg_load_mapimg
static void sg_load_mapimg(struct loaddata *loading)
Definition savegame2.c:5494
ORDER_OLD_HOMECITY
#define ORDER_OLD_HOMECITY
Definition savegame2.c:290
sg_special_set_bv
static void sg_special_set_bv(struct tile *ptile, bv_extras *extras, char ch, const enum tile_special_type *idx, bool rivers_overlay)
Definition savegame2.c:1058
sg_load_player_attributes
static void sg_load_player_attributes(struct loaddata *loading, struct player *plr)
Definition savegame2.c:4861
sg_load_ruledata
static void sg_load_ruledata(struct loaddata *loading)
Definition savegame2.c:1813
sg_special_set_dbv
static void sg_special_set_dbv(struct tile *ptile, struct dbv *extras, char ch, const enum tile_special_type *idx, bool rivers_overlay)
Definition savegame2.c:921
sg_load_player_vision
static void sg_load_player_vision(struct loaddata *loading, struct player *plr)
Definition savegame2.c:4941
worklist_load
static void worklist_load(struct section_file *file, int wlist_max_length, struct worklist *pwl, const char *path,...)
Definition savegame2.c:788
sg_load_player_vision_city
static bool sg_load_player_vision_city(struct loaddata *loading, struct player *plr, struct vision_site *pdcity, const char *citystr)
Definition savegame2.c:5162
sg_roads_set_bv
static void sg_roads_set_bv(bv_extras *extras, char ch, struct road_type **idx)
Definition savegame2.c:1289
sg_roads_set_dbv
static void sg_roads_set_dbv(struct dbv *extras, char ch, struct road_type **idx)
Definition savegame2.c:1258
sg_load_map_startpos
static void sg_load_map_startpos(struct loaddata *loading)
Definition savegame2.c:2406
loaddata_destroy
static void loaddata_destroy(struct loaddata *loading)
Definition savegame2.c:512
sg_load_players
static void sg_load_players(struct loaddata *loading)
Definition savegame2.c:2946
ORDER_OLD_TRADE_ROUTE
#define ORDER_OLD_TRADE_ROUTE
Definition savegame2.c:289
sg_load_map_tiles_extras
static void sg_load_map_tiles_extras(struct loaddata *loading)
Definition savegame2.c:2300
sg_load_sanitycheck
static void sg_load_sanitycheck(struct loaddata *loading)
Definition savegame2.c:5538
sg_load_event_cache
static void sg_load_event_cache(struct loaddata *loading)
Definition savegame2.c:5364
sg_load_map_tiles_bases
static void sg_load_map_tiles_bases(struct loaddata *loading)
Definition savegame2.c:2316
sg_extras_set_dbv
static void sg_extras_set_dbv(struct dbv *extras, char ch, struct extra_type **idx)
Definition savegame2.c:855
ACTIVITY_LAST_SAVEGAME2
#define ACTIVITY_LAST_SAVEGAME2
Definition savegame2.c:147
sg_order_to_action
static int sg_order_to_action(int order, struct unit *act_unit, struct tile *tgt_tile)
Definition savegame2.c:4170
halfbyte_iterate_roads
#define halfbyte_iterate_roads(r, num_roads_types)
Definition savegame2.c:275
calc_civ_score
void calc_civ_score(struct player *pplayer)
Definition score.c:251
script_server_state_load
void script_server_state_load(struct section_file *file)
Definition script_server.c:387
script_server.h
settings_game_load
void settings_game_load(struct section_file *file, const char *section)
Definition settings.c:4946
level
struct setting_list * level[OLEVELS_NUM]
Definition settings.c:190
str_to_int
bool str_to_int(const char *str, int *pint)
Definition shared.c:517
is_base64url
bool is_base64url(const char *s)
Definition shared.c:318
scanin
char scanin(const char **buf, char *delimiters, char *dest, int size)
Definition shared.c:1922
randomize_base64url_string
void randomize_base64url_string(char *s, size_t n)
Definition shared.c:339
CLIP
#define CLIP(lower, current, upper)
Definition shared.h:57
ARRAY_SIZE
#define ARRAY_SIZE(x)
Definition shared.h:85
spaceship_calc_derived
void spaceship_calc_derived(struct player_spaceship *ship)
Definition spacerace.c:46
spaceship_init
void spaceship_init(struct player_spaceship *ship)
Definition spaceship.c:96
NUM_SS_STRUCTURALS
#define NUM_SS_STRUCTURALS
Definition spaceship.h:87
SSHIP_LAUNCHED
@ SSHIP_LAUNCHED
Definition spaceship.h:85
SSHIP_NONE
@ SSHIP_NONE
Definition spaceship.h:84
specialist_by_rule_name
struct specialist * specialist_by_rule_name(const char *name)
Definition specialist.c:112
specialist_index
Specialist_type_id specialist_index(const struct specialist *sp)
Definition specialist.c:82
specialist_type_iterate_end
#define specialist_type_iterate_end
Definition specialist.h:79
specialist_type_iterate
#define specialist_type_iterate(sp)
Definition specialist.h:73
DEFAULT_SPECIALIST
#define DEFAULT_SPECIALIST
Definition specialist.h:43
size
size_t size
Definition specvec.h:72
y
struct sprite int int y
Definition sprite_g.h:31
x
struct sprite int x
Definition sprite_g.h:31
server_game_init
void server_game_init(bool keep_ruleset_value)
Definition srv_main.c:3464
aifill
const char * aifill(int amount)
Definition srv_main.c:2466
game_was_started
bool game_was_started(void)
Definition srv_main.c:349
identity_number_reserve
void identity_number_reserve(int id)
Definition srv_main.c:1994
srvarg
struct server_arguments srvarg
Definition srv_main.c:176
init_game_seed
void init_game_seed(void)
Definition srv_main.c:203
update_nations_with_startpos
void update_nations_with_startpos(void)
Definition srv_main.c:2271
server_game_free
void server_game_free(void)
Definition srv_main.c:3488
srv_main.h
Treaty::accept0
bool accept0
Definition diptreaty.h:80
Treaty::accept1
bool accept1
Definition diptreaty.h:80
achievement::first
struct player * first
Definition achievements.h:34
ai_trait::val
int val
Definition traits.h:38
ai_trait::mod
int mod
Definition traits.h:39
attribute_block_s::data
void * data
Definition player.h:219
attribute_block_s::length
int length
Definition player.h:220
base_type
Definition base.h:41
built_status::turn
int turn
Definition city.h:246
city
Definition city.h:320
city::task_reqs
struct worker_task_list * task_reqs
Definition city.h:412
city::turn_last_built
int turn_last_built
Definition city.h:387
city::wlcb
enum city_wl_cancel_behavior wlcb
Definition city.h:404
city::food_stock
int food_stock
Definition city.h:367
city::built
struct built_status built[B_LAST]
Definition city.h:394
city::original
struct player * original
Definition city.h:324
city::history
int history
Definition city.h:410
city::did_sell
bool did_sell
Definition city.h:380
city::id
int id
Definition city.h:326
city::last_turns_shield_surplus
int last_turns_shield_surplus
Definition city.h:392
city::disbanded_shields
int disbanded_shields
Definition city.h:391
city::turn_plague
int turn_plague
Definition city.h:374
city::city_options
bv_city_options city_options
Definition city.h:403
city::was_happy
bool was_happy
Definition city.h:381
city::acquire_t
enum city_acquire_type acquire_t
Definition city.h:329
city::turn_founded
int turn_founded
Definition city.h:386
city::airlift
int airlift
Definition city.h:378
city::caravan_shields
int caravan_shields
Definition city.h:390
city::did_buy
bool did_buy
Definition city.h:379
city::routes
struct trade_route_list * routes
Definition city.h:344
city::anarchy
int anarchy
Definition city.h:384
city::worklist
struct worklist worklist
Definition city.h:401
city::production
struct universal production
Definition city.h:396
city::nationality
citizens * nationality
Definition city.h:341
city::steal
int steal
Definition city.h:414
city::before_change_shields
int before_change_shields
Definition city.h:389
city::style
int style
Definition city.h:327
city::had_famine
bool had_famine
Definition city.h:382
city::synced
bool synced
Definition city.h:448
city::specialists
citizens specialists[SP_MAX]
Definition city.h:336
city::tile
struct tile * tile
Definition city.h:322
city::shield_stock
int shield_stock
Definition city.h:368
city::vision
struct vision * vision
Definition city.h:455
city::server
struct city::@17::@19 server
city::changed_from
struct universal changed_from
Definition city.h:399
city::units_supported
struct unit_list * units_supported
Definition city.h:406
city::rapture
int rapture
Definition city.h:385
civ_game::last_updated_year
bool last_updated_year
Definition game.h:240
civ_game::turn_change_time
float turn_change_time
Definition game.h:222
civ_game::vision_reveal_tiles
bool vision_reveal_tiles
Definition game.h:204
civ_game::scenario_desc
struct packet_scenario_description scenario_desc
Definition game.h:88
civ_game::control
struct packet_ruleset_control control
Definition game.h:83
civ_game::fogofwar_old
bool fogofwar_old
Definition game.h:238
civ_game::info
struct packet_game_info info
Definition game.h:89
civ_game::timeoutcounter
int timeoutcounter
Definition game.h:211
civ_game::rulesetdir
char rulesetdir[MAX_LEN_NAME]
Definition game.h:242
civ_game::scoreturn
int scoreturn
Definition game.h:229
civ_game::seed
randseed seed
Definition game.h:231
civ_game::scenario
struct packet_scenario_info scenario
Definition game.h:87
civ_game::timeoutint
int timeoutint
Definition game.h:207
civ_game::revealmap
unsigned revealmap
Definition game.h:181
civ_game::orig_game_version
char orig_game_version[MAX_LEN_NAME]
Definition game.h:225
civ_game::foggedborders
bool foggedborders
Definition game.h:151
civ_game::server
struct civ_game::@31::@35 server
civ_game::timeoutincmult
int timeoutincmult
Definition game.h:209
civ_game::timeoutinc
int timeoutinc
Definition game.h:208
civ_game::phase_mode_stored
int phase_mode_stored
Definition game.h:220
civ_game::max_players
int max_players
Definition game.h:160
civ_game::timeoutintinc
int timeoutintinc
Definition game.h:210
civ_map
Definition map_types.h:71
civ_map::xsize
int xsize
Definition map_types.h:78
civ_map::seed
randseed seed
Definition map_types.h:92
civ_map::ysize
int ysize
Definition map_types.h:78
civ_map::have_resources
bool have_resources
Definition map_types.h:108
civ_map::server
struct civ_map::@42::@44 server
civ_map::have_huts
bool have_huts
Definition map_types.h:107
civ_map::generator
enum map_generator generator
Definition map_types.h:98
extra_type
Definition extras.h:88
government::changed_to_times
int changed_to_times
Definition government.h:64
history_report
Definition report.h:26
history_report::turn
int turn
Definition report.h:27
impr_type
Definition improvement.h:50
loaddata::order
const char ** order
Definition savecompat.h:54
loaddata::file
struct section_file * file
Definition savecompat.h:48
multiplier_value::value
int value
Definition player.h:239
multiplier_value::target
int target
Definition player.h:241
multiplier_value::changed
int changed
Definition player.h:243
nation_style
Definition style.h:22
nation_type
Definition nation.h:98
packet_game_info::coolinglevel
int coolinglevel
Definition packets_gen.h:145
packet_game_info::globalwarming
int globalwarming
Definition packets_gen.h:162
packet_game_info::nuclearwinter
int nuclearwinter
Definition packets_gen.h:203
packet_game_info::citizen_nationality
bool citizen_nationality
Definition packets_gen.h:138
packet_game_info::year_0_hack
bool year_0_hack
Definition packets_gen.h:242
packet_game_info::great_wonder_owners
int great_wonder_owners[B_LAST]
Definition packets_gen.h:173
packet_game_info::cooling
int cooling
Definition packets_gen.h:144
packet_game_info::global_advances
bool global_advances[A_LAST]
Definition packets_gen.h:160
packet_game_info::is_new_game
bool is_new_game
Definition packets_gen.h:184
packet_game_info::warminglevel
int warminglevel
Definition packets_gen.h:240
packet_game_info::skill_level
enum ai_level skill_level
Definition packets_gen.h:220
packet_game_info::phase_mode
enum phase_mode_type phase_mode
Definition packets_gen.h:205
packet_game_info::illness_on
bool illness_on
Definition packets_gen.h:179
packet_game_info::heating
int heating
Definition packets_gen.h:176
packet_game_info::turn
int turn
Definition packets_gen.h:239
packet_game_info::year
int year
Definition packets_gen.h:241
packet_game_info::phase
int phase
Definition packets_gen.h:204
packet_game_info::fogofwar
bool fogofwar
Definition packets_gen.h:148
packet_ruleset_control::num_extra_types
int num_extra_types
Definition packets_gen.h:1460
packet_ruleset_control::num_road_types
int num_road_types
Definition packets_gen.h:1462
packet_ruleset_control::num_specialist_types
int num_specialist_types
Definition packets_gen.h:1474
packet_ruleset_control::num_base_types
int num_base_types
Definition packets_gen.h:1461
packet_scenario_description::description
char description[MAX_LEN_CONTENT]
Definition packets_gen.h:1627
packet_scenario_info::lake_flooding
bool lake_flooding
Definition packets_gen.h:1617
packet_scenario_info::have_resources
bool have_resources
Definition packets_gen.h:1622
packet_scenario_info::is_scenario
bool is_scenario
Definition packets_gen.h:1610
packet_scenario_info::ruleset_locked
bool ruleset_locked
Definition packets_gen.h:1620
packet_scenario_info::allow_ai_type_fallback
bool allow_ai_type_fallback
Definition packets_gen.h:1619
packet_scenario_info::players
bool players
Definition packets_gen.h:1613
packet_scenario_info::authors
char authors[MAX_LEN_PACKET/3]
Definition packets_gen.h:1612
packet_scenario_info::name
char name[256]
Definition packets_gen.h:1611
packet_scenario_info::prevent_new_cities
bool prevent_new_cities
Definition packets_gen.h:1616
packet_scenario_info::handmade
bool handmade
Definition packets_gen.h:1618
packet_scenario_info::startpos_nations
bool startpos_nations
Definition packets_gen.h:1614
packet_scenario_info::save_random
bool save_random
Definition packets_gen.h:1615
player_ai::skill_level
enum ai_level skill_level
Definition player.h:114
player_ai::traits
struct ai_trait * traits
Definition player.h:124
player_ai::barbarian_type
enum barbarian_type barbarian_type
Definition player.h:120
player_ai::science_cost
int science_cost
Definition player.h:117
player_ai::love
int love[MAX_NUM_PLAYER_SLOTS]
Definition player.h:122
player_ai::expand
int expand
Definition player.h:116
player_ai::fuzzy
int fuzzy
Definition player.h:115
player_diplstate
Definition player.h:196
player_diplstate::type
enum diplstate_type type
Definition player.h:197
player_economic::luxury
int luxury
Definition player.h:64
player_economic::science
int science
Definition player.h:63
player_economic::tax
int tax
Definition player.h:62
player_economic::gold
int gold
Definition player.h:61
player_score::units_killed
int units_killed
Definition player.h:103
player_score::landarea
int landarea
Definition player.h:92
player_score::mfg
int mfg
Definition player.h:100
player_score::population
int population
Definition player.h:94
player_score::pollution
int pollution
Definition player.h:97
player_score::wonders
int wonders
Definition player.h:89
player_score::settledarea
int settledarea
Definition player.h:93
player_score::units_used
int units_used
Definition player.h:106
player_score::specialists
int specialists[SP_MAX]
Definition player.h:88
player_score::units_lost
int units_lost
Definition player.h:104
player_score::angry
int angry
Definition player.h:87
player_score::techout
int techout
Definition player.h:91
player_score::game
int game
Definition player.h:108
player_score::units
int units
Definition player.h:96
player_score::units_built
int units_built
Definition player.h:102
player_score::content
int content
Definition player.h:85
player_score::happy
int happy
Definition player.h:84
player_score::spaceship
int spaceship
Definition player.h:101
player_score::culture
int culture
Definition player.h:107
player_score::unhappy
int unhappy
Definition player.h:86
player_score::cities
int cities
Definition player.h:95
player_score::bnp
int bnp
Definition player.h:99
player_score::literacy
int literacy
Definition player.h:98
player_score::techs
int techs
Definition player.h:90
player_spaceship
Definition spaceship.h:94
player_tile
Definition maphand.h:30
player_tile::extras_owner
struct player * extras_owner
Definition maphand.h:35
player_tile::owner
struct player * owner
Definition maphand.h:34
player::cities
struct city_list * cities
Definition player.h:279
player::bulbs_last_turn
int bulbs_last_turn
Definition player.h:349
player::ai_common
struct player_ai ai_common
Definition player.h:286
player::flags
bv_plr_flags flags
Definition player.h:290
player::is_male
bool is_male
Definition player.h:255
player::wonders
int wonders[B_LAST]
Definition player.h:303
player::unassigned_ranked
bool unassigned_ranked
Definition player.h:253
player::target_government
struct government * target_government
Definition player.h:257
player::username
char username[MAX_LEN_NAME]
Definition player.h:250
player::revolution_finishes
int revolution_finishes
Definition player.h:271
player::nturns_idle
int nturns_idle
Definition player.h:263
player::government
struct government * government
Definition player.h:256
player::team
struct team * team
Definition player.h:259
player::turns_alive
int turns_alive
Definition player.h:264
player::units
struct unit_list * units
Definition player.h:280
player::ranked_username
char ranked_username[MAX_LEN_NAME]
Definition player.h:252
player::huts
int huts
Definition player.h:347
player::is_alive
bool is_alive
Definition player.h:266
player::real_embassy
bv_player real_embassy
Definition player.h:275
player::economic
struct player_economic economic
Definition player.h:282
player::spaceship
struct player_spaceship spaceship
Definition player.h:284
player::attribute_block
struct attribute_block_s attribute_block
Definition player.h:305
player::score
struct player_score score
Definition player.h:281
player::multipliers
struct multiplier_value multipliers[MAX_NUM_MULTIPLIERS]
Definition player.h:312
player::nation
struct nation_type * nation
Definition player.h:258
player::style
struct nation_style * style
Definition player.h:277
player::border_vision
bool border_vision
Definition player.h:325
player::phase_done
bool phase_done
Definition player.h:261
player::server
struct player::@70::@72 server
player::history
int history
Definition player.h:314
player::orig_username
char orig_username[MAX_LEN_NAME]
Definition player.h:345
player::last_war_action
int last_war_action
Definition player.h:268
player::unassigned_user
bool unassigned_user
Definition player.h:251
req_context
Definition requirements.h:100
req_context::tile
const struct tile * tile
Definition requirements.h:103
road_type
Definition road.h:71
section_file
Definition section_file.h:36
server_arguments::metaserver_addr
char metaserver_addr[256]
Definition srv_main.h:29
server_arguments::serverid
char serverid[256]
Definition srv_main.h:49
startpos
Definition map.c:41
team_slot
Definition team.c:31
team
Definition team.c:40
tile
Definition tile.h:50
tile::index
int index
Definition tile.h:51
tile::extras
bv_extras extras
Definition tile.h:55
tile::units
struct unit_list * units
Definition tile.h:58
tile::claimer
struct tile * claimer
Definition tile.h:64
trade_route
Definition traderoutes.h:83
trade_route::partner
int partner
Definition traderoutes.h:84
unit_order
Definition unit.h:92
unit_order::order
enum unit_orders order
Definition unit.h:93
unit_type
Definition unittype.h:500
unit
Definition unit.h:138
unit::length
int length
Definition unit.h:195
unit::upkeep
int upkeep[O_LAST]
Definition unit.h:148
unit::has_orders
bool has_orders
Definition unit.h:193
unit::orders
struct unit::@80 orders
unit::action_decision_want
enum action_decision action_decision_want
Definition unit.h:202
unit::battlegroup
int battlegroup
Definition unit.h:191
unit::activity
enum unit_activity activity
Definition unit.h:157
unit::moves_left
int moves_left
Definition unit.h:150
unit::id
int id
Definition unit.h:145
unit::ord_city
int ord_city
Definition unit.h:242
unit::moved
bool moved
Definition unit.h:173
unit::ord_map
int ord_map
Definition unit.h:241
unit::index
int index
Definition unit.h:195
unit::vision
struct vision * vision
Definition unit.h:244
unit::vigilant
bool vigilant
Definition unit.h:197
unit::hp
int hp
Definition unit.h:151
unit::fuel
int fuel
Definition unit.h:153
unit::changed_from_target
struct extra_type * changed_from_target
Definition unit.h:170
unit::current_form_turn
int current_form_turn
Definition unit.h:208
unit::facing
enum direction8 facing
Definition unit.h:142
unit::server
struct unit::@81::@84 server
unit::activity_target
struct extra_type * activity_target
Definition unit.h:164
unit::activity_count
int activity_count
Definition unit.h:162
unit::list
struct unit_order * list
Definition unit.h:198
unit::changed_from
enum unit_activity changed_from
Definition unit.h:168
unit::nationality
struct player * nationality
Definition unit.h:144
unit::repeat
bool repeat
Definition unit.h:196
unit::homecity
int homecity
Definition unit.h:146
unit::paradropped
bool paradropped
Definition unit.h:174
unit::done_moving
bool done_moving
Definition unit.h:181
unit::birth_turn
int birth_turn
Definition unit.h:207
unit::goto_tile
struct tile * goto_tile
Definition unit.h:155
unit::action_decision_tile
struct tile * action_decision_tile
Definition unit.h:203
unit::veteran
int veteran
Definition unit.h:152
unit::changed_from_count
int changed_from_count
Definition unit.h:169
unit::ssa_controller
enum server_side_agent ssa_controller
Definition unit.h:172
universal::kind
enum universals_n kind
Definition fc_types.h:902
vision_site
Definition vision.h:109
worker_task
Definition workertask.h:21
world::map
struct civ_map map
Definition world_object.h:38
city_style
int city_style(struct city *pcity)
Definition style.c:241
style_by_rule_name
struct nation_style * style_by_rule_name(const char *name)
Definition style.c:117
style_by_number
struct nation_style * style_by_number(int id)
Definition style.c:88
style_rule_name
const char * style_rule_name(const struct nation_style *pstyle)
Definition style.c:108
fc_snprintf
int fc_snprintf(char *str, size_t n, const char *format,...)
Definition support.c:974
fc_strcasecmp
int fc_strcasecmp(const char *str0, const char *str1)
Definition support.c:189
fc_vsnprintf
int fc_vsnprintf(char *str, size_t n, const char *format, va_list ap)
Definition support.c:900
sz_strlcpy
#define sz_strlcpy(dest, src)
Definition support.h:195
RETURN_VALUE_AFTER_EXIT
#define RETURN_VALUE_AFTER_EXIT(_val_)
Definition support.h:146
TRUE
#define TRUE
Definition support.h:46
FALSE
#define FALSE
Definition support.h:47
team_slot_by_number
struct team_slot * team_slot_by_number(int team_id)
Definition team.c:175
team_add_player
bool team_add_player(struct player *pplayer, struct team *pteam)
Definition team.c:467
team_new
struct team * team_new(struct team_slot *tslot)
Definition team.c:317
team_members
const struct player_list * team_members(const struct team *pteam)
Definition team.c:456
is_future_tech
bool is_future_tech(Tech_type_id tech)
Definition tech.c:281
valid_advance_by_number
struct advance * valid_advance_by_number(const Tech_type_id id)
Definition tech.c:176
advance_by_rule_name
struct advance * advance_by_rule_name(const char *name)
Definition tech.c:200
advance_number
Tech_type_id advance_number(const struct advance *padvance)
Definition tech.c:98
A_FUTURE
#define A_FUTURE
Definition tech.h:46
A_NONE
#define A_NONE
Definition tech.h:43
A_UNSET
#define A_UNSET
Definition tech.h:48
A_UNKNOWN
#define A_UNKNOWN
Definition tech.h:49
init_tech
void init_tech(struct research *research, bool update)
Definition techtools.c:1094
terrain_by_rule_name
struct terrain * terrain_by_rule_name(const char *name)
Definition terrain.c:186
terrain_rule_name
const char * terrain_rule_name(const struct terrain *pterrain)
Definition terrain.c:247
terrain_has_resource
bool terrain_has_resource(const struct terrain *pterrain, const struct extra_type *presource)
Definition terrain.c:255
terrain_type_iterate
#define terrain_type_iterate(_p)
Definition terrain.h:373
T_UNKNOWN
#define T_UNKNOWN
Definition terrain.h:57
TERRAIN_UNKNOWN_IDENTIFIER
#define TERRAIN_UNKNOWN_IDENTIFIER
Definition terrain.h:195
terrain_type_iterate_end
#define terrain_type_iterate_end
Definition terrain.h:379
RESOURCE_NONE_IDENTIFIER
#define RESOURCE_NONE_IDENTIFIER
Definition terrain.h:47
RESOURCE_NULL_IDENTIFIER
#define RESOURCE_NULL_IDENTIFIER
Definition terrain.h:46
tile_has_claimable_base
bool tile_has_claimable_base(const struct tile *ptile, const struct unit_type *punittype)
Definition tile.c:215
tile_virtual_destroy
void tile_virtual_destroy(struct tile *vtile)
Definition tile.c:1033
tile_virtual_new
struct tile * tile_virtual_new(const struct tile *ptile)
Definition tile.c:981
tile_set_label
bool tile_set_label(struct tile *ptile, const char *label)
Definition tile.c:1095
tile_set_resource
void tile_set_resource(struct tile *ptile, struct extra_type *presource)
Definition tile.c:349
tile_city
struct city * tile_city(const struct tile *ptile)
Definition tile.c:83
tile_set_worked
void tile_set_worked(struct tile *ptile, struct city *pcity)
Definition tile.c:106
tile_index
#define tile_index(_pt_)
Definition tile.h:88
tile_worked
#define tile_worked(_tile)
Definition tile.h:118
tile_terrain
#define tile_terrain(_tile)
Definition tile.h:114
TILE_XY
#define TILE_XY(ptile)
Definition tile.h:43
tile_has_extra
#define tile_has_extra(ptile, pextra)
Definition tile.h:151
tile_owner
#define tile_owner(_tile)
Definition tile.h:96
goods_by_number
struct goods_type * goods_by_number(Goods_type_id id)
Definition traderoutes.c:604
free_unit_orders
void free_unit_orders(struct unit *punit)
Definition unit.c:1777
unit_transport_load
bool unit_transport_load(struct unit *pcargo, struct unit *ptrans, bool force)
Definition unit.c:2378
set_unit_activity
void set_unit_activity(struct unit *punit, enum unit_activity new_activity)
Definition unit.c:1096
unit_transport_get
struct unit * unit_transport_get(const struct unit *pcargo)
Definition unit.c:2449
can_unit_continue_current_activity
bool can_unit_continue_current_activity(const struct civ_map *nmap, struct unit *punit)
Definition unit.c:849
set_unit_activity_targeted
void set_unit_activity_targeted(struct unit *punit, enum unit_activity new_activity, struct extra_type *new_target)
Definition unit.c:1113
unit_virtual_create
struct unit * unit_virtual_create(struct player *pplayer, struct city *pcity, const struct unit_type *punittype, int veteran_level)
Definition unit.c:1632
unit_order_list_is_sane
bool unit_order_list_is_sane(const struct civ_map *nmap, int length, const struct unit_order *orders)
Definition unit.c:2657
unit_virtual_destroy
void unit_virtual_destroy(struct unit *punit)
Definition unit.c:1737
unit_tile_set
void unit_tile_set(struct unit *punit, struct tile *ptile)
Definition unit.c:1263
unit_tile
#define unit_tile(_pu)
Definition unit.h:397
BATTLEGROUP_NONE
#define BATTLEGROUP_NONE
Definition unit.h:190
unit_orders
unit_orders
Definition unit.h:37
ORDER_ACTION_MOVE
@ ORDER_ACTION_MOVE
Definition unit.h:45
ORDER_ACTIVITY
@ ORDER_ACTIVITY
Definition unit.h:41
ORDER_FULL_MP
@ ORDER_FULL_MP
Definition unit.h:43
ORDER_MOVE
@ ORDER_MOVE
Definition unit.h:39
ORDER_LAST
@ ORDER_LAST
Definition unit.h:49
ORDER_PERFORM_ACTION
@ ORDER_PERFORM_ACTION
Definition unit.h:47
unit_owner
#define unit_owner(_pu)
Definition unit.h:396
unit_list_sort_ord_map
void unit_list_sort_ord_map(struct unit_list *punitlist)
Definition unitlist.c:73
unit_list_sort_ord_city
void unit_list_sort_ord_city(struct unit_list *punitlist)
Definition unitlist.c:85
unit_list_iterate
#define unit_list_iterate(unitlist, punit)
Definition unitlist.h:31
unit_list_iterate_safe
#define unit_list_iterate_safe(unitlist, _unit)
Definition unitlist.h:39
unit_list_iterate_end
#define unit_list_iterate_end
Definition unitlist.h:33
unit_list_iterate_safe_end
#define unit_list_iterate_safe_end
Definition unitlist.h:61
resolve_unit_stacks
void resolve_unit_stacks(struct player *pplayer, struct player *aplayer, bool verbose)
Definition unittools.c:1395
unit_refresh_vision
void unit_refresh_vision(struct unit *punit)
Definition unittools.c:4841
bounce_unit
void bounce_unit(struct unit *punit, bool verbose)
Definition unittools.c:1222
unit_type_get
const struct unit_type * unit_type_get(const struct unit *punit)
Definition unittype.c:123
utype_upkeep_cost
int utype_upkeep_cost(const struct unit_type *ut, struct player *pplayer, Output_type_id otype)
Definition unittype.c:132
unit_type_by_rule_name
struct unit_type * unit_type_by_rule_name(const char *name)
Definition unittype.c:1767
unit_rule_name
const char * unit_rule_name(const struct unit *punit)
Definition unittype.c:1587
utype_veteran_levels
int utype_veteran_levels(const struct unit_type *punittype)
Definition unittype.c:2625
utype_index
Unit_type_id utype_index(const struct unit_type *punittype)
Definition unittype.c:91
utype_name_translation
const char * utype_name_translation(const struct unit_type *punittype)
Definition unittype.c:1560
utype_has_flag
static bool utype_has_flag(const struct unit_type *punittype, int flag)
Definition unittype.h:617
unit_type_iterate
#define unit_type_iterate(_p)
Definition unittype.h:855
U_LAST
#define U_LAST
Definition unittype.h:40
unit_type_iterate_end
#define unit_type_iterate_end
Definition unittype.h:862
vision_site_size_set
void vision_site_size_set(struct vision_site *psite, citizens size)
Definition vision.c:180
vision_new
struct vision * vision_new(struct player *pplayer, struct tile *ptile)
Definition vision.c:33
vision_reveal_tiles
bool vision_reveal_tiles(struct vision *vision, bool reveal_tiles)
Definition vision.c:62
vision_site_new
struct vision_site * vision_site_new(int identity, struct tile *location, struct player *owner)
Definition vision.c:86
vision_site_destroy
void vision_site_destroy(struct vision_site *psite)
Definition vision.c:74
worker_task_is_sane
bool worker_task_is_sane(struct worker_task *ptask)
Definition workertask.c:40
worker_task_list_iterate
#define worker_task_list_iterate(tasklist, ptask)
Definition workertask.h:33
worker_task_list_iterate_end
#define worker_task_list_iterate_end
Definition workertask.h:35
worklist_init
void worklist_init(struct worklist *pwl)
Definition worklist.c:38
Generated on Sun Aug 31 2025 23:00:36 for Freeciv-3.2 by doxygen 1.9.8