Freeciv

struct player;

enum winning_strategy {

};

#define SPECENUM_NAME war_reason

#define SPECENUM_VALUE1 DAI_WR_SPACE

#define SPECENUM_VALUE1NAME "Space"

#define SPECENUM_VALUE2 DAI_WR_EXCUSE

player_name(pplayer));

adip->countdown = -10;

break;

dai_diplo_notify(target,

_("*%s (AI)* I have tolerated your vicious antics "

"long enough! To war!"),

"Long live our glorious alliance!"),

player_name(pplayer));

break;

case DAI_WR_EXCUSE:

dai_diplo_notify(ally,

PL_("*%s (AI)* %s has grossly violated their treaties "

&& dai_diplomacy_get(ait, pplayer, aplayer)->countdown == -1) {

DIPLO_LOG(ait, LOG_DIPL2, pplayer, aplayer, "Plans war in revenge");

war_countdown(ait, pplayer, aplayer, map_size_checked(),

}

} players_iterate_end;

if (unit_has_type_flag(punit, UTYF_WORKERS)) {

parameter->get_TB = no_fights;

} else if (long_path && unit_is_cityfounder(punit)) {

* move as far along the path to the destination as we can;

* that is, ignore the presence of enemy units when computing the

* path.

parameter->get_TB = no_fights;

} else if (is_losing_hp(punit)) {

/* Losing hitpoints over time (helicopter in classic rules) */

} else if (utype_may_act_at_all(unit_type_get(punit))) {

switch (unit_data->task) {

case AIUNIT_AUTO_WORKER:

parameter->get_TB = no_fights;

break;

case AIUNIT_NONE:

break;

}

} else {

};

/* Sounds don't sound good on Windows unless the buffer size is 4k,

* such as a delay before playing the sound. */

#ifdef FREECIV_MSWINDOWS

const size_t buf_size = 4096;

{

size_t i;

for (i = 0; i < sum->n; i++) {

fc_assert(sum->sums != NULL);

if ((strcmp(sum->sums[i].posdesc, posdesc) == 0)

lists of patterns. A pattern may be preceded by '!' to have its result

negated.

the filter tooltip in property_page_new().

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

static struct property_filter *property_filter_new(const char *filter)

a|b&c - Matches all properties whose names contain either an "a",

or contain both "b" and "c".

the filter tooltip in property_page_new().

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

static bool property_filter_match(struct property_filter *pf,

lists of patterns. A pattern may be preceded by '!' to have its result

negated.

the filter tooltip in property_page_new().

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

static struct property_filter *property_filter_new(const char *filter)

a|b&c - Matches all properties whose names contain either an "a",

or contain both "b" and "c".

the filter tooltip in property_page_new().

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

static bool property_filter_match(struct property_filter *pf,

lists of patterns. A pattern may be preceded by '!' to have its result

negated.

the filter tooltip in property_page_new().

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

static struct property_filter *property_filter_new(const char *filter)

a|b&c - Matches all properties whose names contain either an "a",

or contain both "b" and "c".

the filter tooltip in property_page_new().

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

static bool property_filter_match(struct property_filter *pf,

bool rbutton_down = FALSE;

bool rectangle_active = FALSE;

button in Area Selection mode. */

bool tiles_hilited_cities = FALSE;

/* More backwards compatibility, for removed options that had been

* folded into then-existing options. Here, the backwards-compatibility

/* Removed in 2.4 */

if (!secfile_lookup_bool_default(sf, TRUE,

views.

NB: The 'layer' argument is NOT a LAYER_* value, but rather one of 0, 1, 2.

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

int fill_basic_terrain_layer_sprite_array(struct tileset *t,

struct drawn_sprite *sprs,

* the negative of the ID of the city or unit that has reserved the

* tile.

*

* positive values encountered, and never attempt to steal a tile

* which has a negative value.

*/

* The intended meaning for EC is "how much we want to avoid this tile",

* see DISCUSSION below for more.

*

* tells us whether we can enter and leave tile as normal (see enum

* tile_behavior).

*

* paths/tiles we want to consider. For example, a trireme might want to

* never enter deep sea. A chariot, would like to find paths going to

* enemy cities but not going _through_ them. This can be achieved

* TB_IGNORE for tiles we don't want to visit and TB_DONT_LEAVE for tiles

* we won't be able to leave (at least alive).

*

*

*

* FORMULAE:

* total_MC = ((turn + 1) * move_rate - moves_left)

*

* For calculating total_CC:

* not guaranteed to get the one with the least steps in it. If you care,

* specifying EC to be 1 will do the job.

* 3. To prevent AI from thinking that it can pass through "chokepoints"

* occupied enemy city to be TB_DONT_LEAVE.

*/

}

/* NB: if there are UTYF_NEVER_PROTECTS units on the tile, 'attack_any'

has to get set TRUE at least once to enable an attack to the tile,

}

} unit_list_iterate_end;

}

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

PF callback to prohibit going into the unknown. Also makes sure we

A callback for amphibious movement

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

static enum tile_behavior

{

struct pft_amphibious *amphibious = param->data;

const bool ferry_move = is_native_tile(amphibious->sea.utype, ptile);

parameter->combined.move_rate = move_rate;

parameter->combined.get_MC = amphibious_move;

parameter->combined.get_move_scope = amphibious_move_scope;

parameter->combined.get_EC = amphibious_extra_cost;

if (parameter->land.is_pos_dangerous != nullptr

|| parameter->sea.is_pos_dangerous != nullptr) {

#define FC__CHAT_H

/* Definitions related to interpreting chat messages.

* server are assumed to agree on these details. */

#ifdef __cplusplus

; Descriptions of nation groups

; These are more cosmetic than sets; they affect the "pick nation" dialog,

; It`s OK to not define any nation groups at all.

; name = name of the group (used adjectivally)

; hidden = TRUE to not include this group in the "pick nation" dialog

; Descriptions of nation groups

; These are more cosmetic than sets; they affect the "pick nation" dialog,

; It`s OK to not define any nation groups at all.

; name = name of the group (used adjectivally)

; hidden = TRUE to not include this group in the "pick nation" dialog

; Descriptions of nation groups

; These are more cosmetic than sets; they affect the "pick nation" dialog,

; It`s OK to not define any nation groups at all.

; name = name of the group (used adjectivally)

; hidden = TRUE to not include this group in the "pick nation" dialog

; Descriptions of nation groups

; These are more cosmetic than sets; they affect the "pick nation" dialog,

; It`s OK to not define any nation groups at all.

; name = name of the group (used adjectivally)

; hidden = TRUE to not include this group in the "pick nation" dialog

these must all be made merely unhappy before any unhappy citizens can \

be made content, but in all other respects behave as unhappy citizens.\

"),

; this. See city_refresh_from_main_map() in common/city.c.

_("\

Luxury makes citizens happy. For every two luxury points a city \

\n\

; Descriptions of nation groups\n\

; These are more cosmetic than sets; they affect the \"pick nation\" dialog,\n\

; It`s OK to not define any nation groups at all.\n\

; name = name of the group (used adjectivally)\n\

; hidden = TRUE to not include this group in the \"pick nation\" dialog\n\

; Descriptions of nation groups

; These are more cosmetic than sets; they affect the "pick nation" dialog,

; It`s OK to not define any nation groups at all.

; name = name of the group (used adjectivally)

; hidden = TRUE to not include this group in the "pick nation" dialog

So the goal of compatibility is mainly used as a limiting factor in

development: when a new feature is added to Freeciv that makes gameplay

different, it is generally implemented in such a way that the

not aiming for absolute 100% compatibility; in particular, we're not

aiming for bug-compatibility.

Tile ownership is decided only by the server, and sent to the clients, which

draw border lines between tiles of differing ownership. Owner information is

sent for all tiles that are known by a client, whether or not they are fogged.

limited information about non-neighboring and unseen enemies, is available

at http://freecivac.sf.net/.

probably better described by statistical mechanics than by logic.

Both ferries and prospective passenger (PP) move around in what looks

like a random fashion, trying to get closer to each other. On

hell to debug but means that small bugs don't affect overall picture

visibly (and stay unfixed as a result).

prior arrangements is the only good strategy -- it means that a boat

will not rely on the PP to notify it when it's not needed anymore.

This is not very effective but can only be changed when the PPs behave

they try to check if the old target is still good before trying to

find a new one.

DIPLOMACY

=========

'diplomacy' server setting.

Easier AI levels propose cease-fire on first contact.

- To play Freeciv normally: don't do anything special; the new

features all have defaults which give the standard Freeciv

- To play a game with rules more like Civ1, start the server with:

./fcser -r data/civ1.serv

/* History can decrease, but never go below zero */

pcity->history = MAX(pcity->history, 0);

city celebrating */

if (!is_happy) {

is_happy = city_happy(pcity);

for (p = 0; p < maxslots; p++) {

l = p / 32;

for (x = 0; x < xsize; x++) {

* on common platforms, information happens not to be lost, just

* oddly arranged. */

if (known_row_old[l * xsize + x] & (1u << (p - l * 8))) {

/* In 2.3.x and prior, saveturns=0 meant no turn-based saves.

* This is now controlled by the "autosaves" setting. */

if (!fc_strcasecmp("saveturns", name)) {

* and settings.c:autosaves_name() (but these defaults reflect

const char *const nosave = "GAMEOVER|QUITIDLE|INTERRUPT";

const char *const save = "TURN|GAMEOVER|QUITIDLE|INTERRUPT";

int nturns;

* knock some levels off. */

lvls = utype_veteran_system(to_unit)->levels - 1;

punit->veteran = MIN(punit->veteran, lvls);

punit->veteran = MAX(punit->veteran - vet_loss, 0);

/* Scale HP and MP, rounding down. Be careful with integer arithmetic,

number of used bytes, used strlen() instead.

NB: 'utf8_string' must be UTF-8 valid (see fc_utf8_validate()), or the

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

size_t fc_utf8_strlen(const char *utf8_string)

{

Iterator base class. "Derived" iterators must have this struct as

their first member (as a "vtable") and provide implementations of the

"pure virtual" member functions. See the function comment headers

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

struct iterator {

void (*next)(struct iterator *it);

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

Test one aspect of randomness, using n numbers.

Tests current random state; saves and restores state, so can call

without interrupting current sequence.

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

RANDOM_STATE saved_state;

int i, old_value = 0, new_value;

bool didchange, olddidchange = FALSE;

saved_state = fc_rand_state();

/* fc_srand(time(nullptr)); */ /* Use current state */

didchange = (new_value != old_value);

if (i > 1) { /* Have olddidchange */

if (didchange != olddidchange) {

} else {

}

}

olddidchange = didchange;

old_value = new_value;

}

log_test("test_random1(%d) same: %d, change: %d",

/* Restore state: */

fc_rand_set_state(saved_state);

truncation occurred.

Not sure about the asserts below, but they are easier than

In particular note that n == 0 is prohibited (e.g., since there

must at least be room for a nul); could consider other options.

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