server/sanitycheck.c

   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 #ifdef HAVE_CONFIG_H
  15 #include <fc_config.h>
  16 #endif
  17
  18 /* utility */
  19 #include "bitvector.h"
  20 #include "log.h"
  21
  22 /* common */
  23 #include "city.h"
  24 #include "game.h"
  25 #include "government.h"
  26 #include "map.h"
  27 #include "movement.h"
  28 #include "player.h"
  29 #include "research.h"
  30 #include "specialist.h"
  31 #include "terrain.h"
  32 #include "unit.h"
  33 #include "unitlist.h"
  34
  35 /* server */
  36 #include "citytools.h"
  37 #include "cityturn.h"           /* city_repair_size() */
  38 #include "maphand.h"
  39 #include "plrhand.h"
  40 #include "srv_main.h"
  41 #include "unittools.h"
  42
  43 #include "sanitycheck.h"
  44
  45
  46 #ifdef SANITY_CHECKING
  47
  48 #define SANITY_FAIL(format, ...) \
  49   fc_assert_fail(file, function, line, NULL, format, ## __VA_ARGS__)
  50
  51 #define SANITY_CHECK(check) \
  52   fc_assert_full(file, function, line, check, , NOLOGMSG, NOLOGMSG)
  53
  54 #define SANITY_CITY(_city, check)                                           \
  55   fc_assert_full(file, function, line, check, ,                             \
  56                  "(%4d, %4d) in \"%s\"[%d]", TILE_XY((_city)->tile),        \
  57                  city_name_get(_city), city_size_get(_city))
  58
  59 #define SANITY_TERRAIN(_tile, check)                                        \
  60   fc_assert_full(file, function, line, check, ,                             \
  61                  "(%4d, %4d) at \"%s\"", TILE_XY(_tile),                    \
  62                  terrain_rule_name(tile_terrain(_tile)))
  63
  64 #define SANITY_TILE(_tile, check)                                           \
  65   do {                                                                      \
  66     struct city *_tile##_city = tile_city(_tile);                           \
  67     if (NULL != _tile##_city) {                                             \
  68       SANITY_CITY(_tile##_city, check);                                     \
  69     } else {                                                                \
  70       SANITY_TERRAIN(_tile, check);                                         \
  71     }                                                                       \
  72   } while(0)
  73
  74 static void check_city_feelings(const struct city *pcity, const char *file,
  75                                 const char *function, int line);
  76
  77 /**************************************************************************
  78   Sanity checking on map (tile) specials.
  79 **************************************************************************/
  80 static void check_specials(const char *file, const char *function, int line)
  81 {
  82   whole_map_iterate(ptile) {
  83     const struct terrain *pterrain = tile_terrain(ptile);
  84
  85     extra_type_iterate(pextra) {
  86       if (tile_has_extra(ptile, pextra)) {
  87         extra_deps_iterate(&(pextra->reqs), pdep) {
  88           SANITY_TILE(ptile, tile_has_extra(ptile, pdep));
  89         } extra_deps_iterate_end;
  90       }
  91     } extra_type_iterate_end;
  92
  93     extra_type_by_cause_iterate(EC_MINE, pextra) {
  94       if (tile_has_extra(ptile, pextra)) {
  95         SANITY_TILE(ptile, pterrain->mining_result == pterrain);
  96       }
  97     } extra_type_by_cause_iterate_end;
  98     extra_type_by_cause_iterate(EC_IRRIGATION, pextra) {
  99       if (tile_has_extra(ptile, pextra)) {
 100         SANITY_TILE(ptile, pterrain->irrigation_result == pterrain);
 101       }
 102     } extra_type_by_cause_iterate_end;
 103
 104     SANITY_TILE(ptile, terrain_index(pterrain) >= T_FIRST
 105                        && terrain_index(pterrain) < terrain_count());
 106   } whole_map_iterate_end;
 107 }
 108
 109 /**************************************************************************
 110   Sanity checking on fog-of-war (visibility, shared vision, etc.).
 111 **************************************************************************/
 112 static void check_fow(const char *file, const char *function, int line)
 113 {
 114   if (!game_was_started()) {
 115     /* The private map of the players is only allocated at game start. */
 116     return;
 117   }
 118
 119   whole_map_iterate(ptile) {
 120     players_iterate(pplayer) {
 121       struct player_tile *plr_tile = map_get_player_tile(ptile, pplayer);
 122
 123       vision_layer_iterate(v) {
 124         /* underflow of unsigned int */
 125         SANITY_TILE(ptile, plr_tile->seen_count[v] < 30000);
 126         SANITY_TILE(ptile, plr_tile->own_seen[v] < 30000);
 127         SANITY_TILE(ptile, plr_tile->own_seen[v] <= plr_tile->seen_count[v]);
 128       } vision_layer_iterate_end;
 129
 130       /* Lots of server bits depend on this. */
 131       SANITY_TILE(ptile, plr_tile->seen_count[V_INVIS]
 132                    <= plr_tile->seen_count[V_MAIN]);
 133       SANITY_TILE(ptile, plr_tile->own_seen[V_INVIS]
 134                    <= plr_tile->own_seen[V_MAIN]);
 135     } players_iterate_end;
 136   } whole_map_iterate_end;
 137
 138   SANITY_CHECK(game.government_during_revolution != NULL);
 139   SANITY_CHECK(game.government_during_revolution
 140                == government_by_number(game.info.government_during_revolution_id));
 141 }
 142
 143 /**************************************************************************
 144   Miscellaneous sanity checks.
 145 **************************************************************************/
 146 static void check_misc(const char *file, const char *function, int line)
 147 {
 148   int nplayers = 0, nbarbs = 0;
 149
 150   /* Do not use player_slots_iterate as we want to check the index! */
 151   player_slots_iterate(pslot) {
 152     if (player_slot_is_used(pslot)) {
 153       if (is_barbarian(player_slot_get_player(pslot))) {
 154         nbarbs++;
 155       }
 156       nplayers++;
 157     }
 158   } player_slots_iterate_end;
 159
 160   SANITY_CHECK(nplayers == player_count());
 161   SANITY_CHECK(nbarbs == server.nbarbarians);
 162
 163   SANITY_CHECK(player_count() <= player_slot_count());
 164   SANITY_CHECK(team_count() <= MAX_NUM_TEAM_SLOTS);
 165   SANITY_CHECK(normal_player_count() <= game.server.max_players);
 166 }
 167
 168 /**************************************************************************
 169   Sanity checks on the map itself.  See also check_specials.
 170 **************************************************************************/
 171 static void check_map(const char *file, const char *function, int line)
 172 {
 173   whole_map_iterate(ptile) {
 174     struct city *pcity = tile_city(ptile);
 175     int cont = tile_continent(ptile);
 176
 177     CHECK_INDEX(tile_index(ptile));
 178
 179     if (NULL != pcity) {
 180       SANITY_TILE(ptile, same_pos(pcity->tile, ptile));
 181       if (BORDERS_DISABLED != game.info.borders) {
 182         SANITY_TILE(ptile, tile_owner(ptile) != NULL);
 183       }
 184     }
 185
 186     if (is_ocean_tile(ptile)) {
 187       SANITY_TILE(ptile, cont < 0);
 188       adjc_iterate(ptile, tile1) {
 189         if (is_ocean_tile(tile1)) {
 190           SANITY_TILE(ptile, tile_continent(tile1) == cont);
 191         }
 192       } adjc_iterate_end;
 193     } else {
 194       SANITY_TILE(ptile, cont > 0);
 195       adjc_iterate(ptile, tile1) {
 196         if (!is_ocean_tile(tile1)) {
 197           SANITY_TILE(ptile, tile_continent(tile1) == cont);
 198         }
 199       } adjc_iterate_end;
 200     }
 201
 202     unit_list_iterate(ptile->units, punit) {
 203       SANITY_TILE(ptile, same_pos(unit_tile(punit), ptile));
 204
 205       /* Check diplomatic status of stacked units. */
 206       unit_list_iterate(ptile->units, punit2) {
 207         SANITY_TILE(ptile, pplayers_allied(unit_owner(punit),
 208                                            unit_owner(punit2)));
 209       } unit_list_iterate_end;
 210       if (pcity) {
 211         SANITY_TILE(ptile, pplayers_allied(unit_owner(punit),
 212                                            city_owner(pcity)));
 213       }
 214     } unit_list_iterate_end;
 215   } whole_map_iterate_end;
 216 }
 217
 218 /**************************************************************************
 219   Verify that the city itself has sane values.
 220 **************************************************************************/
 221 static bool check_city_good(struct city *pcity, const char *file,
 222                             const char *function, int line)
 223 {
 224   struct player *pplayer = city_owner(pcity);
 225   struct tile *pcenter = city_tile(pcity);
 226
 227   if (NULL == pcenter) {
 228     /* Editor! */
 229     SANITY_FAIL("(----,----) city has no tile (skipping remaining tests), "
 230                 "at %s \"%s\"[%d]%s",
 231                 nation_rule_name(nation_of_player(pplayer)),
 232                 city_name_get(pcity), city_size_get(pcity),
 233                 "{city center}");
 234     return FALSE;
 235   }
 236
 237   SANITY_CITY(pcity, !terrain_has_flag(tile_terrain(pcenter), TER_NO_CITIES));
 238
 239   if (BORDERS_DISABLED != game.info.borders) {
 240     SANITY_CITY(pcity, NULL != tile_owner(pcenter));
 241   }
 242
 243   if (NULL != tile_owner(pcenter)) {
 244     if (tile_owner(pcenter) != pplayer) {
 245       SANITY_FAIL("(%4d,%4d) tile owned by %s, at %s \"%s\"[%d]%s",
 246                   TILE_XY(pcenter),
 247                   nation_rule_name(nation_of_player(tile_owner(pcenter))),
 248                   nation_rule_name(nation_of_player(pplayer)),
 249                   city_name_get(pcity), city_size_get(pcity),
 250                   "{city center}");
 251     }
 252   }
 253
 254   unit_list_iterate(pcity->units_supported, punit) {
 255     SANITY_CITY(pcity, punit->homecity == pcity->id);
 256     SANITY_CITY(pcity, unit_owner(punit) == pplayer);
 257   } unit_list_iterate_end;
 258
 259   city_built_iterate(pcity, pimprove) {
 260     if (is_small_wonder(pimprove)) {
 261       SANITY_CITY(pcity, city_from_small_wonder(pplayer, pimprove) == pcity);
 262     } else if (is_great_wonder(pimprove)) {
 263       SANITY_CITY(pcity, city_from_great_wonder(pimprove) == pcity);
 264     }
 265   } city_built_iterate_end;
 266
 267   return TRUE;
 268 }
 269
 270 /**************************************************************************
 271   Sanity check city size versus worker and specialist counts.
 272 **************************************************************************/
 273 static void check_city_size(struct city *pcity, const char *file,
 274                             const char *function, int line)
 275 {
 276   int delta;
 277   int citizen_count = 0;
 278   struct tile *pcenter = city_tile(pcity);
 279
 280   SANITY_CITY(pcity, city_size_get(pcity) >= 1);
 281
 282   city_tile_iterate_skip_free_worked(city_map_radius_sq_get(pcity), pcenter,
 283                                   ptile, _index, _x, _y) {
 284     if (tile_worked(ptile) == pcity) {
 285       citizen_count++;
 286     }
 287   } city_tile_iterate_skip_free_worked_end;
 288
 289   citizen_count += city_specialists(pcity);
 290   delta = city_size_get(pcity) - citizen_count;
 291   if (0 != delta) {
 292     SANITY_FAIL("(%4d,%4d) %d citizens not equal [size], "
 293                 "repairing \"%s\"[%d]", TILE_XY(pcity->tile),
 294                 citizen_count, city_name_get(pcity), city_size_get(pcity));
 295
 296     citylog_map_workers(LOG_DEBUG, pcity);
 297     log_debug("[%s (%d)] specialists: %d", city_name_get(pcity), pcity->id,
 298               city_specialists(pcity));
 299
 300     city_repair_size(pcity, delta);
 301     city_refresh_from_main_map(pcity, NULL);
 302   }
 303 }
 304
 305 /**************************************************************************
 306   Verify that the number of people with feelings + specialists equal
 307   city size.
 308 **************************************************************************/
 309 static void check_city_feelings(const struct city *pcity, const char *file,
 310                                 const char *function, int line)
 311 {
 312   int feel;
 313   int spe = city_specialists(pcity);
 314
 315   for (feel = FEELING_BASE; feel < FEELING_LAST; feel++) {
 316     int sum = 0;
 317     int ccategory;
 318
 319     for (ccategory = CITIZEN_HAPPY; ccategory < CITIZEN_LAST; ccategory++) {
 320       sum += pcity->feel[ccategory][feel];
 321     }
 322
 323     /* While loading savegame, we want to check sanity of values read from the
 324      * savegame despite the fact that city workers_frozen level of the city
 325      * is above zero -> can't limit sanitycheck callpoints by that. Instead
 326      * we check even more relevant needs_arrange. */
 327     SANITY_CITY(pcity, !pcity->server.needs_arrange);
 328
 329     SANITY_CITY(pcity, city_size_get(pcity) - spe == sum);
 330   }
 331 }
 332
 333 /**************************************************************************
 334   Verify that the city has sane values.
 335 **************************************************************************/
 336 void real_sanity_check_city(struct city *pcity, const char *file,
 337                             const char *function, int line)
 338 {
 339   if (check_city_good(pcity, file, function, line)) {
 340     check_city_size(pcity, file, function, line);
 341     check_city_feelings(pcity, file, function, line);
 342   }
 343 }
 344
 345 /**************************************************************************
 346   Sanity checks on all cities in the world.
 347 **************************************************************************/
 348 static void check_cities(const char *file, const char *function, int line)
 349 {
 350   players_iterate(pplayer) {
 351     city_list_iterate(pplayer->cities, pcity) {
 352       SANITY_CITY(pcity, city_owner(pcity) == pplayer);
 353
 354       real_sanity_check_city(pcity, file, function, line);
 355     } city_list_iterate_end;
 356   } players_iterate_end;
 357 }
 358
 359 /**************************************************************************
 360   Sanity checks on all units in the world.
 361 **************************************************************************/
 362 static void check_units(const char *file, const char *function, int line)
 363 {
 364   players_iterate(pplayer) {
 365     unit_list_iterate(pplayer->units, punit) {
 366       struct tile *ptile = unit_tile(punit);
 367       struct terrain *pterr = tile_terrain(ptile);
 368       struct city *pcity;
 369       struct city *phome;
 370       struct unit *ptrans = unit_transport_get(punit);
 371
 372       SANITY_CHECK(unit_owner(punit) == pplayer);
 373
 374       if (IDENTITY_NUMBER_ZERO != punit->homecity) {
 375         SANITY_CHECK(phome = player_city_by_number(pplayer,
 376                                                    punit->homecity));
 377         if (phome) {
 378           SANITY_CHECK(city_owner(phome) == pplayer);
 379         }
 380       }
 381
 382       /* Unit in the correct player list? */
 383       SANITY_CHECK(player_unit_by_number(unit_owner(punit),
 384                                          punit->id) != NULL);
 385
 386       if (!can_unit_continue_current_activity(punit)) {
 387         SANITY_FAIL("(%4d,%4d) %s has activity %s, "
 388                     "but it can't continue at %s",
 389                     TILE_XY(ptile), unit_rule_name(punit),
 390                     get_activity_text(punit->activity),
 391                     tile_get_info_text(ptile, TRUE, 0));
 392       }
 393
 394       if (activity_requires_target(punit->activity)
 395           && (punit->activity != ACTIVITY_IRRIGATE || pterr->irrigation_result == pterr)
 396           && (punit->activity != ACTIVITY_MINE || pterr->mining_result == pterr)) {
 397         SANITY_CHECK(punit->activity_target != NULL);
 398       }
 399
 400       pcity = tile_city(ptile);
 401       if (pcity) {
 402         SANITY_CHECK(pplayers_allied(city_owner(pcity), pplayer));
 403       }
 404
 405       SANITY_CHECK(punit->moves_left >= 0);
 406       SANITY_CHECK(punit->hp > 0);
 407
 408       /* Check for ground units in the ocean. */
 409       SANITY_CHECK(can_unit_exist_at_tile(punit, ptile) || ptrans != NULL);
 410
 411       /* Check for over-full transports. */
 412       SANITY_CHECK(get_transporter_occupancy(punit)
 413                    <= get_transporter_capacity(punit));
 414
 415       /* Check transporter. This should be last as the pointer ptrans will
 416        * be modified. */
 417       if (ptrans != NULL) {
 418         struct unit *plevel = punit;
 419         int level = 0;
 420
 421         /* Make sure the transporter is on the tile. */
 422         SANITY_CHECK(same_pos(unit_tile(punit), unit_tile(ptrans)));
 423
 424         /* Can punit be cargo for its transporter? */
 425         SANITY_CHECK(unit_transport_check(punit, ptrans));
 426
 427         /* Check that the unit is listed as transported. */
 428         SANITY_CHECK(unit_list_search(unit_transport_cargo(ptrans),
 429                                       punit) != NULL);
 430
 431         /* Check the depth of the transportation. */
 432         while (ptrans) {
 433           struct unit_list *pcargos = unit_transport_cargo(ptrans);
 434
 435           SANITY_CHECK(pcargos != NULL);
 436           SANITY_CHECK(level < GAME_TRANSPORT_MAX_RECURSIVE);
 437
 438           /* Check for next level. */
 439           plevel = ptrans;
 440           ptrans = unit_transport_get(plevel);
 441           level++;
 442         }
 443
 444         /* Transporter capacity will be checked when transporter itself
 445          * is checked */
 446       }
 447
 448       /* Check that cargo is marked as transported with this unit */
 449       unit_list_iterate(unit_transport_cargo(punit), pcargo) {
 450         SANITY_CHECK(unit_transport_get(pcargo) == punit);
 451       } unit_list_iterate_end;
 452     } unit_list_iterate_end;
 453   } players_iterate_end;
 454 }
 455
 456 /**************************************************************************
 457   Sanity checks on all players.
 458 **************************************************************************/
 459 static void check_players(const char *file, const char *function, int line)
 460 {
 461   players_iterate(pplayer) {
 462     int found_palace = 0;
 463
 464     if (!pplayer->is_alive) {
 465       /* Dead players' units and cities are disbanded in kill_player(). */
 466       SANITY_CHECK(unit_list_size(pplayer->units) == 0);
 467       SANITY_CHECK(city_list_size(pplayer->cities) == 0);
 468
 469       continue;
 470     }
 471
 472     SANITY_CHECK(pplayer->server.adv != NULL);
 473     SANITY_CHECK(!pplayer->nation || pplayer->nation->player == pplayer);
 474     SANITY_CHECK(player_list_search(team_members(pplayer->team), pplayer));
 475
 476     SANITY_CHECK(!(city_list_size(pplayer->cities) > 0
 477                    && !pplayer->server.got_first_city));
 478
 479     city_list_iterate(pplayer->cities, pcity) {
 480       if (is_capital(pcity)) {
 481         found_palace++;
 482       }
 483       SANITY_CITY(pcity, found_palace <= 1);
 484     } city_list_iterate_end;
 485
 486     players_iterate(pplayer2) {
 487       struct player_diplstate *state1, *state2;
 488
 489       if (pplayer2 == pplayer) {
 490         break; /* Do diplomatic sanity check only once per player couple. */
 491       }
 492
 493       state1 = player_diplstate_get(pplayer, pplayer2);
 494       state2 = player_diplstate_get(pplayer2, pplayer);
 495       SANITY_CHECK(state1->type == state2->type);
 496       SANITY_CHECK(state1->max_state == state2->max_state);
 497       if (state1->type == DS_CEASEFIRE
 498           || state1->type == DS_ARMISTICE) {
 499         SANITY_CHECK(state1->turns_left == state2->turns_left);
 500       }
 501       if (state1->type == DS_TEAM) {
 502         SANITY_CHECK(players_on_same_team(pplayer, pplayer2));
 503         SANITY_CHECK(player_has_real_embassy(pplayer, pplayer2));
 504         SANITY_CHECK(player_has_real_embassy(pplayer2, pplayer));
 505         SANITY_CHECK(really_gives_vision(pplayer, pplayer2));
 506         SANITY_CHECK(really_gives_vision(pplayer2, pplayer));
 507       }
 508       if (pplayer->is_alive
 509           && pplayer2->is_alive
 510           && pplayers_allied(pplayer, pplayer2)) {
 511         enum dipl_reason allied_players_can_be_allied =
 512           pplayer_can_make_treaty(pplayer, pplayer2, DS_ALLIANCE);
 513         SANITY_CHECK(allied_players_can_be_allied
 514                      != DIPL_ALLIANCE_PROBLEM_US);
 515         SANITY_CHECK(allied_players_can_be_allied
 516                      != DIPL_ALLIANCE_PROBLEM_THEM);
 517       }
 518     } players_iterate_end;
 519
 520     if (pplayer->revolution_finishes == -1) {
 521       if (government_of_player(pplayer) == game.government_during_revolution) {
 522         SANITY_FAIL("%s government is anarchy, but does not finish!",
 523                     nation_rule_name(nation_of_player(pplayer)));
 524       }
 525       SANITY_CHECK(government_of_player(pplayer) != game.government_during_revolution);
 526     } else if (pplayer->revolution_finishes > game.info.turn) {
 527       SANITY_CHECK(government_of_player(pplayer) == game.government_during_revolution);
 528     } else {
 529       /* Things may vary in this case depending on when the sanity_check
 530        * call is made.  No better check is possible. */
 531     }
 532
 533     /* Dying players shouldn't be left around.  But they are. */
 534     SANITY_CHECK(!BV_ISSET(pplayer->server.status, PSTATUS_DYING));
 535   } players_iterate_end;
 536
 537   nations_iterate(pnation) {
 538     SANITY_CHECK(!pnation->player || pnation->player->nation == pnation);
 539   } nations_iterate_end;
 540
 541   teams_iterate(pteam) {
 542     player_list_iterate(team_members(pteam), pplayer) {
 543       SANITY_CHECK(pplayer->team == pteam);
 544     } player_list_iterate_end;
 545   } teams_iterate_end;
 546 }
 547
 548 /****************************************************************************
 549   Sanity checking on teams.
 550 ****************************************************************************/
 551 static void check_teams(const char *file, const char *function, int line)
 552 {
 553   int count[MAX_NUM_TEAM_SLOTS];
 554
 555   memset(count, 0, sizeof(count));
 556   players_iterate(pplayer) {
 557     /* For the moment, all players have teams. */
 558     SANITY_CHECK(pplayer->team != NULL);
 559     if (pplayer->team) {
 560       count[team_index(pplayer->team)]++;
 561     }
 562   } players_iterate_end;
 563
 564   team_slots_iterate(tslot) {
 565     if (team_slot_is_used(tslot)) {
 566       struct team *pteam = team_slot_get_team(tslot);
 567       fc_assert_exit(pteam);
 568       SANITY_CHECK(player_list_size(team_members(pteam))
 569                    == count[team_slot_index(tslot)]);
 570     }
 571   } team_slots_iterate_end;
 572 }
 573
 574 /****************************************************************************
 575   Sanity checks on all players.
 576 ****************************************************************************/
 577 static void
 578 check_researches(const char *file, const char *function, int line)
 579 {
 580   researches_iterate(presearch) {
 581     SANITY_CHECK(S_S_RUNNING != server_state()
 582                  || A_UNSET == presearch->researching
 583                  || is_future_tech(presearch->researching)
 584                  || (A_NONE != presearch->researching
 585                      && valid_advance_by_number(presearch->researching)));
 586     SANITY_CHECK(A_UNSET == presearch->tech_goal
 587                  || (A_NONE != presearch->tech_goal
 588                      && valid_advance_by_number(presearch->tech_goal)));
 589   } researches_iterate_end;
 590 }
 591
 592 /**************************************************************************
 593   Sanity checking on connections.
 594 **************************************************************************/
 595 static void check_connections(const char *file, const char *function,
 596                               int line)
 597 {
 598   /* est_connections is a subset of all_connections */
 599   SANITY_CHECK(conn_list_size(game.all_connections)
 600                >= conn_list_size(game.est_connections));
 601 }
 602
 603 /**************************************************************************
 604   Do sanity checks on the server state.  Call this once per turn or
 605   whenever you feel like it.
 606
 607   But be careful, calling it too much would make the server slow down.  And
 608   at some times the server isn't supposed to be in a sane state so you
 609   can't call it in the middle of an operation that is supposed to be
 610   atomic.
 611 **************************************************************************/
 612 void real_sanity_check(const char *file, const char *function, int line)
 613 {
 614   if (!map_is_empty()) {
 615     /* Don't sanity-check the map if it hasn't been created yet (this
 616      * happens when loading scenarios). */
 617     check_specials(file, function, line);
 618     check_map(file, function, line);
 619     check_cities(file, function, line);
 620     check_units(file, function, line);
 621     check_fow(file, function, line);
 622   }
 623   check_misc(file, function, line);
 624   check_players(file, function, line);
 625   check_teams(file, function, line);
 626   check_researches(file, function, line);
 627   check_connections(file, function, line);
 628 }
 629
 630 /*****************************************************************************
 631   Verify that the tile has sane values. This should be called after the
 632   terrain is changed.
 633 *****************************************************************************/
 634 void real_sanity_check_tile(struct tile *ptile, const char *file,
 635                             const char *function, int line)
 636 {
 637   SANITY_CHECK(ptile != NULL);
 638   SANITY_CHECK(ptile->terrain != NULL);
 639
 640   unit_list_iterate(ptile->units, punit) {
 641     /* Check if the units can survive on the tile (terrain). Here only the
 642      * 'easy' test if the unit is transported is done. A complete check is
 643      * done by check_units() in real_sanity_check(). */
 644     if (!can_unit_exist_at_tile(punit, ptile)
 645         && !unit_transported(punit)) {
 646       SANITY_FAIL("(%4d,%4d) %s can't survive on %s", TILE_XY(ptile),
 647                   unit_rule_name(punit), tile_get_info_text(ptile, TRUE, 0));
 648     }
 649   } unit_list_iterate_end;
 650 }
 651
 652 #endif /* SANITY_CHECKING */