Freeciv

if (state) {

fc_snprintf(buffer, sizeof(buffer), "%s(%s)",

return buffer;

} else {

return improvement_name_translation(pimprove);

**************************************************************************/

bool can_city_build_improvement_now(const struct city *pcity,

const struct impr_type *pimprove)

if (!can_city_build_improvement_direct(pcity, pimprove)) {

return FALSE;

}

}

/**********************************************************************//**

is obsolete.

**************************************************************************/

bool can_city_build_unit_direct(const struct civ_map *nmap,

}

/**********************************************************************//**

obsolete.

**************************************************************************/

bool can_city_build_unit_now(const struct civ_map *nmap,

}

/**********************************************************************//**

**************************************************************************/

bool can_city_build_later(const struct civ_map *nmap,

const struct city *pcity,

void city_choose_build_default(const struct civ_map *nmap, struct city *pcity)

{

if (NULL == city_tile(pcity)) {

* target could fail. This currently might happen during map editing.

* FIXME: assumes the first unit is always "valid", so check for

* obsolete units elsewhere. */

const struct impr_type *pimprove)

{

if (NULL == pimprove) {

* valid_improvement_by_number() */

return FALSE;

}

}

}

* get_tile_output_bonus(pcity, ptile, output,

/ 100;

if (penalty_limit > 0 && prod > penalty_limit) {

if (prod <= game.info.granularity) {

}

/**********************************************************************//**

You don't have to free the return pointer.

**************************************************************************/

const char *city_style_name_translation(const int style)

}

/**********************************************************************//**

location. may_be_on_center determines if a city at x,y counts.

**************************************************************************/

bool city_exists_within_max_city_map(const struct civ_map *nmap,

*angry = MIN(base_angry, size - spes);

/* Create unhappy citizens. In the beginning, all who are not content,

* buildings later. */

*unhappy = (size - spes - *content - *angry);

}

/**********************************************************************//**

* angry citizen are eliminated first

* then content are made happy, then unhappy content, etc.

* each conversions costs 2 or 4 luxuries.

}

/**********************************************************************//**

returns the health penalty in tenth of percent which depends on the size

of both cities. The health penalty is given as the product of the ruleset

option 'game.info.illness_trade_infection' (in percent) and the square

/* Calculate city production!

*

* This is a rather complicated process if we allow rules to become

* loops, but there are some dependencies that do not follow strict

* trade taxes can be counted up, which must occur before the science bonus

* this case the bonuses are multiplied on twice (but only saved the second

* time).

*/

if (settings->cancelling == TRI_ACTIVE) {

can_trade = TRUE;

}

if (can_trade) {

int value;

{

log_debug("Improvement %s removed from city %s",

improvement_rule_name(pimprove), pcity->name);

pcity->built[improvement_index(pimprove)].turn = I_DESTROYED;

if (is_server() && is_wonder(pimprove)) {

bool was_happy;

bool had_famine;

int turn_founded;

int turn_last_built;

double def_P_lose1 = 1 - att_P_lose1;

/*

binomial_coeff(def_N_lose-1 + lr, lr)

* def_P_lose1^(def_N_lose-1)

*def_fp = MIN(*def_fp, game.info.low_firepower_pearl_harbor);

}

* When attacked by fighters, helicopters have their firepower

* reduced to low firepower bonus.

*/

}

/*******************************************************************//**

had enough luck and EFT_NUKE_PROOF.

If the attack was successful return NULL.

***********************************************************************/

/*******************************************************************//**

return the modified defense power of a unit.

being attacked by a missile gets defense 288.

***********************************************************************/

int get_total_defense_power(const struct unit *attacker,

Freeciv - Copyright (C) 1996 - A Kjeldberg, L Gregersen, P Unold

This program is free software; you can redistribute it and/or modify

it under the terms of the GNU General Public License as published by

}

#endif /* __cplusplus */

&& diplomacy_possible(pplayer,aplayer)

&& get_player_bonus(pplayer, EFT_NO_DIPLOMACY) <= 0

&& get_player_bonus(aplayer, EFT_NO_DIPLOMACY) <= 0

|| player_has_embassy(pplayer, aplayer)

|| player_diplstate_get(pplayer, aplayer)->contact_turns_left

> 0

log_error("Illegal tech value %i in clause.", val);

return FALSE;

}

if (is_pact_clause(type)

&& ((ds == DS_PEACE && type == CLAUSE_PEACE)

|| (ds == DS_ARMISTICE && type == CLAUSE_PEACE)

/* we already have this diplomatic state */

log_error("Illegal treaty suggested between %s and %s - they "

"already have this treaty level.",

nation_rule_name(nation_of_player(ptreaty->plr1)));

return FALSE;

}

pclause->type = type;

pclause->from = pfrom;

pclause->value = val;

clause_list_append(ptreaty->clauses, pclause);

ptreaty->accept0 = FALSE;

}

/**********************************************************************//**

Now also initialise sorted_events[].

**************************************************************************/

void events_init(void)

}

/**********************************************************************//**

**************************************************************************/

void events_free(void)

{

if (extra_has_flag(pextra, EF_AUTO_ON_CITY_CENTER)) {

struct tile *vtile = tile_virtual_new(ptile);

tile_remove_extra(vtile, pextra);

if (player_can_build_extra(pextra, city_owner(pcity), vtile)) {

/* No need to worry about conflicting extras - extra would had

}

return stop - featured_text + 1;

}

/**********************************************************************//**

Separate the text from the text features. 'tags' can be nullptr.

* Full name sequence: [strike] ... [/strike]

* Abbreviation sequence: [s] ... [/s]

* Text tag type: TTT_STRIKE

* - Underline.

* Full name sequence: [underline] ... [/underline]

* Abbreviation sequence: [u] ... [/u]

#define FT_OFFSET_UNSET ((ft_offset_t) -1)

/* Opaque type. */

/* Define struct text_tag_list. */

#define SPECLIST_TAG text_tag

#define SPECLIST_TYPE struct text_tag

#define text_tag_list_iterate(tags, ptag) \

TYPED_LIST_ITERATE(struct text_tag, tags, ptag)

char *helptxt;

};

#define TURNS_NEEDED_TO_RANK 10

struct civ_game {

}

/**********************************************************************//**

You don't have to free the return pointer.

**************************************************************************/

const char *government_name_translation(const struct government *pgovern)

}

/**********************************************************************//**

You don't have to free the return pointer.

**************************************************************************/

const char *government_name_for_player(const struct player *pplayer)

}

/**********************************************************************//**

You don't have to free the return pointer.

**************************************************************************/

const char *improvement_name_translation(const struct impr_type *pimprove)

}

/* Check if particular building can be solt */

&& !can_city_sell_building(pcity, pimprove)) {

return TR_OTHER_FAILURE;

}

astr_str(&defaults[MAPDEF_TURNS]), astr_str(&defaults[MAPDEF_ZOOM]),

astr_str(&defaults[MAPDEF_MAP]),

astr_str(&str_format), astr_str(&str_showplr));

mapdef_destroy(pmapdef);

astr_free(&str_format);

astr_free(&str_showplr);

int x, int y)

{

int nat_x, nat_y;

MAP_TO_NATIVE_POS(&nat_x, &nat_y, x, y);

*base_x = nat_x * TILE_SIZE + ((nat_y % 2) ? TILE_SIZE / 2 : 0);

}

/************************************************************************//**

You don't have to free the return pointer.

****************************************************************************/

const char *nation_adjective_translation(const struct nation_type *pnation)

}

/************************************************************************//**

You don't have to free the return pointer.

****************************************************************************/

const char *nation_plural_translation(const struct nation_type *pnation)

}

/************************************************************************//**

You don't have to free the return pointer.

****************************************************************************/

const char *nation_adjective_for_player(const struct player *pplayer)

}

/************************************************************************//**

You don't have to free the return pointer.

****************************************************************************/

const char *nation_plural_for_player(const struct player *pplayer)

ae_contra_close(oreq->contras);

} obligatory_req_vector_iterate_end;

obligatory_req_vector_free(&oblig_hard_reqs_sr[i]);

}

/**********************************************************************//**

fc_strlcat(buf, prefix, bufsz);

if (preq->present) {

cat_snprintf(buf, bufsz,

* nation." */

_("Requires that you are playing %s style nation."),

style_name_translation(preq->source.value.style));

/* TRANS: %s is a list of unit classes separated by "or". */

cat_snprintf(buf, bufsz, Q_("?uclasslist:Requires %s units."),

astr_str(&list));

/* TRANS: %s is a list of unit classes separated by "or". */

cat_snprintf(buf, bufsz, Q_("?uclasslist:Does not apply to "

"%s units."),

struct spaceship_component *fill)

{

fc_assert_ret_val(fill != NULL, FALSE);

if (ship->modules > (ship->habitation + ship->life_support

+ ship->solar_panels)) {

/* "nice" governments prefer to keep success 100%;

int i;

if (!BV_ISSET(ship->structure, 0)) {

fill->type = SSHIP_PLACE_STRUCTURAL;

fill->num = 0;

return TRUE;

}

if (ship->habitation >= 1

&& !BV_ISSET(ship->structure, modules_info[0].required)) {

req = modules_info[0].required;

Freeciv - Copyright (C) 1996 - A Kjeldberg, L Gregersen, P Unold

This program is free software; you can redistribute it and/or modify

it under the terms of the GNU General Public License as published by

use Tech_type_id very widely, and don't use (-1) flag values. (?)

*/

/* [more accurately]

* sometimes add and subtract these numbers.

*/

#define A_NONE 0

bv_tech_flags flags;

struct strvec *helptext;

*/

char *bonus_message;

* be right if game.info.tech_cost_style is TECH_COST_CIV1CIV2. */

double cost;

* Number of requirements this technology has _including_

* itself. Precalculated at server then send to client.

*/

empty_cleared = TRUE;

}

}

/************************************************************************//**

tile_mine(ptile, tgt);

return TRUE;

tile_irrigate(ptile, tgt);

return TRUE;

{

enum unit_activity current = punit->activity;

struct extra_type *target = punit->activity_target;

enum gen_action action = punit->action;

bool result;

enemy unit (that has a ZOC) on a terrain that has zoc rules.

Since this function is used in the client, it has to deal with some

see units inside enemy cities.

**************************************************************************/

bool is_plr_zoc_client(const struct player *pplayer, const struct tile *ptile0,

}

/**********************************************************************//**

**************************************************************************/

static struct unit *base_transporter_for_unit(const struct unit *pcargo,

const struct tile *ptile,

};

enum unit_focus_status {

};

enum goto_route_type {

Return the "happy cost" (the number of citizens who are discontented)

for this unit.

**************************************************************************/

const struct player *pplayer)

{

return ut->happy_cost * get_player_bonus(pplayer, EFT_UNHAPPY_FACTOR);

Freeciv - Copyright (C) 1996 - A Kjeldberg, L Gregersen, P Unold

This program is free software; you can redistribute it and/or modify

it under the terms of the GNU General Public License as published by

}

#endif /* __cplusplus */

Freeciv - Copyright (C) 1996 - A Kjeldberg, L Gregersen, P Unold

This program is free software; you can redistribute it and/or modify

it under the terms of the GNU General Public License as published by

}

#endif /* __cplusplus */

for (i = 0; i < MAX_LEN_WORKLIST; i++) {

/* just setting the entry to zero: */

pwl->entries[i].kind = VUT_NONE;

pwl->entries[i].value.building = NULL;

}

}

/************************************************************************//**

also be used as the next available worklist index (assuming that

len < MAX_LEN_WORKLIST).

****************************************************************************/

void worklist_advance(struct worklist *pwl)

{

worklist_remove(pwl, 0);

/************************************************************************//**

Copy contents from worklist src to worklist dst.

}

/* just setting the entry to zero: */

pwl->entries[pwl->length - 1].kind = VUT_NONE;

pwl->entries[pwl->length - 1].value.building = NULL;

pwl->length--;

}

/************************************************************************//**

the unit/building to be produced; is_unit specifies whether it's a unit or

****************************************************************************/

bool worklist_append(struct worklist *pwl, const struct universal *prod)

{

/************************************************************************//**

Inserts the production at the location idx in the worklist, thus moving

if successful.

****************************************************************************/

bool worklist_insert(struct worklist *pwl, const struct universal *prod,