server/diplomats.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 #include <stdio.h>
  19
  20 /* utility */
  21 #include "bitvector.h"
  22 #include "fcintl.h"
  23 #include "log.h"
  24 #include "rand.h"
  25
  26 /* common */
  27 #include "base.h"
  28 #include "events.h"
  29 #include "game.h"
  30 #include "government.h"
  31 #include "map.h"
  32 #include "movement.h"
  33 #include "player.h"
  34 #include "research.h"
  35 #include "unitlist.h"
  36
  37 /* server */
  38 #include "actiontools.h"
  39 #include "aiiface.h"
  40 #include "citytools.h"
  41 #include "cityturn.h"
  42 #include "diplhand.h"
  43 #include "diplomats.h"
  44 #include "maphand.h"
  45 #include "notify.h"
  46 #include "plrhand.h"
  47 #include "techtools.h"
  48 #include "unithand.h"
  49 #include "unittools.h"
  50
  51 /* server/scripting */
  52 #include "script_server.h"
  53
  54 /****************************************************************************/
  55
  56 static void diplomat_charge_movement (struct unit *pdiplomat,
  57                                       struct tile *ptile);
  58 static bool diplomat_success_vs_defender(struct unit *patt, struct unit *pdef,
  59                                          struct tile *pdefender_tile);
  60 static bool diplomat_infiltrate_tile(struct player *pplayer,
  61                                      struct player *cplayer,
  62                                      const struct action *paction,
  63                                      struct unit *pdiplomat,
  64                                      struct unit *pvictim,
  65                                      struct tile *ptile);
  66 static bool diplomat_was_caught(struct player *act_player,
  67                                 struct unit *act_unit,
  68                                 struct city *tgt_city,
  69                                 struct player *tgt_player,
  70                                 const struct action *act);
  71 static void diplomat_escape(struct player *pplayer, struct unit *pdiplomat,
  72                             const struct city *pcity,
  73                             const struct action *paction);
  74 static void diplomat_escape_full(struct player *pplayer,
  75                                  struct unit *pdiplomat,
  76                                  bool city_related,
  77                                  struct tile *ptile,
  78                                  const char *vlink,
  79                                  const struct action *paction);
  80
  81 /******************************************************************************
  82   Poison a city's water supply.
  83
  84   - Check for infiltration success.  Our poisoner may not survive this.
  85   - If successful, reduces population by one point.
  86
  87   - The poisoner may be captured and executed, or escape to its home town.
  88
  89   'pplayer' is the player who tries to poison 'pcity' with its unit
  90   'pdiplomat'.
  91
  92   Returns TRUE iff action could be done, FALSE if it couldn't. Even if
  93   this returns TRUE, unit may have died during the action.
  94 ****************************************************************************/
  95 bool spy_poison(struct player *pplayer, struct unit *pdiplomat,
  96                 struct city *pcity, const struct action *paction)
  97 {
  98   struct player *cplayer;
  99   struct tile *ctile;
 100   const char *clink;
 101
 102   /* Fetch target city's player.  Sanity checks. */
 103   fc_assert_ret_val(pcity, FALSE);
 104   cplayer = city_owner(pcity);
 105   fc_assert_ret_val(cplayer, FALSE);
 106
 107   /* Sanity check: The actor still exists. */
 108   fc_assert_ret_val(pplayer, FALSE);
 109   fc_assert_ret_val(pdiplomat, FALSE);
 110
 111   ctile = city_tile(pcity);
 112   clink = city_link(pcity);
 113
 114   log_debug("poison: unit: %d", pdiplomat->id);
 115
 116   /* Check if the Diplomat/Spy succeeds against defending Diplomats/Spies. */
 117   if (!diplomat_infiltrate_tile(pplayer, cplayer, paction,
 118                                 pdiplomat, NULL, ctile)) {
 119     return FALSE;
 120   }
 121
 122   log_debug("poison: infiltrated");
 123   log_debug("poison: succeeded");
 124
 125   /* Poison people! */
 126   if (city_reduce_size(pcity, 1, pplayer, "poison")) {
 127     /* Notify everybody involved. */
 128     notify_player(pplayer, ctile, E_MY_DIPLOMAT_POISON, ftc_server,
 129                   _("Your %s poisoned the water supply of %s."),
 130                   unit_link(pdiplomat), clink);
 131     notify_player(cplayer, ctile,
 132                   E_ENEMY_DIPLOMAT_POISON, ftc_server,
 133                   _("%s is suspected of poisoning the water supply of %s."),
 134                   player_name(pplayer), clink);
 135
 136     if (game.info.poison_empties_food_stock) {
 137       /* The food was poisoned too. */
 138       city_empty_food_stock(pcity);
 139     }
 140
 141     /* Update clients. */
 142     city_refresh (pcity);
 143     send_city_info(NULL, pcity);
 144   } else {
 145     /* Notify everybody involved. */
 146     notify_player(pplayer, ctile, E_MY_DIPLOMAT_POISON, ftc_server,
 147                   _("Your %s destroyed %s by poisoning its water supply."),
 148                   unit_link(pdiplomat), clink);
 149     notify_player(cplayer, ctile,
 150                   E_ENEMY_DIPLOMAT_POISON, ftc_server,
 151                   _("%s is suspected of destroying %s by poisoning its"
 152                     " water supply."),
 153                   player_name(pplayer), clink);
 154   }
 155
 156   /* this may cause a diplomatic incident */
 157   action_consequence_success(paction, pplayer, cplayer, ctile, clink);
 158
 159   /* Now lets see if the spy survives. */
 160   diplomat_escape_full(pplayer, pdiplomat, TRUE, ctile, clink, paction);
 161
 162   return TRUE;
 163 }
 164
 165 /******************************************************************************
 166   Investigate a city.
 167
 168   - It costs some minimal movement to investigate a city.
 169
 170   - The actor unit always survives the investigation unless the action
 171     being performed is configured to always consume the actor unit.
 172
 173   Returns TRUE iff action could be done, FALSE if it couldn't. Even if
 174   this returns TRUE, unit may have died during the action.
 175 ****************************************************************************/
 176 bool diplomat_investigate(struct player *pplayer, struct unit *pdiplomat,
 177                           struct city *pcity,
 178                           const struct action *paction)
 179 {
 180   struct player *cplayer;
 181   struct packet_unit_short_info unit_packet;
 182   struct packet_city_info city_packet;
 183   struct packet_web_city_info_addition web_packet;
 184   struct traderoute_packet_list *routes;
 185
 186   /* Fetch target city's player.  Sanity checks. */
 187   fc_assert_ret_val(pcity, FALSE);
 188   cplayer = city_owner(pcity);
 189   fc_assert_ret_val(cplayer, FALSE);
 190
 191   /* Sanity check: The actor still exists. */
 192   fc_assert_ret_val(pplayer, FALSE);
 193   fc_assert_ret_val(pdiplomat, FALSE);
 194
 195   /* Sanity check: The target is foreign. */
 196   if (cplayer == pplayer) {
 197     /* Nothing to do to a domestic target. */
 198     return FALSE;
 199   }
 200
 201   log_debug("investigate: unit: %d", pdiplomat->id);
 202
 203   /* Do It... */
 204   update_dumb_city(pplayer, pcity);
 205   /* Special case for a diplomat/spy investigating a city:
 206      The investigator needs to know the supported and present
 207      units of a city, whether or not they are fogged. So, we
 208      send a list of them all before sending the city info.
 209      As this is a special case we bypass send_unit_info. */
 210   unit_list_iterate(pcity->units_supported, punit) {
 211     package_short_unit(punit, &unit_packet,
 212                        UNIT_INFO_CITY_SUPPORTED, pcity->id);
 213     /* We need to force to send the packet to ensure the client will receive
 214      * something (e.g. investigating twice). */
 215     lsend_packet_unit_short_info(pplayer->connections, &unit_packet, TRUE);
 216   } unit_list_iterate_end;
 217   unit_list_iterate((pcity->tile)->units, punit) {
 218     package_short_unit(punit, &unit_packet,
 219                        UNIT_INFO_CITY_PRESENT, pcity->id);
 220     /* We need to force to send the packet to ensure the client will receive
 221      * something (e.g. investigating twice). */
 222     lsend_packet_unit_short_info(pplayer->connections, &unit_packet, TRUE);
 223   } unit_list_iterate_end;
 224   /* Send city info to investigator's player.
 225      As this is a special case we bypass send_city_info. */
 226   routes = traderoute_packet_list_new();
 227   package_city(pcity, &city_packet, &web_packet, routes, TRUE);
 228   /* We need to force to send the packet to ensure the client will receive
 229    * something and popup the city dialog. */
 230   lsend_packet_city_info(pplayer->connections, &city_packet, TRUE);
 231   web_lsend_packet(city_info_addition, pplayer->connections, &web_packet, TRUE);
 232   traderoute_packet_list_iterate(routes, route_packet) {
 233     lsend_packet_traderoute_info(pplayer->connections, route_packet);
 234     FC_FREE(route_packet);
 235   } traderoute_packet_list_iterate_end;
 236   traderoute_packet_list_destroy(routes);
 237
 238   /* Charge a nominal amount of movement for this. */
 239   (pdiplomat->moves_left)--;
 240   if (pdiplomat->moves_left < 0) {
 241     pdiplomat->moves_left = 0;
 242   }
 243
 244   /* this may cause a diplomatic incident */
 245   action_consequence_success(paction, pplayer, cplayer,
 246                              city_tile(pcity), city_link(pcity));
 247
 248   /* The actor unit always survive unless the action it self has determined
 249    * to always consume it. */
 250   if (!utype_is_consumed_by_action(paction, unit_type_get(pdiplomat))) {
 251     /* This unit isn't about to be consumed. Send updated unit information
 252      * to the clients. */
 253     send_unit_info(NULL, pdiplomat);
 254   }
 255
 256   return TRUE;
 257 }
 258
 259 /******************************************************************************
 260   Get list of improvements from city (for purposes of sabotage).
 261
 262   - Always successful; returns list.
 263
 264   Only send back to the originating connection, if there is one. (?)
 265 ****************************************************************************/
 266 void spy_send_sabotage_list(struct connection *pc, struct unit *pdiplomat,
 267                             struct city *pcity,
 268                             const struct action *paction)
 269 {
 270   struct packet_city_sabotage_list packet;
 271
 272   /* Send city improvements info to player. */
 273   BV_CLR_ALL(packet.improvements);
 274
 275   improvement_iterate(ptarget) {
 276     if (city_has_building(pcity, ptarget)) {
 277       BV_SET(packet.improvements, improvement_index(ptarget));
 278     }
 279   } improvement_iterate_end;
 280
 281   packet.diplomat_id = pdiplomat->id;
 282   packet.city_id = pcity->id;
 283   packet.action_id = paction->id;
 284   send_packet_city_sabotage_list(pc, &packet);
 285 }
 286
 287 /******************************************************************************
 288   Establish an embassy.
 289
 290   - Barbarians always execute ambassadors.
 291   - Otherwise, the embassy is created.
 292   - It costs some minimal movement to establish an embassy.
 293
 294   - The actor unit always survives the investigation unless the action
 295     being performed is configured to always consume the actor unit.
 296
 297   Returns TRUE iff action could be done, FALSE if it couldn't. Even if
 298   this returns TRUE, unit may have died during the action.
 299 ****************************************************************************/
 300 bool diplomat_embassy(struct player *pplayer, struct unit *pdiplomat,
 301                       struct city *pcity, const struct action *paction)
 302 {
 303   struct player *cplayer;
 304
 305   /* Fetch target city's player.  Sanity checks. */
 306   fc_assert_ret_val(pcity, FALSE);
 307   cplayer = city_owner(pcity);
 308   fc_assert_ret_val(cplayer, FALSE);
 309
 310   /* Sanity check: The actor still exists. */
 311   fc_assert_ret_val(pplayer, FALSE);
 312   fc_assert_ret_val(pdiplomat, FALSE);
 313
 314   /* Sanity check: The target is foreign. */
 315   if (cplayer == pplayer) {
 316     /* Nothing to do to a domestic target. */
 317     return FALSE;
 318   }
 319
 320   log_debug("embassy: unit: %d", pdiplomat->id);
 321
 322   log_debug("embassy: succeeded");
 323
 324   establish_embassy(pplayer, cplayer);
 325
 326   /* Notify everybody involved. */
 327   notify_player(pplayer, city_tile(pcity),
 328                 E_MY_DIPLOMAT_EMBASSY, ftc_server,
 329                 _("You have established an embassy in %s."),
 330                 city_link(pcity));
 331   notify_player(cplayer, city_tile(pcity),
 332                 E_ENEMY_DIPLOMAT_EMBASSY, ftc_server,
 333                 _("The %s have established an embassy in %s."),
 334                 nation_plural_for_player(pplayer),
 335                 city_link(pcity));
 336
 337   /* Charge a nominal amount of movement for this. */
 338   (pdiplomat->moves_left)--;
 339   if (pdiplomat->moves_left < 0) {
 340     pdiplomat->moves_left = 0;
 341   }
 342
 343   /* this may cause a diplomatic incident */
 344   action_consequence_success(paction, pplayer, cplayer,
 345                              city_tile(pcity), city_link(pcity));
 346
 347   /* The actor unit always survive unless the action it self has determined
 348    * to always consume it. */
 349   if (!utype_is_consumed_by_action(paction, unit_type_get(pdiplomat))) {
 350     /* This unit isn't about to be consumed. Send updated unit information
 351      * to the clients. */
 352     send_unit_info(NULL, pdiplomat);
 353   }
 354
 355   return TRUE;
 356 }
 357
 358 /******************************************************************************
 359   Sabotage an enemy unit.
 360
 361   - If successful, reduces hit points by half of those remaining.
 362
 363   - The saboteur may be captured and executed, or escape to its home town.
 364
 365   Returns TRUE iff action could be done, FALSE if it couldn't. Even if
 366   this returns TRUE, unit may have died during the action.
 367 ****************************************************************************/
 368 bool spy_sabotage_unit(struct player *pplayer, struct unit *pdiplomat,
 369                        struct unit *pvictim,
 370                        const struct action *paction)
 371 {
 372   char victim_link[MAX_LEN_LINK];
 373   struct player *uplayer;
 374
 375   /* Fetch target unit's player.  Sanity checks. */
 376   fc_assert_ret_val(pvictim, FALSE);
 377   uplayer = unit_owner(pvictim);
 378   fc_assert_ret_val(uplayer, FALSE);
 379
 380   /* Sanity check: The actor still exists. */
 381   fc_assert_ret_val(pplayer, FALSE);
 382   fc_assert_ret_val(pdiplomat, FALSE);
 383
 384   log_debug("sabotage-unit: unit: %d", pdiplomat->id);
 385
 386   /* N.B: unit_link() always returns the same pointer. */
 387   sz_strlcpy(victim_link, unit_link(pvictim));
 388
 389   /* Diplomatic battle against any diplomatic defender except the intended
 390    * victim of the sabotage. */
 391   if (!diplomat_infiltrate_tile(pplayer, uplayer,
 392                                 paction,
 393                                 pdiplomat, pvictim,
 394                                 unit_tile(pvictim))) {
 395     return FALSE;
 396   }
 397
 398   log_debug("sabotage-unit: succeeded");
 399
 400   if (pvictim->hp < 2) {
 401     /* Not possible to halve the hit points. Kill it. */
 402     wipe_unit(pvictim, ULR_KILLED, pplayer);
 403
 404     /* Notify everybody involved. */
 405     notify_player(pplayer, unit_tile(pvictim),
 406                   E_MY_DIPLOMAT_SABOTAGE, ftc_server,
 407                   _("Your %s's successful sabotage killed the %s %s."),
 408                   unit_link(pdiplomat),
 409                   nation_adjective_for_player(uplayer),
 410                   victim_link);
 411     notify_player(uplayer, unit_tile(pvictim),
 412                   E_ENEMY_DIPLOMAT_SABOTAGE, ftc_server,
 413                   /* TRANS: ... the Poles! */
 414                   _("Your %s was killed by %s sabotage!"),
 415                   victim_link,
 416                   nation_plural_for_player(pplayer));
 417   } else {
 418     /* Sabotage the unit by removing half its remaining hit points. */
 419     pvictim->hp /= 2;
 420     send_unit_info(NULL, pvictim);
 421
 422     /* Notify everybody involved. */
 423     notify_player(pplayer, unit_tile(pvictim),
 424                   E_MY_DIPLOMAT_SABOTAGE, ftc_server,
 425                   _("Your %s succeeded in sabotaging the %s %s."),
 426                   unit_link(pdiplomat),
 427                   nation_adjective_for_player(uplayer),
 428                   victim_link);
 429     notify_player(uplayer, unit_tile(pvictim),
 430                   E_ENEMY_DIPLOMAT_SABOTAGE, ftc_server,
 431                   /* TRANS: ... the Poles! */
 432                   _("Your %s was sabotaged by the %s!"),
 433                   victim_link,
 434                   nation_plural_for_player(pplayer));
 435   }
 436
 437   /* this may cause a diplomatic incident */
 438   action_consequence_success(paction, pplayer, uplayer,
 439                              unit_tile(pvictim), victim_link);
 440
 441   /* Now lets see if the spy survives. */
 442   diplomat_escape(pplayer, pdiplomat, NULL, paction);
 443
 444   return TRUE;
 445 }
 446
 447 /******************************************************************************
 448   Bribe an enemy unit.
 449
 450   - Can't bribe a unit if:
 451     - Player doesn't have enough gold.
 452   - Otherwise, the unit will be bribed.
 453
 454   - A successful briber will try to move onto the victim's square.
 455
 456   Returns TRUE iff action could be done, FALSE if it couldn't. Even if
 457   this returns TRUE, unit may have died during the action.
 458 ****************************************************************************/
 459 bool diplomat_bribe(struct player *pplayer, struct unit *pdiplomat,
 460                     struct unit *pvictim, const struct action *paction)
 461 {
 462   char victim_link[MAX_LEN_LINK];
 463   struct player *uplayer;
 464   struct tile *victim_tile;
 465   int bribe_cost;
 466   int diplomat_id = pdiplomat->id;
 467   struct city *pcity;
 468
 469   /* Fetch target unit's player.  Sanity checks. */
 470   fc_assert_ret_val(pvictim, FALSE);
 471   uplayer = unit_owner(pvictim);
 472   fc_assert_ret_val(uplayer, FALSE);
 473
 474   /* Sanity check: The actor still exists. */
 475   fc_assert_ret_val(pplayer, FALSE);
 476   fc_assert_ret_val(pdiplomat, FALSE);
 477
 478   /* Sanity check: The target is foreign. */
 479   if (uplayer == pplayer) {
 480     /* Nothing to do to a domestic target. */
 481     return FALSE;
 482   }
 483
 484   /* Sanity check: The victim isn't a unique unit the actor player already
 485    * has. */
 486   if (utype_player_already_has_this_unique(pplayer,
 487                                            unit_type_get(pvictim))) {
 488     log_debug("bribe-unit: already got unique unit");
 489     notify_player(pplayer, unit_tile(pdiplomat),
 490                   E_UNIT_ILLEGAL_ACTION, ftc_server,
 491                   /* TRANS: You already have a Leader. */
 492                   _("You already have a %s."),
 493                   unit_link(pvictim));
 494
 495     return FALSE;
 496   }
 497
 498   log_debug("bribe-unit: unit: %d", pdiplomat->id);
 499
 500   /* Get bribe cost, ignoring any previously saved value. */
 501   bribe_cost = unit_bribe_cost(pvictim, pplayer);
 502
 503   /* If player doesn't have enough gold, can't bribe. */
 504   if (pplayer->economic.gold < bribe_cost) {
 505     notify_player(pplayer, unit_tile(pdiplomat),
 506                   E_MY_DIPLOMAT_FAILED, ftc_server,
 507                   _("You don't have enough gold to bribe the %s %s."),
 508                   nation_adjective_for_player(uplayer),
 509                   unit_link(pvictim));
 510     log_debug("bribe-unit: not enough gold");
 511     return FALSE;
 512   }
 513
 514   log_debug("bribe-unit: enough gold");
 515
 516   /* Diplomatic battle against any diplomatic defender except the one that
 517    * will get the bribe. */
 518   if (!diplomat_infiltrate_tile(pplayer, uplayer,
 519                                 paction,
 520                                 pdiplomat, pvictim,
 521                                 pvictim->tile)) {
 522     return FALSE;
 523   }
 524
 525   log_debug("bribe-unit: succeeded");
 526
 527   victim_tile = unit_tile(pvictim);
 528   pvictim = unit_change_owner(pvictim, pplayer, pdiplomat->homecity,
 529                               ULR_BRIBED);
 530
 531   /* N.B.: unit_link always returns the same pointer. As unit_change_owner()
 532    * currently remove the old unit and replace by a new one (with a new id),
 533    * we want to make link to the new unit. */
 534   sz_strlcpy(victim_link, unit_link(pvictim));
 535
 536   /* Notify everybody involved. */
 537   notify_player(pplayer, victim_tile, E_MY_DIPLOMAT_BRIBE, ftc_server,
 538                 /* TRANS: <diplomat> ... <unit> */
 539                 _("Your %s succeeded in bribing the %s."),
 540                 unit_link(pdiplomat), victim_link);
 541   if (maybe_make_veteran(pdiplomat)) {
 542     notify_unit_experience(pdiplomat);
 543   }
 544   notify_player(uplayer, victim_tile, E_ENEMY_DIPLOMAT_BRIBE, ftc_server,
 545                 /* TRANS: <unit> ... <Poles> */
 546                 _("Your %s was bribed by the %s."),
 547                 victim_link, nation_plural_for_player(pplayer));
 548
 549   /* The unit may have been on a tile shared with a city or a unit
 550    * it no longer can share a tile with. */
 551   pcity = tile_city(unit_tile(pvictim));
 552   if ((NULL != pcity && !pplayers_allied(city_owner(pcity), pplayer))
 553       || 1 < unit_list_size(unit_tile(pvictim)->units)) {
 554     bounce_unit(pvictim, TRUE);
 555   }
 556
 557   /* This costs! */
 558   pplayer->economic.gold -= bribe_cost;
 559
 560   /* This may cause a diplomatic incident */
 561   action_consequence_success(paction, pplayer, uplayer,
 562                              victim_tile, victim_link);
 563
 564   if (!unit_is_alive(diplomat_id)) {
 565     return TRUE;
 566   }
 567
 568   /* Try to move the briber onto the victim's square unless its a city or
 569    * have other units. */
 570   if (NULL == pcity && unit_list_size(unit_tile(pvictim)->units) < 2
 571       /* Post bribe move. */
 572       && !unit_move_handling(pdiplomat, victim_tile, FALSE, TRUE, NULL)
 573       /* May have died while trying to move. */
 574       && unit_is_alive(diplomat_id)) {
 575     pdiplomat->moves_left = 0;
 576   }
 577   if (NULL != player_unit_by_number(pplayer, diplomat_id)) {
 578     send_unit_info(NULL, pdiplomat);
 579   }
 580
 581   /* Update clients. */
 582   send_player_all_c(pplayer, NULL);
 583
 584   return TRUE;
 585 }
 586
 587 /****************************************************************************
 588   Try to steal a technology from an enemy city.
 589   If paction results in ACTION_SPY_STEAL_TECH, steal a random technology.
 590   Otherwise, steal the technology whose ID is "technology".
 591   (Note: Only Spies can select what to steal.)
 592
 593   - Check for infiltration success.  Our thief may not survive this.
 594   - Check for basic success.  Again, our thief may not survive this.
 595   - If a technology has already been stolen from this city at any time:
 596     - Diplomats will be caught and executed.
 597     - Spies will have an increasing chance of being caught and executed.
 598   - Steal technology!
 599
 600   - The thief may be captured and executed, or escape to its home town.
 601
 602   FIXME: It should give a loss of reputation to steal from a player you are
 603   not at war with
 604
 605   Returns TRUE iff action could be done, FALSE if it couldn't. Even if
 606   this returns TRUE, unit may have died during the action.
 607 ****************************************************************************/
 608 bool diplomat_get_tech(struct player *pplayer, struct unit *pdiplomat,
 609                        struct city  *pcity, Tech_type_id technology,
 610                        const struct action *paction)
 611 {
 612   struct research *presearch, *cresearch;
 613   struct player *cplayer;
 614   int count;
 615   int bonus;
 616   int times;
 617   Tech_type_id tech_stolen;
 618
 619   /* We have to check arguments. They are sent to us by a client,
 620      so we cannot trust them */
 621   fc_assert_ret_val(pcity, FALSE);
 622   cplayer = city_owner(pcity);
 623   fc_assert_ret_val(cplayer, FALSE);
 624
 625   /* Sanity check: The actor still exists. */
 626   fc_assert_ret_val(pplayer, FALSE);
 627   fc_assert_ret_val(pdiplomat, FALSE);
 628
 629   /* Sanity check: The target is foreign. */
 630   if (cplayer == pplayer) {
 631     /* Nothing to do to a domestic target. */
 632     return FALSE;
 633   }
 634
 635   if (action_has_result(paction, ACTION_SPY_STEAL_TECH)) {
 636     /* Can't choose target. Will steal a random tech. */
 637     technology = A_UNSET;
 638   }
 639
 640   /* Targeted technology should be a ruleset defined tech,
 641    * "At Spy's Discretion" (A_UNSET) or a future tech (A_FUTURE). */
 642   if (technology == A_NONE
 643       || (technology != A_FUTURE
 644           && !(technology == A_UNSET
 645                && action_has_result(paction, ACTION_SPY_STEAL_TECH))
 646           && !valid_advance_by_number(technology))) {
 647     return FALSE;
 648   }
 649
 650   presearch = research_get(pplayer);
 651   cresearch = research_get(cplayer);
 652
 653   if (technology == A_FUTURE) {
 654     if (presearch->future_tech >= cresearch->future_tech) {
 655       return FALSE;
 656     }
 657   } else if (technology != A_UNSET) {
 658     if (research_invention_state(presearch, technology) == TECH_KNOWN) {
 659       return FALSE;
 660     }
 661     if (research_invention_state(cresearch, technology) != TECH_KNOWN) {
 662       return FALSE;
 663     }
 664     if (!research_invention_gettable(presearch, technology,
 665                                      game.info.tech_steal_allow_holes)) {
 666       return FALSE;
 667     }
 668   }
 669
 670   log_debug("steal-tech: unit: %d", pdiplomat->id);
 671
 672   /* Check if the Diplomat/Spy succeeds against defending Diplomats/Spies. */
 673   if (!diplomat_infiltrate_tile(pplayer, cplayer,
 674                                 paction,
 675                                 pdiplomat, NULL,
 676                                 pcity->tile)) {
 677     return FALSE;
 678   }
 679
 680   log_debug("steal-tech: infiltrated");
 681
 682   bonus = get_unit_bonus(pdiplomat, EFT_STEALINGS_IGNORE);
 683   if (bonus < 0) {
 684     /* Negative effect value means infinite bonus */
 685     times = 0;
 686   } else {
 687     times = pcity->server.steal - bonus;
 688     if (times < 0) {
 689       times = 0;
 690     }
 691   }
 692
 693   /* Check if the Diplomat/Spy succeeds with his/her task. */
 694   /* (Twice as difficult if target is specified.) */
 695   /* (If already stolen from, impossible for Diplomats and harder for Spies.) */
 696   if (times > 0 && !unit_has_type_flag(pdiplomat, UTYF_SPY)) {
 697     /* Already stolen from: Diplomat always fails! */
 698     count = 1;
 699     log_debug("steal-tech: difficulty: impossible");
 700   } else {
 701     /* Determine difficulty. */
 702     count = 1;
 703     if (action_has_result(paction, ACTION_SPY_TARGETED_STEAL_TECH)) {
 704       /* Targeted steal tech is more difficult. */
 705       count++;
 706     }
 707     count += times;
 708     log_debug("steal-tech: difficulty: %d", count);
 709     /* Determine success or failure. */
 710     while (count > 0) {
 711       if (fc_rand(100) >= game.server.diplchance) {
 712         break;
 713       }
 714       count--;
 715     }
 716   }
 717
 718   if (count > 0) {
 719     if (pcity->server.steal > 0 && !unit_has_type_flag(pdiplomat, UTYF_SPY)) {
 720       notify_player(pplayer, city_tile(pcity),
 721                     E_MY_DIPLOMAT_FAILED, ftc_server,
 722                     _("%s was expecting your attempt to steal technology "
 723                       "again. Your %s was caught and executed."),
 724                     city_link(pcity),
 725                     unit_tile_link(pdiplomat));
 726     } else {
 727       notify_player(pplayer, city_tile(pcity),
 728                     E_MY_DIPLOMAT_FAILED, ftc_server,
 729                     _("Your %s was caught in the attempt of"
 730                       " stealing technology from %s."),
 731                     unit_tile_link(pdiplomat),
 732                     city_link(pcity));
 733     }
 734     notify_player(cplayer, city_tile(pcity),
 735                   E_ENEMY_DIPLOMAT_FAILED, ftc_server,
 736                   _("The %s %s failed to steal technology from %s."),
 737                   nation_adjective_for_player(pplayer),
 738                   unit_tile_link(pdiplomat),
 739                   city_link(pcity));
 740     /* this may cause a diplomatic incident */
 741     action_consequence_caught(paction, pplayer, cplayer,
 742                               city_tile(pcity), city_link(pcity));
 743     wipe_unit(pdiplomat, ULR_CAUGHT, cplayer);
 744     return FALSE;
 745   }
 746
 747   tech_stolen = steal_a_tech(pplayer, cplayer, technology);
 748
 749   if (tech_stolen == A_NONE) {
 750     notify_player(pplayer, city_tile(pcity),
 751                   E_MY_DIPLOMAT_FAILED, ftc_server,
 752                   _("No new technology found in %s."),
 753                   city_link(pcity));
 754     diplomat_charge_movement (pdiplomat, pcity->tile);
 755     send_unit_info(NULL, pdiplomat);
 756     return FALSE;
 757   }
 758
 759   /* Update stealing player's science progress and research fields */
 760   send_player_all_c(pplayer, NULL);
 761
 762   /* Record the theft. */
 763   (pcity->server.steal)++;
 764
 765   /* this may cause a diplomatic incident */
 766   action_consequence_success(paction, pplayer, cplayer,
 767                              city_tile(pcity), city_link(pcity));
 768
 769   /* Check if a spy survives her mission. */
 770   diplomat_escape(pplayer, pdiplomat, pcity, paction);
 771
 772   return TRUE;
 773 }
 774
 775 /**************************************************************************
 776   Incite a city to disaffect.
 777
 778   - Can't incite a city to disaffect if:
 779     - Player doesn't have enough gold.
 780   - Check for infiltration success.  Our provocateur may not survive this.
 781   - Check for basic success.  Again, our provocateur may not survive this.
 782   - Otherwise, the city will disaffect:
 783     - Player gets the city.
 784     - Player gets certain of the city's present/supported units.
 785     - Player gets a technology advance, if any were unknown.
 786
 787   - The provocateur may be captured and executed, or escape to its home
 788     town.
 789
 790   Returns TRUE iff action could be done, FALSE if it couldn't. Even if
 791   this returns TRUE, unit may have died during the action.
 792 **************************************************************************/
 793 bool diplomat_incite(struct player *pplayer, struct unit *pdiplomat,
 794                      struct city *pcity, const struct action *paction)
 795 {
 796   struct player *cplayer;
 797   struct tile *ctile;
 798   const char *clink;
 799   int revolt_cost;
 800
 801   /* Fetch target civilization's player.  Sanity checks. */
 802   fc_assert_ret_val(pcity, FALSE);
 803   cplayer = city_owner(pcity);
 804   fc_assert_ret_val(cplayer, FALSE);
 805
 806   /* Sanity check: The actor still exists. */
 807   fc_assert_ret_val(pplayer, FALSE);
 808   fc_assert_ret_val(pdiplomat, FALSE);
 809
 810   /* Sanity check: The target is foreign. */
 811   if (cplayer == pplayer) {
 812     /* Nothing to do to a domestic target. */
 813     return FALSE;
 814   }
 815
 816   ctile = city_tile(pcity);
 817   clink = city_link(pcity);
 818
 819   log_debug("incite: unit: %d", pdiplomat->id);
 820
 821   /* Get incite cost, ignoring any previously saved value. */
 822   revolt_cost = city_incite_cost(pplayer, pcity);
 823
 824   /* If player doesn't have enough gold, can't incite a revolt. */
 825   if (pplayer->economic.gold < revolt_cost) {
 826     notify_player(pplayer, ctile, E_MY_DIPLOMAT_FAILED, ftc_server,
 827                   _("You don't have enough gold to subvert %s."),
 828                   clink);
 829     log_debug("incite: not enough gold");
 830     return FALSE;
 831   }
 832
 833   /* Check if the Diplomat/Spy succeeds against defending Diplomats/Spies. */
 834   if (!diplomat_infiltrate_tile(pplayer, cplayer,
 835                                 paction,
 836                                 pdiplomat, NULL,
 837                                 pcity->tile)) {
 838     return FALSE;
 839   }
 840
 841   log_debug("incite: infiltrated");
 842
 843   /* Check if the Diplomat/Spy succeeds with his/her task. */
 844   if (diplomat_was_caught(pplayer, pdiplomat, pcity, cplayer,
 845                           paction)) {
 846     notify_player(pplayer, ctile, E_MY_DIPLOMAT_FAILED, ftc_server,
 847                   _("Your %s was caught in the attempt"
 848                     " of inciting a revolt!"),
 849                   unit_tile_link(pdiplomat));
 850     notify_player(cplayer, ctile, E_ENEMY_DIPLOMAT_FAILED, ftc_server,
 851                   _("You caught %s %s attempting"
 852                     " to incite a revolt in %s!"),
 853                   nation_adjective_for_player(pplayer),
 854                   unit_tile_link(pdiplomat),
 855                   clink);
 856
 857     /* This may cause a diplomatic incident */
 858     action_consequence_caught(paction, pplayer, cplayer, ctile, clink);
 859
 860     wipe_unit(pdiplomat, ULR_CAUGHT, cplayer);
 861     return FALSE;
 862   }
 863
 864   log_debug("incite: succeeded");
 865
 866   /* Subvert the city to your cause... */
 867
 868   /* City loses some population. */
 869   if (city_size_get(pcity) > 1) {
 870     city_reduce_size(pcity, 1, pplayer, "incited");
 871   }
 872
 873   /* This costs! */
 874   pplayer->economic.gold -= revolt_cost;
 875
 876   /* Notify everybody involved. */
 877   notify_player(pplayer, ctile, E_MY_DIPLOMAT_INCITE, ftc_server,
 878                 _("Revolt incited in %s, you now rule the city!"),
 879                 clink);
 880   notify_player(cplayer, ctile, E_ENEMY_DIPLOMAT_INCITE, ftc_server,
 881                 _("%s has revolted, %s influence suspected."),
 882                 clink,
 883                 nation_adjective_for_player(pplayer));
 884
 885   pcity->shield_stock = 0;
 886   nullify_prechange_production(pcity);
 887
 888   /* You get a technology advance, too! */
 889   steal_a_tech(pplayer, cplayer, A_UNSET);
 890
 891   /* this may cause a diplomatic incident */
 892   action_consequence_success(paction, pplayer, cplayer, ctile, clink);
 893
 894   /* Transfer city and units supported by this city (that
 895      are within one square of the city) to the new owner. */
 896   if (transfer_city(pplayer, pcity, 1, TRUE, TRUE, FALSE,
 897                     !is_barbarian(pplayer))) {
 898     script_server_signal_emit("city_transferred", 4,
 899                               API_TYPE_CITY, pcity,
 900                               API_TYPE_PLAYER, cplayer,
 901                               API_TYPE_PLAYER, pplayer,
 902                               API_TYPE_STRING, "incited");
 903   }
 904
 905   /* Check if a spy survives her mission.
 906    * _After_ transferring the city, or the city area is first fogged
 907    * when the diplomat is removed, and then unfogged when the city
 908    * is transferred. */
 909   diplomat_escape_full(pplayer, pdiplomat, TRUE, ctile, clink, paction);
 910
 911   /* Update the players gold in the client */
 912   send_player_info_c(pplayer, pplayer->connections);
 913
 914   return TRUE;
 915 }
 916
 917 /**************************************************************************
 918   Sabotage enemy city's improvement or production.
 919   If this is untargeted sabotage city a random improvement or production is
 920   targeted.
 921   Targeted sabotage city lets the value of "improvement" decide the target.
 922   If "improvement" is -1, sabotage current production.
 923   Otherwise, sabotage the city improvement whose ID is "improvement".
 924
 925   - Check for infiltration success.  Our saboteur may not survive this.
 926   - Check for basic success.  Again, our saboteur may not survive this.
 927   - Determine target, given arguments and constraints.
 928   - If specified, city walls and anything in a capital are 50% likely to fail.
 929   - Do sabotage!
 930
 931   - The saboteur may be captured and executed, or escape to its home town.
 932
 933   Returns TRUE iff action could be done, FALSE if it couldn't. Even if
 934   this returns TRUE, unit may have died during the action.
 935 **************************************************************************/
 936 bool diplomat_sabotage(struct player *pplayer, struct unit *pdiplomat,
 937                        struct city *pcity, Impr_type_id improvement,
 938                        const struct action *paction)
 939 {
 940   struct player *cplayer;
 941   struct impr_type *ptarget;
 942   int count, which;
 943
 944   /* Fetch target city's player.  Sanity checks. */
 945   fc_assert_ret_val(pcity, FALSE);
 946   cplayer = city_owner(pcity);
 947   fc_assert_ret_val(cplayer, FALSE);
 948
 949   /* Sanity check: The actor still exists. */
 950   fc_assert_ret_val(pplayer, FALSE);
 951   fc_assert_ret_val(pdiplomat, FALSE);
 952
 953   log_debug("sabotage: unit: %d", pdiplomat->id);
 954
 955   /* Check if the Diplomat/Spy succeeds against defending Diplomats/Spies. */
 956   if (!diplomat_infiltrate_tile(pplayer, cplayer,
 957                                 paction,
 958                                 pdiplomat, NULL,
 959                                 pcity->tile)) {
 960     return FALSE;
 961   }
 962
 963   log_debug("sabotage: infiltrated");
 964
 965   /* Check if the Diplomat/Spy succeeds with his/her task. */
 966   if (diplomat_was_caught(pplayer, pdiplomat, pcity, cplayer,
 967                           paction)) {
 968     notify_player(pplayer, city_tile(pcity),
 969                   E_MY_DIPLOMAT_FAILED, ftc_server,
 970                   _("Your %s was caught in the attempt"
 971                     " of industrial sabotage!"),
 972                   unit_tile_link(pdiplomat));
 973     notify_player(cplayer, city_tile(pcity),
 974                   E_ENEMY_DIPLOMAT_SABOTAGE, ftc_server,
 975                   _("You caught %s %s attempting sabotage in %s!"),
 976                   nation_adjective_for_player(pplayer),
 977                   unit_tile_link(pdiplomat),
 978                   city_link(pcity));
 979
 980     /* This may cause a diplomatic incident */
 981     action_consequence_caught(paction, pplayer, cplayer,
 982                               city_tile(pcity), city_link(pcity));
 983
 984     wipe_unit(pdiplomat, ULR_CAUGHT, cplayer);
 985     return FALSE;
 986   }
 987
 988   log_debug("sabotage: succeeded");
 989
 990   /* Examine the city for improvements to sabotage. */
 991   count = 0;
 992   city_built_iterate(pcity, pimprove) {
 993     if (pimprove->sabotage > 0) {
 994       count++;
 995     }
 996   } city_built_iterate_end;
 997
 998   log_debug("sabotage: count of improvements: %d", count);
 999
1000   /* Determine the target (-1 is production). */
1001   if (action_has_result(paction, ACTION_SPY_SABOTAGE_CITY)) {
1002     /*
1003      * Pick random:
1004      * 50/50 chance to pick production or some improvement.
1005      * Won't pick something that doesn't exit.
1006      * If nothing to do, say so, deduct movement cost and return.
1007      */
1008     if (count == 0 && pcity->shield_stock == 0) {
1009       notify_player(pplayer, city_tile(pcity),
1010                     E_MY_DIPLOMAT_FAILED, ftc_server,
1011                     _("Your %s could not find anything to sabotage in %s."),
1012                     unit_link(pdiplomat),
1013                     city_link(pcity));
1014       diplomat_charge_movement(pdiplomat, pcity->tile);
1015       send_unit_info(NULL, pdiplomat);
1016       log_debug("sabotage: random: nothing to do");
1017       return FALSE;
1018     }
1019     if (count == 0 || fc_rand (2) == 1) {
1020       ptarget = NULL;
1021       log_debug("sabotage: random: targeted production");
1022     } else {
1023       ptarget = NULL;
1024       which = fc_rand (count);
1025
1026       city_built_iterate(pcity, pimprove) {
1027         if (pimprove->sabotage > 0) {
1028           if (which > 0) {
1029             which--;
1030           } else {
1031             ptarget = pimprove;
1032             break;
1033           }
1034         }
1035       } city_built_iterate_end;
1036
1037       if (NULL != ptarget) {
1038         log_debug("sabotage: random: targeted improvement: %d (%s)",
1039                   improvement_number(ptarget),
1040                   improvement_rule_name(ptarget));
1041       } else {
1042         log_error("sabotage: random: targeted improvement error!");
1043       }
1044     }
1045   } else if (improvement < 0) {
1046     /* If told to sabotage production, do so. */
1047     ptarget = NULL;
1048     log_debug("sabotage: specified target production");
1049   } else {
1050     struct impr_type *pimprove = improvement_by_number(improvement);
1051     if (pimprove == NULL) {
1052       log_error("sabotage: requested for invalid improvement %d", improvement);
1053       return FALSE;
1054     }
1055     /*
1056      * Told which improvement to pick:
1057      * If try for wonder or palace, complain, deduct movement cost and return.
1058      * If not available, say so, deduct movement cost and return.
1059      */
1060     if (city_has_building(pcity, pimprove)) {
1061       if (pimprove->sabotage > 0) {
1062         ptarget = pimprove;
1063         log_debug("sabotage: specified target improvement: %d (%s)",
1064                   improvement, improvement_rule_name(pimprove));
1065       } else {
1066         notify_player(pplayer, city_tile(pcity),
1067                       E_MY_DIPLOMAT_FAILED, ftc_server,
1068                       _("You cannot sabotage a %s!"),
1069                       improvement_name_translation(pimprove));
1070         diplomat_charge_movement(pdiplomat, pcity->tile);
1071         send_unit_info(NULL, pdiplomat);
1072         log_debug("sabotage: disallowed target improvement: %d (%s)",
1073                   improvement, improvement_rule_name(pimprove));
1074         return FALSE;
1075       }
1076     } else {
1077       notify_player(pplayer, city_tile(pcity),
1078                     E_MY_DIPLOMAT_FAILED, ftc_server,
1079                     _("Your %s could not find the %s to sabotage in %s."),
1080                     unit_name_translation(pdiplomat),
1081                     improvement_name_translation(pimprove),
1082                     city_link(pcity));
1083       diplomat_charge_movement(pdiplomat, pcity->tile);
1084       send_unit_info(NULL, pdiplomat);
1085       log_debug("sabotage: target improvement not found: %d (%s)",
1086                 improvement, improvement_rule_name(pimprove));
1087       return FALSE;
1088     }
1089   }
1090
1091   /* Now, the fun stuff!  Do the sabotage! */
1092   if (NULL == ptarget) {
1093      char prod[256];
1094
1095     /* Do it. */
1096     pcity->shield_stock = 0;
1097     nullify_prechange_production(pcity); /* Make it impossible to recover */
1098
1099     /* Report it. */
1100     universal_name_translation(&pcity->production, prod, sizeof(prod));
1101
1102     notify_player(pplayer, city_tile(pcity),
1103                   E_MY_DIPLOMAT_SABOTAGE, ftc_server,
1104                   _("Your %s succeeded in destroying"
1105                     " the production of %s in %s."),
1106                   unit_link(pdiplomat),
1107                   prod,
1108                   city_name_get(pcity));
1109     notify_player(cplayer, city_tile(pcity),
1110                   E_ENEMY_DIPLOMAT_SABOTAGE, ftc_server,
1111                   _("The production of %s was destroyed in %s,"
1112                     " %s are suspected."),
1113                   prod,
1114                   city_link(pcity),
1115                   nation_plural_for_player(pplayer));
1116     log_debug("sabotage: sabotaged production");
1117   } else {
1118     int vulnerability = ptarget->sabotage;
1119
1120     /* Sabotage a city improvement. */
1121
1122     /*
1123      * One last chance to get caught:
1124      * If target was specified, and it is in the capital or are
1125      * City Walls, then there is a 50% chance of getting caught.
1126      */
1127     vulnerability -= (vulnerability
1128                       * get_city_bonus(pcity, EFT_SABOTEUR_RESISTANT)
1129                       / 100);
1130
1131     if (fc_rand(100) >= vulnerability) {
1132       /* Caught! */
1133       notify_player(pplayer, city_tile(pcity),
1134                     E_MY_DIPLOMAT_FAILED, ftc_server,
1135                     _("Your %s was caught in the attempt of sabotage!"),
1136                     unit_tile_link(pdiplomat));
1137       notify_player(cplayer, city_tile(pcity),
1138                     E_ENEMY_DIPLOMAT_FAILED, ftc_server,
1139                     _("You caught %s %s attempting"
1140                       " to sabotage the %s in %s!"),
1141                     nation_adjective_for_player(pplayer),
1142                     unit_tile_link(pdiplomat),
1143                     improvement_name_translation(ptarget),
1144                     city_link(pcity));
1145
1146       /* This may cause a diplomatic incident */
1147       action_consequence_caught(paction, pplayer, cplayer,
1148                                 city_tile(pcity), city_link(pcity));
1149
1150       wipe_unit(pdiplomat, ULR_CAUGHT, cplayer);
1151       log_debug("sabotage: caught in capital or on city walls");
1152       return FALSE;
1153     }
1154
1155     /* Report it. */
1156     notify_player(pplayer, city_tile(pcity),
1157                   E_MY_DIPLOMAT_SABOTAGE, ftc_server,
1158                   _("Your %s destroyed the %s in %s."),
1159                   unit_link(pdiplomat),
1160                   improvement_name_translation(ptarget),
1161                   city_link(pcity));
1162     notify_player(cplayer, city_tile(pcity),
1163                   E_ENEMY_DIPLOMAT_SABOTAGE, ftc_server,
1164                   _("The %s destroyed the %s in %s."),
1165                   nation_plural_for_player(pplayer),
1166                   improvement_name_translation(ptarget),
1167                   city_link(pcity));
1168     log_debug("sabotage: sabotaged improvement: %d (%s)",
1169               improvement_number(ptarget),
1170               improvement_rule_name(ptarget));
1171
1172     /* Do it. */
1173     building_lost(pcity, ptarget);
1174   }
1175
1176   /* Update clients. */
1177   send_city_info(NULL, pcity);
1178
1179   /* this may cause a diplomatic incident */
1180   action_consequence_success(paction, pplayer, cplayer,
1181                              city_tile(pcity), city_link(pcity));
1182
1183   /* Check if a spy survives her mission. */
1184   diplomat_escape(pplayer, pdiplomat, pcity, paction);
1185
1186   return TRUE;
1187 }
1188
1189 /**************************************************************************
1190   Steal gold from another player.
1191   The amount stolen is decided randomly.
1192   Not everything stolen reaches the player that ordered it stolen.
1193
1194   - Check for infiltration success.  Our thief may not survive this.
1195   - Check for basic success.  Again, our thief may not survive this.
1196   - Can't steal if there is no money to take.
1197
1198   Returns TRUE iff action could be done, FALSE if it couldn't. Even if
1199   this returns TRUE, unit may have died during the action.
1200 **************************************************************************/
1201 bool spy_steal_gold(struct player *act_player, struct unit *act_unit,
1202                     struct city *tgt_city, const struct action *paction)
1203 {
1204   struct player *tgt_player;
1205   struct tile *tgt_tile;
1206
1207   const char *tgt_city_link;
1208
1209   int gold_take;
1210   int gold_give;
1211
1212   /* Sanity check: The actor still exists. */
1213   fc_assert_ret_val(act_player, FALSE);
1214   fc_assert_ret_val(act_unit, FALSE);
1215
1216   /* Sanity check: The target city still exists. */
1217   fc_assert_ret_val(tgt_city, FALSE);
1218
1219   /* Who to steal from. */
1220   tgt_player = city_owner(tgt_city);
1221
1222   /* Sanity check: The target player still exists. */
1223   fc_assert_ret_val(tgt_player, FALSE);
1224
1225   /* Sanity check: The target is foreign. */
1226   if (tgt_player == act_player) {
1227     /* Nothing to do to a domestic target. */
1228     return FALSE;
1229   }
1230
1231   /* Sanity check: There is something to steal. */
1232   if (tgt_player->economic.gold <= 0) {
1233     return FALSE;
1234   }
1235
1236   tgt_tile = city_tile(tgt_city);
1237   tgt_city_link = city_link(tgt_city);
1238
1239   log_debug("steal gold: unit: %d", act_unit->id);
1240
1241   /* Battle all units capable of diplomatic defence. */
1242   if (!diplomat_infiltrate_tile(act_player, tgt_player,
1243                                 paction,
1244                                 act_unit, NULL, tgt_tile)) {
1245     return FALSE;
1246   }
1247
1248   log_debug("steal gold: infiltrated");
1249
1250   /* The thief may get caught while trying to steal the gold. */
1251   if (diplomat_was_caught(act_player, act_unit, tgt_city, tgt_player,
1252                           paction)) {
1253     notify_player(act_player, tgt_tile, E_MY_DIPLOMAT_FAILED, ftc_server,
1254                   _("Your %s was caught attempting to steal gold!"),
1255                   unit_tile_link(act_unit));
1256     notify_player(tgt_player, tgt_tile, E_ENEMY_DIPLOMAT_FAILED,
1257                   ftc_server,
1258                   _("You caught %s %s attempting"
1259                     " to steal your gold in %s!"),
1260                   nation_adjective_for_player(act_player),
1261                   unit_tile_link(act_unit),
1262                   tgt_city_link);
1263
1264     /* This may cause a diplomatic incident */
1265     action_consequence_caught(paction, act_player,
1266                               tgt_player, tgt_tile, tgt_city_link);
1267
1268     /* Execute the caught thief. */
1269     wipe_unit(act_unit, ULR_CAUGHT, tgt_player);
1270
1271     return FALSE;
1272   }
1273
1274   log_debug("steal gold: succeeded");
1275
1276   /* The upper limit on how much gold the thief can steal. */
1277   gold_take = (tgt_player->economic.gold
1278                * get_city_bonus(tgt_city, EFT_MAX_STOLEN_GOLD_PM))
1279               / 1000;
1280
1281   /* How much to actually take. 1 gold is the smallest amount that can be
1282    * stolen. The victim player has at least 1 gold. If he didn't the
1283    * something to steal sanity check would have aborted the theft. */
1284   gold_take = fc_rand(gold_take) + 1;
1285
1286   log_debug("steal gold: will take %d gold", gold_take);
1287
1288   /* Steal the gold. */
1289   tgt_player->economic.gold -= gold_take;
1290
1291   /* Some gold may be lost during transfer. */
1292   gold_give = gold_take
1293             - (gold_take * get_unit_bonus(act_unit, EFT_THIEFS_SHARE_PM))
1294               / 1000;
1295
1296   log_debug("steal gold: will give %d gold", gold_give);
1297
1298   /* Pocket the stolen money. */
1299   act_player->economic.gold += gold_give;
1300
1301   /* Notify everyone involved. */
1302   notify_player(act_player, tgt_tile, E_MY_SPY_STEAL_GOLD, ftc_server,
1303                 PL_("Your %s stole %d gold from %s.",
1304                     "Your %s stole %d gold from %s.", gold_give),
1305                 unit_link(act_unit), gold_give, tgt_city_link);
1306   notify_player(tgt_player, tgt_tile, E_ENEMY_SPY_STEAL_GOLD, ftc_server,
1307                 PL_("The %s are suspected of stealing %d gold from %s.",
1308                     "The %s are suspected of stealing %d gold from %s.",
1309                     gold_take),
1310                 nation_plural_for_player(act_player),
1311                 gold_take, tgt_city_link);
1312
1313   /* This may cause a diplomatic incident. */
1314   action_consequence_success(paction, act_player,
1315                              tgt_player, tgt_tile, tgt_city_link);
1316
1317   /* Try to escape. */
1318   diplomat_escape_full(act_player, act_unit, TRUE,
1319                        tgt_tile, tgt_city_link, paction);
1320
1321   /* Update the players' gold in the client */
1322   send_player_info_c(act_player, act_player->connections);
1323   send_player_info_c(tgt_player, tgt_player->connections);
1324
1325   return TRUE;
1326 }
1327
1328 /**************************************************************************
1329   Steal part of another player's map.
1330
1331   - Check for infiltration success. Our thief may not survive this.
1332   - Check for basic success.  Again, our thief may not survive this.
1333
1334   Returns TRUE iff action could be done, FALSE if it couldn't. Even if
1335   this returns TRUE, unit may have died during the action.
1336 **************************************************************************/
1337 bool spy_steal_some_maps(struct player *act_player, struct unit *act_unit,
1338                          struct city *tgt_city,
1339                          const struct action *paction)
1340 {
1341   struct player *tgt_player;
1342   struct tile *tgt_tile;
1343
1344   const char *tgt_city_link;
1345
1346   /* Sanity check: The actor still exists. */
1347   fc_assert_ret_val(act_player, FALSE);
1348   fc_assert_ret_val(act_unit, FALSE);
1349
1350   /* Sanity check: The target city still exists. */
1351   fc_assert_ret_val(tgt_city, FALSE);
1352
1353   /* Who to steal from. */
1354   tgt_player = city_owner(tgt_city);
1355
1356   /* Sanity check: The target player still exists. */
1357   fc_assert_ret_val(tgt_player, FALSE);
1358
1359   /* Sanity check: The target is foreign. */
1360   if (tgt_player == act_player) {
1361     /* Nothing to do to a domestic target. */
1362     return FALSE;
1363   }
1364
1365   tgt_tile = city_tile(tgt_city);
1366   tgt_city_link = city_link(tgt_city);
1367
1368   log_debug("steal some maps: unit: %d", act_unit->id);
1369
1370   /* Battle all units capable of diplomatic defence. */
1371   if (!diplomat_infiltrate_tile(act_player, tgt_player,
1372                                 paction,
1373                                 act_unit, NULL, tgt_tile)) {
1374     return FALSE;
1375   }
1376
1377   log_debug("steal some maps: infiltrated");
1378
1379   /* Try to steal the map. */
1380   if (diplomat_was_caught(act_player, act_unit, tgt_city, tgt_player,
1381                           paction)) {
1382     notify_player(act_player, tgt_tile, E_MY_DIPLOMAT_FAILED, ftc_server,
1383                   _("Your %s was caught in an attempt of"
1384                     " stealing parts of the %s world map!"),
1385                   unit_tile_link(act_unit),
1386                   nation_adjective_for_player(tgt_player));
1387     notify_player(tgt_player, tgt_tile, E_ENEMY_DIPLOMAT_FAILED,
1388                   ftc_server,
1389                   _("You caught %s %s attempting to steal"
1390                     " parts of your world map in %s!"),
1391                   nation_adjective_for_player(act_player),
1392                   unit_tile_link(act_unit),
1393                   tgt_city_link);
1394
1395     /* This may cause a diplomatic incident. */
1396     action_consequence_caught(paction, act_player,
1397                               tgt_player, tgt_tile, tgt_city_link);
1398
1399     /* Execute the caught thief. */
1400     wipe_unit(act_unit, ULR_CAUGHT, tgt_player);
1401
1402     return FALSE;
1403   }
1404
1405   log_debug("steal some maps: succeeded");
1406
1407   /* Steal it. */
1408   give_distorted_map(tgt_player, act_player, 1, 1, TRUE);
1409
1410   /* Notify everyone involved. */
1411   notify_player(act_player, tgt_tile, E_MY_SPY_STEAL_MAP, ftc_server,
1412                 _("Your %s stole parts of the %s world map in %s."),
1413                 unit_link(act_unit),
1414                 nation_adjective_for_player(tgt_player),
1415                 tgt_city_link);
1416   notify_player(tgt_player, tgt_tile, E_ENEMY_SPY_STEAL_MAP, ftc_server,
1417                 _("The %s are suspected of stealing"
1418                   " parts of your world map in %s."),
1419                 nation_plural_for_player(act_player),
1420                 tgt_city_link);
1421
1422   /* This may cause a diplomatic incident. */
1423   action_consequence_success(paction, act_player,
1424                              tgt_player, tgt_tile, tgt_city_link);
1425
1426   /* Try to escape. */
1427   diplomat_escape_full(act_player, act_unit, TRUE,
1428                        tgt_tile, tgt_city_link, paction);
1429
1430   return TRUE;
1431 }
1432
1433 /**************************************************************************
1434   Hide a suitcase nuke in a city and detonate it.
1435
1436   - Check for infiltration success. Our thief may not survive this.
1437   - Check for basic success.  Again, our thief may not survive this.
1438
1439   Returns TRUE iff action could be done, FALSE if it couldn't. Even if
1440   this returns TRUE, unit may have died during the action.
1441 **************************************************************************/
1442 bool spy_nuke_city(struct player *act_player, struct unit *act_unit,
1443                    struct city *tgt_city, const struct action *paction)
1444 {
1445   struct player *tgt_player;
1446   struct tile *tgt_tile;
1447
1448   const char *tgt_city_link;
1449
1450   /* Sanity check: The actor still exists. */
1451   fc_assert_ret_val(act_player, FALSE);
1452   fc_assert_ret_val(act_unit, FALSE);
1453
1454   /* Sanity check: The target city still exists. */
1455   fc_assert_ret_val(tgt_city, FALSE);
1456
1457   /* The victim. */
1458   tgt_player = city_owner(tgt_city);
1459
1460   /* Sanity check: The target player still exists. */
1461   fc_assert_ret_val(tgt_player, FALSE);
1462
1463   tgt_tile = city_tile(tgt_city);
1464   tgt_city_link = city_link(tgt_city);
1465
1466   log_debug("suitcase nuke: unit: %d", act_unit->id);
1467
1468   /* Battle all units capable of diplomatic defense. */
1469   if (!diplomat_infiltrate_tile(act_player, tgt_player,
1470                                 paction,
1471                                 act_unit, NULL, tgt_tile)) {
1472     return FALSE;
1473   }
1474
1475   log_debug("suitcase nuke: infiltrated");
1476
1477   /* Try to hide the nuke. */
1478   if (diplomat_was_caught(act_player, act_unit, tgt_city, tgt_player,
1479                           paction)) {
1480     notify_player(act_player, tgt_tile, E_MY_DIPLOMAT_FAILED, ftc_server,
1481                   _("Your %s was caught in an attempt of"
1482                     " hiding a nuke in %s!"),
1483                   unit_tile_link(act_unit),
1484                   tgt_city_link);
1485     notify_player(tgt_player, tgt_tile, E_ENEMY_DIPLOMAT_FAILED,
1486                   ftc_server,
1487                   _("You caught %s %s attempting to hide a nuke in %s!"),
1488                   nation_adjective_for_player(act_player),
1489                   unit_tile_link(act_unit),
1490                   tgt_city_link);
1491
1492     /* This may cause a diplomatic incident. */
1493     action_consequence_caught(paction, act_player,
1494                               tgt_player, tgt_tile, tgt_city_link);
1495
1496     /* Execute the caught terrorist. */
1497     wipe_unit(act_unit, ULR_CAUGHT, tgt_player);
1498
1499     return FALSE;
1500   }
1501
1502   log_debug("suitcase nuke: succeeded");
1503
1504   /* Notify everyone involved. */
1505   notify_player(act_player, tgt_tile, E_MY_SPY_NUKE, ftc_server,
1506                 _("Your %s hid a nuke in %s."),
1507                 unit_link(act_unit),
1508                 tgt_city_link);
1509   notify_player(tgt_player, tgt_tile, E_ENEMY_SPY_NUKE, ftc_server,
1510                 _("The %s are suspected of hiding a nuke in %s."),
1511                 nation_plural_for_player(act_player),
1512                 tgt_city_link);
1513
1514   /* Try to escape before the blast. */
1515   diplomat_escape_full(act_player, act_unit, TRUE,
1516                        tgt_tile, tgt_city_link, paction);
1517
1518   if (utype_is_consumed_by_action(paction, unit_type_get(act_unit))) {
1519     /* The unit must be wiped here so it won't be seen as a victim of the
1520      * detonation of its own nuke. */
1521     wipe_unit(act_unit, ULR_USED, NULL);
1522   }
1523
1524   /* TODO: In real life a suitcase nuke is way less powerful than an ICBM.
1525    * Maybe the size of the suitcase nuke explosion should be ruleset
1526    * configurable? */
1527
1528   /* Detonate the nuke. */
1529   dlsend_packet_nuke_tile_info(game.est_connections, tile_index(tgt_tile));
1530   do_nuclear_explosion(act_player, tgt_tile);
1531
1532   /* This may cause a diplomatic incident. */
1533   action_consequence_success(paction, act_player,
1534                              tgt_player, tgt_tile, tgt_city_link);
1535
1536   return TRUE;
1537 }
1538
1539 /**************************************************************************
1540   Returns TRUE iff the spy/diplomat was caught outside of a diplomatic
1541   battle.
1542 **************************************************************************/
1543 static bool diplomat_was_caught(struct player *act_player,
1544                                 struct unit *act_unit,
1545                                 struct city *tgt_city,
1546                                 struct player *tgt_player,
1547                                 const struct action *act)
1548 {
1549   int odds;
1550
1551   /* Take the odds from the diplchance setting. */
1552   odds = game.server.diplchance;
1553
1554   /* Let the Action_Odds_Pct effect modify the odds. The advantage of doing
1555    * it this way in stead of rolling twice is that Action_Odds_Pct can
1556    * increase the odds. */
1557   odds += ((odds
1558             * get_target_bonus_effects(NULL,
1559                                        act_player, tgt_player,
1560                                        tgt_city, NULL, NULL,
1561                                        act_unit, unit_type_get(act_unit),
1562                                        NULL, NULL, act,
1563                                        EFT_ACTION_ODDS_PCT))
1564            / 100);
1565
1566   /* Roll the dice. */
1567   return fc_rand (100) >= odds;
1568 }
1569
1570 /**************************************************************************
1571   This subtracts the destination movement cost from a diplomat/spy.
1572 **************************************************************************/
1573 static void diplomat_charge_movement(struct unit *pdiplomat, struct tile *ptile)
1574 {
1575   pdiplomat->moves_left -=
1576     map_move_cost_unit(&(wld.map), pdiplomat, ptile);
1577   if (pdiplomat->moves_left < 0) {
1578     pdiplomat->moves_left = 0;
1579   }
1580 }
1581
1582 /**************************************************************************
1583   This determines if a diplomat/spy succeeds against some defender,
1584   who is also a diplomat or spy. Note: a superspy defender always
1585   succeeds, otherwise a superspy attacker always wins.
1586
1587   Return TRUE if the "attacker" succeeds.
1588 **************************************************************************/
1589 static bool diplomat_success_vs_defender(struct unit *pattacker,
1590                                          struct unit *pdefender,
1591                                          struct tile *pdefender_tile)
1592 {
1593   int chance = 50; /* Base 50% chance */
1594
1595   if (unit_has_type_flag(pdefender, UTYF_SUPERSPY)) {
1596     /* A defending UTYF_SUPERSPY will defeat every possible attacker. */
1597     return FALSE;
1598   }
1599   if (unit_has_type_flag(pattacker, UTYF_SUPERSPY)) {
1600     /* An attacking UTYF_SUPERSPY will defeat every possible defender
1601      * except another UTYF_SUPERSPY. */
1602     return TRUE;
1603   }
1604
1605   /* Add or remove 25% if spy flag. */
1606   if (unit_has_type_flag(pattacker, UTYF_SPY)) {
1607     chance += 25;
1608   }
1609   if (unit_has_type_flag(pdefender, UTYF_SPY)) {
1610     chance -= 25;
1611   }
1612
1613   /* Use power_fact from veteran level to modify chance in a linear way.
1614    * Equal veteran levels cancel out.
1615    * It's probably not good for rulesets to allow this to have more than
1616    * 20% effect. */
1617   {
1618     const struct veteran_level
1619       *vatt = utype_veteran_level(unit_type_get(pattacker), pattacker->veteran);
1620     const struct veteran_level
1621       *vdef = utype_veteran_level(unit_type_get(pdefender), pdefender->veteran);
1622     fc_assert_ret_val(vatt != NULL && vdef != NULL, FALSE);
1623     chance += vatt->power_fact - vdef->power_fact;
1624   }
1625
1626   /* Reduce the chance of an attack by EFT_SPY_RESISTANT percent. */
1627   chance -= chance
1628             * get_target_bonus_effects(NULL,
1629                                        tile_owner(pdefender_tile), NULL,
1630                                        tile_city(pdefender_tile), NULL,
1631                                        pdefender_tile, NULL, NULL, NULL,
1632                                        NULL, NULL,
1633                                        EFT_SPY_RESISTANT) / 100;
1634
1635   return (int)fc_rand(100) < chance;
1636 }
1637
1638 /**************************************************************************
1639   This determines if a diplomat/spy succeeds in infiltrating a tile.
1640
1641   - The infiltrator must go up against each defender.
1642   - The victim unit won't defend. (NULL if everyone should defend)
1643   - One or the other is eliminated in each contest.
1644
1645   - Return TRUE if the infiltrator succeeds.
1646
1647   'pplayer' is the player who tries to do a spy/diplomat action on 'ptile'
1648   with the unit 'pdiplomat' against 'cplayer'.
1649 **************************************************************************/
1650 static bool diplomat_infiltrate_tile(struct player *pplayer,
1651                                      struct player *cplayer,
1652                                      const struct action *paction,
1653                                      struct unit *pdiplomat,
1654                                      struct unit *pvictim,
1655                                      struct tile *ptile)
1656 {
1657   char link_city[MAX_LEN_LINK] = "";
1658   char link_diplomat[MAX_LEN_LINK];
1659   char link_unit[MAX_LEN_LINK];
1660   struct city *pcity = tile_city(ptile);
1661
1662   if (pcity) {
1663     /* N.B.: *_link() always returns the same pointer. */
1664     sz_strlcpy(link_city, city_link(pcity));
1665   }
1666
1667   /* We don't need a _safe iterate since no transporters should be
1668    * destroyed. */
1669   unit_list_iterate(ptile->units, punit) {
1670     struct player *uplayer = unit_owner(punit);
1671
1672     /* I can't confirm if we won't deny that we weren't involved. */
1673     if (uplayer == pplayer) {
1674       continue;
1675     }
1676
1677     if (punit == pvictim
1678         && !unit_has_type_flag(punit, UTYF_SUPERSPY)) {
1679       /* The victim unit is defenseless unless it's a SuperSpy.
1680        * Rationalization: A regular diplomat don't mind being bribed. A
1681        * SuperSpy is high enough up the chain that accepting a bribe is
1682        * against his own interests. */
1683       continue;
1684     }
1685
1686     if (unit_has_type_flag(punit, UTYF_DIPLOMAT)
1687         || unit_has_type_flag(punit, UTYF_SUPERSPY)) {
1688       /* A UTYF_SUPERSPY unit may not actually be a spy, but a superboss
1689        * which we cannot allow puny diplomats from getting the better
1690        * of. UTYF_SUPERSPY vs UTYF_SUPERSPY in a diplomatic contest always
1691        * kills the attacker. */
1692
1693       if (diplomat_success_vs_defender(pdiplomat, punit, ptile)) {
1694         /* Defending Spy/Diplomat dies. */
1695
1696         /* N.B.: *_link() always returns the same pointer. */
1697         sz_strlcpy(link_unit, unit_tile_link(punit));
1698         sz_strlcpy(link_diplomat, unit_link(pdiplomat));
1699
1700         notify_player(pplayer, ptile, E_ENEMY_DIPLOMAT_FAILED, ftc_server,
1701                       /* TRANS: <unit> ... <diplomat> */
1702                       _("An enemy %s has been eliminated by your %s."),
1703                       link_unit, link_diplomat);
1704
1705         if (pcity) {
1706           if (uplayer == cplayer) {
1707             notify_player(cplayer, ptile, E_MY_DIPLOMAT_FAILED, ftc_server,
1708                           /* TRANS: <unit> ... <city> ... <diplomat> */
1709                           _("Your %s has been eliminated defending %s"
1710                             " against a %s."), link_unit, link_city,
1711                           link_diplomat);
1712           } else {
1713             notify_player(cplayer, ptile, E_MY_DIPLOMAT_FAILED, ftc_server,
1714                           /* TRANS: <nation adj> <unit> ... <city>
1715                            * TRANS: ... <diplomat> */
1716                           _("A %s %s has been eliminated defending %s "
1717                             "against a %s."),
1718                           nation_adjective_for_player(uplayer),
1719                           link_unit, link_city, link_diplomat);
1720             notify_player(uplayer, ptile, E_MY_DIPLOMAT_FAILED, ftc_server,
1721                           /* TRANS: ... <unit> ... <nation adj> <city>
1722                            * TRANS: ... <diplomat> */
1723                           _("Your %s has been eliminated defending %s %s "
1724                             "against a %s."), link_unit,
1725                           nation_adjective_for_player(cplayer),
1726                           link_city, link_diplomat);
1727           }
1728         } else {
1729           if (uplayer == cplayer) {
1730             notify_player(cplayer, ptile, E_MY_DIPLOMAT_FAILED, ftc_server,
1731                           /* TRANS: <unit> ... <diplomat> */
1732                           _("Your %s has been eliminated defending "
1733                             "against a %s."), link_unit, link_diplomat);
1734           } else {
1735             notify_player(cplayer, ptile, E_MY_DIPLOMAT_FAILED, ftc_server,
1736                           /* TRANS: <nation adj> <unit> ... <diplomat> */
1737                           _("A %s %s has been eliminated defending "
1738                             "against a %s."),
1739                           nation_adjective_for_player(uplayer),
1740                           link_unit, link_diplomat);
1741             notify_player(uplayer, ptile, E_MY_DIPLOMAT_FAILED, ftc_server,
1742                           /* TRANS: ... <unit> ... <diplomat> */
1743                           _("Your %s has been eliminated defending "
1744                             "against a %s."), link_unit, link_diplomat);
1745           }
1746         }
1747
1748         pdiplomat->moves_left = MAX(0, pdiplomat->moves_left - SINGLE_MOVE);
1749
1750         /* Attacking unit became more experienced? */
1751         if (maybe_make_veteran(pdiplomat)) {
1752           notify_unit_experience(pdiplomat);
1753         }
1754         send_unit_info(NULL, pdiplomat);
1755         wipe_unit(punit, ULR_ELIMINATED, pplayer);
1756         return FALSE;
1757       } else {
1758         /* Attacking Spy/Diplomat dies. */
1759
1760         const char *victim_link;
1761
1762         /* N.B.: *_link() always returns the same pointer. */
1763         sz_strlcpy(link_unit, unit_link(punit));
1764         sz_strlcpy(link_diplomat, unit_tile_link(pdiplomat));
1765
1766         notify_player(pplayer, ptile, E_MY_DIPLOMAT_FAILED, ftc_server,
1767                       _("Your %s was eliminated by a defending %s."),
1768                       link_diplomat, link_unit);
1769
1770         if (pcity) {
1771           if (uplayer == cplayer) {
1772             notify_player(cplayer, ptile, E_ENEMY_DIPLOMAT_FAILED, ftc_server,
1773                           _("Eliminated a %s %s while infiltrating %s."),
1774                           nation_adjective_for_player(pplayer),
1775                           link_diplomat, link_city);
1776           } else {
1777             notify_player(cplayer, ptile, E_ENEMY_DIPLOMAT_FAILED, ftc_server,
1778                           _("A %s %s eliminated a %s %s while infiltrating "
1779                             "%s."), nation_adjective_for_player(uplayer),
1780                           link_unit, nation_adjective_for_player(pplayer),
1781                           link_diplomat, link_city);
1782             notify_player(uplayer, ptile, E_ENEMY_DIPLOMAT_FAILED, ftc_server,
1783                           _("Your %s eliminated a %s %s while infiltrating "
1784                             "%s."), link_unit,
1785                           nation_adjective_for_player(pplayer),
1786                           link_diplomat, link_city);
1787           }
1788         } else {
1789           if (uplayer == cplayer) {
1790             notify_player(cplayer, ptile, E_ENEMY_DIPLOMAT_FAILED, ftc_server,
1791                           _("Eliminated a %s %s while infiltrating our troops."),
1792                           nation_adjective_for_player(pplayer),
1793                           link_diplomat);
1794           } else {
1795             notify_player(cplayer, ptile, E_ENEMY_DIPLOMAT_FAILED, ftc_server,
1796                           _("A %s %s eliminated a %s %s while infiltrating our "
1797                             "troops."), nation_adjective_for_player(uplayer),
1798                           link_unit, nation_adjective_for_player(pplayer),
1799                           link_diplomat);
1800             notify_player(uplayer, ptile, E_ENEMY_DIPLOMAT_FAILED, ftc_server,
1801                           /* TRANS: ... <unit> ... <diplomat> */
1802                           _("Your %s eliminated a %s %s while infiltrating our "
1803                             "troops."), link_unit,
1804                           nation_adjective_for_player(pplayer),
1805                           link_diplomat);
1806           }
1807         }
1808
1809         /* Defending unit became more experienced? */
1810         if (maybe_make_veteran(punit)) {
1811           notify_unit_experience(punit);
1812         }
1813
1814         switch (action_get_target_kind(paction)) {
1815         case ATK_CITY:
1816           victim_link = city_link(pcity);
1817           break;
1818         case ATK_UNIT:
1819         case ATK_UNITS:
1820           victim_link = pvictim ? unit_tile_link(pvictim)
1821                                 : tile_link(ptile);
1822           break;
1823         case ATK_TILE:
1824           victim_link = tile_link(ptile);
1825           break;
1826         case ATK_SELF:
1827           /* How did a self targeted action end up here? */
1828           fc_assert(action_get_target_kind(paction) != ATK_SELF);
1829         default:
1830           victim_link = NULL;
1831           break;
1832         }
1833
1834         fc_assert(victim_link != NULL);
1835
1836         action_consequence_caught(paction, pplayer, cplayer,
1837                                   ptile, victim_link);
1838
1839         wipe_unit(pdiplomat, ULR_ELIMINATED, uplayer);
1840         return FALSE;
1841       }
1842     }
1843   } unit_list_iterate_end;
1844
1845   return TRUE;
1846 }
1847
1848 /**************************************************************************
1849   This determines if a diplomat/spy survives and escapes.
1850   If "pcity" is NULL, assume action was in the field.
1851
1852   Spies have a game.server.diplchance specified chance of survival (better
1853   if veteran):
1854     - Diplomats always die.
1855     - Escapes to home city.
1856     - Escapee may become a veteran.
1857 **************************************************************************/
1858 static void diplomat_escape(struct player *pplayer, struct unit *pdiplomat,
1859                             const struct city *pcity,
1860                             const struct action *paction)
1861 {
1862   struct tile *ptile;
1863   const char *vlink;
1864
1865   if (pcity) {
1866     ptile = city_tile(pcity);
1867     vlink = city_link(pcity);
1868   } else {
1869     ptile = unit_tile(pdiplomat);
1870     vlink = NULL;
1871   }
1872
1873   return diplomat_escape_full(pplayer, pdiplomat, pcity != NULL,
1874                               ptile, vlink, paction);
1875 }
1876
1877 /**************************************************************************
1878   This determines if a diplomat/spy survives and escapes.
1879
1880   Spies have a game.server.diplchance specified chance of survival (better
1881   if veteran):
1882     - Diplomats always die.
1883     - Escapes to home city.
1884     - Escapee may become a veteran.
1885 **************************************************************************/
1886 static void diplomat_escape_full(struct player *pplayer,
1887                                  struct unit *pdiplomat,
1888                                  bool city_related,
1889                                  struct tile *ptile,
1890                                  const char *vlink,
1891                                  const struct action *paction)
1892 {
1893   int escapechance;
1894   struct city *spyhome;
1895
1896   /* Veteran level's power factor's effect on escape chance is relative to
1897    * unpromoted unit's power factor */
1898   {
1899     const struct veteran_level
1900       *vunit = utype_veteran_level(unit_type_get(pdiplomat), pdiplomat->veteran);
1901     const struct veteran_level
1902       *vbase = utype_veteran_level(unit_type_get(pdiplomat), 0);
1903
1904     escapechance = game.server.diplchance
1905       + (vunit->power_fact - vbase->power_fact);
1906   }
1907
1908   /* find closest city for escape target */
1909   spyhome = find_closest_city(ptile, NULL, unit_owner(pdiplomat), FALSE,
1910                               FALSE, FALSE, TRUE, FALSE, NULL);
1911
1912   if (spyhome
1913       && !utype_is_consumed_by_action(paction, unit_type_get(pdiplomat))
1914       && (unit_has_type_flag(pdiplomat, UTYF_SUPERSPY)
1915           || fc_rand (100) < escapechance)) {
1916     /* Attacking Spy/Diplomat survives. */
1917     notify_player(pplayer, ptile, E_MY_DIPLOMAT_ESCAPE, ftc_server,
1918                   _("Your %s has successfully completed"
1919                     " the mission and returned unharmed to %s."),
1920                   unit_link(pdiplomat),
1921                   city_link(spyhome));
1922     if (maybe_make_veteran(pdiplomat)) {
1923       notify_unit_experience(pdiplomat);
1924     }
1925
1926     /* being teleported costs all movement */
1927     if (!teleport_unit_to_city (pdiplomat, spyhome, -1, FALSE)) {
1928       send_unit_info(NULL, pdiplomat);
1929       log_error("Bug in diplomat_escape: Spy can't teleport.");
1930       return;
1931     }
1932
1933     return;
1934   } else {
1935     if (city_related) {
1936       notify_player(pplayer, ptile, E_MY_DIPLOMAT_FAILED, ftc_server,
1937                     _("Your %s was captured after completing"
1938                       " the mission in %s."),
1939                     unit_tile_link(pdiplomat),
1940                     vlink);
1941     } else {
1942       notify_player(pplayer, ptile, E_MY_DIPLOMAT_FAILED, ftc_server,
1943                     _("Your %s was captured after completing"
1944                       " the mission."),
1945                     unit_tile_link(pdiplomat));
1946     }
1947   }
1948
1949   if (!utype_is_consumed_by_action(paction, unit_type_get(pdiplomat))) {
1950     /* The unit was caught, not spent. It must therefore be deleted by
1951      * hand. */
1952     wipe_unit(pdiplomat, ULR_CAUGHT, NULL);
1953   }
1954 }
1955
1956 /**************************************************************************
1957  return number of diplomats on this square.  AJS 20000130
1958 **************************************************************************/
1959 int count_diplomats_on_tile(struct tile *ptile)
1960 {
1961   int count = 0;
1962
1963   unit_list_iterate((ptile)->units, punit) {
1964     if (unit_has_type_flag(punit, UTYF_DIPLOMAT)) {
1965       count++;
1966     }
1967   } unit_list_iterate_end;
1968
1969   return count;
1970 }