DELTA 3369 1112 6271
SVN  „P×$‚f‘/ …8 €‚R G €K D†@€…) MÀ?™ D†@€‚2 MÀ?« D†@€ƒ MÀ?€„. OÉ{€ˆ. MÀ?€ D†@€†3 MÀ?€ D†@€…T MÀ?° D†@€‚U LÀ@€T D†@€| MÀ? ‡€ ‚tˆ¼ ’‹7˜ „0Y¶ D†@€Œ' z¦m€  D†@€J ƒE¨d€ D†@€‚ RÀ?¯ D†@€ RÀ?€G D†@€„ SÀ?· D†@€‚^ TÀ>€ D†@€ƒL ‚$Îb¨ /Ñ€‚ D†@€‰1 hÛ4€` D†@€ˆy ‚_éZ€ƒ PÀ?€  D†@€ƒb QÀ?€/ D†@€‚l SÀ?€ D†@€‘" QÀ?€ D†@€‚o ‚ ‚0 G €O D†@€< SÀ?€ D†@€ƒ
#ifdef HAVE_CONFIG_H
#include <fc_config.h>
#endif

#include <math.h>

/* utility */
#include "bitvector.h"
#include "rand.h"
#include "log.h"

/* common */
#include "base.h"
#include "game.h"
#include "map.h"
#include "movement.h"
#include "packets.h"
#include "unit.h"
#include "unitlist.h"
#include "unittype.h"

#include "combat.h"

*
  Checks if player is restricted diplomatically from attacking the tile.
  Returns FLASE if
  1) the tile is empty or
  2) the tile contains a non-enemy city or
  3) the tile contains a non-enemy unit
***/
bool can_player_attack_tile(const struct player *pplayer,
			    const struct tile *ptile)
{
  struct city *pcity = tile_city(ptile);
  
  /* 1. Is there anyone there at all? */
  if (!pcity && unit_list_size((ptile->units)) == 0) {
    return FALSE;
  }

  /* 2. If there is a city there, can we attack it? */
  if (pcity && !pplayers_at_war(city_owner(pcity), pplayer)) {
    return FALSE;
  }

  /* 3. Are we allowed to attack _all_ units there? */
  unit_list_iterate(ptile->units, aunit) {
    if (!pplayers_at_war(unit_owner(aunit), pplayer)) {
      /* Enemy hiding behind a human/diplomatic shield */
      return FALSE;
    }
  } unit_list_iterate_end;

  return TRUE
  Can unit attack other
***/
static bool is_unit_reachable_by_unit(const struct unit *defender,
                                      const struct unit *attacker)
{
  struct unit_class *dclass = unit_class_get(defender);
  struct unit_type *atype = unit_type_get(attacker);

  return BV_ISSET(atype->targets, uclass_index(dclass))
  Can unit attack other at given location
***/
bool is_unit_reachable_at(const struct unit *defender,
                          const struct unit *attacker,
                          const struct tile *location)
{
  if (NULL != tile_city(location)) {
    return TRUE;
  }

  if (is_unit_reachable_by_unit(defender, attacker)) {
    return TRUE;
  }

  if (tile_has_native_base(location, unit_type_get(defender))) {
    return TRUE;
  }

  return FALSE
  Checks if a unit can physically attack pdefender at the tile
  (assuming it is adjacent and at war).

  Unit can NOT attack if:
  1) it does not have any attack power.
  2) it is not a fighter and defender is a flying unit (except city/airbase).
  3) it is a ground unit without marine ability and it attacks from ocean.
  4) it is a ground unit and it attacks a target on an ocean square.
  5) it is a sailing unit without shore bombardment capability and it
     attempts to attack land.

  Does NOT check:
  1) Moves left
  2) Adjacency
  3) Diplomatic/
enum unit_attack_result unit_attack_unit_at_tile_result(const struct unit *punit,
                                                        const struct unit *pdefender,
                                                        const struct tile *dest_tile)
{
  /* 1. Can we attack _anything_ ? */
  if (!is_military_unit(punit) || !is_attack_unit(punit)) {
    return ATT_NON_ATTACK;
  }

  /* 2. Only fighters can attack planes, except in city or airbase attacks */
  if (!is_unit_reachable_at(pdefender, punit, dest_tile)) {
    return ATT_UNREACHABLE;
  }

  /* 3. Can't attack with ground unit from ocean, except for marines */
  if (!is_native_tile(unit_type_get(punit), unit_tile(punit))
      && !can_attack_from_non_native(unit_type_get(punit))) {
    return ATT_NONNATIVE_SRC;
  }

  /* 4. Most units can not attack non-native terrain.
   *    Most ships can attack land tiles (shore bombardment) */
  if (!is_native_tile(unit_type_get(punit), dest_tile)
      && !can_attack_non_native(unit_type_get(punit))) {
    return ATT_NONNATIVE_DST;
  }

  return ATT_OK
  When unreachable_protects setting is TRUE:
  To attack a stack, unit must be able to attack every unit there (not
  including transported units).
****/
static enum unit_attack_result unit_attack_all_at_tile_result(const struct unit *punit,
                                                              const struct tile *ptile)
{
  unit_list_iterate(ptile->units, aunit) {
    /* HACK: we don't count transported units here.  This prevents some
     * bugs like a submarine carrying a cruise missile being invulnerable
     * to other sea units.  However from a gameplay perspective it's a hack,
     * since players can load and unload their units manually to protect
     * their transporters. */
    if (!unit_transported(aunit)) {
        enum unit_attack_result result;

        result = unit_attack_unit_at_tile_result(punit, aunit, ptile);
        if (result != ATT_OK) {
          return result;
        }
      }
  } unit_list_iterate_end;

  return ATT_OK
  When unreachable_protects setting is FALSE:
  To attack a stack, unit must be able to attack some unit there (not
  including transported units).
****/
static enum unit_attack_result unit_attack_any_at_tile_result(const struct unit *punit,
                                                              const struct tile *ptile)
{
  enum unit_attack_result result = ATT_OK;

  unit_list_iterate(ptile->units, aunit) {
    /* HACK: we don't count transported units here.  This prevents some
     * bugs like a cargoplane carrying a land unit being vulnerable. */
    if (!unit_transported(aunit)) {
      result = unit_attack_unit_at_tile_result(punit, aunit, ptile);
      if (result == ATT_OK) {
        return result;
      }
    }
  } unit_list_iterate_end;

  /* That's result from check against last unit on tile, not first.
   * Shouldn't matter. */
  return result
  Check if unit can attack unit stack at tile.
***/
enum unit_attack_result unit_attack_units_at_tile_result(const struct unit *punit,
                                                         const struct tile *ptile)
{
  if (game.info.unreachable_protects) {
    return unit_attack_all_at_tile_result(punit, ptile);
  } else {
    return unit_attack_any_at_tile_result(punit, ptile);
  }
  Is unit (1) diplomatically allowed to attack and (2) physically able
  to do so?
***/
bool can_unit_attack_tile(const struct unit *punit,
                          const struct tile *dest_tile)
{
  return (can_player_attack_tile(unit_owner(punit), dest_tile)
          && unit_attack_units_at_tile_result(punit, dest_tile) == ATT_OK)NOTE: this number can be _very_ small, fx in a battle between an
ironclad and a battleship the ironclad has less than 1/100000 chance of
winning.(ahp + dfp - 1) / dfp;
  int def_N_lose = (dhp + afp - 1) / (double)(def_N_lose - 1)A unit's effective firepower depend on the situation.
******/
void get_modified_firepower(const struct unit *attacker,
			    const struct unit *defender,
			    int *att_fp, int *def_fp)
{
  struct city *pcity = tile_city(unit_tile(defender));

  *att_fp = unit_type_get(attacker)->firepower;
  *def_fp = unit_type_get(defender)->firepower;

  /* Check CityBuster flag */
  if (unit_has_type_flag(attacker, UTYF_CITYBUSTER) && pcity) {
    *att_fp *= 2;
  }

  /*
   * UTYF_BADWALLATTACKER sets the firepower of the attacking unit to 1 if
   * an EFT_DEFEND_BONUS applies (such as a land unit attacking a city with
   * city walls).
   */
  if (unit_has_type_flag(attacker, UTYF_BADWALLATTACKER)
      && get_unittype_bonus(unit_owner(defender), unit_tile(defender),
                            unit_type_get(attacker), EFT_DEFEND_BONUS) > 0) {
    *att_fp = 1;
  }

  /* pearl harbour - defender's firepower is reduced to one, 
   *                 attacker's is multiplied by two         */
  if (unit_has_type_flag(defender, UTYF_BADCITYDEFENDER)
      && tile_city(unit_tile(defender))) {
    *att_fp *= 2;
    *def_fp = 1;
  }
  
  /* 
   * When attacked by fighters, helicopters have their firepower
   * reduced to 1.
   */
  if (combat_bonus_against(unit_type_get(attacker)->bonuses,
                           unit_type_get(defender),
                           CBONUS_FIREPOWER1)) {
    *def_fp = 1;
  }

  /* In land bombardment both units have their firepower reduced to 1 */
  if (!is_native_tile(unit_type_get(attacker), unit_tile(defender))
      && !can_exist_at_tile(unit_type_get(defender), unit_tile(attacker)Returns a double in the range [0;1] indicating the attackers chance of
winning. The calculation takes all factors into account.
******/
double unit_win_chance(const struct unit *attacker,
		       constTry defending against nuclear attack, if succed return a city which 
  had enough luck and EFT_NUKE_PROOF.
  If the attack was succesful return NULL.
******/
struct city *sdi_try_defend(const struct player *owner,
			       const struct tile *ptile)
{
  square_iterate(ptile, 2, ptile1) {
    struct city *pcity = tile_city(ptile1);

    if (pcity
        && !pplayers_allied(city_owner(pcity), owner)
        && fc_rand(100) < get_city_bonus(pcity, EFT_NUKE_PROOF)) {
      return pcity;
    }
  } square_iterate_end;

  return NULLConvenience wrapper for base_get_attack_power.
******/
int get_attack_power(const struct unit *punit)
{
  return base_get_attack_power(unit_type_get(punit), punit->veteran,
			       punit->moves_left)Returns the attack power, modified by moves left, and veteran
 status.
******/
int base_get_attack_power(const struct unit_type *punittype,
                          int veteran, int moves_left)
{
  int power;
  const struct veteran_level *vlevel;

  fc_assert_ret_val(punittype != NULL, 0);

  vlevel = utype_veteran_level(punittype, veteran);
  fc_assert_ret_val(vlevel != NULL, 0);

  power = punittype->attack_strength * POWER_FACTOR
          * vlevel->power_fact / 100;

  if (game.info.tired_attack && moves_left < SINGLE_MOVE) {
    power = (power * moves_left) / SINGLE_MOVE;
  }

  return powerReturns the defense power, modified by veteran status.
******/
int base_get_defense_power(const struct unit *punit)
{
  const struct veteran_level *vlevel;

  fc_assert_ret_val(punit != NULL, 0);

  vlevel = utype_veteran_level(unit_type_get(punit), punit->veteran);
  fc_assert_ret_val(vlevel != NULL, 0);

  return unit_type_get(punit)->defense_strength * POWER_FACTOR
         * vlevel->power_fact / 10Returns the defense power, modified by terrain and veteran status.
  Note that rivers as special road types are not handled here as
  terrain property.
******/
static int get_defense_power(const struct unit *punit)
{
  int db, power = base_get_defense_power(punit);
  struct tile *ptile = unit_tile(punit);
  struct unit_class *pclass = unit_class_get(punit);

  if (uclass_has_flag(pclass, UCF_TERRAIN_DEFENSE)) {
    db = 10 + tile_terrain(ptile)->defense_bonus / 10;
    power = (power * db) / 10;
  }

  if (!is_native_tile_to_class(pclass, ptile)) {
    power = power * pclass->non_native_def_pct / 100;
  }const struct unit *attacker,
			   const
 Return an increased defensepower. Effects which increase the
 defensepower are:
  - unit type effects (horse vs pikemen for example)
  - defender in a fortress
  - fortified defender

May be called with a non-existing att_type to avoid any unit type
effects.
******/
static int defense_multiplication(const struct unit_type *att_type,
				  const struct unit_type *def_type,
				  const struct player *def_player,
				  const struct tile *ptile,
				  int defensepower, bool fortified)
{
  struct city *pcity = tile_city(ptile);
  int mod;

  fc_assert_ret_val(NULL != def_type, 0);

  if (NULL != att_type) {
    int defense_divider;
    int defense_multiplier = 1 + def_type->cache.defense_mp_bonuses[utype_index(att_type)];

    defensepower *= defense_multiplier;

    /* This applies even if pcity is NULL. */
    mod = 100 + get_unittype_bonus(def_player, ptile,
                                   att_type, EFT_DEFEND_BONUS);
    defensepower = MAX(0, defensepower * mod / 100);

    defense_divider = 1 + combat_bonus_against(att_type->bonuses, def_type,
                                               CBONUS_DEFENSE_DIVIDER);
    defensepower /= defense_divider;
  }

  defensepower +=
    defensepower * tile_extras_defense_bonus(ptile, def_type) / 100;

  if ((pcity || fortified)
      && uclass_has_flag(utype_class(def_type), UCF_CAN_FORTIFY)
      && !utype_has_flag(def_type, UTYF_CANT_FORTIFY)) {
    defensepower = (defensepower * 3) / 2;
  } May be called with a non-existing att_type to avoid any effects which
 depend on the attacker.
******/
int get_virtual_defense_power(const struct unit_type *att_type,
			      const struct unit_type *def_type,
			      const struct player *def_player,
			      const struct tile *ptile,
			      bool fortified, int veteran)
{
  int defensepower = def_type->defense_strength;
  int db;
  const struct veteran_level *vlevel;
  struct unit_class *defclass;

  fc_assert_ret_val(def_type != NULL, 0);

  if (!can_exist_at_tile(def_type, ptile)) {
    /* Ground units on ship doesn't defend. */
    return 0;
  }

  vlevel = utype_veteran_level(def_type, veteran);
  fc_assert_ret_val(vlevel != NULL, 0);

  defclass = utype_class(def_type);

  db = POWER_FACTOR;
  if (uclass_has_flag(defclass, UCF_TERRAIN_DEFENSE)) {
    db += tile_terrain(ptile)->defense_bonus / (100 / POWER_FACTOR);
  }
  defensepower *= db;
  defensepower *= vlevel->power_fact / 100;
  if (!is_native_tile_to_class(defclass, ptile)) {
    defensepower = defensepower * defclass->non_native_def_pct / 100;
  }

  return defense_multiplication(att_type, def_type, def_player,
                                ptile, defensepower,
                                fortified)const struct unit *attacker,
			    const struct unit *defender)
{
  return defense_multiplication(unit_type_get(attacker),
                                unit_type_get(defender),
                                unit_owner(defender), unit_tile(defender),
                                get_defense_power(defender),
                                defender->activity == ACTIVITY_FORTIFIED)*
  Return total defense power of the unit if it fortifies, if possible,
  where it is. attacker might be NULL to skip calculating attacker specific
  bonuses.
*******/
int get_fortified_defense_power(const struct unit *attacker,
                                const struct unit *defender)
{
  struct unit_type *att_type = NULL;

  if (attacker != NULL) {
    att_type = unit_type_get(attacker);
  }

  return defense_multiplication(att_type, unit_type_get(defender),
                                unit_owner(defender), unit_tile(defender),
                                get_defense_power(defender),
                                TRUE)A number indicating the defense strength.
Unlike the one got from win chance this doesn't potentially get insanely
small if the units are unevenly matched, unlike win_chance.
******/
static int get_defense_rating(const struct unit *attacker,
			      const struct unit *defender)
{
  int afp, dfp;

  int rating = get_total_defense_power(attacker, defender);
  get_modified_firepower(attacker, defender, &afp, &dfp);

  /* How many rounds the defender will last */
  rating *= (defender->hp + afp-1)/afp;

  rating *= dfp;

  return ratingFinds the best defender on the tile, given an attacker.  The diplomatic
  relationship of attacker and defender is ignored; the caller should check
  this.
******/
struct unit *get_defender(const struct unit *attacker,
			  const struct tile *ptile)
{
  struct unit *bestdef = NULL;
  int bestvalue = -99, best_cost = 0, rating_of_best = 0;

  /* Simply call win_chance with all the possible defenders in turn, and
   * take the best one.  It currently uses build cost as a tiebreaker in
   * case 2 units are identical, but this is crude as build cost does not
   * neccesarily have anything to do with the value of a unit.  This function
   * could be improved to take the value of the unit into account.  It would
   * also be nice if the function was a bit more fuzzy about prioritizing,
   * making it able to fx choose a 1a/9d unit over a 10a/10d unit. It should
   * also be able to spare units without full hp's to some extent, as these
   * could be more valuable later. */
  unit_list_iterate(ptile->units, defender) {
    /* We used to skip over allied units, but the logic for that is
     * complicated and is now handled elsewhere. */
    if (unit_can_defend_here(defender)
        && unit_attack_unit_at_tile_result(attacker, defender, ptile) == ATT_OK) {
      bool change = FALSE;
      int build_cost = unit_build_shield_cost(defender);
      int defense_rating = get_defense_rating(attacker, defender);
      /* This will make units roughly evenly good defenders look alike. */
      int unit_def 
        = (int) (100000 * (1 - unit_win_chance(attacker, defender)));

      fc_assert_action(0 <= unit_def, continue);

      if (unit_has_type_flag(defender, UTYF_GAMELOSS)
          && !is_stack_vulnerable(unit_tile(defender))) {
        unit_def = -1; /* then always use leader as last defender. */
        /* FIXME: multiple gameloss units with varying defense value
         * not handled. */
      }

      if (unit_def > bestvalue) {
	change = TRUE;
      } else if (unit_def == bestvalue) {
	if (build_cost < best_cost) {
	  change = TRUE;
	} else if (build_cost == best_cost) {
	  if (rating_of_best < defense_rating) {	
	    change = TRUE;
	  }
	}
      }

      if (change) {
	bestvalue = unit_def;
	bestdef = defender;
	best_cost = build_cost;
	rating_of_best = defense_rating;
      }
    }
  } unit_list_iterate_end;

  return bestdefget unit at (x, y) that wants to kill defender.

Works like get_defender; see comment there.
This function is mostly used by the AI.
******/
struct unit *get_attacker(const struct unit *defender,
			  const struct tile *ptile)
{
  struct unit *bestatt = 0;
  int bestvalue = -1, unit_a, best_cost = 0;

  unit_list_iterate(ptile->units, attacker) {
    int build_cost = unit_build_shield_cost(attacker);

    if (pplayers_allied(unit_owner(defender), unit_owner(attacker))) {
      return NULL;
    }
****
  Is it a city/fortress/air base or will the whole stack die in an attack
******/
bool is_stack_vulnerable(const struct tile *ptile)
{
  return (game.info.killstack
          && !tile_has_base_flag(ptile, BF_NO_STACK_DEATH)
          && NULL == tile_city(ptile))Get bonus value against given unit type from bonus list.

  Consider using cached values instead of calling this recalculation
  directly.
******/
int combat_bonus_against(const struct combat_bonus_list *list,
                         const struct unit_type *enemy,
                         enum combat_bonus_type type)
{
  int value = 0;

  combat_bonus_list_iterate(list, pbonus) {
    if (pbonus->type == type && utype_has_flag(enemy, pbonus->flag)) {
      value += pbonus->value;
    }
  } combat_bonus_list_iterate_end;

  return value;
}
ENDREP
DELTA 30317 62089 95
SVN  ÜOß‚7 –_ €‚ ¾7–Z± ‡AÕstruct {
    int max_defense_mp; /* Value 0 here does not guarantee that unit never
                         * has CBONUS_DEFENSE_MULTIPLIER, it merely means
                         * that there's no POSITIVE one */
    int defense_mp_bonuses[U_LAST];
  } cachevoid set_unit_type_caches(struct unit_type *ptypeENDREP
DELTA 30647 0 308
SVN  ƒÅKƒÁ@"„, †)  r†I€„ ¨Ž{ª L¸i ‚‹º4heck defender type
       * specific bonuses. */

      /* Skip defenders that have no bonuses at all. Acceptable
       * side-effect is that we can't consider negative bonuses at
       * all ("No bonuses" should be better than "negative bonus") */
      if (def->cache.max_defense_mp > 0) {
        unit_type_iterate(utype) {
          int idx = utype_index(utype);

          if (def->cache.defense_mp_bonuses[idx] > defense_bonuses[idx]) {
            defense_bonuses[idx] = def->cache.defense_mp_bonuses[idx]maxbonus = punittype->cache.max_defense_mpENDREP
DELTA 30696 52 73
SVN  †  †    †   †  ƒ‹lƒŒ ” € ‚÷”jptype) {
    ptype->unknown_move_cost = utype_unknown_move_cost(ptype);
    set_unit_type_caches(ptype);
    unit_type_action_cache_set(ptypeENDREP
DELTA 28819 62268 29453
SVN  ƒñ„œ.‚­ ‡c † –7‡U„ ˜!ž„ †¶-„ ƒ¼5„ Œ¿; *Ì"” Ž6Ü^‰ ƒ8ëŠ q†#€‚ –KñX€ ‰ˆ=€ƒ ‚1‘T€ƒ ”€G Pº €P N  €ƒa S¦  ˜•\€‚j bÞx€ŒE …%­„ ‰?²5„ „X»t„ …ÀL„ ‚oÅd„ …EÈS„ Ž Î„ ´6Ü€I N  €„| ˆ%‚}€, ŠJ‚˜€ ï9‚¥-€C „Qƒ•!š †*ƒ™g€ Œyƒ   §iƒ­ž L  €ƒx m›k ”}ƒÕ® †ƒêdcombat_get_get_get_getutype_may_act_at_allAND_FAKES  int uidxits unit state is. */
  action_iterate(action_id) {
    BV_CLR_ALL(ustate_act_cache[uidx][action_id]);
  } action_iterate_end;
  BV_CLR_ALL(ustate_act_cache[uidx][ACTION_ANY]);
  BV_CLR_ALL(ustate_act_cache[uidx][ACTION_HOSTILE]);

  if (!utype_may_act_at_all  BV_CLR_ALL(dipl_rel_action_cache[putype_id][ACTION_ANY]);
  BV_CLR_ALL(dipl_rel_action_cache[putype_id][ACTION_HOSTILE]);

  if (!utype_may_act_at_alldiplrel,
                                          REQ_RANGE_LOCAL, TRUE));
          BV_SET(dipl_rel_action_cache[putype_id][ACTION_HOSTILE],
                 requirement_diplrel_ereq(req.source.value.diplrel,
                                          REQ_RANGE_LOCAL, TRUE));
          BV_SET(dipl_rel_action_cache[putype_id][ACTION_ANY],
                 requirement_diplrel_ereq(req.source.value.diplreldiplrel,
                                       REQ_RANGE_LOCAL, FALSE));
          BV_SET(dipl_rel_action_cache[putype_id][ACTION_HOSTILE],
              requirement_diplrel_ereq(req.source.value.diplrel,
                                       REQ_RANGE_LOCAL, FALSE));
          BV_SET(dipl_rel_action_cache[putype_id][ACTION_ANY],
              requirement_diplrel_ereq(req.source.value.diplrelstruct range {
  int min;
  int max;
};

#define MOVES_LEFT_INFINITY -1Get the legal range of move fragments left of the specified requirement
  vectorstatic struct range *moves_left_range(struct requirement_vector *reqs)
{
  struct range *prange = fc_malloc(sizeof(prange));

  prange->min = 0;
  prange->max = MOVES_LEFT_INFINITY;

  requirement_vector_iterate(reqs, preq) {
    if (preq->source.kind == VUT_MINMOVES) {
      if (preq->present) {
        prange->min = preq->source.value.minmoves;
      } else {
        prange->max = preq->source.value.minmoves;
      }
    }
  } requirement_vector_iterate_end;

  return prange
  Return TRUE iff the given (action enabler controlled) action may be
  performed by a unit of the given type that has the given number of move
  fragments left.

  Note: Values aren't cached. If a performance critical user appears it
  would be a good idea to cache the (merged) ranges of move fragments
  where a unit of the given type can perform the specifimay_act_move_frags(struct unit_type *punit_type,
                              const int action_id,
                              const int move_fragments)
{
  struct range *ml_range;

  fc_assert(action_id_is_valid(action_id) || action_id == ACTION_ANY);

  if (!utype_may_act_at_all(punit_type)) {
    /* Not an actor unit. */
    return FALSE;
  }

  if (action_id == ACTION_ANY) {
    /* Any action is OK. */
    action_iterate(alt_act) {
      if (utype_may_act_move_frags(punit_type, alt_act,
                                   move_fragments)) {
        /* It only has to be true for one action. */
        return TRUE;
      }
    } action_iterate_end;

    /* No action enabled. */
    return FALSE;
  }

  if (action_get_actor_kind(action_id) != AAK_UNIT) {
    /* This action isn't performed by any unit at all so this unit type
     * can't do it. */
    return FALSE;
  }

  action_enabler_list_iterate(action_enablers_for_action(action_id),
                              enabler) {
    if (!requirement_fulfilled_by_unit_type(punit_type,
                                            &(enabler->actor_reqs))) {
      /* This action enabler isn't for this unit type at all. */
      continue;
    }

    ml_range = moves_left_range(&(enabler->actor_reqs));
    if (ml_range->min <= move_fragments
        && (ml_range->max == MOVES_LEFT_INFINITY
            || ml_range->max > move_fragments)) {
      /* The number of move fragments is in range of the action enabler. */

      free(ml_range);

      return TRUE;
    }

    free(ml_range);
  } action_enabler_list_iterate_end;

  return FALSE_get_get_get_get_get_get_get  Returns TRUE iff the unit type is unique and the player already has onebool utype_player_already_has_this_unique(const struct player *pplayer,
                                          const struct unit_type *putype)
{
  if (!utype_has_flag(putype, UTYF_UNIQUE)) {
    /* This isn't a unique unit type. */
    return FALSE;
  }

  unit_list_iterate(pplayer->units, existing_unit) {
    if (putype == unit_type_get(existing_unit)) {
      /* FIXME: This could be slow if we have lots of units. We could
       * consider keeping an array of unittypes updated with this info
       * instead. */

      return TRUE;
    }
  } unit_list_iterate_end;

  /* The player doesn't already have one. */
  return FALSEutype_has_flag(punittype, UTYF_NEWCITY_GAMES_ONLY)
      && game.scenario.prevent_new_cities) {
    /* Unit is usable only in games where founding of new cities is allowed.}

  if (utype_player_already_has_this_unique(p, punittype)) {
    /* A player can only have one unit of each unique unit type. */
    return FALSE_get(const struct unit *punit)
{
  return utype_class(unit_type_get  unit_classes[i].helptext  if (unit_classes[i].helptext != NULL) {
      strvec_destroy(unit_classes[i].helptext);
      unit_classes[i].helptext = NULL
    return name_translation_get**
  Set caches for unit types**/
void set_unit_type_caches(struct unit_type *ptype)
{
  ptype->cache.max_defense_mp = -FC_INFINITY;

  unit_type_iterate(utype) {
    int idx = utype_index(utype);

    ptype->cache.defense_mp_bonuses[idx] = combat_bonus_against(ptype->bonuses, utype,
                                                                CBONUS_DEFENSE_MULTIPLIER);
    if (ptype->cache.defense_mp_bonuses[idx] > ptype->cache.max_defense_mp) {
      ptype->cache.max_defense_mp = ptype->cache.defense_mp_bonuses[idx];
    }if (is_native_to_class(puclass, pterrain, NULLENDREP
DELTA 27757 0 181226
SVN  †  †  ZŒS ›I £ Çr›?€F lä† Ž=æ€M ^ò5… [ð:„  ó{„ ‚$ôx… C÷… ø_Œ N„ü@€Z ‚g…l€L c‚…+’ Ô"‚ˆ  ‚ÜQ‚ …v‚ÝP… ‚ãF… ÄV‚ä_· Ä@ƒ©+€q ÔvƒïH„ ]„Ä>„ ‚„Å„ …g„Ç2€e ‚„Íxƒ  G„Ð ‹L„ðV… „ü"€ƒQ ÓI„ý* †0…Ðs½ Ÿg…×\€O —D…÷{ „†?struct requirement_vector reqs_list
  filename = secfile_name(file);

  requirement_vector_reserve(&reqs_, quie    quiet = FALSE;
    if ((pentry = secfile_entry_lookup(file, "%s.%s%d.quiequietquiequiereqs_reqs_bonus->quiet             "%s.%s%d.quiet",
                                               sec, sub, j);  out[tr].fixed = secfile_lookup_int_default(file, -1, "%s.%s%s_default",
    field_prefix,
  pci = uclass_index(punitclass);
pcutypeutypeuc->helptext = lookup_strvec(file, sec_name, "helptext"reachable) {
        if (!uclass_has_flag(preachable, UCF_UNREACHABLE)) {
          BV_SET(u->targets, uclass_index(preachable));
          BV_SET(u->embarks, uclass_index(preachable));
          BV_SET(u->disembarks, uclass_index(preachableterrterrterrresi = resource_index(presource);
      const char *sec_name = section_name(section_list_get(sec, resresconst char *textgame.text = secfile_lookup_str_default(file,
                                    N_("?gui_type:Build Type A Base"),
                                    "extraui.ui_name_base_fortress");
  sz_strlcpy(terrain_control.gui_type_base0, text);

  text = secfile_lookup_str_default(file,
                                    N_("?gui_type:Build Type B Base"),
                                    "extraui.ui_name_base_airbase");
  sz_strlcpy(terrain_control.gui_type_base1, textccj = 0; cj < nval; cj++) {
        const char *sval = slist[c
        if (extra_has_flag(pextra, EF_NATURAL_DEFENSE)) {
          extra_to_caused_by_list(pextra, EC_NATURAL_DEFENSIVE);
        } else {
          extra_to_caused_by_list(pextra, EC_DEFENSIVE);
        }b†  †  †  ƒtç2€‡2 ZŸx” l…º.€ƒ1 ¤< º Œ¤; x°a€q ‚²6˜ ™´P€P p…z€D p…z€‚[ p…z€ƒ- p…z€… W…Ä)€ƒt † Ö€…U ­cÝ, @à\ ‚Vâ' bè, ‚9‹ƒ œhH€ ‰ªi€ „0´+€ ˆw¹ ‚Ã$€ƒa ƒ]Å.€‚ ‚È\€Šp •
Ít¢ ‡'ä&˜ ¬!ëK  ‚—c¬ ‚˜c€„  –'‚™o€\ ƒ<‚°a€W †L‚´f€U –:‚»}€u ƒ‚ÓF€‚ ƒ{‚Ø3 ‚Ý  ¥o‚Þ#ƒ ƒ„ƒ ƒ…ƒ „lƒ†)ƒ „-ƒ‹ ‚í<   ƒB „$ƒ¯a †*ƒ³x€ƒm ’nƒ¾[… ƒpƒÑI€„4 ]ƒÙ>€‚: ]ƒÜ:€ rƒÞ$€] `ƒßd€ˆ. °ƒã#€ƒK ¬H„–{€‚ F„Õ< ¦„Ã‰ …}„ê! ˆd„ñ_© h„¯>Ÿ I„õy€* ˜8„ú9‚ ƒ…’r€ ‰…—€‚5 •…¢? e…·@ ‚$…¸% .…ºI€d `‚ö~€E  break;
      }

      pbase->border_sq  = secfile_lookup_int_default(file, -1, "%s.border_sq",
                                                     section);
      pbase->vision_main_sq   = secfile_lookup_int_default(file, -1,
                                                           "%s.vision_main_sq",
                                                           section);
      pbase->vision_invis_sq  = secfile_lookup_int_default(file, -1,
                                                           "%s.vision_invis_sq",
                                                           section);

      slist = secfile_lookup_str_vec(file, &nval, "%s.flags", section);
      BV_CLR_ALL(pbase->flags);
      for (bj = 0; bj < nval; bj++) {
        const char *sval = slist[bj];
        enum base_flag_id flag = base_flag_id_by_name(sval, fc_strcasecmp);

        if (!base_flag_id_is_valid(flag)) {
          ruleset_error(LOG_ERROR, "\"%s\" basebase_rule_name(pbasebase->flags, flag);
        }
      }

      free(slist);

      if (!ok) {
        break;
      }

      if (territory_claiming_base(pbase)) {
        base_type_iterate(pbase2) {
          if (pbase == pbase2) {
            /* End of the fully initialized bases iteration. */
            break;
          }
          if (territory_claiming_base(pbase2)) {
            struct extra_type *pextra2 = base_extra_get(pbase2);

           Also load multiplier names/count from governments.rulesetNUM_MULTIPLIERSNUM_MULTIPLIERS);

      ok = FALSE;
    } else {
      game.control.num_multipliers = nval;
    }

    if (ok) {
                       multipliers_iterate(pmul) {
      int id = multiplier_index(pmul);
      const char *sec_name = section_name(section_list_get(sec, id));

      if (!secfile_lookup_int(file, &pmul->start, "%s.start", sec_name      if (!secfile_lookup_int(file, &pmul->stop, "%s.stop", sec_name      if (pmul->stop <= pmul->start) {
        ruleset_error(LOG_ERROR, "Multiplier \"%s\" stop (%d) must be greater "
                      "than start (%d)", multiplier_rule_name(pmul),
                      pmul->stop, pmul->start);
        ok = FALSE;
        break;
      }
      if (!secfile_lookup_int(file, &pmul->step, "%s.step", sec_name      if (((pmul->stop - pmul->start) % pmul->step) != 0) {
        ruleset_error(LOG_ERROR, "Multiplier \"%s\" step (%d) does not fit "
                      "exactly into interval start-stop (%d to %d)",
                      multiplier_rule_name(pmul), pmul->step,
                      pmul->start, pmul->stop);
        ok = FALSE;
        break;
      }
      if (!secfile_lookup_int(file, &pmul->def, "%s.default", sec_name      if (pmul->def < pmul->start || pmul->def > pmul->stop) {
        ruleset_error(LOG_ERROR, "Multiplier \"%s\" default (%d) not within "
                      "legal range (%d to %d)", multiplier_rule_name(pmul),
                      pmul->def, pmul->start, pmul->stop);
        ok = FALSE;
        break;
      }
      if (((pmul->def - pmul->start) % pmul->step) != 0) {
        ruleset_error(LOG_ERROR, "Multiplier \"%s\" default (%d) not legal "
                      "with respect to step size %d",
                      multiplier_rule_name(pmul), pmul->def, pmul->step);
        ok = FALSE;
        break;
      }
      pmul->offset"%s.offset", sec_name);
      pmul->factor = secfile_lookup_int_default(file, 100,
                                                "%s.factor", sec_name);
      if (pmul->factor == 0) {
        ruleset_error(LOG_ERROR, "Multiplier \"%s\" scaling factor must "
                      "not be zero", multiplier_rule_name(pmul));
        ok = FALSE;
        break;
      }

      pmul->helptext = lookup_strvec(file, sec_name, "helptext");   
    } multipliers_iterate_end;
    section_list_destroy(sec);int desc_left = game.control.desc_length;
  int index = 0;

  lsend_packet_ruleset_control(dest, &(game.control));

  if (game.ruleset_summary != NULL) {
    struct packet_ruleset_summary summary;

    strncpy(summary.text, game.ruleset_summary, MAX_LEN_CONTENT);

    lsend_packet_ruleset_summary(dest, &summary);
  }

  while (desc_left > 0) {
    struct packet_ruleset_description_part part;
    int this_len = desc_left;

    if (this_len > MAX_LEN_CONTENT - 21) {
      this_len = MAX_LEN_CONTENT - 1;
    }

    part.text[this_len] = '\0';

    strncpy(part.text, &game.ruleset_description[index], this_len);
    index += this_len;
    desc_left -= this_len;

    lsend_packet_ruleset_description_part(dest, &part);
  }const char *name  
game.server.ruledit.allowed_terrains != NULL
              && !is_on_allowed_list(p,
                                     game.server.ruledit.!= NULL && game.server.ruledit.allowed_terrains != NULL) {
            if (!is_on_allowed_list(p,
                                    game.server.ruledit.game.server.ruledit.allowed_terrains == NULL
                || !is_on_allowed_list(p,
                                       game.server.ruledit.  vec  = secfile_lookup_str_vec(file, &game.server.ruledit.embedded_nations_count,
                                "ruledit.embedded_nations");

  if (vec != NULL) {
    /* Copy to persistent vector */
    game.server.ruledit.embedded_nations
      = fc_malloc(game.server.ruledit.embedded_nations_count * sizeof(char *));

    for (j = 0; j < game.server.ruledit.embedded_nations_count; j++) {
      game.server.ruledit.embedded_nations[j] = fc_strdup(vec[j]);
    }

    free(vecfixed < 0) {
      int diff = game.server.default_traits[tr].max - game.server.default_traits[tr].min;

      /* TODO: Should sometimes round the a / 2 = x.5 results up */
      game.server.default_traits[tr].fixed = diff / 2 + game.server.default_traits[tr].minvec = secfile_lookup_str_vec(file, &game.server.ruledit.ag_count,
                                 "compatibility.allowed_govs");
    if (vec != NULL) {
      /* Copy to persistent vector */
      game.server.ruledit.allowed_govs
        = fc_malloc(game.server.ruledit.ag_count * sizeof(char *));

      for (j = 0; j < game.server.ruledit.ag_count; j++) {
        game.server.ruledit.allowed_govs[j] = fc_strdup(vec[j]);
      }

      free(vec);
    }

    vec = secfile_lookup_str_vec(file, &game.server.ruledit.at_count,
                                 "compatibility.allowed_terrains");
    if (vec != NULL) {
      /* Copy to persistent vector */
      game.server.ruledit.allowed_terrains
        = fc_malloc(game.server.ruledit.at_count * sizeof(char *));

      for (j = 0; j < game.server.ruledit.at_count; j++) {
        game.server.ruledit.allowed_terrains[j] = fc_strdup(vec[j]);
      }

      free(vec);
    }

    vec = secfile_lookup_str_vec(file, &game.server.ruledit.as_count,
                                 "compatibility.allowed_styles");
    if (vec != NULL) {
      /* Copy to persistent vector */
      game.server.ruledit.allowed_styles
        = fc_malloc(game.server.ruledit.as_count * sizeof(char *));

      for (j = 0; j < game.server.ruledit.as_count; j++) {
        game.server.ruledit.allowed_styles[j] = fc_strdup(vec[j]);
      }

      free(vec);
    }pgroup = nation_group_by_rule_name      const char *legendbool server_traits_used = TRUE;
 else {
          server_traits_used = FALSE else {
          server_traits_used = FALSE;
        }
        if (pnation->server.traits[tr].fixed < 0) {
          if (server_traits_used) {
            pnation->server.traits[tr].fixed = game.server.default_traits[tr].fixed;
          } else {
            int diff = pnation->server.traits[tr].max - pnation->server.traits[tr].min;

            /* TODO: Should sometimes round the a / 2 = x.5 results up */
            pnation->server.traits[tr].fixed = diff / 2 + pnation->server.traits[tr].min;
          }!= NULL && game.server.ruledit.allowed_govs != NULL) {
          if (!is_on_allowed_list(name,
                                  game.server.ruledit.allowed_govs,
                                  game.server.ruledit.ag_game.server.ruledit.allowed_govs == NULL
              || !is_on_allowed_list(name,
                                     game.server.ruledit.allowed_govs,
                                     game.server.ruledit.ag_game.server.ruledit.allowed_styles == NULL
            || !is_on_allowed_list(name,
                                   game.server.ruledit.allowed_styles,
                                   game.server.ruledit.as_game.server.ruledit.allowed_govs != NULL
          && !is_on_allowed_list(government_rule_name(pnation->init_government),
                                 game.server.ruledit.allowed_govs,
                                 game.server.ruledit.ag_game.server.ruledit.allowed_terrains,
                               game.server.ruledit.at_count)) {
        ok = FALSE;
        break;
      }

      legend = secfile_lookup_str_default(file, "", "%s.legend", sec_name);
      pnation->legend = fc_strdup(legendmusmusmusmusmultiplier *pmul{
      const char *multiplier_name
        = secfile_lookup_str(file, "%s.multiplier", sec_name);

      if (multiplier_name) {
        pmul = multiplier_by_rule_name(multiplier_name);
        if (!pmul) {
          ruleset_error(LOG_ERROR, "\"%s\" [%s] has unknown multiplier \"%s\".",
                        filename, sec_name, multiplier_name);
          ok = FALSE;
          break;
        }
      } else {
        pmul = NULL;
      }
    }

    peffect = effect_new(eff, value, pmul);pref_pref_text = secfile_lookup_str_default(file, "", "tileset.prefered");
  pref_text = secfile_lookup_str_default(file, pref_text, "tileset.preferred");
  if (pref_text[0] != '\0') {
    /* There was tileset suggestion */
    sz_strlcpy(game.control.preferred_tileset, pref_text);
  } else {
    /* No tileset suggestions */
    game.control.preferred_tileset[0] = '\0';
  }

  /* section: soundset */
  pref_text = secfile_lookup_str_default(file, "", "soundset.prefered");
  pref_text = secfile_lookup_str_default(file, pref_text, "soundset.preferred");
  if (pref_red_soundset, pref_text);
  } else {
    /* No soundset suggestions */
    game.control.preferred_soundset[0] = '\0';
  }

  /* section: musicset */
  pref_text = secfile_lookup_str_default(file, "", "musicset.prefered");
  pref_text = secfile_lookup_str_default(file, pref_text, "musicset.preferred");
  if (pref_red_musicset, pref_text);
  } else {
    /* No musicset suggestions */
    game.control.preferred_musicset[0] = '\0';
  }

  /* section: about */
  pref_pref_text);

  pref_text = secfile_lookup_str_default(file, "", "about.version");
  if (pref_pref_text);
  } else {
    /* No version information */
    game.control.version[0] = '\0';
  }

  pref_text = secfile_lookup_str_default(file, "", "about.summary");
  if (pref_text[0] != '\0') {
    int len;

    /* Ruleset/modpack summary found */
    len = strlen(pref_text);
    game.ruleset_summary = fc_malloc(len + 1);
    fc_strlcpy(game.ruleset_summary, pref_text, len + 1);
  } else {
    /* No summary */
    if (game.ruleset_summary != NULL) {
      free(game.ruleset_summary);
      game.ruleset_summary = NULL;
    }
  }

  pref_text = secfile_lookup_str_default(file, "", "about.description");
  if (pref_text[0] != '\0') {
    int len;

    /* Ruleset/modpack description found */
    len = strlen(pref_text);
    game.ruleset_description = fc_malloc(len + 1);
    fc_strlcpy(game.ruleset_description, pref_text, len + 1);
    game.control.desc_length = len;
  } else {
    /* No description */
    if (game.ruleset_description != NULL) {
      free(game.ruleset_description);
      game.ruleset_description = NULL;
    }
    game.control.desc_length = 0gi;

      /* check for <= 0 entries */
      for (gi = 0; gi < game.info.granary_num_inis; gi++) {
        if (food_ini[gi] <= 0) {
          if (gi == 0) {
            food_ini[gi] = RS_DEFAULT_GRANARY_FOOD_INI;
          } else {
            food_ini[gi] = food_ini[gi - 1];
          }
          log_error("Bad value for granary_food_ini[%i]. Using %i.",
                    gi, food_ini[gi]);
        }
        game.info.granary_food_ini[gi] = food_ini[g/* Forbid entering the marketplace when a trade route can be
       * established. */
      game.info.force_trade_route
        = secfile_lookup_bool_default(file, RS_DEFAULT_FORCE_TRADE_ROUTE,
                                      "actions.force_trade_route"action_idgame.info.border_city_permanent_radius_sqBORDER_RADIUS_SQ_CITY_PERMANENT_PERMANENT,
                                           RS_MAX_BORDER_RADIUS_SQ_CITY_PERMANENT,
                                           "borders.radius_sq_city_permanencfml
      = secfile_lookup_int_default(file, RS_DEFAULT_CULTURE_MIGRATION_PML,
                                   "culture.migration_pmlcf = 0; cf < game.info.calendar_fragments; cf++) {
      const char *fname;

      fname = secfile_lookup_str_default(file, NULL, "calendar.fragment_name%d", cf);
      if (fname != NULL) {
        strncpy(game.info.calendar_fragment_name[cf], fname,
                sizeof(game.info.calendar_fragment_name[cfddd/* secfile_check_unused() is not here, but only after also settings section
   * has been loaded. */Send the units ruleset information (all individual unit classes) to tŒÀ ø[‚Â,¸1 ¿|€„ hÎ~® ¿u€ X†=€K ‡U© ‰€› hÎ~€J }À €ƒv vÃ6€} hÎ~° 	¿t€ Z†=¸ ‡P˜ !ˆ|€` rÈz€…s hÎ~€P }À €ƒ? qÃ6€q ‹u ½ {‹tš ·*ŒH¤ —`Ãoº ‡xÛN ‚?ãF€j ‚&æ@† vèeunit_classes(struct conn_list *dest)
{
  struct packet_ruleset_unit_class packet;

  unit_class_iterate(c) {
    packet.id = uclass_number(c);
    sz_strlcpy(packet.name, untranslated_name(&c->name));
    sz_strlcpy(packet.rule_name, rule_name(&c->name));
    packet.min_speed = c->min_speed;
    packet.hp_loss_pct = c->hp_loss_pct;
    packet.hut_behavior = c->hut_behavior;
    packet.flags = c->flags;

    PACKET_STRVEC_COMPUTE(packet.helptext, c->helptext);

    lsend_packet_ruleset_unit_class(dest, &packet);
  } unit_classunits ruleset information (all individual unitunits(struct conn_list *dest)
{
  struct packet_ruleset_unit packet;
  struct packet_ruleset_unit_flag fpacket;
  int i;

  for (i = 0; i < MAX_NUM_USER_UNITUTYF_USER_FLAG_1;

    flagname = unit_type_flag_id_name(i + UTYF_USER_FLAGunit_type_flag_helptxt(i + UTYF_USER_FLAGunit_flag(dest, &fpacket);
  }

  unit_type_iterate(u) {
    packet.id = utype_number(u);
    sz_strlcpy(packet.name, untranslated_name(&u->name));
    sz_strlcpy(packet.rule_name, rule_name(&u->name));
    sz_strlcpy(packet.sound_move, u->sound_move);
    sz_strlcpy(packet.sound_move_alt, u->sound_move_alt);
    sz_strlcpy(packet.sound_fight, u->sound_fight);
    sz_strlcpy(packet.sound_fight_alt, u->sound_fight_alt);
    sz_strlcpy(packet.graphic_str, u->graphic_str);
    sz_strlcpy(packet.graphic_alt, u->graphic_alt);
    packet.unit_class_id = uclass_number(utype_class(u));
    packet.build_cost = u->build_cost;
    packet.pop_cost = u->pop_cost;
    packet.attack_strength = u->attack_strength;
    packet.defense_strength = u->defense_strength;
    packet.move_rate = u->move_rate;
    packet.tech_requirement = u->require_advance
                              ? advance_number(u->require_advance)
                              : advance_count();
    packet.impr_requirement = u->need_improvement
                              ? improvement_number(u->need_improvement)
                              : improvement_count();
    packet.gov_requirement = u->need_government
                             ? government_number(u->need_government)
                             : government_count();
    packet.vision_radius_sq = u->vision_radius_sq;
    packet.transport_capacity = u->transport_capacity;
    packet.hp = u->hp;
    packet.firepower = u->firepower;
    packet.obsoleted_by = u->obsoleted_by
                          ? utype_number(u->obsoleted_by)
                          : utype_count();
    packet.converted_to = u->converted_to
                          ? utype_number(u->converted_to)
                          : utype_count();
    packet.convert_time = u->convert_time;
    packet.fuel = u->fuel;
    packet.flags = u->flags;
    packet.roles = u->roles;
    packet.happy_cost = u->happy_cost;
    output_type_iterate(o) {
      packet.upkeep[o] = u->upkeep[o];
    } output_type_iterate_end;
    packet.paratroopers_range = u->paratroopers_range;
    packet.paratroopers_mr_req = u->paratroopers_mr_req;
    packet.paratroopers_mr_sub = u->paratroopers_mr_sub;
    packet.bombard_rate = u->bombard_rate;
    packet.city_size = u->city_size;
    packet.cargo = u->cargo;
    packet.targets = u->targets;
    packet.embarks = u->embarks;
    packet.disembarks = u->disembarks;

    if (u->veteran == NULL) {
      /* Use the default veteran system. */
      packet.veteran_levels = 0;
    } else {
      /* Per unit veteran system definition. */
      packet.veteran_levels = utype_veteran_levels(u);

      for (i = 0; i < packet.veteran_levels; i++) {
        const struct veteran_level *vlevel = utype_veteran_level(u, i);

        sz_strlcpy(packet.veteran_name[i], untranslated_name(&vlevel->name));
        packet.power_fact[i] = vlevel->power_fact;
        packet.move_bonus[i] = vlevel->move_bonus;
      }
    }
    PACKET_STRVEC_COMPUTE(packet.helptext, u->helptext);

    lsend_packet_ruleset_unit(dest, &packet);

    combat_bonus_list_iterate(u->bonuses, pbonus) {
      struct packet_ruleset_unit_bonus bonuspacket;

      bonuspacket.unit  = packet.id;
      bonuspacket.flag  = pbonus->flag;
      bonuspacket.type  = pbonus->type;
      bonuspacket.value = pbonus->value;
      bonuspacket.quiet = pbonus->quiet;

      lsend_packet_ruleset_unit_bonus(dest, &bonuspacket);
    } combat_bonus_list_iterate_end;
  } unit_typespecialists ruleset information (all individual specialist
  types) to thespecialists(struct conn_list *dest)
{
  struct packet_ruleset_specialist packet;

  specialist_type_iterate(spec_id) {
    struct specialist *s = specialist_by_number(spec_id);
    int j;

    packet.id = spec_id;
    sz_strlcpy(packet.plural_name, untranslated_name(&s->name));
    sz_strlcpy(packet.rule_name, rule_name(&s->name));
    sz_strlcpy(packet.short_name, untranslated_name(&s->abbreviation));
    sz_strlcpy(packet.graphic_alt, s->graphic_alt);
    j = 0;
    requirement_vector_iterate(&sPACKET_STRVEC_COMPUTE(packet.helptext, s->helptext);

    lsend_packet_ruleset_specialist(dest, &packet);
  } specialist_typetechs ruleset information (all individual advanctechs(struct conn_list *dest)
{
  struct packet_ruleset_tech packet;
  struct packet_ruleset_tech_flag fpacket;
  int i;

  for (i = 0; i < MAX_NUM_USER_TECHCH_USER_1;

    flagname = tech_flag_id_name_cb(i + TECHch_flag_helptxt(i + TECHch_flag(dest, &fpacket);
  }

  advance_iterate(A_FIRST, a) {
    packet.id = advance_number(a);    sz_strlcpy(packet.graphic_str, a->graphic_str);
    sz_strlcpy(packet.graphic_alt, a->graphic_alt);

    packet.req[AR_ONE] = a->require[AR_ONE]
                         ? advance_number(a->require[AR_ONE])
                         : advance_count();
    packet.req[AR_TWO] = a->require[AR_TWO]
                         ? advance_number(a->require[AR_TWO])
                         : advance_count();
    packet.root_req = a->require[AR_ROOT]
                      ? advance_number(a->require[AR_ROOT])
                      : advance_count();

    packet.flags = a->flags;
    packet.cost = a->cost;
    packet.num_reqs = a->num_reqs;
    PACKET_STRVEC_COMPUTE(packet.helptext, a->helptext);

    lsend_packet_ruleset_tech(dest, &packet);
  } advancebuildings ruleset information (all individual improvements and
  wonders) to thebuildings(struct conn_list *dest)
{
  improvement_iterate(b) {
    struct packet_ruleset_building packet;
    int j;

    packet.id = improvement_number(b);
    packet.genus = b->genus;
    sz_strlcpy(packet.name, untranslated_name(&b->name));
    sz_strlcpy(packet.rule_name, rule_name(&b->name));
    sz_strlcpy(packet.graphic_str, b->graphic_str);
    sz_strlcpy(packet.graphic_alt, b->graphic_alt);
    j = 0;
    requirement_vector_iterate(&b    j = 0;
    requirement_vector_iterate(&b->obsolete_by, pobs) {
      packet.obs_reqs[j++] = *pobs;
    } requirement_vector_iterate_end;
    packet.obs_count = j;
    packet.build_cost = b->build_cost;
    packet.upkeep = b->upkeep;
    multiplier_number(pmul),
                                    pmul->offset, pmul->factor  requirement_vector_free(&reqs_list
    if (ok) {
      secfile_check_unused(gamefile);
    }!ptype) {
      ptype->unknown_move_cost = utype_unknown_move_cost(ptype);
      set_unit_type_caches(ptype(void)ENDREP
DELTA 29401 190 155
SVN  ŸvŸ|y ê €y ´fë  int att_idx = utype_index(att);

  unit_type_iterate(deftype) {
    int mp = deftype->cache.defense_mp_bonuses[att_idx]ENDREP
id: 1u.5so.r30698/49502
type: file
pred: 1u.5so.r30647/333
count: 341
text: 30698 19383 604 57536 8685d1e0865a77fcf017914fb9a94539
props: 10765 17515 112 0 ecd9c25ffd2014c732acffc1b3aab533
cpath: /branches/S2_6/ai/default/advmilitary.c
copyroot: 19757 /trunk/ai/default/advmilitary.c

id: 24.5sn.r30698/49787
type: file
pred: 24.5sn.r29401/4536
count: 109
text: 30698 49330 145 20476 9d28bea90549ff6563dc6b85cc05d260
props: 10913 82 111 0 a3a3251698e05efa35962766e5c7e5c1
cpath: /branches/S2_6/ai/default/aitech.c
copyroot: 19757 /trunk/ai/default/aitech.c

PLAIN
K 11
Makefile.am
V 24
file 6k4.5ck.r26385/1025
K 14
advdiplomacy.c
V 26
file 2ek.5qt.r30061/176188
K 14
advdiplomacy.h
V 25
file 2el.5ga.r21819/30478
K 13
advdomestic.c
V 21
file 1m.5qz.r30681/61
K 13
advdomestic.h
V 24
file 1n.5gc.r21819/29385
K 13
advmilitary.c
V 24
file 1u.5so.r30698/49502
K 13
advmilitary.h
V 23
file 1v.5ge.r27368/1068
K 7
aiair.c
V 24
file 15y.5t6.r30105/1910
K 7
aiair.h
V 25
file 15z.5gi.r21819/33076
K 8
aicity.c
V 25
file 20.5r8.r30061/177038
K 8
aicity.h
V 22
file 21.5sp.r30670/109
K 8
aidata.c
V 25
file 6mb.5sk.r30222/62271
K 8
aidata.h
V 24
file 6mc.5re.r29401/4263
K 12
aidiplomat.c
V 26
file 16r.5rl.r30061/177315
K 12
aidiplomat.h
V 25
file 16s.5go.r21819/32802
K 9
aiferry.c
V 24
file 2iw.5ra.r30105/2184
K 9
aiferry.h
V 24
file 2ix.5gq.r25299/3783
K 9
aiguard.c
V 25
file 335.5gr.r21830/20422
K 9
aiguard.h
V 25
file 336.5rp.r28076/25981
K 8
aihand.c
V 24
file 22.5gt.r26403/72867
K 8
aihand.h
V 24
file 23.5gu.r21810/35768
K 8
aihunt.c
V 24
file 2gc.5t8.r30105/2462
K 8
aihunt.h
V 25
file 2gd.5gw.r21819/35411
K 7
ailog.c
V 25
file 6p8.5s8.r28854/25132
K 7
ailog.h
V 26
file 6p9.5gy.r26905/232907
K 15
aiparatrooper.c
V 26
file 36o.5t9.r30061/178161
K 15
aiparatrooper.h
V 25
file 36p.5h0.r25366/42160
K 10
aiplayer.c
V 24
file 6i3.5sh.r30143/6033
K 10
aiplayer.h
V 24
file 6i4.5td.r30143/6310
K 11
aisettler.c
V 24
file 2lh.5r9.r30105/2735
K 11
aisettler.h
V 25
file 2li.5h4.r22374/17958
K 8
aitech.c
V 24
file 24.5sn.r30698/49787
K 8
aitech.h
V 23
file 25.5h6.r25452/2151
K 9
aitools.c
V 22
file 9.5rb.r30105/3016
K 9
aitools.h
V 23
file a.5h8.r25366/39676
K 8
aiunit.c
V 22
file b.5r7.r30311/2726
K 8
aiunit.h
V 22
file c.5t7.r30311/2998
K 12
daieffects.c
V 26
file 156e.5qi.r29460/23344
K 12
daieffects.h
V 25
file 156g.5qi.r29401/5074
END
ENDREP
id: 6k3.5qi.r30698/51856
type: dir
pred: 6k3.5qi.r30681/2133
count: 397
text: 30698 50060 1783 0 c0ee304945782e6caab9dc0ba245f438
props: 19010 5510 53 0 1aad128f6d028f535e9ce7233326568e
cpath: /branches/S2_6/ai/default
copyroot: 27474 /branches/S2_6

PLAIN
K 11
Makefile.am
V 24
file 5d.5ck.r26100/14492
K 10
aitraits.c
V 24
file 7k0.5qi.r30331/6378
K 10
aitraits.h
V 26
file 7k2.5ck.r26905/225228
K 7
classic
V 23
dir l53.5qi.r30311/2479
K 7
default
V 24
dir 6k3.5qi.r30698/51856
K 12
difficulty.c
V 25
file 1b4x.5qi.r29443/3259
K 12
difficulty.h
V 27
file 1b4z.5ck.r26905/225513
K 11
handicaps.c
V 26
file syo.5ck.r26905/225805
K 11
handicaps.h
V 24
file syq.5qi.r29443/3517
K 4
stub
V 25
dir 6k5.5ck.r26905/226459
K 8
threaded
V 23
dir 6pi.5qi.r30311/5967
END
ENDREP
id: 8.5qi.r30698/52626
type: dir
pred: 8.5qi.r30681/2899
count: 1844
text: 30698 52107 506 0 6b5009bfd7aca3c4da9256ccc21a8ebf
props: 11108 11315 64 0 abac628483ea4fdfa3bea3a3a56e0532
cpath: /branches/S2_6/ai
copyroot: 27474 /branches/S2_6

id: n.5qi.r30698/52866
type: file
pred: n.5qi.r30696/6869
count: 1063
text: 30698 20012 184 153117 a81e97b0489b321b956da91ac107c7e6
props: 11088 14698 112 0 2c9d3e41a2f20488aa9cdb8d740d094e
cpath: /branches/S2_6/client/packhand.c
copyroot: 27474 /branches/S2_6

PLAIN
K 11
Makefile.am
V 23
file 5f.5qi.r30216/2645
K 6
agents
V 23
dir zf.5qi.r29744/10642
K 11
attribute.c
V 24
file xh.5ck.r25151/59391
K 11
attribute.h
V 24
file xi.5ck.r18863/23649
K 7
audio.c
V 24
file 139.5qi.r30673/6533
K 7
audio.h
V 24
file 13a.5qi.r30673/6790
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.5qi.r30211/29757
K 17
chatline_common.h
V 24
file 14r.5ck.r24892/5917
K 16
citydlg_common.c
V 24
file z4.5qi.r30211/30026
K 16
citydlg_common.h
V 24
file z5.5qi.r29744/11160
K 13
cityrepdata.c
V 24
file mb.5qi.r30211/30292
K 13
cityrepdata.h
V 24
file mc.5ck.r18863/19121
K 13
client_main.c
V 23
file 2f.5rc.r30375/2010
K 13
client_main.h
V 23
file hz.5sl.r29334/5749
K 8
climap.c
V 24
file 197.5ck.r20232/3008
K 8
climap.h
V 25
file 198.5qi.r30222/65356
K 9
climisc.c
V 23
file d5.5qi.r30696/6357
K 9
climisc.h
V 23
file i0.5qi.r30696/6617
K 8
clinet.c
V 23
file hc.5qi.r30615/2244
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 24
file 2fw.5qi.r30360/9019
K 19
connectdlg_common.h
V 25
file 2fx.5ck.r19154/53802
K 9
control.c
V 23
file gz.5qi.r30685/4976
K 9
control.h
V 23
file i2.5qi.r30094/7239
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.5qi.r30514/4804
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 24
file vu.5qi.r30211/31615
K 6
goto.h
V 24
file vv.5qi.r27872/19931
K 11
gui-gtk-2.0
V 23
dir zs.5qi.r30673/11930
K 11
gui-gtk-3.0
V 23
dir zs.5qq.r30673/16974
K 6
gui-qt
V 23
dir 6ie.5qi.r30639/3393
K 7
gui-sdl
V 24
dir 16t.5qi.r30673/22298
K 8
gui-sdl2
V 24
dir 16t.5r1.r30673/27627
K 8
gui-stub
V 22
dir mh.5qi.r29388/3851
K 7
gui-xaw
V 23
dir 9o.5qi.r30375/30247
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.5qi.r30514/14159
K 10
helpdata.h
V 22
file i3.5qi.r30005/963
K 7
include
V 23
dir b8.5qi.r29938/33828
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.5qi.r29744/13350
K 16
mapctrl_common.c
V 22
file 15m.5qi.r30623/71
K 16
mapctrl_common.h
V 24
file 15n.5ck.r27397/5459
K 16
mapview_common.c
V 22
file z2.5qi.r30450/115
K 16
mapview_common.h
V 23
file z3.5qi.r30297/1392
K 19
messagewin_common.c
V 25
file 14s.5qi.r30211/72878
K 19
messagewin_common.h
V 25
file 14t.5ck.r18863/21579
K 7
music.c
V 25
file zmc.5qi.r30211/73150
K 7
music.h
V 25
file zme.5ck.r27127/11513
K 9
options.c
V 24
file dc.5qi.r30665/19253
K 9
options.h
V 24
file i4.5qi.r30665/19508
K 17
overview_common.c
V 25
file 2yk.5qi.r30222/85277
K 17
overview_common.h
V 24
file 2yl.5qi.r29834/4937
K 10
packhand.c
V 23
file n.5qi.r30698/52866
K 10
packhand.h
V 24
file i5.5ck.r18863/20596
K 15
plrdlg_common.c
V 24
file 14u.5qi.r28834/2098
K 15
plrdlg_common.h
V 25
file 14v.5ck.r18863/21328
K 17
repodlgs_common.c
V 26
file 11i.5qi.r30061/217644
K 17
repodlgs_common.h
V 25
file 11j.5ck.r19589/11861
K 9
reqtree.c
V 25
file 2ym.5qi.r30211/74457
K 9
reqtree.h
V 24
file 2yn.5ck.r24150/6004
K 9
servers.c
V 25
file 33x.5qi.r30615/13147
K 9
servers.h
V 25
file 33y.5ck.r20478/36372
K 6
text.c
V 26
file 2g3.5qi.r30061/217915
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.5qi.r30673/28156
K 10
tilespec.h
V 24
file i6.5qi.r30673/28417
K 19
unitselect_common.c
V 26
file 76v.5qi.r30061/218439
K 19
unitselect_common.h
V 26
file 76w.5ck.r26905/117548
K 14
update_queue.c
V 25
file 4jw.5qi.r29066/44235
K 14
update_queue.h
V 26
file 4jx.5ck.r26905/141966
K 10
voteinfo.c
V 25
file 4fe.5qi.r30211/74980
K 10
voteinfo.h
V 26
file 4ff.5ck.r26905/142263
K 6
zoom.c
V 25
file 212g.5qi.r30498/1183
K 6
zoom.h
V 25
file 212i.5qi.r30498/1381
END
ENDREP
id: d.5qi.r30698/57486
type: dir
pred: d.5qi.r30696/11483
count: 6851
text: 30698 53128 4345 0 45321205a1030b414571fc459afc4932
props: 28037 12634 400 0 bbe1d6769a94f3af2a54f7dc91fc9c71
cpath: /branches/S2_6/client
copyroot: 27474 /branches/S2_6

id: wp.5qi.r30698/57733
type: file
pred: wp.5qi.r30105/12537
count: 128
text: 30698 0 18981 27556 d632f7597d6e1cdc60e00d0189845959
props: 11060 17292 111 0 e77f29e20031f26b4b1e16b63c7aa55c
cpath: /branches/S2_6/common/combat.c
copyroot: 27474 /branches/S2_6

id: v9.5qi.r30698/57992
type: file
pred: v9.5qi.r30514/20320
count: 208
text: 30698 20221 6049 69166 0859c324fe2ab587949fcc413efef816
props: 10932 10175 111 0 3f70303ff9ea148b5e232db96a904e98
cpath: /branches/S2_6/common/unittype.c
copyroot: 27474 /branches/S2_6

id: va.5qi.r30698/58256
type: file
pred: va.5qi.r30317/78159
count: 190
text: 30698 19009 346 28558 302c487d39721875c641869d18444349
props: 10932 10530 111 0 c621529c87aa3e4513ceb9a8b717aa47
cpath: /branches/S2_6/common/unittype.h
copyroot: 27474 /branches/S2_6

PLAIN
K 11
Makefile.am
V 24
file 5h.5qi.r30222/90685
K 14
achievements.c
V 25
file qhc.5qi.r30222/90944
K 14
achievements.h
V 26
file qhe.5ck.r26905/215849
K 9
actions.c
V 22
file r7a.5qi.r30512/92
K 9
actions.h
V 23
file r7c.5qi.r29792/962
K 4
ai.c
V 23
file 4go.5qi.r29098/627
K 4
ai.h
V 24
file 4gp.5qi.r30311/6973
K 6
aicore
V 23
dir 18t.5qi.r30122/5695
K 6
base.c
V 26
file 3jw.5qi.r30061/225212
K 6
base.h
V 25
file 3jx.5qi.r29646/20289
K 9
borders.c
V 25
file 4f0.5qi.r28854/19065
K 9
borders.h
V 26
file 4f1.5ck.r26905/213493
K 10
calendar.c
V 27
file 147p.5ck.r26905/214086
K 10
calendar.h
V 27
file 147r.5ck.r26905/215265
K 8
capstr.c
V 22
file dv.5ck.r24976/289
K 8
capstr.h
V 24
file dw.5ck.r18858/97074
K 10
citizens.c
V 26
file 6mx.5ck.r26905/203234
K 10
citizens.h
V 26
file 6my.5ck.r26905/204108
K 6
city.c
V 24
file q.5qi.r30061/225467
K 6
city.h
V 23
file 3q.5qi.r29373/6009
K 13
clientutils.c
V 26
file zj9.5ck.r26905/212022
K 13
clientutils.h
V 26
file zjb.5ck.r26905/213199
K 8
combat.c
V 24
file wp.5qi.r30698/57733
K 8
combat.h
V 24
file wq.5ck.r24573/25814
K 12
connection.c
V 24
file un.5qi.r30615/18011
K 12
connection.h
V 24
file uo.5qi.r30394/34772
K 9
culture.c
V 27
file 104t.5ck.r26905/202652
K 9
culture.h
V 27
file 104v.5ck.r26905/203523
K 8
dataio.c
V 25
file 15r.5qi.r30615/18272
K 8
dataio.h
V 24
file 15s.5ck.r26834/4081
K 11
diptreaty.c
V 23
file 3r.5qi.r29571/7104
K 11
diptreaty.h
V 23
file 3s.5qi.r27518/9734
K 10
disaster.c
V 25
file b2m.5qi.r30000/39648
K 10
disaster.h
V 26
file b2o.5ck.r26905/216145
K 9
effects.c
V 26
file 2eo.5qi.r30061/225985
K 9
effects.h
V 24
file 2ep.5qi.r29180/3668
K 8
events.c
V 24
file 33h.5qi.r28399/2883
K 8
events.h
V 23
file 3t.5qi.r28399/3138
K 8
extras.c
V 26
file o9u.5qi.r30061/226248
K 8
extras.h
V 25
file o9w.5qi.r29786/30339
K 12
fc_cmdhelp.c
V 26
file 76j.5ck.r26905/216438
K 12
fc_cmdhelp.h
V 26
file 76k.5ck.r26905/216731
K 14
fc_interface.c
V 23
file 4up.5qi.r29369/494
K 14
fc_interface.h
V 25
file 4uq.5qi.r28204/10610
K 10
fc_types.h
V 25
file 2ll.5qi.r30685/10094
K 15
featured_text.c
V 26
file 4h3.5ck.r26905/212899
K 15
featured_text.h
V 25
file 4h4.5qi.r30000/40165
K 6
game.c
V 24
file 3u.5qi.r30673/33286
K 6
game.h
V 24
file 3v.5qi.r30394/35293
K 19
generate_packets.py
V 24
file 2f4.5qi.r30652/1060
K 12
government.c
V 24
file he.5qi.r30000/40431
K 12
government.h
V 24
file hf.5ck.r25151/83855
K 6
idex.c
V 24
file qo.5ck.r25151/84101
K 6
idex.h
V 24
file qp.5ck.r18858/92434
K 13
improvement.c
V 24
file vb.5qi.r30000/40695
K 13
improvement.h
V 23
file vc.5ck.r26605/3666
K 5
map.c
V 21
file r.5qi.r30599/181
K 5
map.h
V 24
file 41.5qi.r30222/91725
K 11
map_types.h
V 25
file 2175.5qi.r30224/3567
K 8
mapimg.c
V 22
file 6n9.5qi.r30290/74
K 8
mapimg.h
V 26
file 6na.5ck.r26905/215559
K 15
metaknowledge.c
V 26
file siq.5qi.r30061/226767
K 15
metaknowledge.h
V 26
file sis.5ck.r26905/206455
K 10
movement.c
V 25
file 2xv.5qi.r30514/19290
K 10
movement.h
V 25
file 2xw.5qi.r30514/19551
K 13
multipliers.c
V 26
file 197b.5qi.r30000/40959
K 13
multipliers.h
V 26
file 197d.5qi.r29118/55021
K 18
name_translation.h
V 25
file 4k1.5qi.r30000/41223
K 8
nation.c
V 21
file il.5qi.r30333/79
K 8
nation.h
V 22
file im.5ck.r27000/284
K 9
packets.c
V 24
file 43.5qi.r30615/18531
K 11
packets.def
V 25
file 2f5.5qi.r30696/11728
K 9
packets.h
V 24
file 44.5qi.r28854/17506
K 8
player.c
V 24
file 45.5qi.r30536/19951
K 8
player.h
V 24
file 46.5qi.r30536/20210
K 14
requirements.c
V 26
file 2wq.5qi.r30061/227558
K 14
requirements.h
V 24
file 2wr.5qi.r29445/8145
K 10
research.c
V 25
file 4ro.5qi.r30000/41751
K 10
research.h
V 23
file 4rp.5qi.r27751/838
K 10
rgbcolor.c
V 26
file 6i6.5ck.r26905/218776
K 10
rgbcolor.h
V 26
file 6i7.5ck.r26905/219068
K 6
road.c
V 26
file 6pq.5qi.r30061/227827
K 6
road.h
V 24
file 6pr.5qi.r29808/7032
K 10
scriptcore
V 24
dir 75a.5qi.r30222/93978
K 11
spaceship.c
V 23
file 98.5ck.r26349/9773
K 11
spaceship.h
V 24
file 99.5ck.r26349/10015
K 12
specialist.c
V 25
file 33f.5qi.r30000/42012
K 12
specialist.h
V 24
file 33g.5qi.r29571/9422
K 7
style.c
V 25
file zzb.5qi.r30000/42275
K 7
style.h
V 26
file zzd.5ck.r26905/204988
K 6
team.c
V 23
file 33i.5ck.r25891/212
K 6
team.h
V 23
file 33j.5ck.r26183/314
K 6
tech.c
V 23
file t.5qi.r30000/42534
K 6
tech.h
V 21
file u.5qi.r29318/376
K 9
terrain.c
V 25
file 2fp.5qi.r30222/94237
K 9
terrain.h
V 24
file qs.5qi.r27880/14146
K 6
tile.c
V 25
file 2ys.5qi.r30514/19811
K 6
tile.h
V 25
file 2yt.5qi.r30514/20067
K 13
traderoutes.c
V 25
file bf8.5qi.r27552/33422
K 13
traderoutes.h
V 25
file bfa.5qi.r27552/33689
K 8
traits.h
V 24
file 7k3.5qi.r30331/8160
K 6
unit.c
V 23
file v.5qi.r30685/10622
K 6
unit.h
V 24
file 48.5qi.r30685/10876
K 10
unitlist.c
V 25
file 39m.5qi.r27612/25885
K 10
unitlist.h
V 25
file 39n.5qi.r27612/26147
K 10
unittype.c
V 24
file v9.5qi.r30698/57992
K 10
unittype.h
V 24
file va.5qi.r30698/58256
K 9
version.c
V 23
file oe.5ck.r26171/7093
K 9
version.h
V 23
file e7.5ck.r26171/7331
K 9
victory.c
V 26
file qex.5ck.r26905/217020
K 9
victory.h
V 26
file qez.5ck.r26905/217896
K 8
vision.c
V 22
file 4dm.5qi.r27639/98
K 8
vision.h
V 24
file 4dn.5ck.r24742/9986
K 12
workertask.c
V 26
file llw.5ck.r26905/206753
K 12
workertask.h
V 25
file lly.5qi.r28927/25134
K 10
worklist.c
V 22
file o8.5qi.r28027/169
K 10
worklist.h
V 24
file o9.5ck.r18858/98299
END
ENDREP
id: p.5qi.r30698/63863
type: dir
pred: p.5qi.r30696/17335
count: 4326
text: 30698 58519 5331 0 d38bc59bac01e592b159b428a001201a
props: 23743 0 112 0 b2bc91bf125d83375389d51f25ff2c2f
cpath: /branches/S2_6/common
copyroot: 27474 /branches/S2_6

id: 8w.5qi.r30698/64106
type: file
pred: 8w.5qi.r30673/39389
count: 800
text: 30698 26301 23001 246029 86734657509484560f651e070f63d99b
props: 11085 367 112 0 7f6d12fc80ead5cc285da723cb8caa9d
cpath: /branches/S2_6/server/ruleset.c
copyroot: 27474 /branches/S2_6

PLAIN
K 11
Makefile.am
V 24
file 5q.5qi.r28430/14363
K 13
actiontools.c
V 23
file 1p8q.5qi.r30373/96
K 13
actiontools.h
V 26
file 1p8t.5qi.r28430/14182
K 8
advisors
V 23
dir 4n2.5qi.r30596/1656
K 9
aiiface.c
V 25
file 4gm.5ck.r26905/55786
K 9
aiiface.h
V 25
file 4gn.5ck.r26905/56374
K 9
animals.c
V 26
file vnk.5qi.r30222/102161
K 9
animals.h
V 25
file vnm.5ck.r26905/63257
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.5qi.r29856/17671
K 11
barbarian.h
V 22
file lx.5qi.r28606/673
K 14
citizenshand.c
V 25
file 6mz.5qi.r29646/26851
K 14
citizenshand.h
V 25
file 6n0.5ck.r26905/56662
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 22
file 4g.5qi.r30386/326
K 11
citytools.h
V 23
file 4h.5qi.r29015/8710
K 10
cityturn.c
V 22
file 4i.5qi.r30522/698
K 10
cityturn.h
V 24
file 4j.5ck.r24742/16670
K 11
civserver.c
V 24
file 4k.5qi.r30360/31178
K 10
commands.c
V 24
file 2ly.5qi.r27913/1890
K 10
commands.h
V 25
file 2lz.5qi.r28013/36715
K 13
connecthand.c
V 25
file 2dw.5qi.r29856/17933
K 13
connecthand.h
V 24
file 2dx.5ck.r23606/2057
K 9
console.c
V 24
file dd.5ck.r24895/15492
K 9
console.h
V 23
file de.5ck.r19183/7918
K 10
diplhand.c
V 23
file 4m.5qi.r30236/2316
K 10
diplhand.h
V 23
file 4n.5qi.r27518/5128
K 11
diplomats.c
V 23
file vz.5qi.r30203/2301
K 11
diplomats.h
V 23
file w0.5ck.r27461/1674
K 10
edithand.c
V 26
file 3bk.5qi.r30061/237597
K 10
edithand.h
V 25
file 4ez.5ck.r26905/64705
K 6
fcdb.c
V 25
file 6l3.5ck.r26905/56956
K 6
fcdb.h
V 25
file 6l4.5ck.r26905/57239
K 10
gamehand.c
V 22
file 4o.5qi.r30551/550
K 10
gamehand.h
V 24
file 4p.5ck.r26564/23149
K 9
generator
V 23
dir 2me.5qi.r30690/1101
K 10
handchat.c
V 23
file 4q.5ck.r25915/6654
K 10
handchat.h
V 24
file dj.5ck.r18270/28229
K 9
maphand.c
V 25
file 13.5qi.r30222/105544
K 9
maphand.h
V 23
file 14.5ck.r24759/3742
K 6
meta.c
V 24
file 4s.5qi.r30615/25159
K 6
meta.h
V 23
file 4t.5ck.r27204/3095
K 6
mood.c
V 26
file 112c.5ck.r26905/63547
K 6
mood.h
V 26
file 112e.5ck.r26905/64129
K 8
notify.c
V 25
file 4i2.5qi.r30696/17833
K 8
notify.h
V 25
file 4i3.5ck.r26905/58681
K 9
plrhand.c
V 21
file 4u.5qi.r30295/64
K 9
plrhand.h
V 22
file 4v.5qi.r29630/442
K 8
report.c
V 23
file vi.5qi.r29900/1902
K 8
report.h
V 23
file vj.5qi.r29900/2158
K 10
rssanity.c
V 25
file hew.5qi.r30514/28898
K 10
rssanity.h
V 25
file hey.5ck.r26905/55500
K 9
ruleset.c
V 24
file 8w.5qi.r30698/64106
K 9
ruleset.h
V 24
file 8x.5qi.r30103/20281
K 13
sanitycheck.c
V 21
file wi.5qi.r30488/99
K 13
sanitycheck.h
V 24
file wj.5qi.r28076/13693
K 12
savecompat.c
V 24
file qva.5qi.r30663/1022
K 12
savecompat.h
V 24
file qvc.5qi.r30204/4618
K 10
savegame.c
V 22
file vl.5qi.r30577/405
K 10
savegame.h
V 24
file vm.5ck.r20758/19233
K 11
savegame2.c
V 24
file 4m0.5qi.r30663/1279
K 11
savegame2.h
V 25
file 4m1.5ck.r26905/58971
K 7
score.c
V 25
file 2eg.5qi.r29646/30135
K 7
score.h
V 24
file 2eh.5ck.r21929/6179
K 9
scripting
V 23
dir 31x.5qi.r30658/3157
K 8
sernet.c
V 24
file 15.5qi.r30615/25416
K 8
sernet.h
V 23
file 4y.5ck.r23685/5129
K 10
settings.c
V 25
file 2m0.5qi.r30331/27076
K 10
settings.h
V 23
file 2m1.5qi.r29780/954
K 11
spacerace.c
V 24
file 9a.5ck.r25063/30975
K 11
spacerace.h
V 21
file 9b.0.r11338/1129
K 9
srv_log.c
V 24
file 15t.5rh.r28854/9971
K 9
srv_log.h
V 25
file 15u.5ri.r28013/36974
K 10
srv_main.c
V 21
file vg.5qi.r30687/90
K 10
srv_main.h
V 24
file vh.5qi.r29282/23936
K 11
stdinhand.c
V 24
file 4z.5qi.r30174/17327
K 11
stdinhand.h
V 24
file 50.5ck.r26100/15471
K 11
techtools.c
V 23
file 33n.5qi.r30619/496
K 11
techtools.h
V 24
file 33o.5ck.r27058/2134
K 10
unithand.c
V 24
file 18.5qi.r30685/16977
K 10
unithand.h
V 24
file 19.5ck.r23027/66151
K 11
unittools.c
V 24
file 1a.5qi.r30685/17238
K 11
unittools.h
V 23
file 1b.5qi.r29212/1520
K 8
voting.c
V 25
file 4ex.5ck.r26905/57525
K 8
voting.h
V 25
file 4ey.5ck.r26905/58399
END
ENDREP
id: z.5qi.r30698/68318
type: dir
pred: z.5qi.r30696/22040
count: 6105
text: 30698 64369 3936 0 0497db53c2d387beabe137b981184e93
props: 23990 448 166 0 e5026e1cb18fe57b41417951bfac7b19
cpath: /branches/S2_6/server
copyroot: 27474 /branches/S2_6

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.5qi.r29455/952
K 9
ChangeLog
V 26
file 6l.5ck.r27473/7455495
K 7
INSTALL
V 21
file 6.5qi.r29706/131
K 11
Makefile.am
V 23
file 59.5qi.r30174/7026
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.5qi.r30698/52626
K 10
autogen.sh
V 23
file 12o.5qi.r30655/418
K 9
bootstrap
V 23
dir 2p5.5qi.r29679/3655
K 6
client
V 22
dir d.5qi.r30698/57486
K 6
common
V 22
dir p.5qi.r30698/63863
K 12
configure.ac
V 25
file 149.5qi.r30615/24369
K 4
data
V 22
dir w.5qi.r30660/11453
K 12
dependencies
V 24
dir 2yu.5qi.r30394/45765
K 3
doc
V 23
dir k7.5qi.r30645/20608
K 10
fc_version
V 25
file 2lo.5qj.r30696/17578
K 11
gen_headers
V 25
dir 1hsw.5qi.r30615/24964
K 2
m4
V 23
dir 12p.5qi.r30493/2429
K 7
scripts
V 23
dir 2yo.5qi.r28717/5437
K 6
server
V 22
dir z.5qi.r30698/68318
K 5
tests
V 22
dir 2g9.5ck.r27023/734
K 5
tools
V 23
dir 4pj.5qp.r30675/2532
K 12
translations
V 25
dir t0a.5qi.r30693/232958
K 7
utility
V 23
dir 1c.5qi.r30673/49847
K 3
vms
V 25
dir u9.5ck.r21528/1396085
K 5
win32
V 23
dir 2eu.5qi.r30585/1785
END
ENDREP
id: 3.5qi.r30698/69741
type: dir
pred: 3.5qi.r30696/23461
count: 19991
text: 30698 68563 1165 0 6c21c00b689034e0ccc9d89dd37c5236
props: 28037 14463 292 0 9e1d5de0253c723466868990c52c129f
cpath: /branches/S2_6
copyroot: 27474 /branches/S2_6

PLAIN
K 5
S1_14
V 21
dir 3.21.r18109/18803
K 4
S2_0
V 21
dir 3.10x.r21862/4178
K 4
S2_1
V 22
dir 3.59e.r20026/11014
K 4
S2_2
V 21
dir 3.5cy.r21861/5036
K 4
S2_3
V 21
dir 3.5f2.r29458/5135
K 4
S2_4
V 22
dir 3.5ii.r30401/87429
K 4
S2_5
V 23
dir 3.5kv.r30692/112551
K 4
S2_6
V 22
dir 3.5qi.r30698/69741
K 11
freeciv-web
V 22
dir 3.5bl.r13594/14918
END
ENDREP
id: 1.0.r30698/70338
type: dir
pred: 1.0.r30696/24059
count: 10175
text: 30698 69982 343 0 31feba708142fc6748e1ba16724c473f
cpath: /branches
copyroot: 0 /

PLAIN
K 8
branches
V 20
dir 1.0.r30698/70338
K 4
tags
V 19
dir 2.0.r29519/6475
K 5
trunk
V 22
dir 3.5ck.r30697/41541
K 7
website
V 20
dir 3ge.0.r30613/922
END
ENDREP
id: 0.0.r30698/70660
type: dir
pred: 0.0.r30697/41932
count: 30698
text: 30698 70494 153 0 347d15c6ed063a10e5bf5b1bf3019f85
cpath: /
copyroot: 0 /

1u.5so.t30697-1 modify true false /branches/S2_6/ai/default/advmilitary.c

24.5sn.t30697-1 modify true false /branches/S2_6/ai/default/aitech.c

n.5qi.t30697-1 modify true false /branches/S2_6/client/packhand.c

wp.5qi.t30697-1 modify true false /branches/S2_6/common/combat.c

v9.5qi.t30697-1 modify true false /branches/S2_6/common/unittype.c

va.5qi.t30697-1 modify true false /branches/S2_6/common/unittype.h

8w.5qi.t30697-1 modify true false /branches/S2_6/server/ruleset.c


70660 70808
