DELTA 20808 2071 171547
SVN  †  †  ƒJ½ ‹ € b‹mˆ …)W– ‚~’S© ƒJ•N€6 RÐ; ˆX›+‘ ‡0¤ G  >±q X³6  g´<€R „QÆA€ƒ Sõ Ÿ|ÎD˜ IÊ@€Œ Rõ úî@™ ·YèW€F V„‰;€‚@ Y‚¢t€N ¤F‚¥M †0‚Ê ƒz‚ÐC ˜^‚Ô=€[ †;‚îE€& ” ‚õl€S ›BƒŠº ’Rƒ¥C“ ‚ƒ¸€V †tƒº_€G ‡ƒÁ}ƒ ‚pƒÉ€‚ YƒÏ ¢ ¹ƒÏx ;‚ 0‡ j‚¡o€Y ^‚£1€G –d„Š
€ †!„¢ ´ ‡a„¨€ †S„¯x „„·Z” ˆG„»p€‚! †C„Ä+€@ ^…‹d€	 oƒ¦a€] Š„ËW §„ÖI¡ eƒý~‹ g„ý=® Cƒû?» eƒý~­ „ü>¡ eƒý~— 4…›"€ Q„ø;„ „ù€‚s …œU€†	 „0…Q€j M…y€! o… #€B Y…r€, o… #€ ËN…¢ traderoutes.h"
#include "unit.h"
#include "unittype.h"

/* server */
#include "citytools.h"
#include "plrhand.h"
#include "rssanity2.Feb.28T_SECTION_PREFIX "nset#define DISASTER_SECTION_PREFIX "disasterbool load_rulesetdir(const char *rsdir);
static struct section_file *openload_ruleset_file(const char *whichset,
                                                  const char *rsdir);const char *rsdirint line, enum log_level level,
,
                                                  const char *rsdir)
{
  char sfilename[512];
  const char *dfilename = valid_ruleset_filename(rsdir, whichset,
                                                bool openload_script_file(const char *whichset, const char *rsdir)
{
  const char *dfilename = valid_ruleset_filename(rsdir, whichset,
                                                 SCRIPT_SUFFIX);

  if (!script_server_do_file(NULL, dfilename)) {
    ruleset_error(LOG_ERROR, "\"%s\": could not load ruleset script.",
                  dfilename);

    return FALSE;
  }

  return TRUE Load combat bonus list
*/
static bool lookup_cbonus_list(struct combat_bonus_list *list,
                               struct section_file *file,
                               const char *sec,
                               const char *sub)
{
  const char *flag;
  int j;
  const char *filename;
  bool success = TRUE;

  filename = secfile_name(file);

  for (j = 0; (flag = secfile_lookup_str_default(file, NULL, "%s.%s%d.flag",
                                                 sec, sub, j)); j++) {
    struct combat_bonus *bonus = fc_malloc(sizeof(*bonus));
    const char *type;

    bonus->flag = unit_type_flag_id_by_name(flag, fc_strcasecmp);
    if (!unit_type_flag_id_is_valid(bonus->flag)) {
      log_error("\"%s\": unknown flag name \"%s\" in '%s.%s'.",
                filename, flag, sec, sub);
      FC_FREE(bonus);
      success = FALSE;
      continue;
    }
    type = secfile_lookup_str(file, "%s.%s%d.type", sec, sub, j);
    bonus->type = combat_bonus_type_by_name(type, fc_strcasecmp);
    if (!combat_bonus_type_is_valid(bonus->type)) {
      log_error("\"%s\": unknown bonus type \"%s\" in '%s.%s'.",
                filename, type, sec, sub);
      FC_FREE(bonus);
      success = FALSE;
      continue;
    }
    if (!secfile_lookup_int(file, &bonus->value, "%s.%s%d.value",
                            sec, sub, j)) {
      log_error("\"%s\": failed to get value from '%s.%s%d'.",
                filename, sec, sub, j);
      FC_FREE(bonus);
      success = FALSE;
      continue;
    }
    combat_bonus_list_append(list, bonus);
  }

  return success"trader",
    "aggressiveint i;
  const char *filename = secfile_name(file);
  const char *flagUser unit flag names */
  for (i = 0; (flag = secfile_lookup_str_default(file, NULL, "control.flags%d.name", i)) ;
       i++) {
    const char *helptxt = secfile_lookup_str_default(file, NULL, "control.flags%d.helptxt",
                                                     i);

    if (i > MAX_NUM_USER_UNIT_FLAGS) {
    filename);
    }

    set_user_unit_type_flag_name(UTYF_USER_FLAG_1 + i, flag, helptxt);
  }

  for (; i < MAX_NUM_USER_UNIT_FLAGS; i++) {
    set_user_unit_type_flag_name(UTYF_USER_FLAG_1 + i, NULL, NULLwwwtype_flag_id_by_name(sval, fc_strcasecmp);
        if (unit_type_flag_id_is_valid(ival)) {
          log_error("\"%s\" unit_class \"%s\": unit_type flag \"%s\"!",
                    filename, uclass_rule_name(uc), sval        bv_roads roads;

        BV_CLR_ALL(spe);
        BV_CLR_ALL(bases);
        BV_CLR_ALL(roads);

        if (is_native_to_class(uc, pterrain, spe, bases, road  u->convert_time = secfile_lookup_int_default(file, 1, "%s.convert_time", sec_namelookup_cbonus_list(u->bonuses, file, sec_name, "bonuses");UTYF_LAST_USER_FLAGtype_flag_id_by_name(sval, fc_strcasecmp);
      if (!unit_type_flag_id_is_valid(ival)id_by_name(sval, fc_strcasecmp);
      if (!unit_role_id_is_valid(ival)UTY (num_role_units(UTYF_SETTLERS) == 0) {
    ruleset_error(LOG_FATAL, "\"%s\": No flag=settler units?", filename);
  }
  if (num_role_units(L_EXPLORER) == 0) {
    ruleset_error(LOG_FATAL, "\"%s\": No role=explorer units?", filename);
  }
  if (num_role_units(L_FERRYBOAT) ==  (num_role_units(L_FIRSTBUILD) == terrainTER_USER_LAST - TER_USER_1) {
    ruleset_error(LOG_FATAL, "\"%s\": Too many user terrainterrain_flag_name(TER_USER_1 + i, flaglist[i]);
  }
  for (; i < TER_USER_LAST - TER_USER_1; i++) {
    set_user_terrain_flag_name(TER_USER_1 + i, NULL);
  }
  if (flaglist) {
    free(flaglist);
  }> MAX_ROAD_TYPES) {
    ruleset_error(LOG_FATAL, "\"%s\": Too many road types (%d, max %d)",
                  filename, nval, MAX_ROAD_TYPESbool compat_road = FALSE;
  bool compat_rail = FALSEterrain_control.min_start_native_area
    = secfile_lookup_int_default(file, 0,
                                 "parameters.min_start_native_area    const char *cstrcstr = secfile_lookup_str(file, "%s.class", tsection);
    pterrain->tclass = terrain_class_by_name(cstr, fc_strcasecmp);
    if (!terrain_class_is_valid(pterrain->tclass)) {
      ruleset_error(LOG_FATAL, "\"%s\": [%s] unknown class \"%s\"",
                    filename, tsection, cstr);output_type_iterate(o) {
      pterrain->road_output_incr_pct[o]              "%s.road_%s_incr_pct",
                                                                     tsection,
                     if (!secfile_lookup_int(file, &pterrain->base_time,
                            "%s.base_time    sz_strlcpy(pbase->act_gfx_altact_gfx_alt    const char *special;

    sz_strlcpy(proad "%s.graphic", section));
    sz_strlcpy(proad->graphic_altgraphic_alt", section));
    sz_strlcpy(proad    sz_strlcpy(proad->act_gfx_altact_gfx_alt", section))    proad->build_time = secfile_lookup_int_default(file, 0, "%s.build_time", section);

    proad->buildable = secfile_lookup_bool_default(file, TRUE,
 roadoutput_type_iterate(o) {
      proad->tile_incr[o] =
        secfile_lookup_int_default(file, 0, "%s.%s_incr",
                                   section, get_output_identifier(o));
      proad->tile_bonus[o] =
        secfile_lookup_int_default(file, 0, "%s.%s_bonus",
                                   section, get_output_identifier(o));
    } output_type_iterate_end;pecial = secfile_lookup_str_default(file, "None", "%s.compat_special", section);
    if (!fc_strcasecmp(special, "Road")) {
      if (compat_road) {
        ruleset_error(LOG_FATAL, "Multiple roads marked as compatibility \"Road\"");
      }
      compat_road = TRUE;
      proad->compat = ROCO_ROAD;
    } else if (!fc_strcasecmp(special, "Railroad")) {
      if (compat_rail) {
        ruleset_error(LOG_FATAL, "Multiple roads marked as compatibility \"Railroad\"");
      }
      compat_rail = TRUE;
      proad->compat = ROCO_RAILROAD;
    } else if (!fc_strcasecmp(special, "None")) {
      proad->compat = ROCO_NONE;
    } else {
      ruleset_error(LOG_FATAL, "Illegal compatibility special \"%s\" for road %s",
                    special, road_rule_name(proad));
    }
    slist = secfile_lookup_str_vec(file, &nval, "%s.hidden_by", section);
    BV_CLR_ALL(proad->hidden_byconst struct road_type *top = road_type_by_rule_name(sval);

      if (top == NULL) {
        ruleset_error(LOG_FATAL, "\"%s\" road \"%s\" hidden by unknown roadval);
      } else {
        BV_SET(proad->hidden_by, road_index(top));
      }
    }
    free(slist);

    slist = secfile_lookup_str_vec(file, &nval, "%s.flags", section);
    BV_CLR_ALL(proadroad_flag_id flag = road_flag_id_by_name(sval, fc_strcasecmp);

      if (!road_flag_id_is_valid(flag)) {
        ruleset_error(LOG_FATAL, "\"%s\" road \"%s\": unknown flagval);
      } else {
        BV_SET(proad->flags, flag);
      }
    }
    free(slist);

    proad->helptext = lookup_strvec(file, section, "helptext");
†  „Ó	„ècƒ„€L H… €¡2 V×@š H… €ƒV L£@€q ˆ< € FÆ< —<ˆ}€ ¦ 0€  ¯Æ<€a 0õ5€e ”^öb€B •T‹_‘ %¡7€i ‚6£½ h¥/€‚Z …D¦u€  ‚¬6 ‘x®y À+Àp Œa‚‚,€‚V Žj‚	€•H ‰Z‚m€„e ‹x‚§Mž ‰ ‚³8€‚q a‚ì:  ‚½A™ …‚ÝA€- …o‚ã 2‚é#­ ‰n‚øN€„  ,ƒ‚[€4 &ƒ„º ‚¥x€‚9 q‚Ói€‚( a‚ì:€F ‚¥x€ƒ X×@ ›=ƒ…<„ §-ƒ¡ƒ H… €ˆ, Sƒ’ ¢ ƒÈS­ ƒÉ|‰ ‚ƒË€^ UƒÍr€‚ TƒÐ3€a ‚[ƒÑZ€f ‚ZƒÕ)€M KƒØx€ƒ? Sƒ’  iƒÝ/˜ ‚pƒß€A ƒ;ƒâ7€V ƒåd The
  malloc'ed city name list (which is all filled out) will be returned.
****/
static void load_city_name_list(struct section_file *file,
                                struct nation_type *pnation,
                                const char *secfile_str1,
                                const char *secfile_str2)
{
  size_t dim, j;
  const char **cities = secfile_lookup_str_vec(file, &dim, "%s.%s",
                                               secfile_str1, secfile_str2);

  /* Each string will be of the form "<cityname> (<label>, <label>, ...)".
   * The cityname is just the name for this city, while each "label" matches
   * a terrain type for the city (or "river"), with a preceeding ! to negate
   * it. The parentheses are optional (but necessary to have the settings,
   * of course). Our job is now to parse it. */
  for (j = 0; j < dim; j++) {
    size_t len = strlen(cities[j]);
    char city_name[len + 1], *p, *next, *end;
    struct nation_city *pncity;

    sz_strlcpy(city_name, cities[j]);

    /* Now we wish to determine values for all of the city labels. A value
     * of NCP_NONE means no preference (which is necessary so that the use
     * of this is optional); NCP_DISLIKE means the label is negated and
     * NCP_LIKE means it's labelled. Mostly the parsing just involves
     * a lot of ugly string handling... */
    if ((p = strchr(city_name, '('))) {
      *p++ = '\0';

      if (!(end = strchr(p, ')'))) {
        ruleset_error(LOG_ERROR, "\"%s\" [%s] %s: city name \"%s\" "
                      "unmatched parenthesis.", secfile_name(file),
                      secfile_str1, secfile_str2, cities[j]);
      }

      for (*end++ = '\0'; '\0' != *end; end++) {
        if (!fc_isspace(*end)) {
          ruleset_error(LOG_ERROR, "\"%s\" [%s] %s: city name \"%s\" "
                        "contains characthers after last parenthesis, "
                        "ignoring...", secfile_name(file), secfile_str1,
                        secfile_str2, cities[j]);
        }
      }
    }

    /* Build the nation_city. */
    remove_leading_trailing_spaces(city_name);
    if (check_name(city_name)) {
      /* The ruleset contains a name that is too long. This shouldn't
       * happen - if it does, the author should get immediate feedback. */
      ruleset_error(LOG_ERROR, "\"%s\" [%s] %s: city name \"%s\" "
                    "is too long; shortening it.", secfile_name(file),
                    secfile_str1, secfile_str2, city_name);
      city_name[MAX_LEN_NAME - 1] = '\0';
    }
    pncity = nation_city_new(pnation, city_name);

    if (NULL != p) {
      /* Handle the labels one at a time. */
      do {
        enum nation_city_preference prefer;

        if ((next = strchr(p, ','))) {
          *next = '\0';
        }
        remove_leading_trailing_spaces(p);

        /* The ! is used to mark a negative, which is recorded with
         * NCP_DISLIKE. Otherwise we use a NCP_LIKE.
         */
        if (*p == '!') {
          p++;
          prefer = NCP_DISLIKE;
        } else {
          prefer = NCP_LIKE;
        }

        if (0 == fc_strcasecmp(p, "river")) {
          nation_city_set_river_preference(pncity, prefer);
        } else {
          const struct terrain *pterrain = terrain_by_rule_name(p);

          if (NULL == pterrain) {
            /* Try with removing frequent trailing 's'. */
            size_t l = strlen(p);

            if (0 < l && 's' == fc_tolower(p[l - 1])) {
              p[l - 1] = '\0';
            }
            pterrain = terrain_by_rule_name(p);
          }

          if (NULL != pterrain) {
            nation_city_set_terrain_preference(pncity, pterrain, prefer);
          } else {
            /* Nation authors may use terrains like "lake" that are
             * available in the default ruleset but not in civ1/civ2.
             * In normal use we should just ignore hints for unknown
             * terrains, but nation authors may want to know about this
             * to spot typos etc. */
             log_verbose("\"%s\" [%s] %s: terrain \"%s\" not found;"
                         " skipping it.",
                         secfile_name(file), secfile_str1, secfile_str2, p);
          }
        }

        p = next ? next + 1 : NULL;
      } while (NULL != p && '\0' != *p);
    }
  }

  if (NULL != cities) {
    free(citiesLoad nations.ruleset file
**/
static void load_ruleset_nations(struct section_file *file)
{
  struct government *gov;
  int j;
  size_t dim;
  char temp_name[MAX_LEN_NAME];
  const char **vec;
  const char *name, *bad_leader;
  int barb_land_count = 0;
  int barb_sea_count = 0;
  bool warn_city_style;
  const char *sval;
  struct government *default_government = NULL;
  const char *filename = secfile_name(file);
  struct section_list *sec;
  int default_traits[TRAIT_COUNT];
  enum trait tr;

  warn_city_style
    = secfile_lookup_bool_default(file, TRUE,
				  "compatibility.warn_city_style");

  ruleset_load_traits(default_traits, file, "default_traits", "");
  for (tr = trait_begin(); tr != trait_end(); tr = trait_next(tr)) {
    if (default_traits[tr] < 0) {
      default_traits[tr] = TRAIT_DEFAULT_VALUE;
    }
  }

  sval = secfile_lookup_str_default(file, NULL,
                                    "compatibility.default_government");
  if (sval != NULL) {
    default_government = government_by_rule_name(sval);
  }

  set_allowed_nation_groups(NULL);

  sec = secfile_sections_by_name_prefix(file, NATION_SET_SECTION_PREFIX);
  if (sec) {
    section_list_iterate(sec, psection) {
      struct nation_group *pset;

      name = secfile_lookup_str(file, "%s.name", section_name(psection));
      if (NULL == name) {
        ruleset_error(LOG_FATAL, "Error: %s", secfile_error());
      }
      pset = nation_group_new(name);
      nation_group_set_set(pset, TRUE);
    } section_list_iterate_end;
    section_list_destroy(sec);
  }

  sec = secfile_sections_by_name_prefix(file, NATION_GROUP_SECTION_PREFIX);
  section_list_iterate(sec, psection) {
    struct nation_group *pgroup;

    name = secfile_lookup_str(file, "%s.name", section_name(psection));
    if (NULL == name) {
      ruleset_error(LOG_FATAL, "Error: %s", secfile_error());
    }
    pgroup = nation_group_new(name);
    if (!secfile_lookup_int(file, &j, "%s.match", section_name(psection))) {
      ruleset_error(LOG_FATAL, "Error: %s", secfile_error());
    }
    nation_group_set_match(pgroup, j);
  } section_list_iterate_end;
  section_list_destroy(sec);

  sec = secfile_sections_by_name_prefix(file, NATION_SECTION_PREFIX);
  nations_iterate(pnation) {
    struct nation_type *pconpnation == pconflict) {
        ruleset_error(LOG_ERROR, "Nation %s conflicts with itself",
                      nation_rule_name(pnation));
      } elseNation player color preference, if any */
    fc_assert_ret(pnation->server.rgb == NULL);
    rgbcolor_load(file, &pnation->server.rgb, "%s.color", sec_name);pconflict == pnation) {
        ruleset_error(LOG_ERROR, "Nation %s is its own civil war nation",
                      nation_rule_name(pnation));
      } elsegame.info.pop_report_zeroes =
    secfile_lookup_int_default(file, 1, "parameters.pop_report_zerogame.info.citizen_convert_speed =
    secfile_lookup_int_default(file, 50, "citizen.convert_speed");
type", sec_name);
    if (type == NULL) {
      /* Backward compatibility. Field used to be named "name" */
      type = secfile_lookup_str(file, "%s.name", sec_name);
    }
    if (type == NULLconst char *rsdir  struct section_list *sec;
  int nval;
  const char *name;

  file = openload_ruleset_file("game", rsdirtext = secfile_lookup_str_default(file, text, "tileset.prefersoundset */
  text = secfile_lookup_str_default(file, "", "soundset.prefered");
  text = secfile_lookup_str_default(file, text, "soundset.preferred");
  if (text[0] != '\0') {
    /* There was soundset suggestion */
    sz_strlcpy(game.control.prefered_soundset, text);
  } else {
    /* No soundset suggestions */
    game.control.prefered_sound  game.control.popup_tech_help = secfile_lookup_bool_default(file, FALSE,
                                                             "options.popup_tech_help"sval = secfile_lookup_str(file, "research.free_tech_method");
  game.info.free_tech_method = free_tech_method_by_name(sval, fc_strcasecmp);
  if (!free_tech_method_is_valid(game.info.free_tech_method)) {
    log_error("Bad value %s for free_tech_method. Using "
              "\"Goal\".", sval);
    game.info.free_tech_method = FTM_GOAL;
  }c = secfile_sections_by_name_prefix(file, DISASTER_SECTION_PREFIX);
  nval = (NULL != sec ? section_list_size(sec) : 0);
  if (nval > MAX_DISASTER_TYPES) {
    ruleset_error(LOG_FATAL, "\"%s\": Too many disaster types (%d, max %d)",
                  filename, nval, MAX_DISASTER_TYPES);
  }
  game.control.num_disaster_types = nval;

  disaster_type_iterate(pdis) {
    int id = disaster_index(pdis);
    int j;
    size_t eff_count;
    struct requirement_vector *reqs;
    const char *sec_name = section_name(section_list_get(sec, id));

    ruleset_load_names(&pdis->name, file, sec_name);

    reqs = lookup_req_list(file, sec_name, "reqs", disaster_rule_name(pdis));
    requirement_vector_copy(&pdis->reqs, reqs);

    reqs = lookup_req_list(file, sec_name, "nreqs", disaster_rule_name(pdis));
    requirement_vector_copy(&pdis->nreqs, reqs);

    pdis->frequency = secfile_lookup_int_default(file, 10, "%s.frequency",
                                                 sec_name);

    svec = secfile_lookup_str_vec(file, &eff_count, "%s.effects", sec_name);

    BV_CLR_ALL(pdis->effects);
    for (j = 0; j < eff_count; j++) {
      const char *sval = svec[j];
      enum disaster_effect_id effect;

      effect = disaster_effect_id_by_name(sval, fc_strcasecmp);

      if (!disaster_effect_id_is_valid(effect)) {
        ruleset_error(LOG_FATAL,
                      "\"%s\" disaster \"%s\": unknown effect \"%s\".",
                      filename,
                      disaster_rule_name(pdis),
                      sval);
      } else {
        BV_SET(pdis->effects, effect);
      }
    }

    free(svec);
  } disaster_type_iterate_end;

  for (i = 0; (name = secfile_lookup_str_default(file, NULL,
                                                 "trade.settings%d.type",
                                                 i)); i++) {
    enum trade_route_type type = trade_route_type_by_name(name);

    if (type == TRT_LAST) {
      ruleset_error(LOG_FATAL,
                    "\"%s\" unknown trade route type \"%s\".",
                    filename, name);
    } else {
      struct trade_route_settings *set = trade_route_settings_by_type(type);
      const char *cancelling;

      set->trade_pct = secfile_lookup_int_default(file, 100,
                                                  "trade.settings%d.pct", i);
      cancelling = secfile_lookup_str_default(file, "Active",
                                              "trade.settings%d.cancelling", i);
      set->cancelling = traderoute_cancelling_type_by_name(cancelling);
      if (set->cancelling == TRI_LAST) {
        ruleset_error(LOG_FATAL,
                      "\"%s\" unknown traderoute cancelling type \"%s\".",
                      filename, cancelling);
      }
    }
  }struct packet_ruleset_unit_flag fpacket;
  int i;

  for (i = 0; i < MAX_NUM_USER_UNIT_FLAGS; i++) {
    const char *flagname;
    const char *helptxt;

    fpacket.id = i + UTYF_USER_FLAG_1;

    flagname = unit_type_flag_id_name(i + UTYF_USER_FLAG_1);
    if (flagname == NULL) {
      fpacket.name[0] = '\0';
    } else {
      sz_strlcpy(fpacket.name, flagname);
    }

    helptxt = unit_type_flag_helptxt(i + UTYF_USER_FLAG_1);
    if (helptxt == NULL) {
      fpacket.helptxt[0] = '\0';
    } else {
      sz_strlcpy(fpacket.helptxt, helptxt);
    }

    lsend_packet_ruleset_unit_flag(dest, &fpacket);
  }convert_time = u->convert_time
    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;

      lsend_packet_ruleset_unit_bonus(dest, &bonuspacket);
    } combat_bonus_list_iterate_end;
  } unittclass = pterrain->tclassoutput_type_iterate(o) {
      packet.road_output_incr_pct[o] = pterrain->road_output_incr_pct[o];
    } output_type_iterate_end;

    packet.base_time = pterrain->base_timesz_strlcpy(packet.act_gfx_alt, b->act_gfx_altsz_strlcpy(packet.graphic_str, r->graphic_str);
    sz_strlcpy(packet.graphic_alt, r->graphic_alt);
    sz_strlcpy(packet.activity_gfx, r->activity_gfx);
    sz_strlcpy(packet.act_gfx_alt, r->act_gfx_alt);

    packet.move_cost = r->move_cost;
    packet.build_time = r->build_time;
    packet.buildable = r->buildable;
    packet.pillageable = r->pillageable;

    output_type_iterate(o) {
      packet.tile_incr[o] = r->tile_incr[o];
      packet.tile_bonus[o] = r->tile_bonus[o];
    } output_type_iterate_endcompat = r->compat;

    packet.native_to = r->native_to;
    packet.hidden_by = r->hidden_by;
    packet.flags = r->flags;

    PACKET_STRVEC_COMPUTE(packet.helptext, r->helptext)disaster ruleset information (all individual disaster typedisasters(struct conn_list *dest)
{
  struct packet_ruleset_disaster packet;

  disaster_type_iterate(d) {
    int j;
    packet.id = disaster_number(d);

    sz_strlcpy(packet.name, untranslated_name(&d->name));
    sz_strlcpy(packet.rule_name, rule_name(&d->name));

    j = 0;
    requirement_vector_iterate(&d
    j = 0;
    requirement_vector_iterate(&d->nreqs, preq) {
      packet.nreqs[j++] = *preq;
    } requirement_vector_iterate_end;
    packet.nreqs_count = j;

    packet.frequency = d->frequency;

    packet.effects = d->effects;

    lsend_packet_ruleset_disaster(dest, &packet);
  } disaster
  Send the disaster ruleset information (all individual disaster typetrade_routes(struct conn_list *dest)
{
  struct packet_ruleset_trade packet;
  enum trade_route_type type;

  for (type = TRT_NATIONAL; type < TRT_LAST; type++) {
    struct trade_route_settings *set = trade_route_settings_by_type(type);

    packet.id = type;
    packet.trade_pct = set->trade_pct;
    packet.cancelling = set->cancelling;

    lsend_packet_ruleset_trade(dest, &packetTECHs.
**/
bool load_rulesets(const char *restore)
{
  if (load_rulesetdir(game.server.rulesetdir)) {
    return TRUE;
  }

  /* Fallback to previous one. */
  if (restore != NULL) {
    if (load_rulesetdir(restore)) {
      sz_strlcpy(game.server.rulesetdir, restore);

      /* We're in sane state as restoring previous ruleset succeeded,
       * but return failure to indicate that this is not what caller
       * wanted. */
      return FALSE;
    }
  }

  /* Fallback to default one, but not if that's what we tried already */
  if (strcmp(GAME_DEFAULT_RULESETDIR, game.server.rulesetdir)
      && (restore == NULL || strcmp(GAME_DEFAULT_RULESETDIR, restore))) {
    if (load_rulesetdir(GAME_DEFAULT_RULESETDIR)) {
      /* We're in sane state as fallback ruleset loading succeeded,
       * but return failure to indicate that this is not what caller
       * wanted. */
      sz_strlcpy(game.server.rulesetdir, GAME_DEFAULT_RULESETDIR);

      return FALSE;
    }
  }

  /* Cannot load even default ruleset, we're in completely unusable state */
  exit(EXIT_FAILURE)Loads the rulesets from directory.static bool load_rulesetdir(const char *rsdir  bool ok, rsdir);
  load_tech_names(techfile);

  buildfile = openload_ruleset_file("buildings", rsdir, rsdir);
  load_government_names(govfile);

  unitfile = openload_ruleset_file("units", rsdir);
  load_unit_names(unitfile);

  terrfile = openload_ruleset_file("terrain", rsdir);
  load_terrain_names(terrfile);

  cityfile = openload_ruleset_file("cities", rsdir, rsdir);
  load_nation_names(nationfile);

  effectfile = openload_ruleset_file("effects", rsdirrsdir);

  /* Init nations we just loaded. */
  init_available_nations();

  ok = sanity_check_rulesetif (ok) {
    script_server_free();

    script_server_init();

    ok = openload_script_file("default", rsdir)
      && openload_script_file("script", rsdir);
  }

  if (ok) {
    precalc_tech_data();

    adv_units_ruleset_init();
    CALL_FUNC_EACH_AI(units_ruleset_init);

    /* We may need to adjust the number of AI players
     * if the number of available nations changed. */
    if (game.info.aifill > server.playable_nations) {
      log_normal(_("Reducing aifill because there "
                   "are not enough playable nations."));
      game.info.aifill = server.playable_nations;
      aifill(game.info.aifill);
    }
  }

  return ok, game.server.rulesetdir/* ruleset_control also indicates to client that ruleset sending starts. */
  send_ruleset_control(dest);

  send_ruleset_game(dest);
  send_ruleset_disasters(dest);
  send_ruleset_trade_routesIndicate client that all rulesets have now been sent. */
  lsend_packet_rulesets_readyENDREP
id: 8w.5ck.r22239/25772
type: file
pred: 8w.5ck.r22230/357
count: 576
text: 22239 0 25741 181347 7d1baa0f6230f338e65dc76905e4e36d
props: 11085 367 112 0 7f6d12fc80ead5cc285da723cb8caa9d
cpath: /trunk/server/ruleset.c
copyroot: 15280 /trunk

PLAIN
K 11
Makefile.am
V 24
file 5q.5ck.r21872/18138
K 8
advisors
V 23
dir 4n2.5ck.r21955/1304
K 9
aiiface.c
V 23
file 4gm.5ck.r21902/109
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.r22030/22058
K 11
barbarian.h
V 24
file lx.5ck.r18054/18407
K 14
citizenshand.c
V 24
file 6mz.5ck.r21958/1131
K 14
citizenshand.h
V 24
file 6n0.5ck.r21434/4374
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.r22228/29457
K 11
citytools.h
V 23
file 4h.5ck.r21726/5658
K 10
cityturn.c
V 24
file 4i.5ck.r22228/29700
K 10
cityturn.h
V 23
file 4j.5ck.r21808/3931
K 11
civserver.c
V 23
file 4k.5ck.r21887/5564
K 11
civserver.h
V 21
file 4l.0.r2805/33121
K 10
commands.c
V 24
file 2ly.5ck.r21821/1908
K 10
commands.h
V 24
file 2lz.5ck.r21821/2153
K 13
connecthand.c
V 23
file 2dw.5ck.r21926/135
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.r22030/22792
K 11
diplomats.h
V 23
file w0.5ck.r19106/3619
K 10
edithand.c
V 24
file 3bk.5ck.r22134/1292
K 10
edithand.h
V 26
file 4ez.5ck.r18452/115476
K 6
fcdb.c
V 23
file 6l3.5ck.r21489/222
K 6
fcdb.h
V 25
file 6l4.5ck.r21255/12759
K 10
gamehand.c
V 24
file 4o.5ck.r21918/10897
K 10
gamehand.h
V 24
file 4p.5ck.r15698/24111
K 9
generator
V 23
dir 2me.5ck.r22237/2224
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 22
file 13.5ck.r22201/990
K 9
maphand.h
V 23
file 14.5ck.r22019/3196
K 6
meta.c
V 22
file 4s.5ck.r22204/237
K 6
meta.h
V 24
file 4t.5ck.r18054/19078
K 8
notify.c
V 25
file 4i2.5ck.r20229/25959
K 8
notify.h
V 24
file 4i3.5ck.r18282/3660
K 9
plrhand.c
V 22
file 4u.5ck.r22068/956
K 9
plrhand.h
V 23
file 4v.5ck.r22068/1195
K 8
report.c
V 24
file vi.5ck.r21823/40810
K 8
report.h
V 24
file vj.5ck.r18270/29203
K 10
rssanity.c
V 24
file hew.5ck.r22207/2950
K 10
rssanity.h
V 25
file hey.5ck.r21709/23329
K 9
ruleset.c
V 24
file 8w.5ck.r22239/25772
K 9
ruleset.h
V 24
file 8x.5ck.r22222/16112
K 13
sanitycheck.c
V 22
file wi.5ck.r21813/276
K 13
sanitycheck.h
V 24
file wj.5ck.r20315/26296
K 10
savegame.c
V 24
file vl.5ck.r22222/16786
K 10
savegame.h
V 24
file vm.5ck.r20758/19233
K 11
savegame2.c
V 25
file 4m0.5ck.r22222/16355
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.r22218/17026
K 8
sernet.c
V 23
file 15.5ck.r20559/1478
K 8
sernet.h
V 24
file 4y.5ck.r19197/31924
K 10
settings.c
V 25
file 2m0.5ck.r22221/24330
K 10
settings.h
V 24
file 2m1.5ck.r20244/5486
K 11
spacerace.c
V 24
file 9a.5ck.r19268/77290
K 11
spacerace.h
V 21
file 9b.0.r11338/1129
K 9
srv_log.c
V 25
file 15t.5el.r20229/25451
K 9
srv_log.h
V 25
file 15u.5em.r20315/26035
K 10
srv_main.c
V 24
file vg.5ck.r22222/15621
K 10
srv_main.h
V 23
file vh.5ck.r22134/1051
K 11
stdinhand.c
V 24
file 4z.5ck.r22222/16540
K 11
stdinhand.h
V 23
file 50.5ck.r18978/5769
K 11
techtools.c
V 25
file 33n.5ck.r22161/12606
K 11
techtools.h
V 25
file 33o.5ck.r21976/23870
K 10
unithand.c
V 22
file 18.5ck.r22234/118
K 10
unithand.h
V 24
file 19.5ck.r21095/21648
K 11
unittools.c
V 23
file 1a.5ck.r22215/5945
K 11
unittools.h
V 23
file 1b.5ck.r22169/4578
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.r22239/29726
type: dir
pred: z.5ck.r22237/6176
count: 4946
text: 22239 26013 3700 3700 2cb223044189498b027821c9a8c078bf
props: 17175 659 139 0 d1c9699dde7f9d81e54426750008041d
cpath: /trunk/server
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.r20415/4358289
K 7
INSTALL
V 22
file 6.5ck.r22211/1040
K 11
Makefile.am
V 22
file 59.5ck.r22212/711
K 4
NEWS
V 22
file 6m.5ck.r21786/165
K 6
README
V 20
file 7.0.r4421/96382
K 2
ai
V 22
dir 8.5ck.r22199/27852
K 10
autogen.sh
V 24
file 12o.5ck.r22211/1267
K 9
bootstrap
V 23
dir 2p5.5ck.r22212/2098
K 6
client
V 22
dir d.5ck.r22229/10008
K 6
common
V 21
dir p.5ck.r22231/7073
K 12
configure.ac
V 23
file 149.5ck.r22211/803
K 4
data
V 21
dir w.5ck.r22238/3803
K 6
debian
V 22
dir 5w.5ck.r22191/3141
K 12
dependencies
V 23
dir 2yu.5ck.r21897/1754
K 11
diff_ignore
V 24
file qq.5ck.r21039/26581
K 3
doc
V 22
dir k7.5ck.r22197/2040
K 10
fc_version
V 25
file 2lo.5en.r22228/29208
K 2
m4
V 23
dir 12p.5ck.r22118/2975
K 2
po
V 25
dir fs.5ck.r22224/1883521
K 7
scripts
V 22
dir 2yo.5ck.r21694/735
K 6
server
V 22
dir z.5ck.r22239/29726
K 5
tests
V 22
dir 2g9.5ck.r22096/825
K 5
tools
V 24
dir 4pj.5js.r22222/15386
K 7
utility
V 23
dir 1c.5ck.r22231/10244
K 3
vms
V 25
dir u9.5ck.r21528/1396085
K 5
win32
V 23
dir 2eu.5ck.r21785/1378
END
ENDREP
id: 3.5ck.r22239/31150
type: dir
pred: 3.5ck.r22238/5225
count: 15983
text: 22239 29957 1180 1180 6e176d07e1626d33cea6baf56fe03327
props: 20140 3888 282 0 e4bb46e81629a60eef613b169b23a9ea
cpath: /trunk
copyroot: 15280 /trunk

PLAIN
K 8
branches
V 19
dir 1.0.r22236/6993
K 4
tags
V 19
dir 2.0.r22067/5911
K 5
trunk
V 22
dir 3.5ck.r22239/31150
K 7
website
V 18
dir 3ge.0.r12388/0
END
ENDREP
id: 0.0.r22239/31539
type: dir
pred: 0.0.r22238/5611
count: 22239
text: 22239 31376 150 150 be8e29ca718f3111f41a28bf722551b9
cpath: /
copyroot: 0 /

8w.5ck.t22238-1 modify true false /trunk/server/ruleset.c


31539 31688