DELTA 29311 0 216
SVN  ìì!w Ð? … EÐ?… rÒ€E ˆ{Ô;¨ Ž9ÝT_type_typeo) {
      fc_snprintf(buf[o], BUFFER_SIZE, "%+3d", result->surplus[o_types)), "",
              citizen_typeENDREP
DELTA 29117 145 333
SVN  ‚·2‚¸0…7 ûA €W Ñ*û`€‚; dÏ)€r zÐ{ˆ „ZÑ{ˆ tÖ[€# ÞIØi                                 Output_type_id otype,
                                                           enum citizen_category *categories)
{
  int i = 0, n;

  fc_assert(index >= 0 && index < FEELING_LAST);

  for (n = 0; n < pcity->feel[CITIZEN_HAPPY][index]; n++, i++) {
    categories[i] = CITIZEN_HAPPY;
  }
  for (n = 0; n < pcity->feel[CITIZEN_CONTENT][index]; n++, i++) {
    categorieategories[i] = CITIZEN_UNHAPPY;
  }
  for (n = 0; n < pcity->feel[CITIZEN_ANGRY][index]; n++, i++) {
    categorieategorieategorieategories);

  if (citizen_index < 0 || citizen_index >= num_citizens
      || categories[citizen_index] < CITIZEN_SPECIALIST) {
    return;
  }
  from = categorieENDREP
DELTA 20306 13385 3029
SVN  ÑyÓ6S…v ‹r … ‰>‹r— ‚:•A• ƒ ˜
… ƒi›*… †4Ÿ… ‚=¥G… ‰7¨… …!±;€ƒz a¹n… ŠFºO€# ˆ}Æ… ‚IÏ…Ñbmain_main_fcl, str, "cmd");
main_fcl, filename);
main_main_main_main_main_main_fcl != NULL) {
    fc_assert_ret_val(main_fcl->state != NULL, FALSE);

    return TRUE;
  }

  main_fcl = luascript_new(script_client_output);
  if (main_fcl == NULL) {
    luascript_destroy(main_fcl); /* TODO: main_fcl is NULL here... */
    main_fcl = NULL;

    return FALSE;
  }

  tolua_common_a_open(main_fcl->state);
  api_specenum_open(main_fcl->state);
  tolua_game_open(main_fcl->state);
  tolua_signal_open(main_fcl->state);
  tolua_client_open(main_fcl->state);
  tolua_common_z_open(main_main_main_fcl != NULL) {
    script_client_code_free();
    script_client_vars_free();

    luascript_signal_free(main_fcl);

    luascript_destroy(main_fcl);
    main_main_main_ENDREP
DELTA 29547 7114 1233
SVN  †  †  3ƒ? …Â) ‚ …c…Â*’ f…È« ‚+…É+€} V…ÌG€ †N…ÎF€ É …Öbebe = 0; be < 2; bebe]);
        SET_SPRITE(grid.borders[i][bentw = t->normal_tile_width, nth = t->normal_tile_height;
      int offsets[4][2] = {{ntw / 2, 0}, {0, nth / 2}, {ntw / 2, nth                                                offsets[i][1], ntw / 2, nth / 2,
                                                vi, k = i;

      for (vi = 0; vi < 4; vi++) {
	values[vi] = k % 3;
	k /= 3;

	cat_snprintf(buf, sizeof(buf), "_%c", ids[values[vi†  †  †  f‰I€p ƒ €‚
 … ‘.†3€ ªW‚˜Eµ ÂƒÃO _„…k¿ ¼+„‡ ‡/„Ã2 …„Êa º„Ïf€‚ ÿh…‹e€! Q†Œi€( Ž_†S ESTYLE_ROAD_ALL_COMBINED:
  case ESTYLE_RIVER:
    tileset_setup_road(t, pextra);
    break;

  case ESTYLE_SINbl = draw->blending - 1;

    if (NULL == draw->blender) {
      int li = 0;

      /* try an already loaded base */
      while (NULL == draw->blender
        &&  li < draw->blending
        &&  0 < draw->layer[li].base.size) {
        draw->blender = draw->layer[lb        enum direction8 vdir = t->valid_tileset_dirs[i];

        if (draw_road[vdir]) {
          road_tileno |= 1 << i;
        focus) {
        if (!is_native_tile(unit_type(pfocusccdir]) == TC_OCEAN
                  || BV_ISSET(textras_near[ceeepunit == NULL) {
    return NULL;
  }

  if (citymode && unit_owner(punit) == city_owner(citymode)) {
    return NULL;
  }

  if (!unit_is_in_focus(punit)
      || t->sprites.unit.select[0] || focus_unit_state == 0) {
    return punit;
  } else {
    return NULL;
  }wi;

  /* We currently have no city sprites loaded. */
  t->sprites.city.tile     = NULL;

  for (wi = 0; wi < NUM_WALL_TYPES; wi++) {
    t->sprites.city.wall[wedge, j, id = player_slot_index(pslot);

    for (edge = 0; edge < EDGE_COUNT; edge++) {
      for (j = 0; j < 2; j++) {
        t->sprites.player[id].grid_borders[edgeŒÀ ¾cÀ1Q› U‡:¶ `‰? ¾+8[resource_index(presource)]Return a representative sprite for the given extra typENDREP
DELTA 29732 2182 227
SVN  †  †  nŠ ‚‘, €h …n‚’€‚ ƒƒš!¥ nƒd€I „ƒŸ 8ƒ£!€L uƒ¥€1 nƒ¬4º mƒ¨j€ Zƒªj€p nƒ¬4º mƒ¨j ¯ƒ®J€k „Þ;¸ ¿}„ßswtile) {
        if (wtile->worked == pcity) {
          int dist_sq = sq_map_distance(pcenter, wtile);
hcity;

      if ((hcity = game_city_by_number(punit->homecity))) {
	unit_list_remove(hcity->units_supported, punit);
	refresh_city_dialog(hcity);
      }

      punit->homecity = packet_unit->homecity;
      if ((hcity = game_city_by_number(punit->homecity))) {
	unit_list_prepend(hccity = tile_city(unit_tile(punit));
ccity != NULL && (ccity->id != punit->homecity)) {
	refresh_city_dialog(cc (ccity != NULL)  {
	if (can_player_see_units_in_city(client.conn.playing, cccity->tile->units) > 0);

          if (ccity->client.occupied != new_occupied) {
            ccity->client.occupied = new_occupied;
            refresh_city_mapcanvas(ccity, cccity);
            }
          }
        }

        if (cccity);
        }
      }

      if ((ccity = tile_city(unit_tile(punit)))) {
        if (can_player_see_units_in_city(client.conn.playing, cccity->client.occupied) {
            ccity->client.occupied = TRUE;
            refresh_city_mapcanvas(ccity, cccity);
            }
          }
        }

        if (ccadvi) {
    newstate = packet->inventions[advi] - '0';
    oldstate = research_invention_set(presearch, advadvi) {
          gained_techs[gained_techs_num++] = adv†  ƒƒ4ƒƒ[‚P ½ €‚@ ‚Ä	¿+lass);
    set_udbg) {
      log_debug("Improvement: %s...", improvement_rule_name(bdbg));
      log_debug("  build_cost %3d", bdbg->build_cost);
      log_debug("  upkeep      %2d", bdbg->upkeep);
      log_debug("  sabotage   %3d", bdbg->sabotage);
      if (NULL != bdbg->helptext) {
        strvec_iterate(bdbg->helptext, text) {
  ENDREP
DELTA 29010 38915 294
SVN  ‚–z‚—&\ Üj » 6Ý" "Þs‚ là‚ _á ´âasp) {
    struct specialist *s = specialist_by_number(sp);
sp], sizeof(sp_explanation[spspspENDREP
DELTA 29303 0 78
SVN  ºº` ëV €` Í`ì-hilicity) {
      if (is_city_hilited(hilicity)) {
        clipboard_send_production_packet(hiliENDREP
DELTA 27397 2371 348
SVN  žEžG
 ”b ˆ ‰]”hategorieENDREP
DELTA 24790 195077 2169
SVN  ‰+‰7‚ ¶D ¼ X¶~€b Ï}¹.0 = options.overview.map_x0 * OVERVIEW_TILE_SIZE;
    int y00;
    int iy = options.overview.height - y0;

    canvas_copy(dst, src, 0, 0, ix, iy, x0, y0);
    canvas_copy(dst, src, 0, y0, ix, 0, x0, iy);
    canvas_copy(dst, src, x0, 0, 0, iy, ix, y0);
    canvas_copy(dst, src, x0, y0ENDREP
DELTA 29287 4526 61
SVN  †  †  2‚E „±8 €A ‹V„±e€Z ‹g„¾€P n„Ê$€Z ²*„ÌX ‡	…ÿ ™%††base_x, int canvas_base_y,
			    int width_base, int height_basebase_x - dx / 2,
			 mapview.gui_y0 + canvas_base_y - dy,
			 width_base + dx, height_basebase_x, int canvas_base_y,
                      int width_base, int height_basebase_x - dx / 2,
			 mapview.gui_y0 + canvas_base_y - dy,
			 width_base + dx, height_base†  È*ÈA;†€D û; €w xý rþ2€ f%€d Jƒ€] b†7 `‡ _ˆ ¾I‰a.  Another would
   * be to prevent the window from getting too larg;
  struct tileset *t = tileset;

  spr = get_spaceship_sprite(t, SPACESHIP_HABITATION);
  get_sprite_dimensions(spr, &w, &h);

  canvas_put_rectangle(pcanvas,
                       get_color(tileset, COLOR_SPACESHIP_BACKGROUND),
                 = (k == 0 ? get_spaceship_sprite(t, SPACESHIP_HABITATION)
           : k == 1 ? get_spaceship_sprite(t, SPACESHIP_LIFE_SUPPORT)
     );
  }

  for (i = 0; i < NUM_SS_COMPONENTS; i++) {
    const int j = i / 2;
    const int k = i % 2 = ((k == 0) ? get_spaceship_sprite(t, SPACESHIP_FUEL)
           : get_spaceship_sprite(t, SPACESHIP_PROPULSION));

    canvas_put_sprite_full(pcanvas, x, y, spr);

    if (k && ship->state == SSHIP_LAUNCHED) {
      sprENDREP
DELTA 16571 0 71566
SVN  …ò3†  0ô) …X €_ R†/€‚[ P‡|˜ W‰i€9 IŠ`‡ mŒ)€ 
Ž]µ 'e¿ ‘€l s’}€N ‚>“mŒ RƒÝ@€O ‚a—vŒ RƒÝ@€„ Tì>  UÂ@ ‚O¡Jº …Y¤5 ª€B U‚‰@€ Tì> t«4† j­.€ [¯'º Tì> ƒx°v† …Q´t€A Rº~€„l ‚2¿ƒ U„µ@ Â …Ä€m ‚{Ëˆ HÍ|£ UÂ@€t ~Ñu– U‚‰@€ Sì? fÒr» …8ÕŽ …bÚM” ~à>€` eä!€] X‚±> æ4Ž ƒgçA€~ Tì>¨ VÂ?˜ ‚çA OéY€L W‚±> í€ Wƒ“  „ïm‘ ^ô‡ gõr€q c÷! ‚	ù’ vû/€} Mý|‹ -ÿQ€ˆ- @†3½ ‚ˆ"Ž zŠDˆ „+Œ> ƒy€R Tì= }•: F—Nš d™)š I›"€# ƒ11˜ . }˜ …4¢FŠ V¨€Q rª€h „9¬f€…[ ³V€| RµI „7Ã&º …Ç_€O O‚‰?€: Sì? JØu€ N‚‰@€E Ûx€) dÜe€} TÞ-€‚[ Kà:€…` ‚èv€‹C aë{¯ ‚ŸsŒ ƒ6íˆ …ñ5ˆ ‰öD€V †‚€ „‚‡ˆ ‚‹8€n N‚‰@€ˆU ‚i‚‹€f ƒ‚m€…r ‚—o€„
 }‚›€^ ZƒÝ@€Z d‚t€‚5  ‚ŸgŒ ‚g‚¡ _‚£~ '‚¤h£ ‚d‚¦2¥ F‚© ƒ‚ª^ ‚)‚­z€t Y‚°=¡ S‚‰; „a‚²f Qì?€B L‚‰@€‚  ƒ~‚·V€S D‚»x€: R‚¿=Š }‚À€‚& ‚Ã6€( ‚Åf€ƒ  Sì?€> w‚Ëv¸ O‚‰?€‚ X‚Ó~€V N‚‰@€T „2‚Ó~€‚ p‚ó. „‚Û€‡# Sì?€~ N‚‰@€ Sì?€} O‚‰? ^‚æ&€‚ Wƒ“ ¨ ‚‚ìl° %‚îq“ .‚ð&¨ N‚‰@€_ +‚ò~Ž N‚‰@€c ƒM‚õn ‚#‚ùF£ L‚‰@€e ‚c‚ýC€A ‚Hƒ€K™ ƒƒB‘ ƒ„U’ ƒ…}’ V‚±@€g N‚‰@€„A X‚±>Ÿ ƒ'ƒ“Y€  ‚ƒ—s€G O‚‰? iƒšG¥ Tƒ‘9¹ ví• ‚Lƒž,• ‚cƒ z  N‚‰@€‡ U‚±@ª aƒÝ@€s ‚dƒ¯;¤ ‚Qƒ²3• ƒÌ› aƒÝ@€^ 	ƒÌ~— aƒÝ@€] vƒÌ  N‚‰@€y ƒÌˆ fƒÛ €N ‚_ƒº&˜ ƒÌ bƒÝ?€W ‚Uƒ¿]ˆ ‚[ƒÂ2 	ƒÌ~‡ aƒÝ@€Z ƒÌ‰ aƒÝ@€P ‚PƒÊˆ ‚LƒÌoˆ ‚AƒÏ;ˆ ƒÑ|ƒ cƒÛ €a ƒÌ‡ bƒÝ?€Z 
ƒÌ}‰ aƒÝ@€P ‚BƒÙfˆ ‚=ƒÜ(‘ wƒÌ~¨ N‚‰@€ wƒÌ~Ÿ N‚‰@€w ‚=ƒÞn— ƒÌŠ aƒÝ@€Q !ƒãv– ‚8ƒå€V 2ƒçS€| X‚±>¢ O‚‰?€ƒ% cƒëi€ ƒ&ƒí€} hƒñu€L wƒôC€„( ƒFƒ÷k€2 Yƒû|  ƒvƒüsˆ ƒ$„ € e„Šr „ŒWµ ‚„e½ ‚I„*ˆ S„’s¹ <„“l€q ƒb„—˜ ‡„›¬ ‡%„¢8¬ _„©s® ‚„«i¬ ‰}„® ‚%„¸! …|„¼j³ ‚„Âs€} )„Á=³ ‚X„Ç€ƒ ‚0„Ìž ‚w„Î`ž …„ÑY¸ …„×Ÿ ‚0„Ü,¦ Sƒà  ^„ß1€` ‚&„àu€V Sì?¦ Sƒà €c F„çuž Sƒà ­ Uì= Sƒà €B Rì? ƒŒo€K Sì?œ Sƒà  „ïP› Sƒà   „ñ=© Sƒà €‚T s„à|Ÿ Sƒà  „C„ö"€] X‚±>— Sƒà  „üf¢ Lƒà ž M…yŒ m„Û=° Sƒà  …€~€$ s„à|  Sƒà  …p…„5Ž 
…Œa† N…x m„Û=¢ Sƒà €L Sì?› Sƒà  ‚5…“± Sƒà   …–%€$ s„à|¤ Sƒà  `…™^° MƒÝ@€ƒk s„à|° MƒÝ@€„ s„à| Sƒà €K Sì?ž Sƒà ½ Sì?› Sƒà  i…“+¬ s„à|¤ Sƒà €R Sì?ª Sƒà €ƒi s„à|› Sƒà  ‚,…¬£ Sƒà  ‡	…¯³ ‚…¶;† u…¸U u…ºUŽ „…»XŽ 6…¿rµ …1…Á]¤ Sƒà  ƒ'…Çc” …È~€^fc_config.h>
#endif

/* utility */
#include "astring.h"
#include "bitvector.h"
#include "fcintlcombat.h"
#include "game.h"
#include "map.h"
#include "movement.h"
#include "unitlist.h"

/* common/aicore */
#include "path_finding.h"

/* client/include */
#include "chatline_g.h"
#include "citydlg_g.h"
#include "dialogs_g.h"
#include "gui_main_g.h"
#include "mapctrl_g.h"
#include "mapview_g.h"
#include "menu_g.h"

/* client */
#include "audioeditor.h"
#include "gotopdate_queue.h"

#include "control.h"


struct client_nuke_data {
  int *units_id;
  int units_num;
  int tile_idx;
};

/* Move on in the diplomat queue. */
#define ACTION_CHOOSE_NEXT -1 = NULL*/
static struct unit_list *previous_focus = NULL;

/* The priority unit(s) for unit_focus_advance(). */
static struct unit_list *urgent_focus_queue = NULLstruct extra_type *connect_tgt;

int goto_last_actionCurrent moving unit. */
static struct unit *punit_moving = NULL */
static struct genlist *diplomat_arrival_queue = NULL;

static bool have_asked_server_for_actions = FALSEstatic void key_unit_clean(enum unit_activity act, enum extra_rmcause rmcause)lient_main.ccontrol_init(void)
{
  int i;

  diplomat_arrival_queue = genlist_new_full(freelient_main.ccontrol_free(void)
{
  int i;

  genlist_destroy(diplomat_arrival_queue);
  diplomat_arrival_queue = NULL;

  unit_list_destroy(current_focus);
  current_focus = NULL;
  unit_list_destroy(previous_focus);
  previous_focus = NULL;
  unit_list_destroy(urgent_focus_queue);
  urgent_focus_queue = NULL;

  for (i = 0; i < MAX_NUM_BATTLEGROUPS; i++) {
    unit_list_destroy(battlegroups[i]);
    battlegroups[i] = NULL;
  }

  set_hover_state(NULL, HOVER_NONE,
                  ACTIVITY_LAST, NULL, ACTION_COUNT, ORDER_LAST);
  free_client_goto Returns list of units currently(NULL != current_focus ? unit_list_size(current_focus) : 0nit_focus_urgentDo various updates required when the set of units in focus changesvoid focus_units_changed(void)
{
  update_unit_info_label(get_units_in_focus());
  menus_update();
  /* Notify the GUI */
  real_focus_units_changedremove
                    ACTIVITY_LAST, NULL, ACTION_COUNT, ORDER_LAST);
  }

  unit_list_remove(previous_focus, punit);
  unit_list_removeremove(battlegroups[i], punit);
  }

  focus_units_changedremoveIRRIGATE, etc.)
    order => The last order (ORDER_PERFORM_ACTION                     struct extra_type *tgt,
                     int action,
                     enum unit_orders order)
{
  fc_assert_ret((punits && unit_list_size(punits) > 0)
                || state == HOVER_NONE);
  fc_assert_ret(state == HOVER_CONNECT || activity == ACTIVITY_LAST);
  fc_assert_ret(state == HOVER_GOTO || order == ORDER_LAST);
  fc_assert_ret(state == HOVER_GOTO || action == ACTION_COUNT);
  exit_goto_state();
  hover_state = state;
  connect_activity = activity;
  if (tgt) {
    connect_tgt = tgt;
  } else {
    connect_tgt = NULL;
  }
  goto_last_order = order;
  goto_last_action = action !=unit_tile(punit)unit_tile(punit);
  } else if (get_num_units_in_focus() > 0) {
    return unit_tile(head_of_units_in_focus())options.Add unit to list of units currently/
static void current_focus_append(struct unit *punit)
{
  unit_list_append(current_focus, punit);

  punit->client.focus_status = FOCUS_AVAIL;
  refresh_unit_mapcanvas(punit, unit_tile(punit), TRUE, FALSE);

  if (options.unit_selection_clearsRemove focus from unitvoid current_focus_remove(struct unit *punit)
{
  unit_list_remove(current_focus, punit);
  refresh_unit_mapcanvas(punit, unit_tile(punit), TRUE, FALSE
      || punit->ai_controlled)  {
    punit->ai_controlledunit_focus_setunit_tile(punit_old)fc_assert(punit == NULL);
    return;
  }

  if (NULL != punit) {
    current_focus_append(punit
                    ACTIVITY_LAST, NULL, ACTION_COUNT, ORDER_LAST);
    focus_units_changed(unit_focus_add
                    ACTIVITY_LAST, NULL, ACTION_COUNT, ORDER_LAST);
  }

  current_focus_append(punit);
  focus_units_changed Removes this unit from the list of unit/
void unit_focus_remove!
                    ACTIVITY_LAST, NULL, ACTION_COUNT, ORDER_LAST);
  }

  current_focus_remove(punit);
  if (get_num_units_in_focus() > 0) {
    focus_units_changed();
  } else {
    unit_focus_advance(unit_focus_set_and_select(struct unit *punit)
{
  unit_focus_set(punit);
  if (punit) {
    put_cross_overlay_tile(unit_tile(punitunit_tile(pfirst)client.(punit->moves_left > 0 || unit_type(punit)->move_rate == 0)
	  && !punit->done_moving
	  && !punit->ai_controllednit_focus_updateunit_focus_advanceunit_focus_set(NULL);
    return;
  }

  set_hover_state(NULL, HOVER_NONE,
                  ACTIVITY_LAST, NULL, ACTION_COUN_controlledstruct tile *focus_tile = (get_num_units_in_focus() > 0
                               ? unit_tile(head_of_units_in_focus())
                               : NULL);

    unit_list_both_iterate(urgent_focus_queue, plink, punit) {
      if (ACTIVITY_IDLE != punit->activity
          || unit_has_orders(punit)) {
        /* We have assigned new orders to this unit since, remove it. */
        unit_list_erase(urgent_focus_queue, plink);
      } else if (NULL == focus_tile
                 || focus_tile == unit_tile(punit)) {
        /* Use the first one found */
        candidate = punit;
        break;
      } else if (NULL == candidate) {
        candidate = punit;
      }
    } unit_list_both_iterate_end;

    if (NULL != candidate) {
      unit_list_remove(urgent_focus_queue, candidate);

      /* Autocenter on Wakeup, regardless of the local option
       * "auto_center_on_unit". */
      if (!tile_visible_and_not_on_border_mapcanvas(unit_tile(candidate))) {
        center_tile_mapcanvas(unit_tile(candidate));
      }
    }
  }

  if (NULL == candidate)client.focus_status == FOCUS_WAIT) {
          punit->client.unit_focus_setoptions.nit_focus_update_controlled) {
      return;
    }
  } unit_list_iterate_end;

  unit_focus_advancunit_tile(punit_attacking)unit_tile(punit_defending)unit_list_iterate(get_units_in_focus(), punit) {
    if (punit != punit_moving && unit_tile(punit) == ptile) {
      return punit;
    }
  } unit_list_iterate_end;!unit_transported(punit)!unit_transported(punit)timer_readtimer_renew(blink_timer, TIMER_USER, TIMER_ACTIVE);
      timer_start(blink_timerunit_tile(punit), FALSE, TRUE);
      } unit_list_iterate_end;
    }

    return blink_time - timer_read
      && is_player_phase(client.conn.playing, game.info.phase)) {
    if (!blink_timer || timer_read_seconds(blink_timer) > blink_time) {
      int is_waiting = 0, is_moving = 0;
      bool blocking_mode;
      struct option *opt;

      opt = optset_option_by_name(server_optset, "turnblock");
      if (opt != NULL) {
        blocking_mode = option_bool_get(opt);
      } else {
        blocking_mode = FALSE;
      }

      players_iterate_alive(pplayer) {
        if ((pplayer->is_connected || blocking_mode)
            && is_player_phase(pplayer, game.info.phase)) {
          if (pplayer->phase_done) {
            is_waiting++;
          } else {
            is_moving++;
          }
        }
      } players_iterate_alivtimer_renew(blink_timer, TIMER_USER, TIMER_ACTIVE);
      timer_start(blink_timer);
    }
    return blink_time - timer_readunit_tile(punit)  Adjusts way combatants are displayed suitable for combatMove along the queue of units that need player input about what action
  to takvoid choose_action_queue_next(void)
{
  /* This was called because the queue can move on. */
  have_asked_server_for_actions = FALSE;

  process_diplomat_arrival(NULL, ACTION_CHOOSE_NEXT and target_tile_id is ACTION_CHOOSE_NEXT, just do for
  the next arrival in the queue.
  Please use choose_action_queue_next() to move the queue alongvoid process_diplomat_arrival(struct unit *pdiplomat, int target_tileAn unit that isn't there asks for input about what action to take.
   * This isn't a request to move on. */
  if (!pdiplomat && (target_tile_id != ACTION_CHOOSE_NEXT)) {the punit.id of the diplomat and the index of the targeted tile. */

  if (pdiplomat) {
    /* A new unit should be queued */target_tile_id;
    genlist_prepend(diplomat_arrival_queue, p_ids);
  }

  /* There can only be one dialog at a time.
   * Stop if one is (about to pop) up. */
  if (have_asked_server_for_actions
      || action_selection_actor_unit() != IDENTITY_NUMBER_ZERO) {
    return;
  }

  /* Request a list of actions for the first element in the queue */tgt_tile_id;
    struct tile *ptile;

    p_ids = genlist_get(diplomat_arrival_queue, 0);
    diplomat_id = p_ids[0];
    tgt_tile_id = p_ids[1];
    genlist_remove(diplomat_arrival_queue, p_ids); /* Do free(p_ids). */

    pdiplomat = player_unit_by_number(client_player(), diplomat_id);
    ptile = index_to_tile(tgt_tile_id);

    if (ptile && pdiplomat && is_actor_unit(pdiplomat)) {
      have_asked_server_for_actions = TRUE;
      dsend_packet_unit_get_actions(&client.conn,
                                    diplomat_id,
                                    IDENTITY_NUMBER_ZERO,
                                    IDENTITY_NUMBER_ZERO,
                                    tgt_tile_id,
                                    TRUE, int action_id)
{
  struct unit_list *punits = get_units_in_focus();

  fc_assert_ret(action_id == ACTION_COUNT
                || last_order == ORDER_PERFORM_ACTION);

  if (unit_list_size(punits) == 0) {
    return;
  }

  if (last_order == ORDER_PERFORM_ACTION) {
    fc_assert_ret(action_id != ACTION_COUNT);

    unit_list_iterate(punits, punit) {
      if (!unit_can_do_action(punit, action_id)) {
        /* This unit can't perform the action specified in the last
         * order. */

        struct astring astr = ASTRING_INIT;

        if (role_units_translations(&astr,
                                    action_get_role(action_id),
                                    TRUE)) {
          /* ...but other units can perform it. */

          create_event(unit_tile(punit), E_BAD_COMMAND, ftc_client,
                        /* TRANS: Only Nuclear or ICBM can do Explode
                         * Nuclear. */
                       _("Only %s can do %s."),
                       astr_str(&astr),
                       gen_action_translated_name(action_id));

          astr_free(&astr);
        } else {
          create_event(unit_tile(punit), E_BAD_COMMAND, ftc_client,
                       /* TRANS: Spy can't do Explode Nuclear. */
                       _("%s can't do %s."),
                       unit_name_translation(punit),
                       gen_action_translated_name(action_id));
        }

        return;
      }
    } unit_list_iterate_endNULL,
                    action_id, last_orderfc_assert_re
       options., nuke or will attack. */
    if (is_valid_goto_destination(ptile)) {
      if (goto_last_action == ACTION_NUKE) {
        /* Goto results in nuclear attack. */
        mouse_cursor_type = CURSOR_NUKE;
      } elseactivityFill orders to build recursive roads. This modifies ptile, so virtual
  copy of the real tile should be passedint check_recursive_road_connect(struct tile *ptile, const struct extra_type *pextra,
                                 const struct unit *punit, const struct player *pplayer, int rec)
{
  int activity_mc = 0;
  struct terrain *pterrain = tile_terrain(ptile);

  if (rec > MAX_EXTRA_TYPES) {
    return -1;
  }

  if (!is_extra_caused_by(pextra, EC_ROAD)) {
    return -1;
  }

  extra_deps_iterate(&(pextra->reqs), pdep) {
    if (!tile_has_extra(ptile, pdep)) {
      int single_mc;

      single_mc = check_recursive_road_connect(ptile, pdep, punit, pplayer, rec + 1);

      if (single_mc < 0) {
        return -1;
      }

      activity_mc += single_mc;
    }
  } extra_deps_iterate_end;

  /* Can build road after that? */
  if (punit != NULL) {
    if (!can_build_road(extra_road_get(pextra), punit, ptile)) {
      return -1;
    }
  } else if (pplayer != NULL) {
    if (!player_can_build_road(extra_road_get(pextra), pplayer, ptile)) {
      return -1;
    }
  }

  tile_add_extra(ptile, pextra);

  activity_mc += terrain_extra_build_time(pterrain, ACTIVITY_GEN_ROAD, pextra);

  return activity_mc
                         enum unit_activity activity,
                         struct extra_type *tgt) 
{
  struct tile *ptile = unit_tile(punit);
  struct terrain *pterrain = tile_terrain(ptile);
  struct road_type *proad = NULLGEN_ROAD:
    {
      struct tile *vtile;
      int build_time;

      fc_assert(is_extra_caused_by(tgt, EC_ROAD));

      proad = extra_road_get(tgt);

      if (tile_has_road(ptile, proad)) {
        /* This tile has road, can unit build road to other tiles too? */
        return are_reqs_active(NULL, NULL, NULL, NULL, NULL,
                               punit, unit_type(punit), NULL, NULL, NULL,
                               &tgt->reqs, RPT_POSSIBLE);
      }

      /* To start connect, unit must be able to build road to this
       * particular tile. */
      vtile = tile_virtual_new(ptile);
      build_time = check_recursive_road_connect(vtile, tgt, punit, NULL, 0);
      tile_virtual_destroy(vtile);

      return build_time >= 0;
    }
if (!unit_has_type_flag(punit, UTYF_SETTLERS)) {
      return FALSE;
    }
    if (tile_has_extra(ptile, tgt)) {
      return are_reqs_active(NULL, NULL, NULL, NULL, NULL,
                             punit, unit_type(punit), NULL, NULL, NULL,
                             &tgt->reqs, RPT_POSSIBLE);
    }

    return pterrain == pterrain->irrigation_result
      && can_be_irrigated(ptile, punit)
      && can_build_extra(tgt, punit, ptile)
      && !is_activity_on_tile(ptile,
                              ACTIVITY_MINE  Prompt player for entering destination point for unit connect
  (e.g. connecting with roads)unit_connect(enum unit_activity activity,
                          struct extra_type *tgt, tgt)) {
    return;
  }

  if (hover_state != HOVER_CONNECT || connect_activity != activity
      || (connect_tgt != tgt
          && (activity == ACTIVITY_GEN_ROAD
              || activity == ACTIVITY_IRRIGATE))) {
    set_hover_state(punits, HOVER_CONNECT,
                    activity, tgt, ACTION_COUNTfc_assert_reunit_tile(punit)unit_tile(punit)unit_transport_get(pcargo) == punit  Send unit airlift request to server dir = -1;
      order.activity = ACTIVITY_SENTRY;
      order.target = EXTRA_NONE;
      order.action = ACTION_COUNTWakes all owned sentried units onunit_tile(punit)**
  Defines specific hash tables needed for request_unit_select()**/
#define SPECHASH_TAG unit_type
#define SPECHASH_IKEY_TYPE struct unit_type *
#define SPECHASH_IDATA_TYPE void *
#include "spechash.h"

#define SPECHASH_TAG continent
#define SPECHASH_INT_KEY_TYPE
#define SPECHASH_IDATA_TYPE void *
#include "spechash.h"tile_hash *tile_table;
  struct unit_type_hash *type_table;
  struct continent_hashunit_focus_set(punit_first);
    return;
  }

  pplayer = unit_owner(punit_first);
  tile_table = tile_hash_new();
  type_table = unit_type_hash_new();
  cont_table = continent_hash_new(unit_type_tile_hash_insert(tile_table, ptile, NULL);
    } else if (selloc == SELLOC_CONT) {
      continent_hash_insert(cont_table, tile_continent(ptile), NULL);
    }
  } unit_list_iterate_end;

  if (selloc == SELLOC_TILE) {
    tile_hash_iterate(tile_table, hash_tile) {
      unit_list_iterate(hash_unit_type_hash_lookup(type_table, unit_type(punit), NULL)) {
          continue;
        }
        unit_focus_add(punit);
      } unit_list_iterate_end;
    } tile_hashunit_type_hash_lookup(type_table, unit_type(punit), NULL))
          || (selloc == SELLOC_CONT
              && !continent_hash_lookup(cont_table, tile_continent(ptile),
                                        NULL))) {
        continue;
      }

      unit_focus_add(punit);
    } unit_list_iterate_end;
  }

  tile_hash_destroy(tile_table);
  unit_type_hash_destroy(type_table);
  continent_hash_destroy(cont_table Request an actor unit to do a specific action.
  - action : The action to be requested.
  - actor_id : The unit ID of the actor unit.
  - target_id : The ID of the target unit, city or tile  - name : Used by ACTION_FOUND_CITY to specify city namvoid request_do_action(enum gen_action action, int actor_id,
                       int target_id, int value, const char *name)
{
  dsend_packet_unit_do_action(&client.conn,
                              actor_id, target_id, value, name,
                                Request data for follow up questions about an action the unit can
  perform.
  - action : The action more details .
  - actor_id : The unit ID of the acting unit.
  - target_id : The ID of the target unit or cityvoid request_action_details(enum gen_action action, int actor_id,
                            int target_id)
{
  dsend_packet_unit_action_query(&client.conn,
                                 actor_id, target_id, struct city *pcity;

  if ((pcity = tile_city(unit_tile(punit)))) {
    /* Try to join the city. */
    request_do_action(ACTION_JOIN_CITY, punit->id, pcity->id, 0, "");
  } else {
    /* The reply will trigger a dialog to name the new city. */
    dsend_packet_city_name_suggestion_reqpacket_unit_orders p;
  struct tile *dest_tile;

  /* Catches attempts to move off map */
  dest_tile = mapstep(unit_tile(punit), dir);
  if (!dest_tile) {
    return;
  }

  /* The goto system isn't used to send the order because that would
   * prevent direction movement from overriding it.
   * Example of a situation when overriding the goto system is useful:
   * The goto system creates a longer path to make a move legal. The player
   * wishes to order the illegal move so the server will explain why the
   * short move is illegal. */

  memset(&p, 0, sizeof(p));

  p.repeat = FALSE;
  p.vigilant = FALSE;

  p.unit_id = punit->id;
  p.src_tile = tile_index(unit_tile(punit));
  p.dest_tile = tile_index(dest_tile);

  p.length = 1;
  p.orders[0] = ORDER_ACTION_MOVE;
  p.dir[0] = dir;
  p.activity[0] = ACTIVITY_LAST;
  p.target[0] = EXTRA_NONE;
  p.action[0] = ACTION_COUNT;

  send_packet_unit_orders(&client.conn, &p Send request for unit activity changing to server. If activity has
  target, use request_new_unit_activity_targeted() insteadvoid request_new_unit_activity(struct unit *punit, enum unit_activity act)
{
  request_new_unit_activity_targeted(punit, act, NULL Send request for unit activity changing to server. This is for
  activities that are targeted to certain special or base typstruct extra_type *tgt)
{
  if (!can_client_issue_orders()) {
    return;
  }

  if (tgt == NULL) {
    dsend_packet_unit_change_activity(&client.conn, punit->id, act, EXTRA_NONE);
  } else {
    dsend_packet_unit_change_activity(&client.conn, punit->id, act, extra_index(tgt  Send request to disband unit to server  Send request to change unit homecity to serverunit_tile(punit));
  Send request to upgrade unit to servervoid request_unit_upgrade(struct unit *punit)
{
  struct city *pcity=tile_city(unit_tile(punit)convert packetvoid request_unit_convert(struct unit *punit)
{
  request_new_unit_activity(punit, ACTIVITY_CONVERTunit_tile(punit)suitable transporter will be chosen**/
void request_unit_load(struct unit *pcargo, struct unit *ptrans)
{
  if (!ptrans) {
    ptrans =                                       ACTIVITY_SENTRY, EXTRA_NONEunit_transport_get(pcargounit_tile(pcargo)== ACTIVITY_SENTRYEXTRA_NONE);
    }Send request to do caravan action - establishing traderoute or
  helping in wonder building - to servervoid request_unit_caravan_action(struct unit *punit,
                                 enum gen_action action)
{
  struct city *target_city;

  if (!((target_city = tile_city(unit_tile(punit))))) {
    return;
  }

  if (action == ACTION_TRADE_ROUTE) {
    request_do_action(ACTION_TRADE_ROUTE, punit->id,
                      target_city->id, 0, "");
  } else if (action == ACTION_HELP_WONDER) {
    request_do_action(ACTION_HELP_WONDER, punit->id,
                      target_city->id, 0, "");
  } else {
    log_error("request_unit_caravan_action() Bad action (%d)", actionSend paradrop request to serverunit_tile(punit);
    }
  } unit_list_iterate_end;
  if (can) {
    set_hover_state(punits, HOVER_PARADROP, ACTIVITY_LAST, NULL,
                    ACTION_COUN  Either start new patrol route planning, or add waypoint to current onNULL,
                    ACTION_COUN  create_line_at_mouse_pos();
  } else {
    fc_assert_re
  Try to sentry unit  Try to fortify unit  Send pillage request to servervoid request_unit_pillage(struct unit *punit)
{
  if (!game.info.pillage_select) {
    /* Leave choice up to the server */
    request_new_unit_activity_targeted(punit, ACTIVITY_PILLAGE, NULL);
  } else {
    struct tile *ptile = unit_tile(punit);
    bv_extras pspossible;
    int count = 0;

    BV_CLR_ALL(pspossible);
    extra_type_iterate(potential) {
      if (can_unit_do_activity_targeted_at(punit, ACTIVITY_PILLAGE,
                                           potential, ptile)) {
        BV_SET(pspossible, extra_index(potential));
        count++;
      }
    } extra_type_iterate_end;

    if (count > 1) {
      popup_pillage_dialog(punit, pspossible);
    } else {
      /* Should be only one choice... */
      struct extra_type *target = get_preferred_pillage(pspossible);

      if (target != NULL) {
        request_new_unit_activity_targeted(punit, ACTIVITY_PILLAGE, target);
      }
    }Toggle display of city outlines on the mapcity_outlines(void) 
{
  if (!can_client_change_view()) {
    return;
  }

  options.draw_city_outlines = !options.options.draw_city_output = !options.options.draw_map_gridnational borders on the mapmap_borders(void) 
{
  if (!can_client_change_view()) {
    return;
  }

  options.draw_bordernative tiles on the mapmap_native(void) 
{
  if (!can_client_change_view()) {
    return;
  }

  options.draw_native Toggle display of city full barvoid request_toggle_city_full_bar(void)
{
  if (!can_client_change_view()) {
    return;
  }

  options.draw_full_citybarcity namy_names(void)
{
  if (!can_client_change_view()) {
    return;
  }

  options.options.draw_city_growthcity productioncity_productions(void)
{
  if (!can_client_change_view()) {
    return;
  }

  options.options.options.draw_city_trade_routeterrainterrain(void)
{
  if (!can_client_change_view()) {
    return;
  }

  options.draw_terraincoastlinecoastline(void)
{
  if (!can_client_change_view()) {
    return;
  }

  options.options.options.options.basbases(void)
{
  if (!can_client_change_view()) {
    return;
  }

  options.draw_fortress_airbasespecialspecials(void)
{
  if (!can_client_change_view()) {
    return;
  }

  options.draw_speciapollutionpollution(void)
{
  if (!can_client_change_view()) {
    return;
  }

  options.options.options.draw_unit Toggle display of unit solid backgroundvoid request_toggle_unit_solid_bg(void)
{
  if (!can_client_change_view()) {
    return;
  }

  options.solid_color_behind_unit Toggle display of unit shieldsvoid request_toggle_unit_shields(void)
{
  if (!can_client_change_view()) {
    return;
  }

  options.draw_unit_shieldoptions.draw_focus_unitfog of warfog_of_war(void)
{
  if (!can_client_change_view()) {
    return;
  }

  options.  Center to focus unit  Set units in list to waiting focus. If they are current focus units,
  advance focusclient.focus_status = FOCUS_WAIT;
  } unit_list_iterate_end;
  if (punits == get_units_in_focus()) {
    unit_focus_advance(Set focus units to FOCUS_DONE statvoid request_unit_move_done(void)
{
  if (get_num_units_in_focus() > 0) {
    enum unit_focus_status new_status = FOCUS_DONE;
    unit_list_iterate(get_units_in_focus(), punit) {
      /* If any of the focused units are busy, keep all of them
       * in focus; another tap of the key will dismiss them */
      if (punit->activity != ACTIVITY_IDLE) {
        new_status = FOCUS_WAIT;
      }
    } unit_list_iterate_end;client.focus_status = new_status;
    } unit_list_iterate_end;
    if (new_status == FOCUS_DONE) {
      unit_focus_advance();
    }unit_tile(punit);
  struct tile *dst_tile = unit_tile(target_unit);
  bool was_teleported, do_animation;
  bool in_focus = unit_is_in_focus(punit);

  was_teleported = !is_tiles_adjacent(src_tile, dst_tile);
  do_animation = (!was_teleported && options.!unit_transported(punit)) {
    audio_play_sound(unit_type(punit)->sound_move,
                     unit_type(punit)->sound_move_alt);
  }

  if (unit_owner(punit) == client.conn.playing
      && options.if (hover_state != HOVER_NONE && in_focus) {
    /* Cancel current goto/patrol/connect/nuke command. */
    set_hover_state(NULL, HOVER_NONE,
                    ACTIVITY_LAST, NULL, ACTION_COUNT, ORDER_LAST);
    update_unit_info_label(get_units_in_focus());
  }

  unit_list_remove(src_tile->units, punit);

  if (!unit_transported(punit)) {
    /* Mark the unit as moving unit, then find_visible_unit() won't return
     * it. It is especially useful to don't draw many times the unit when
     * refreshing the canvas. */
    punit_moving = punit;
tile_set(punit, dst_tile);
  unit_list_prepend(dst_tile->units, punit);

  if (!unit_transported(punit)) {
    /* For find_visible_unit(), see above. */
    punit_moving = NULL;
 bar we have to update the city in_focus
  if (hover_state != HOVER_NONE) {
    switch (hover_state) {
    case HOVER_NONE:
      break;
    case HOVER_GOTO:
      do_unit_goto(ptile);, connect_tgt
                    ACTIVITY_LAST, NULL, ACTION_COUNunit_focus_set_and_select(qunit);
      maybe_goto = options.options.get_transporter_occupancy(unit_list_get(ptile->units, 0))options.keyboardless_goto;
	if (qtype == SELECT_APPEND) {
	  unit_focus_add(punit);
	} else {
	  unit_focus_set_and_select(punit);
	}
      }
    } else if (pcity) {
      /* Don't hide the unit in the city. */
      unit_select_dialog_popupunit_select_dialog_popupfc_assert_ret_val(qtype > SELECT_POPUP, NULLutype_move_type(unit_type(punit)) == UMT_SEAutype_move_type(unit_type(punit)) == UMT_LAND)utype_move_type(unit_type(punit)) == UMT_SEA
                  ACTIVITY_LAST, NULL, ACTION_COUN,
                     struct extra_type *tgt)
{
  if (is_valid_goto_draw_line(ptile)) {
    send_connect_route(activity, tgt
                  ACTIVITY_LAST, NULL, ACTION_COUNgoto_pop_waypoint()) {
      break;
    }
    /* else fall through: */
  case HOVER_PARADROP:
    set_hover_state(NULL, HOVER_NONE,
                    ACTIVITY_LAST, NULL, ACTION_COUNT, ORDER_LAST);
    update_unit_info_label(get_units_in_focus());

    keyboardless_goto_button_down = FALSE;
    keyboardless_goto_active = FALSE;
    keyboardless_goto_start_tile = NULL;
    break;
  case HOVER_NONEplayer_capital(client_player()  Handle user 'end turn' inputunit_focus_set(punit);
    } else {
      unit_focus_add  Handle use 'build city' input  Handle user 'help build wonder' inpucan_do_action(punit, ACTION_HELP_WONDER)) {
      request_unit_caravan_action(punit, ACTION_HELP,
                      struct extra_type *tgt)
{
  request_unit_connect(activity, tgt Handle user 'diplomatic actions' inpukey_unit_diplomat_actions(void)
{
  struct tile *ptile;
  unit_list_iterate(get_units_in_focus(), punit) {
    if (is_actor_unit(punit)
        && (ptile = unit_tile(punit))) {
      process_diplomat_arrival(punit, ptile->index  Handle user 'unit done' inpukey_unit_done(void)
{
  request_unit_move_don Handle user 'unit goto' inpukey_unit_goto(void)
{
  request_unit_goto(ORDER_LAST, ACTION_COUNTkey_unit_nuke(void)
{
  request_unit_goto(ORDER_PERFORM_ACTION, ACTION_NUKE Handle user 'paradrop' inpu  Handle user 'patrol' inpu  Handle user 'establish traderoute' inpukey_unit_trade_route(void)
{
  unit_list_iterate(get_units_in_focus(), punit) {
    /* TODO: Is falling back on ACTION_MARKETPLACE if not able to establish
     * a trade route trade a good idea or an unplecant surprice? */
    if (unit_can_do_action(punit, ACTION_TRADE_ROUTE)) {
      request_unit_caravan_action(punit, ACTION_TRADE_ROUTE  Handle user 'unload all' inpuclient.focus_status = FOCUS_WAIT;
    } unit_list_iterate_end;
    unit_focus_set(pnext_focusHandle user 'wait' inpu  Handle user 'wakeup others' inpu*/
void key_unit_wakeup_otherswakeup(punit  Handle user 'build base of class airbase' inpuunit_tile(punit));

    if (pbase) {
      struct extra_type *pextra = base_extra_get(pbase);

      request_new_unit_activity_targeted(punit, ACTIVITY_BASE, pextra  Handle user 'autoexplore' inpu  Unit convertconverconvert(punit  Handle user 'clean fallout' inpukey_unit_fallout(void)
{
  key_unit_clean(ACTIVITY_FALLOUT, ERM_CLEANFALLOUT Handle user 'fortify' inpu  Handle user 'build base of class fortress' inpuunit_tile(punit));

    if (pbase) {
      struct extra_type *pextra = base_extra_get(pbase);

      request_new_unit_activity_targeted(punit, ACTIVITY_BASE, pextra  Handle user 'change homecity' inpu  Handle user extra building input of given typestatic void key_unit_extra(enum unit_activity act, enum extra_cause cause)
{
  unit_list_iterate(get_units_in_focus(), punit) {
    struct extra_type *tgt = next_extra_for_tile(unit_tile(punit),
                                                 cause,
                                                 unit_owner(punit),
                                                 punit);

    if (can_unit_do_activity_targeted(punit, act, tgt)) {
      request_new_unit_activity_targeted(punit, act, tgt  Handle user extra cleaning input of given typestatic void key_unit_clean(enum unit_activity act, enum extra_rmcause rmcause)
{
  unit_list_iterate(get_units_in_focus(), punit) {
    struct extra_type *tgt = prev_extra_in_tile(unit_tile(punit),
                                                rmcause,
                                                unit_owner(punit),
                                                punit);

    if (tgt != NULL
        && can_unit_do_activity_targeted(punit, act, tgt)) {
      request_new_unit_activity_targeted(punit, act, tgt  Handle user 'irrigate' inpukey_unit_irrigate(void)
{
  key_unit_extra(ACTIVITY_IRRIGATE, EC_IRRIGATION Handle user 'build mine' inpukey_unit_mine(void)
{
  key_unit_extra(ACTIVITY_MINE, EC_MINE Handle user 'pillage' inpukey_unit_pillagePILLAGE)) {
      request_unit_pillage(punit  Handle user 'clean pollution' inpukey_unit_pollution(void)
{
  key_unit_clean(ACTIVITY_POLLUTION, ERM_CLEANPOLLUTION Handle user 'build road or railroad' inpukey_unit_road(void)
{
  unit_list_iterate(get_units_in_focus(), punit) {
    struct extra_type *tgt = next_extra_for_tile(unit_tile(punit),
                                                 EC_ROAD,
                                                 unit_owner(punit),
                                                 punit);

    if (tgt != NULL
        && can_unit_do_activity_targeted(punit, ACTIVITY_GEN_ROAD, tgt)) {
      request_new_unit_activity_targeted(punit, ACTIVITY_GEN_ROAD, tgt  Handle user 'sentry' inpu  Handle user 'transform unit' inpuunit_tile(punit), TRUE, FALSE);
	  unit_list_removeremoveunit_tile(punit)unit_focus_addunit_focus_setunit_focus_set(punit);
      } else {
	unit_focus_add  Handle user 'toggle map grid' inpu  Toggle native tilenative_toggle(void)
{
  request_toggle_map_native();
}

/*************************************…ò3 »]»]€»]*************************************
  Toggle the "Draw the city bar" option.
**************************************************************************/
void key_city_full_bar_toggle(void)
{
  request_toggle_city_full_bar();
}

/**************************************************************************
  Handle user 'toggle city names display' input
**************************************************************************/
void key_city_names_toggle(void)
{
  request_toggle_city_names();
}

/**************************************************************************
  Toggles the "show city growth turns" option by passing off the
  request to another function...
**************************************************************************/
void key_city_growth_toggle(void)
{
  request_toggle_city_growth();
}

/**************************************************************************
  Toggles the showing of the buy cost of the current production in the
  city descriptions.
**************************************************************************/
void key_city_buycost_toggle(void)
{
  request_toggle_city_buycost();
}

/**************************************************************************
  Handle user 'toggle city production display' input
**************************************************************************/
void key_city_productions_toggle(void)
{
  request_toggle_city_productions();
}

/**************************************************************************
  Handle client request to toggle drawing of trade route information
  by the city name for cities visible on the main map view.
**************************************************************************/
void key_city_trade_routes_toggle(void)
{
  request_toggle_city_trade_routes();
}

/**************************************************************************
  Handle user 'toggle terrain display' input
**************************************************************************/
void key_terrain_toggle(void)
{
  request_toggle_terrain();
}

/**************************************************************************
  Handle user 'toggle coastline display' input
**************************************************************************/
void key_coastline_toggle(void)
{
  request_toggle_coastline();
}

/**************************************************************************
  Handle user 'toggle road/railroad display' input
**************************************************************************/
void key_roads_rails_toggle(void)
{
  request_toggle_roads_rails();
}

/**************************************************************************
  Handle user 'toggle irrigation display' input
**************************************************************************/
void key_irrigation_toggle(void)
{
  request_toggle_irrigation();
}

/**************************************************************************
  Handle user 'toggle mine display' input
**************************************************************************/
void key_mines_toggle(void)
{
  request_toggle_mines();
}

/**************************************************************************
  Handle user 'toggle bases display' input
**************************************************************************/
void key_bases_toggle(void)
{
  request_toggle_bases();
}

/**************************************************************************
  Handle user 'toggle specials display' input
**************************************************************************/
void key_specials_toggle(void)
{
  request_toggle_specials();
}

/**************************************************************************
  Handle user 'toggle pollution display' input
**************************************************************************/
void key_pollution_toggle(void)
{
  request_toggle_pollution();
}

/**************************************************************************
  Handle user 'toggle cities display' input
**************************************************************************/
void key_cities_toggle(void)
{
  request_toggle_cities();
}

/**************************************************************************
  Handle user 'toggle units display' input
**************************************************************************/
void key_units_toggle(void)
{
  request_toggle_units();
}

/**************************************************************************
  Toggle the "Solid unit background color" option.
**************************************************************************/
void key_unit_solid_bg_toggle(void)
{
  request_toggle_unit_solid_bg();
}

/**************************************************************************
  Toggle the "Draw shield graphics for units" option.
**************************************************************************/
void key_unit_shields_toggle(void)
{
  request_toggle_unit_shields();
}

/**************************************************************************
  Handle user 'toggle key units display' input
**************************************************************************/
void key_focus_unit_toggle(void)
{
  request_toggle_focus_unit();
}

/**************************************************************************
  Handle user 'toggle fog of war display' input
**************************************************************************/
void key_fog_of_war_toggle(void)
{
  request_toggle_fog_of_war();
}

/**************************************************************************
  Toggle editor mode in the server.
**************************************************************************/
void key_editor_toggle(void)
{
  dsend_packet_edit_mode(&client.conn, !game.info.is_edit_mode);
}

/**************************************************************************
  Recalculate borders.
**************************************************************************/
void key_editor_recalculate_borders(void)
{
  send_packet_edit_recalculate_borders(&client.conn);
}

/**************************************************************************
  Send a request to the server to toggle fog-of-war for the current
  player (only applies in edit mode).
**************************************************************************/
void key_editor_toggle_fogofwar(void)
{
  if (client_has_player()) {
    dsend_packet_edit_toggle_fogofwar(&client.conn, client_player_number());
  }
}

/**************************************************************************
  All units ready to build city to the tile should now proceed.
**************************************************************************/
void finish_city(struct tile *ptile, const char *name)
{
  unit_list_iterate(ptile->units, punit) {
    if (punit->client.asking_city_name) {
      /* Unit will disappear only in case city building still success.
       * Cancel city building status just in case something has changed
       * to prevent city building in the meanwhile and unit will remain
       * alive. */
      punit->client.asking_city_name = FALSE;
      request_do_action(ACTION_FOUND_CITY, punit->id, ptile->index,
                        0, name);
    }
  } unit_list_iterate_end;
}

/**************************************************************************
  Do not build city after all. Cancel city building mark from all units
  prepared for it.
**************************************************************************/
void cancel_city(struct tile *ptile)
{
  unit_list_iterate(ptile->units, punit) {
    punit->client.asking_city_name = FALSE;
  } unit_list_iterate_end;
}
ENDREP
DELTA 29677 0 670
SVN  †  †   Þ)  Þ)€K ‚ßx á€K …¼,ãNrrname,
                       MAX(0, 18 - (int)get_internal_string_length(rbbname,
                       MAX(0, 18 - (int)get_internal_string_length(b†  †  †  )‚J† ß º í@® Šà}€d ‚³2ë]€r Cƒ † ‚þ"ƒ¡Jintf(badvi) {
              if (valid_advance_by_number(advi)) {advance_name_translation(advance_by_number(advci;

                  for (ci = 0; ci < ncats; ci++) {
                    if (fc_strcasecmp(cats[ctarget) {
    if (uclass_has_flag(target, UCF_UNREACHABLE)
        && BV_ISSET(utype->targets, uclass_index(targettargetŒÀ ñQñe” ñQ r multiple veteran lENDREP
DELTA 28414 0 6546
SVN  ƒ¤zƒ¤~Y„\ ‰ €~ n‹  §+‹o€ ‚´" ¶6 -·= „B¸k t½.€ dÇw ËQÁ‚ ‡OƒŒb€ gƒ•6€@ Ž#ƒ–Wid)
{
  struct universal target;

  if (id >= B_LAST) {
    target.kind = VUT_UTYPE;
    target.value.utype = utype_by_number(id;
  int items_used = 0;

  for (id = first; id < last; id++) {
    bool append = FALSE;
    struct universal target = cid_decode(id = 0; id < ARRAY_SIZE(mapping); id++) {
    if (mapping[id]) {
      targets[cids_used] = cid_decode(id);
      cids_used++;
    }
  }i_i_map, sizeof(mi_map), "%s",
                   mapimg_layer_name(layer));
      mi_map[map_pos++] = mapimg_layer_name(layer)[0];
    }
  }
  mi_i_map, "-");
  }
  cat_snprintf(str, sizeof(str), ":map=%s", mi_ENDREP
DELTA 29682 0 47
SVN  ƒøBƒøR#M ÞS  ‚hÞT 5áA ‚iâw‘ N…|­ ƒ‘^ædhhcity != NULLhhcity != NULL) {
astr_add_line(&str, _("from %s"), city_name(hENDREP
DELTA 27397 0 984
SVN  ïïRJ ß& €J Žbà3base_x, int canvas_base_y,
                            int width_base, int height_base);
void show_tile_labels(int canvas_base_x, int canvas_base_y,
                      int width_base, int height_baseENDREP
DELTA 29184 5422 32
SVN  ¢%¢jƒ> Ä €s }Ä|´ µ;Æ€; kü}€\ £mþ8srv_cmdline_opts = ASTRING_INIT;
      int i;

      for (i = 1; i < argc; i++) {
        astr_add(&srv_cmdline_optsrv_cmdline_opts));
      astr_free(&srv_cmdline_opttopobuf[16];

    fc_strlcpy(topobuf, "WRAPX", sizeof(topobuf));
    if (tileset_is_isometric(tileset) && 0 == tileset_hex_height(tileset)) {
      fc_strlcat(topobuf, "|ISO", sizeof(topotopobuf, "|HEX", sizeof(topobuf));
    }
    desired_settable_option_update("topology", topoENDREP
DELTA 29184 5534 32
SVN  ¿{À9 © ƒ ‚j©³ t¬/ƒ ’X­#plrplrhost = secfile_lookup_str_default(file, "", 
   plrENDREP
id: zl.5ck.r29743/51088
type: file
pred: zl.5ck.r29311/244
count: 51
text: 29743 0 159 13857 5f1b01926929fdb4e2945384d37222fb
props: 10779 52547 111 0 1c266b4433d829481714f1852322e965
cpath: /trunk/client/agents/cma_fec.c
copyroot: 15280 /trunk

PLAIN
K 11
Makefile.am
V 21
file zg.5ck.r27763/49
K 8
agents.c
V 21
file zh.5ck.r29330/84
K 8
agents.h
V 24
file zi.5ck.r18863/16987
K 10
cma_core.c
V 24
file zj.5ck.r28218/30959
K 10
cma_core.h
V 24
file zk.5ck.r18863/17236
K 9
cma_fec.c
V 24
file zl.5ck.r29743/51088
K 9
cma_fec.h
V 24
file zm.5ck.r18863/16740
K 5
sha.c
V 24
file 2fy.5ck.r19466/3097
K 5
sha.h
V 25
file 2fz.5ck.r18863/16495
END
ENDREP
id: zf.5ck.r29743/51739
type: dir
pred: zf.5ck.r29330/729
count: 185
text: 29743 51334 392 0 06464d6798f5d62e91c6e32d85738959
props: 11108 11608 65 0 c67827893bff2f279fa7f0439c4cba47
cpath: /trunk/client/agents
copyroot: 15280 /trunk

id: z4.5ck.r29743/51974
type: file
pred: z4.5ck.r29117/11976
count: 165
text: 29743 184 757 39959 7578a5a4b4f591acd16c04afbccf2ead
props: 11067 4204 111 0 32cf26490c5995022c752556481ff094
cpath: /trunk/client/citydlg_common.c
copyroot: 15280 /trunk

id: z5.5ck.r29743/52224
type: file
pred: z5.5ck.r27397/15293
count: 45
text: 29743 5949 29 3911 f61fec089d87986b8fbf675bc730c10e
props: 10806 19569 111 0 18cdb9becb11c47631b7a093e907200c
cpath: /trunk/client/citydlg_common.h
copyroot: 15280 /trunk

id: mb.5ck.r29743/52473
type: file
pred: mb.5ck.r29010/62955
count: 93
text: 29743 5633 143 35714 09b097fecb17db8f3750bb9e7fc8ce64
props: 10806 19211 111 0 93646be3752db5a3cd8e77177837d494
cpath: /trunk/client/cityrepdata.c
copyroot: 15280 /trunk

id: d5.5ck.r29743/52721
type: file
pred: d5.5ck.r28414/62002
count: 269
text: 29743 49319 707 53886 b75896e1e6dbe07de6a95b3cdd62fa14
props: 11057 49717 112 0 a13a5521476fb3b00a5e0433e6f85ac7
cpath: /trunk/client/climisc.c
copyroot: 15280 /trunk

id: 2fw.5ck.r29743/52967
type: file
pred: 2fw.5ck.r29184/45941
count: 83
text: 29743 50452 490 20842 463366cccfe5d3660725cb1591f18d90
props: 9999 36135 111 0 b4233197920770c602c29330b7f7c623
cpath: /trunk/client/connectdlg_common.c
copyroot: 15280 /trunk

id: gz.5ck.r29743/53223
type: file
pred: gz.5ck.r29472/2829
count: 384
text: 29743 7611 41042 110045 b5eda7e2e3fc6b4099fb9a87818fdd4a
props: 11088 7720 112 0 89a05fc93c37a832d4b63085dac12c4b
cpath: /trunk/client/control.c
copyroot: 15280 /trunk

id: h1.5ck.r29743/53469
type: file
pred: h1.5ck.r29677/699
count: 457
text: 29743 48680 614 219365 41e593a819abd72bca9cd0c78edbc6d0
props: 10865 39466 112 0 7c92b74246787b3b87930d3304880700
cpath: /trunk/client/helpdata.c
copyroot: 15280 /trunk

id: 765.5ck.r29743/53715
type: file
pred: 765.5ck.r26905/115746
count: 2
text: 29743 968 853 10678 733e8da1dcc27d8c8ca8e1647ec9068b
props: 26905 115699 34 0 25e6c2f7558b7484000d4d090dea5b92
cpath: /trunk/client/luascript/script_client.c
copyroot: 15280 /trunk

PLAIN
K 11
Makefile.am
V 25
file 762.5ck.r27705/90035
K 17
api_client_base.c
V 26
file 763.5ck.r26905/115436
K 17
api_client_base.h
V 26
file 764.5ck.r26905/116057
K 15
script_client.c
V 25
file 765.5ck.r29743/53715
K 15
script_client.h
V 26
file 766.5ck.r26905/116368
K 16
tolua_client.pkg
V 24
file 767.5ck.r22514/7109
END
ENDREP
id: 761.5ck.r29743/54308
type: dir
pred: 761.5ck.r27705/90564
count: 6
text: 29743 53976 319 0 22e6dd72c38f858ec087f0dabb93801e
props: 20323 0 91 0 1dea2a702e202607451f6250c717eb03
cpath: /trunk/client/luascript
copyroot: 15280 /trunk

id: 15m.5ck.r29743/54544
type: file
pred: 15m.5ck.r29303/106
count: 117
text: 29743 5805 120 23830 059a9083a7d56edcea94bcd2a147d532
props: 11057 48634 111 0 e77f29e20031f26b4b1e16b63c7aa55c
cpath: /trunk/client/mapctrl_common.c
copyroot: 15280 /trunk

id: z2.5ck.r29743/54796
type: file
pred: z2.5ck.r29287/22159
count: 342
text: 29743 6354 1230 128065 c61e3366471dc5c23e663aa0b685153e
props: 11084 12552 112 0 73ff9df0f3aabd6f615c7264c2fe22c7
cpath: /trunk/client/mapview_common.c
copyroot: 15280 /trunk

id: z3.5ck.r29743/55050
type: file
pred: z3.5ck.r27397/9503
count: 133
text: 29743 50201 226 14290 7b35ca026532a74c81ac0bd563bb435c
props: 11084 12915 112 0 c6f01847c43db8681cbef2f439eec19f
cpath: /trunk/client/mapview_common.h
copyroot: 15280 /trunk

id: 2yk.5ck.r29743/55302
type: file
pred: 2yk.5ck.r24790/283201
count: 39
text: 29743 6006 317 17591 fc22927894c03a1bbc10e1489ec8815d
props: 11057 37417 111 0 df9f31216c5039327c376b7fe82756f5
cpath: /trunk/client/overview_common.c
copyroot: 15280 /trunk

id: n.5ck.r29743/55557
type: file
pred: n.5ck.r29732/6376
count: 1058
text: 29743 3835 1770 152027 e07db88eb6745346f376121d90714b56
props: 11088 14698 112 0 2c9d3e41a2f20488aa9cdb8d740d094e
cpath: /trunk/client/packhand.c
copyroot: 15280 /trunk

id: 33x.5ck.r29743/55803
type: file
pred: 33x.5ck.r29184/46195
count: 72
text: 29743 50969 92 24583 2b716e7f399f40c9cf717fe950d5cda7
props: 11101 62 110 0 fdfdab56f53d2388a66f6a5ce0985f95
cpath: /trunk/client/servers.c
copyroot: 15280 /trunk

id: 2g3.5ck.r29743/56046
type: file
pred: 2g3.5ck.r29682/972
count: 201
text: 29743 50052 125 64594 a05463e3ec1fcc39a3f75bca350098ad
props: 11057 45424 111 0 93646be3752db5a3cd8e77177837d494
cpath: /trunk/client/text.c
copyroot: 15280 /trunk

id: hl.5ck.r29743/56289
type: file
pred: hl.5ck.r29547/12456
count: 610
text: 29743 1851 1955 213041 979d4f06074cca7c0854be53a9eddf07
props: 11096 3792 112 0 71c6b453a620995957914f193a952f13
cpath: /trunk/client/tilespec.c
copyroot: 15280 /trunk

PLAIN
K 11
Makefile.am
V 24
file 5f.5ck.r29325/10642
K 6
agents
V 23
dir zf.5ck.r29743/51739
K 11
attribute.c
V 24
file xh.5ck.r28218/30713
K 11
attribute.h
V 24
file xi.5ck.r18863/23649
K 7
audio.c
V 25
file 139.5ck.r27127/10791
K 7
audio.h
V 25
file 13a.5ck.r27127/11031
K 12
audio_none.c
V 25
file 13d.5ck.r24916/15731
K 12
audio_none.h
V 25
file 13e.5ck.r18863/20841
K 11
audio_sdl.c
V 25
file 13f.5ck.r27123/78063
K 11
audio_sdl.h
V 25
file 13g.5ck.r18863/23885
K 17
chatline_common.c
V 25
file 14q.5ck.r24895/20143
K 17
chatline_common.h
V 24
file 14r.5ck.r24892/5917
K 16
citydlg_common.c
V 24
file z4.5ck.r29743/51974
K 16
citydlg_common.h
V 24
file z5.5ck.r29743/52224
K 13
cityrepdata.c
V 24
file mb.5ck.r29743/52473
K 13
cityrepdata.h
V 24
file mc.5ck.r18863/19121
K 13
client_main.c
V 22
file 2f.5cp.r29619/512
K 13
client_main.h
V 23
file hz.5cq.r29333/6077
K 8
climap.c
V 24
file 197.5ck.r20232/3008
K 8
climap.h
V 25
file 198.5ck.r18863/24126
K 9
climisc.c
V 24
file d5.5ck.r29743/52721
K 9
climisc.h
V 23
file i0.5ck.r26654/5011
K 8
clinet.c
V 23
file hc.5ck.r29474/2160
K 8
clinet.h
V 24
file i1.5ck.r18863/24866
K 15
colors_common.c
V 24
file 33a.5ck.r22855/3020
K 15
colors_common.h
V 24
file 33b.5ck.r24136/6711
K 19
connectdlg_common.c
V 25
file 2fw.5ck.r29743/52967
K 19
connectdlg_common.h
V 25
file 2fx.5ck.r19154/53802
K 9
control.c
V 24
file gz.5ck.r29743/53223
K 9
control.h
V 23
file i2.5ck.r29287/5018
K 7
dummy.c
V 26
file 4f9.5ck.r26905/141682
K 12
dummycxx.cpp
V 26
file 6kr.5ck.r26905/106211
K 8
editor.c
V 24
file 3bg.5ck.r26198/2350
K 8
editor.h
V 24
file 3bh.5ck.r26198/2592
K 17
global_worklist.c
V 26
file 4i6.5ck.r26905/117850
K 17
global_worklist.h
V 26
file 4i7.5ck.r26905/126022
K 6
goto.c
V 23
file vu.5ck.r29307/1653
K 6
goto.h
V 24
file vv.5ck.r27871/19506
K 11
gui-gtk-2.0
V 23
dir zs.5ck.r29729/16410
K 11
gui-gtk-3.0
V 23
dir zs.5g7.r29729/20895
K 6
gui-qt
V 24
dir 6ie.5ck.r29729/24454
K 7
gui-sdl
V 24
dir 16t.5ck.r29729/29803
K 8
gui-sdl2
V 23
dir 16t.5l8.r29736/5263
K 8
gui-stub
V 23
dir mh.5ck.r29054/23524
K 14
gui_cbsetter.c
V 26
file a3c.5ck.r27417/165161
K 14
gui_cbsetter.h
V 25
file a3d.5ck.r26905/69091
K 15
gui_interface.c
V 26
file 6jm.5ir.r27417/187983
K 15
gui_interface.h
V 26
file 6jn.5is.r27417/193557
K 10
helpdata.c
V 24
file h1.5ck.r29743/53469
K 10
helpdata.h
V 24
file i3.5ck.r25494/33011
K 7
include
V 23
dir b8.5ck.r29054/43247
K 19
luaconsole_common.c
V 26
file 75z.5ck.r26905/100821
K 19
luaconsole_common.h
V 26
file 760.5ck.r26905/106500
K 9
luascript
V 24
dir 761.5ck.r29743/54308
K 16
mapctrl_common.c
V 25
file 15m.5ck.r29743/54544
K 16
mapctrl_common.h
V 24
file 15n.5ck.r27397/5459
K 16
mapview_common.c
V 24
file z2.5ck.r29743/54796
K 16
mapview_common.h
V 24
file z3.5ck.r29743/55050
K 19
messagewin_common.c
V 26
file 14s.5ck.r24790/282945
K 19
messagewin_common.h
V 25
file 14t.5ck.r18863/21579
K 7
music.c
V 25
file zmc.5ck.r27127/11271
K 7
music.h
V 25
file zme.5ck.r27127/11513
K 9
options.c
V 21
file dc.5ck.r29559/86
K 9
options.h
V 23
file i4.5ck.r29474/2640
K 17
overview_common.c
V 25
file 2yk.5ck.r29743/55302
K 17
overview_common.h
V 26
file 2yl.5ck.r24790/283707
K 10
packhand.c
V 23
file n.5ck.r29743/55557
K 10
packhand.h
V 24
file i5.5ck.r18863/20596
K 15
plrdlg_common.c
V 24
file 14u.5ck.r28833/2098
K 15
plrdlg_common.h
V 25
file 14v.5ck.r18863/21328
K 17
repodlgs_common.c
V 25
file 11i.5ck.r22325/76263
K 17
repodlgs_common.h
V 25
file 11j.5ck.r19589/11861
K 9
reqtree.c
V 25
file 2ym.5ck.r28242/13215
K 9
reqtree.h
V 24
file 2yn.5ck.r24150/6004
K 9
servers.c
V 25
file 33x.5ck.r29743/55803
K 9
servers.h
V 25
file 33y.5ck.r20478/36372
K 6
text.c
V 25
file 2g3.5ck.r29743/56046
K 6
text.h
V 25
file 2g4.5ck.r24459/13284
K 15
themes_common.c
V 22
file 352.5ck.r26465/95
K 15
themes_common.h
V 25
file 353.5ck.r18863/22710
K 10
tilespec.c
V 24
file hl.5ck.r29743/56289
K 10
tilespec.h
V 23
file i6.5ck.r29399/2204
K 19
unitselect_common.c
V 26
file 76v.5ck.r26905/117249
K 19
unitselect_common.h
V 26
file 76w.5ck.r26905/117548
K 14
update_queue.c
V 25
file 4jw.5ck.r29054/20297
K 14
update_queue.h
V 26
file 4jx.5ck.r26905/141966
K 10
voteinfo.c
V 26
file 4fe.5ck.r26905/141386
K 10
voteinfo.h
V 26
file 4ff.5ck.r26905/142263
END
ENDREP
id: d.5ck.r29743/60779
type: dir
pred: d.5ck.r29736/9752
count: 6773
text: 29743 56536 4230 0 fbe21bbc07766e371df8358a9b04397b
props: 28036 11094 400 0 bbe1d6769a94f3af2a54f7dc91fc9c71
cpath: /trunk/client
copyroot: 15280 /trunk

PLAIN
K 9
ABOUT-NLS
V 24
file fu.5ck.r27270/69307
K 7
AUTHORS
V 24
file 5u.5ck.r22143/14016
K 7
COPYING
V 22
file 1h.5ck.r29454/952
K 9
ChangeLog
V 26
file 6l.5ck.r27473/7455495
K 7
INSTALL
V 21
file 6.5ck.r29702/222
K 11
Makefile.am
V 22
file 59.5ck.r29567/733
K 4
NEWS
V 24
file 6m.5ck.r25634/30702
K 6
README
V 20
file 7.0.r4421/96382
K 2
ai
V 22
dir 8.5ck.r29729/11808
K 10
autogen.sh
V 24
file 12o.5ck.r29071/2757
K 9
bootstrap
V 23
dir 2p5.5ck.r29680/3553
K 6
client
V 22
dir d.5ck.r29743/60779
K 6
common
V 22
dir p.5ck.r29732/17315
K 12
configure.ac
V 23
file 149.5ck.r29702/447
K 4
data
V 21
dir w.5ck.r29734/5634
K 12
dependencies
V 23
dir 2yu.5ck.r29380/5913
K 3
doc
V 23
dir k7.5ck.r29729/54314
K 10
fc_version
V 25
file 2lo.5en.r29732/29439
K 11
gen_headers
V 24
dir 1hsw.5ck.r29636/5434
K 2
m4
V 23
dir 12p.5ck.r29626/2978
K 7
scripts
V 23
dir 2yo.5ck.r28716/5421
K 6
server
V 21
dir z.5ck.r29741/7372
K 5
tests
V 23
dir 2g9.5ck.r27783/1363
K 5
tools
V 24
dir 4pj.5js.r29729/62143
K 12
translations
V 25
dir t0a.5ck.r29716/101557
K 7
utility
V 22
dir 1c.5ck.r29708/3186
K 5
win32
V 23
dir 2eu.5ck.r28347/2148
END
ENDREP
id: 3.5ck.r29743/62143
type: dir
pred: 3.5ck.r29741/8731
count: 19904
text: 29743 61009 1121 0 b8a58026df1dec5a2e40bc3e7b2e9568
props: 28036 14655 292 0 9e1d5de0253c723466868990c52c129f
cpath: /trunk
copyroot: 15280 /trunk

PLAIN
K 8
branches
V 19
dir 1.0.r29742/9194
K 4
tags
V 19
dir 2.0.r29519/6475
K 5
trunk
V 22
dir 3.5ck.r29743/62143
K 7
website
V 21
dir 3ge.0.r22980/2263
END
ENDREP
id: 0.0.r29743/62533
type: dir
pred: 0.0.r29742/9511
count: 29743
text: 29743 62367 153 0 2415e8802eab6e4a7f52a414087db2c6
cpath: /
copyroot: 0 /

zl.5ck.t29742-1 modify true false /trunk/client/agents/cma_fec.c

z4.5ck.t29742-1 modify true false /trunk/client/citydlg_common.c

z5.5ck.t29742-1 modify true false /trunk/client/citydlg_common.h

mb.5ck.t29742-1 modify true false /trunk/client/cityrepdata.c

d5.5ck.t29742-1 modify true false /trunk/client/climisc.c

2fw.5ck.t29742-1 modify true false /trunk/client/connectdlg_common.c

gz.5ck.t29742-1 modify true false /trunk/client/control.c

h1.5ck.t29742-1 modify true false /trunk/client/helpdata.c

765.5ck.t29742-1 modify true false /trunk/client/luascript/script_client.c

15m.5ck.t29742-1 modify true false /trunk/client/mapctrl_common.c

z2.5ck.t29742-1 modify true false /trunk/client/mapview_common.c

z3.5ck.t29742-1 modify true false /trunk/client/mapview_common.h

2yk.5ck.t29742-1 modify true false /trunk/client/overview_common.c

n.5ck.t29742-1 modify true false /trunk/client/packhand.c

33x.5ck.t29742-1 modify true false /trunk/client/servers.c

2g3.5ck.t29742-1 modify true false /trunk/client/text.c

hl.5ck.t29742-1 modify true false /trunk/client/tilespec.c


62533 62680
