Freeciv

Freeciv - Copyright (C) 2002 - The Freeciv Project

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

/* Cost of our unit */

unit_cost = unit_build_shield_cost_base(punit);

/* This is to say "wait, ill unit will get better!" */

/* Determine cost of enemy units */

victim_cost = stack_cost(punit, pdefender);

profit = kill_desire(victim_cost, unit_attack, unit_cost, victim_defense, 1)

- SHIELD_WEIGHTING + 2 * TRADE_WEIGHTING;

if (profit > 0) {

game_city_by_number(punit->homecity),

profit, sortie_time, balanced_cost);

log_debug("%s at (%d, %d) is a worthy target with profit " ADV_WANT_PRINTF,

continue;

}

&& !map_is_known_and_seen(ptile, pplayer, V_MAIN)) {

/* The tile is fogged */

continue;

}

} else {

try to attack something

TODO: Distant target selection, support for fuel > 2

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

void dai_manage_airunit(struct ai_type *ait, struct player *pplayer,

if (find_something_to_bomb(ait, nmap, punit, &path, &dst_tile) > 0) {

/* Found target, coordinates are in punit's goto_dest.

* tile to attack from */

fc_assert_ret(path != NULL && dst_tile != NULL);

if (!adv_follow_path(punit, path, dst_tile)) {

}

pf_path_destroy(path);

} else {

unit_rule_name(punit));

def_ai_unit_data(punit, ait)->done = TRUE;

unit_activity_handling(punit, ACTIVITY_IDLE, ACTION_NONE);

/* We are tracking a unit if punit->server.ai->cur_pos is not NULL. If we

* are not tracking, start tracking by setting cur_pos. If we are,

* necessary coordinates to calculate a probable trajectory. */

players_iterate_alive(aplayer) {

if (aplayer == pplayer) {

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

void dai_adjust_policies(struct ai_type *ait, struct player *pplayer)

{

struct adv_data *adv;

adv = adv_data_get(pplayer, NULL);

* previously used one. This is important for diplomacy. - Per */

#define DIPLO_DEFENSE_WANT 3000

struct city *pcity);

static void find_city_to_diplomat(struct player *pplayer, struct unit *punit,

struct unit_type *ut = best_role_unit(pcity, UTYF_DIPLOMAT);

if (ut) {

"A defensive diplomat will be built in city %s.",

city_name_get(pcity));

choice->want = 16000; /* diplomat more important than soldiers */

return;

}

utype_build_shield_cost(pcity, NULL, ut));

if (!player_has_embassy(pplayer, city_owner(acity))

if (aplayer == pplayer || is_barbarian(aplayer)

|| (pplayers_allied(pplayer, aplayer) && has_embassy)) {

}

incite_cost = city_incite_cost(pplayer, acity);

struct city *ctarget = NULL;

struct city *pcity = tile_city(unit_tile(punit));

&& count_diplomats_on_tile(pcity->tile) == 1

&& def_ai_city_data(pcity, ait)->urgency > 0) {

/* Danger and we are only diplomat present - stay. */

Will try to bribe a ship on the coast as well as land stuff.

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

static bool dai_diplomat_bribe_nearby(struct ai_type *ait,

struct unit *punit, struct pf_map *pfm)

{

int gold_avail, expenses;

bribee_tile = mapstep(nmap, pos.tile, DIR_REVERSE(pos.dir_to_here));

path = pf_map_path(pfm, bribee_tile);

|| punit->moves_left <= 0) {

pf_path_destroy(path);

return FALSE;

if (count_diplomats_on_tile(unit_tile(punit)) == 1

&& (city_data->diplomat_threat

|| city_data->urgency > 0)) {

city_name_get(pcity), city_data->urgency);

dai_unit_new_task(ait, punit, AIUNIT_NONE, NULL); /* abort mission */

def_ai_unit_data(punit, ait)->done = TRUE;

}

dai_unit_new_task(ait, punit, task, ctarget->tile);

&& unit_data->task != AIUNIT_NONE);

}

return;

}

|| wonder_city == NULL

|| city_data->distance_to_wonder_city <= 0

|| !city_production_gets_caravan_shields(&wonder_city->production)

fc_assert_ret(VUT_IMPROVEMENT == wonder_city->production.kind);

want /= MAX(dist, 1);

utype_rule_name(unit_type),

city_name_get(wonder_city),

want);

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

Calculate walking distances to wonder city from nearby cities.

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

struct adv_data *adv)

{

struct pf_map *pfm;

struct player *pplayer,

struct city *pcity);

struct adv_data *adv);

#endif /* FC__DAIDOMESTIC_H */

specialists who provide at least HAPPY_COST luxury, being the number of

luxuries needed to make one citizen content or happy.

to become a worker. The benefits from an extra worker are weighed against

the losses from acquiring the two extra luxury.

int factor = 2;

/* Try to build wonders to offset empire size unhappiness */

> get_player_bonus(pplayer, EFT_EMPIRE_SIZE_BASE)) {

if (get_player_bonus(pplayer, EFT_EMPIRE_SIZE_BASE) > 0) {

int step_bonus = get_player_bonus(pplayer, EFT_EMPIRE_SIZE_STEP);

/ MAX(step_bonus, 1);

}

factor += 2;

}

break;

case EFT_AIRLIFT:

* totally braindead. */

v += c + MIN(adv->stats.units.airliftable, 13);

break;

/* The idea being that if we have a full granary, we have an

* automatic surplus of our granary excess in addition to anything

* collected by city workers. */

city_granary_size(city_size_get(pcity) - 1);

}

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

Set tax/science/luxury rates.

TODO: Audit the use of pplayer->ai.maxbuycost in the code elsewhere,

then add support for it here.

/* === Luxury === */

/* Should (and can) we celebrate? */

* this is ignored. Maybe we need ruleset AI hints. */

/* TODO: Allow celebrate individual cities? No modpacks use this yet. */

if (get_player_bonus(pplayer, EFT_RAPTURE_GROW) > 0

want += 25 * game.info.turn;

}

plr_data->tech_want[adv->goal.govt.req] += want;

"dai_manage_government() + %d for %s",

want,

government_rule_name(adv->goal.govt.gov));

dai_manage_cities(ait, pplayer);

TIMING_LOG(AIT_CITIES, TIMER_STOP);

TIMING_LOG(AIT_TECH, TIMER_START);

TIMING_LOG(AIT_TECH, TIMER_STOP);

dai_manage_spaceship(pplayer);

We don't need a hunter in this city if we already have one. Return

existing hunter if any.

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

struct city *pcity)

{

unit_list_iterate(pcity->units_supported, punit) {

}

/* FIXME: We need to store some data that can tell us if

* In this case, want nuclear much more! */

desire = (ut->hp

* MIN(ut->attack_strength, 30) /* nuke fix */

}

UNIT_LOG(LOGLEVEL_HUNT, punit, "hunting %s %s[%d](%d,%d) "

nation_rule_name(nation_of_unit(target)),

target->id,

TILE_XY(target_tile),

stackthreat,

/* utility */

#include "log.h"

#include "support.h"

part of the AI code. */

#define LOGLEVEL_TECH LOG_DEBUG

This algorithm is very strange. But I created it by nesting up

Syela's convoluted if ... else logic, and it seems to work. -- Per

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

int defense)

{

if (*value == 0 || danger <= 0) {

}

/* Not bothering to s/!vuln/!pdef/ here for the time being. -- Syela

* something for them to kill. */

if (vuln == 0

&& (utype_class(punittype)->adv.land_move == MOVE_NONE

/* Benefit from fighting the target */

adv_want benefit;

/* Defender of the target city/tile */

const struct unit_type *def_type;

struct player *def_owner;

int def_vet; /* Is the defender veteran? */

process_attacker_want(ait, pcity, benefit, def_type, def_owner,

def_vet, ptile,

best_choice, NULL, NULL, NULL);

/* Attract a boat to our city or retain the one that's already here */

fc_assert_ret_val(unit_class_get(myunit)->adv.sea_move != MOVE_FULL, choice);

best_choice->need_boat = TRUE;

Before building a military unit, AI builds a barracks/port/airport

NB: It is assumed this function isn't called in an emergency

situation, when we need a defender _now_.

TODO: something more sophisticated, like estimating future demand

for military units, considering Sun Tzu instead.

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

struct adv_choice *choice)

{

Impr_type_id id;

bool allow_gold_upkeep;

urgency = assess_danger(ait, nmap, pcity, ul_cb);

* of small units -- Syela */

/* It has to be AFTER assess_danger() thanks to wallvalue. */

dai_choose_diplomat_defensive(ait, pplayer, pcity, choice, our_def);

}

} /* Ok, don't need to defend */

|| pcity->feel[CITIZEN_UNHAPPY][FEELING_FINAL] > pcity->feel[CITIZEN_UNHAPPY][FEELING_EFFECT]

|| pcity->id == ai->wonder_city) {

* build them if our populace doesn't feel like it */

return choice;

}

if (!map_is_known(ptile, pplayer)) {

continue;

}

acity = tile_city(ptile);

if (acity && city_owner(acity) == unit_owner(punit)

&& unit_list_size(ptile->units) == 0) {

}

}

} square_iterate_end;

if (best_tile != NULL) {

acity = tile_city(best_tile);

"Choose to jump in order to protect allied city %s (%d %d). "

"Benefit: %d",

city_name_get(acity), TILE_XY(best_tile), best);

}

}

} square_iterate_end;

if (best_tile != NULL) {

acity = tile_city(best_tile);

"Choose to jump into enemy city %s (%d %d). Benefit: %d",

city_name_get(acity), TILE_XY(best_tile), best);

return best_tile;

NULL);

val += pterrain->defense_bonus / 10;

val -= punit->hp * 100;

if (val > best) {

best = val;

best_tile = ptile;

if (punit->moves_left == 0) {

return;

}

if (pcity && unit_list_size(unit_tile(punit)->units) == 1) {

UNIT_LOG(LOGLEVEL_PARATROOPER, punit, "Defending the city.");

return;

struct civ_map *nmap = &(wld.map);

profit += u_type->defense_strength

+ u_type->attack_strength;

square_iterate(nmap, ptile_city, range, ptile) {

/* utility */

#include "mem.h"

#include "log.h"

#include "timing.h"

/* common */

/* COMMENTS */

This code tries hard to do the right thing, including looking

into the future (wrt to government), and also doing this in a

modpack friendly manner. However, there are some pieces missing.

give more optimal city placements, since existing cities could

move their workers around to give a new city better placement.

Occasionally you will see cities being placed sub-optimally

/* Percentage bonus to city locations near an ocean. */

#define NAVAL_EMPHASIS 20

* This is % of defense % to increase want by. */

#define DEFENSE_EMPHASIS 20

+ (result->best_other.tdc != NULL

? result->best_other.tdc->sum : 0);

} else if (result->best_other.tdc != NULL) {

* is so darn good. */

result->total = result->best_other.tdc->sum;

} else {

/* FIXME: Maybe penalty for using an existing boat is too high?

* We shouldn't make the penalty for building a new boat too high though.

* good for the economy. (c) Bush family */

cr2 = settler_map_iterate(ait, &parameter, punit,

unit_build_shield_cost_base(ferry));

if (result && result->result > best_impr) {

UNIT_LOG(LOG_DEBUG, punit, "city want " ADV_WANT_PRINTF, result->result);

if (tile_city(result->tile)) {

city_name_get(tile_city(result->tile)),

TILE_XY(result->tile));

} else {

TILE_XY(result->tile));

if (punit->server.debug) {

print_cityresult(pplayer, result);

struct ai_tech_choice {

Tech_type_id choice; /* The id of the most needed tech */

adv_want want; /* Want of the most needed tech */

* or is our current goal */

};

4. A tech isn't a requirement of itself.

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

static void dai_select_tech(struct ai_type *ait,

struct ai_tech_choice *choice,

struct ai_tech_choice *goal)

{

&& (penalty + research->bulbs_researched

<= research_total_bulbs_required(research, research->researching,

FALSE))) {

research_advance_rule_name(research, research->researching),

penalty);

choose_tech(research, choice.choice);