DELTA 22861 55790 13590
SVN  åÕ  ë*  ÁMó$ ¨½ ENDREP
DELTA 1041 13965 2996
SVN  ¨ªOƒZ …i € G  ˜M†0€7 GŸ4  †1¡€s#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */

/* utility */
#include "bitvector.h"
#include "support.h"            /* bool type */

 /* Used in the network protocol. */
#define NUM_SS_COMPONENTS 16
#define NUM_SS_MODULES 12

/* Used in the network protocol. */
BV_DEFINE(bv_spaceship_structure, NUM_SS_STRUCTURALS);bv_spaceship_structure structureconst struct player_spaceship *ship);

#ifdef __cplusplus
}
#endif /* __cplusplus */

#endif /* FC__SPACESHIP_H */
ENDREP
DELTA 23417 6117 22
SVN  ˆYˆX
 ‡  J‡6ENDREP
DELTA 18362 31851 2838
SVN  âTäj‰X …X ƒ ‰…X€i H€…@ ‰1”z ‡%ž5  $¦b£ E§@ ¨O S´@ ‡mªDª E§@ „j²z€K ‚¸€K W½z€f vËzš LÂ. š¾l™ E§@ ‰ÙPfc_ (i = 0; i < NUM_SS_STRUCTURALS; i++) {
    if (BV_ISSET(ship->structure, i)) {
      ship->mass += (i <  (i = 0; i < ship->fuel; i++) {
    if (BV_ISSET(ship->structure, components_info[i * 2].required)) {
      fuel++;
    }
  }
  for (i = 0; i < ship->propulsion; i++) {
    if (BV_ISSET(ship->structure, components_info[i * 2 + 1].required)) {
      propulsion++;
    }
  }
  for (i = 0; i < ship->habitation; i++) {
    if (BV_ISSET(ship->structure, modules_info[i * 3].required)) {
      habitation++;
    }
  }
  for (i = 0; i < ship->life_support; i++) {
    if (BV_ISSET(ship->structure, modules_info[i * 3 + 1].required)) {
      life_support++;
    }
  }
  for (i = 0; i < ship->solar_panels; i++) {
    if (BV_ISSET(ship->structure, modules_info[i * 3 + 2].required)) {
      solar_panels++;
    }info.structure = ship->structure  Handle spaceship launch request.
capital(pplayer)  Handle spaceship part placement request
 < 0 || num >= NUM_SS_STRUCTURALS
        || BV_ISSET(ship->structure, num) != 0
        && !BV_ISSET(ship->structure, structurals_info[num].required)That Space Structural would not be connected!"));
      return;
    }
    BV_SET(ship->structure, num)FUEL) {
    if (ship->fuel  Handle spaceship loss.
ENDREP
DELTA 23312 456 56378
SVN  †  †    †   †  ³
³
 ø œ º^ø,BV_ISSET(ship->structure, i)ENDREP
DELTA 22339 4787 2595
SVN  ««dJ…C ‡K ¼ E‡@€Y …gŠB€  ƒ/3“ Cš@“ Q”} ƒ”w„ Uš;„ Uš; … š3½ &ŸE€# ‚T¡x †¥};

struct data_out {
  void *dest;
  size_t dest_size, used};

/* Used for dio_<put|get>_type() methods.
 * NB: we only support integer handling currently. */
enum data_type {
  DIOT_UINT8,
  DIOT_UINT16,
  DIOT_UINT32,
  DIOT_SINT8,
  DIOT_SINT16,
  DIOT_SINT32,

  DIOT_LASTsize_t data_type_size(enum data_type type);

/* gets */
bool dio_get_type(struct data_in *din, enum data_type type, int *dest)
    fc__attribute((nonnull (3)));bool dio_get_sint32
bool dio_get_bool8techunittype(struct data_out *dout, enum data_type type, int value);
void dio_put_sint8(struct data_out *dout, int value);
void dio_put_sint16(struct data_out *dout, int value);
void dio_put_sint32(struct data_out *dout, int value);ENDREP
DELTA 23390 5301 116
SVN  ƒ‰Wƒ‰ea ¹U  ˜º » âÒŠ Ã}´œ ‘#ø4type BV_SPACESHIP_STRUCT = bitvector(bv_spaceship_structure;
  UINT16V_SPACESHIP_STRUCT structureENDREP
DELTA 23398 11154 1583
SVN  †  †   „¶T €\ E„·< ç`„¸ «/* Already not set */
	} else if (st[i] == '1') {
	  BV_SET(ship->structure, i);
	} else {
	n%03d", nat_y),
	set_savegame_old_resource(†  ƒ­.ƒ­  ƒ­+ENDREP
DELTA 23169 3631 28546
SVN  †  †  Dº ª  vª,† ƒ!¬— ½SÀ; ƒˆB |Œu ƒHL £f¡K G  ¾Ô[ §ƒ † —%ƒÄ.š ¤AƒÛR“ ŒZ„€0€‚o O„œ8€Y ˆh„Œx S‚˜  üj„£€… V…Å@› V‚¸ € Vƒ¾=€”1 e‚Î@• V‚¸ ¾ Vƒ¾=€ _„¢<˜ V‚¸ €@ Vƒ¾=€ˆk d‚Î@˜ V‚¸ ¿ Vƒ¾=€compatextern bool sg_success;, TRUEif (loading->special.size)urrent_compat_ver()activities order in the savegame. */
  secfile_insert_int(saving->file, ACTIVITY_LAST,
                     "savefile.activities_size");
  if (ACTIVITY_LAST > 0) {
    const char **modname;
    int i = 0;
    int j;

    modname = fc_calloc(ACTIVITY_LAST, sizeof(*modname));

    for (j = 0; j < ACTIVITY_LAST; j++) {
      modname[i++] = unit_activity_name(j);
    }ACTIVITY_LAST,
                           "savefile.activities_vector");
    free(modname[MAX_LEN_NAME * nation_hash_size(nations)];

      nation_names[0] = '\0';
      nation_hash_iterate(nations, pnation) {
        if ('\0' == nation_names[0]) {
          fc_strlcpy(nation_names, nation_rule_name(pnation),
                     sizeof(nation_names));
        } else {
          cat_snprintf(nation_names, sizeof(nation_names),
                       "%c%s", SEPARATOR, nation_rule_name(pnation));
        }
      } nation_hash_iterate_end;
      secfile_insert_str(saving->file, nation_names,
                         "map.startpos%d.nations", i);
    }
    i++;
  } map_startpos_iterate_end;

  fc_assert(map_startpos_count() == iLoad tile owner informationvoid sg_load_map_owner(struct loaddata *loading)
{
  int x, y;
  struct player *owner = NULL;
  struct tile *claimer = NULL;
  struct player *eowner = NULL;
if (game.info.is_new_game) {
    /* No owner/source information for a new game / scenario. */
    return;
  }

  /* Owner and ownership source are stored as plain numbers */
  for (y = 0; y < map.ysize; y++) {
    const char *buffer1 = secfile_lookup_str(loading->file,
                                             "map.owner%04d", y);
    const char *buffer2 = secfile_lookup_str(loading->file,
                                             "map.source%04d", y);
    const char *buffer3 = secfile_lookup_str(loading->file,
                                             "map.eowner%04d", y);
    const char *ptr1 = buffer1;
    const char *ptr2 = buffer2;
    const char *ptr3 = buffer3;

    sg_failure_ret(buffer1 != NULL, "%s", secfile_error());
    sg_failure_ret(buffer2 != NULL, "%s", secfile_error());
    if (loading->version >= 30) {
      sg_failure_ret(buffer3 != NULL, "%s", secfile_error());
    }

    for (x = 0; x < map.xsize; x++) {
      char token1[TOKEN_SIZE];
      char token2[TOKEN_SIZE];
      char token3[TOKEN_SIZE];
      int number;
      struct tile *ptile = native_pos_to_tile(x, y);

      scanin(&ptr1, ",", token1, sizeof(token1));
      sg_failure_ret(token1[0] != '\0',
                     "Map size not correct (map.owner%d).", y);
      if (strcmp(token1, "-") == 0) {
        owner = NULL;
      } else {
        sg_failure_ret(str_to_int(token1, &number),
                       "Got map owner %s in (%d, %d).", token1, x, y);
        owner = player_by_number(number);
      }

      scanin(&ptr2, ",", token2, sizeof(token2));
      sg_failure_ret(token2[0] != '\0',
                     "Map size not correct (map.source%d).", y);
      if (strcmp(token2, "-") == 0) {
        claimer = NULL;
      } else {
        sg_failure_ret(str_to_int(token2, &number),
                       "Got map source %s in (%d, %d).", token2, x, y);
        claimer = index_to_tile(number);
      }

      if (loading->version >= 30) {
        scanin(&ptr3, ",", token3, sizeof(token3));
        sg_failure_ret(token3[0] != '\0',
                       "Map size not correct (map.eowner%d).", y);
        if (strcmp(token3, "-") == 0) {
          eowner = NULL;
        } else {
          sg_failure_ret(str_to_int(token3, &number),
                         "Got base owner %s in (%d, %d).", token3, x, y);
          eowner = player_by_number(number);
        }
      } else {
        eowner = owner;
      }

      map_claim_ownership(ptile, owner, claimer, FALSE);
      tile_claim_bases(ptile, eowner);
      log_debug("extras_owner(%d, %d) = %s", TILE_XY(ptile), player_name(eowner))ile owner informationvoid sg_save_map_owner(struct savedata *saving)
{
  int x, y;
if (saving->scenario && !saving->save_players) {
    /* Nothing to do for a scenario without saved players. */
    return;
  }

  /* Store owner and ownership source as plain numbers. */
  for (y = 0; y < map.ysize; y++) {
    char line[map.xsize * TOKEN_SIZE];

    line[0] = '\0';
    for (x = 0; x < map.xsize; x++) {
      char token[TOKEN_SIZE];
      struct tile *ptile = native_pos_to_tile(x, y);

      if (!saving->save_players || tile_owner(ptile) == NULL) {
        strcpy(token, "-");
      } else {
        fc_snprintf(token, sizeof(token), "%d",
                    player_number(tile_owner(ptile)));
      }
      strcat(line, token);
      if (x + 1 < map.xsize) {
        strcat(line, ",");
      }
    }
    secfile_insert_str(saving->file, line, "map.owner%04d", y);
  }

  for (y = 0; y < map.ysize; y++) {
    char line[map.xsize * TOKEN_SIZE];

    line[0] = '\0';
    for (x = 0; x < map.xsize; x++) {
      char token[TOKEN_SIZE];
      struct tile *ptile = native_pos_to_tile(x, y);

      if (ptile->claimer == NULL) {
        strcpy(token, "-");
      } else {
        fc_snprintf(token, sizeof(token), "%d", tile_index(ptile->claimer));
      }
      strcat(line, token);
      if (x + 1 < map.xsize) {
        strcat(line, ",");
      }
    }
    secfile_insert_str(saving->file, line, "map.source%04d", y);
  }

  for (y = 0; y < map.ysize; y++) {
    char line[map.xsize * TOKEN_SIZE];

    line[0] = '\0';
    for (x = 0; x < map.xsize; x++) {
      char token[TOKEN_SIZE];
      struct tile *ptile = native_pos_to_tile(x, y);

      if (!saving->save_players || base_owner(ptile) == NULL) {
        strcpy(token, "-");
      } else {
        fc_snprintf(token, sizeof(token), "%d",
                    player_number(base_owner(ptile)));
      }
      strcat(line, token);
      if (x + 1 < map.xsize) {
        strcat(line, ",");
      }
    }
    secfile_insert_str(saving->file, line, "map.eowner%04d", yworked tiles informationvoid sg_load_map_worked(struct loaddata *loading)
{
  int x, y;
sg_failure_ret(loading->worked_tiles == NULL,
                 "City worked map not loaded!");

  loading->worked_tiles = fc_malloc(MAP_INDEX_SIZE *
                                    sizeof(*loading->worked_tiles));

  for (y = 0; y < map.ysize; y++) {
    const char *buffer = secfile_lookup_str(loading->file, "map.worked%04d",
                                            y);
    const char *ptr = buffer;

    sg_failure_ret(NULL != buffer,
                   "Savegame corrupt - map line %d not found.", y);
    for (x = 0; x < map.xsize; x++) {
      char token[TOKEN_SIZE];
      int number;
      struct tile *ptile = native_pos_to_tile(x, y);

      scanin(&ptr, ",", token, sizeof(token));
      sg_failure_ret('\0' != token[0],
                     "Savegame corrupt - map size not correct.");
      if (strcmp(token, "-") == 0) {
        number = -1;
      } else {
        sg_failure_ret(str_to_int(token, &number) && 0 < number,
                       "Savegame corrupt - got tile worked by city "
                       "id=%s in (%d, %d).", token, x, y);
      }

      loading->worked_tiles[ptile->index] = numberworked tiles informationvoid sg_save_map_worked(struct savedata *saving)
{
  int x, y;
if (saving->scenario && !saving->save_players) {
    /* Nothing to do for a scenario without saved players. */
    return;
  }

  /* †  †  †  U²P â5¾"© •‚ K· ¼'‚·4¡ ‚ómœ L‚ô|€D Ž7‚õr› ë-ƒ„< ‹&„÷4 ƒi„ïi’ ‚8…–. „ö€X J„ð;Ž w„ôz T„õr€H J„ð;Œ w„ôz T„õr€, “…ƒ… ƒ9…–€c J„ð;Ž w„ôz …• €a J„ð;Œ w„ôz …• ž XƒË< …8…šH€“X ]º=Ÿ Wƒž ³ =†r€”E Tœ|‘ D† €[BV_SET(pach->achievers, player_index(plr)!(st[i] == '0')) {
          BV_SET(ship->structure, i)achievement_player_has(pach, plr)if (pach->first == plr) {
    "player%d.achievement%d.first", plrno, j);
        } else {
          secfile_insert_bool(saving->file, FALSE,
                              "player%d.achievement%d.first", plrno, j);
        }
BV_ISSET(ship->structure, i else if (activity else if (activity == ACTIVITY_POLLUTION) {
      struct extra_type *tgt = prev_extra_inEC_POLLUTION,
POLLUTION, tgt);
      } else {
        set_unit_activity_targeted(punit, ACTIVITY_POLLUTION, NULL);
      }
    } else if (activity == ACTIVITY_FALLOUT) {
      struct extra_type *tgt = prev_extra_inEC_FALLOUT,
FALLOUT, tgt);
      } else {
        set_unit_activity_targeted(punit, ACTIVITY_FALLOUT, NULL);
      }
    } else {
      set_unit_activity_targeted(punit, activity, NULL else else if (punit->changed_from == ACTIVITY_POLLUTION) {
      struct extra_type *tgt = prev_extra_inEC_POLLUTION,
 else if (punit->changed_from == ACTIVITY_FALLOUT) {
      struct extra_type *tgt = prev_extra_inEC_FALLOUT,
}

  punit->changed_from_count.data) {
    free(plr->attribute_block.data);
    plr->attribute_block.data = NULL;
  }

  /* This is a big heap of opaque data for the client, check everything! */
  plr->attribute_block.length = secfile_lookup_int_default(
      loading->file, 0, "player%d.attribute_v2_block_length", plrno);

  if (0 > plr->attribute_block.length) {
    log_sg("player%d.attribute_v2_block_length=%d too small", plrno,
           plr->attribute_block.length);
    plr->attribute_block.length = 0;
  } else if (MAX_ATTRIBUTE_BLOCK < plr->attribute_block.length) {
    log_sg("player%d.attribute_v2_block_length=%d too big (max %d)",
           plrno, plr->attribute_block.length, MAX_ATTRIBUTE_BLOCK);
    plr->attribute_block.length = 0;
  } else if (0 < plr->attribute_block.length) {
    int part_nr, parts;
    size_t actual_length;
    int quoted_length;
    char *quoted;

    sg_failure_ret(
        secfile_lookup_int(loading->file, &quoted_length,
                           "player%d.attribute_v2_block_length_quoted",
                           plrno), "%s", secfile_error());
    sg_failure_ret(
        secfile_lookup_int(loading->file, &parts,
                           "player%d.attribute_v2_block_parts", plrno),
        "%s", secfile_error());

    quoted = fc_malloc(quoted_length + 1);
    quoted[0] = '\0';
    plr->attribute_block.data = fc_malloc(plr->attribute_block.length);
    for (part_nr = 0; part_nr < parts; part_nr++) {
      const char *current =
          secfile_lookup_str(loading->file,
                             "player%d.attribute_v2_block_data.part%d",
                             plrno, part_nr);
      if (!current) {
        log_sg("attribute_v2_block_parts=%d actual=%d", parts, part_nr);
        break;
      }
      log_debug("attribute_v2_block_length_quoted=%lu have=%lu part=%lu",
                (unsigned long) quoted_length,
                (unsigned long) strlen(quoted),
                (unsigned long) strlen(current));
      fc_assert(strlen(quoted) + strlen(current) <= quoted_length);
      strcat(quoted, current);
    }
    fc_assert_msg(quoted_length == strlen(quoted),
                  "attribute_v2_block_length_quoted=%lu actual=%lu",
                  (unsigned long) quoted_length,
                  (unsigned long) strlen(quoted));

    actual_length =
        unquote_block(quoted,
                      plr->attribute_block.data,
                      plr->attribute_block.length);
    fc_assert(actual_length == plr->attribute_block.length);
    free(quoted);player (client) attributes datavoid sg_save_player_attributes(struct savedata *savhis is a big heap of opaque data from the client.  Although the binary
   * format is not user editable, keep the lines short enough for debugging,
   * and hope that data compression will keep the file a reasonable size.
   * Note that the "quoted" format is a multiple of 3.
   */
#define PART_SIZE (3*256)
#define PART_ADJUST (3)
  if (plr->attribute_block.data) {
    char part[PART_SIZE + PART_ADJUST];
    int parts;
    int current_part_nr;
    char *quoted = quote_block(plr->attribute_block.data,
                               plr->attribute_block.length);
    char *quoted_at = strchr(quoted, ':');
    size_t bytes_left = strlen(quoted);
    size_t bytes_at_colon = 1 + (quoted_at - quoted);
    size_t bytes_adjust = bytes_at_colon % PART_ADJUST;

    secfile_insert_int(saving->file, plr->attribute_block.length,
                       "player%d.attribute_v2_block_length", plrno);
    secfile_insert_int(saving->file, bytes_left,
                       "player%d.attribute_v2_block_length_quoted", plrno);

    /* Try to wring some compression efficiencies out of the "quoted" format.
     * The first line has a variable length decimal, mis-aligning triples.
     */
    if ((bytes_left - bytes_adjust) > PART_SIZE) {
      /* first line can be longer */
      parts = 1 + (bytes_left - bytes_adjust - 1) / PART_SIZE;
    } else {
      parts = 1;
    }

    secfile_insert_int(saving->file, parts,
                       "player%d.attribute_v2_block_parts", plrno);

    if (parts > 1) {
      size_t size_of_current_part = PART_SIZE + bytes_adjust;

      /* first line can be longer */
      memcpy(part, quoted, size_of_current_part);
      part[size_of_current_part] = '\0';
      secfile_insert_str(saving->file, part,
                         "player%d.attribute_v2_block_data.part%d",
                         plrno, 0);
      bytes_left -= size_of_current_part;
      quoted_at = &quoted[size_of_current_part];
      current_part_nr = 1;
    } else {
      quoted_at = quoted;
      current_part_nr = 0;
    }

    for (; current_part_nr < parts; current_part_nr++) {
      size_t size_of_current_part = MIN(bytes_left, PART_SIZE);

      memcpy(part, quoted_at, size_of_current_part);
      part[size_of_current_part] = '\0';
      secfile_insert_str(saving->file, part,
                         "player%d.attribute_v2_block_data.part%d",
                         plrno,
                         current_part_nr);
      bytes_left -= size_of_current_part;
      quoted_at = &quoted_at[size_of_current_part];
    }
    fc_assert(bytes_left == 0);
    free(quoted);
  }
#undef PART_ADJUST
#undef PART_SIZELoad vision data
********/
static void sg_load_player_vision(struct loaddata *loading,
                     ŒÀ ‚él¹Y
  E•| ¹®)ENDREP
DELTA 20460 27027 26
SVN  ¨F©<9ƒP ™] œ R™o¿ Q›o€F Qœu€F K{¶ ‚Ÿr³ ¢9© }£]ž g¤n¹ B§BV_ISSET(ship->structure, 0)        && !BV_ISSET(ship->structure, modules_info[0].required)               && !BV_ISSET(ship->structure, modules_info[1].required)               && !BV_ISSET(ship->structure, modules_info[2].required)BV_ISSET(ship->structure, components_info[i].required)BV_ISSET(ship->structure, modules_info[i].required)        if (!BV_ISSET(ship->structure, i)BV_ISSET(ship->structure, req)BV_ISSET(ship->structure, structurals_info[req].required)ENDREP
DELTA 18148 0 66787
SVN  †  †  ‰–\ …X ƒ b…X€r M‡S€/ ‡eŠ€z ‚Ì~€C ‚>•Ÿ KƒÊ  ‰B˜2 !¡r€ L…¿@€z 5¤Q€E ‚%¦c€# i©k€2 S«G€l …!®;€X e¼} ‚´g€ L…¿@€ ¸A€$ fº:€‚v ‚_¼e€ „AÀF€b ‰7Ä …cÎ;³ _Ô: ‚eÕ€‚~ †/×{„ †:Þ(¾ ]å*¿ æ<€G ‚Aè› 0ê`€R AìX§ Sƒœ ˆwï† „2ø œ6ü<— ‚H™€} €ƒM {žhƒ …Ÿf ‚n§3€	 6ª€) ‚N¤f I¬!¢ "­j¯ ¢w½
† Iàš ^ü€
 ƒMã €‚! „æk© vŠ4¨ „ìr ‚Qñ¢ ‚7ón¯ ‚ö#ž „zøq¢ Z…¿@ ;þG ”2‚€Ž ‰$‚”R£ RƒÊ  ƒE‚žK… ƒ4‚¢¿ Q…–œ L…¿@€9 ^‚ªZ• L…¿@  ^‚­€N g‚»Q€†9 ƒi‚½3€‚p ˆ9‚Ã -‚Ëa€„g D‚Ï@€9 ‡z‚Ñ‡ B‚Ù#‡ v‚Úo€X ‚‚Ûd „e‚Þ€' ‹m‚ã}˜ ‚/‚ð· „"‚ó€‚. ‡p‚ùH€^ ƒƒ‚€b <ƒ…y€‰4 jƒ‡1 nƒˆ&€& cƒ‰Z ƒƒ‹M¥ L…¿@¦ 
ƒ^€Y ƒ|ƒ‘ Žƒ• L…¿@  ‚eƒ¤„ …Mƒ¦€‚W .ƒ­/ ‚7ƒ®m€@ MƒÊ €c ^ƒ²5Œ „ƒÂ€X ƒÆŠ R…–~ ‚	ƒÈB¢ ƒÊe `ƒËr€ˆ ªƒÎ<€z †-ƒø=› L…¿@€K Q…–¤ L…¿@§ ‚
ƒÿZ€‡0 :„‡s½ \Ê? ‚7„‰~€m ›D„´ d„¨lŽ ˜~„©_œ p„Âo€‚m K„Ç€N c„Ël #„Ê³ „ËW© f„Ì{ž `„Íu¹ ‚„Ð¢ L…¿@€G †d„Ó1¢ ‚„Ý L…¿@  ƒ„à2 …„ãd€U ƒM„ì †8„ïg€ƒ Œm„ö „q…†~€‚+ ‡N…‹g …“3¤ ‚{…”U x…—N¦ 5…™d€m …Q…›?€M „…¡ D…§€„2 Q…–€H L…¿@€ƒ] Q…–¦ L…¿@© …ª<¡ |…«l  L…¿@£ …®R¡ ‡o…°€` „#…¸(€ƒ /…¾¦ L…¿@€‚ Q…–¥ L…¿@€ƒX Q…–  L…¿@£ …À'¡ „…ÁL¥ L…¿@€ƒI Q…–¤ L…¿@§ ,…ÆIfc_achievements.h"
#include "actions.h"
#include "capstr.h"
#include "citizens.h"
#include "events.h"
#include "extrargbcolor.h"
#include "road.h"
#include "spaceship.h"
#include "specialist.h"
#include "traderoutes.h"
#include "unit.h"
#include "unitlist.h"
#include "worklist.h"

/* client//* Define this macro to get additional debug output about the transport
 * status of the units. */
#undef DEBUG_TRANSPORT
;
static bool handle_unit_packet_common(struct unit *packet_unit);
lient_main.c client_game_free() Especially notice that unit structure filled
  here is just temporary one. Values must be copied to real unit in
  handle_unit_packet_common()**/
static struct unit *unpackage_unit(const struct packet_unit_info *packet)
{
  struct unit *punit = unit_virtual_createunit_virtual_create. */
  punit->nationality = player_by_number(packet->nationality);
  punit->id = packet->id;
  unit_tile_set(punit, index_to_tile(packet->tile));
  punit->facing = packet->facing
  if (packet->activity_tgt == EXTRA_NONE) {
    punit->activity_target = NULL;
  } else {
    punit->activity_target = extra_by_number(packet->activity_tgt);
  }

 if (packet->changed_from_tgt == EXTRA_NONE) {
    punit->changed_from_target = NULL;
  } else {
    punit->changed_from_target = extra_by_number(packet->changed_from_tgt);
  }

  /* Transporter / transporting information. */
  punit->client.occupied = packet->occupied;
  if (packet->transported) {
    punit->client.transported_by = packet->transported_by;
  } else {
    punit->client.transported_by = -1;
  }
target = packet->orders_targets[i];
    }
  }

  punit->client.asking_city_name = FALSE; Especially notice that unit structure filled
  here is just temporary one. Values must be copied to real unit in
  handle_unit_packet_common()**/
static struct unit *
unpackage_short_unit(const struct packet_unit_short_info *packet)
{
  struct unit *punit = unit_virtual_createunit_virtual_create. */
  punit->id = packet->id;
  unit_tile_set(punit, index_to_tile(packet->tile));
  punit->facing = packet->facing;
  punit->nationality = NULL
  if (packet->activity_tgt == EXTRA_NONE) {
    punit->activity_target = NULL;
  } else {
    punit->activity_target = extra_by_number(packet->activity_tgt);
  }

  /* Transporter / transporting information. */
  punit->client.occupied = packet->occupied;
  if (packet->transported) {
    punit->client.transported_by = packet->transported_by;
  } else {
    punit->client.onst char *message,
                              const char *capability,
                              const char *challenge_file, int conn_id)
{
  consttrncpy(client_info.distribution, FREECIV_DISTRIBUTOR,
            sizeof(client_info.distribution)unit_by_number(unit_id);
  struct unit_list *cargos/* Unload cargo if this is a transporter. */
  cargos = unit_transport_cargo(punit);
  if (unit_list_size(cargos) > 0) {
    unit_list_iterate(cargos, pcargo) {
      unit_transport_unload(pcargo);
    } unit_list_iterate_end;
  }

  /* Unload unit if it is transported. */
  if (unit_transport_get(punit)) {
    unit_transport_unload(punit);
  }
  punit->client.transported_by = -1onstunit_by_number(attacker_unit_id);
  struct unit *punit1 = gameunit_tile(punit0)) &&
	tile_visible_mapcanvas(unit_tile(punit1)unit_tile(punit0));
      else
	center_tile_mapcanvas(unit_tile(punit1)smooth_combat_step_msec > 0unit_tile(punit0), TRUE, FALSE);
	refresh_unit_mapcanvas(punit1, unit_tile(punit1)unit_tile(pwinner), TRUE, FALSE);
    }const city_size_set(pcity, 0)city_size_add(pcity, pcity->feel[i][FEELING_FINAL]);
  }
  specialist_type_iterate(sp) {
    pcity->specialists[sp] = packet->specialists[sp];
    city_size_add(pcity, pcity->specialists[sp]);
  } specialist_type_iterate_end;

  if (city_size_get(pcity)city_size_get(pcity), packet->size, city_name(pcity));
    city_size_set(pcity, packet->size);
  }

  /* The nationality of the citizens. */
  if (game.info.citizen_nationality) {
    citizens_init(pcity);
    for (i = 0; i < packet->nationalities_count; i++) {
      citizens_nation_set(pcity, player_slot_by_number(packet->nation_id[i]),
                          packet->nation_citizens[i]);
    }
    fc_assert(citizens_count(pcity) == city_size_get(pcity))MAX/* Need to consider shield stock/surplus for unit dialog as used build
   * slots may change, affecting number of "in-progress" units. */
      || pcity->surplus[O_SHIELD] != packet->surplus[O_SHIELD]
      || shield_stock_changed) {
    need_units_dialog_update = TRUE;
  }
  pcity->production = product;
 /* DONE_BY_create_city_virtual */  pcity->client.city_image = packet->city_imageconst city_by_number(packet->id)tile_list *worked_tiles = NULL;
  struct player *powner = player_by_number(packet->owner);
  int radius_sq = game.info.init_city_radius_sq
      whole_map_iterate(ptile) {
        if (ptile->worked == pcity) {
          int dist_sq = sq_map_distance(pcenter, ptile);
          if (dist_sq > city_map_radius_sq_get(pcity)) {
            city_map_radius_sq_set(pcity, dist_sq);
          }
        }
      } whole_map_iterate_endradius_sq = city_map_radius_sq_get(pcity)city_map_radius_sq_set(pcity, radius_sq)rcity_size_set(pcity, packet->size)  pcity->client.city_image = packet->city_images_improvement_visible(pimprove  Handle turn and year advancementnit_focus_updateunit_focus_set  Plays sound associated with eventonst onst char *message)
{
  popup_connect_msg(_("Welcome"), message**
  Packet page_msg handler**/
void handle_page_msg(const char *caption, const char *headline,
                     const char *lines, enum event_type event)
{
  if (!client_has_player()
      || !client_player()**
  Packet unit_info**/
void handle_unit_info(const unit_by_number(unit_owner(packet_unit), packet_unit->id);
  if (!punit && game/* In some situations, the size of repaint units require can change;
     * in particular, city-builder units sometimes get a potential-city
     * outline, but to speed up redraws we don't repaint this whole area
     * unnecessarily. We need to ensure that when the footprint shrinks,
     * old bits aren't left behind on the canvas.
     * If the current (old) status of the unit is such that it gets a large
     * repaint, as a special case, queue a large repaint immediately, to
     * schedule the correct amount/location to be redrawn; but rely on the
     * repaint being deferred until the unit is updated, so that what's
     * drawn reflects the new status (e.g., no city outline). */
    if (unit_drawn_with_city_outline(punit, TRUE)) {
      refresh_unit_mapcanvas(punit, unit_tile(punit), TRUE, FALSE);
    }
facing != packet_unit->facing) {
      punit->facing = packet_unit->facing;
      repaint_unit = TRUE;
    }

    if (punit->activity != packet_unit->activity
        || punit->activity_target == packet_unit->activity_target
        || punit->client.transported_by != packet_unit->client.transported_by
        || punit->client.occupied != packet_unit->client.occupiednit_focus_urgent
      if (punit->client.transported_by
          != packet_unit->client.transported_by) {
        if (packet_unit->client.transported_by == -1) {
          /* The unit was unloaded from its transport. The check for a new
           * transport is done below. */
          unit_transport_unload(punit);
        }

        punit->client.transported_by = packet_unit->client.transported_by;
      }

      if (punit->client.occupied != packet_unit->client.occupied) {
        if (get_focus_unit_on_tile(unit_tile(packet_unit))) {
          /* Special case: (un)loading a unit in a transporter on the same
           *  * loaded.  Thus the orders->(un)load menu item needs updating. */
          need_menus_update = TRUE;
        }
        punit->client.occupied = packet_unit->client.occupied;
      }
 = game = game
      /* This can change total upkeep figures */
      need_units_report_update = TRUE;unit_tile(punit)unit_tile(punit), unit_tile(packet_unit))) {
      /*** Change position ***/
      struct city *pcity = tile_city(unit_tile(punit));

      old_tile = unit_tile(punit)!unit_transported(punit)unit_transport_cargo(punit), pcargo) {
            if ( ((pcity = game_city_by_number(punit->homecity))) {
	refresh_city_dialog(pcity);
      }
      if (repaint_unit && tile_city(unit_tile(punit))
          && tile_city(unit_tile(punit)) != pcity) {
        /* Refresh the city we're occupying too. */
        refresh_city_dialog(tile_city(unit_tile(punit)unit_tile(punit)->units, punit);

    unit_register_battlegroup(punit);

    if ((pcity = game!unit_transported(punit);
    agents_unit_new(punit);

    if ((pcity = tile_city(unit_tile(punit)/* Check if we have to load the unit on a transporter. */
  if (punit->client.transported_by != -1) {
    struct unit *ptrans
      = game_unit_by_number(packet_unit->client.transported_by);

    /* Load unit only if transporter is known by the client. For full
     * unit info the transporter should be known. See recursive sending
     * of transporter information in send_unit_info_to_onlookers(). */
    if (ptrans && ptrans != unit_transport_get(punit)) {
      /* First, we have to unload the unit from its old transporter. */
      unit_transport_unload(punit);
      unit_transport_load(punit, ptrans, TRUE);
#ifdef DEBUG_TRANSPORT
      log_debug("load %s (ID: %d) onto %s (ID: %d)",
                unit_name_translation(punit), punit->id,
                unit_name_translation(ptrans), ptrans->id);
    } else if (ptrans && ptrans == unit_transport_get(punit)) {
      log_debug("%s (ID: %d) is loaded onto %s (ID: %d)",
                unit_name_translation(punit), punit->id,
                unit_name_translation(ptrans), ptrans->id);
    } else {
      log_debug("%s (ID: %d) is not loaded", unit_name_translation(punit),
                punit->id);
#endif /* DEBUG_TRANSPORT */
    }
  }unit_tile(punit)  /* Update (an possible active) unit select dialog. */
    unit_select_dialog_update();
  }

  if (repaint_unit) {
    refresh_unit_mapcanvas(punit, unit_tile(punit)nit_focus_update**
  Receive a short_unit info packet**/
void handle_unit_short_info(const unit_by_number(packet->id);
    if (punit) {
      /* Unload unit if it is transported. */
      if (unit_transport_get(punit)) {
        unit_transport_unload(punit);
      }
      punit->client.transported_by = -1;
**
  Packet game_info handler**/
void handle_game_info(const NULLvictory_conditions != pinfo->victory_conditions);
  if (game.info.timeout != 0 && pinfo->seconds_to_phasedone >= 0) {
    /* If this packet is received in the middle of a turn, this value
     * represents the number of seconds from now to the end of the turn
     * (not from the start of the turn). So we need to restart our
     * timer. */nit_focus_update  Sets player inventions to values specified in inventions arraystatic bool read_player_info_techs(struct player *pplayer,
                                   const  int plr_nb/* Free the memory allocated for the player color. */
  tileset_player_free(tileset, pplayer);

  /* Save player number before player is freed */
  plr_nbr = player_number(pplayer);

  client_player_destroy(pplayer);r_nbr, TRU**/
void handle_player_info(const bool new_player/* Player. */
  pslot = player_slot_by_number(pinfo->playerno);
  fc_assert(NULL != pslot);
  new_player = !player_slot_is_used(pslot);
  pplayer = player_new(pslot);

  if (pplayer->rgb == NULL || (pplayer->rgb->r != pinfo->color_red
                               || pplayer->rgb->g != pinfo->color_green
                               || pplayer->rgb->b != pinfo->color_blue)) {
    struct rgbcolor *prgbcolor = rgbcolor_new(pinfo->color_red,
                                              pinfo->color_green,
                                              pinfo->color_blue);
    fc_assert_ret(prgbcolor != NULL);

    player_set_color(pplayer, prgbcolor);
    tileset_player_init(tileset, pplayer);

    rgbcolor_destroy(prgbcolor);

    /* Queue a map update -- may need to redraw borders, etc. */
    update_map_canvas_visible();
  }

  if (new_player) {
    /* Initialise client side player data (tile vision). At the moment
     * redundant as the values are initialised with 0 due to fc_calloc(). */
    client_player_init(pplayer);
  }if (new_tech) {
      /* If we got a new tech the tech tree news an update. */
      science_report_dialog_redraw();
    }**
  Player gained new tech**/
void handle_tech_gained(int tech)
{
  if (tech != A_FUTURE && !valid_advance_by_number(tech)) {
    log_error("Received illegal gained tech %d", tech);
    return;
  }

  show_tech_gained_dialog(tech**
  Packet player_diplstate handler**/
void handle_player_diplstate(const   bool need_players_dialog_update = FALSE;

  fc_assert_ret(ds != NULL);

  if (client_has_player() && my_player == plr2) {
    if (ds->type != packet->type) {
      need_players_dialog_update = TRUE;
    }

    /* Check if we detect change to armistice with us. If so,
     * ready all units for movement out of the territory in
     * question; otherwise they will be disbanded. */
    if (DS_ARMISTICE != player_diplstate_get(plr1, my_player)->type
        && DS_ARMISTICE == packet->type) {
      unit_list_iterate(my_player->units, punit) {
        if (!tile_owner(unit_tile(punit))
            || tile_owner(unit_tile(punit)) != plr1) {
          continue;
        }
        if (punit->client.focus_status == FOCUS_WAIT) {
          punit->client.focus_status = FOCUS_AVAIL;
        }
        if (punit->activity != ACTIVITY_IDLE) {
          request_new_unit_activity(punit, ACTIVITY_IDLE);
        }
      } unit_list_iterate_end;
    }
  if (need_players_dialog_update) {
    players_dialog_updat**/
void handle_conn_info(const struct packet_conn_info *pinfo)
{
  struct connection *pconn = conn_by_numberconst int *conn_id,
                           constconn_by_numberBV_ISSET(ship->structure, 0)        && !BV_ISSET(ship->structure, modules_info[0].required)) {
      req = modules_info[0].required;
    } else if (ship->life_support >= 1
               && !BV_ISSET(ship->structure, modules_info[1].required)) {
      req = modules_info[1].required;
    } else if (ship->solar_panels >= 1
               && !BV_ISSET(ship->structure, modules_info[2].required)BV_ISSET(ship->structure, components_info[i].required)) {
	    req = componentBV_ISSET(ship->structure, modules_info[i].required)        if (!BV_ISSET(ship->structure, i)BV_ISSET(ship->structure, req)BV_ISSET(ship->structure, structurals_info[req].required)**
  Packet spaceship_info handler**/
void handle_spaceship_info(const struct packet_spaceship_info *p)
{ship->structure    = p->structure;**
  Packet tile_info handler**/
void handle_tile_info(const if (!BV_ARE_EQUAL(ptile->extras, packet->extras)) {
    ptile->extras = packet->extra else {
        int dist_sq = sq_map_distance(city_tile(pwork), ptile);
        if (dist_sq > city_map_radius_sq_get(pwork)) {
          /* This is probably enemy city which has grown in diameter since we
           * last saw it. We need city_radius_sq to be at least big enough so
           * that all workers fit in, so set it so. */
          city_map_radius_sq_set(pwork, dist_sq)packet->label[0] == '\0') {
    if (ptile->label != NULL) {
      FC_FREE(ptile->label);
      ptile->label = NULL;
      tile_changed = TRUE;
    }
  } else if (ptile->label == NULL || strcmp(packet->label, ptile->label)) {
      tile_set_label(ptile, packet->label);
      tile_changed = TRUE;
  }**/
void handle_scenario_info(const **/
void handle_ruleset_control(const .client.ruleset_init = FALSE;
  game_ruleset_free();
  game_ruleset_init();
  game.client.ruleset_init = TRUE  VALIDATE(num_road_types,      MAX_ROAD_TYPES,         "roads");
  VALIDATE(num_disaster_types,  MAX_DISASTER_TYPES,     "disasters");
  VALIDATE(num_achievement_types, MAX_ACHIEVEMENT_TYPES, "achievementif (autoaccept_tileset_suggestion) {
        tilespec_reread(game.control.prefered_tileset);
      } else {
        popup_tileset_suggestion_dialog();
      }
    }
  }

  if (packet->prefered_soundset[0] != '\0') {
    /* There is soundset suggestion */
    if (strcmp(packet->prefered_soundset, sound_set_name)) {
      /* It's not currently in use */
      if (autoaccept_soundset_suggestion) {
        audio_restart(game.control.prefered_soundset);
      } else {
        popup_soundset_suggestion_dialog();
      }
    }
  }

  tileset_ruleset_reset(tileset**
  Received packet indicating that all rulesets have now been received**/
void handle_rulesets_ready(void)
{
  /* Setup extra hiders caches */
  extra_type_iterate(pextra) {
    pextra->hiders = extra_type_list_new();
    extra_type_iterate(phider) {
      if (BV_ISSET(pextra->hidden_by, extra_index(phider))) {
        extra_type_list_append(pextra->hiders, phider);
      }
    } extra_type_iterate_end;
  } extra_type_iterate_end;

  /* We are not going to crop any more sprites from big sprites, free them. */
  finish_loading_sprites(tileset**
  Packet ruleset_unit_class handler**/
void handle_ruleset_unit_class(const s_set(&c->name, p->name, p->rule_**
  Packet ruleset_unit handler**/
void handle_ruleset_unit(const s_set(&u->name, p->name, p->rule_converted_to       = utype_by_number(p->converted_to);
  u->convert_time       = p->convert_time  u->embarks            = p->embarks;
  u->disembarks         = p->disembarks;

  if (p->veteran_levels == 0) {
    u->veteran = NULL;
  } else {
    u->veteran = veteran_system_new(p->veteran_levels);

    for (i = 0; i < p->veteran_levels; i++) {
      veteran_system_definition(u->veteran, i, p->veteran_name[i],
                                p->power_fact[i], p->move_bonus[i], 0, 0);
    }**
  Packet ruleset_unit_bonus handler**/
void handle_ruleset_unit_bonus(const struct packet_ruleset_unit_bonus *p)
{
  struct unit_type *u = utype_by_number(p->unit);
  struct combat_bonus *bonus;

  fc_assert_ret_msg(NULL != u, "Bad unit_type %d.", p->unit);

  bonus = malloc(sizeof(*bonus));

  bonus->flag  = p->flag;
  bonus->type  = p->type;
  bonus->value = p->value;

  combat_bonus_list_append(u->bonuses, bonus**
  Packet ruleset_unit_flag handler**/
void handle_ruleset_unit_flag(const struct packet_ruleset_unit_flag *p)
{
  const char *flagname;
  const char *helptxt;

  fc_assert_ret_msg(p->id >= UTYF_USER_FLAG_1 && p->id <= UTYF_LAST_USER_FLAG, "Bad user flag %d.", p->id);

  if (p->name[0] == '\0') {
    flagname = NULL;
  } else {
    flagname = p->name;
  }

  if (p->helptxt[0] == '\0') {
    helptxt = NULL;
  } else {
    helptxt = p->helptxt;
  }

  set_user_unit_type_flag_name(p->id, flagname, helptxt**
  Packet ruleset_tech handler**/
void handle_ruleset_tech(const s_set(&a->name, p->name, p->rule_**
  Packet ruleset_tech_flag handler**/
void handle_ruleset_tech_flag(const struct packet_ruleset_tech_flag *p)
{
  const char *flagname;
  const char *helptxt;

  fc_assert_ret_msg(p->id >= TECH_USER_1 && p->id <= TECH_USER_LAST, "Bad user flag %d.", p->id);

  if (p->name[0] == '\0') {
    flagname = NULL;
  } else {
    flagname = p->name;
  }

  if (p->helptxt[0] == '\0') {
    helptxt = NULL;
  } else {
    helptxt = p->helptxt;
  }

  set_user_tech_flag_name(p->id, flagname, helptxt**
  Packet ruleset_building handler**/
void handle_ruleset_building(const †  Ýqù'ƒw˜l€‹E QÀ§ K €„o QÀ³ K €ƒ2 QÀ¤ K €‘ QÀ© K €ƒP QÀ¹ K €ƒ{ QÀ³ K €‡ PÁ ² K €† QÀ² K €‡ RÍ · K €„` QÀ¶ K €ƒT PÁ ¹ K €‚N PÁ ¹ K €{ E‚@€G K €j PÁ ´ K €‚? E‚@¨ K €w RÀ› Y €‡ UÌ}¡ K ¾  €‡ QÀ« K © +„¨ …X€m ‡¨ Y €w p‰n€‚F G‹ – E‚@¯ Y €‚e Y˜= …u² Y  –T€ d˜=€8 ›$€^ K € QÀ­ K €r QÀ« K €H ‚¡9¬ Y  „r¤3« Y › ƒzª&š SÀ~² R  ‚)±X² R ’ ]±j ‚/µE¦ Y €P SÀ~ 8¿ ° XÏ?¢ Y  Â-™ Y  Ä¦ K ¥ Æ'² K ® „-ÈZ‚ E‚@± K €†O E‚@µ K €…y E‚@ ‡CÍM ÕŸ ‡AÖ0us = p->genus;
  names_set(&b->name, p->name, p->rule_name);
  sz_strlcpy(b->graphic_str, p->graphic_str);
  sz_strlcpy(b->graphic_alt, p->graphic_alt);
  for (i = 0; i < p->reqs_count; i++) {
    requirement_vector_append(&b->reqs, p->reqs[i]);
  }
  fc_assert(b->reqs.size == p->reqs_count);
  for (i = 0; i < p->obs_count; i++) {
    requirement_vector_append(&b->obsolete_by, p->obs_reqs[i]);
  }
  fc_assert(b->obsolete_by.size == p->obs_count);
  b->replaced_by = improvement_by_number(p->replaced_by);
  b->build_cost = p->build_cost;
  b->upkeep = p->upkeep;
  b->sabotage = p->sabotage;
  b->flags = p->flags;
  PACKET_STRVEC_EXTRACT(b->helptext, p->helptext);
  sz_strlcpy(b->soundtag, p->soundtag);
  sz_strlcpy(b->soundtag_alt, p->soundtag_alt);

#ifdef DEBUG
  if (p->id == improvement_count() - 1) {
    improvement_iterate(b) {
      log_debug("Improvement: %s...", improvement_rule_name(b));
      log_debug("  build_cost %3d", b->build_cost);
      log_debug("  upkeep      %2d", b->upkeep);
      log_debug("  sabotage   %3d", b->sabotage);
      if (NULL != b->helptext) {
        strvec_iterate(b->helptext, text) {
        log_debug("  helptext    %s", text);
        } strvec_iterate_end;
      }
    } improvement_iterate_end;
  }
#endif /* DEBUG */

  b->allows_units = FALSE;
  unit_type_iterate(ut) {
    if (ut->need_improvement == b) {
      b->allows_units = TRUE;
      break;
    }
  } unit_type_iterate_end;

  tileset_setup_impr_type(tileset, b**
  Packet ruleset_government handler.**/
void handle_ruleset_government(const struct packet_ruleset_government *p)
{
  int j;
  struct government *gov = government_by_number(p->id);

  fc_assert_ret_msg(NULL != gov, "Bad government %d.", p->id);

  gov->item_number = p->id;

  for (j = 0; j < p->reqs_count; j++) {
    requirement_vector_append(&gov->reqs, p->reqs[j]);
  }
  fc_assert(gov->reqs.size == p->reqs_count);

  names_set(&gov->name, p->name, p->rule_name);
  sz_strlcpy(gov->graphic_str, p->graphic_str);
  sz_strlcpy(gov->graphic_alt, p->graphic_alt);

  PACKET_STRVEC_EXTRACT(gov->helptext, p->helptext);

  tileset_setup_government(tileset, gov**
  Packet ruleset_government_ruler_title handler.**/
void handle_ruleset_government_ruler_title
    (const struct packet_ruleset_government_ruler_title *packet)
{
  struct government *gov = government_by_number(packet->gov);

  fc_assert_ret_msg(NULL != gov, "Bad government %d.", packet->gov);

  (void) government_ruler_title_new(gov, nation_by_number(packet->nation),
                                    packet->male_title,
                                    packet->female_title**
  Packet ruleset_terrain handler.**/
void handle_ruleset_terrain(const struct packet_ruleset_terrain *p)
{
  int j;
  struct terrain *pterrain = terrain_by_number(p->id);

  fc_assert_ret_msg(NULL != pterrain, "Bad terrain %d.", p->id);

  pterrain->tclass = p->tclass;
  pterrain->native_to = p->native_to;
  names_set(&pterrain->name, p->name, p->rule_name);
  sz_strlcpy(pterrain->graphic_str, p->graphic_str);
  sz_strlcpy(pterrain->graphic_alt, p->graphic_alt);
  pterrain->movement_cost = p->movement_cost;
  pterrain->defense_bonus = p->defense_bonus;

  output_type_iterate(o) {
    pterrain->output[o] = p->output[o];
  } output_type_iterate_end;

  if (pterrain->resources != NULL) {
    free(pterrain->resources);
  }
  pterrain->resources = fc_calloc(p->num_resources + 1,
				  sizeof(*pterrain->resources));
  for (j = 0; j < p->num_resources; j++) {
    pterrain->resources[j] = resource_by_number(p->resources[j]);
    if (!pterrain->resources[j]) {
      log_error("handle_ruleset_terrain() "
                "Mismatched resource %d for terrain \"%s\".",
                p->resources[j], terrain_rule_name(pterrain));
    }
  }
  pterrain->resources[p->num_resources] = NULL;

  output_type_iterate(o) {
    pterrain->road_output_incr_pct[o] = p->road_output_incr_pct[o];
  } output_type_iterate_end;

  pterrain->base_time = p->base_time;
  pterrain->road_time = p->road_time;
  pterrain->irrigation_result = terrain_by_number(p->irrigation_result);
  pterrain->irrigation_food_incr = p->irrigation_food_incr;
  pterrain->irrigation_time = p->irrigation_time;
  pterrain->mining_result = terrain_by_number(p->mining_result);
  pterrain->mining_shield_incr = p->mining_shield_incr;
  pterrain->mining_time = p->mining_time;
  pterrain->transform_result = terrain_by_number(p->transform_result);
  pterrain->transform_time = p->transform_time;
  pterrain->clean_pollution_time = p->clean_pollution_time;
  pterrain->clean_fallout_time = p->clean_fallout_time;

  pterrain->flags = p->flags;

  fc_assert_ret(pterrain->rgb == NULL);
  pterrain->rgb = rgbcolor_new(p->color_red, p->color_green, p->color_blue);

  PACKET_STRVEC_EXTRACT(pterrain->helptext, p->helptext);

  tileset_setup_tile_type(tileset, pterrain**
  Packet ruleset_terrain_flag handler.**/
void handle_ruleset_terrain_flag(const struct packet_ruleset_terrain_flag *p)
{
  const char *flagname;
  const char *helptxt;

  fc_assert_ret_msg(p->id >= TER_USER_1 && p->id <= TER_USER_LAST, "Bad user flag %d.", p->id);

  if (p->name[0] == '\0') {
    flagname = NULL;
  } else {
    flagname = p->name;
  }

  if (p->helptxt[0] == '\0') {
    helptxt = NULL;
  } else {
    helptxt = p->helptxt;
  }

  set_user_terrain_flag_name(p->id, flagname, helptxt**
  Handle a packet about a particular terrain resource.**/
void handle_ruleset_resource(const struct packet_ruleset_resource *p)
{
  struct resource *presource = resource_by_number(p->id);

  fc_assert_ret_msg(NULL != presource, "Bad resource %d.", p->id);

  names_set(&presource->name, p->name, p->rule_name);
  sz_strlcpy(presource->graphic_str, p->graphic_str);
  sz_strlcpy(presource->graphic_alt, p->graphic_alt);

  output_type_iterate(o) {
    presource->output[o] = p->output[o];
  } output_type_iterate_end;

  tileset_setup_resource(tileset, presource**
  Handle a packet about a particular extra type.**/
void handle_ruleset_extra(const struct packet_ruleset_extra *p)
{
  struct extra_type *pextra = extra_by_number(p->id);
  int i;

  fc_assert_ret_msg(NULL != pextra, "Bad extra %d.", p->id);

  names_set(&pextra->name, p->name, p->rule_name);

  pextra->category = p->category;
  pextra->causes = p->causes;

  if (pextra->causes & (1 << EC_BASE)) {
    base_type_init(pextra, extra_type_list_size(extra_type_list_by_cause(EC_BASE)));
  }
  if (pextra->causes & (1 << EC_ROAD)) {
    road_type_init(pextra, extra_type_list_size(extra_type_list_by_cause(EC_ROAD)));
  }

  for (i = 0; i < p->reqs_count; i++) {
    requirement_vector_append(&pextra->reqs, p->reqs[i]);
  }
  fc_assert(pextra->reqs.size == p->reqs_count);

  pextra->buildable = p->buildable;

  pextra->native_to = p->native_to;

  pextra->flags = p->flags;
  pextra->hidden_by = p->hidden_by;
  pextra->conflicts = p->conflicts**
  Handle a packet about a particular base type.**/
void handle_ruleset_base(const struct packet_ruleset_base *p)
{
  struct base_type *pbase = base_by_number(p->id);

  fc_assert_ret_msg(NULL != pbase, "Bad base %d.", p->id);

  sz_strlcpy(pbase->graphic_str, p->graphic_str);
  sz_strlcpy(pbase->graphic_alt, p->graphic_alt);
  sz_strlcpy(pbase->activity_gfx, p->activity_gfx);
  sz_strlcpy(pbase->act_gfx_alt, p->act_gfx_alt);
  pbase->pillageable = p->pillageable;

  pbase->gui_type = p->gui_type;
  pbase->build_time = p->build_time;
  pbase->defense_bonus = p->defense_bonus;
  pbase->border_sq  = p->border_sq;
  pbase->vision_main_sq = p->vision_main_sq;
  pbase->vision_invis_sq = p->vision_invis_sq;

  pbase->flags = p->flags;

  PACKET_STRVEC_EXTRACT(pbase->helptext, p->helptext);

  tileset_setup_base(tileset, pbase**
  Handle a packet about a particular road type.**/
void handle_ruleset_road(const struct packet_ruleset_road *p)
{
  struct road_type *proad = road_by_number(p->id);

  fc_assert_ret_msg(NULL != proad, "Bad road %d.", p->id);

  sz_strlcpy(proad->graphic_str, p->graphic_str);
  sz_strlcpy(proad->graphic_alt, p->graphic_alt);
  sz_strlcpy(proad->activity_gfx, p->activity_gfx);
  sz_strlcpy(proad->act_gfx_alt, p->act_gfx_alt);

  proad->move_cost = p->move_cost;
  proad->move_mode = p->move_mode;
  proad->build_time = p->build_time;
  proad->defense_bonus = p->defense_bonus;
  proad->pillageable = p->pillageable;

  output_type_iterate(o) {
    proad->tile_incr_const[o] = p->tile_incr_const[o];
    proad->tile_incr[o] = p->tile_incr[o];
    proad->tile_bonus[o] = p->tile_bonus[o];
  } output_type_iterate_end;

  proad->compat = p->compat;

  proad->flags = p->flags;

  PACKET_STRVEC_EXTRACT(proad->helptext, p->helptext);

  tileset_setup_road(tileset, proa**
  Handle a packet about a particular action enabler.**/
void
handle_ruleset_action_enabler(const struct packet_ruleset_action_enabler *p)
{
  struct action_enabler *enabler;
  int i;

  enabler = action_enabler_new();

  enabler->action = p->enabled_action;

  for (i = 0; i < p->actor_reqs_count; i++) {
    requirement_vector_append(&enabler->actor_reqs, p->actor_reqs[i]);
  }
  fc_assert(enabler->actor_reqs.size == p->actor_reqs_count);

  for (i = 0; i < p->target_reqs_count; i++) {
    requirement_vector_append(&enabler->target_reqs, p->target_reqs[i]);
  }
  fc_assert(enabler->target_reqs.size == p->target_reqs_count);

  action_enabler_add(enabler**
  Handle a packet about a particular disaster type.**/
void handle_ruleset_disaster(const struct packet_ruleset_disaster *p)
{
  struct disaster_type *pdis = disaster_by_number(p->id);
  int i;

  fc_assert_ret_msg(NULL != pdis, "Bad disaster %d.", p->id);

  names_set(&pdis->name, p->name, p->rule_name);

  for (i = 0; i < p->reqs_count; i++) {
    requirement_vector_append(&pdis->reqs, p->reqs[i]);
  }
  fc_assert(pdis->reqs.size == p->reqs_count);

  pdis->frequency = p->frequency;

  pdis->effects = p->effects**
  Handle a packet about a particular achievement type.**/
void handle_ruleset_achievement(const struct packet_ruleset_achievement *p)
{
  struct achievement *pach = achievement_by_number(p->id);

  fc_assert_ret_msg(NULL != pach, "Bad achievement %d.", p->id);

  names_set(&pach->name, p->name, p->rule_name);

  pach->type = p->type;
  pach->unique = p->unique;
  pach->value = p->value**
  Handle a packet about a particular trade route type.**/
void handle_ruleset_trade(const struct packet_ruleset_trade *p)
{
  struct trade_route_settings *pset = trade_route_settings_by_type(p->id);

  if (pset != NULL) {
    pset->trade_pct  = p->trade_pct;
    pset->cancelling = p->cancelling;
  }
}

/*******
  Handle the terrain control ruleset packet sent by the server.**/
void handle_ruleset_terrain_control
    (const struct packet_ruleset_terrain_control *p)
{
  /* Since terrain_control is the same as packet_ruleset_terrain_control
   * we can just copy the data directly. */
  terrain_control = *p**
  Handle the list of groups, sent by the ruleset.**/
void handle_ruleset_nation_groups
    (const struct packet_ruleset_nation_groups *packet)
{
  int i;

  for (i = 0; i < packet->ngroups; i++) {
    struct nation_group *pgroup;

    pgroup = nation_group_new(packet->groups[i]);
    fc_assert(NULL != pgroup);
    fc_assert(i == nation_group_index(pgroup));
  }
}

/*******
  Packet ruleset_nation handler.**/
void handle_ruleset_nation(const struct packet_ruleset_nation *packet)
{
  struct nation_type *pnation = nation_by_number(packet->id);
  int i;

  fc_assert_ret_msg(NULL != pnation, "Bad nation %d.", packet->id);

  names_set(&pnation->adjective, packet->adjective, packet->rule_name);
  name_set(&pnation->noun_plural, packet->noun_plural);
  sz_strlcpy(pnation->flag_graphic_str, packet->graphic_str);
  sz_strlcpy(pnation->flag_graphic_alt, packet->graphic_alt);
  pnation->city_style = packet->city_style;
  for (i = 0; i < packet->leader_count; i++) {
    (void) nation_leader_new(pnation, packet->leader_name[i],
                             packet->leader_is_male[i]);
  }

  pnation->is_available = packet->is_available;
  pnation->is_playable = packet->is_playable;
  pnation->barb_type = packet->barbarian_type;

  if ('\0' != packet->legend[0]) {
    pnation->legend = fc_strdup(_(packet->legend));
  } else {
    pnation->legend = fc_strdup("");
  }

  for (i = 0; i < packet->ngroups; i++) {
    struct nation_group *pgroup = nation_group_by_number(packet->groups[i]);

    if (NULL != pgroup) {
      nation_group_list_append(pnation->groups, pgroup);
    } else {
      log_error("handle_ruleset_nation() \"%s\" have unknown group %d.",
                nation_rule_name(pnation), packet->groups[i]);
    }
  }

  pnation->init_government = government_by_number(packet->init_government_id);
  for (i = 0; i < MAX_NUM_TECH_LIST; i++) {
    pnation->init_techs[i] = packet->init_techs[i];
  }
  for (i = 0; i < MAX_NUM_UNIT_LIST; i++) {
    pnation->init_units[i] = utype_by_number(packet->init_units[i]);
  }
  for (i = 0; i < MAX_NUM_BUILDING_LIST; i++) {
    pnation->init_buildings[i] = packet->init_buildings[i];
  }

  tileset_setup_nation_flag(tileset, pnation  Handle city style packet.ruleset_city(const struct packet_ruleset_city *packet)
{
  int id, j;
  struct citystyle *cs;

  id = packet->style_id;
  fc_assert_ret_msg(0 <= id && game.control.styles_count > id,
                    "Bad citystyle %d.", id);
  cs = &city_styles[id];

  for (j = 0; j < packet->reqs_count; j++) {
    requirement_vector_append(&cs->reqs, packet->reqs[j]);
  }
  fc_assert(cs->reqs.size == packet->reqs_count);
  cs->replaced_by = packet->replaced_by;

  names_set(&cs->name, packet->name, packet->rule_name);
  sz_strlcpy(cs->graphic, packet->graphic);
  sz_strlcpy(cs->graphic_alt, packet->graphic_alt);
  sz_strlcpy(cs->oceanic_graphic, packet->oceanic_graphic);
  sz_strlcpy(cs->oceanic_graphic_alt, packet->oceanic_graphic_alt);
  sz_strlcpy(cs->citizens_graphic, packet->citizens_graphic);
  sz_strlcpy(cs->citizens_graphic_alt, packet->citizens_graphic_alt);

  tileset_setup_city_tiles(tileset**
  Packet ruleset_game handler.**/
void handle_ruleset_game(const struct packet_ruleset_game c_assert_ret(packet->veteran_levels > 0);

  game.veteran = veteran_system_new(packet->veteran_levels);
  game.veteran->levels = packet->veteran_levels;

  for (i = 0; i < MAX_NUM_TECH_LIST; i++) {
    game.rgame.global_init_techs[i] = packet->global_init_techs[i];
  }
  for (i = 0; i < MAX_NUM_BUILDING_LIST; i++) {
    game.rgame.global_init_buildings[i] = packet->global_init_buildings[i];
  }

  for (i = 0; i < packet->veteran_levels; i++) {
    veteran_system_definition(game.veteran, i, packet->veteran_name[i],
                              packet->power_fact[i], packet->move_bonus[i],
                              0, 0);
  }

  if (game.plr_bg_color) {
    rgbcolor_destroy(game.plr_bg_color);
  }

  game.plr_bg_color = rgbcolor_new(packet->background_red,
                                   packet->background_green,
                                   packet->background_blue);

  tileset_background_init(tileset**
  Handle info about a single specialist.**/
void handle_ruleset_specialist(const s_set(&s->name, p->plural_name, p->rule_p->reqs[j]);
  }
  fc_assert(s->reqs.size == p->reqs_count);

  PACKET_STRVEC_EXTRACT(s->helptext, p->helptex  Handle reply to our city name request.city_name_suggestion_info(int unit_id, const char *name)
{
  struct unit *punit = player_unit_by_number(client_player()bool other_asking = FALSE;
      unit_list_iterate(unit_tile(punit)->units, other) {
        if (other->client.asking_city_name) {
          other_asking = TRUE;
        }
      } unit_list_iterate_end;
      punit->client.asking_city_name = TRUE;

      if (!other_asking) {
        popup_newcity_dialog(punit, name);
      } name);
    }
  }
}

/*****
  Handle reply to diplomat action requestunit_diplomat_answer(int diplomat_id, int target_id, int cost,
                                 enum diplomat_actions action_type)
{
  struct city *pcity = game_city_by_number(target_id);
  struct unit *punit = game_unit_by_number(target_id);
  struct unit *pdiplomat = player_unit_by_number(client_player(),
                                                  Handle list of potenttial buildings to sabotage.city_by_number(city_id);
  struct unit *pdiplomat = player_unit_by_number(client_player(),
                                                update_improvement_from_packet(pcity, pimprove,
                                     BV_ISSET(improvements,
                                              improvement_index(pimprove)));**
  Pass the header information about things be displayed in a gui-specific
  endgame dialog.**/
void handle_endgame_report(const struct packet_endgame_report *packet)
{
  set_client_state(C_S_OVER);
  endgame_report_dialog_start(packet**
  Pass endgame report about single player.**/
void handle_endgame_player(const struct packet_endgame_player *packet)
{
  endgame_report_dialog_player(packet**
  Packet player_attribute_chunk handler.**/
void handle_player_attribute_chunk
    (const struct packet_player_attribute_chunk *packet)
{
  if (!client_has_player()) {
    return;
  }

  generic_handle_player_attribute_chunk(client_player()  Handle request to start processing packet.  Handle request to stop processing packet.processing_finished(void)
{agents_processing_finished  Notify interested parties about incoming packet.  Notify interested parties about outgoing packet.notify_about_outgoWe have received PACKET_FREEZE_CLIENT.freeze_client(void)
{
  log_debug("handle_freeze_client");

  agents_freeze_hintagents_thaw_hint();
  update_turn_done_button_stReply to 'ping' packet with 'pong'  Handle server shutdown.**
  Add effect data to ruleset cache.**/
void handle_ruleset_effect(const **
  Add effect requirement data to ruleset cache.**/
void handle_ruleset_effect_req
    (const  /*******
  Handle start position creation/removal.**/
void handle_edit_startpos(const struct packet_edit_startpos *packet)
{
  struct tile *ptile = index_to_tile(packet->id);
  bool changed = FALSE;

  /* Check. */
  if (NULL == ptile) {
    log_error("%s(): invalid tile index %d.", __FUNCTION__, packet->id);
    return;
  }

  /* Handle. */
  if (packet->remove) {
    changed = map_startpos_remove(ptile);
  } else {
    if (NULL != map_startpos_get(ptile)) {
      changed = FALSE;
    } else {
      map_startpos_new(ptile);
      changed = TRUE;
    }
  }

  /* Notify. */
  if (changed && can_client_change_view()) {
    refresh_tile_mapcanvas(ptile, TRUE, FALSE);
    if (packet->remove) {
      editgui_notify_object_changed(OBJTYPE_STARTPOS,
                                    packet->id, TRUE);
    } else {
      editgui_notify_object_created(packet->tag, packet->id);
    }
  }
}

/*******
  Handle start position internal information.**/
void handle_edit_startpos_full(const struct packet_edit_startpos_full *
                               packet)
{
  struct tile *ptile = index_to_tile(packet->id);
  struct startpos *psp;

  /* Check. */
  if (NULL == ptile) {
    log_error("%s(): invalid tile index %d.", __FUNCTION__, packet->id);
    return;
  }

  psp = map_startpos_get(ptile);
  if (NULL == psp) {
    log_error("%s(): no start position at (%d, %d)",
              __FUNCTION__, TILE_XY(ptile));
    return;
  }

  /* Handle. */
  if (startpos_unpack(psp, packet) && can_client_change_view()) {
    /* Notify. */
    refresh_tile_mapcanvas(ptile, TRUE, FALSE);
    editgui_notify_object_changed(OBJTYPE_STARTPOS, startpos_number(psp),
                                  FALSE);
  }
}

/**/
void handle_vote_new(const ENDREP
DELTA 9977 891 106
SVN  ˜|˜P …X ƒ ŒZ…X€X …
“C¹fc_ship->structurals = ship->components = ship->modules = 0;
  BV_CLR_ALL(ship->structure);BV_ISSET(ship->structure, i)) num++;
  }
  return num;
}
ENDREP
id: 15r.5ck.r23422/59095
type: file
pred: 15r.5ck.r22861/100491
count: 49
text: 23422 0 28 27272 63194ac6939b28d94c661fa52a7036e6
props: 10806 11936 111 0 227f1557f5d66bc46d32e4db301b2671
cpath: /trunk/common/dataio.c
copyroot: 15280 /trunk

id: 15s.5ck.r23422/59337
type: file
pred: 15s.5ck.r22420/2371
count: 20
text: 23422 2138 793 5604 6533141abca31cfe788730030c00fe7e
props: 10480 9927 110 0 a3ee73c7ed0bd397f9f2fedc7793a5b7
cpath: /trunk/common/dataio.h
copyroot: 15280 /trunk

id: 2f5.5ck.r23422/59579
type: file
pred: 2f5.5ck.r23412/114
count: 454
text: 23422 2960 140 50405 6bc8c34c41806f42238f8117d51cd2c0
props: 11057 30210 112 0 64942f9576ccbd6a94350596bbb7a5cc
cpath: /trunk/common/packets.def
copyroot: 15280 /trunk

id: 98.5ck.r23422/59826
type: file
pred: 98.5ck.r19259/405393
count: 6
text: 23422 58891 178 3152 86b69077755a14b4609b9201096f5f8b
props: 9977 2509 110 0 7d181b70073f10d0c5a58c73a72d4f04
cpath: /trunk/common/spaceship.c
copyroot: 15280 /trunk

id: 99.5ck.r23422/60070
type: file
pred: 99.5ck.r22430/34849
count: 8
text: 23422 59 517 5455 6be93ae15d007eebeec4eb3e9c5befa5
props: 9977 2856 110 0 7d181b70073f10d0c5a58c73a72d4f04
cpath: /trunk/common/spaceship.h
copyroot: 15280 /trunk

PLAIN
K 11
Makefile.am
V 24
file 5h.5ck.r23389/22051
K 14
achievements.c
V 25
file qhc.5ck.r23319/41868
K 14
achievements.h
V 25
file qhe.5ck.r23319/42059
K 9
actions.c
V 25
file r7a.5ck.r23389/21345
K 9
actions.h
V 25
file r7c.5ck.r23389/21533
K 4
ai.c
V 25
file 4go.5ck.r22382/18940
K 4
ai.h
V 24
file 4gp.5ck.r23107/1391
K 6
aicore
V 24
dir 18t.5ck.r23243/11186
K 6
base.c
V 25
file 3jw.5ck.r23271/25324
K 6
base.h
V 24
file 3jx.5ck.r23417/9421
K 9
borders.c
V 26
file 4f0.5ck.r19259/404033
K 9
borders.h
V 25
file 4f1.5ck.r18858/99721
K 8
capstr.c
V 25
file dv.5ck.r19259/401812
K 8
capstr.h
V 24
file dw.5ck.r18858/97074
K 10
citizens.c
V 24
file 6mx.5ck.r20853/5961
K 10
citizens.h
V 24
file 6my.5ck.r20853/6145
K 6
city.c
V 23
file q.5ck.r23215/13257
K 6
city.h
V 24
file 3q.5ck.r22430/33243
K 8
combat.c
V 24
file wp.5ck.r22606/39236
K 8
combat.h
V 23
file wq.5ck.r22453/1203
K 12
connection.c
V 24
file un.5ck.r22421/11281
K 12
connection.h
V 24
file uo.5ck.r22458/34945
K 8
dataio.c
V 25
file 15r.5ck.r23422/59095
K 8
dataio.h
V 25
file 15s.5ck.r23422/59337
K 11
diptreaty.c
V 25
file 3r.5ck.r19259/398261
K 11
diptreaty.h
V 24
file 3s.5ck.r22430/33000
K 10
disaster.c
V 25
file b2m.5ck.r23215/15462
K 10
disaster.h
V 23
file b2o.5ck.r23275/120
K 9
effects.c
V 22
file 2eo.5ck.r23328/76
K 9
effects.h
V 24
file 2ep.5ck.r23320/6753
K 8
events.c
V 23
file 33h.5ck.r23158/480
K 8
events.h
V 22
file 3t.5ck.r23158/718
K 8
extras.c
V 25
file o9u.5ck.r23390/23262
K 8
extras.h
V 24
file o9w.5ck.r23417/9842
K 12
fc_cmdhelp.c
V 24
file 76j.5ck.r20867/6570
K 12
fc_cmdhelp.h
V 25
file 76k.5ck.r20351/18639
K 14
fc_interface.c
V 24
file 4up.5ck.r22631/8528
K 14
fc_interface.h
V 24
file 4uq.5ck.r23325/4181
K 10
fc_types.h
V 25
file 2ll.5ck.r23390/23012
K 15
featured_text.c
V 25
file 4h3.5ck.r20306/26314
K 15
featured_text.h
V 23
file 4h4.5ck.r22302/750
K 6
game.c
V 24
file 3u.5ck.r23230/32578
K 6
game.h
V 23
file 3v.5ck.r23138/9660
K 19
generate_packets.py
V 25
file 2f4.5ck.r23247/23059
K 12
government.c
V 24
file he.5ck.r23215/15895
K 12
government.h
V 24
file hf.5ck.r18858/98787
K 6
idex.c
V 25
file qo.5ck.r19259/406132
K 6
idex.h
V 24
file qp.5ck.r18858/92434
K 13
improvement.c
V 24
file vb.5ck.r23215/12582
K 13
improvement.h
V 23
file vc.5ck.r23278/1858
K 5
map.c
V 23
file r.5ck.r23234/32098
K 5
map.h
V 24
file 41.5ck.r23095/82068
K 8
mapimg.c
V 24
file 6n9.5ck.r22508/1700
K 8
mapimg.h
V 24
file 6na.5ck.r22508/1884
K 15
metaknowledge.c
V 25
file siq.5ck.r23389/21719
K 15
metaknowledge.h
V 25
file sis.5ck.r23389/21885
K 10
movement.c
V 25
file 2xv.5ck.r23243/11426
K 10
movement.h
V 25
file 2xw.5ck.r23095/80226
K 18
name_translation.h
V 25
file 4k1.5ck.r20375/19703
K 8
nation.c
V 24
file il.5ck.r21807/31505
K 8
nation.h
V 24
file im.5ck.r21807/31745
K 9
packets.c
V 23
file 43.5ck.r22883/2547
K 11
packets.def
V 25
file 2f5.5ck.r23422/59579
K 9
packets.h
V 23
file 44.5ck.r22883/2307
K 8
player.c
V 23
file 45.5ck.r23284/2617
K 8
player.h
V 23
file 46.5ck.r23361/5932
K 14
requirements.c
V 25
file 2wq.5ck.r23215/17055
K 14
requirements.h
V 25
file 2wr.5ck.r23215/17308
K 10
research.c
V 22
file 4ro.5ck.r21370/97
K 10
research.h
V 23
file 4rp.5ck.r19352/728
K 10
rgbcolor.c
V 25
file 6i6.5ck.r21333/48710
K 10
rgbcolor.h
V 25
file 6i7.5ck.r21333/48896
K 6
road.c
V 25
file 6pq.5ck.r23390/21666
K 6
road.h
V 24
file 6pr.5ck.r23417/9659
K 10
scriptcore
V 24
dir 75a.5ck.r23348/13797
K 11
spaceship.c
V 24
file 98.5ck.r23422/59826
K 11
spaceship.h
V 24
file 99.5ck.r23422/60070
K 12
specialist.c
V 23
file 33f.5ck.r22372/258
K 12
specialist.h
V 26
file 33g.5ck.r19113/124404
K 6
team.c
V 26
file 33i.5ck.r19259/396899
K 6
team.h
V 25
file 33j.5ck.r18858/94759
K 6
tech.c
V 23
file t.5ck.r23173/61812
K 6
tech.h
V 22
file u.5ck.r23278/2581
K 9
terrain.c
V 25
file 2fp.5ck.r23390/22764
K 9
terrain.h
V 23
file qs.5ck.r23333/5918
K 6
tile.c
V 25
file 2ys.5ck.r23390/22284
K 6
tile.h
V 25
file 2yt.5ck.r23390/22526
K 13
traderoutes.c
V 25
file bf8.5ck.r22228/24352
K 13
traderoutes.h
V 25
file bfa.5ck.r22430/33483
K 8
traits.h
V 24
file 7k3.5ck.r22120/1406
K 6
unit.c
V 23
file v.5ck.r23387/25589
K 6
unit.h
V 24
file 48.5ck.r23387/25826
K 10
unitlist.c
V 25
file 39m.5ck.r21517/87214
K 10
unitlist.h
V 25
file 39n.5ck.r21517/87700
K 10
unittype.c
V 23
file v9.5ck.r22862/2362
K 10
unittype.h
V 23
file va.5ck.r23278/2339
K 9
version.c
V 23
file oe.5ck.r20942/1546
K 9
version.h
V 23
file e7.5ck.r20942/1783
K 9
victory.c
V 24
file qex.5ck.r23119/2099
K 9
victory.h
V 24
file qez.5ck.r23119/2255
K 8
vision.c
V 26
file 4dm.5ck.r19259/404222
K 8
vision.h
V 24
file 4dn.5ck.r21811/9325
K 12
workertask.c
V 24
file llw.5ck.r22482/3617
K 12
workertask.h
V 25
file lly.5ck.r23027/52794
K 10
worklist.c
V 25
file o8.5ck.r19259/402799
K 10
worklist.h
V 24
file o9.5ck.r18858/98299
END
ENDREP
id: p.5ck.r23422/65114
type: dir
pred: p.5ck.r23417/14830
count: 3535
text: 23422 60310 4791 4791 6f4a839d0318d60f1ef6ecc726f88685
props: 12883 2571 96 0 2763e13ff5d021346ae24ff6c9ced232
cpath: /trunk/common
copyroot: 15280 /trunk

id: f2.5gf.r23422/65346
type: file
pred: f2.5gf.r20460/38380
count: 15
text: 23422 17747 533 5308 9c4275539c6f9a8e56ed379e3356d17b
props: 7995 10761 111 0 3d57169d64a739976bce7d2e578e29eb
cpath: /trunk/ai/default/advspace.c
copyroot: 19757 /trunk/ai/default/advspace.c

PLAIN
K 11
Makefile.am
V 25
file 6k4.5ck.r22318/23771
K 14
advdiplomacy.c
V 25
file 2ek.5g9.r22975/46191
K 14
advdiplomacy.h
V 25
file 2el.5ga.r21819/30478
K 13
advdomestic.c
V 24
file 1m.5gb.r21934/64371
K 13
advdomestic.h
V 24
file 1n.5gc.r21819/29385
K 13
advmilitary.c
V 22
file 1u.5gd.r23132/442
K 13
advmilitary.h
V 24
file 1v.5ge.r22026/41566
K 10
advspace.c
V 24
file f2.5gf.r23422/65346
K 10
advspace.h
V 24
file f3.5gg.r20460/40210
K 7
aiair.c
V 25
file 15y.5gh.r21819/31779
K 7
aiair.h
V 25
file 15z.5gi.r21819/33076
K 8
aicity.c
V 24
file 20.5gj.r23320/11933
K 8
aicity.h
V 24
file 21.5gk.r22418/19956
K 8
aidata.c
V 24
file 6mb.5gl.r21899/3740
K 8
aidata.h
V 25
file 6mc.5gm.r21819/32591
K 12
aidiplomat.c
V 23
file 16r.5gn.r23413/378
K 12
aidiplomat.h
V 25
file 16s.5go.r21819/32802
K 9
aiferry.c
V 24
file 2iw.5gp.r23418/1287
K 9
aiferry.h
V 24
file 2ix.5gq.r23014/6151
K 9
aiguard.c
V 25
file 335.5gr.r21830/20422
K 9
aiguard.h
V 25
file 336.5gs.r21830/20693
K 8
aihand.c
V 24
file 22.5gt.r23118/17917
K 8
aihand.h
V 24
file 23.5gu.r21810/35768
K 8
aihunt.c
V 25
file 2gc.5gv.r21830/20961
K 8
aihunt.h
V 25
file 2gd.5gw.r21819/35411
K 7
ailog.c
V 25
file 6p8.5gx.r21830/19728
K 7
ailog.h
V 25
file 6p9.5gy.r21830/19936
K 15
aiparatrooper.c
V 23
file 36o.5gz.r21921/266
K 15
aiparatrooper.h
V 25
file 36p.5h0.r21819/34318
K 10
aiplayer.c
V 25
file 6i3.5h1.r22720/10515
K 10
aiplayer.h
V 25
file 6i4.5h2.r22720/10728
K 11
aisettler.c
V 23
file 2lh.5h3.r23034/327
K 11
aisettler.h
V 25
file 2li.5h4.r22374/17958
K 8
aitech.c
V 22
file 24.5h5.r22002/180
K 8
aitech.h
V 24
file 25.5h6.r21986/17224
K 9
aitools.c
V 22
file 9.5h7.r23107/8099
K 9
aitools.h
V 22
file a.5h8.r23107/8363
K 8
aiunit.c
V 22
file b.5h9.r23107/8625
K 8
aiunit.h
V 22
file c.5ha.r23107/7840
END
ENDREP
id: 6k3.5ck.r23422/67402
type: dir
pred: 6k3.5ck.r23418/3339
count: 147
text: 23422 65616 1773 1773 09c0dd7a7fe4f3fd571ee58684fa3aff
props: 19010 5510 53 0 1aad128f6d028f535e9ce7233326568e
cpath: /trunk/ai/default
copyroot: 15280 /trunk

PLAIN
K 11
Makefile.am
V 24
file 5d.5ck.r22318/25988
K 10
aitraits.c
V 25
file 7k0.5ck.r21420/16178
K 10
aitraits.h
V 25
file 7k2.5ck.r20500/19827
K 7
classic
V 24
dir l53.5ck.r23361/12482
K 7
default
V 24
dir 6k3.5ck.r23422/67402
K 4
stub
V 24
dir 6k5.5ck.r23361/12971
K 8
threaded
V 24
dir 6pi.5ck.r23361/11869
END
ENDREP
id: 8.5ck.r23422/67964
type: dir
pred: 8.5ck.r23418/3898
count: 1554
text: 23422 67640 311 311 a76828d725b2fe42c2b3ef68d29e75a8
props: 11108 11315 64 0 abac628483ea4fdfa3bea3a3a56e0532
cpath: /trunk/ai
copyroot: 15280 /trunk

id: 2lo.5en.r23422/68190
type: file
pred: 2lo.5en.r23417/15061
count: 327
text: 23422 605 22 1112 ec4582e13b9fe681befc0a5a94213db1
props: 17663 394 136 0 3ab197576d3eab59f498bb0d6a363f31
cpath: /trunk/fc_version
copyroot: 17672 /trunk/fc_version

id: 9a.5ck.r23422/68437
type: file
pred: 9a.5ck.r19268/77290
count: 60
text: 23422 654 1358 12829 2b9934481be1fe0a17e2167fba70009b
props: 10956 4203 111 0 e9cbe3af5d5934f88ab895fd46902062
cpath: /trunk/server/spacerace.c
copyroot: 15280 /trunk

id: 4m0.5ck.r23422/68682
type: file
pred: 4m0.5ck.r23398/15556
count: 184
text: 23422 3343 14374 228569 c86caf9f88b2451674e367197415ac8d
cpath: /trunk/server/savegame2.c
copyroot: 15280 /trunk

id: vl.5ck.r23422/68876
type: file
pred: vl.5ck.r23398/15994
count: 623
text: 23422 3128 185 157315 c9bfe5e1f887bd55346f873f5bf7263e
props: 11092 74 112 0 de3988801a325e2d7d51fcbc7209a255
cpath: /trunk/server/savegame.c
copyroot: 15280 /trunk

PLAIN
K 11
Makefile.am
V 24
file 5q.5ck.r23175/39247
K 8
advisors
V 24
dir 4n2.5ck.r23271/35102
K 9
aiiface.c
V 25
file 4gm.5ck.r22318/27020
K 9
aiiface.h
V 24
file 4gn.5ck.r20559/1295
K 6
auth.c
V 25
file 39c.5ck.r20274/32101
K 6
auth.h
V 25
file 39d.5ck.r18977/19170
K 11
barbarian.c
V 24
file lw.5ck.r23022/22959
K 11
barbarian.h
V 24
file lx.5ck.r22667/36940
K 14
citizenshand.c
V 25
file 6mz.5ck.r22267/14643
K 14
citizenshand.h
V 25
file 6n0.5ck.r22267/14833
K 10
cityhand.c
V 24
file 10.5ck.r19573/66885
K 10
cityhand.h
V 23
file 4f.0.r13297/423686
K 11
citytools.c
V 24
file 4g.5ck.r23417/15308
K 11
citytools.h
V 24
file 4h.5ck.r22876/12292
K 10
cityturn.c
V 24
file 4i.5ck.r23215/29012
K 10
cityturn.h
V 24
file 4j.5ck.r22267/13479
K 11
civserver.c
V 24
file 4k.5ck.r22382/30242
K 11
civserver.h
V 21
file 4l.0.r2805/33121
K 10
commands.c
V 25
file 2ly.5ck.r22458/39749
K 10
commands.h
V 24
file 2lz.5ck.r21821/2153
K 13
connecthand.c
V 24
file 2dw.5ck.r22472/4140
K 13
connecthand.h
V 25
file 2dx.5ck.r18942/25217
K 9
console.c
V 22
file dd.5ck.r20765/191
K 9
console.h
V 23
file de.5ck.r19183/7918
K 10
diplhand.c
V 24
file 4m.5ck.r20286/38784
K 10
diplhand.h
V 21
file 4n.0.r13421/6826
K 11
diplomats.c
V 24
file vz.5ck.r23387/36450
K 11
diplomats.h
V 23
file w0.5ck.r19106/3619
K 10
edithand.c
V 23
file 3bk.5ck.r23353/881
K 10
edithand.h
V 26
file 4ez.5ck.r18452/115476
K 6
fcdb.c
V 25
file 6l3.5ck.r22325/28129
K 6
fcdb.h
V 25
file 6l4.5ck.r21255/12759
K 10
gamehand.c
V 24
file 4o.5ck.r23022/23205
K 10
gamehand.h
V 24
file 4p.5ck.r15698/24111
K 9
generator
V 23
dir 2me.5ck.r23376/3486
K 11
ggzserver.c
V 25
file 39a.5ck.r20126/49744
K 11
ggzserver.h
V 23
file 39b.5ck.r20191/350
K 10
handchat.c
V 23
file 4q.5ck.r21364/3610
K 10
handchat.h
V 24
file dj.5ck.r18270/28229
K 9
maphand.c
V 24
file 13.5ck.r23417/15552
K 9
maphand.h
V 24
file 14.5ck.r23417/15796
K 6
meta.c
V 24
file 4s.5ck.r22382/32888
K 6
meta.h
V 24
file 4t.5ck.r18054/19078
K 8
notify.c
V 24
file 4i2.5ck.r22596/6685
K 8
notify.h
V 24
file 4i3.5ck.r18282/3660
K 9
plrhand.c
V 24
file 4u.5ck.r23320/17676
K 9
plrhand.h
V 23
file 4v.5ck.r22645/1117
K 8
report.c
V 21
file vi.5ck.r22618/92
K 8
report.h
V 24
file vj.5ck.r18270/29203
K 10
rssanity.c
V 25
file hew.5ck.r23234/38020
K 10
rssanity.h
V 25
file hey.5ck.r21709/23329
K 9
ruleset.c
V 24
file 8w.5ck.r23398/15070
K 9
ruleset.h
V 24
file 8x.5ck.r23398/15314
K 13
sanitycheck.c
V 24
file wi.5ck.r23153/99825
K 13
sanitycheck.h
V 24
file wj.5ck.r20315/26296
K 12
savecompat.c
V 25
file qva.5ck.r23175/38726
K 12
savecompat.h
V 25
file qvc.5ck.r23175/38888
K 10
savegame.c
V 24
file vl.5ck.r23422/68876
K 10
savegame.h
V 24
file vm.5ck.r20758/19233
K 11
savegame2.c
V 25
file 4m0.5ck.r23422/68682
K 11
savegame2.h
V 25
file 4m1.5ck.r21363/11592
K 7
score.c
V 24
file 2eg.5ck.r21929/5694
K 7
score.h
V 24
file 2eh.5ck.r21929/6179
K 9
scripting
V 24
dir 31x.5ck.r23348/20416
K 8
sernet.c
V 23
file 15.5ck.r22513/3698
K 8
sernet.h
V 24
file 4y.5ck.r19197/31924
K 10
settings.c
V 25
file 2m0.5ck.r23402/10744
K 10
settings.h
V 25
file 2m1.5ck.r23402/10991
K 11
spacerace.c
V 24
file 9a.5ck.r23422/68437
K 11
spacerace.h
V 21
file 9b.0.r11338/1129
K 9
srv_log.c
V 25
file 15t.5el.r22382/32625
K 9
srv_log.h
V 25
file 15u.5em.r20315/26035
K 10
srv_main.c
V 24
file vg.5ck.r23398/14333
K 10
srv_main.h
V 23
file vh.5ck.r22134/1051
K 11
stdinhand.c
V 24
file 4z.5ck.r23398/15748
K 11
stdinhand.h
V 24
file 50.5ck.r22255/10473
K 11
techtools.c
V 25
file 33n.5ck.r23417/16038
K 11
techtools.h
V 25
file 33o.5ck.r21976/23870
K 10
unithand.c
V 24
file 18.5ck.r23387/36698
K 10
unithand.h
V 24
file 19.5ck.r23027/66151
K 11
unittools.c
V 24
file 1a.5ck.r23325/10513
K 11
unittools.h
V 24
file 1b.5ck.r23027/65661
K 8
voting.c
V 24
file 4ex.5ck.r21364/3852
K 8
voting.h
V 25
file 4ey.5ck.r18054/19315
END
ENDREP
id: z.5ck.r23422/72954
type: dir
pred: z.5ck.r23417/20120
count: 5175
text: 23422 69120 3821 3821 dd1cbddce6de7c7f7689f2a10732fd54
props: 17175 659 139 0 d1c9699dde7f9d81e54426750008041d
cpath: /trunk/server
copyroot: 15280 /trunk

id: n.5ck.r23422/73186
type: file
pred: n.5ck.r23390/43903
count: 896
text: 23422 18308 40556 134311 efeae68f214ea2519689d514f3420948
props: 11088 14698 112 0 2c9d3e41a2f20488aa9cdb8d740d094e
cpath: /trunk/client/packhand.c
copyroot: 15280 /trunk

id: z2.5ck.r23422/73434
type: file
pred: z2.5ck.r23312/344988
count: 321
text: 23422 2042 67 125332 39c102d3394294ccdd86d0ab64bb160a
props: 11084 12552 112 0 73ff9df0f3aabd6f615c7264c2fe22c7
cpath: /trunk/client/mapview_common.c
copyroot: 15280 /trunk

PLAIN
K 11
Makefile.am
V 24
file 5f.5ck.r23142/12550
K 6
agents
V 23
dir zf.5ck.r22382/38489
K 11
attribute.c
V 24
file xh.5ck.r22340/22167
K 11
attribute.h
V 24
file xi.5ck.r18863/23649
K 7
audio.c
V 24
file 139.5ck.r22180/7668
K 7
audio.h
V 24
file 13a.5ck.r22180/7911
K 12
audio_none.c
V 26
file 13d.5ck.r19259/462511
K 12
audio_none.h
V 25
file 13e.5ck.r18863/20841
K 11
audio_sdl.c
V 25
file 13f.5ck.r19354/73618
K 11
audio_sdl.h
V 25
file 13g.5ck.r18863/23885
K 17
chatline_common.c
V 26
file 14q.5ck.r19259/494007
K 17
chatline_common.h
V 25
file 14r.5ck.r18863/23155
K 16
citydlg_common.c
V 25
file z4.5ck.r23312/315678
K 16
citydlg_common.h
V 24
file z5.5ck.r18863/18619
K 13
cityrepdata.c
V 22
file mb.5ck.r23375/139
K 13
cityrepdata.h
V 24
file mc.5ck.r18863/19121
K 13
client_main.c
V 24
file 2f.5cp.r23325/14823
K 13
client_main.h
V 24
file hz.5cq.r18863/25358
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.r23027/92426
K 9
climisc.h
V 24
file i0.5ck.r23027/96165
K 8
clinet.c
V 23
file hc.5ck.r22513/7891
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 25
file 33b.5ck.r19135/48891
K 19
connectdlg_common.c
V 23
file 2fw.5ck.r22486/264
K 19
connectdlg_common.h
V 25
file 2fx.5ck.r19154/53802
K 9
control.c
V 24
file gz.5ck.r23216/23799
K 9
control.h
V 24
file i2.5ck.r23111/19739
K 7
dummy.c
V 23
file 4f9.5ck.r15641/551
K 12
dummycxx.cpp
V 23
file 6kr.5ck.r18947/939
K 8
editor.c
V 26
file 3bg.5ck.r23312/350003
K 8
editor.h
V 23
file 3bh.5ck.r23105/702
K 11
ggzclient.c
V 26
file 394.5ck.r20126/104106
K 11
ggzclient.h
V 25
file 395.5ck.r18863/21083
K 17
global_worklist.c
V 26
file 4i6.5ck.r19259/493810
K 17
global_worklist.h
V 25
file 4i7.5ck.r18863/22960
K 6
goto.c
V 24
file vu.5ck.r23205/31201
K 6
goto.h
V 24
file vv.5ck.r23027/81018
K 11
gui-gtk-2.0
V 23
dir zs.5ck.r23421/33294
K 11
gui-gtk-3.0
V 23
dir zs.5g7.r23389/32443
K 6
gui-qt
V 24
dir 6ie.5ck.r23421/42698
K 7
gui-sdl
V 24
dir 16t.5ck.r23421/39176
K 8
gui-sdl2
V 24
dir 16t.5l8.r23421/27862
K 8
gui-stub
V 24
dir mh.5ck.r23312/344552
K 7
gui-xaw
V 22
dir 9o.5ck.r23409/5891
K 14
gui_cbsetter.c
V 26
file a3c.5ck.r23312/344798
K 14
gui_cbsetter.h
V 25
file a3d.5ck.r20753/37736
K 15
gui_interface.c
V 26
file 6jm.5ir.r23312/328430
K 15
gui_interface.h
V 26
file 6jn.5is.r23312/328650
K 10
helpdata.c
V 24
file h1.5ck.r23234/52953
K 10
helpdata.h
V 24
file i3.5ck.r21778/46227
K 7
include
V 24
dir b8.5ck.r23312/328186
K 19
luaconsole_common.c
V 22
file 75z.5ck.r20372/58
K 19
luaconsole_common.h
V 25
file 760.5ck.r20306/31022
K 9
luascript
V 23
dir 761.5ck.r22514/7638
K 16
mapctrl_common.c
V 25
file 15m.5ck.r20865/59741
K 16
mapctrl_common.h
V 25
file 15n.5ck.r19893/12504
K 16
mapview_common.c
V 24
file z2.5ck.r23422/73434
K 16
mapview_common.h
V 25
file z3.5ck.r23312/345243
K 19
messagewin_common.c
V 25
file 14s.5ck.r19354/71979
K 19
messagewin_common.h
V 25
file 14t.5ck.r18863/21579
K 9
options.c
V 23
file dc.5ck.r23155/7759
K 9
options.h
V 23
file i4.5ck.r23155/1631
K 17
overview_common.c
V 26
file 2yk.5ck.r23312/315932
K 17
overview_common.h
V 24
file 2yl.5ck.r19511/5441
K 10
packhand.c
V 23
file n.5ck.r23422/73186
K 10
packhand.h
V 24
file i5.5ck.r18863/20596
K 15
plrdlg_common.c
V 25
file 14u.5ck.r23284/32811
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.r22451/33416
K 9
reqtree.h
V 24
file 2yn.5ck.r19057/3837
K 9
servers.c
V 25
file 33x.5ck.r22325/81040
K 9
servers.h
V 25
file 33y.5ck.r20478/36372
K 6
text.c
V 25
file 2g3.5ck.r23390/43659
K 6
text.h
V 25
file 2g4.5ck.r22264/31375
K 15
themes_common.c
V 25
file 352.5ck.r19354/73121
K 15
themes_common.h
V 25
file 353.5ck.r18863/22710
K 10
tilespec.c
V 24
file hl.5ck.r23390/44147
K 10
tilespec.h
V 24
file i6.5ck.r22962/15940
K 19
unitselect_common.c
V 24
file 76v.5ck.r20397/3580
K 19
unitselect_common.h
V 24
file 76w.5ck.r20397/3746
K 14
update_queue.c
V 25
file 4jw.5ck.r22413/14226
K 14
update_queue.h
V 25
file 4jx.5ck.r18863/22078
K 10
voteinfo.c
V 25
file 4fe.5ck.r19354/72931
K 10
voteinfo.h
V 25
file 4ff.5ck.r18863/22523
END
ENDREP
id: d.5ck.r23422/77977
type: dir
pred: d.5ck.r23421/47227
count: 5735
text: 23422 73687 4277 4277 2dcd0a3d49dac012bf7273975a7c7912
props: 20641 0 184 0 7e44dc5a5223e43acf7a5285ba8bedd0
cpath: /trunk/client
copyroot: 15280 /trunk

PLAIN
K 9
ABOUT-NLS
V 22
file fu.0.r13215/85704
K 7
AUTHORS
V 24
file 5u.5ck.r22143/14016
K 7
COPYING
V 19
file 1h.0.r9643/400
K 9
ChangeLog
V 26
file 6l.5ck.r22811/6091752
K 7
INSTALL
V 21
file 6.5ck.r23337/519
K 11
Makefile.am
V 24
file 59.5ck.r23180/14191
K 4
NEWS
V 24
file 6m.5ck.r23374/75525
K 6
README
V 20
file 7.0.r4421/96382
K 2
ai
V 22
dir 8.5ck.r23422/67964
K 10
autogen.sh
V 24
file 12o.5ck.r22211/1267
K 9
bootstrap
V 22
dir 2p5.5ck.r23391/985
K 6
client
V 22
dir d.5ck.r23422/77977
K 6
common
V 22
dir p.5ck.r23422/65114
K 12
configure.ac
V 24
file 149.5ck.r23356/3366
K 4
data
V 22
dir w.5ck.r23417/30542
K 6
debian
V 22
dir 5w.5ck.r23303/4506
K 12
dependencies
V 23
dir 2yu.5ck.r23272/7188
K 11
diff_ignore
V 24
file qq.5ck.r21039/26581
K 3
doc
V 23
dir k7.5ck.r23387/36222
K 10
fc_version
V 25
file 2lo.5en.r23422/68190
K 2
m4
V 23
dir 12p.5ck.r23356/3140
K 2
po
V 23
dir fs.5ck.r23389/39424
K 7
scripts
V 22
dir 2yo.5ck.r21694/735
K 6
server
V 22
dir z.5ck.r23422/72954
K 5
tests
V 22
dir 2g9.5ck.r22096/825
K 5
tools
V 24
dir 4pj.5js.r23402/10511
K 7
utility
V 22
dir 1c.5ck.r23282/4290
K 3
vms
V 25
dir u9.5ck.r21528/1396085
K 5
win32
V 23
dir 2eu.5ck.r23258/2527
END
ENDREP
id: 3.5ck.r23422/79403
type: dir
pred: 3.5ck.r23421/48652
count: 16631
text: 23422 78207 1183 1183 faa354e37c4b28ca9b30d971a6e6797b
props: 23244 4830 282 0 e4bb46e81629a60eef613b169b23a9ea
cpath: /trunk
copyroot: 15280 /trunk

PLAIN
K 8
branches
V 19
dir 1.0.r23420/6066
K 4
tags
V 20
dir 2.0.r23370/96893
K 5
trunk
V 22
dir 3.5ck.r23422/79403
K 7
website
V 21
dir 3ge.0.r22980/2263
END
ENDREP
id: 0.0.r23422/79797
type: dir
pred: 0.0.r23421/49045
count: 23422
text: 23422 79630 154 154 44b800cd4ab156819c523c48957bb874
cpath: /
copyroot: 0 /

99.5ck.t23421-1 modify true false /trunk/common/spaceship.h

2lo.5en.t23421-1 modify true false /trunk/fc_version

9a.5ck.t23421-1 modify true false /trunk/server/spacerace.c

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

15s.5ck.t23421-1 modify true false /trunk/common/dataio.h

2f5.5ck.t23421-1 modify true false /trunk/common/packets.def

vl.5ck.t23421-1 modify true false /trunk/server/savegame.c

4m0.5ck.t23421-1 modify true false /trunk/server/savegame2.c

f2.5gf.t23421-1 modify true false /trunk/ai/default/advspace.c

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

98.5ck.t23421-1 modify true false /trunk/common/spaceship.c

15r.5ck.t23421-1 modify true false /trunk/common/dataio.c


79797 79947
