server/barbarian.c

   1 /***********************************************************************
   2  Freeciv - Copyright (C) 2003 - 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   Functions for creating barbarians in huts, land and sea
  16   Started by Jerzy Klek <jekl@altavista.net>
  17   with more ideas from Falk Hueffner
  18 ***********************************************************************/
  19
  20 #ifdef HAVE_CONFIG_H
  21 #include <fc_config.h>
  22 #endif
  23
  24 #include <stdio.h>
  25 #include <stdlib.h>
  26 #include <string.h>
  27
  28 /* utility */
  29 #include "fcintl.h"
  30 #include "log.h"
  31 #include "rand.h"
  32 #include "support.h"
  33
  34 /* common */
  35 #include "effects.h"
  36 #include "events.h"
  37 #include "game.h"
  38 #include "government.h"
  39 #include "map.h"
  40 #include "movement.h"
  41 #include "nation.h"
  42 #include "research.h"
  43 #include "tech.h"
  44 #include "terrain.h"
  45 #include "unitlist.h"
  46
  47 /* server */
  48 #include "aiiface.h"
  49 #include "citytools.h"
  50 #include "gamehand.h"
  51 #include "maphand.h"
  52 #include "notify.h"
  53 #include "plrhand.h"
  54 #include "srv_main.h"
  55 #include "stdinhand.h"
  56 #include "techtools.h"
  57 #include "unithand.h"
  58 #include "unittools.h"
  59
  60 /* server/advisors */
  61 #include "advdata.h"
  62
  63 /* ai */
  64 #include "difficulty.h"
  65
  66 #include "barbarian.h"
  67
  68 #define BARBARIAN_INITIAL_VISION_RADIUS 3
  69 #define BARBARIAN_INITIAL_VISION_RADIUS_SQ 9
  70
  71 /**************************************************************************
  72   Is player a land barbarian?
  73 **************************************************************************/
  74 bool is_land_barbarian(struct player *pplayer)
  75 {
  76   return (pplayer->ai_common.barbarian_type == LAND_BARBARIAN);
  77 }
  78
  79 /**************************************************************************
  80   Is player a sea barbarian?
  81 **************************************************************************/
  82 bool is_sea_barbarian(struct player *pplayer)
  83 {
  84   return (pplayer->ai_common.barbarian_type == SEA_BARBARIAN);
  85 }
  86
  87 /**************************************************************************
  88   Creates the land/sea barbarian player and inits some stuff. If
  89   barbarian player already exists, return player pointer. If barbarians
  90   are dead, revive them with a new leader :-)
  91
  92   Dead barbarians forget the map and lose the money.
  93 **************************************************************************/
  94 struct player *create_barbarian_player(enum barbarian_type type)
  95 {
  96   struct player *barbarians;
  97   struct nation_type *nation;
  98   struct research *presearch;
  99
 100   players_iterate(old_barbs) {
 101     if ((type == LAND_BARBARIAN && is_land_barbarian(old_barbs))
 102         || (type == SEA_BARBARIAN && is_sea_barbarian(old_barbs))) {
 103       if (!old_barbs->is_alive) {
 104         old_barbs->economic.gold = 0;
 105         old_barbs->is_alive = TRUE;
 106         player_status_reset(old_barbs);
 107
 108         /* Free old name so pick_random_player_name() can select it again.
 109          * This is needed in case ruleset defines just one leader for
 110          * barbarian nation. */
 111         old_barbs->name[0] = '\0';
 112         server_player_set_name(old_barbs,
 113             pick_random_player_name(nation_of_player(old_barbs)));
 114         sz_strlcpy(old_barbs->username, _(ANON_USER_NAME));
 115         old_barbs->unassigned_user = TRUE;
 116         /* I need to make them to forget the map, I think */
 117         whole_map_iterate(ptile) {
 118           map_clear_known(ptile, old_barbs);
 119         } whole_map_iterate_end;
 120       }
 121       old_barbs->economic.gold += 100;  /* New leader, new money */
 122
 123       return old_barbs;
 124     }
 125   } players_iterate_end;
 126
 127   /* make a new player, or not */
 128   barbarians = server_create_player(-1, default_ai_type_name(), NULL, FALSE);
 129   if (!barbarians) {
 130     return NULL;
 131   }
 132   server_player_init(barbarians, TRUE, TRUE);
 133
 134   nation = pick_a_nation(NULL, FALSE, FALSE, type);
 135
 136   /* Ruleset loading time checks should guarantee that there always is
 137      suitable nation available */
 138   fc_assert(nation != NULL);
 139
 140   player_nation_defaults(barbarians, nation, TRUE);
 141   if (game_was_started()) {
 142     /* Find a color for the new player. */
 143     assign_player_colors();
 144   }
 145
 146   server.nbarbarians++;
 147
 148   sz_strlcpy(barbarians->username, _(ANON_USER_NAME));
 149   barbarians->unassigned_user = TRUE;
 150   barbarians->is_connected = FALSE;
 151   barbarians->government = init_government_of_nation(nation);
 152   fc_assert(barbarians->revolution_finishes < 0);
 153   barbarians->server.got_first_city = FALSE;
 154   barbarians->economic.gold = 100;
 155
 156   barbarians->phase_done = TRUE;
 157
 158   /* Do the ai */
 159   barbarians->ai_controlled = TRUE;
 160   barbarians->ai_common.barbarian_type = type;
 161   set_ai_level_directer(barbarians, game.info.skill_level);
 162
 163   presearch = research_get(barbarians);
 164   init_tech(presearch, TRUE);
 165   give_initial_techs(presearch, 0);
 166
 167   /* Ensure that we are at war with everyone else */
 168   players_iterate(pplayer) {
 169     if (pplayer != barbarians) {
 170       player_diplstate_get(pplayer, barbarians)->type = DS_WAR;
 171       player_diplstate_get(barbarians, pplayer)->type = DS_WAR;
 172     }
 173   } players_iterate_end;
 174
 175   CALL_PLR_AI_FUNC(gained_control, barbarians, barbarians);
 176
 177   log_verbose("Created barbarian %s, player %d", player_name(barbarians),
 178               player_number(barbarians));
 179   notify_player(NULL, NULL, E_UPRISING, ftc_server,
 180                 _("%s gain a leader by the name %s. Dangerous "
 181                   "times may lie ahead."),
 182                 nation_plural_for_player(barbarians),
 183                 player_name(barbarians));
 184
 185   send_player_all_c(barbarians, NULL);
 186   /* Send research info after player info, else the client will complain
 187    * about invalid team. */
 188   send_research_info(presearch, NULL);
 189
 190   return barbarians;
 191 }
 192
 193 /**************************************************************************
 194   (Re)initialize direction checked status array based on terrain class.
 195 **************************************************************************/
 196 static void init_dir_checked_status(bool *checked,
 197                                     enum terrain_class *terrainc,
 198                                     enum terrain_class tclass)
 199 {
 200   int dir;
 201
 202   for (dir = 0; dir < 8; dir++) {
 203     if (terrainc[dir] == tclass) {
 204       checked[dir] = FALSE;
 205     } else {
 206       checked[dir] = TRUE;
 207     }
 208   }
 209 }
 210
 211 /**************************************************************************
 212   Return random directory from not yet checked ones.
 213 **************************************************************************/
 214 static int random_unchecked_direction(int possibilities, const bool *checked)
 215 {
 216   int j = -1;
 217   int i;
 218
 219   int num = fc_rand(possibilities);
 220   for (i = 0; i <= num; i++) {
 221     j++;
 222     while (checked[j]) {
 223       j++;
 224       fc_assert(j < 8);
 225     }
 226   }
 227
 228   return j;
 229 }
 230
 231 /**************************************************************************
 232   Unleash barbarians means give barbarian player some units and move them
 233   out of the hut, unless there's no place to go.
 234
 235   Barbarian unit deployment algorithm: If enough free land around, deploy
 236   on land, if not enough land but some sea free, load some of them on
 237   boats, otherwise (not much land and no sea) kill enemy unit and stay in
 238   a village. The return value indicates if the explorer survived entering
 239   the vilage.
 240 **************************************************************************/
 241 bool unleash_barbarians(struct tile *ptile)
 242 {
 243   struct player *barbarians;
 244   int unit_cnt;
 245   int i;
 246   bool alive = TRUE;     /* explorer survived */
 247   enum terrain_class terrainc[8];
 248   struct tile *dir_tiles[8];
 249   int land_tiles = 0;
 250   int ocean_tiles = 0;
 251   bool checked[8];
 252   int checked_count;
 253   int dir;
 254   bool barbarian_stays = FALSE;
 255
 256   /* FIXME: When there is no L_BARBARIAN unit,
 257    *        but L_BARBARIAN_TECH is already available,
 258    *        we should unleash those.
 259    *        Doesn't affect any ruleset I'm aware of. */
 260   if (BARBS_DISABLED == game.server.barbarianrate
 261       || game.info.turn < game.server.onsetbarbarian
 262       || num_role_units(L_BARBARIAN) == 0) {
 263     unit_list_iterate_safe((ptile)->units, punit) {
 264       wipe_unit(punit, ULR_BARB_UNLEASH, NULL);
 265     } unit_list_iterate_safe_end;
 266     return FALSE;
 267   }
 268
 269   barbarians = create_barbarian_player(LAND_BARBARIAN);
 270   if (!barbarians) {
 271     return FALSE;
 272   }
 273
 274   adv_data_phase_init(barbarians, TRUE);
 275   CALL_PLR_AI_FUNC(phase_begin, barbarians, barbarians, TRUE);
 276
 277   unit_cnt = 3 + fc_rand(4);
 278   for (i = 0; i < unit_cnt; i++) {
 279     struct unit_type *punittype
 280       = find_a_unit_type(L_BARBARIAN, L_BARBARIAN_TECH);
 281
 282     /* If unit cannot live on this tile, we just don't create one.
 283      * Maybe find_a_unit_type() should take tile parameter, so
 284      * we could get suitable unit if one exist. */
 285     if (is_native_tile(punittype, ptile)) {
 286       struct unit *barb_unit;
 287
 288       barb_unit = create_unit(barbarians, ptile, punittype, 0, 0, -1);
 289       log_debug("Created barbarian unit %s", utype_rule_name(punittype));
 290       send_unit_info(NULL, barb_unit);
 291     }
 292   }
 293
 294   /* Get information about surrounding terrains in terrain class level.
 295    * Only needed if we consider moving units away to random directions. */
 296   for (dir = 0; dir < 8; dir++) {
 297     dir_tiles[dir] = mapstep(ptile, dir);
 298     if (dir_tiles[dir] == NULL) {
 299       terrainc[dir] = terrain_class_invalid();
 300     } else if (!is_non_allied_unit_tile(dir_tiles[dir], barbarians)) {
 301       if (is_ocean_tile(dir_tiles[dir])) {
 302         terrainc[dir] = TC_OCEAN;
 303         ocean_tiles++;
 304       } else {
 305         terrainc[dir] = TC_LAND;
 306         land_tiles++;
 307       }
 308     } else {
 309       terrainc[dir] = terrain_class_invalid();
 310     }
 311   }
 312
 313   if (land_tiles >= 3) {
 314     /* Enough land, scatter guys around */
 315     unit_list_iterate_safe((ptile)->units, punit2) {
 316       if (unit_owner(punit2) == barbarians) {
 317         bool dest_found = FALSE;
 318
 319         /* Initialize checked status for checking free land tiles */
 320         init_dir_checked_status(checked, terrainc, TC_LAND);
 321
 322         /* Search tile to move to */
 323         for (checked_count = 0; !dest_found && checked_count < land_tiles;
 324              checked_count++) {
 325           int rdir = random_unchecked_direction(land_tiles - checked_count, checked);
 326
 327           if (unit_can_move_to_tile(punit2, dir_tiles[rdir], TRUE)) {
 328             /* Move */
 329             (void) unit_move_handling(punit2, dir_tiles[rdir],
 330                                       TRUE, TRUE, NULL);
 331             log_debug("Moved barbarian unit from (%d, %d) to (%d, %d)",
 332                       TILE_XY(ptile), TILE_XY(dir_tiles[rdir]));
 333             dest_found = TRUE;
 334           }
 335
 336           checked[rdir] = TRUE;
 337         }
 338         if (!dest_found) {
 339           /* This barbarian failed to move out of hut tile. */
 340           barbarian_stays = TRUE;
 341         }
 342       }
 343     } unit_list_iterate_safe_end;
 344
 345   } else {
 346     if (ocean_tiles > 0) {
 347       /* maybe it's an island, try to get on boats */
 348       struct tile *btile = NULL; /* Boat tile */
 349
 350       /* Initialize checked status for checking Ocean tiles */
 351       init_dir_checked_status(checked, terrainc, TC_OCEAN);
 352
 353       /* Search tile for boat. We always create just one boat. */
 354       for (checked_count = 0; btile == NULL && checked_count < ocean_tiles;
 355            checked_count++) {
 356         struct unit_type *boat;
 357         int rdir = random_unchecked_direction(ocean_tiles - checked_count, checked);
 358
 359         boat = find_a_unit_type(L_BARBARIAN_BOAT, -1);
 360         if (is_native_tile(boat, dir_tiles[rdir])) {
 361           (void) create_unit(barbarians, dir_tiles[rdir], boat, 0, 0, -1);
 362           btile = dir_tiles[rdir];
 363         }
 364
 365         checked[rdir] = TRUE;
 366       }
 367
 368       if (btile) {
 369         /* We do have a boat. Try to get everybody in */
 370         unit_list_iterate_safe((ptile)->units, punit2) {
 371           if (unit_owner(punit2) == barbarians) {
 372             if (unit_can_move_to_tile(punit2, btile, TRUE)) {
 373               /* Load */
 374               (void) unit_move_handling(punit2, btile, TRUE, TRUE, NULL);
 375             }
 376           }
 377         } unit_list_iterate_safe_end;
 378       }
 379
 380       /* Move rest of the barbarians to random land tiles */
 381       unit_list_iterate_safe((ptile)->units, punit2) {
 382         if (unit_owner(punit2) == barbarians) {
 383           bool dest_found = FALSE;
 384
 385           /* Initialize checked status for checking Land tiles */
 386           init_dir_checked_status(checked, terrainc, TC_LAND);
 387
 388           /* Search tile to move to */
 389           for (checked_count = 0; !dest_found && checked_count < land_tiles;
 390                checked_count++) {
 391             int rdir;
 392             rdir = random_unchecked_direction(land_tiles - checked_count, checked);
 393
 394             if (unit_can_move_to_tile(punit2, dir_tiles[rdir], TRUE)) {
 395               /* Move */
 396               (void) unit_move_handling(punit2, dir_tiles[rdir],
 397                                         TRUE, TRUE, NULL);
 398               dest_found = TRUE;
 399             }
 400
 401             checked[rdir] = TRUE;
 402           }
 403           if (!dest_found) {
 404             /* This barbarian failed to move out of hut tile. */
 405             barbarian_stays = TRUE;
 406           }
 407         }
 408       } unit_list_iterate_safe_end;
 409     } else {
 410       /* The village is surrounded! Barbarians cannot leave. */
 411       barbarian_stays = TRUE;
 412     }
 413   }
 414
 415   if (barbarian_stays) {
 416     /* There's barbarian in this village! Kill the explorer. */
 417     unit_list_iterate_safe((ptile)->units, punit2) {
 418       if (unit_owner(punit2) != barbarians) {
 419         wipe_unit(punit2, ULR_BARB_UNLEASH, NULL);
 420         alive = FALSE;
 421       } else {
 422         send_unit_info(NULL, punit2);
 423       }
 424     } unit_list_iterate_safe_end;
 425   }
 426
 427   /* FIXME: I don't know if this is needed */
 428   if (ptile) {
 429     map_show_circle(barbarians, ptile, BARBARIAN_INITIAL_VISION_RADIUS_SQ);
 430   }
 431
 432   return alive;
 433 }
 434
 435 /**************************************************************************
 436   Is sea not further than a couple of tiles away from land?
 437 **************************************************************************/
 438 static bool is_near_land(struct tile *tile0)
 439 {
 440   square_iterate(tile0, 4, ptile) {
 441     if (!is_ocean_tile(ptile)) {
 442       return TRUE;
 443     }
 444   } square_iterate_end;
 445
 446   return FALSE;
 447 }
 448
 449 /**************************************************************************
 450   Return this or a neighbouring tile that is free of any units
 451 **************************************************************************/
 452 static struct tile *find_empty_tile_nearby(struct tile *ptile)
 453 {
 454   square_iterate(ptile, 1, tile1) {
 455     if (unit_list_size(tile1->units) == 0) {
 456       return tile1;
 457     }
 458   } square_iterate_end;
 459
 460   return NULL;
 461 }
 462
 463 /**************************************************************************
 464   The barbarians are summoned at a randomly chosen place if:
 465   1. It's not closer than MIN_UNREST_DIST and not further than
 466      MAX_UNREST_DIST from the nearest city. City owner is called 'victim'
 467      here.
 468   2. The place or a neighbouring tile must be empty to deploy the units.
 469   3. If it's the sea it shouldn't be far from the land. (questionable)
 470   4. Place must be known to the victim
 471   5. The uprising chance depends also on the victim empire size, its
 472      government (civil_war_chance) and barbarian difficulty level.
 473   6. The number of land units also depends slightly on victim's empire
 474      size and barbarian difficulty level.
 475   Q: The empire size is used so there are no uprisings in the beginning
 476      of the game (year is not good as it can be customized), but it seems
 477      a bit unjust if someone is always small. So maybe it should rather
 478      be an average number of cities (all cities/player num)? Depending
 479      on the victim government type is also questionable.
 480 **************************************************************************/
 481 static void try_summon_barbarians(void)
 482 {
 483   struct tile *ptile, *utile;
 484   int i, dist;
 485   int uprise;
 486   struct city *pc;
 487   struct player *barbarians, *victim;
 488   struct unit_type *leader_type;
 489   int barb_count, really_created = 0;
 490   bool hut_present = FALSE;
 491   int city_count;
 492   int city_max;
 493
 494   /* We attempt the summons on a particular, random position.  If this is
 495    * an invalid position then the summons simply fails this time.  This means
 496    * that a particular tile's chance of being summoned on is independent of
 497    * all the other tiles on the map - which is essential for balanced
 498    * gameplay. */
 499   ptile = rand_map_pos();
 500
 501   if (terrain_has_flag(tile_terrain(ptile), TER_NO_BARBS)) {
 502     return;
 503   }
 504
 505   if (!(pc = find_closest_city(ptile, NULL, NULL, FALSE, FALSE, FALSE, FALSE,
 506                                FALSE, NULL))) {
 507     /* any city */
 508     return;
 509   }
 510
 511   victim = city_owner(pc);
 512
 513   dist = real_map_distance(ptile, pc->tile);
 514   log_debug("Closest city (to %d,%d) is %s (at %d,%d) distance %d.",
 515             TILE_XY(ptile), city_name_get(pc), TILE_XY(pc->tile), dist);
 516   if (dist > MAX_UNREST_DIST || dist < MIN_UNREST_DIST) {
 517     return;
 518   }
 519
 520   /* I think Sea Raiders can come out of unknown sea territory */
 521   if (!(utile = find_empty_tile_nearby(ptile))
 522       || (!map_is_known(utile, victim)
 523           && !is_ocean_tile(utile))
 524       || !is_near_land(utile)) {
 525     return;
 526   }
 527
 528   fc_assert(1 < game.server.barbarianrate);
 529
 530   /* do not harass small civs - in practice: do not uprise at the beginning */
 531   if ((int)fc_rand(30) + 1 >
 532       (int)city_list_size(victim->cities) * (game.server.barbarianrate - 1)
 533       || fc_rand(100) > get_player_bonus(victim, EFT_CIVIL_WAR_CHANCE)) {
 534     return;
 535   }
 536   log_debug("Barbarians are willing to fight");
 537
 538   /* Remove huts in place of uprising */
 539   extra_type_by_cause_iterate(EC_HUT, pextra) {
 540     if (tile_has_extra(utile, pextra)) {
 541       tile_extra_rm_apply(utile, pextra);
 542       hut_present = TRUE;
 543     }
 544   } extra_type_by_cause_iterate_end;
 545
 546   if (hut_present) {
 547     update_tile_knowledge(utile);
 548   }
 549
 550   city_count = city_list_size(victim->cities);
 551   city_max = UPRISE_CIV_SIZE;
 552   uprise = 1;
 553
 554   while (city_max <= city_count) {
 555     uprise++;
 556     city_max *= 1.2 + UPRISE_CIV_SIZE;
 557   }
 558
 559   barb_count = fc_rand(3) + uprise * game.server.barbarianrate;
 560   leader_type = get_role_unit(L_BARBARIAN_LEADER, 0);
 561
 562   if (!is_ocean_tile(utile)) {
 563     /* land (disembark) barbarians */
 564     barbarians = create_barbarian_player(LAND_BARBARIAN);
 565     if (!barbarians) {
 566       return;
 567     }
 568     for (i = 0; i < barb_count; i++) {
 569       struct unit_type *punittype
 570         = find_a_unit_type(L_BARBARIAN, L_BARBARIAN_TECH);
 571
 572       /* If unit cannot live on this tile, we just don't create one.
 573        * Maybe find_a_unit_type() should take tile parameter, so
 574        * we could get suitable unit if one exist. */
 575       if (is_native_tile(punittype, utile)) {
 576         (void) create_unit(barbarians, utile, punittype, 0, 0, -1);
 577         really_created++;
 578         log_debug("Created barbarian unit %s",utype_rule_name(punittype));
 579       }
 580     }
 581
 582     if (is_native_tile(leader_type, utile)) {
 583       (void) create_unit(barbarians, utile,
 584                          leader_type, 0, 0, -1);
 585       really_created++;
 586     }
 587   } else {                   /* sea raiders - their units will be veteran */
 588     struct unit *ptrans;
 589     struct unit_type *boat;
 590     bool miniphase;
 591
 592     barbarians = create_barbarian_player(SEA_BARBARIAN);
 593     if (!barbarians) {
 594       return;
 595     }
 596     /* Setup data phase if it's not already set up. Created ferries may
 597        need that data.
 598        We don't know if create_barbarian_player() above created completely
 599        new player or did it just return existing one. If it was existing
 600        one, phase has already been set up at turn begin and will be closed
 601        at turn end. If this is completely new player, we have to take care
 602        of both opening and closing the data phase. Return value of
 603        adv_data_phase_init() tells us if data phase was already initialized
 604        at turn beginning. */
 605     miniphase = adv_data_phase_init(barbarians, TRUE);
 606     if (miniphase) {
 607       CALL_PLR_AI_FUNC(phase_begin, barbarians, barbarians, TRUE);
 608     }
 609
 610     boat = find_a_unit_type(L_BARBARIAN_BOAT,-1);
 611
 612     if (is_native_tile(boat, utile)
 613         && (!utype_has_flag(boat, UTYF_TRIREME) || is_safe_ocean(utile))) {
 614       int cap;
 615
 616       ptrans = create_unit(barbarians, utile, boat, 0, 0, -1);
 617       really_created++;
 618       cap = get_transporter_capacity(ptrans);
 619
 620       /* Fill boat with barb_count barbarians at max, leave space for leader */
 621       for (i = 0; i < cap - 1 && i < barb_count; i++) {
 622         struct unit_type *barb
 623           = find_a_unit_type(L_BARBARIAN_SEA, L_BARBARIAN_SEA_TECH);
 624
 625         if (can_unit_type_transport(boat, utype_class(barb))) {
 626           (void) create_unit_full(barbarians, utile, barb, 0, 0, -1, -1,
 627                                   ptrans);
 628           really_created++;
 629           log_debug("Created barbarian unit %s", utype_rule_name(barb));
 630         }
 631       }
 632
 633       if (can_unit_type_transport(boat, utype_class(leader_type))) {
 634         (void) create_unit_full(barbarians, utile, leader_type, 0, 0,
 635                                 -1, -1, ptrans);
 636         really_created++;
 637       }
 638     }
 639
 640     if (miniphase) {
 641       CALL_PLR_AI_FUNC(phase_finished, barbarians, barbarians);
 642       adv_data_phase_done(barbarians);
 643     }
 644   }
 645
 646   if (really_created == 0) {
 647     /* No barbarians found suitable spot */
 648     return;
 649   }
 650
 651   /* Is this necessary?  create_unit_full already sends unit info. */
 652   unit_list_iterate(utile->units, punit2) {
 653     send_unit_info(NULL, punit2);
 654   } unit_list_iterate_end;
 655
 656   /* to let them know where to get you */
 657   map_show_circle(barbarians, utile, BARBARIAN_INITIAL_VISION_RADIUS_SQ);
 658   map_show_circle(barbarians, pc->tile, BARBARIAN_INITIAL_VISION_RADIUS_SQ);
 659
 660   /* There should probably be a different message about Sea Raiders */
 661   if (is_land_barbarian(barbarians)) {
 662     notify_player(victim, utile, E_UPRISING, ftc_server,
 663                   _("Native unrest near %s led by %s."),
 664                   city_link(pc),
 665                   player_name(barbarians));
 666   } else if (map_is_known_and_seen(utile, victim, V_MAIN)) {
 667     notify_player(victim, utile, E_UPRISING, ftc_server,
 668                   _("Sea raiders seen near %s!"),
 669                   city_link(pc));
 670   }
 671 }
 672
 673 /**************************************************************************
 674   Summon barbarians out of the blue. Try more times for more difficult
 675   levels - which means there can be more than one uprising in one year!
 676 **************************************************************************/
 677 void summon_barbarians(void)
 678 {
 679   int i, n;
 680
 681   if (BARBS_DISABLED == game.server.barbarianrate
 682       || BARBS_HUTS_ONLY == game.server.barbarianrate) {
 683     return;
 684   }
 685
 686   if (game.info.turn < game.server.onsetbarbarian) {
 687     return;
 688   }
 689
 690   n = map_num_tiles() / MAP_FACTOR;
 691   if (n == 0) {
 692     /* Allow barbarians on maps smaller than MAP_FACTOR */
 693     n = 1;
 694   }
 695
 696   for (i = 0; i < n * (game.server.barbarianrate - 1); i++) {
 697     try_summon_barbarians();
 698   }
 699 }