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